Agent Archaeology: The Thread Is Part of the Source

It is Monday morning and a colleague hands you a branch, an issue link and a transcript of their conversation with an agent. They are going on holiday. Good luck.
You have what they produced. You do not have how they got there — the two approaches tried and abandoned, the constraint someone mentioned in a meeting, the reason the obvious design was rejected six months ago by someone who has since left. So you start digging through commits for clues. Agent archaeology is the name Richard Feldman gave that digging in a talk at AI Engineer published on 9 November 2026, and his point about it is sharper than "handoffs are hard": the information existed. Something threw it away.
TL;DR — The conversation with the agent is now part of how software gets made, and almost none of it survives a handoff. Commits record state; the thread records derivation, and it lives in one person's client on one person's machine. Zed's answer is to make the thread the shared unit of work and retire pull requests. The portable half of that answer is cheaper and available today: write the decision down — what was chosen, what was rejected, why — in plain markdown your teammates' agents can read, which is what a workspace like MDflow is for. Start free.
What is agent archaeology?
Agent archaeology is reconstructing the reasoning behind a change from artefacts that were never designed to carry it. Commit messages, branch names, a Slack thread someone screenshotted, a transcript pasted into a gist. You read tea leaves, and when the leaves run out you guess.
Feldman's framing in the talk is a jigsaw with pieces missing. You can see most of the picture. You cannot answer the one question you actually have — is that a climbing wall or a mushroom? — because the piece that settles it is gone. His worked example is the six-month-old decision: there is a problem now, you can see how the feature was built, and you cannot tell whether the thing you are about to try was already considered and rejected for a reason you would want to know.
What makes this newly acute is a change in where the work happens. Five years ago most of the thinking was in the code, because typing the code was the slow part. Now a large share of it is in the conversation, and Feldman's point is that the conversation and the code changes can no longer be pulled apart. The artefact we version and the artefact that explains it have come apart.
So the handoff is lossy by construction. You transmit the state and leave the recipient to re-derive the process — which is exactly the split we wrote about in Process Data vs State Data, seen here from the team's side rather than the model's.
Why the thread became part of the source
Because the decisions now live in it, and nothing else records them.
Three things reliably fall out of the gap between a thread and a commit:
- Rejected alternatives. An agent tries an approach, it does not work, the agent does not commit it. The attempt is invisible to everyone afterwards, including the next agent, which may cheerfully try it again.
- The weight of a decision. Feldman makes this point in the demo and it is the subtlest one. When a teammate answers a design question with a one-line preference, the thread records that it was a one-line preference, not a market-research conclusion. A commit records neither the answer nor its weight — so the next reader treats a coin flip and a hard constraint identically.
- Context from outside the tool. The question asked in a meeting, the answer given in a direct message, the thing one person knows and nobody wrote down. This is the implicit knowledge problem, and an agent cannot infer any of it.
Zed's own framing of the consequence is the line worth keeping: "Why should your teammate's agent have to guess how you got there?"
Zed's answer: make the thread the unit of work
Feldman works on Delta, built by Zed Industries — the team behind the Zed editor. Its bet is structural: if the thread is where the decisions are, make the thread the thing you share, review and land, rather than a by-product you screenshot.
What that looks like in practice, from the talk's demo:
- You invite people into a thread, not into a diff. A teammate joining gets the same worktrees on their own machine and can keep working with the agent where you left off. Feldman's own example happened while he was writing the talk: a colleague at-mentioned him from inside a thread, he answered, and the exchange became part of the thread the agent could see — rather than a Slack message disconnected from the work it was about.
- Review happens in the conversation. Line-level comments on the diff go to the agent with the line as context; there is also a formal approve/reject flow for teams that need a recorded sign-off.
- New joiners ask the agent, not the transcript. When Feldman was pulled into a colleague's thread, he opened a sub-thread and asked the agent for an overview of the approach. Sub-threads exist precisely so a tangent does not derail the main conversation.
- Terminal output syncs read-only. You can watch a teammate's terminal; you cannot type into it, which Feldman notes would be remote code execution on their machine.
The numbers, from Zed's public-beta announcement of 16 September 2026 rather than the talk: Zed disabled pull requests on Delta's own repository, and 33 people landed 570 changes to main in the period since. Under the hood, DeltaDB extends Git's content-based versioning with incremental deltas, recording the edits between commits alongside the messages from humans and agents — commits remain the checkpoints, and the work between them is retained instead of discarded. Zed calls the resulting way of working continuous engineering.
Two caveats, and they matter. Asked about scale in the talk's Q&A, Feldman said it has not been stress-tested much beyond 30–40 person standups in a single thread. And per the announcement, zed-industries/zed itself stays on GitHub, because that is where the community files issues — contributors can work in Delta and still submit through GitHub, and teammates who never open Delta see an ordinary Git repository. (At the time of the talk Feldman described a private beta with pricing undecided; the September announcement describes a free public beta with paid plans coming and a free tier promised to remain.)
What a preserved thread still does not give you
A complete record is not the same as a readable answer, and the talk quietly concedes it.
Look again at the best moment in the demo. Feldman is pulled into a colleague's thread, and the first thing he does is not read it. He asks the agent for a summary. That is the correct move — the thread is long, chronological and full of dead ends — but it tells you what the thread actually is: excellent raw material, not an answer. The summary is what gets consumed.
Which raises the obvious question: if a distillation is what people read, why generate it on demand, repeatedly, from a thread that only exists inside one product?
Three limits follow:
- Reconstruction costs tokens and varies. Every arriving person re-summarises the same thread, and no two summaries agree on what mattered.
- The thread is scoped to the work, not to the decision. A constraint discovered in a billing thread is relevant to the next three projects. Nobody will find it there.
- Reading it means joining it. Delta runs on the desktop, on the web without a download, and on a mobile browser, and Zed encourages contributors to share threads alongside their pull requests — so this is softer than a closed silo. But a reader still has to be in Delta, in that thread. Asked about automation in the Q&A, Feldman said there is no bot API at this point. A contributor arriving through GitHub, or a hosted agent holding an API token, does not read it. The pull request had one property that is easy to undervalue: everyone could open it.
None of this is an argument against sharing threads. It is an argument that the durable artefact is a different artefact: a short, dated record of what was decided and what was rejected, written once, where everyone's agent can read it.
But prose was supposed to be the thinnest layer
We recently argued the opposite-looking case in Lint Rules Beat Rules Files: prose is unenforceable and goes stale, and agents use markdown as a ledger of excuses for not doing the right thing. Now here is a post telling you to write more prose. Worth resolving rather than hoping nobody notices.
The two claims survive together because they are about different kinds of writing.
The objection in that post was to prose that governs future behaviour — a rule, an instruction, a convention — because nothing enforces it and a check always would. A decision record makes no claim on the future. It says: on this date, we considered A and B, chose A, and here is what ruled B out. That is the judgment layer Lauren Tan's own argument explicitly reserved for prose, because no linter can derive a rejected alternative or the reason it was rejected.
The staleness objection cuts differently too. A rule that silently stops being true is dangerous. A dated record of what was believed at the time cannot go stale, because it never claimed to be current. It claims to be history — which is the thing that was missing.
The overlap is real in one place, and it is worth being honest about it: a decision record that quietly turns into a standing instruction does become unenforceable prose. Write what was decided. Do not write what everyone must now always do.
Which teams benefit most
- Teams spanning time zones. The asynchronous handoff is the canonical case, and the one with no option of walking over to ask.
- Teams with high agent-written volume. The more code arrives per day, the less of it any human carries the reasoning for.
- Regulated or audited work. "Someone approved this" is recoverable from a pull request; "this alternative was evaluated and rejected because…" usually is not.
- Open source and contractor-heavy projects. Contributors arrive with no context, their own agents and no access to anyone's thread history.
- Long-lived products. The six-month-old decision Feldman describes is a property of codebases that outlive their authors' memories — which is all of them.
- Teams whose agents are not all the same. One person on Claude Code, one on Codex, one in an IDE. The record has to live outside all of them, which is the model-agnostic argument applied to context.
How MDflow fits
Start with the boundary, because this topic cuts against the product. MDflow does not capture threads. It does not watch your agent session, does not record your terminal, and will not replicate a worktree. If what you want is Delta, use Delta. MDflow is the other half: the durable, portable place the distilled decision lands, readable by any agent with a token and by any human with a browser.
What lines up today
- A shared workspace every teammate's agent can reach. Teams gives a Team account its own workspaces with per-member access set to no access, read-only, or read/write/delete. Team access tokens (
mdt_…) are bound to one Team account and to named workspaces, capped read-only or read-and-write, and re-checked against live membership on every request — so a colleague's agent reads the same decision record you wrote, under their own permissions, not yours. - Retrieval by purpose, not by filename. A folder description is the primary ranking signal, and
mdflow_team_get_contextranks those descriptions above folder names and document titles. A folder described as "decisions and rejected alternatives for the billing rewrite" is what an agent finds when it asks about billing — the mechanism we cover in Folder Descriptions as Agent Context. - The agent that did the work can file the record itself. The MCP server and HTTP API are read and write, so "before you finish, write what you rejected and why into the decisions folder" is one instruction, not a chore for the human afterwards. See Let AI Agents Write to Your Knowledge Base.
Connect Claude to MDflow: open the MDflow connector in Claude's Connectors Directory, click Connect to Claude, and sign in — no URL or token to paste. One connection covers claude.ai, the Claude desktop and mobile apps, and Claude Code signed in with a Claude subscription. Team workspaces use a
mdt_Team access token instead, with the bearer-header clients listed in the MCP docs.
- An answer to "what did the agents do to my documents?" In a personal workspace, the Document Log at
/logrecords created, edited, shared and deleted events with the actor on every row —youfor browser actions,automated · <token name>for anything arriving over the API or MCP — and an edited row opens a diff of exactly what changed, retained for 30 days. Team accounts keep a separate audit feed of account, membership, workspace, folder and document lifecycle changes, retained for 365 days. - Version history that covers machine writes. Every saved body change keeps the previous version, across every write path including the API and the MCP server, with a line-by-line diff and a non-destructive restore. A Team seat carries it for every active member.
Where the report card is worse. Four gaps, all real:
- There is no provenance link from a document to the branch, commit or thread that produced it. You can paste a URL; nothing connects them, and nothing notices when the code moves on.
- Version history is not reachable by an agent. Active Team members can compare and restore versions of a Team document in the editor, but history is not exposed over the API or MCP, so no agent can ask what changed and when — which is precisely the arriving reviewer's question. On personal documents it is narrower still: history is private to the document owner.
- Team documents have no comments. Commenting works on personal documents shared by public link or by email; inside a Team workspace it does not exist yet. That is the gap closest to what Feldman demonstrated, and it is the honest weak point of this comparison.
- Writing the record is still a step. Nothing automates the moment of distillation, and "it is a step" is the main reason decisions go unrecorded in every tool, including this one.
Where we are headed — direction, not a dated commitment. The folder description stays the primitive we invest in, because stating what a set of documents is for is what makes retrieval work without an index. The other thread is shrinking the distance between where a decision gets made and where it gets written down, which is why agent write access came before anything prettier.
The bottom line
The talk's diagnosis is right and it is bigger than one product: the conversation became part of the source, and our tooling still versions only the output. Feldman's answer — share the thread, not a screenshot of it — is a serious one, and worth watching.
The part you can do this week is smaller. At the end of a piece of agent-assisted work, before the context evaporates, write five lines somewhere your colleagues' agents can read: what we chose, what we rejected, why, who decided, and when. Not a rule. A record.
It is the cheapest possible insurance against someone — quite possibly you, in June — standing over a six-month-old decision with a trowel.
Start free, connect an AI agent, or read the API docs.
Frequently asked questions
What is agent archaeology?
Agent archaeology is digging back through commits, branch names and half-remembered chat messages to reconstruct why a decision was made, because the conversation that produced the code was never captured anywhere durable. Richard Feldman uses the phrase in an AI Engineer talk published on 9 November 2026. It is a waste of time in a specific way: the information existed when the work happened, and the tooling simply threw it away.
Why don't commit messages capture the reasoning behind AI-written code?
Because a commit is a checkpoint of state, not a record of derivation. It shows what the code became, not the three approaches the agent tried and abandoned, the constraint a teammate mentioned in chat, or why a rejected option was rejected. Work that an agent did and then discarded usually never gets committed at all, so the next person cannot even see that it was considered.
Does Delta replace pull requests?
On its own repository, yes. Zed Industries announced the public beta of Delta on 16 September 2026 and said it had disabled pull requests on Delta's own repository, with 33 people landing 570 changes to main since. Reviews happen in threads instead, each with an isolated copy of the parent thread's worktrees. The main zed-industries/zed repository stays on GitHub, and teammates who never open Delta still see a normal Git repository.
Should you save agent conversations or write a decision record?
Both solve different problems. A saved thread preserves everything and is the right raw material; a decision record is the distillation someone can actually read in a minute. A thread is long, chronological and full of dead ends, so an arriving teammate typically asks an agent to summarise it rather than reading it. If a summary is what gets consumed, it is worth writing one deliberately and keeping it somewhere durable.
Where should a team keep decision records its agents can read?
Somewhere every teammate's agent can reach with its own credentials, outside any one person's machine or any one vendor's thread format. Plain markdown in a shared workspace works because it is readable by people, diffable, and retrievable by an agent over an API or MCP server. The test is simple: if a colleague joins tomorrow with a different agent, can that agent read the reasoning without you forwarding anything?
Further reading
- Stop Doing Agent Archaeology on Your Team's Code — Richard Feldman at AI Engineer, published 9 November 2026. The primary source for the diagnosis and the demo.
- Replace PRs with Delta – Now in Public Beta — Nathan Sobo, Zed Industries, 16 September 2026. The source for the public-beta status, DeltaDB and the 33-people/570-changes figure.
- Process Data vs State Data — the same split, seen from the model's side instead of the team's.
- Why Multi-Agent Pipelines Fail: Context Lost in Handoffs — the agent-to-agent version of the handoff problem.
- Implicit Knowledge Is Invisible to AI Agents — why the reasoning has to be written, not implied.
- Lint Rules Beat Rules Files for AI Coding Agents — the counterweight, and the argument this post has to answer.
- Team Knowledge Base for AI Agents — the shape of the shared layer once you decide to keep one.
- MDflow MCP docs and HTTP API docs — connecting an agent to it.