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.

An agent in its own tab

Sub-agents run in the background, listed in the tasks panel. Open one and it has a tab of its own: its brief, each step's thinking and tool calls, and its answer as it is written — with Stop, and a composer that talks to it rather than to the session.

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.

A question on the side

/btw asks about what the agent knows without adding to what it remembers. The aside starts from the conversation as the agent last sent it and answers in its own block while the main turn carries on — the calls above and below it are the agent, still reading.

It can read and nothing else, under the session's own permissions; a read the agent would be asked about is asked about here too.

One goal, no window

cxagent -p runs a goal and prints the answer, so it goes in a pipe, a script or a CI job. The options are Claude Code's — --output-format json, stream-json, -c to continue the run before — so a script written for claude -p works with cxagent swapped in.

Nobody is there to answer a prompt, so anything that would ask is refused and listed in the result; each run is an ordinary session you can open in the TUI.

A prompt you keep, as a command

A markdown file in .cxagent/commands became /review-branch. The row shows what was typed; the model got the file, with the arguments filled in and the output of its git diff line — which asked first, as the agent's own shell calls do.

Claude Code's command format works as it is; the palette tags each one with where it came from, because the nearer file of a name wins.

What it thought, and how hard

Each step that thought gets its own block, folded from the start and open on a click, so a run reads as thought, calls, thought, answer. Ctrl+O opens the latest; any other is a click away.

F10 and /think set the level the model offers — on or off for a llama.cpp server, low to max for Claude.

Providers, servers and agents, in the app

F8 opens one dialog for providers, MCP servers and sub-agent types. A new provider starts from a card — Anthropic, OpenRouter, OpenAI, Ollama, llama.cpp or any OpenAI-compatible endpoint — and its model is picked from what that endpoint serves, with each model's window and, on OpenRouter, its price.

A save is live. What the model cannot see — a new key, the reviewer, the default — applies in place; a new model would re-send each open tab's conversation, so you are asked how and when.