Lineage

Architecture

Inspiration

Git blame tells you who changed a line, but not what they asked their coding agent or why the code was designed that way. As more development happens through harnesses like Claude Code and Codex, important decisions become trapped in private sessions and disappear when work moves between teammates.

We built Lineage to make that context recoverable.

What it does

Lineage connects developers and their coding agents inside the terminal.

A developer can ask another developer’s agent why a feature was implemented a certain way. Lineage identifies the relevant code and author, routes the question to their live session, and retrieves supporting context from their local Claude or Codex history.

Developers can also:

Send questions, requests, and implementation context between agents
Receive live notifications inside Claude Code
Return the exact originating prompt after approval
Record decision summaries and intent through Git
Detect conflicting assumptions before both developers commit
Log in to workspace as an authenticated teammate

Raw prompt histories remain on their owner’s computer.

How we built it

Running 'lineage init' configures the repository, registers the MCP tools, and indexes local Claude and Codex sessions.

Each developer launches their agent through 'lineage run'. A local daemon connects their session to a repository-specific room over WebSockets. Auth0 verifies participant identities, while Claude Code Channels deliver incoming questions and completed answers directly into active sessions.

For code questions, Lineage connects Git history with metadata from local agent sessions. It stores pointers and hashes rather than copied prompts. When a developer approves a request, Lineage rereads the matching prompt from its original local session and returns a structured answer.

Auth0 authenticates each developer through its Device Authorization Flow. This verifies real identity behind every message so only the intended teammate can view it, maintaining privacy and keeping decision records scoped to the right people.

Everything runs through the CLI. There is no dashboard or required cloud database.

Challenges we ran into

Supporting both Claude Code and Codex despite their different session formats and notification capabilities
Matching a code line to the correct prompt without storing raw conversation history
Delivering asynchronous messages into an active coding session without writing into the user’s input box
Making WebSocket networking reliable across macOS and Windows
Normalizing Windows and Unix file paths for Git-based matching
Keeping requests private while still making the experience fast enough for live collaboration

Accomplishments we’re proud of

Retrieved the exact Codex prompt behind a specific line from a separate ClaudeCode session
Connected agents running on different laptops in real time
Built live request and reply interrupts using Claude Code Channels
Preserved compatibility across Claude Code and Codex histories
Kept raw prompts local and required approval before disclosure
Built the entire experience as a CLI-first developer tool

What we learned

Agent communication is only the transport. The real problem is preserving the reasoning behind software decisions.

We also learned that Git history and agent history complement each other. Git provides stable code ownership and chronology, while agent sessions contain the missing intent. Connecting them creates a much more useful record than either one alone.

What’s next for Lineage

Improve prompt matching across longer and more complex histories
Add native live interruptions for Codex when its client supports pushed MCP events
Support persistent hosted relays for distributed teams
Expand conflict detection between concurrent agent tasks
Add organization-level access controls and audit policies
Build richer decision timelines across files, features, and repositories