Shared memory for your team's AI agents

The problem

AI coding agents are incredibly capable, but their context is usually trapped inside individual sessions. Every new session starts with some version of:

"Here's the repository. Figure it out."

The agent doesn't automatically know:

• What another agent already investigated
• Which approaches were tried and abandoned
• What changed in the codebase, and why
• Which bugs were discovered and how they were fixed
• What remains unfinished
• What another developer is currently working on
• What the team has already learned

As the number of developers and agents increases, the problem compounds.

Teams build their own fragmented workarounds — prompts, markdown files, Git commits, Slack threads, tickets, docs, tribal knowledge — but none of these give every agent a persistent, machine-readable memory it can use directly. The result is repeated work, lost context, slower handoffs, and more coordination overhead. And as teams run more agents in parallel, the amount of lost context grows faster than the number of agents.

Where we're headed

One shared memory for every agent.

We want to build a persistent context layer that sits across a team's AI coding sessions. Every session would contribute to the team's shared memory — discoveries, decisions, changes, attempts, failures, progress, next steps. When another agent starts working, it could retrieve the relevant history instead of starting from scratch. A developer could move from one agent to another without manually reconstructing the entire story.

The goal isn't simply to store transcripts. It's to preserve the useful context behind the work: what happened, what changed, why, what was learned, what remains.

One memory, every agent

Claude Code, Codex, Cursor, and other AI coding agents would all feed into a single shared context layer, available to every developer and every agent on the team. That layer becomes the connective tissue between otherwise independent AI sessions — giving agents access to the context they need without requiring developers to manually copy and paste it between tools.

From sessions to team memory

An AI session shouldn't disappear when the terminal closes — it should become part of the team's institutional memory. Over time, a system like this should understand:

Decisions

Why the team chose one approach over another.

Discoveries

What developers and agents learned while investigating the codebase.

Changes

What was modified and what those changes accomplished.

Failures

What was attempted, what didn't work, and why.

Progress

Where work stopped and what needs to happen next.

Context

The background information needed to make better decisions in future sessions.

This would turn a collection of isolated conversations into a continuously evolving knowledge base for engineering work.

Beyond multi-agent messaging

Most multi-agent architectures treat agents as separate entities that pass messages to each other — Agent A hands off to Agent B, which hands off to Agent C. Each agent has a role, and messages travel between them. But messaging isn't the same as memory.

An agent can receive a message saying "Agent B finished the database migration." That's not enough. A useful memory would include what was changed, why it was changed, what alternatives were considered, what failed, what assumptions were made, and what should happen next. We don't think the answer is another agent-to-agent messaging protocol — it's a shared context layer underneath the agents.

The fundamental unit isn't the agent

Humans organize into teams and hierarchies partly because human memory is fragmented — every person has their own. AI agents don't have to work that way. Instead of building increasingly complicated networks where agents continuously pass context to one another, every agent could draw on a common source of truth. Agent A wouldn't need to tell Agent B everything it knows; Agent B could retrieve the relevant context itself.

In that architecture, agents are workers and shared memory is the connective layer. The agents can change, the models can change, the editors can change — the underlying team memory remains.

Why we're building this

Relay started as a way to give platform and security teams visibility into what coding agents were doing across the org — a shared audit trail of agent sessions, captured automatically via CLI hooks and surfaced in Architect. That visibility turned out to solve a narrower problem than the one teams actually had: seeing what an agent did is useful, but it still leaves a person (or the next agent) to manually reconstruct the reasoning behind it before they can pick the work back up.

That's the direction this vision points toward — from observability of individual agent runs, to a shared memory layer the whole team's agents can build on.

The long-term vision

AI coding agents are becoming a permanent part of software development. Teams will run multiple agents, multiple models, multiple sessions, multiple developers, multiple coding environments, and increasingly parallel workflows. The bottleneck won't simply be model intelligence — it will be context fragmentation.

The team with the best agents won't necessarily be the team with the most models. It may be the team whose agents can collectively remember what they've already learned. We're building toward being the memory layer for that future.