Reading output

When a cell runs, its output shows up underneath. Clusy renders it richly instead of dumping everything as text, so a DataFrame looks like a table and a plot looks like a plot.

DataFrames

A returned DataFrame renders as a table, with sticky headers, zebra rows, and horizontal scroll for wide frames. It's built for actually looking at the data, and large frames are handled without locking up the notebook.

Charts and images

Plotly figures render inline and stay interactive, so you can hover, zoom, and pan. Static plots (matplotlib and friends) render as images, as do any images your code produces from a file, a URL, or raw bytes. The chart libraries load only when a cell produces a chart, so notebooks without plots stay lean.

Training and progress

Long loops get proper treatment instead of scrolling text. tqdm-style loops render as a compact, updating bar, and Hugging Face Trainer runs get a dedicated progress view instead of a wall of log lines. A long training run stays readable.

Text and logs

Plain text and print output render as text. Terminal color codes are interpreted, so colored logs show up colored instead of as escape gibberish.

Errors

When a cell raises, you get the full traceback, formatted and readable, with the failing output marked. This is also what the agent reads when it goes to fix the problem, so if you ask it to, it's working from the same trace you're looking at.

Rich objects

Objects that know how to render themselves (HTML, SVG, custom displays) show up that way in a sandboxed frame, rather than as a bare repr.

Where output travels

Output is saved with the notebook, so it comes along in a share link and in an .ipynb you export from the + menu on the canvas. In both cases what you see is what a reader sees. A share carries output by default; the share dialog has an Include outputs checkbox you can uncheck, and unusually large outputs are replaced with a placeholder rather than shipped whole.

It does not go into Git. Clusy commits notebooks as Jupytext percent-format Python — code and text faces, plus a manifest describing the branch structure — and outputs are left behind on purpose. That's what keeps a commit reviewable as a few changed lines instead of a churned-up JSON blob. So a colleague reading your pull request sees the code; a colleague opening your share link sees the plots.

Deliverables

Long turns produce a lot of cells, and it's easy to lose track of the two or three that actually mattered. At the end of a turn the agent flags what it made in a Deliverables strip under its final message: the cells worth looking at, files it wrote, research runs, and traces from any sub-agents it ran. Click one and Clusy takes you to it — a cell scrolls into view in the notebook, a file opens as a canvas preview.

The strip is per-turn, so it scrolls away as the conversation grows. The same list, for the whole project, lives in a Deliverables section in the Files tab of the sidebar, alongside Notebooks, Datasets, and the sandbox Workspace. That's the place to go when you know the agent made something last week and you can't remember where.

Cells the agent touched but had nothing to say about are collapsed behind a toggle rather than listed, so a twenty-cell turn doesn't bury its own result.