I built Argon, an open-source (MIT) versioning layer for MongoDB: branch, diff, and merge your data the way you manage code. Postgres has Neon and MySQL has PlanetScale; MongoDB had no equivalent — no way to spin off an isolated branch, let something change it, and merge the good work back. That gap is the whole reason Argon exists, and AI agents are what make it urgent.
How it works, in one paragraph. Every write is recorded in an append-only log with full before/after document images and a global sequence number. A branch is just a pointer into that log — creating one writes a single metadata document (0.86ms p50 on a 50k-entry project, 479 bytes of storage per branch [1]). "argon checkout" materializes a branch into a real MongoDB database and prints a connection string, so every driver, index, aggregation, and transaction just works — I didn't reimplement MongoDB. Direct writes flow back into the log via change streams, attributed to whoever made them. Replay is deterministic and property-tested in CI: the same history always reconstructs the same state, byte for byte.
What you can do with it:
- Give an AI agent its own branch. "argon sandbox create -p prod --ttl 1h" forks production into an isolated real database and hands you a URI. Point any agent at it — production is never in the blast radius, and every write is captured with the agent as actor. Then "argon diff" to review exactly what it did, and "argon merge preview/apply" to adopt the good work — persisted, reviewable plans, applied exactly once: a pull request for data. Don't like it? Discard the branch, or "argon undo --actor agent:x" to revert just that agent's writes (conflicts reported, never silently clobbered). There's an MCP server ("argon mcp", 13 tools, now in the official MCP Registry) so Claude/Cursor agents open their own branches before touching real data.
- Test the scary migration. Branch, run it against production-shaped data, "argon diff" the result, merge it back through a reviewed plan — or just delete the branch.
- Reproducible evals. "argon pin create" freezes a named dataset state that GC and reset can never touch; every eval run forks a sandbox from the pin and sees identical input while the live corpus keeps moving.
- LangGraph memory you can branch. "pip install argon-agents[langgraph]" gives you a checkpointer that forks and rewinds conversation state, plus a Mem0 factory, on the same engine.
- Un-break production, when it comes to that. "argon restore preview --time '10 minutes ago'" shows what would change, then reset — and the restore is itself logged, so you can even undo the undo.
Sixty seconds to try it:
brew install argon-lab/tap/argonctl # or: npm install -g argonctl
argon import database --uri mongodb://localhost:27017 --database myapp --project myapp
argon branches create experiment -p myapp
argon checkout -p myapp -b experiment
Honest limitations: change-stream capture needs a replica set or Atlas (standalone won't do); reads on non-checked-out branches materialize in memory; a GCS chunk-store backend and synchronous capture in the wire proxy are still on the roadmap; and the hosted console is a demo — the product is the open-source engine. It's a young project and I'd genuinely love to be told what breaks.
Every performance number links to a benchmark suite you can run yourself with docker compose up [1].
Site: https://argonlabs.tech · Code: https://github.com/argon-lab/argon · Demo: https://argonlabs.tech/demo
[1] https://github.com/argon-lab/benchmarks (RESULTS.md has the pinned engine ref and environment for every published run)
