The agent

The agent is what makes Clusy more than a notebook. It's the AI you talk to in chat, and it can do most of what you can do in the notebook: write cells, run them, read the results, inspect what's in memory, search the web, and decide what to do next.

It works in a loop

For anything non-trivial, the agent doesn't write one block of code and stop. It plans a few steps, writes a cell, runs it, looks at the output, and decides what's next. If a cell errors, it reads the traceback, rewrites the cell, and runs it again, without going back to the plan. You watch this happen: the plan shows as a card, cells appear and run, and the agent tells you what it found before moving on.

The loop keeps turning while you type. A message you send mid-run is handed to the turn already in flight rather than starting a new one, so you can correct course without waiting for it to finish. See Stepping in for what happens to your message in each case.

The agent runs a closed loop: plan, write a cell, run it, read what actually came back, decide again. A failed run goes straight back to a rewrite — and a message you send mid-run folds into the turn already in flight instead of restarting it.

What shows up in chat

The agent's work comes through as cards, not just paragraphs:

• Plan: the steps it's about to take. Reply to redirect it before it starts.
• Thinking: a collapsible block of reasoning, on the models that support it.
• Suggestion: a proposed cell or edit, with Accept, Edit, and Skip.
• Tool call: a compact row for something it ran. Expand it to see the details.
• Clarification: a question it needs answered to keep going.
• Research: results it pulled from the web, with sources. For a full literature review, see Research.
• Sub-agent: a worker it spawned for a chunk of the job (more on this below).
• Deliverables: a strip at the tail of a turn listing what the turn actually produced.

Where the things it made go

When a turn ends, the agent lists what it made: a cell, a file in the workspace, a research run, or a worker trace. That strip sits at the bottom of the turn, and clicking a row opens the thing itself. Turns that only answered a question don't get one.

The same items collect in the Deliverables section of the Files tab in the sidebar, next to Workspace, Notebooks and Datasets. That list is project-wide and survives across sessions, so a file the agent wrote for you last week is still one click away after the chat has scrolled out of sight.

When it asks you

The agent is built to keep going on the mechanical parts and stop on the judgment calls: which column to predict, whether dropping rows with nulls is fine, which of two approaches you'd rather take. Those come through as a clarification, or sometimes as a control cell right in the notebook. When it's only proposing something, you get a suggestion or a ghost cell you can accept or skip. You're the one who commits the change.

Edit a cell yourself and the agent picks up from your version.

Sub-agents

For work that's large or splits into parts, the agent can spawn sub-agents: focused workers that each take a piece and report back. A research task might fan out into several searches. You can open a worker's trace from the chat to see its full reasoning and output, so the work stays inspectable. The trace also lands in the turn's deliverables strip.

What it remembers

The agent has a long-term memory, and it's scoped to the project. Anything it stores in one session, it can recall in another: what the dataset means, which approach you rejected, the naming you use. Start a new session in the same project and you don't have to re-explain the setup. Memory does not cross between projects.

You can write to it in plain language. Tell the agent "remember that I prefer polars over pandas" and it pins that as a durable preference, which means it's carried in context on every turn in that project rather than surfacing only when something reminds it. Tell it "forget that" and it drops the memory. Ask it what it remembers and it will search and tell you.

Pinned preferences are capped at twenty per project, so they're for standing habits, not one-off facts. Everything else is recalled when it's relevant rather than held in context all the time.

It also learns from what you do, not just what you say: accepting, editing, or skipping a suggestion is recorded, so skipping the same kind of suggestion repeatedly makes it stop offering them.

Plan mode

For a big job, you can have the agent research and lay out a full plan before it writes any code, then approve it and watch it build and run. Flip on the Plan toggle in the chat composer to switch into Plan mode.

Which model is behind it

"The agent" isn't one fixed model. You choose which model backs it, from a fast free default up to the most capable ones, and the choice changes how it behaves. See Choosing a model.

You can also bring your own: paste an Anthropic or OpenAI key and the agent runs on your key, or pair your machine and it runs through your own Claude Code or Codex CLI with the local runner.