The answer is the claim. The blocks are the evidence.

An ordinary chat page gives you prose and nothing else. Pi Agent gives you prose plus a record, because it does not only talk — it reads your files and changes them.

All three have proper names, worth learning because the software uses these words when something goes wrong.

Each row deserves a closer look than the one above it.

One turn can carry all three. A real session can place the gray block above the final answer, show a tool call as a white card, and render a file change in red and green — and each can be expanded for the detail underneath. Which of them you actually get depends on the model you chose and on what the request needed. A question answered from memory may produce none of them.

Easy to miss, and easy to over-trust

The reasoning block is gray, usually labeled Thinking or its translated equivalent, and normally arrives collapsed. Open it and you get whatever reasoning text the model's route makes available — a long passage, a short summary, or only usage metadata.

Only a supported reasoning model on a supported route produces one at all. Open it when the answer is strange, when it conflicts with something you told it, or when you want to see how the request was split up — for a lighting request, into trigger, condition and action. Skip it for a lookup, for anything low risk that you can check yourself, and for results you are not going to use.

You picked a reasoning model and got no block

Three things to check, in this order:

• The reasoning option is off. Where a model entry exposes a reasoning checkbox, that is what decides whether the block is rendered separately. Part 3 covers the model entry.
• The provider's thinkingFormat is wrong. It is a provider-level field: zai for GLM, deepseek for DeepSeek, qwen for a compatible Qwen route, openai only for an applicable direct OpenAI-compatible route. A direct Anthropic route normally leaves it blank, because the SDK uses its own thinking content block. The wrong parser simply fails to separate the reasoning out.
• The model is not a reasoning model. Family names lie. A catalog can list reasoning and non-reasoning variants side by side, and a Kimi K2-Instruct listing is an Instruct route, not a Thinking one. Confirm the exact model ID.

The block that records something real

A tool card appears when the agent needs to act rather than write. It carries the tool name, the input it sent and the result it got back, and reads Running…, success or failure as it goes.

The core package, @earendil-works/pi-coding-agent, ships seven tools, all lowercase:

Names like read_file, web_fetch or search belong to other agent systems. There is no built-in web fetch here; reaching the web needs a Skill built around something like curl or playwright, or a plain bash: curl … command.

While it runsEach card is timed and priced as it happens, and the session total sits in the top bar.Live workspace

• Each card names its tool and its file — write notes.md at 5s, read notes.md at 2s — with its own cost line underneath, so a slow or expensive step is obvious without doing arithmetic.
• $0.02 in the top bar is the running session total. That is this whole exchange, not a month of use.
• Waiting for model… is the gap between the last tool result and the written answer. Nothing is stuck.
• The message box becomes Steer now / queue follow-up with Steer and Follow-up buttons, and the red Stop at the bottom right is your handbrake for the moment you read a bash command you did not expect.

When the run finishes, the turn collapses into a summary you can reopen.

After it finishesTwo messages, two tool calls, one new file — and the explorer on the left shows it.Live workspace

• Process details · 2 messages · 2 tool calls is the collapsed record of the run. Open that row to get the cards back.
• notes.md in the EXPLORER on the left is the proof the file exists now. The chip sitting beside the answer names it too.
• The cost line ends with 1,152 cache R — input served from cache, which is part of why a follow-up in the same session often costs less than the first message did.

Your last human checkpoint

Deleted lines are red with a -. Added lines are green with a +. The white lines between them are unchanged context, exactly like a diff on a code hosting site.

A diff appears when the agent proposes or performs an edit to a file it has a baseline for. A standalone code sample has no baseline, so it produces no diff — which is itself a signal that nothing has been compared against your actual file.

Read the whole patch, not just what fits on screen. Controls such as Show details, Apply, Copy and Compare HEAD depend on your pi-web version and the active guardrails, so yours may differ.

Three ways to handle one

What a real turn looks like end to end

Say you ask for a 10:00 p.m. living-room lighting automation. The session has file tools and the home-assistant-best-practices Skill, which adds guidance rather than any new tool — it nudges the agent toward edit rather than rewriting all of automations.yaml. The turn may come back in five parts.

flowchart TD
  A["1 · Reasoning block
a 22:00 trigger, light.turn_off,
target light.living_room"] --> B["2 · Tool card: read
path: /config/automations.yaml"]
  B --> C["3 · Tool card: edit
plus an inline diff of the new entry"]
  C --> D["4 · Result inside the same card
success, or old_string did not match"]
  D --> E["5 · Final answer
a summary, plus reload guidance"]
  E --> F["6 · You validate the config
and test the automation safely"]

If all you read is “Done”, you never saw the path, the entity ID, the exact YAML, or whether the tool actually succeeded. The blocks are where those four things live.

Every block is also tokens

All three can add to your usage, though how a route bills them varies. A reasoning block may add hundreds or thousands of tokens. A large read pushes a lot of file into your context, and that context comes back around on the next turn.

Three controls that do change the number:

• Use reasoning only when the task needs it. For a lookup or a low-risk question, pick a current lower-cost non-reasoning model from your catalog.
• Decide how much file it needs before you ask. If one range matters, ask for that range instead of loading thousands of irrelevant lines into context.
• Start a new session when one gets long. Old reasoning blocks and tool output ride along into later turns. Watch the contextUsage indicator if your version shows percent used against the context window.

As for hiding them: the documented 0.8.4 baseline has no guaranteed global switch that suppresses every reasoning block. What it has is a display preference for whether they start open.

Settings → GeneralA display preference, not a billing one.

• Expand thinking blocks by default is the toggle people go looking for. It is off here, so reasoning blocks arrive collapsed. It does not decide whether reasoning happens.
• Appearance — Light, Dark or System, set to System, which follows the theme your browser is already using.
• The rest of the tab is Chat content width at 820px and Chat font size at 14px. Reading comfort, nothing to do with what a turn costs.

To genuinely stop paying for reasoning, change the model entry's reasoning setting where the route supports it, or select a non-reasoning model ID. A tidier screen is not a smaller bill.

Six things that go wrong

Where to go from here