Give it a goal.
It changes the code.

A session, end to end

Two workers explored a GPU monitoring tool and reported back. The agent wrote the summary you are reading from what they found, not from the files — and the panel on the right carries what that cost while it happened: 1.2M tokens across workers. The system prompt is built the same way every turn, so what the model has already read stays read.

The next capture is this same session, scrolled up.

The same session, one worker open

Every collapsed worker expands into what it actually did: fifty-two calls across six tools in under four seconds, each with its arguments and its duration. Some are csharp_definition — a plugin's tools, sitting among the built-in ones with nothing to tell them apart.

You are not asked to trust a summary of the work. The work is there.

Trusting a folder

The first question of the first session. Reads and writes inside this folder stop asking; anything that writes elsewhere, and every shell command, still stops.

A worker in its own context

A worker explores with its own turn count and occupancy — the parent stays where it was. The panel splits workers from this agent, because a session that spent most of its tokens inside children would otherwise look identical to one that spawned none.

When the decision is yours

The model gets one call and up to four questions, presented as steps. Every option carries a description saying what it means — a list of bare labels asks you to guess what the model was thinking.

Running what it built

A feature that compiles but was never executed is not finished. Every shell command asks first. Failed calls render red and stay in the transcript — here the agent adapted its own invocation across three failures before the export ran.

Every call a worker made

A finished worker is one row; opened, it shows its own model, the task as it was briefed, its turns and tokens, then every call it made with the time each took and how much came back.

What it actually cost

/stats ranks tools by characters returned rather than call count — a turn re-sends everything before it, so one tool returning 215k characters does not cost that once.

Loading a plugin

A plugin is a DLL cxagent did not ship. The prompt says what it will contribute and covers its approval with a hash of the whole load set — change a byte and the question comes back.

A plugin resolving a reference

csharp_definition resolves a reference in a test project to its declaration in the project under test — across a boundary grep cannot cross. The first call pays to index; everything after is answered from a warm index.

A terminal, for what a tool cannot do

A captured stream has nothing to type into, so a sudo password or a git rebase -i is where an agent stops and hands the job back. /shell opens a real PTY in a window over the session — the colours are the giveaway, since ls emits them only when it believes it is talking to a terminal.

Afterwards the agent is told what happened, queued rather than delivered into a turn of its own — so it does not start talking while you are still reading.