Ready to supercharge your AI agents?

Install any skill in seconds. Free to start, no credit card required.

Get Started Free →

Deep Research Skill · valtterimelkko | DecimalAI

Researchby valtterimelkko

Deep Research Skill

COMPREHENSIVE top-tier research for topics where breadth, source quality, and auditable methodology matter.

SkillScore

SkillScore68/100

Test results 68

Safety

3/3 safety checks passed

Code scan
Intent
Content

What it changes

45%68%of test cases passed +23 pts

Without skill10 of 22

With skill15 of 22

8 fixed7 passed either way4 still failing3 broke

Measured on gemini-3.6-flash8/4/2026v117 comparable

Track record

Agent runs: 0; All time

See one task, with and without the skill

One test taskHow many candidate sources should each preliminary discovery scout subagent aim to identify and briefly summarize when exploring a research dimension for a clean energy market study?

Without the skillMissed

With the skillPassed

Same model, same task. Answers are capped and redacted.

Use this skill

Your agent runs on

Adds every file the skill has, pinned so you can update it. No account needed.

pip install "decimalai>=0.15"
decimalai skills add valtterimelkko-deep-research
claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

The same install from Python, for a notebook or a setup script.

Install

pip install "decimalai>=0.15"

Add the skill

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

print("Added. Start Claude Code with the command below.")

Start Claude Code with it

claude --plugin-dir "$(git rev-parse --show-toplevel 2>/dev/null || pwd)/.agents"

Type these in a Claude Code session. No account or API key. It writes the skill and any files it bundles, and asks first when its safety rating isn't Passed.

Add the DecimalAI plugin, once

/plugin marketplace add decimal-labs/decimalai-claude-plugins
/plugin install decimalai@decimalai

Install this skill

/decimalai:install valtterimelkko-deep-research

The plugin needs python3 and curl on your machine.

No Python or account. Claude Code picks it up in its next session.

Save it into your project

curl -fsSL --create-dirs -o .claude/skills/valtterimelkko-deep-research/SKILL.md https://app.decimal.ai/s/valtterimelkko-deep-research/SKILL.md

Copy SKILL.md

Save it in your project, as

.claude/skills/valtterimelkko-deep-research/SKILL.md

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Claude Code docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

The same install from Python, for a notebook or a setup script. agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[claude-agent-sdk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from claude_agent_sdk import ClaudeAgentOptions
from decimalai.claude_agent_sdk import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

async def main():
    question = "Hello!"
    async with support.run(question) as run:  # one user message, one run
        async for message in run.query(options=ClaudeAgentOptions(max_turns=6)):
            print(message)

# In a notebook or async code: await main()
asyncio.run(main())

Prefer its own loader? ClaudeAgentOptions(plugins=[skills_plugin()], skills="all") reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from claude_agent_sdk import ClaudeAgentOptions, query

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
options = ClaudeAgentOptions(system_prompt=f"You are a helpful agent.\n\n{skill}", max_turns=6)

async def main():
    async for message in query(prompt="Hello!", options=options):
        print(message)

# In a notebook or async code: await main()
asyncio.run(main())

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Claude Agent SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai-agents]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

Install

pip install "decimalai[openai-agents]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from agents import Agent, Runner
from decimalai.openai_agents import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    name=support.name,
    instructions=support.instructions,  # your prompt, then the skill list
    tools=[*support.tools],             # your tools, then load_skill
)
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

Using SandboxAgent? capabilities=[Shell(), decimalai.openai_agents.sandbox_skills()] points its own loader at the same folder.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from agents import Agent, Runner

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = Agent(name="support", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await Runner.run(agent, "Hello!")
result = Runner.run_sync(agent, "Hello!")

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

OpenAI Agents docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[openai]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

Install

pip install "decimalai[openai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import json

from openai import OpenAI
from decimalai.openai import agent_config

client = OpenAI()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your tools, as Chat Completions takes them, and what answers each.
TOOLS = [{"type": "function", "function": {
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters": {"type": "object", "properties": {"order_id": {"type": "string"}},
                   "required": ["order_id"]},
}}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    # run.system is your prompt, then the skill list.
    messages = [{"role": "system", "content": run.system}, run.message]
    while True:
        reply = client.chat.completions.create(
            model="gpt-5.4-mini",
            messages=messages,
            tools=[*TOOLS, *run.tools],  # your tools, then load_skill
        ).choices[0].message
        messages.append(reply)
        if not reply.tool_calls:
            break
        for call in reply.tool_calls:
            # load_skill is answered by the run; your own tools by FUNCTIONS.
            function = FUNCTIONS.get(call.function.name)
            messages.append(run.tool_result(call) or {
                "role": "tool", "tool_call_id": call.id,
                "content": function(**json.loads(call.function.arguments)) if function
                else f"There is no tool named {call.function.name!r}.",
            })
print(reply.content)

# The Responses API takes run.response_tools instead of run.tools.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from openai import OpenAI

client = OpenAI()
skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
reply = client.chat.completions.create(
    model="gpt-5.4-mini",
    messages=[
        {"role": "system", "content": f"You are a helpful agent.\n\n{skill}"},
        {"role": "user", "content": "Hello!"},
    ],
).choices[0].message

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

OpenAI SDK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[anthropic]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

Install

pip install "decimalai[anthropic]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import anthropic
from decimalai.anthropic import agent_config

client = anthropic.Anthropic()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

question = "Hello!"
with support.run(question) as run:  # one user message, one run
    answer = client.beta.messages.tool_runner(
        model="claude-haiku-5-5",
        max_tokens=4096,
        system=run.system,     # your prompt, then the skill list
        tools=[*run.tools],    # your tools, then load_skill
        messages=[{"role": "user", "content": question}],
    ).until_done()

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
import anthropic

client = anthropic.Anthropic()
skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
reply = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,
    system=f"You are a helpful agent.\n\n{skill}",
    messages=[{"role": "user", "content": "Hello!"}],
)

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Anthropic docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[google-genai]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

Install

pip install "decimalai[google-genai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from google import genai
from google.genai import types
from decimalai.google_genai import agent_config

client = genai.Client()
# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")


def lookup_order(order_id: str) -> str:
    return f"Order {order_id} shipped yesterday."


# Your functions, as declarations for the model, and what answers each.
TOOLS = [{"function_declarations": [{
    "name": "lookup_order",
    "description": "Look up the status of an order.",
    "parameters_json_schema": {"type": "object", "properties": {"order_id": {"type": "string"}},
                               "required": ["order_id"]},
}]}]
FUNCTIONS = {"lookup_order": lookup_order}

question = "Where is order A1001?"
with support.run(question) as run:  # one user message, one run
    config = types.GenerateContentConfig(
        system_instruction=run.system,     # your prompt, then the skill list
        tools=[*TOOLS, *run.tool_params],  # your functions, then load_skill
    )
    contents = [{"role": "user", "parts": [{"text": run.message}]}]
    while True:
        response = client.models.generate_content(
            model="gemini-3.5-flash", contents=contents, config=config,
        )
        if not response.function_calls:
            break
        contents.append(response.candidates[0].content)
        parts = []
        for call in response.function_calls:
            # load_skill is answered by the run; your own functions by FUNCTIONS.
            # A loop of your own rather than automatic function calling, which
            # raises KeyError when the model asks for a function you did not pass.
            function = FUNCTIONS.get(call.name)
            parts.append(run.tool_result(call) or {"function_response": {
                "name": call.name, "id": call.id,
                "response": {"result": function(**(call.args or {})) if function
                             else f"There is no function named {call.name!r}."},
            }})
        contents.append({"role": "user", "parts": parts})
print(response.text)

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
response = client.models.generate_content(
    model="gemini-3.5-flash",
    contents="Hello!",
    config=types.GenerateContentConfig(system_instruction=f"You are a helpful agent.\n\n{skill}"),
)

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Gemini API docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[langchain]" langchain-openai
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

Install

pip install "decimalai[langchain]" langchain-openai

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from langchain.agents import create_agent
from decimalai.langchain import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = create_agent(
    "openai:gpt-5.4-mini",
    tools=[],                         # your tools; the middleware adds load_skill
    middleware=[support.middleware],  # your prompt, the skill list and load_skill
)
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from langchain.agents import create_agent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = create_agent("openai:gpt-5.4-mini", tools=[], system_prompt=f"You are a helpful agent.\n\n{skill}")
result = agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

LangChain docs

CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

The same install from Python, for a notebook or a setup script. CrewAI's own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" "crewai>=1.15.27"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.crewai
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                               # your own CrewAI LLM
    skills=decimalai.crewai.skills(),      # the installed folder
    tools=decimalai.crewai.skill_tools(),  # reads a skill's files, runs its scripts
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

No DecimalAI package. CrewAI's own loader reads the folder, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from crewai import Agent, Crew, Task

agent = Agent(
    role="Support", goal="Help the customer", backstory="A support agent.",
    llm=llm,                         # your own CrewAI LLM
    skills=[Path(".agents/skills")],
)
task = Task(description="Hello!", expected_output="an answer", agent=agent)
Crew(agents=[agent], tasks=[task]).kickoff()

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

CrewAI docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[adk]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

Install

pip install "decimalai[adk]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.adk import DecimalAIPlugin, agent_config
from google.adk.agents import LlmAgent
from google.adk.apps import App

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = LlmAgent(
    name="support",          # ADK needs a Python identifier
    model="gemini-3.5-flash",
    instruction=support.instruction,  # your prompt, then the skill list
    tools=[*support.tools],           # your tools, then load_skill
)
# DecimalAIPlugin makes each invocation of runners built from this App one trace.
app = App(name="support", root_agent=agent, plugins=[DecimalAIPlugin()])

Prefer ADK's own loader? SkillToolset(skills=decimalai.adk.skills(), ...) reads the same folder. Use one or the other: a skill delivered both ways reaches the prompt twice.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from google.adk.agents import LlmAgent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = LlmAgent(
    name="support",
    model="gemini-3.5-flash",
    instruction=lambda context: f"You are a helpful agent.\n\n{skill}",
)

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Google ADK docs

agent_config() hands your agent the skill. With no DecimalAI key it reads your project's files and sends nothing. Needs SDK 0.27 or newer.

Install

pip install "decimalai[pydantic-ai]"
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

Install

pip install "decimalai[pydantic-ai]"

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from pydantic_ai import Agent
from decimalai.pydantic_ai import agent_config

# With no DECIMAL_API_KEY this reads the skills your project lists, from disk.
support = agent_config("support", fallback="You are a helpful agent.")

agent = Agent(
    "openai:gpt-4o-mini",
    name=support.name,
    tools=[],                 # your tools; the capability adds load_skill
    capabilities=[support],   # your prompt, the skill list and load_skill
)
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

On the Pydantic AI harness, decimalai.pydantic_ai_harness.skills(project) uses its own loader instead.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from pydantic_ai import Agent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = Agent("openai:gpt-4o-mini", instructions=f"You are a helpful agent.\n\n{skill}")
# In a notebook or async code: result = await agent.run("Hello!")
result = agent.run_sync("Hello!")

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Pydantic AI docs

Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

The same install from Python, for a notebook or a setup script. Deep Agents' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" deepagents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import decimalai.deepagents
from deepagents import create_deep_agent

agent = create_deep_agent(model=model, **decimalai.deepagents.skills())
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

The default backend reads files but has no shell. To run a skill's scripts, pass skills(backend=LocalShellBackend(...)).

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from deepagents import create_deep_agent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = create_deep_agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent.invoke({"messages": [{"role": "user", "content": "Hello!"}]})

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Deep Agents docs

Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework
decimalai skills add valtterimelkko-deep-research

Add it to your agent

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

The same install from Python, for a notebook or a setup script. Its own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" agent-framework

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

import asyncio

from agent_framework import Agent
from decimalai.agent_framework import skills

agent = Agent(client=client, instructions="You are a helpful agent.", context_providers=[skills()])
asyncio.run(agent.run("Hello!"))

It caches skills by default, so restart the process after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

import asyncio
from pathlib import Path
from agent_framework import Agent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = Agent(client=client, instructions=f"You are a helpful agent.\n\n{skill}")
asyncio.run(agent.run("Hello!"))

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Microsoft Agent Framework docs

Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents
decimalai skills add valtterimelkko-deep-research

Add it to your agent

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

The same install from Python, for a notebook or a setup script. Strands' own skill loader reads the installed folder. No DecimalAI account needed.

Install

pip install "decimalai>=0.16" strands-agents

Add it to your agent

from decimalai import skillpkg

# Writes .agents/skills and .decimal/skills.toml. Safe to run twice.
result = skillpkg.add("valtterimelkko-deep-research")
if result.exit_code:
    raise SystemExit(result.problems)

from decimalai.strands import skills
from strands import Agent
from strands.vended_tools import file_editor, shell

agent = Agent(
    model=model,                # always pass one: the default is Amazon Bedrock
    system_prompt="You are a helpful agent.",
    tools=[file_editor, shell],
    plugins=[skills()],
)
agent("Hello!")

Strands loads an agent's skills once, so build the agent again after decimalai skills update.

No DecimalAI package. The whole skill goes in every prompt, and nothing pins or updates it.

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

Give it to your agent

from pathlib import Path
from strands import Agent

skill = Path(".agents/skills/valtterimelkko-deep-research/SKILL.md").read_text()
agent = Agent(model=model, system_prompt=f"You are a helpful agent.\n\n{skill}")
agent("Hello!")

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Strands docs

Adds every file the skill has, pinned so you can update it. Cursor, Copilot, Cline and Warp read this folder by themselves.

pip install "decimalai>=0.15"
decimalai skills add valtterimelkko-deep-research

No Python or account. Cursor, Copilot, Cline and Warp read this folder by themselves.

Save it into your project

curl -fsSL --create-dirs -o .agents/skills/valtterimelkko-deep-research/SKILL.md https://app.decimal.ai/s/valtterimelkko-deep-research/SKILL.md

Copy SKILL.md

Save it in your project, as

.agents/skills/valtterimelkko-deep-research/SKILL.md

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Cursor and other editors docs

Fetch the file and give its text to your model as instructions. No account or package needed.

Get the file

curl -fsSL https://app.decimal.ai/s/valtterimelkko-deep-research/SKILL.md

Read the summary as JSON

curl -fsSL https://app.decimal.ai/s/valtterimelkko-deep-research.json

This gets SKILL.md only. The skill's 3 other files are not included.

Other ways to add it

Other setups docs

You don't need a DecimalAI account.

Version: v1, tested 8/4/2026
Source: valtterimelkko/agent-workflow-skills ↗
License: MIT

Manage it in DecimalAI

Saved prompts and skills, pinned versions, and traces of this skill in your runs. DecimalAI does not run your agent.

Claude Code reads files from your project, so DecimalAI config does not apply there.

On Claude Agent SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI Agents: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On OpenAI SDK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Anthropic: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Gemini API: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On LangChain: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On CrewAI: set DECIMAL_API_KEY and add decimalai.init(crewai=True) to record runs and skill use. The skill version stays in your repo.

On Google ADK: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Pydantic AI: save the skill to an agent here, set DECIMAL_API_KEY, and the same code uses it with no command to run. Changes you save reach the next run with no redeploy.

On Deep Agents: set DECIMAL_API_KEY and add decimalai.init(langchain=True) to record runs and skill use. The skill version stays in your repo.

On Microsoft Agent Framework: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

On Strands: set DECIMAL_API_KEY and add decimalai.init(otel=True, agent_name="support") to record runs and skill use. The skill version stays in your repo.

Editors read files from your project, so DecimalAI config does not apply there.

Anywhere else: record a use with decimalai.log_skill_activation() inside a trace.

Use this skill

SKILL.md

Deep Research Skill

A comprehensive workflow for conducting broad, source-rich, auditable research using iterative waves of subagents.

Time: ~6–10 minutes
Sources: 40–100+
Best for: academic rigor, due diligence, comparative analysis, high-stakes synthesis

The strength of this skill is breadth with control: it covers many dimensions without letting any single subagent become the whole research system.

Core Operating Model

The main agent is the research conductor.

Subagents are used for:

scouting source landscapes
analysing curated source batches
resolving contradictions
checking synthesis quality

The main agent is responsible for:

defining dimensions
maintaining the research manifest
maintaining the blocked-source registry
curating which sources get promoted to deeper analysis
deciding whether the research is sufficient
consulting the user on fallback options when high-value blocked sources remain

Core Principles

Breadth is preserved at the workflow level, not overloaded into each subagent.
Subagents must return useful findings in their response text first. File writes are secondary.
Subagents must not silently switch to non-default fallback workflows such as browser automation. If blocked, they must report and move on.
Forward progress is preferred unless a critical gap is identified.
Blocked-source review happens at the end of the standard workflow, before considering fallback workflows.
Fallback workflows require explicit user consultation.

Research Tier Positioning

Use this skill as the heaviest general-purpose research tier:

Native web_search / web_fetch — one-off current facts, a single page, or a few URLs
gpt-research — quick / medium-depth synthesis across roughly 10-20 sources
deep-research (this skill) — 40+ sources, explicit methodology, high-stakes synthesis
Specialised recency skills such as last30days — when the main need is recent discourse across social/web platforms rather than broad general-web synthesis

If the user simply says “research this”, reserve this skill for tasks where the consequence of missing a dimension is materially important.

When to Use This Skill vs Fast Research

Use deep-research when:

the user needs 40+ sources
the topic has multiple dimensions that must all be covered
source quality and traceability matter
the work is for publication, due diligence, or high-stakes decision-making
the user explicitly wants a transparent, auditable methodology

Use fast research instead when:

the user wants a quick overview
10–20 sources are enough
the topic is exploratory rather than high-stakes
speed matters more than exhaustive coverage

The Workflow

Phase 0 — Preflight and Planning

Goal

Validate that the normal research path is viable, then define the scope.

Main agent actions

Analyse the user’s actual decision or question.
Break the topic into 4–8 research dimensions.
Identify the key questions, likely source classes, and any obvious edge cases / blind spots.
Draft 5–10 initial search queries or search angles spanning the most important dimensions.
Run a small preflight check using the standard acquisition path to see whether search/fetch is broadly working.
Create a Research Manifest in your own notes / working state.

Research Manifest (minimum fields)

Track at least:

dimension name
scout assigned
scout result status
analyst assigned
analyst result status
blocked-source count for the dimension
whether the dimension is adequately covered

Do not turn the manifest into bureaucratic overhead. It is a lightweight control table.

Phase 1 — Scout Wave (broad, lightweight)

Goal

Cast a wide net cheaply and safely.

Rule

Scouts are discovery agents, not full analysts. They should identify promising sources and report them compactly.

Spawn

Launch 3–6 parallel scout agents, each covering a distinct dimension or source class.

Examples:

official / regulatory
academic / technical
industry / practitioner
news / current developments
community / user sentiment
regional / local angle

Scout task shape

Each scout should:

identify 6–10 promising sources
give a 1-line relevance note for each
estimate credibility at a high level
capture publication date / recency when visible
suggest follow-up queries if coverage looks thin or skewed
report blocked URLs if encountered
avoid deep extraction
avoid contradiction resolution unless extremely obvious

Mandatory scout instructions

Use wording along these lines:

Use your default acquisition path only.
Do NOT invoke browser automation, playwright, or other non-default fallback workflows.
Browser automation is NOT a bot-protection bypass strategy in this workflow.
If a source is blocked by Cloudflare, anti-bot protection, rate limits, login walls, paywalls, or fetch failures, record the exact URL, barrier type, source class, and failure reason, then continue.
Your primary deliverable is this response text. File writes are optional secondary artifacts.
At the end, explicitly report:
- created_files: [...]
- modified_files: [...]
- blocked_urls: [{url, barrier_type, reason, source_class}]
- unblocked_sources: [{title, url, publication_date_or_recency, relevance_note, credibility_estimate}]
- follow_up_queries: [...]
If no files were created, say so explicitly.

Preferred scout output format

## Scout Summary
Dimension: [name]
Status: adequate | thin | blocked-heavy

## Candidate Sources
1. [Title] — URL
   - Relevance: ...
   - Credibility: High/Medium/Low
   - Date/Recency: ...

## Follow-up Queries
- ...

## Blocked URLs
- URL — barrier type — reason

## Files
- created_files: [...]
- modified_files: [...]

Main agent after scouts

Read all scout outputs.
Deduplicate sources.
Update the manifest.
Build a Blocked Source Registry.
Promote the strongest sources into curated analyst batches.

Phase 2 — Analyst Wave (narrower, heavier)

Goal

Do the deep reading and extraction on curated source batches.

Rule

Analysts receive curated URLs. They should not wander broadly. However, if a curated batch is missing a necessary primary source, a key dissenting source, or another narrowly defined source needed to evaluate a material claim, the analyst may add up to 1–2 tightly scoped supplementary sources and must label them clearly as supplementary recovery sources.

Batch size

Give each analyst ~4–7 URLs or a similarly narrow, clearly bounded source batch.

Analyst responsibilities

Each analyst should:

extract key findings
identify areas of consensus and disagreement
note methodological caveats
flag weak or suspicious sources
apply a compact source-verification checklist to material sources: author/organisation, date/recency, source type, primary-vs-secondary, methodology present/absent when relevant, obvious bias/conflict flags, and whether the claim was cross-checked
report blocked URLs if any curated sources fail
propose follow-up queries if a material gap remains
return structured markdown in response text first

Mandatory analyst instructions

Use wording along these lines:

Use your default acquisition path only.
Do NOT invoke browser automation, playwright, or other non-default fallback workflows.
Browser automation is NOT a bot-protection bypass strategy in this workflow.
If any curated URL is blocked or fails to load, report it exactly and continue with the remaining sources.
Do not broaden scope unless explicitly instructed, except for at most 1–2 tightly scoped supplementary recovery sources when needed for a material claim.
Your primary deliverable is this response text. File writes are optional secondary artifacts.
At the end, explicitly report:
- created_files: [...]
- modified_files: [...]
- blocked_urls: [{url, barrier_type, reason, source_class, estimated_importance}]
- supplementary_sources: [{title, url, why_needed}]
- follow_up_queries: [...]

Preferred analyst output format

## Analyst Findings
Batch: [name]
Coverage: strong | moderate | weak

## Key Findings
- ...

## Important Claims and Support
- Claim: ...
  - Sources: ...
  - Cross-check status: ...

## Source Verification Notes
- Source: ...
  - Author/Organisation: ...
  - Date/Recency: ...
  - Type: primary / secondary / commentary
  - Methodology present?: yes/no/not applicable
  - Bias/conflict notes: ...

## Caveats / Contradictions
- ...

## Supplementary Recovery Sources
- ...

## Follow-up Queries
- ...

## Blocked URLs
- URL — barrier type — reason — estimated importance

## Files
- created_files: [...]
- modified_files: [...]

Phase 3 — Synthesis and Gap Resolution

Goal

Turn analysed batches into a coherent answer.

Main agent actions

Group findings into themes.
Identify what is already adequately covered.
Identify only the most important remaining gaps.
If substantive disagreement appears on a material claim, spawn a targeted contradiction-resolution deep dive before treating that claim as high-confidence.
Spawn other targeted deep-dive agents only where necessary.

Use additional deep-dive agents for:

contradiction resolution
missing official / survey evidence
missing primary / seminal / uniquely probative evidence
regional gaps
terminology or methodology clarification

Do not spawn another broad scout wave unless:

a major dimension is still under-covered, or
the user explicitly asks for more breadth

Phase 4 — QA and Sufficiency Check

Goal

Decide whether the research is strong enough to stand on its own.

Main agent checks

Are all key dimensions covered?
Are the strongest claims supported by credible sources?
Are the blocked sources material to the conclusions?
Is the evidence set broad enough to answer the original prompt faithfully?

QA micro-checklist

Before finalising, explicitly check:

Are any material claims unsupported, weakly supported, or supported only by low-credibility sources?
Do the citations actually support the claims they are attached to?
Were substantive contradictions either resolved through targeted follow-up or clearly carried forward as uncertainty/contestation?
Are any high-confidence conclusions relying on evidence that should instead be framed as tentative?

Prefer forward progress

Do not keep digging forever. Move toward report assembly unless a critical gap remains.

Phase 5 — Blocked Source Review (end of normal workflow)

This happens after the standard workflow is complete, not mid-workflow.

Goal

Assess whether blocked/failed sources materially weaken the result.

Maintain a Blocked Source Registry

Track, at minimum:

URL
source class (official / major survey / academic / technical doc / practitioner / media / community / aggregator / other)
dimension
barrier type / failure reason
evidentiary role (official, major survey, primary study, seminal paper, benchmark doc, canonical technical documentation, practitioner evidence, commentary, other)
whether an equivalent unblocked source was found
replaceability (high / medium / low)
estimated importance

Importance rubric

Class blocked sources as:

Critical — sources whose absence materially weakens the conclusion because they are official, major-survey, primary, seminal, uniquely probative, or otherwise not adequately replaceable
Important — strong sources that materially improve confidence or breadth, but are replaceable with some loss of fidelity
Peripheral — useful but non-essential

Default threshold for stronger fallback recommendations

Recommend stronger fallback options primarily when blocked sources include:

official sources, and/or
major survey sources that are not adequately replaced by unblocked alternatives

Also consider stronger fallback recommendations when blocked sources are:

primary or seminal sources central to a key claim
canonical technical documentation / benchmark pages needed to verify an important claim
uniquely relevant regional or practitioner evidence with no good unblocked substitute

End-of-workflow blocked-source analysis

Report to the user:

number of blocked URLs
blocked-source count by source class
which dimensions were affected
whether the blocked sources are critical, important, or peripheral
whether the current research is still sufficient without them
which blocked sources are likely replaced well vs poorly replaced

Do not dump a giant raw URL list into the final user-facing summary unless asked.

Fallback Workflows (only after standard workflow ends)

Fallback workflows are considered only at the end of the normal deep-research workflow.

Fallback A — Camofox targeted recovery (free, local, preferred first)

Recommend camofox first when blocked sources remain important and the problem looks like a browser-style anti-bot / JS-rendering barrier, especially when:

a small number of high-value URLs are blocked
the blocked pages are public but hidden behind Cloudflare, challenge pages, blank JS rendering, or similar anti-bot friction
recovering those pages would materially improve confidence in one or more important claims

Camofox rules in this workflow

Use it only for targeted recovery of specific blocked URLs, not as a silent background path for every scout or analyst
The main agent should decide which blocked URLs are worth recovery after blocked-source analysis
Recover the smallest useful set first: official pages, major surveys, canonical documentation, or other poorly replaceable sources
If Camofox fails, keep the evidence gap visible and only then consider higher-friction fallbacks

Fallback B — NotebookLM (user-participatory broad recovery)

Recommend NotebookLM when blocked sources remain important and the recovery problem is broad rather than a short list of individual pages, especially when:

the blocked material spans a broad topic
several blocked URLs affect the same dimension or subtopic
the user is comfortable doing a login step and wants a lower-barrier recovery path

NotebookLM is usually the next fallback when the blocked problem is broad or when multiple important blocked URLs can be recovered through a user-participatory notebook workflow.

Two NotebookLM patterns

1. Broad-topic recovery

Use NotebookLM to perform deep research on:

the same topic, or
a narrower blocked subtopic

This is appropriate when blocked coverage affects a broad slice of the research.

2. Narrow-source recovery

If only a modest number of blocked URLs matter, recommend adding those URLs directly as notebook sources, then querying the notebook.

Important NotebookLM notes

Requires user login / session participation
Treat NotebookLM as a recommended fallback, not an autonomous silent fallback
It is best used as a recovery and synthesis aid, not as a perfect substitute for direct fetch
For technical details and commands, read the notebooklm skill

Fallback C — Residential Proxy (higher barrier; explicit permission only)

Recommend residential proxy only when:

blocked sources are high-value, especially official or major-survey sources
or the blocked sources are critical primary / seminal / uniquely probative sources that are poorly replaceable
the gaps materially weaken the research
the user explicitly authorizes the proxy path

Residential proxy policy

Never use it without explicit user permission
Estimate data volume bands, not exact cost:
- small batch
- medium batch
- large batch
Explain why the blocked sources are important enough to justify it
For technical details, read the residential-proxy skill

Retry Policy

Default bias

Prefer balanced forward progress:

move on unless a critical gap is identified
do not let one blocked source stall the whole workflow

Recommended retry behavior

Blocked / anti-bot / rate-limit / login-wall / paywall failure: do not retry with browser automation, Playwright, or other non-default acquisition tools; log the barrier type and continue
Formatting / malformed output failure: 1 retry with simpler output requirements
Thin scout results: 1 narrower retry if the dimension still matters
Repeated failure: mark the dimension as thin or blocked-heavy and proceed

Final Report Requirements

The final report should include all of the following:

Blocked-source statistics
Blocked-source importance analysis
Confidence statement
Fallback recommendations (if relevant)
Methodology limitations stated up front, not buried only in an appendix
References section for sources actually used in the report
Source inventory appendix or machine-readable source list covering the consulted evidence base

Major claims in the final report should be traceable to cited sources. Do not rely on uncited synthesis for material conclusions.

Recommended methodology summary table

Include a concise methodology / limitations table in the final report, for example:

Item	Status
Dimensions covered	X / Y
Sources used	N
Blocked URLs	N
Critical blocked sources	N
Research confidence	High / Medium / Low
Fallback recommended	None / Camofox / NotebookLM / Residential proxy

Common Pitfalls to Avoid

Overloading scouts with deep extraction and formatting duties
Losing findings because file writes failed
Silent browser/playwright fallback that creates hidden artifacts without helping
Treating all blocked URLs as equally important
Raw-appending research files into the final report instead of synthesizing them cleanly
Letting blocked-source analysis derail the standard workflow too early
Burying major methodology limitations in appendices only
Letting curated analysts become broad scouts again instead of using only narrow recovery where truly needed
Dropping source traceability because the prose sounds confident

Summary

This skill wins by keeping the overall workflow broad while making each subagent more focused and auditable.

Use broad scouting first, promote the best sources into deeper analysis, keep a clear blocked-source registry, and only consider fallback workflows after the normal research pass is complete.

Default stance: keep moving, surface blocked-source significance clearly, try targeted camofox recovery before paid proxy escalation, and involve the user before using higher-friction fallback paths.

When it activates

Automatically, when a task matches. Use when the user needs 40+ sources, publication-grade synthesis, due diligence, policy or market analysis, or any high-stakes research where missing key dimensions would materially weaken the answer. This skill is especially valuable when the prompt has multiple dimensions that must all be covered faithfully. NOT for quick or medium-depth briefs; prefer gpt-research or native web_search/w

About this skill

Automatic

Research pack

SkillSafety

✓ 3 of 3 passed

Code scan15 of 15 checks clean

0 critical · 0 warning · 0 info — scanner v4 — 8/1/2026

View 15 scanner checks

live_secretremote_code_executionreverse_shelldata_exfiltrationssrf_metadataagent_snoopinganti_refusaldestructive_commandsobfuscated_unicodeunicode_homoglyphopaque_blobsuspicious_urltool_overreachtrigger_abuseprompt_injection_phrasing

IntentSafe

LLM judge · does the skill do what it claims

ContentClean

LLM judge · policy & harmful-content review

Source

Imported

valtterimelkko / agent-workflow-skills

skills/deep-research/SKILL.md

View on GitHub ↗

License MITImported 8/1/2026Version v1Bundled 3 files

Illustrative Want to see what valtterimelkko/deep-research would put in front of your model? Preview the rendered body and check its trigger phrases — no LLM call, no signup.

Other skills for the same job

Published skills whose descriptions closely match this one, with their headline benchmark lift.

Related skills

Skills that do similar work, with their headline benchmark lift.

From the same source and nearby in the catalogue.

Ready to supercharge your AI agents?

SkillScore

Safety

What it changes

Track record

Use this skill

Deep Research Skill

Core Operating Model

Core Principles

Research Tier Positioning

When to Use This Skill vs Fast Research

Use deep-research when:

Use fast research instead when:

The Workflow

Phase 0 — Preflight and Planning

Goal

Main agent actions

Research Manifest (minimum fields)

Phase 1 — Scout Wave (broad, lightweight)

Goal

Rule

Spawn

Scout task shape

Mandatory scout instructions

Preferred scout output format

Main agent after scouts

Phase 2 — Analyst Wave (narrower, heavier)

Goal

Rule

Batch size

Analyst responsibilities

Mandatory analyst instructions

Preferred analyst output format

Phase 3 — Synthesis and Gap Resolution

Goal

Main agent actions

Use additional deep-dive agents for:

Do not spawn another broad scout wave unless:

Phase 4 — QA and Sufficiency Check

Goal

Main agent checks

QA micro-checklist

Prefer forward progress

Phase 5 — Blocked Source Review (end of normal workflow)

Goal

Maintain a Blocked Source Registry

Importance rubric

Default threshold for stronger fallback recommendations

End-of-workflow blocked-source analysis

Fallback Workflows (only after standard workflow ends)

Fallback A — Camofox targeted recovery (free, local, preferred first)

Camofox rules in this workflow

Fallback B — NotebookLM (user-participatory broad recovery)

Two NotebookLM patterns

1. Broad-topic recovery

2. Narrow-source recovery

Important NotebookLM notes

Fallback C — Residential Proxy (higher barrier; explicit permission only)

Residential proxy policy

Retry Policy

Default bias

Recommended retry behavior

Final Report Requirements

Recommended methodology summary table

Common Pitfalls to Avoid

Summary

When it activates

SkillSafety

Source

Other skills for the same job

Related skills

More in the registry