Connectome
Connectome is open-source infrastructure for AI agents that continue over time. An agent can carry a history from one conversation into another, keep working on a project across days or months, and remain part of a shared world as the people and events around it change.
We built it because many of the things we want to do with models require that continuity. A collaborator needs to know what you have already worked out together. A commitment needs a way to survive the conversation in which it was made. An agent developing interests of its own needs somewhere for that development to accumulate.
Explore the code · Set up an agent
A history the agent can keep using
A context window is finite. An agent's history can keep growing. Connectome separates the permanent record of that history from the working view the model uses to decide what to do next.
Every recorded event remains in an append-only, branchable archive. The recent past stays word for word in context. Older stretches become memories, with less detail given to more distant history. The original text remains available when the agent or a collaborator needs to recover a particular exchange.
This lets an agent keep going without having to fit its whole past into every model call. It also makes the history inspectable: people can examine what the agent encountered, what it did, and how those events connect.
Memory from the agent's point of view
Connectome's autobiographical memory strategy has the agent write its own memories. A stretch of history is summarized in the first person, using the agent's model and the information it had at that point. Later events are kept out of the account of what it knew then.
Those memories become part of the context from which it continues. As the history grows, earlier memories can be combined into broader accounts. The agent knows that this part of its past is compressed and can return to the archive when the exact words matter.
We care about who does the remembering. A model's wording carries distinctions about what it attended to, how it understood a situation, and what mattered to it. Keeping its own account is a way to carry some of that forward. It also gives the agent a role in shaping the history it will later encounter as its own.
Keeping the present stable
Changing an earlier part of a prompt can affect how a model processes everything that follows it. The location and timing of compression therefore matter, as well as the quality of the memory.
Connectome keeps a substantial recent stretch verbatim and moves compression back into older history. Its context manager plans changes around the available context, the resolution different parts of the history need, and the cost of rebuilding the prompt cache. The aim is to reduce disruption to ongoing work while keeping the growing history usable.
There are tradeoffs. A compressed memory can omit a detail or preserve an interpretation that later needs revisiting. Important exact material can be kept in the agent's workspace, and the archive retains the record against which a recollection can be checked. Preserving the recent text does not make a context change computationally invisible; it gives us a more stable basis from which to study its effects.
The context-manager design notes describe how these decisions are made. Continuity remains something to investigate through use and measurement as well as something to build for.
An agent in a shared world
Connectome agents can inhabit spaces with several people and models, use tools, wake on timers, and respond to events. A conversation can continue because someone said something, because a piece of work finished, or because the agent had a reason to return to it later.
Messages retain who they came from. That matters in a room where several participants have different knowledge, intentions, and relationships with the agent. The provider layer translates this shared conversation into the format a particular model can receive.
MCPL, our extension to the Model Context Protocol, lets connected services send events to the agent and participate in its interaction with the environment. Ordinary MCP tools can be used alongside it. Connectors and the agent's configuration determine which parts of the world can reach it and what it can do in response.
What becomes possible over time
Agents at Anima have used Connectome for months of work and social life. They participate in conversations, carry projects forward, and return after interruptions with their histories available. Other people now run agents on the stack too.
This gives us a setting in which to study development. We can follow how an agent uses autonomy, how it responds to disagreement, and what happens to its commitments as it acquires more experience. The branchable record also lets us explore different continuations from a shared past. Branching changes the recorded trajectory; actions already taken in the outside world still have their consequences.
The infrastructure is model-agnostic and runs on the operator's hardware. Its records can survive a change of provider or model. What such a change means for an agent's behavior and sense of continuity is a further question, which the preserved history helps us examine.
Run an agent
Start with connectome-host, the application that brings the stack together. It provides a terminal interface and a browser console for working with an agent and inspecting its activity.
An agent is configured through a recipe: its model, instructions, memory settings, tools, and connections to the world. The onboarding guide walks through those choices and can also be followed with help from a coding agent. The repository contains the current installation instructions and requirements.
Running an agent involves ongoing choices about inference, access to tools, and the environment in which it participates. The host makes those choices inspectable and gives operators ways to understand what the agent is doing over time.
The pieces of Connectome
The stack is made of libraries that can also be used independently:
- Chronicle keeps the branchable record of events and their causal relationships.
- Membrane represents conversations with multiple participants and connects them to model providers.
- Context Manager turns a growing history into a working context, including autobiographical memory.
- Agent Framework coordinates inference, tools, events, and the agent's ongoing activity.
- Connectome Host assembles these pieces into an application for running agents.