Stop stuffing your context window until it bursts. A new architectural pattern called Chain of Recall is gaining traction among agent builders who need long-running memory without the token bloat. Proposed in the DeepSeek Harness article Exploring Super-agent Design (published Nov 1, 2026), this approach treats memory as a graph of stable IDs rather than a linear text stream. It is not a product you download; it is a design pattern you implement, currently prototyped in the dsh-superagent-prototype.

The Context Window Crisis

Long-running agents, like those monitoring GitHub CI or chat threads, hit a wall when events pile up. Traditional fixes fail: storing everything costs a fortune, summarizing loses critical details like error codes, and vector similarity search often misses the mark when queries don't match embeddings. Chain of Recall solves this by keeping only lightweight pointers in the promptβ€”IDs, brief summaries, and neighbor referencesβ€”while spilling the heavy logs to external storage. The agent retrieves full context only when needed, via precise ID lookups.

How the Reference Graph Works

The system relies on three immutable object types: Triggers (events like CI failures), Threads (related events like a PR), and Workers (agent sessions). These form a reference graph. When a user asks why retry logic was added to a payments client on Friday, the agent doesn’t scan three days of chat. It hops from a Thread ID to a Worker ID, then to a specific Trigger ID containing the CI error. This multi-hop walk retrieves the exact root cause in three API calls, ensuring accuracy without keeping stale data in the prompt.

Not a Replacement for RAG

Don't confuse Chain of Recall with Retrieval-Augmented Generation (RAG). RAG asks what is similar to this, while Chain of Recall asks what is linked to this. The former is probabilistic and fuzzy; the latter is deterministic and precise. The source material notes that vector search is still better for unstructured documents, but for event-driven workflows like PRs or tickets, ID-based recall is superior. In practice, builders are encouraged to hybridize: use vector search to find a starting Thread ID, then use Chain of Recall to traverse the exact history.

API Contracts Are Non-Negotiable

This pattern lives or dies by its backend API. If an ID changes or returns a 200 with an empty object instead of a 404, the agent hallucinates. The design mandates four strict contracts: IDs must never mutate, fetch-by-ID must be exact (not approximate), missing IDs must fail loudly with 404s, and cursors must page without gaps. A silent failure here breaks the entire memory chain. Automated tests are essential to verify that a Thread ID returned today resolves to the same record next month, even after system migrations.

Key Takeaways

  • Chain of Recall is a design pattern, not a released product, using stable IDs to traverse memory graphs instead of stuffing context windows.
  • It differs from RAG by asking what is linked rather than what is similar, offering deterministic precision for event-driven workflows like PRs and CI runs.
  • Implementation requires strict API contracts: immutable IDs, exact fetch-by-ID responses, loud 404 failures for missing data, and gapless cursor pagination.
  • The pattern supports hybrid approaches, such as using vector search to locate a starting Thread ID before traversing the specific history via ID lookups.

The Bottom Line

Chain of Recall is a pragmatic, builder-focused solution that trades the fuzzy convenience of RAG for the rigid reliability of graph traversal. If your agents are hallucinating due to context rot, stop summarizing and start indexing: build the API contracts first, because a memory system without deterministic lookups is just a guessing game.