Deep Research Skill

Turn a question into a multi-step research run with sources, cross-checks and a cited report.

Made by
Runcell team
Category
Research
Format
SKILL.md
Works with
Claude Code, Codex, Cursor, Runcell (Jupyter)

Showcase

Illustrative output. The real run happens in your notebook.

Research plan
Q: How does cold weather affect EV battery range?
  1. Capacity loss vs. temperature (lab data)
  2. Real-world range reports by climate
  3. Preconditioning: does it help, by how much?
Rounds: 3  ·  Sources so far: 0  ·  Ledger: open
The plan comes first: sub-questions, then rounds of search and reading.
DataFrame
FindingSourcesConfidence
Range drops 20-30% near -7 °C4High
Preconditioning recovers part of the loss2Medium
Effect differs by cell chemistry1Low
Every finding links to its sources and carries a confidence level.

Description

Deep research is more than a longer answer. This skill gives an agent a procedure: break the question into sub-questions, search and read in rounds, keep a source ledger, check claims against each other, and write up only what the evidence supports.

It is written for coding agents that can run tools: Claude Code, Codex, Cursor, and Runcell inside Jupyter. In a notebook the same run also keeps the data it pulled, so a chart or a table in the report links back to a cell you can execute again.

  • Decomposes a broad question into a research plan with explicit sub-questions
  • Runs search, read and extract loops and records every source with URL, date and quote
  • Flags contradictions between sources instead of averaging them away
  • Separates established findings from single-source claims
  • Produces a structured report: summary, findings, evidence table, open questions
  • Keeps intermediate data in notebook cells so the report is rerunnable
Editor's Recommendation

Recommended by

Runcell team

Why we built this skill

Most "research" from an agent is one search and a confident paragraph. We wanted the opposite: a run that keeps its receipts. The source ledger and the evidence table are the parts we use every week, and in a notebook the numbers it pulls stay in cells we can check.

What you get

  • A cited research report in Markdown
  • A source ledger with URL, access date and key quote
  • An evidence table linking each finding to its sources
  • A list of open questions and what would resolve them

Use it when

  • Literature scans before a project starts
  • Market or competitor landscapes
  • Fact-checking a claim before it goes into a paper or a deck
  • Any question where "I read three sources" is not good enough

FAQ

What is a deep research skill for Claude Code?

It is a SKILL.md file that tells Claude Code, or another agent, how to run a research task step by step: plan, search, read, record sources, cross-check, and write a report. Without it, an agent usually answers from a single pass. With it, the agent follows a repeatable procedure and shows its sources.

How is this different from a chat product's built-in deep research?

Built-in research modes run inside a chat product and return a document. A skill runs in your own coding agent, so you control the tools it uses, keep the raw sources and data it collected, and can rerun or extend the run. In Jupyter, the collected data stays in cells you can inspect.

Which agents can use it?

Any agent that follows the Agent Skills format: Claude Code, Codex, Cursor, and Runcell inside JupyterLab. The procedure is the same. The tools for search and fetching depend on what your agent has available.

Does it need web access?

Yes, for live research. The skill expects a search or fetch tool. If the agent only has local files, it runs the same procedure over that corpus and says so in the report.

Related Skills

View all

Information

Format
SKILL.md (Agent Skills)
Works with
Claude Code, Codex, Cursor, Runcell (Jupyter)
Runs in
A live Jupyter kernel in Runcell, or your terminal agent
Maintained by
Runcell team
Last updated
Sep 20, 2026
Price
Free

Run this skill in your notebook

Runcell is a Jupyter-native AI agent that executes every step in a live kernel. Results are cells you can inspect and rerun.

Try in Runcell