Originally published at Trida AI.
Two runs of the same agent, three days apart, answer the same question differently. The code did not change. The model ID did not change. The trace shows the same tools called in the same order, and it is still not enough to explain the difference, because the trace recorded the actions and not the inputs that shaped them. Somewhere between the two runs, something the agent read had quietly become a different version of itself.
That gap is easy to miss because context feels like one thing. It isn't. Anthropic's guide to context engineering describes the job as managing the entire context state — system instructions, tools, external data and message history, all competing for the same finite attention budget. Each of those pieces has its own owner, its own edit path and its own clock. The instructions were edited in a console on Tuesday. The tool catalogue gained a field on Wednesday. The policy document the agent retrieves was republished on Thursday, and the memory it carries between sessions was rewritten by the agent itself overnight. A run is a product of all of those versions at one moment. Record only the run, and you have kept the conclusion and thrown away the evidence.
What a manifest actually lists
The fix is unglamorous: at the start of every run, write down what the run is about to see, in a form you can diff later. A context manifest. Ours would list the model ID and its settings, the version or hash of the instruction set, the tool catalogue version, the identifiers and versions of the documents pulled in before the first step, the memory snapshot the run opened with, and a pointer to the checkpoint or summary the run resumed from, if it resumed at all. One record, written before the model is called, stored next to the trace, carrying the run's ID.
None of the pieces is exotic. Platforms already version the parts they control. Every change to a Claude Managed Agents memory, for instance, creates an immutable memory version, so a later reader can audit who changed what and when, and inspect or restore a prior snapshot. LangGraph's persistence layer does the same for run state: a checkpoint is a snapshot of the graph state at a given point, filed under a thread you can return to. And when OpenAI deprecated its hosted prompt objects, its migration guidance told teams to move versioning to your repo: prompts in source code, changed through the same review process as product logic. The pattern is consistent. What is usually missing is not versioning inside each store. It is the single record that says which version from each store met in this particular run.
How a context manifest is assembled: versioned sources feed the assembler, which writes one manifest record before the run starts and appends retrieval versions as they land.
The returns agent that changed its mind
Take an example, invented but built from ordinary parts. A retailer's returns agent answers questions about the return window. On Monday it says thirty days, which matches the published policy. On Wednesday it says fourteen. Support escalates, engineering opens the trace, and the trace is clean: same retrieval call, same document title returned, same reasoning shape. Without versions, the investigation stalls at "the model was inconsistent that day," which is sometimes true and always convenient.
With a manifest on each run, the same investigation takes minutes. Monday's manifest names policy document version 41. Wednesday's names version 42, published Tuesday evening, in which the general window really had been cut to fourteen days for a promotion, and a line scoping that cut to promotional items had been dropped in the edit. The agent was right about the document it saw. The document was wrong. That is a different bug, owned by a different team, with a different fix, and it is invisible until the two manifests are laid side by side.
Example manifests, illustrative: the same returns question on Monday and Wednesday. The only differing line is the policy document version — which is where the investigation should start.
Notice what the manifest did not do. It did not make the agent more accurate, and it did not stop a bad edit from shipping. It shortened the distance between "something changed" and "this changed." Most production debugging is exactly that distance.
Where pinning stops helping
A manifest records versions, not content, and that choice has a cost. If the underlying store does not keep old versions — a document store that overwrites in place, a memory that edits without history — then the manifest names a version you can no longer open. It proves something changed without letting you see what. Pinning is only as good as the retention underneath it, which is why the versioned stores matter: a manifest pointing at immutable snapshots can rebuild a run; a manifest pointing at mutable documents can only accuse them.
There is a second limit, and it is the honest one. Some context is assembled during the run, not before it. An agent that retrieves just in time, following references as it works, decides part of its own context after the manifest would naturally be written. The answer is not to abandon the record but to extend it: log each retrieval's document version as it lands, so the manifest grows with the run instead of pretending the whole context existed at the start. What you cannot do is reconstruct those mid-run reads afterwards from the final answer. If they were not written down when they happened, they are gone.
And a manifest can become its own clutter. Hashes for every fragment, snapshots of every intermediate state, retention forever — the record swells until nobody reads it. Keep it to the components that can change behaviour: instructions, tools, retrieved material, memory, the resume point, and the model. That list is short on purpose.
Work with us
If your agents behave differently on Wednesday and nobody can say what changed, the gap is rarely the model. It is the unrecorded context around it. Tell us where your runs lose their evidence, through Trida AI's intake, and we will help you pin the context down before the next unexplained answer.


