Stop Doing Agent Archaeology on Your Team's Code with Richard Feldman, Delta

As coding agents become central to software development, the conversation and context between humans and agents must be collaboratively shared in real time r

By Sean Weldon

Abstract

As coding agents assume a central role in software development, the context generated during human-agent interaction has become a primary engineering artifact - yet it is typically confined to individual workstations. This synthesis examines the thesis that agent conversations must be collaboratively shared in real time rather than siloed, since siloed interaction reduces inter-colleague handoffs to lossy snapshots and forces agent archaeology: the reconstruction of past rationale from commits and transcripts. The analysis draws on a demonstration of Delta, a model- and harness-agnostic collaboration tool that unifies agent conversations, code review, and real-time human participation in a single thread-based environment. Reported mechanisms include at-mention notification into live agent threads, inline commenting on agent-generated diffs, view-only terminal synchronization, and purpose-built repository mirroring. Observed scale reached 30-40 concurrent participants in one thread. Practical implications concern context durability, review compliance, and the displacement of pull-request workflows.

1. Introduction

The locus of software engineering knowledge is shifting. Where design rationale was once encoded in commit messages, design documents, and code review threads, an increasing share now resides in transient conversations between engineers and coding agents - large language model (LLM) systems that read, write, and execute code under human direction. Such conversations contain not only the resulting diff but the deliberative record surrounding it: alternatives considered, directions explored and abandoned, and the degree of scrutiny applied to each decision.

The central problem is that this record is, by default, private. An engineer converses with an agent locally and then transmits a summary to colleagues. The resulting handoff is structurally lossy, and the loss is asymmetric: what survives is the artifact (a branch, a diff, a gist), while the reasoning that justifies it is discarded unless explicitly transcribed. When a colleague later needs to understand why a decision was made, the recipient is forced to reconstruct intent from residue rather than retrieve it directly - a process this synthesis, following the source material, terms agent archaeology.

This synthesis states the thesis under examination as follows: context generated in human-agent interaction should be treated as shared, real-time team infrastructure rather than per-user session state. Section 2 establishes the conceptual framing. Section 3 analyzes the failure modes of siloed collaboration and the mechanisms proposed to address them. Section 4 consolidates technical findings, Section 5 discusses implications and open questions, and Section 6 concludes.

2. Background and Related Work

The problem is illustrated by a canonical handoff scenario: a colleague departs for vacation leaving behind a gist, a branch name, and an agent transcript. Each artifact is individually legible, yet collectively insufficient. Absent are the thought process, the rationale behind specific decisions, and the record of explored directions that failed. The recipient must infer intent from residue rather than inspect it directly.

The framing analogy offered contrasts a collection of disparate single-purpose devices - a video camera, a corded telephone, a boombox with an accompanying compact disc collection, a desktop tower - with an integrated smartphone. The point is not capability but friction: disparate tools can accomplish the same set of tasks, while tools designed to interoperate eliminate the coordination overhead between them. Applied to agentic development, the argument holds that conversation, code, review, and execution are currently separate devices that a unified product could consolidate.

Delta is presented as the integrated alternative. Architecturally relevant prior work includes the Agent Client Protocol (ACP), referenced as the intended integration path for subscription-based harnesses such as Claude Code, and conventional pull-request-centered review, which Delta is reported to have replaced internally with in-thread CI and landing workflows.

3. Core Analysis

3.1 The Cost Structure of Siloed Interaction

Teams presently operate as individual silos, with each engineer conversing with a private agent and exporting snapshots only when collaboration becomes necessary. This produces two distinct costs. The first is immediate: a coworker reconstructing context must read a transcript divorced from the live state of the code, often after the relevant decisions have already been made and forgotten. The second is deferred: months later, a team may need to understand why a historical decision was taken, and the only available artifacts are commit messages and whatever transcript fragments were manually preserved. As stated in the source material, "it's a waste of time to just go back and try to guess at what happened when we could just have the full information of what actually did happen." The claim is not that information is unrecoverable, but that recovery is costly relative to the alternative of never having lost it.

3.2 Real-Time Participation as a Structural Fix

The demonstrated alternative replaces export-based handoff with direct participation inside an ongoing agent thread. In a live example, an agent working with one engineer surfaced a question about a stale feature and, rather than routing the question through a separate channel such as Slack, at-mentioned a second engineer (Bennett) directly inside the existing thread. Bennett joined and responded in real time, and - critically - the agent retained the full context of the exchange for future reference, since it occurred within the thread rather than alongside it. This distinction matters because it determines whether the agent can later distinguish the depth of scrutiny a decision received: "the agent can actually know was this a really deep market research question or was this just like, 'what do you think? Okay. Yeah, that seems good to me.'" That distinction is unavailable when collaboration happens out-of-band.

3.3 Review and Compliance Inside the Thread

The same demonstration extended to formal code review: a roughly 2,000-line diff generated by the agent was reviewed line-by-line, with comments submitted directly against the diff. Highlighting any text or code produces a comment that is itself submitted to the agent as a prompt, collapsing the review-and-revise loop into the same surface used for authoring. The tool additionally supports approve/reject sign-offs intended to satisfy formal compliance requirements such as SOC 2, suggesting that the thread-based model is designed to subsume, not merely supplement, traditional review gates. Consistent with this, Delta reportedly replaced pull-request workflows internally, substituting dedicated CI execution and a landing/sign-off mechanism triggered directly from within the thread.

3.4 Scale and Isolation Mechanisms

Reported usage includes team stand-ups conducted inside Delta with 30-40 concurrent participants in a single thread without observed degradation, though the source material notes that full organization-wide scaling has not yet been stress-tested. To manage context growth as participation scales, the system supports threads and nested sub-threads, which isolate side discussions without interrupting the primary conversation. A related mechanism allows a coworker joining a thread late to ask the agent directly for a summary rather than reading the full history, shifting the burden of context compression from the human reader to the agent.

4. Technical Insights

Several implementation-level mechanisms distinguish this approach from conventional version-control-centric workflows:

5. Discussion

The broader implication is that agent-generated context is being treated as a durable engineering artifact on par with source code itself, rather than as ephemeral session state. This reframing has consequences for how teams think about documentation: if rationale is retrievable rather than reconstructed, the incentive to manually document decisions may shift, though this also creates dependency on the collaboration platform persisting and remaining searchable over the relevant time horizons - a dependency not addressed in the source material.

The displacement of pull requests with in-thread CI and landing workflows is notable because it suggests review processes are being redesigned around the conversational medium rather than retrofitted onto it. Whether this generalizes beyond small, fast-moving teams to larger organizations with stricter governance requirements remains an open question, particularly given the explicit acknowledgment that org-wide scale has not been stress-tested.

This development sits within a broader industry trend toward treating multi-agent and multi-human coordination as a first-class product category rather than an emergent use of existing chat and version-control tools. The explicit harness-agnosticism and planned ACP integration also suggest an anticipated ecosystem in which collaboration platforms sit above, rather than compete with, individual agent harnesses.

6. Conclusion

This synthesis has examined the argument that agent conversations constitute a primary engineering artifact whose value is lost when confined to individual sessions, and that collaborative, real-time sharing of that context - rather than post-hoc transcript export - is the structural remedy for lossy handoffs and agent archaeology. The Delta demonstration provides concrete mechanisms for this shift: in-thread at-mentioning, inline diff commentary, view-only terminal sharing, and thread-based review and landing workflows.

The practical takeaway for engineering teams is that the design question is no longer solely which model or harness to adopt, but where and how the resulting conversations are stored and who can access them during and after the fact. As agent-driven development scales, the durability and shareability of that context may prove as consequential to team velocity as the capability of the underlying models.

Sources

About the Author

Sean Weldon is an AI engineer and systems architect specializing in autonomous systems, agentic workflows, and applied machine learning. He builds production AI systems that automate complex business operations.

LinkedIn | Website | GitHub

At 22Atlas, the studio I run, we put Claude to work for clients, and 22Atlas on Claude covers how.

Sean Weldon builds apps and custom software at 22Atlas.

Start your build

More about Sean