Introducing Lockstep: A System of Record for AI Coding Agents

AI coding agents are transforming how teams build software. Claude Code, Codex, Gemini CLI — developers are shipping faster than ever, with an AI pair programmer that writes, refactors, and reasons about code at superhuman speed.

But there's a coordination problem hiding underneath the productivity gains, and it's getting worse with every developer who adopts an agent. DORA's 2025 State of AI-assisted Software Development report found that roughly 90% of developers now use AI at work, and that AI increases delivery throughput and instability together. The tools amplify. They don't coordinate.

The tools we use to coordinate engineering work — Git, pull requests, Slack, issue trackers — were designed for a world where humans are the ones writing code. Humans who talk to each other in standups, who mention things in Slack before changing them, who carry the context of last week's architecture discussion into today's coding session. These tools assume a background layer of human awareness that keeps everyone roughly aligned.

AI agents don't have this. There is no hallway conversation between Claude Code and Codex. There is no background awareness. Every agent session starts from a blank slate — no memory of what your colleague's agents decided, changed, or broke since the last session. And agents are fast. By the time anyone notices a conflict, both agents have produced dozens of files built on contradictory assumptions.

Teams feel this daily. On Anthropic's own tracker, an engineering manager running two teams (fourteen engineers) filed a request for shared team memory across Claude Code sessions, calling the gap "the single biggest efficiency bottleneck for teams adopting Claude Code seriously."

Git doesn't prevent this — it catches conflicts after they've happened, when two branches touch the same lines. It doesn't tell your teammate's agent that you decided to rename an endpoint. Pull requests don't prevent it — they review finished work, not in-progress decisions. And Slack doesn't prevent it, because agents don't read Slack.

The deeper issue is that every codebase is governed by invisible decisions. "We use JWTs, not session cookies." "The orders API is REST, but the payments service is gRPC." "The mobile app depends on the v2 endpoint — don't break it." These rules keep a codebase coherent. Humans learn them gradually through code reviews, pair programming, and institutional memory. AI agents never learn them. Every session is a fresh start. If the decision isn't explicitly in the agent's context window, it doesn't exist.

This is why we built Lockstep. We wanted to give teams a decision memory their agents could read: a system of record where decisions are explicit, changes are tracked, dependencies are known, and every agent starts every session with full awareness of what the rest of the team has been doing.

Our vision is to create a more reliable and efficient way for teams to work with AI coding agents — without sacrificing the speed that makes agents valuable in the first place.

Here's how we're going about it:

Decisions are first-class objects, not Slack messages. When an agent makes a decision that affects others — renaming an endpoint, changing an auth pattern, deprecating a surface — that decision is proposed, recorded, and must be acknowledged before it becomes binding. No more invisible choices that break someone else's work three days later.

The right people find out automatically. A dependency graph knows who consumes what. When a shared API surface changes, every agent that depends on it gets notified — immediately, not when the merge fails. The developer doesn't need to remember who to tell. The system knows.

Every agent starts with full context. When an agent opens a new session, Lockstep replays everything it missed — changes, binding decisions, open questions. The agent begins with the current state of the world, not a blank slate. This is the difference between an agent that works with the team and one that works next to it.

Source code never leaves the machine. This is the design constraint that makes the whole thing viable for real teams. Only decisions and metadata flow through the system. Source code, file contents, diffs, credentials — none of it leaves the developer's machine. You get coordination without surveillance.

It works across vendors. The record is neutral: any MCP-speaking agent (Claude Code, Cursor, and others) can read it and write decisions to it through the same tools. Automatic session capture ships for Claude Code today, with Codex and Gemini CLI adapters on the roadmap.

There's a hard gate at merge time. Real-time coordination is best-effort. So at PR time, a safety net checks every changed shared surface against the ledger. No binding decision? The PR is blocked. This catches everything the real-time system missed.

This is just the start. We know this is a new category — there are tools for writing code, reviewing code, deploying code, and tracking bugs, but there has never been a tool for coordinating the decisions that govern code. That's been a human job, handled through conversations and collective memory. AI agents don't have conversations or collective memory. They need something else.

Lockstep is open-source under the Apache-2.0 license, and you can self-host it. If you're running a team where multiple developers use AI coding agents, we'd love for you to try it and help shape where this goes.