An Answer Is Not Accountability

A wrong answer can be asked again; a real action may already have sent the mail, created the resource, or charged the card. Side effects need keys, receipts, and phases.

A wrong answer is cheap: ask again. A wrong action is not. The mail is sent, the resource exists, the card is charged. Once a model can write files, run commands, deploy services, and change production data, inference quality stops being the hard part. What matters is whose identity it acts as, what it can reach, whether it resumes after an interruption, and who declares the work done agent-trend-2026.

Three phases and a reconciliation

A tool with side effects runs in three phases: before dispatch, record the intent and mint an idempotency key; after dispatch, record that it was sent; after the result is confirmed, write back the outcome and produce a receipt. The point is narrow: at any instant you can say what state this action is in.

The case that matters is a crash before the result is confirmed. Any action whose outcome is unknown has to be reconciled: ask the external system whether the call landed, get a definite state, then decide. Never replay blind: replaying a charge whose result you never learned turns a failure into a refund.

Two things go with it. Generate the key from business meaning, such as order id plus action type, not at random, or you will not recognize the same intent when it returns. Add a dedupe check downstream too, since a key only binds inside your boundary.

A handoff needs eight fields

A structured handoff carries eight fields: target scope, verified facts, open assumptions, the current checkpoint, side effects awaiting confirmation, approval status, stopping conditions, and who receives the result. Passing along one paragraph of natural language summary is just disguising context loss as division of labor agent-trend-2026.

Two get dropped most often. Side effects awaiting confirmation tell the receiver whether to reconcile first. Who receives the result decides whose job this is; without it, ownership evaporates.

One more rule: statements in a handoff are leads, not facts. Agents reading each other's summaries easily produce conclusions that reinforce one another while resting on nothing: A says it verified X, B builds on X, and nobody ever ran that test.

Grade your message semantics

Collaboration messages come in four tiers, with authority increasing as you go up:

• Comment records shared facts and triggers nothing.
• Mention is explicit delivery: this concerns you.
• Handoff carries results and evidence, and moves responsibility.
• Structured results — completed, blocked, failed — are the only thing that changes task state.

Neither ordinary messages nor the end of a single model call may change state. A model call can be interrupted and resumed, so its completion is not closure. Treat it as closure and the agent says it is done while the task sits in the same place.

Two abstractions: task and job

The Tarot platform at Taotian splits this into two layers. A task is the persistent anchor for a goal: the final result, the scope, what is out of scope, upstream dependencies, and the evidence of completion. An agent's context at minute 5 and minute 50 differs completely, but the task does not; it is the system's basis for deciding whether the work is finished. A job is the smallest unit of execution: what problem it solves, which structured results end it, and what evidence it leaves taotian-loop.

An agent declaring completion is not closure: it requires the goal, the evidence, and an exit, all at once. The payoff is that failure stays inside the current job, and the task resumes from the affected stage instead of restarting wholesale.

The execution ledger splits the same way: file changes, commands, mocks, screenshots, diffs, and test results are facts and go in the ledger; rationale and residual risk are judgments and travel as comments and handoffs. Put both in one field and you cannot afterwards tell evidence from speculation.

The cost and how to audit

Bun migrated from Zig to Rust: a million lines, 6,755 commits, and 19 regressions that appeared after the merge. That is not the agent failing, it is the agent's boundary: mechanical migration can be pushed as far as existing verifiers cover, and behavior your tests never expressed still escapes agent-trend-2026. Verification is worth more than generation speed.

The cost is also plain: idempotency keys, receipts, reconciliation, and structured handoffs are code you have to write, and short chains will find it verbose. The test is reversibility: safely retryable calls may compress the phases, anything that sends mail, creates resources, or moves money needs every one.

Three questions audit you. Can you name the current phase of every side-effecting tool you run? If the process is killed before confirmation, do you have a reconciliation path? Does your last handoff list side effects awaiting confirmation and a recipient?