Faithful Computation Trace / Provenance Record.

Abella E — Wed, 12 Aug 2026 21:48:23 +0000

Why Chain-of-Thought Is Unfaithful by Construction

TL;DR: Chain-of-thought is not a trace. It is text generated by the same system you are trying to audit. A faithful system should return a computation trace / provenance record instead.

The problem

Chain-of-thought is usually shaped like this:

generate(reasoning_text | answer, policy, memory, prompt, incentives)

That is not the computation.

It is a narrative about the computation.
And because it is emitted through the same single channel as the answer, it has the same fault-tolerance problem as any n=1 system:

n ≥ 3f + 1
n = 1
therefore f ≤ 0

A single model channel tolerates zero faulty narrators.

If the answer is wrong, strategic, post-hoc, policy-shaped, or memory-contaminated, asking that same channel “why?” does not magically create auditability.

It just creates another output.
What faithful explainability looks like
Faithful explainability should not ask the model to write a story.
It should return the computation’s own record.
In .me, a derived value can be inspected like this:
me["!"].explain("order.total")
The result is not generated prose.
*It is a structured trace:
*

{
  "path": "order.total",
  "value": 1000,
  "expr": "price * quantity",
  "derivation": {
    "expression": "price * quantity",
    "inputs": [
      {
        "label": "price",
        "path": "order.price",
        "value": 200,
        "origin": "public",
        "masked": false
      },
      {
        "label": "quantity",
        "path": "order.quantity",
        "value": 5,
        "origin": "public",
        "masked": false
      }
    ]
  },
  "meta": {
    "dependsOn": ["order.price", "order.quantity"],
    "k": 1,
    "recomputed": ["order.total"],
    "sourcePath": "order.price"
  }
}

That is the difference:
CoT: "Here is why I probably answered this way."
Trace: "Here is the expression, the inputs, and the dependency path that produced the value."

The important distinction

A chain-of-thought explanation is generated.
A provenance record is returned.
That means it can be checked:
expr: price * quantity
inputs: price = 200, quantity = 5
recompute: 200 * 5 = 1000
value: 1000
No persuasion layer required.
Secret inputs do not have to leak
Faithful traces do not mean dumping all private state.
If a dependency comes from a stealth/secret branch, .me can preserve the dependency shape while masking the value:

{
  "label": "fuel_price",
  "path": "finance.fuel_price",
  "value": "●●●●",
  "origin": "stealth",
  "masked": true
}

So the trace can still say:
this output depended on finance.fuel_price
without revealing:
the private fuel price was 24.5

That is the useful middle ground: audit structure without leaking protected content.
Proof, not vibes
Next to the trace, .me also exposes a proof primitive:

await me["!"].prove({
  rootNamespace: "netget.me",
  challenge: "audit-2026"
})

This returns an Ed25519-signed proof of the active branch expression against the root namespace.
It does not replace the trace. It signs the identity/branch binding around the computation surface.
The point is the same: make the system return verifiable structure, not vibes.

Performance

This is practical because the runtime keeps an inverted dependency index:

source path -> dependent derived paths

So when one input changes, the kernel does not scan the whole tree.

It follows the dependency frontier.
In the current .me benchmark for 3000 nodes, one local run measured:

baseline p95: 0.0151ms
with explain p95: 0.0201ms
overhead: +0.0050ms

The exact number varies by machine/run, but the important part is architectural: explainability is a lookup over the computation record, not a second model generation pass.
What to return instead of chain-of-thought
Do not return hidden reasoning text as if it were ground truth.
Return a provenance object:

{
  value,
  expr,
  derivation: {
    expression,
    inputs
  },
  meta: {
    dependsOn,
    recomputed,
    sourcePath
  }
}

If you need human-readable explanation, generate it from this object.
But the object is the audit surface.
The prose is just a view.

The principle

Faithful explainability is not:

"Tell me what you were thinking."

It is:

"Return the computation record."

Chain-of-thought asks the narrator to be honest.
A provenance record makes the computation inspectable.
That is the difference.

missed the degenerate case? Lamport: n 3f+1 Centralized AI: n=1 Result: f 0 Zero-trust with n=1 is a PDF. The math says you can't. Source: suign.github.io/Equations.html

Abella E — Wed, 12 Aug 2026 04:22:24 +0000

Sui Gn

Aug 12

Applying n=1 f 0 to a single AI channel.

2 min read

DEV Community: Abella E