AI Engineer World's Fair 2026

A Genius With Amnesia

Loading slides…

Read the talk

A Genius With Amnesia

Coding agents need more than intelligence: they need access to connected repositories and the history of the work that changed them.

From a talk by Victor Savkin

Before you start: Familiarity with Git repositories, pull requests, CI, and coding-agent sessions will help you follow the demonstrations.

The genius with amnesia

Imagine finding a magic lamp in an antique store. Buried in deadlines, you ask the genie for the best engineer to help with an impossible project. Victor Savkin’s choice is John Carmack from his id days. The genie delivers—with restrictions. Carmack can see only one-thousandth of your codebase and remembers nothing from previous conversations.

You have extraordinary engineering ability available, but you must repeatedly explain the system’s conventions, the work already completed, and why things are arranged as they are. That is the mismatch behind the title: intelligence without system context or continuity leaves the human responsible for both.

0:040:18
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:04 · section reference included

One change, seven explanations

Consider four repositories: UI, Module 1, Module 2, and Platform. A button change in UI must propagate through the system. The first explanation is unavoidable: someone has to express the intended change. The repetition begins when that intent crosses a repository boundary.

  1. Explain the button change in UI, implement it, and publish the library.
  2. Move to Module 1 and explain what changed so it can consume the package. Discover that the published version is incompatible.
  3. Return to UI and explain both the original change and the newly discovered issue to a fresh agent.
  4. Fix and republish UI, then explain the revised change in Module 1.
  5. Explain it again in Module 2.
  6. Move to Platform and explain how the pieces fit together.
  7. A week after release, a production bug appears in the UI component. Start another UI session and explain the original change and the production issue again.

Savkin counts seven explanations for one change in this four-repository scenario. Different developers may perform the handoffs; distributing the work does not eliminate the repeated explanations.

Count Unnecessary Reexplaining slide with connected Platform, Module 1, Module 2 and UI boxes, a numbered checklist, and a counter showing 7.Open full source frame
A UI change produces seven explanations across four repositories.
0:571:12
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

0:57 · section reference included

Repository boundaries limit what an agent can change

The repeated explanations have two causes:

ConstraintWhat the agent lacksWhat the human supplies
SpaceVisibility beyond its current repositorySystem relationships and downstream context
TimeMemory of previous sessionsIntent, decisions, and prior discoveries

A repository-bound agent generally sees and changes one repository at a time, even when the system spans hundreds or thousands. A fresh session then loses the history of work within that limited view.

Without a model of repository relationships, the agent depends on the developer to research how a change fits the wider system. In the UI example, it cannot account for Module 1 unless someone supplies that context. Standards and best practices may also live elsewhere, outside the repository it can inspect.

Writing across those boundaries is harder still. Module 1’s CI should have exposed the UI incompatibility while the UI change was being made. Instead, the originating agent cannot validate downstream behavior or update consumers while it still has the full context of its own change. The developer must reconstruct that context for each consumer. Savkin’s illustrative twenty-repository change requires twenty explanations, spending developer time and tokens on the same intent.

Writes stop at the repo edge slide showing an agent separated from API consumer, Mobile App and Service B boxes, with all three limitation statements highlighted.Open full source frame
Repository boundaries prevent downstream validation, consumer updates and system-wide refactoring.
2:503:03
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

2:50 · section reference included

The graph behind the work

The missing history is episodic memory: knowledge of particular sessions in which work happened. Combine those episodes with the code they changed, and the organization becomes a graph with two layers. The lower layer contains repositories, including owned artifacts and open-source dependencies. The upper layer contains agent sessions that created or modified them. Repositories relate to repositories; sessions relate to other sessions and to the code they touched.

Savkin illustrates the scale with a thousand owned repositories and tens of thousands of open-source repositories. The lower layer describes what exists; the upper layer describes how it came to be. An individual agent usually sees one session and a small portion of that code, so it relies on developers who carry fragments of the wider graph in their heads.

To make the restriction feel less familiar, imagine an agent allowed to inspect only one file and remember only five previous messages. Both its spatial reach and its temporal reach would be visibly inadequate. Repository-sized visibility and session-sized memory impose the same kind of constraint, with the consequences becoming more apparent as the organization grows.

4:284:42
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

4:28 · section reference included

Making separate repositories behave like one codebase

Polygraph is an agent-agnostic meta-harness: infrastructure around coding agents that expands the code and history available to them. Savkin presents it as one implementation of a broader approach, noting that other organizations have built similar solutions.

The starting point is a GitHub user’s accessible repositories. Polygraph analyzes them without changing their source code, extracting metadata into a unified dependency graph. That graph lets the harness present separate repositories as one body of code the agent can read and write. Savkin describes his personal graph as roughly 300 owned repositories plus thousands of open-source dependencies. For each project within each repository, Polygraph identifies packages and APIs it produces and consumes, then connects the producers to their consumers.

Turning that graph into a working session requires more than retrieval:

  1. Bring in the relevant source repositories.
  2. Install their dependencies.
  3. Set up an agent for each repository.
  4. Connect the agents so they can work together.
  5. Provide a terminal UI that keeps the multi-repository change navigable.

This assembles the environment in which the change can happen; coordinating the resulting writes is the next problem.

A session involving ten repositories can produce ten pull requests. Each has CI, but treating those results independently misses failures caused by interactions between repositories. Polygraph treats the CI results as one vector: a combined view of the change’s validation state.

Return to UI and its consumers. If Module 1 fails, the question is not merely which check is red. It is where the correction belongs:

  • Consumer correction: Module 1 needs a patch to accommodate the intended UI change.
  • Producer correction: The UI change is incompatible and must itself be fixed, potentially requiring patches for the other consumers too.

Savkin describes Polygraph as coordinating that responsibility across the session, so a multi-repository change can be handled as one coherent unit of work.

6:186:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

6:18 · section reference included

Recording the work, not just the conversation

The same session machinery also supplies persistent memory. Polygraph captures the intent, participating repositories, pull requests, and agent traces. Those records connect work in one repository to work in another. A session can then be restored on another machine or referenced from a later piece of work.

Episodic memory slide listing Intent, Repos, Pull requests, CI statuses and All agent traces, followed by statements about relating sessions and restoring or referencing state; presenter inset at lower right.Open full source frame
Captured work supports related sessions and restoration of their state.

Savkin characterizes the result as photographic memory of the organization: knowledge of how repositories fit together alongside recall of the sessions that changed them. The mechanism is the captured, related record of work, rather than an individual agent remembering everything inside one conversation.

9:289:32
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

9:28 · section reference included

A backend and frontend change in one session

The demonstration starts with a small GitHub organization containing three repositories. Savkin runs the session command and selects the backend and frontend: the intended change affects both an API and how its data is displayed. He names the session, then chooses Claude from the installed agents. Polygraph supplies the surrounding coordination; it is not itself the coding agent.

Once the agents start, the interaction resembles work in a single repository. Savkin supplies instructions, the agent plans the change, and the TUI shows progress with animations. After it determines how the repositories relate, he asks it to implement the change. The repository boundaries remain in the underlying version-control workflow, but they do not require separate explanations of the desired behavior.

The resulting session groups the separate pull requests under a description of the work as a whole. Its view includes the participating repositories, PRs, CI results, and captured agent logs. Those logs will also support resuming the work. Savkin reports avoiding one re-explanation in this demo: he explains the change once, and it is implemented in both backend and frontend.

10:2510:33
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

10:25 · section reference included

Handing off the state of the work

Suppose the backend owner needs to finish the change. Savkin sends them the session, which they reconstruct by command on another machine—even if they have never worked on it before. They can also choose a different agent: the original session used Claude; the resumed session uses Codex.

The demonstrated restoration brings back the repositories at the same commit SHAs, starts and connects their agents, and primes them with the captured traces. Both backend and frontend therefore have the code revision and history associated with the original work. The agent changes, but the session’s recorded context travels with it.

The transferable unit is the state attached to the session, not just conversational memory. Savkin compares it to a Star Trek transporter: the working situation materializes on another machine so someone else can continue. The later resuming and handoff documentation makes the operational boundaries explicit: restoration uses relevant revisions and available context, users need access to every repository in the session, and transcript availability depends on sharing. Switching agents starts a fresh agent with a context-restoring prompt.

Savkin uses this for review. When a pull request raises questions, he resumes the author’s session and asks his agent about the decisions recorded in its traces, rather than immediately asking the author to reconstruct them. He describes the restored review environment as requiring zero setup. The same transfer also lets him switch from Claude to Codex mid-session if a service becomes unavailable.

12:5013:00
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

12:50 · section reference included

Finding the history needed for the next change

Now revisit the production bug. Instead of retelling the original implementation, Savkin references its session and asks the agent to investigate what is broken. The agent looks up the session and retrieves what it needs. A high-level description may be sufficient; otherwise, it can pull the relevant repositories, commit SHAs, and agent logs to reconstruct the earlier state. Savkin reports that the demonstration produces a fix without him supplying further context beyond the session reference and bug notice.

Repository and session selection need not remain manual. The dependency graph can turn an objective into a scope of work:

  • Library updates: Find repositories depending on a particular library version and update them.
  • Writing research: Describe a proposed blog post or article and find the repositories most relevant to it.
  • Implementation precedent: For a change such as adding vector indexing to the PR collection, find earlier sessions that did related work, then load one or several.

These requests use both repository contents and relationships to locate useful context.

Prior sessions also provide a concrete route to consistency. Rather than inventing a bespoke implementation in each repository, the agent can follow an approach used in a respected engineer’s earlier session. Retrieval is contextual in both directions: the current repository helps prioritize sessions, while the current session helps suggest repositories that similar work has used.

15:0515:21
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

15:05 · section reference included

Adding source to an agent already in progress

The demonstrations so far begin in the Polygraph CLI and launch a coding agent from there. The reverse direction also works: an existing agent session can engage Polygraph when another repository becomes useful. While working on a Vitest plugin in Nx, for example, Savkin asks to add the Vitest repository. Polygraph configures the checkout and brings it into the current session.

The agent can then explore the actual implementation to understand behavior or diagnose an issue in the original repository. Savkin prefers this depth of source access to Context7, which retrieves documentation and code examples. That is a preference for the material available to investigate, not a measured performance comparison. Repository expansion becomes something the agent can request as the work reveals a need for it.

17:4918:02
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

17:49 · section reference included

Context beyond any one developer

The two original restrictions now map to two connected capabilities: reach across accessible owned and open-source code, and retrieval of the sessions and decisions that changed it. Savkin calls the latter perfect memory. His later essay, Agentic Memory: Why Code Is Fundamentally Different, adds an essential distinction: a recorded episode describes a past state, which may no longer hold. Having the record within reach does not guarantee that conclusions drawn from it remain correct.

The larger consequence is that memory crosses developer boundaries. In Savkin’s illustrative thousand-engineer organization, each person contributes sessions to a shared body of work. An agent drawing on that body can have more context available than any single developer carries personally. The repository graph provides the structure of the system; the session graph provides its accumulated history.

Summary slide stating that the agent can see all the code and remember every decision made, with purple session circles linked to cyan repository boxes; presenter inset covers part of the lower-right diagram.Open full source frame
Connected sessions and repositories illustrate access to code and remembered decisions.

Savkin closes with the Borg analogy: individual developers and agents contribute to a collective memory. The ambition is to stop making each human reconstruct the same context for each new conversation, and instead make the organization’s recorded work available where the next change happens. He invites readers to try Polygraph and follow his work on Twitter.

18:5219:05
Suggest correction

This note stays in this page until you copy or download it. Nothing is submitted; reloading clears the draft.

18:52 · section reference included

Resources

From the talk

  • Announcing PolygraphArticle

    Savkin's launch explanation of repository boundaries, episodic memory, and the meta-harness approach.

  • Official guide to integrating Vitest into an Nx workspace.

Updates since the talk

Transcript download
Full transcript

Loading transcript…