01
Isolated agent workspaces
Agents work independently without requiring conventional branch management for every task.
Source control for humans and coding agents
AI-first source control. Git compatible.
Multiple agents. One codebase. No lost work.1
Strata gives AI coding agents isolated workspaces, persistent development context, and safe concurrent integration, while keeping your existing Git workflows.
Keep your Git tools. Give your agents something better to work with.
01 — The problem
Git wasn't designed for a hundred agents working at once.
Git is excellent distributed version control, and it already supports concurrent, distributed development. The friction sits in the workflow layered on top: branches, rebases, pull requests and merge queues were designed around a handful of people who remember what they did yesterday.
When many autonomous agents modify the same codebase, that workflow turns into orchestration work. Someone, or some script, has to create branches, sequence merges, retry rebases and carry knowledge from one session to the next. Strata moves coordination, integration and context into the source control system itself.
- 01Branch proliferationOne branch per task per agent, each to be named, tracked and cleaned up.
- 02Repeated rebasingEvery merge to main moves the base under every other open branch.
- 03Merge orchestrationSomeone has to decide the order in which work lands.
- 04Coordination overheadAgents cannot see who else is changing the same files.
- 05Concurrent conflictsText conflict markers are written for people, not programs.
- 06Lost session contextWhat an agent learned ends with its session.
- 07Fragmented knowledgeDecisions live in chat logs, PR comments and prompts.
- 08Fragile automationScripts around Git break on the edge cases agents hit constantly.
02 — How Strata works
From isolated work to integrated history.
- 01An agent receives a taskTracked with an owner, dependencies and status.
- 02Strata creates a workspaceIsolated, at the current authoritative revision.
- 03Context is retrievedDecisions, discoveries and checkpoints for the task.
- 04The agent submits changesAs a candidate, not a push to a branch.
- 05Strata validates and integratesAgainst current state. Overlaps return as structured conflicts.
- 06History and context persistWith provenance, for the next agent or developer.
03 — Core capabilities
✓ EVALUATED marks areas covered by the reported private evaluation.
Source control primitives for agents.
02✓ EVALUATED
Transactional integration
Changes are integrated against authoritative repository state using concurrency-safe publication mechanisms.
03
Persistent development context
Task intent, decisions, discoveries, provenance, and handoffs survive individual sessions.
04✓ EVALUATED
Structured conflict resolution
Conflicts become actionable data that coding agents can inspect and resolve.
05
Multi-agent coordination
Tasks, dependencies, agent identities, and progress can be managed across concurrent development activity.
06✓ EVALUATED
Git compatibility
Existing Git clients and workflows remain available over Git HTTP and SSH.
07✓ EVALUATED
MCP and native APIs
Agents interact with Strata through purpose-built interfaces over MCP and gRPC.
08✓ EVALUATED
Identity and access control
Human users and agents have distinct identities, permissions, and delegated authority.
09✓ EVALUATED
Self-hosting
Run Strata on your own infrastructure, with backups and recovery.
04 — Git compatibility
Keep Git. Change the workflow.
Developers keep cloning, fetching and pushing with the Git clients they already use, over HTTP or SSH. Agents work through Strata's native interfaces: they get a workspace, submit candidates, receive structured conflicts and read and write context. Both paths read and write the same authoritative repository state.
Compatibility is scoped to the operations covered by tests. The Git compatibility reference lists supported operations and known limitations.
DevelopersGit clientsclone · fetch · push
Coding agentsNative interfacesworkspace · submit · conflict · context
GIT HTTP / SSH
MCP · gRPC
AUTHORITATIVE REPOSITORY STATEone history · provenance per change
POSTGRESQL · S3-COMPATIBLE OBJECTS
05 — Multi-agent development
Three agents, one repository.
Two changes integrate cleanly. The third overlaps and comes back as a structured conflict instead of being merged silently. Integration safety means acknowledged changes are not lost; it does not make the combined code semantically correct. Your tests and review still do that.
Fig. 05 — Concurrent integration · step 1 / 9 · Illustrative simulation, not a live backend
Tasks assigned
main
Keyboard: focus the figure, ← → to step, R to reset.
06 — Persistent context
Your agents forget. Your repository shouldn't.
Agents record what they learn as structured context: task objectives, architectural decisions, implementation discoveries, progress checkpoints and handoffs. Each record carries its source revision and a status, so it can be verified or superseded as the code moves on.
Strata stores what agents explicitly write. It does not read a model's private reasoning. Context is evidence, and the next agent checks it against the current repository state.
07 — Concurrency evidence
Built for concurrent development. Tested with 100 agents.
- Distinct agents submitting concurrently
- 100
- Acknowledged changes
- 100
- Acknowledged changes lost
- 01
- Agents in the integration and conflict-resolution test
- 3
1 — Controlled evaluation on a single private deployment backed by PostgreSQL and S3-compatible storage. The results describe behaviour under those test conditions. They are not a scalability limit, a throughput benchmark or a production reliability guarantee.
08 — Architecture
Infrastructure, not another coding assistant.
Strata is not an LLM and does not write code. It is the system of record that coding agents and developers work against. The backend is written in Go and ships as Docker containers, with PostgreSQL for metadata and S3-compatible object storage for repository content.
It does not depend on a particular model provider. Any agent that speaks MCP, the native API or Git can use it.
Clients
Git clients
Claude Code
Codex
Other MCP agents
Interfaces
Git HTTP / SSH
MCP
gRPC API
Identity
Users & agents
Permissions
Delegation
Core
Workspaces
Integration
Context store
Coordination
Storage
PostgreSQL
S3-compatible
09 — Self-hosting
Your code. Your infrastructure. Your control.
Strata is open source and runs on infrastructure you operate. Repository content, context records and identities stay inside your network. The installation guide covers prerequisites, configuration, backups and recovery.
| runtime | Go services in Docker |
|---|---|
| metadata | PostgreSQL |
| objects | S3-compatible storage (evaluated on Ceph) |
| access | Git HTTP / SSH, MCP, gRPC |
| status | EVALUATION · NOT YET PRODUCTION-READY |
The current deployment has passed evaluation of PostgreSQL, S3-compatible storage, Git HTTP and SSH, IAM, MCP and gRPC, recovery and backups. Strata has not been declared production-ready; the roadmap lists what remains.
Your agents should collaborate, not compete for the same branch.
Give coding agents a shared development foundation built for concurrency, context, and safe integration.
Explore the Documentation →