Notebook-native AI agent · powered by Claude
Claude Code edits your .ipynb from the terminal — as raw JSON, with no live kernel and no rendered output. Runcell is the Jupyter-native AI agent, powered by Claude, that runs every cell in a live kernel and shows the results as they happen.
macOS & Windows · runs in your existing JupyterLab, Notebook, or VS Code
> work on analysis.ipynb
● Read(analysis.ipynb)
⎿ {"cells":[{"cell_type":"code",
"execution_count":null,"outputs":[],
"source":["df.plot.bar()"]}]}
● Edit(analysis.ipynb)
⎿ patched cell source — as raw JSON
⚠ no kernel attached — can't run the cell
or see the chart it would produce
│ >
df.plot.bar()— output not rendered —
The problem
Claude Code is a great terminal agent — until your work lives in a notebook. A .ipynb file is JSON on disk, so from the terminal you are editing a blob of cell metadata and escaped source, not the notebook you actually see in JupyterLab. The part that makes a notebook useful — the rendered plots, the dataframe tables, the widgets — never shows up in a terminal.
So the loop breaks. You cannot watch a cell execute, you cannot see the figure it produced, and the common workaround is to bolt on a Jupyter MCP server to bridge Claude Code to a kernel. It works, sort of — but now you are maintaining plumbing instead of doing the analysis.
The difference
Runcell is an AI agent that lives inside your notebook, connected to a live Jupyter kernel — and it can be powered by Claude. It writes a cell, runs it in your real kernel, reads the actual output, and corrects itself before handing you a result. Every answer is a cell you can rerun — nothing hides in JSON.
Plot the default rate by credit band.
df.groupby('band')['default'].mean().plot.bar()● ran in 0.4s · read the chart · suggests trying monotonic constraints next
The real thing
Straight answer
Short answer: Claude Code can read and edit the .ipynb file, but it was not built to work inside a live notebook. From the terminal it operates on the notebook's JSON, so it cannot render the visual output that makes notebooks useful — charts, tables, and interactive widgets stay invisible, and you do not watch cells execute. Teams usually reach for a Jupyter MCP server to close the gap.
Runcell is built for exactly this. It installs into JupyterLab, classic Notebook, or VS Code and runs as a notebook-native agent on a live kernel, powered by Claude — so using Claude in a Jupyter notebook is the default, not a workaround.
How it works
Add it to JupyterLab, classic Notebook, or VS Code — about five minutes.
Choose Claude as your model in settings. No Anthropic API key required.
It writes the cell, runs it in your kernel, reads the output, and iterates.
What changes
In a terminal, an agent can tell you it ran your code — but you cannot see the figure it produced. Runcell executes each cell in your live kernel and renders the output inline, so you watch the result appear instead of taking it on faith.
The usual way to give Claude Code a kernel is to wire up a Jupyter MCP server and keep it running. Runcell skips the bridge entirely: it is the notebook-native agent, with the kernel built in.
Opening a notebook from the terminal means scrolling escaped source and cell metadata. Runcell works in the rendered notebook, so you and the agent both see real cells, not a JSON blob.
Side by side
The practical questions for notebook work: does it run inside a live kernel, can you see the output, and do you keep a reproducible notebook?
| Dimension | Runcell | Claude Code (terminal) | Claude Code + Jupyter MCP |
|---|---|---|---|
| Runs inside a live notebook kernel | Yes, in JupyterLab/Notebook/VS Code | Edits the .ipynb file from the terminal | Bridges to a kernel via an MCP server you set up |
| See cells run and rich output (plots, dataframes) | Yes, rendered inline in real time | No — a terminal cannot render notebook output | Partial, depends on your MCP setup |
| How it reads the notebook | Rendered cells in the notebook UI | Raw .ipynb JSON | Raw JSON plus MCP tool calls |
| Powered by Claude | Yes — Claude, GPT, and Gemini built in | Yes | Yes |
| Setup | Install the extension, about 5 minutes | Install the CLI | CLI plus configure a Jupyter MCP server |
Related
Runcell runs in JupyterLab, classic Notebook, and VS Code, so you keep the environment you already use. If your notebooks are mostly data work, the agent reads your outputs and carries the project across sessions rather than completing one line at a time.
Explore related workflows: AI Data Analyst, AI Agent for Jupyter, and the Jupyter Cursor alternative. For Claude in notebooks specifically, this page is the right starting point.
FAQ
Claude Code is a terminal-based agent. It can read and edit the .ipynb file on disk, but it does not run inside a live notebook, so you never watch cells execute or see rendered output like plots and dataframes. Runcell takes a different approach: it is an AI agent that lives inside JupyterLab, classic Notebook, or VS Code with a live kernel — and it can be powered by Claude — so you use Claude in your notebook and see every cell run in real time.
It can open and edit the notebook as JSON, but a terminal cannot render a notebook’s visual output, so charts, tables, and widgets stay invisible. Runcell works in the notebook itself, on a live kernel, so rendered outputs appear inline as the agent works instead of being hidden in raw JSON.
Claude Code can modify cells by editing the underlying .ipynb file. What it is not built to do is execute against a live, interactive kernel inside a notebook and show you the results visually. Runcell runs the cells in your real kernel and reads the actual output — numbers, dataframes, plots, and tracebacks — to decide its next step.
Install Runcell in JupyterLab, classic Notebook, or VS Code, choose Claude as your model, and ask in plain language. Runcell writes the Python, runs it in your kernel, and shows the output — no terminal and no JSON wrangling. Most people are set up in about five minutes.
No. Claude Code is Anthropic’s terminal coding agent. Runcell is a separate, Jupyter-native AI agent that runs inside your notebook. It can be powered by Claude (and other models), but it is built specifically for the notebook and live-kernel workflow that a terminal agent was not designed for.
Runcell includes access to leading models — including Claude, GPT, and Gemini — based on your plan, so you can use Claude in your notebook without bringing your own API key. You can switch models in settings.
Yes. Runcell installs as an extension in JupyterLab and classic Notebook, and it also works in VS Code, so you can keep the environment you already use instead of moving to a separate tool.