The AI project partner inside your notebook

Runcell is the Jupyter-native AI agent for domain experts running real, multi-week ML and data projects. It reads your notebook and its outputs, remembers where your project left off, and runs long tasks end to end — not just snippets of code.

$pip install runcell

Why projects stall in the notebook

Your project doesn't fit in one prompt.

A real model, paper, or pipeline takes weeks, dozens of notebooks, and hundreds of decisions. Generic AI tools treat every message like a fresh start — so you become the glue.

They forget everything

Every session you re-explain the dataset, the decisions, and where the project left off. The tool never remembers — you do.

They can't see your results

Most assistants read your code but not the loss curve, the confusion matrix, or the figure your cell just produced. They debug blind.

They give up halfway

A multi-hour training run or a thousand-step analysis is exactly where chat tools time out and lose the thread.

Runcell works at the project level — it remembers your project, reads your outputs, and runs long tasks end to end, inside the JupyterLab you already use.

A different category

Code editors finish your lines. Runcell carries your project.

Cursor, Copilot, and Continue are code editors with AI — great at the next line and the next file. A multi-week ML project is a different job: a sequence of experiments, results, and decisions that has to hold together over time. That's what Runcell is built for.

Remembers your project

Cross-session memory. Pick up days later and ask "what did we do so far?" — Runcell knows the dataset, the decisions, and the state of the work.

Goes the distance

Long-running tasks that span hours or days. Runcell runs thousands of steps end to end without losing the thread.

Reads your results

It sees the charts, plots, and image outputs your cells produce — reasoning about real outcomes like a diverging loss curve, not just your code.

Lives in your notebook

Runs inside JupyterLab on your existing .ipynb files. No new editor, no copy-paste.

How it works

From a goal to a finished project

Hand Runcell an outcome and it plans the steps, writes the code, runs the cells, reads the results, and keeps going — remembering the project as it works, inside the JupyterLab you already use.

Out [1]Autonomous agent
01Autonomous agent

🤖Give it a goal, it runs the notebook

Describe the outcome you want. Runcell plans the steps, writes the code, executes the cells, and fixes errors as it goes — an autonomous agent working end to end inside your notebook.

Multi-step workflows, executed for you

Out [2]In-context assist
02In-context assist

💬Ask about any cell, apply the fix in one click

Select a cell and ask what is wrong or what comes next. Runcell reads the surrounding code and outputs, generates the fix, and recommends your next step — all without leaving the notebook.

AI that understands the cells around it

Out [3]Learn by doing
03Learn by doing

🎓Understand unfamiliar code with live examples

Hit an algorithm or library you do not know well? Runcell explains it with runnable examples right in your notebook — like comparing K-means vs DBSCAN on real data instead of digging through docs.

Concepts explained with runnable cells

Out [4]Domain expertise
04Domain expertise

🧬You bring the domain, the agent writes the code

For domain experts who think in problems, not Python. Describe the analysis or figure you need — like a genomics circos plot — and Runcell handles the implementation.

Research-grade code, minus the boilerplate

Who Runcell is for

Built for the work you actually ship.

The deepest Runcell users aren't hobbyists learning Python — they're domain experts shipping real projects.

📊

Risk & fintech modeling

Iterate dozens of model versions, read PSI/IV and confusion matrices, and ship to production.

🔬

Academic research

Take a study from raw data to publication-ready figures across one long project.

📦

Supply chain & forecasting

Keep multi-notebook demand and commodity models consistent over months.

🧬

Medical & life-science ML

Train and evaluate on small, sensitive datasets with the rigor your field demands.

Why Runcell

What is Runcell?

Runcell is a Jupyter-native AI project partner for domain experts running real, multi-week ML and data projects. It lives inside JupyterLab as a lightweight extension — writing and debugging your Python, executing cells, and reading the charts and outputs your code produces. Unlike chat tools bolted onto a notebook, Runcell remembers your project across sessions and runs long tasks that span days, so it carries the whole project with you instead of answering one prompt at a time.

Runs inside JupyterLabRemembers your project across sessionsRuns tasks that span daysReads your charts & outputsWorks on existing .ipynb filesNo API key required

What Runcell can do

It remembers your project

Cross-session memory keeps your dataset, decisions, and progress in context. Pick up a multi-week project days later and ask “what did we do so far?” — Runcell knows.

Explore the features or the documentation.

It sees your outputs

Runcell reads the charts, plots, and image outputs your cells produce — so it reasons about real results, like a diverging loss curve, instead of guessing from your code alone.

It runs the long jobs

Multi-hour training runs and thousand-step analyses. Runcell executes long tasks end to end without losing the thread or timing out halfway through.

Key capabilities

Everything you need to run a project, not just write code

Notebook-nativeRuns inside JupyterLab on your existing .ipynb — no new editor.
Auto execution & debuggingRuns cells, diagnoses errors, and keeps your analysis moving.
Output-awareReasons about the charts and results your cells produce.
Jupyter superpowersFile tree, global search, and git built right into JupyterLab.

How it compares

Code editors vs. a project partner

vs. Cursor & AI IDEs

Cursor is an excellent code editor, but it is built around files and the next line — it pulls you out of Jupyter and does not carry a multi-week project. Runcell is notebook-native and built for the project, not the snippet.

vs. Copilot autocomplete

Autocomplete guesses the next line. Runcell plans a multi-step analysis, runs it, reads the results, remembers what happened, and iterates — a project partner, not code completion.

vs. notebook AI chat

Chat bolted onto a notebook answers questions about your code. Runcell acts on the notebook — running cells, reading outputs, remembering the project, and moving the work forward.

FAQ

Frequently asked questions

Runcell is a Jupyter-native AI project partner for domain experts running real, multi-week ML and data projects. It works inside JupyterLab — writing and debugging Python, running cells, reading your outputs, and remembering your project across sessions — so it carries the whole project with you, not just one prompt at a time.

If you like agentic AI coding but live in Jupyter, yes — but Runcell does more than port Cursor into a notebook. Cursor is a code editor built around files; Runcell is a project partner that reads your outputs, remembers your project across sessions, and runs long multi-step tasks. For real, multi-week ML and data projects, that is a different job than a code editor does.

Yes. Runcell keeps cross-session memory of your dataset, your decisions, and the state of your work, so you can pick up a multi-week project days later and ask “what did we do so far?” instead of re-explaining everything.

Yes. Runcell is built for long-running work — multi-hour training runs and analyses that take thousands of steps — executing them end to end inside your notebook without losing the thread.

Install the extension with “pip install runcell” (or through the JupyterLab extension manager), restart JupyterLab, and sign in. There is no separate desktop app and no new IDE to learn.

No. Runcell includes access to leading AI models such as GPT, Claude, and Gemini based on your plan, so you can start without bringing your own API key.

Yes. Runcell reads the visualizations and image outputs your cells produce, so it reasons about real results instead of guessing from your code alone.

Yes. Runcell works on your existing .ipynb notebooks in JupyterLab and respects your workflow, adding conveniences like a file tree, global search, and git directly in Jupyter.

Yes. The free Hobby plan includes monthly credits so you can try Runcell on a real project, and paid plans add more credits plus access to advanced models for heavier ML and data work.
Runcell demo + intro in 1 minute

Start your next project with Runcell

Install in one line, sign in, and put a project partner inside the JupyterLab you already use — one that remembers your work and runs the long jobs with you.

Free to start • Runs in your JupyterLab • No API key required

From the blog

Tutorials, tips, and best practices for working with Jupyter notebooks

Tutorial

nbconvert tutorial: Convert ipynb to HTML, PDF, and Python scripts

Learn how to convert your Jupyter notebooks to various formats using nbconvert

Guide

5 Ways to Delete a Column in Pandas DataFrame

Master different methods for removing columns from your pandas DataFrames

Explanation

Understanding `.ipynb_checkpoints`: What they are and how to manage them

Understand checkpoint files in Jupyter and learn how to manage them effectively