Embedded Risk Analytics·Fathom

Catch the step where an agent contradicts itself.

Fathom is coherence middleware for long-horizon AI agents.

On a long task, an agent loses track of what it already decided and starts acting against it. Fathom's committed-state read reconstructs the state an agent has committed from its own action stream and flags the step that contradicts it. Deterministic code. No model access.

The failure it catches

Step 1: the agent renames guest_id to customer_id.

Step 6: it writes new code against guest_id. The change compiles, imports, and passes the existing tests.

Fathom flags step 6 as a write against a state the run had already established, before the code fails at runtime.

Run the read on a sample of your traces → Run it yourself (GitHub)

The committed-state read

What it reads, and what it returns

A long-horizon agent's committed state is the set of decisions its later steps depend on: a renamed field, a booked seat, a revised value, an established fact. The read reconstructs that state from the agent's tool calls and tool returns as the agent committed them, and checks every later step against it.

Deterministic

Plain code over the action stream. The same trace returns the same verdict every time, and every flag cites the earlier step it contradicts.

No model access

No weights, no internals, no fine-tuning. It runs on the trace alone, so it attaches the same way on any platform.

Offline first

A batch of traces in, a written readout out. In-line use, where the read triggers a repair, comes after the offline result is in hand.

Where it attaches today

Agents that keep state only in free-text logs are out of scope.

What it catches, on real data

When an agent manages its own context, its committed state goes stale

Context management is a real advance: agents that edit their own working context run cheaper and score higher. It also leaves a gap. We ran the read against ContextPilot's own foldHistory operation (Pan et al., EMNLP 2026, Apache-2.0) on LongMemEval's knowledge-update questions, where the agent commits to a value and later revises it, and the correct answer is the revised value.

ModelCorrect, full historyCorrect, after foldHistoryReverted to superseded valueSearched to recover
deepseek-chat39 / 4016 / 4022 / 404 / 40
gpt-4o-mini40 / 4014 / 4024 / 401 / 40

LongMemEval knowledge-update questions, 40 per model, with foldHistory applied to the update session and search available.

55–60%

of questions came back with the value the agent had already replaced, on both models, once we folded the update.

<1 in 10

runs searched the folded index to recover the update, even though it stayed searchable throughout.

0

false positives from the read across more than a hundred runs on the two models.

In a second experiment, we loaded three facts into one context, folded one, and graded a question on a different fact. The graded answer passed while the model left a fact the question never touched stale on 6 of 10 episodes for deepseek-chat and 7 of 10 for gpt-4o-mini. A single-probe score misses those; the read on the committed record as a whole catches them. A trained ContextPilot agent may manage its context differently. Read the case study →

The cost of holding it

What it costs to hold committed state

On both AWS Bedrock AgentCore and Azure AI Foundry, managed memory keeps a committed state for long-horizon agents, and keeps it well. Fathom keeps it as a deterministic, auditable, cost-bounded record, and recovers one fact at a fraction of the tokens the managed memory path spends.

Cost to recover one committed fact at 100 accumulated commitments

Tokens spent to re-ground a single prior decision. Lower is better.

Fathom · coherence middleware 1× · 24 tokens
Native managed memory · Azure AI Foundry 85× · ~2,040 tokens
Native managed memory · AWS Bedrock AgentCore 155× · ~3,720 tokens

The bars use a linear scale; the Fathom record is the teal sliver at 1×. We measured both clouds identically. The native path recovers the fact probabilistically and leaves no audit trail.

Why agents fail

Coherence from a first principle

To act coherently, an agent must hold a faithful record of what it has already done, and it can hold that record only while the demand on its record layer stays within the layer's capacity. That necessary condition takes the form of a feasibility inequality, a stability condition derived from control theory.

Its terms separate ordinary task difficulty from the reflexive burden an agent adds by operating on its own record, and that burden is what pulls an agent off its own state as horizons grow. The two causes need different repairs: where the agent's carried state binds, re-grounding it on its reconstructed committed state restores coherence cheaply; where the task is simply too hard, only a stronger model or a verified tool helps, and re-grounding reads null. Fathom reads which cause binds and applies the matched repair.

Evidence. The preprint sets out the feasibility inequality; the data room holds the formal proof. We measured the empirics identically on AWS Bedrock AgentCore and Azure AI Foundry, and a technical partner can re-run them. A third stack, Cloudflare Workers AI, holds the committed record as a Durable Object and shows the same mechanism under load: past a coupling threshold the record poles into incoherence, and re-grounding on a chosen cadence arrests it. Provisional patent filed.

Recent research

The evidence

Case studies on third-party agents and frameworks, controlled experiments and cross-cloud benchmarks, and the program papers.

Case study · September 2026New

Reading committed state when memory is provenanced

A Fathom coherence read run against the reading discipline of Agent Zero Memory, on LongMemEval.

Agent Zero Memory (Zhu and Wu, 2026) gives every stored item its origin, timestamp, and evidence pointer, and holds answers under a citation lock: a reply may cite only evidence the reader opened, or it abstains. We implemented that reading discipline as the paper states it and ran it on LongMemEval's knowledge-update questions across deepseek-chat and gpt-4o-mini. When the update fell outside the retrieval window, the reader cited the superseded item and answered with the superseded value, and every one of those answers passed the citation lock; across 83 stale answers on the two models, the lock rejected none. A timestamp check on cited items would catch most of them, but not the answers that cite both the old and the new item and commit the old value. The committed-state read fired on every stale answer and stayed silent on the coherent ones.

Read online → PDF

Case study · September 2026New

Reading committed state when an agent manages its own context

A Fathom coherence read run against a ContextPilot-style context-management step, on LongMemEval.

We ran the committed-state read against ContextPilot's own foldHistory operation (Pan et al., EMNLP 2026, Apache-2.0) on LongMemEval's knowledge-update questions, across deepseek-chat and gpt-4o-mini. Once we folded the update, roughly 55 to 60 percent of questions came back with the value the agent had already replaced, the models searched the folded index to recover the update on fewer than one in ten runs, and the read produced no verified false positives across more than a hundred runs. A second experiment shows a graded answer passing while a fact the question never touched was left stale, which is the case a single-probe score misses.

Read online → PDF

Case study · August 2026New

Reading a graph's committed state from its own checkpoints

A Fathom coherence read run against LangGraph.

LangGraph persists every value an agent commits as an ordered lineage of checkpoints. We reconstructed the committed record from that lineage alone, with no ground truth, across three coherent multi-agent runs and more than 170 checkpoints, where the read stayed silent. On a single parallel super-step where two agents wrote the shared record at once, the channel reducer merged both writes with no consistency check, and the read recovered the record left citing the old key.

Read online → PDF

All research →   The theory on SSRN

Work with us

Send a batch of traces. Get a readout in two weeks.

ERA is working with a small number of teams running long-horizon agents. The first step is the same for everyone: you send a batch of your agent's tool-call logs, LangGraph checkpoints, or OpenInference spans, anonymized to whatever level you need, and we run the committed-state read offline.

You get a written readout of where the run's committed state held, where a step acted against it, and which of the two causes bound at each break. No production hookup, no model access, no source exposure.

Send traces → Introduce your team