Mastering Agentic Data Science with Marimo Pair: A Step-by-Step Guide

Overview

Data science workflows are increasingly complex, with tasks ranging from data wrangling to model evaluation. Traditional pair programming—two developers working together—has proven effective for code quality, but what if one of those partners is an intelligent coding agent? This is where Marimo Pair comes in. Marimo is an interactive Python notebook environment (think Jupyter but with reactivity and cleaner code), and its pair feature introduces an AI agent that actively collaborates on your data science tasks. In this tutorial, you'll learn how to set up and use Marimo Pair for agentic data science pair programming, with practical examples in data wrangling and exploratory research.

Prerequisites

Before diving in, ensure you have the following:

• Python 3.9+ installed on your system.
• Marimo installed (pip install marimo). Verify with marimo --version.
• An API key for a language model provider (e.g., OpenAI, Anthropic) if you plan to use a cloud-based agent. Alternatively, you can run a local model via Ollama or Llama.cpp.
• Basic familiarity with Python data science libraries like pandas, NumPy, and matplotlib.
• A dataset to work with (we'll use the classic Titanic dataset for examples).

Optionally, install pandas, matplotlib, and seaborn for richer analysis.

Step-by-Step Instructions

1. Setting Up Marimo and the Pair Environment

Start Marimo in the directory where you'll store your notebooks:

marimo edit

This launches a local server and opens a new notebook in your browser. The interface is similar to Jupyter but with a cleaner, more modular design.

To enable the pair feature, you need to configure an AI backend. Marimo Pair supports multiple providers. Create a new cell and run:

import marimo as mo
mo.pair.enable(provider="openai", model="gpt-4", api_key="your-key-here")

If you prefer a local model, you can set provider="ollama" and model="codellama". Once enabled, you'll see a chat panel on the right side of the notebook. This is your agentic partner.

2. Understanding the Agent's Capabilities

The agent in Marimo Pair is not just a chatbot. It has context of your notebook—it can read cell outputs, execute code, and even propose edits. It specializes in:

• Assisting with data loading and cleaning.
• Suggesting visualizations and statistical tests.
• Debugging code errors.
• Providing explanations for results.

Think of it as an expert data scientist colleague who sees everything you do.

3. Agentic Data Wrangling: A Concrete Example

Let's load the Titanic dataset and ask the agent to help clean it. In a new cell, write:

import pandas as pd
df = pd.read_csv('titanic.csv')
df.head()

Now, in the chat panel, type: "The 'Age' column has missing values. What's the best strategy to impute them? Show the code."

The agent responds with a suggestion (e.g., median imputation by class) and offers to insert the code directly into your notebook. Accept the proposal by clicking the Apply button. A new cell appears:

# Agent-suggested imputation
df['Age'] = df.groupby('Pclass')['Age'].transform(lambda x: x.fillna(x.median()))

You can also ask follow-up questions, like "Create a feature engineering column for family size." The agent will generate code and even add comments explaining the logic.

4. Agent-Assisted Exploratory Research

Beyond cleaning, the agent can guide your research. For example, ask: "What factors most influenced survival? Perform a logistic regression and visualize the coefficients."

The agent will likely respond with a multi-step plan, including dummy variable encoding, splitting data, training a model, and plotting. Each step can be inserted as individual cells. You can also ask the agent to interpret the results:

# The agent might produce something like:
import statsmodels.api as sm
# ... model fitting ...
print(model.summary())

By working iteratively, you maintain control while accelerating the exploration.

5. Customizing Agent Behavior

You can fine-tune how the agent interacts. In the pair settings, you can adjust:

• Verbosity: How much explanation vs. direct code.
• Proactivity: Whether the agent suggests improvements without being asked.
• Scope: Limit the agent's access to specific cells or libraries.

To change settings, click the gear icon in the chat panel or run mo.pair.configure().

Common Mistakes and How to Avoid Them

Over-reliance on the Agent

The agent is a tool, not a replacement for critical thinking. Always verify the suggested code, especially when it comes to data transformations that might introduce bias. Run unit tests on small subsets.

Not Providing Enough Context

The agent only knows what's in the notebook. If your dataset has domain-specific quirks (e.g., columns with special meanings), mention them explicitly in your prompts. For example: "The 'Cabin' column has missing values that indicate passengers without a cabin, not a data entry error."

Ignoring Security Best Practices

When using cloud-based models, your data may be sent to external servers. Avoid uploading sensitive or personally identifiable information (PII). If working with such data, use a local model (e.g., via Ollama) to keep everything on your machine.

Not Iterating on Agent Suggestions

The first answer may not be optimal. Don't hesitate to ask for alternatives or refinements. Example: "That imputation method increases variance. Can you try using a predictive model for a more accurate estimate?"

Summary

Marimo Pair brings the power of agentic pair programming to data science, allowing you to collaborate with an AI that understands your notebook context. In this guide, you learned how to set up the environment, work with the agent on data wrangling and research tasks, and avoid common pitfalls. The result is a more efficient workflow where you retain creative control while offloading repetitive coding and exploratory steps. Try it on your next data project—your productivity will thank you.