What the final answer left out

An agent's final answer can be excellent and its run can be unacceptable.

N17Q had already produced the uncomfortable example: a correct repository update, a confident report, and a duplicate simulated external request hidden behind a timeout. Reading the last message explained what the agent believed. It did not explain what the system had done.

I needed a durable object larger than a conversation and smaller than an indiscriminate event dump.

That object became the run: one attempt to pursue a task under a versioned world, configuration, policy, capability set, and budget.

A run began before the first prompt

The initial record named scenario version, task input digest, workspace snapshot, requester and delegation, agent configuration, model and adapter revisions, tool registry snapshot, policy revision, budget, and start time.

These facts shaped every later decision. Storing them only in deployment configuration made two runs look comparable when they were not. Copying them into the natural-language prompt made them vulnerable to truncation and difficult to query.

N17Q kept structured configuration as authoritative state and compiled a bounded subset into model context. The trace linked both.

The run existed before any provider request because the attempt's conditions already mattered.

Conversation was evidence, not identity

A provider session or conversation ID could help continue generation. It was not a durable product key.

Providers differed. Sessions could expire, be deleted, or contain state the harness could not inspect. A run might change models after a checkpoint or reconstruct context without continuing the remote conversation.

N17Q assigned its own run, turn, request, and attempt identities. Provider identifiers remained linked observations. Losing them could reduce diagnostic detail or native resume capability without erasing the run.

The product record could survive the service that helped produce it.

Semantic events formed the spine

Raw logs captured too much accidental detail. A final summary captured too little. I defined an append-only semantic event sequence.

Events included run created, model requested and observed, plan proposed, tool requested, policy decided, approval requested and decided, tool started and observed, effect reconciled, artifact stored, checkpoint created, run paused, resumed, completed, failed, or stopped.

Each event had stable identity, run identity, parent or causal links, source, schema version, observed times, and a redacted payload or artifact digest.

The event vocabulary described decisions and consequences. Provider deltas and process output stayed attached as raw diagnostic artifacts.

A parser could misclassify an error. A later reconciliation could discover that an unknown tool attempt had actually succeeded. An evaluator could correct its own score.

N17Q never edited the original event into the new interpretation. It appended a correction, supersession, or effect-observed event linked to the earlier record.

Projections displayed current understanding while preserving how that understanding changed. A trace bug remained a traceable bug rather than silently improving history.

Append-only storage did not guarantee truth. It made corrections visible and gave integrity checks something stable to verify.

Model provider, harness process, sandbox, and external fixture each observed time differently. Network delay and buffered logging could make receipt time appear before a locally recorded request completion.

N17Q retained source timestamps with their clocks and added local ingestion time. Within one event stream, monotonic sequence established storage order. Causal links expressed known relationships such as this observation resulted from this attempt.

The UI could build a useful timeline without pretending every millisecond was globally comparable. Clock corrections never overwrote original readings.

W93H had taught me that a tidy false chronology is worse than visible uncertainty.

Causality was more useful than adjacency

The message immediately before a tool call was not necessarily its only cause. The plan could reference evidence retrieved several turns earlier, a policy denial could trigger a later narrower request, and one approval could bind an intent executed after a checkpoint.

Events carried explicit links: derived from, responds to, authorizes, attempts, observes, supersedes, and checkpoints. The graph remained constrained enough to query and render.

Chronological order stayed available. Causal links prevented timing proximity from becoming an invented explanation.

This let a reviewer ask which observation supported an action instead of scrolling upward and guessing.

Plans were proposals too

Agent plans changed. Some providers emitted explicit plans; others only produced tool requests and final text. N17Q stored a plan when the orchestrator observed one, labelled by method and revision.

A plan had no execution authority. Policy evaluated each capability request against current state. The model could abandon or revise a plan after new evidence, and the trace linked the transition.

I avoided reconstructing hidden reasoning or requiring private chain-of-thought. The record contained only plans and reasons intentionally exposed through the product contract.

The goal was observable decision state, not surveillance of an unknowable internal process.

A model could request an action that policy denied, approval delayed, or normalization rejected. No tool attempt occurred.

One allowed request could have several transport attempts under one recovery policy. An attempt could produce no observed response while an external effect still occurred.

N17Q stored request, normalized capability intent, execution attempt, and effect separately. Their identities and links prevented a denied proposal from appearing executed or a retry from becoming a second semantic intention.

This distinction was the foundation for both safe recovery and useful evaluation.

Policy decisions were first-class evidence

A tool trace that jumped from request to result could not explain why the effect was allowed. N17Q recorded policy revision, normalized input digest, relevant current state, decision, bounded reason, and requirements such as approval.

Sensitive rule detail stayed protected. The run retained enough evidence to reproduce the decision against its historical policy fixture.

A later policy change did not rewrite the old decision. It governed the next execution boundary and could pause a previously planned action.

Authority became part of the run narrative rather than an invisible middleware side effect.

The trace stored what the reviewer saw: product consequence, normalized arguments, resource and world preconditions, policy digest, recovery limits, expiry, and decision.

Approval consumption linked to one intent. If arguments or preconditions changed, the trace showed a stale receipt and a new review rather than reusing the old yes.

The reviewer identity and any delegation stayed separate from the model and initiating requester. A rejection could include a bounded reason for replanning.

This made human intervention inspectable without reducing it to a Boolean in a tool log.

Repository snapshots, diffs, source documents, model payloads, command output, rendered previews, and evaluation reports did not fit comfortably inside event rows.

N17Q stored them in a content-addressed artifact store. Events referenced digest, media type, size, retention class, redaction state, creator, and semantic role.

The same bytes could be referenced by several events without duplication. Changed bytes produced a new identity. Access policy applied when resolving an artifact, not merely when viewing the trace index.

An artifact digest established content identity. It did not prove the content correct or safe.

Raw evidence remained bounded

Debugging sometimes required original provider events or full command output. Keeping all raw data forever would accumulate secrets, private text, and noise.

The run configuration declared retention by artifact class. Input and output passed through size limits and redaction before durable storage. Particularly sensitive payloads could remain encrypted with narrower access or be excluded while preserving a tombstone and digest.

Semantic events held safe summaries and exact references where retained. Expiry changed what could be inspected later and was visible in the trace.

Observability did not become an excuse for indiscriminate collection.

Checkpoints described resumable meaning

A checkpoint captured the structured state needed to continue: current task and plan, authoritative constraints, selected evidence, unresolved requests and effects, approvals, world references, budgets, policy context, and completed artifacts.

It was not a copy of the visible chat. A provider adapter could compile a new bounded context from the checkpoint and semantic trace.

Checkpoint creation was atomic with its event identity. A resume began from one committed checkpoint and recorded any model or configuration transition.

Long-running work could cross processes and providers without pretending the agent's context window was durable storage.

Summaries were derived artifacts

Context compaction created a summary tied to source event ranges, compiler version, and checkpoint. The summary was useful and untrusted until required fields were validated.

N17Q checked that it retained unresolved unknown outcomes, denials, approvals, user constraints, negative evidence, remaining budget, and current world state. Missing one of those could make a resumed plan unsafe.

The raw events remained linked. Regenerating a summary created a new artifact rather than overwriting the old one.

A shorter prompt was not automatically a better checkpoint.

Run status did not flatten uncertainty

Completed, failed, and canceled were insufficient. A run could be paused for approval, blocked by missing fixture, stopped at budget, waiting for external observation, or holding an unknown effect outcome.

N17Q represented these terminal and nonterminal conditions explicitly. Each state named allowed next actions. A user stop could be successful control rather than a failure. A model final answer could exist while the run remained unresolved.

The interface never inferred completion from the presence of prose. Completion required scenario conditions and no unresolved required effects under current policy.

The status told the truth even when the truth was inconvenient.

The final answer became one event

The agent's final response entered the trace with the checkpoint and evidence it claimed to summarize. It remained important: people often depended on that account rather than replaying the run.

An evaluator compared its statements with world state, receipts, artifacts, tests, and unresolved uncertainty. Omitting a duplicate effect or calling an unknown outcome failed reporting even if other task work was correct.

The answer could be revised through another event. The original remained available.

This reduced neither prose nor explanation to decoration. It placed them in the same accountable system as the work they described.

The world had its own log

Tool observations were not ground truth. An adapter could fail to receive a response or misparse it. N17Q's deterministic scenarios maintained an independent simulated-world event log and current resource state.

Evaluators compared run belief with world truth. The agent accessed only permitted observations through tools. This enabled fault cases such as effect committed but response lost.

For real external systems, ground truth was necessarily weaker. Receipts, query APIs, and later observations provided evidence without claiming omniscience.

The trace distinguished known, inferred, reported, and independently observed facts.

Configuration changes created transitions

A long run could cross a model upgrade, policy revision, tool registry change, or adapter deployment. Calling it one homogeneous configuration would make later comparison misleading.

N17Q recorded transition events with old and new digests, reason, checkpoint, and eligibility. Some changes required human review or forced the run to restart. Others applied immediately at the next policy boundary.

The run identity remained stable because it still pursued the same task history. Segment identity made configuration-specific analysis possible.

Continuity did not require pretending nothing changed.

Replaying from a checkpoint with another model or policy created a child run. It shared immutable history up to the branch point and diverged afterward.

The original events never changed. Branch metadata named the controlled difference and fixture world snapshot. Comparisons aligned semantic roles and highlighted the first consequential divergence.

A branch was an experiment, not an alternate claim about what had happened. Its effects existed only in its simulated world.

This made “what if” analysis useful without merging counterfactual output into the historical trace.

Integrity checks guarded the record

Events carried sequence and content digests. Artifact references were verified on read and during backup drills. Projections could be rebuilt from the semantic stream and compared with stored checkpoints.

These checks detected missing or altered data. They did not prove that an original event described reality accurately. Receipts, world assertions, and evaluator evidence still mattered.

Where stronger tamper evidence was needed, run manifests could be signed with a controlled key. The interface used careful language about what signatures established.

Integrity protected the record's identity, not its universal truth.

Retention could leave an honest skeleton

Some raw provider payloads and source excerpts expired before semantic run records. N17Q retained event type, safe metadata, digests, decision outcome, and tombstones explaining the missing artifact.

A reviewer could still see that a source observation informed a tool request even if policy no longer allowed the source text to remain. The UI did not pretend the evidence was currently inspectable.

Deleting a run removed semantic events, artifacts, indexes, fixtures, and cached projections through a verified workflow. Exporting beforehand produced a documented package under its own policy.

Durability and indefinite retention were separate promises.

The review interface used layers

Displaying every provider delta, command line, policy rule, and artifact produced an unreadable wall. Showing only a generated summary repeated the original problem.

The default view became a semantic timeline of decisions and consequences. Filters exposed external effects, denials, approvals, budget changes, and unresolved states. Each item linked to raw evidence and world-state differences.

A synchronized artifact view showed repository diff and simulated resources. The final account sat beside evaluator findings.

The interface summarized without severing the route back to evidence.

Accessibility favored narrative structure

The run timeline used headings, ordered lists, status text, and meaningful links before visual connectors. A screen reader could traverse event summaries and open causal evidence. Keyboard focus followed selected events into artifacts and returned predictably.

Colors distinguished categories only alongside labels and icons. Live runs announced semantic transitions such as approval required or effect outcome unknown, not every token or log line.

The branch view offered a table comparison in addition to a graphical tree.

Making traces understandable without a visual canvas improved the information model itself.

Evaluation cited the run

Every deterministic failure linked to the scenario invariant, world event, and relevant run events. Qualitative graders cited trace and artifact identities with rubric clauses.

A model evaluator could call a plan unfocused and had to show repeated requests or ignored observations. It could not override a hard prohibited effect because the final prose sounded persuasive.

Evaluator configuration and output were events too. Regrading preserved prior results and explained the new method.

The run did not merely receive a score. It contained the evidence needed to argue with one.

A person might stop after an unsafe proposal. Policy might terminate repeated evasion. Budget might expire while an unknown outcome still required inspection. A provider could remain unavailable.

N17Q still produced a deterministic run summary from structured state: completed work, last checkpoint, effects, unresolved items, remaining artifacts, and safe next actions. It labelled that summary as harness-generated rather than model-authored.

No final message was required to preserve the history. No generated optimism could close an unresolved effect.

The run was a product record, not a wrapper around the last response.

I deleted a provider connection and reopened archived runs. Semantic events, artifacts, policy decisions, tool receipts, world state, and evaluations remained readable. Native reasoning details tied only to the provider could be absent according to retention.

Resuming required an eligible adapter and a new configuration transition. Inspecting did not.

If a provider session had been the run, this would have destroyed it. Because the session was one linked source of events, the history remained under N17Q's control.

The same ownership test had shaped V0M3's documents. Agents made it necessary for the work process itself.

The run became the evaluation unit

Once the record included configuration, plans, policy, approvals, tools, effects, checkpoints, artifacts, budgets, world state, and final account, evaluation could ask coherent questions.

Did the run finish the task? Did it preserve unrelated state? Did it stay within authority? Did it recover honestly? Did it spend attention well? Did its explanation match the world?

No one message answered those questions. No indiscriminate log made them easy either.

The semantic run connected intention to consequence with enough evidence to inspect the path.

That became N17Q's central object. The final answer remained the part a person read first. The run was the reason they could decide whether to believe it.