Thinking by Writing

The previous articles established the Real (tier zero), captured evidence (tier one), and the four capture modes — commit, assert, measure, formalise. Tier one is not ground truth in the tier-zero sense — it is substrate: emissions and measurements when logged. Between substrate and the Real sits a gap every capture mode inherits.

So far we have spoken as if the hardest gap were between an inner commitment in an agent’s head and the mark on the record — signature, keystroke, click. That picture is true for forms and signatures. It is incomplete for how agents actually think.

This article asks: what if the decision, at the finest grain we can hold, is the symbol projected — the word in working memory, the token written to the log — not a ghost state behind it that the symbol only reports? And what follows when an AI agent thinks by writing the same way?

The same shape

Consider autoregressive inference — brain or LLM — with the loop drawn on state, not on symbols:

          infer               infer
[state_n] ────► [state_{n+1}] ────► [state_{n+2}] ── …   (L-α)
    │                   │
    └────► symbol_n     └────► symbol_{n+1}   (L-β when captured)
     project            project

Inference (L-α) advances state. Projection branches sideways: a word or token for conscious access, speech, or the log — not the arrow that drives the next infer step.

What closes the loop is not the emitted symbol read back as symbol. It is the inference product in embedding-like form — sub-symbolic state already carried inside state_{n+1}:

Same picture for both: the loop runs on carriers in state space; L-β is readout.

The brain is not an exception. A projected word can perturb the next state — inner speech drives re-entrant loops — but that influence is still L-α signal, not symbol chaining symbol. Implementations append tokens as vectors; brains re-enter as neural activity. Neither is the glyph qua meaning closing the loop.

There is no ghost deciding in hidden silence before expression. Inner monologue and chain of thought (CoT) are the accessible surface; step-to-step drive remains state-to-state inference beneath.

Words in the head are not a complete dump of all neural activity. Neither is chain of thought (CoT) a dump of all activations. The decision-relevant stream we can hold may still be the symbolic stream — with L-α as computation that infers the next state, not as a second, deeper kind of “decision” with stronger standing.

Decision-as-emission: at the finest grain we can hold, a decision is a projected emission — a word, a token, a mark — that indexes a step in the inference trajectory. Sub-symbolic inference advances state; L-β is projection for access and capture, not direct semantic feedback.

Four layers

To keep the tiers straight, distinguish four layers:

Tier zero is the Real, not the stream inside the agent. Tier one is what a system can hold: emissions and measurements, faithfully recorded.

The sentence “no system ever holds it directly” must therefore split:

• No system holds the Real directly — only claims and captures about it.
• Systems can hold the emission stream directly when instrumentation logs each symbol at creation — AI more completely than human, if policy requires it.

The old conflation — tier-zero inner commitment behind tier-one expression — gives way to: tier-zero world; tier-one emissions (and the gaps between stream and summary).

Micro-decisions and macro-commitments

Article 04 introduced two boundaries. They survive; their meaning sharpens.

Assertion boundary. An emission is recorded as conjecture — the act of projecting at full strength, its content at an honest tier. Each token in a chain of thought (CoT) trace conceptually indexes a micro-decision; logging policy may batch many tokens into one assert event without losing what the commitment boundary needs (see Capturing L-β on the log below).

Action boundary. A macro-commitment produces an irrevocable external effect: a tool call, a message sent, a signature with force, a side effect in the world. The harness’s ResponseSent is the AI analogue of the human’s signed form.

Generating tokens is not the same as sending the answer. Computing is not the same as committing. But both are emissions — only the second crosses the action boundary.

Forces, reframed:

Why AI capture can be more direct

Article 06 listed gaps between expression and binding. Those describe L-γ macro-expression — especially when it summarizes a stream the system never saw.

For an instrumented AI agent, L-β can be logged at generation — model id, checkpoint, prompt hash, tool I/O, temperature, seed, and the symbolic stream, batched to a practical grain (TokenSequenceEmitted, ThoughtEmitted, or a single ChainOfThoughtEmitted before send). That is not second-hand. It is capture of the stream as produced, at finer effective resolution than most human records, which jump straight from private monologue to signature.

This does not make tokens tier-zero truth about the world. It makes them tier-one atoms of what the agent emitted — whose content remains defeasible, tier 2 and above.

Capturing L-β on the log

Four Capture Modes classifies assert as forward-without-bind. This section specifies how to capture L-β honestly on the event log — envelope fields, batch grain, and assert event types. Capture mode is one question; shape of the thought stream is another (reasoning topology below).

Envelope — correlation, causation, context

Every tier-one event carries the shared envelope from art. 07. For thought asserts, three fields are load-bearing:

• correlationId — one conversation, case, or run family (including parallel branches).
• causationId — the prior event or API requestId that triggered this thought; links messages in a dialogue.
• contextRef — harness / MCP snapshot (tools, resources, policy) at capture time; pass forward or reference a ContextAttached assert so later steps do not misread stripped context.

Assert event types (batched)

# Theoretical limit — one micro-decision per token; practically infeasible at volume
# type: TokenEmitted  (+ full envelope)

L-β pragmatism. Each token is a conceptual micro-decision; one event per token adds no load-bearing epistemic gain at the commitment boundary when batched asserts carry runId, step range, runner provenance, and replay hash. TokenEmitted remains the theoretical limit, not a production default.

# TokenSequenceEmitted — sentence or decode chunk (+ envelope)
type: TokenSequenceEmitted
schemaVersion: 1
runId: string
startStepIndex: integer
endStepIndex: integer
tokenTexts: string[]          # or contentHash + blobRef
runnerId: string
runnerVersion: string
runnerConfigHash: string

# ThoughtEmitted — one legible step (+ envelope)
type: ThoughtEmitted
schemaVersion: 1
runId: string
thoughtIndex: integer
thoughtText: string
parentThoughtRefs: string[]
precedingEventRefs: string[]
runnerId: string
runnerVersion: string

# ChainOfThoughtEmitted — linear trace before send (+ envelope)
type: ChainOfThoughtEmitted
schemaVersion: 1
runId: string
topology: chain
runnerId: string
runnerVersion: string
segmentCount: integer
segments:
  - { kind: thought, text: string, sourceEventId: string | null }
  - { kind: tool_call, toolName: string, inputHash: string, outputEventRef: string }
contentHash: string

# ThoughtGraphEmitted — tree, DAG, or network (+ envelope)
type: ThoughtGraphEmitted
schemaVersion: 1
runId: string
topology: tree | dag | network
nodes:
  - { nodeId: string, text: string, parentNodeIds: string[] }
edges:
  - { from: string, to: string, kind: derives | aggregates | refines | broadcasts }
contentHash: string
runnerId: string
runnerVersion: string

Choose grain by policy and severity. The terminal assert (or ReasoningAsserted) is what the commit references — see The Moment of Commitment.

Why capture chain of thought

A preserved trace is explainability — for auditors and for continuous improvement. When a bind fails later, replay finds the faulty step and yields precise negative feedback for model training and harness policy. Good traces can be compressed into reusable patterns over time.

Reasoning topology

Chain of thought (CoT) is the linear case — one path of legible steps. Reasoning is often richer: branch, merge, loop, parallel perspectives. External LLM literature names several reasoning topologies (prompting inside one model):

Survey and taxonomy: Demystifying Chains, Trees, and Graphs of Thoughts — topology (path / tree / graph) vs reasoning schedule (how it is traversed).

Not standard paper titles: Mesh of Thought, Loop of Thought, Hyper-Thought. Loops appear as feedback edges in GoT, not a separate brand.

Broadcast on the log

Event-sourced asserts add what single-model prompting papers underplay: publishing a thought is broadcast. Humans approximate this by speaking; on the log, ThoughtEmitted with correlationId and causationId can trigger other agents — branches that converge, diverge, or recurse. That is a graph of thought events, not a flattened linear CoT narrative. Name topology honestly and link nodes with parentThoughtRefs / causationId.

What can still go wrong

Direct capture narrows some gaps; it does not abolish epistemics.

Unfaithful stream. Visible chain of thought (CoT) may not reflect sub-symbolic computation — trained legibility, post-hoc narration. Human inner speech has the same structural risk. Treat as insincere commitment or capture-chain distortion at the narration layer, not as proof of a hidden “true” decision behind the stream.

Stream-to-summary collapse. A macro-commitment — final answer, signed form — recorded without the L-β stream that produced it. The radiologist signs a conclusion without think-aloud; the harness sends ResponseSent and deletes chain of thought (CoT). The record shows what was committed at L-γ, not how the stream argued. This is second-hand commitment aimed at one’s own earlier self — or at one’s own model run.

Harness cut. Hidden scratchpad, truncated trace, logging policy that retains only L-γ — direct capture is conditional on instrumentation. Failure to log is lost certainty when replay could have preserved the stream.

Stochastic runs. With sampling, the decision is this run’s stream — identity (runId, step range, content hash) — not a unique necessary path. Same for human: this utterance at this moment.

Content ≠ world. Logging every token does not tell you whether the patient has pneumonia. It tells you what the agent said, step by step.

Human and machine — complementary limits

Two asymmetries follow, developed further in later articles:

Accountability. Humans can suffer consequences — pain, loss, remorse — in a way machines do not. Operational accountability can be assigned to a credential (decidedBy: "model-v3"); moral accountability may require a subject with stake. That is why the action boundary for high-severity decisions often remains human even when the machine explains better.

Explainability. Instrumented AI can exceed human introspection for L-β: replay, diff, systematic correction from chain of thought (CoT) trace — and, when a bind fails later, pinpoint the thinking error for model training and harness tuning (Capturing L-β on the log). Humans carry purpose — desire, care, ends not fully specifiable — that explicit goals and harness loops do not generate. Machines may be superior executors and explainers on some tasks; humans remain load-bearing for purpose and for commitment that stake makes real.

Neither replaces the other. Do not confuse machine explainability with machine accountability. Do not confuse human purpose with human infallibility.

Diagram

Unified inference loop (brain and LLM — same shape; carriers differ):

Capture stack (tiers and layers):

What systems should do

When decisions matter:

1. Log L-β when AI is involved — retain chain of thought (CoT) with provenance at a practical batch grain; bind every L-γ event to runId and trace refs — not one event per token unless policy and volume truly warrant it.
2. Never treat L-γ alone as the whole decision — macro-commitment without stream is stream-to-summary collapse.
3. Keep act and content separate — each emission is tier-one assert or commit capture as an act; what it claims about the world carries its own tier.
4. Cross the action boundary explicitly — ResponseSent, tool invocation, human signature — as its own event, not an implied side effect of generation.
5. For humans, admit the asymmetry — we rarely log L-β; design L-γ (forms, signatures, speech acts) knowing they summarize a private stream we cannot recover.

Sub-symbolic computation remains ephemeral and reproducible in principle. The symbolic stream, when it matters, should not be.

What this prepares

We now have a finer picture of what an atom of decision is: an emission at L-β or L-γ, tier one when logged, always distinct from tier-zero Real and from the sub-symbolic computation beneath.

The next article is the line where conjecture becomes binding consequence: The Moment of Commitment.