#555: Marimo Pair - A Canvas for Agent + Developers Collaboration

Summary of #555: Marimo Pair - A Canvas for Agent + Developers Collaboration

by Michael Kennedy

1h 4m•July 13, 2026
Listen to Episode

Overview of #555: Marimo Pair - A Canvas for Agent + Developers Collaboration

In this Talk Python to Me episode, Michael Kennedy interviews Trevor Mance of Marimo about Marimo Pair, a new agent skill that lets coding agents work inside a live Marimo notebook kernel instead of only editing files on disk. The big idea is to give agents access to the actual in-memory Python state—variables, data frames, plots, and notebook cells—so they can help with exploratory data work in a way that feels much closer to how humans use notebooks.

What Marimo Is

Marimo is a reactive Python notebook designed around reproducibility and the Python ecosystem.

Key characteristics

  • Uses Python files instead of .ipynb notebooks.
  • Tracks data dependencies between cells rather than relying on execution order.
  • Automatically re-executes dependent cells when values change.
  • Prevents hidden state and out-of-order notebook confusion.
  • Provides polished rendering for Python-native data objects like:
    • Pandas data frames
    • Polars data frames
    • Ibis tables
    • other data-frame-like protocols

Why it matters

Marimo is positioned as a notebook environment that feels more like incrementally building a Python program than maintaining a scratchpad of executed cells.

Why Traditional Coding Agents Struggle with Notebooks

The episode spends a lot of time on why standard coding agents are a poor fit for notebook-based workflows.

Main problems

  • Agents are optimized for file-system-based coding tasks, where the source of truth is on disk.
  • Notebook files contain:
    • cell code
    • execution output
    • stale state
    • sometimes large embedded data
  • That makes notebook files noisy and hard for agents to reason about.
  • In a notebook, the important context is often the live kernel state, not just the source file.

Core insight

For data work, the useful environment is not just the code file—it’s the running interactive session with values in memory. Marimo Pair is designed to expose that state to an agent.

What Marimo Pair Does

Marimo Pair is an agent skill that drops an agent into a running Marimo notebook session.

Capabilities

  • Run Python code inside the live kernel
  • Inspect variables and notebook state
  • Read notebook cell source and outputs
  • Create, edit, and run cells
  • Install packages from within the notebook workflow
  • Use live runtime values to guide analysis

Why it’s different

Instead of asking an agent to reconstruct notebook state from files, Marimo Pair lets the agent query the live notebook directly. That means the agent can:

  • inspect schemas
  • check row counts and column types
  • zoom into specific data subsets
  • react to intermediate results
  • iterate in tighter loops

How It Works

The integration is built around a single Python execution tool that the agent can use in the active Marimo kernel.

Under the hood

  • The agent skill installs into supported agent harnesses.
  • Marimo exposes a semi-private internal API called code mode.
  • Through that API, the agent can:
    • list variables
    • inspect cells
    • show notifications in the UI
    • create/edit/run cells
    • interact with notebook state directly

Important design choice

Marimo Pair uses Python as the control surface, not a pile of MCP/JSON tools. That makes it easier for the agent to compose actions with loops, conditionals, and richer logic.

Benefits for Data Work

The episode emphasizes that Marimo Pair changes how agents help with exploratory data analysis.

Practical advantages

  • The agent can answer questions from actual in-memory data, not just code text.
  • It can identify relevant columns and types automatically.
  • It can generate plots without needing all parameters spelled out.
  • It can respond to selections and interactions in charts.
  • It reduces the need to “babysit” the agent with lots of manual context.

Example use cases

  • Load messy Excel files into a notebook
  • Ask the agent what columns or visualizations are interesting
  • Build plots from live data frames
  • Explore nulls, schema, distributions, and selections
  • Iterate on data cleaning and analysis step by step

Installation and Distribution

Marimo Pair is distributed as an agent skill.

Installation options discussed

  • npx skills add marimo-team/marimo-pair
  • uvx dino -a npm skills
  • Cloud Code marketplace install
  • Codex marketplace install
  • GitHub-based skill installation

Why a skill-based approach

  • Keeps the integration lightweight
  • Works with multiple agent harnesses
  • Avoids tight coupling to any one AI product UI
  • Lets Marimo stay useful as the agent ecosystem changes rapidly

Tooling and Ecosystem Support

The conversation also covers how Marimo Pair fits into the broader agent landscape.

Supported/targeted environments

  • Cloud Code
  • Codex
  • OpenCode
  • VS Code integration
  • Marimo’s own chat experience
  • Remote/cloud notebook sessions

VS Code direction

Trevor mentions ongoing work to let agents in VS Code directly drive notebook outputs and interact with Marimo notebooks more naturally.

Headless and Collaborative Workflows

Marimo Pair is not only for interactive “pair programming” style use.

Two main workflows

  • Hands-on notebook collaboration
    • Human and agent work together live
    • Best for exploratory analysis
  • Headless session generation
    • Agent builds a notebook from scratch or near-scratch
    • Human reviews the resulting reproducible notebook afterward

Why this works well

Because Marimo enforces reproducible execution, agents are forced to build notebooks in a more disciplined, cell-by-cell way rather than generating a broken artifact and hoping it runs.

Roadmap and Future Direction

Trevor says Marimo is expanding agent support across more environments.

Near-term and future work

  • Tighter integration in VS Code
  • Better support for browser/editor-based notebook workflows
  • Potential support for desktop agent apps
  • Real-time collaboration features in Marimo
  • Better handling of remote kernels and cloud-based notebook sessions

Remote execution

Marimo Pair can connect to a remote Marimo kernel, allowing:

  • local agent, remote notebook
  • cloud sandbox usage
  • GPU-backed environments
  • collaboration from anywhere

Main Takeaways

  • Notebook state matters for data work, and file-based agents miss that context.
  • Marimo Pair brings the agent into the live notebook kernel, not just the file system.
  • The integration makes agents much better at exploratory data analysis, visualization, and iterative notebook work.
  • A skill-based distribution model lets Marimo work with many agent tools without locking into one UI.
  • The long-term goal is to make Marimo notebooks a reproducible, agent-friendly canvas for both humans and AI assistants.

Recommended Next Step

If you work with data in Python notebooks, the best way to evaluate Marimo Pair is to:

  • install the skill,
  • open a Marimo notebook,
  • and try asking an agent to load, inspect, and visualize a real dataset.

Trevor’s advice is essentially: bring your own data and let the agent help you explore it live.