Argon — MongoDB sandboxes for AI agents

Give every agent run its own real MongoDB database, forked from your data.
Review what it changed, merge what you want, discard the rest. Git-style
branching, time travel and merge underneath. Any driver, real mongod.
Three ideas, thirty seconds:
- A sandbox is a real MongoDB database — forked from a branch or a pinned
dataset, checked out and given a TTL in one command. pymongo, mongoose,
mongosh, indexes, aggregation, transactions: all real.
- What the agent wrote is a diff — supported document writes become
history while capture is healthy, so a run can be reviewed, merged as a data
pull request, undone or thrown away. Your source data is untouched until you
merge.
- Underneath, it is Git for MongoDB — a branch is a pointer created with a
metadata write; checkout separately materializes the data. Diff, merge, undo
and pins work within the configured retention and capture guarantees.
Install
For npm, use Node.js 24 LTS with npm 11.16 or newer. The package-scoped
approval allows the installer to download Argon's binary on npm 12.
brew install argon-lab/tap/argonctl
npm install -g argonctl --allow-scripts=argonctl
docker run -d --name argon-mongo -p 127.0.0.1:27017:27017 mongo:7 --replSet rs0
docker exec argon-mongo mongosh --quiet --eval 'rs.initiate({_id:"rs0",members:[{_id:0,host:"localhost:27017"}]})'
argon doctor
Use a current supported MongoDB patch release in production. Source builds use
Go 1.26.11 or newer, as declared in go.mod. Use a patched toolchain: on the
Go 1.27 line that means 1.27.4 or newer, which carry the same standard-library fixes.
The flow
your data ──sandbox──▶ mongodb://… ← the agent, any driver
│
argon diff ──────┤ what the run changed
▼ ▼
merge (a data PR) or discard / undo
argon import database --uri mongodb://localhost:27017 --database myapp --project myapp --source-quiesced
argon sandbox create -p myapp --ttl 1h --watch --actor agent:run-1
argon diff -p myapp -b <sandbox>
argon merge preview -p myapp -b <sandbox>
argon merge apply <plan-id>
argon sandbox discard -p myapp -b <sandbox>
Through the MCP server or argon console, capture and expiry are managed for
you: nothing stays in the foreground, and expired sandboxes are swept every
minute. --watch needs 2.3.0 or newer; on older versions run
argon watch -p myapp -b <sandbox> --actor agent:run-1 after creating the sandbox.
Long-lived branches work the same way with argon branches create and
argon checkout, and argon restore reset rewinds a branch to an earlier time.
Prefer clicking? argon console serves a local web console (UI + REST API),
supervises capture, reaps expired sandboxes every minute, and opens your browser.
The console's MIT-licensed source is in web/; see the
rebuild instructions.
For a complete managed workflow, run the two-agent pinned dataset example.
For AI agents
claude mcp add argon -- argon mcp
python3 -m pip install 'argon-agents[langgraph]==0.2.0'
Start argon console --no-browser in another terminal, then:
from argon_agents import ArgonClient, ArgonCheckpointSaver
argon = ArgonClient("http://127.0.0.1:1818")
argon.get_or_create_project("myapp")
saver = ArgonCheckpointSaver.from_sandbox(argon, "myapp")
plan = argon.merge_preview("myapp", saver.sandbox.branch)
print(plan)
argon.create_pin("myapp", "eval-v1")
run = argon.sandbox_from_pin("myapp", "eval-v1")
saver.merge() is a convenience call that previews and applies immediately;
use the separate calls above when approval is required. Pins protect captured
document state while they exist; keep independent backups.
To keep a person in the loop, withhold tools from the MCP server:
argon mcp --disable-tools argon_merge_apply leaves applying a merge plan to
argon merge apply <plan-id>, and argon mcp --read-only offers only the
tools that inspect state.
The full agent workflow: docs/AGENTS.md.
What you get
| Command | In one line |
|---|
| Sandboxes | argon sandbox create --ttl 1h | fork + checkout + TTL in one step — disposable agent workspaces |
| Dataset pins | argon pin create / pin sandbox | named captured states protected from GC and resets while the pin exists |
| Data PRs | argon merge preview/apply | three-way merges as reviewable plans; conflicts never silent |
| Undo | argon undo --actor <a> | revert a range or actor label; append-only, conflict-aware |
| Real databases | argon checkout / argon proxy | any driver, real mongod; proxy serves stable mongodb://host/<project>~<branch> URIs |
| Write capture | argon watch | exact change-stream images → history, one actor label per branch |
| Branching | argon branches create | a metadata write — instant, zero copy |
| Time travel | argon time-travel query | query captured document states at retained LSNs; restore/pin also accept timestamps |
| Restore | argon restore preview/reset/branch | rewind a released branch or fork retained history |
| Web console | argon console | local UI + REST API in one command |
Data history covers document inserts, updates, replacements and deletes. Collection
drop/rename produces degraded capture; indexes and collection options are not
versioned. Native writes are asynchronous; control operations drain capture.
Stop writers before release. Existing pins protect their referenced states, while GC can expire audit
and undo history. See operations for recovery and credentials.
Two things to know before handing a sandbox to an agent. A collection the agent
creates is captured exactly while capture is running, or when it is next
synchronized within MongoDB's snapshot history (five minutes by default); the
one exception is a document that is updated and then changed again inside one
transaction on a collection created moments earlier. Before 2.3.1 such a collection needed
argon collections prepare first. And a sandbox is a full physical copy with
capture ready, so creating one takes longer as the data grows: the
benchmarks measure it as
sandbox_capture_ready_ms.
Storage retention uses snapshots + retention-window GC to keep state plus a
window of history, not every write forever. Details and the consistency
model, stated honestly: ARCHITECTURE.md.
Documentation
| |
|---|
| Quick start | install → first merge, step by step |
| CLI reference | every command |
| Agents | sandboxes, pins, MCP, REST API, argon-agents, proxy |
| Architecture | how it works and what it guarantees |
| Operations | deployment, chunk stores (S3/FS), GC, v1→v2 migration |
| Performance | every number lives in the reproducible benchmarks — none here, by policy |
Issues ·
Discussions ·
Contributing ·
argonlabs.tech · Blog
Contributors
Thank you to everyone who has made Argon better.
What each person shipped, and the release it shipped in, is listed at
argonlabs.tech/about#contributors.
Every release also names its new contributors in the
release notes.
New here? Start with a
good first issue
and the first-contribution guide.
Give your MongoDB a time machine. Branch without fear. ⭐