Richard Feldman: keep the agent conversation with the code

Richard Feldman asks listeners to imagine a coworker leaving for vacation after sharing a branch and a transcript of an agent conversation. The recipient has the issue and some code snapshots, but may not know which approaches failed or why the coworker made particular choices.

Commits do not necessarily preserve abandoned attempts, and a pasted transcript may omit other discussions or reasoning. Feldman compares the handoff to a puzzle with missing pieces: the recipient and their agent must reconstruct context before continuing.

Months later, someone extending the feature may have to infer why a decision was made from commit messages and fragments. Feldman calls this agent archaeology: recovering context that existed during the work but was not retained alongside it.

He recounts a colleague mentioning him in Delta, the collaboration tool his team builds, to ask about an old undo feature. Feldman explained that his work was stale and the colleague could take it over. Their exchange remained in the agent thread, so the agent could use the answer as context.

Feldman argues that code changes, agent conversations and human discussions belong together. In Delta a teammate can see a diff, join the discussion and work with an agent. He demonstrates the product, which his team also developed.

The demo shows a macOS application, with Linux, Windows and mobile versions also mentioned. Feldman highlights text from an agent conversation and asks a follow-up question. He says the product aims to work with different models and agent frameworks.

He mentions a coworker, Bennett, in the thread to ask whether an error should be a toast or an inline message. Bennett joins and chooses inline. The decision becomes part of the shared conversation for the current agent and future collaborators with access.

Feldman shows a line-by-line code review. Comments can be attached to individual lines and sent to an agent; teammates can also review, approve or reject changes and directly edit code. Threads and nested subthreads provide separate contexts.

Bennett invites him into another thread during the presentation. Feldman can see Bennett's terminal output synchronized in real time but cannot type into that terminal, which would grant remote execution on Bennett's machine.

Feldman opens his own terminal, runs the project locally and says joining the thread created a local mirror of the repository. He calls these Delta worktrees rather than Git worktrees. Each participant can work locally and choose an agent while sharing context.

He returns to the handoff: a shared history can preserve agent conversations, code changes and human decisions together, making the evolution of work easier to inspect than a branch and scattered snapshots alone.

Asked about scale, Feldman says the team has used a single thread for standups with roughly 30 to 40 people, but has not performed a large stress test and cannot give a definitive limit.

The demonstration uses cloud-hosted synchronization, while agents can run locally or on cloud runners. Feldman says an on-premises pilot is underway. At the time of the talk, Delta was in private beta, pricing had not been published and the beta was free.

On the development lifecycle, he says his team has stopped using pull requests internally: an agent can run CI and then land a change, and a formal approval workflow is available. He says a bot API was not yet officially available.

Asked how a newly invited person catches up, Feldman describes asking the agent for an overview in a subthread. The original conversation can continue while the newcomer asks follow-up questions separately.