Agents That Compound
What one agent session learns, the next one inherits
A capable agent can produce a quarter of strategy work in an afternoon. The problem was never production. It is that each session starts cold, re-derives what the last one knew, and leaves its output in a document the next session never reads. The outputs drift apart because nothing reconciles them. UPG gives every agent one typed, shared graph to read and write, so a session opens with the prior session’s conclusions already in place, and the work accumulates instead of resetting.
How a session inherits what the last one learned
Without shared structure, each AI session starts from nothing. It re-reads the codebase, re-guesses the strategy, and writes its conclusions into a fresh document. The next session does the same work again, and the outputs drift apart because nothing reconciles them.
On a UPG graph, a session opens with get_product_context and inherits the active playbook step, the recent-change cursor, the open hypotheses, and the current lens. It writes typed nodes, not prose. The session after it starts where this one stopped.
produces a docstarts cold, re-explainsoutput drifts from 1Each session is disposable. The work does not accumulate; it is re-litigated.
.upgwrites typed nodesinherits the last stepbuilds on 1 and 2Every session opens on the same structure and adds to it. Output compounds.
Agents, people, and tools on one graph
UPG is exposed over the Model Context Protocol, the layer the major AI clients already speak. Claude Code, Cursor, a VS Code extension, a person working in a canvas, and an in-house tool all read and write the same graph through the same typed tools.
Because the surfaces share one graph, the insight an agent writes in Cursor is the insight a product manager reads in the canvas an hour later. There is one source of truth, and each client reads and writes that, rather than keeping a copy per surface.
Everything reads and writes the same graph.
The three protocol properties behind the compounding
The compounding rests on three properties of the protocol. An agent is introspection-first: it calls get_entity_schema to ask what would be valid here, right now, then writes a node that conforms on the first attempt, so the same code works against any spec version.
It carries typed session context: get_session_context and update_session_context move working memory across conversations as structured data, not chat history. And it uses change-based collaboration: two agents reconcile by diffing cursors with get_changes, not by taking locks, so long-running sessions stay compatible with concurrent edits.
get_entity_schemaget_session_contextget_changesThe protocol carries three properties that turn AI throughput into knowledge that lasts. An agent introspects the schema before it writes, carries typed working memory across sessions, and reconciles by change rather than by lock. None of these properties depends on a particular client. They define how an agent talks to the graph.
The graph is the durable layer under single sessions, and it is additive: point one agent at a .upg file and the next one already reads what it wrote. Follow a thread: