Agent run cells' outputs not visible to user

[julius-julius]

Hi, I have been having issues with seeing the outputs of the agent run cells. I am using Claude Code via MCP.

[julius-julius]

Agent-evaluated cell outputs are not visible in the notebook UI

Date: 2026-05-08

TL;DR

When the agent runs a cell via wolfbook_insertCells (with evaluate: true) or wolfbook_runCell, the kernel actually evaluates the code (global state is updated, definitions persist), but the resulting output is not written into the notebook. The cell still appears as "not evaluated" to anyone — including the user — looking at the notebook in VSCode. Only the agent sees the result, via the tool's text reply.

This means: outputs of agent-run cells are invisible to the user. If the user needs to see a cell's output, they must run it manually (or the agent must echo the result in chat / write it elsewhere).

Test design

Insert cells with distinctive contents, run them via different paths, then check whether the resulting output is stored in the notebook.

Three independent observation channels:

1. Tool reply — what the agent receives back from insertCells / runCell.
2. wolfbook_getCellOutput — reads the cell's stored output from notebook state (this is what the user sees).
3. wolfbook_getNotebookContext action="read" — reads the full cell with its stored output.

Plus wolfbook_evaluateExpression to query the kernel state independently — to confirm whether evaluation actually happened.

Tests

Test 1 — insertCells with evaluate: true

Inserted cell:

Print["AGENT_MARKER_INSERT_T1"]; testValueInsert = 6 * 7

Channel	Result
insertCells tool reply	Cell 1 (...): ✓ — (no output)
getCellOutput	no output (not evaluated yet or suppressed result).
getNotebookContext	Cell shown with code, marked *(not evaluated)*
Kernel state — evaluateExpression["testValueInsert"]	Out= 42 — kernel did evaluate

Test 2 — runCell on a previously-inserted cell

Inserted with evaluate: false, then ran via runCell:

Print["AGENT_MARKER_RUNCELL_T2"]; testValueRunCell = 11 * 11

Channel	Result
runCell tool reply	Cell 2 (...) executed. (no output — definition or suppressed expression)
getCellOutput	no output (not evaluated yet or suppressed result).
getNotebookContext	*(not evaluated)*
Kernel state — evaluateExpression["testValueRunCell"]	Out= 121 — kernel did evaluate

Tests 3 & 4 — pure expressions (no Print, no assignment)

Inserted via insertCells with evaluate: true:

2 + 2          (* should display 4 *)
Range[5]       (* should display {1,2,3,4,5} *)

Channel	Result
insertCells tool reply	✓ — (no output) for both cells
getCellOutput	no output (not evaluated yet or suppressed result). for both
getNotebookContext	both cells *(not evaluated)*

Even pure expressions whose return values would normally show as Out[...]= 4 produce nothing visible in the notebook when the agent runs them.

Sanity check that stored output normally exists

For comparison, cells which were previously manually run show explicit stored output, e.g.:

Out[6]=  ⟨|"ρ[3/10]" → 0.0889..., ...|⟩
Out[9]=  0
Out[12]= -11320.931695006491

getNotebookContext and getCellOutput see these. So the read tools work fine — the issue is specifically that agent-run evaluations don't write output back to the notebook.

What this means in practice

Operation	Kernel state updated?	Visible in notebook?	Visible to agent?
Agent: insertCells evaluate=true	yes	no	yes (tool reply)
Agent: runCell	yes	no	yes (tool reply)
Agent: evaluateExpression	yes	n/a (no cell)	yes (tool reply)
User: manual cell evaluation in editor	yes	yes	yes (next read)

Implications for collaboration

• Don't rely on agent-run cells as a way to show the user a result. The cell will look unevaluated to them.
• If a result needs to be visible: either report the result in chat or ask the user to run the cell manually or write it to a separate file.
• Re-running a notebook from scratch after an agent session: the user must execute cells themselves to see any of the outputs the agent generated. Side-effect state (definitions, variables) IS retained in the kernel session, but the rendered outputs are not.
• This affects the value of inserting "verification" cells whose only purpose was to display a sanity-check result — that result is invisible until the user re-runs.

Activity log evidence

The Wolfbook activity log records BULK INSERT and RUN CELL events for agent operations (visible in getNotebookContext recent-activity list), but the cells those events touched still register as *(not evaluated)* in the stored notebook state. The events fired; the outputs simply weren't persisted into the notebook.

[julius-julius]

It could be that if the user runs at least one cell in the wolfbook themself, then subsequent evaluations by the agent are visible.