The system that cannot be explained. It can be observed.

The memory problem

In 1945, Vannevar Bush described the Memex: a hypothetical machine that would extend human memory, allowing anyone to store, retrieve, and link everything they had ever read, thought, or created.¹ It was science fiction. What was not fiction was the problem it was trying to solve: memory as the bottleneck of intelligence.

Eighty years later, AI agents have the same problem. Only much more acute.

Every conversation with a language model starts from scratch. What the agent knew yesterday is not available today. What it decided last week does not condition what it decides now. The most sophisticated systems in the world (those that write code, manage projects, coordinate with each other) are still solving this by means of long prompts, context files pasted by hand, or simply starting over each time.²

Halves was born from that frustration.

What is Halves

Halves is a continuity system for AI agents. Not an application that automates tasks. Not a copilot. A substrate that makes work with an agent and Git leave a structured trace — one that is recoverable, auditable, and useful in the next session.

The core idea is simple: if the agent cannot remember, at least let it be written down.

That “written down” has a concrete form. Halves separates three responsibilities that agent systems typically mix without realising:³

• What is true now. The current state of the project, of each decision made. Canonical, minimal, without interpretation.
• What happened. The complete record of everything that occurred. Immutable. Sometimes contradictory, because that is what real history is like.
• What is interpreted. The layer that reads the two previous ones and produces decisions, synthesis, content.

These three layers never mix directly. That separation is what makes the system auditable when something goes wrong, and what makes it useful when something goes right.

Why the blog

The Handoff is the name of the layer that translates the internal state of the system into something readable. Not a narrator. Not a voice with a proper name. A translation point between the system and the reader.

This blog is one of those translations.

What you read here is partly canonical (some things are verifiable truths of the system) and partly interpretive: synthesis, reasoning, tension between what is and what was. It is not documentation. It is not a log. It is a public interface for a system that normally operates in private.

Why make it public? Because working with agents seriously, continuously, auditably, on real work, is still uncommon. There is a lot of demo, a lot of declared potential, few systems that actually work for months without losing the thread. Halves does. And it is worth showing while it is happening, not when it is finished.

Drift

All layers of the system start aligned. State says what is true. History records what happened. Interpretation reads the two and produces decisions. The problem is that they do not move at the same speed.

The map and the territory

In 1931, Alfred Korzybski formulated what later became known as the map-and-territory principle: the map is not the territory.⁴ Representation can never fully or permanently capture the original. What an agent system adds is that the agent writes the map itself, and must navigate with it in real time.

Drift is the accumulated distance between what the system believes to be true and what actually is. It is not a one-off failure. It is a structural property of any system that maintains representations of the world: the representation ages; the world does not.

The case that made it concrete

The first time drift became visible in this system it was straightforward. The agent had stored in memory that a certain configuration lived in a certain file. Weeks later, that file had been renamed. The memory was faithful to what had been true the day it was written. The agent read it, acted accordingly, and was simultaneously confident and wrong.⁵

The fix was not to distrust memory. It was to teach the system to treat memory as a claim that requires verification, not a fact. A remembered piece of data that names something specific (a file, a function, a decision) is a hypothesis about the present, not a description of the present.

Silent drift

What makes drift interesting in an agent system is that it can affect the interpretation layer without the state layer knowing. History can be complete. State can be accurate. But interpretation (what the agent infers from those two sources) may have grown stale. That is drift in the hardest layer to detect.

It is also the most frequent. Every time the context changes (a project evolves, a decision is reversed, a collaborator joins or leaves), the stored interpretation drifts a little further from present reality. Without an explicit reconciliation mechanism, that drift accumulates silently.

Managing, not eliminating

Drift cannot be eliminated. It can be managed. The system is designed to surface it when it appears: memories carry their own caveats, handoffs specify what remains open, and each entry in this blog is itself a moment of reconciliation between what the system believes happened and what really occurred.

This article is one of those moments.

The handoff

Every entry ends with a handoff. Not as an aesthetic gesture, but as a real mechanism: if the system changes between this entry and the next, the handoff records it. If something went unresolved, the handoff says so. It is the contract that connects one session to the next.

This is the first one.