Argon vs DumboDB: What DoltHub’s Comparison Got Right

DoltHub compared Argon with DumboDB and measured both. Their account of Argon is accurate. Our own measurements, the trade-off, and what we are changing.

By Argon Labs11 min read
ComparisonMongoDBBranching

Current capability notes: checkout materializes a physical database; native actor attribution is per branch/run; undo needs complete images and retained history. CLI sandboxes require watch and scheduled sweep. Read the capability matrix.

On November 10, Neil Macneale of DoltHub published Version Control Database Spotlight: Argon. DoltHub is building DumboDB, a MongoDB-compatible database with version control in its storage engine, and the article compares it with Argon: how Argon works, a side-by-side table, and benchmarks at ten thousand, a hundred thousand and a million documents.

Thank you to Neil and to DoltHub. They read our code and documentation closely enough to describe Argon correctly, they were generous about what it does well, and they published numbers. This is our response. The short version:

  • Their description of Argon is accurate. We go through their table row by row below.
  • The pattern in their benchmark is real. We ran the same steps on Argon 2.4.0. A new sandbox, a diff and a merge preview each take time in proportion to the number of documents in the database, not the number that changed.
  • The gap comes from a design decision on each side. Argon has a real mongod execute every query. DumboDB is its own engine. Each side gives up what the other is good at.
  • Part of the gap does not have to exist. Diff and merge preview can compare only the documents that changed. That work is tracked in a public issue.

What Argon is

For readers arriving from their article: Argon gives AI agents MongoDB sandboxes. A sandbox is a real MongoDB database, forked from your data or from a pinned state, that an agent reads and writes with ordinary drivers. When the run ends you read the diff, then merge it, undo it or throw the sandbox away. Branches, captured history and merge are how that works underneath. Argon runs beside a MongoDB deployment you already have. It does not replace the database.

What they got right

Their side-by-side table has nine rows. Here is each statement about Argon, in our words, and whether it holds for Argon 2.4.0.

DoltHub's statements about Argon and whether each is accurate
Their statement about ArgonAccurate?Detail
Queries run on stock mongod, version 6 or newer, as a replica setYesThis is the design, and the reason for most of the rows below.
History is a numbered sequence of captured writes, with no commitsYesA pin names a state you want to keep. The reviewed unit is a branch's diff against its parent.
argon gc removes history older than the retention window, seven days by default, unless a pin protects itYesIt runs when you run or schedule it, and it removes only entries that a snapshot already covers.
Using a branch means checking it out, which copies it into a new databaseYesCreating the branch is a metadata write. The checkout is the copy.
Reading the past is rebuilt in memory, without indexes or aggregationYesThat is argon time-travel query. To run aggregation on an old state you fork it with argon restore branch and check that out, which is another full copy.
Merge goes from a branch into its parent, compares whole documents, and takes one resolution for the whole mergeYesTwo branches that change different fields of one document conflict. argon merge apply resolves every conflict in a plan the same way, theirs or ours.
Documents are versioned; indexes, validators and collection options are notYesA checked-out branch has the _id index and no others until you create them.
History lags the write, and capture can fall behind or have gapsYesCapture reads MongoDB's change stream after the write is acknowledged. When it cannot record a change exactly, Argon marks the branch's history incomplete and refuses to diff it.
Every checked-out branch is a full copy in mongodYesBranches do not share storage once checked out.

We have nothing to correct. Their account of how a diff and a merge are computed is also right: Argon rebuilds the state at the fork point, the branch and its parent from its log, then compares them one document at a time.

The merge row deserves an example, because it is the one most likely to surprise you. We gave two sandboxes the same product. One changed its price and was merged. The other changed its quantity, and its preview reported a conflict, although the two never touched the same field:

$ argon merge preview -p shop -b agent-b
Merging agent-b → main
  CONFLICT products/~argon:bson:DAAAABBpAAEAAAAA (both sides changed since the fork)
0 change(s), 1 conflict(s)

Plan 6afd0ed9e11370547863c59a saved (pending).
Apply with: argon merge apply 6afd0ed9e11370547863c59a --strategy theirs|ours

The long identifier is how the CLI prints an _id that is not a string, here the integer 1. Applied without a strategy, the plan is refused. Applied with theirs, it goes through:

$ argon merge apply 6afd0ed9e11370547863c59a --strategy theirs
Merged: 1 change(s) applied, 1 conflict(s) resolved via --strategy theirs.

Afterwards the main branch held the second sandbox's quantity and the original price. The first sandbox's price change was gone, because theirs takes the whole document. Argon never resolves a conflict silently, but resolving this one well means reading both versions yourself.

What we measured

Their article does not say what machine, document shape or method produced its numbers, so we could not repeat their run. We ran our own on the evening of November 17, 2026, US Eastern time, and published the script, the environment and every sample.

  • Argon 2.4.0, the binary that npm install -g argonctl installs, and MongoDB 7.0.45 as a one-node replica set. Both ran in containers on one Apple M6 laptop under Docker Desktop.
  • One collection of ten thousand, a hundred thousand and a million documents of about 236 bytes each, with the _id index only.
  • The steps in their tables: initial import, a new branch to its first read, a new sandbox to its first read, 100 and 10,000 updates through the driver, diff, merge, and point reads by _id.
  • Five runs of each step at each size. Each timing covers a whole CLI command, as you would wait for it in a terminal.

We measured Argon only. We did not run DumboDB, and its numbers are DoltHub's. Every figure below comes from the benchmark report, which has the raw samples, the spread of each step and the conditions of the run. These are medians.

Argon 2.4.0, median of whole CLI commands by number of documents
Step10,000 documents100,000 documents1,000,000 documents
New branch to first read96 ms584 ms8,472 ms
New sandbox to first read114 ms852 ms7,776 ms
argon diff, 100 documents changed101 ms348 ms7,088 ms
argon diff, 10,000 documents changed179 ms617 ms8,491 ms
argon merge preview, 100 changed99 ms351 ms6,045 ms
argon merge apply, 100 changes42 ms39 ms112 ms
argon merge apply, 10,000 changes1,952 ms2,164 ms6,421 ms
Bulk update of 100 documents3.0 ms3.3 ms7.2 ms
Bulk update of 10,000 documents151 ms168 ms820 ms
Point read by _id78 µs81 µs129 µs
argon import database0.2 s1.9 s28.4 s
Peak memory of one argon diff112 MiB541 MiB5,016 MiB

Read the last column with care. The million-document tier ran once, while unrelated containers were running on the same machine, and its samples are spread widely: the diff of 100 changed documents ranged from 4.8 to 14.9 seconds. The two smaller tiers were run twice, with similar results.

Here are the three operations their article leads with, at ten thousand, a hundred thousand and a million documents, beside the figures they published. Ours is a diff with 100 documents changed, and a merge preview plus its apply. Theirs come with no description of the method, so the columns are not a controlled comparison.

New branch, diff and merge: our Argon figures beside DoltHub's published figures
StepArgon, our runArgon, DoltHub's figuresDumboDB, DoltHub's figures
New branch to first read96 / 584 / 8,472 ms500 / 4,000 / 47,200 ms3 / 3 / 4 ms
Diff101 / 348 / 7,088 ms500 / 2,200 / 23,700 ms4 / 4 / 5 ms
Merge142 / 393 / 6,134 ms500 / 2,300 / 24,100 ms3 / 4 / 4 ms

What the numbers show:

  • A new sandbox, a diff and a merge preview grow with the database. Each takes longer with every tenfold step in document count, and at a million documents each takes seconds. Creating the branch takes milliseconds at every size. The time is in the checkout.
  • The size of the change barely matters to a diff. With a million documents in the database, a diff of 100 changed documents and a diff of 10,000 took about the same time.
  • Applying a merge follows the size of the change. argon merge apply writes a saved plan, so 100 changes apply quickly at every size. Some applies took longer and used far more memory, in a pattern that fits Argon's automatic snapshots of the target branch; we did not trace it further.
  • Diff and merge preview hold three states in memory. At a million of these small documents, a single diff process peaked at several gigabytes of resident memory. Their article did not measure memory, and you should know this before pointing Argon at a large collection.
  • Reads and writes are MongoDB's. Point reads and bulk updates on a checked-out branch go to mongod directly. Argon records a write in its history after MongoDB has acknowledged it, a fraction of a second later in our runs.
  • Our absolute times are lower than the ones they published for Argon, by a factor of roughly three to seven for those three operations. We read nothing into that: it is a different machine and a different document, and we do not know their method. It does not change the conclusion. At a million documents these three operations take seconds in Argon, and DoltHub reports a few milliseconds for DumboDB.

Why the two behave this way

Both designs follow from one question: what executes the query?

Argon: MongoDB executes it

On a checked-out Argon branch every read and write goes to mongod: the query planner, index types, aggregation stages, transactions and driver behavior are MongoDB's, because it is MongoDB. Argon keeps history beside it, by reading the change stream into its own log.

The price is the one their article measured. mongod can only serve a branch that exists as a database, so a sandbox is a copy. And MongoDB's storage does not know which documents differ between two branches, so Argon works that out from its log. Compatibility also stops at the engine: a sandbox does not carry your indexes or validators.

DumboDB: its own engine executes it

DumboDB implements the MongoDB 8.0 wire protocol itself, on the storage engine DoltHub built for Dolt. That storage shares structure between versions. A new branch is a new pointer into data that is already there, and a diff or merge only has to visit what differs. This is why their numbers barely move as the collection grows, and it is a real advantage.

The price is that every MongoDB behavior has to be built again. DumboDB's README is candid about where that stands. On November 17, 2026 it described DumboDB as “pre-1.0 software and not yet ready for production use” and listed, among others, these differences from MongoDB:

  • TTL expiry (expireAfterSeconds) is rejected, and support is not planned.
  • Capped collections are rejected, and support is not planned.
  • Atlas features such as Search indexes are not supported, and support is not planned.
  • Documents are stored with their keys sorted, so a legacy geo point stored as an embedded document is not treated as a point.
  • An encoded key, an _id or an index entry, can be at most 1024 bytes. MongoDB accepts much larger keys.
  • It can join a MongoDB replica set as a non-voting member. General replica-set operation and sharding are out of scope.

Its roadmap lists query parity with MongoDB among the things to finish before a beta. None of this is a criticism. It is what the early life of a database engine looks like, and DoltHub has been through it before: Dolt has been a version-controlled SQL database since 2019, years before Argon existed. If none of those gaps touches your application, they cost you nothing.

Which one to choose

Look at DumboDB first when:

  • Version control is the main thing you do with the data: many branches, and frequent diffs and merges on large collections.
  • You want what their article lists for it: every commit kept, merges between any two branches, and conflicts resolved one document at a time.
  • You can run a pre-1.0 engine, as the database or as a non-voting member of your MongoDB replica set, and its listed gaps do not touch your application.

Look at Argon first when:

  • The data already lives in MongoDB, and the engine that answers queries has to stay mongod.
  • The work is agent runs: a sandbox per run, a diff a person reads, then a merge or a discard, with undo by actor, TTL cleanup and an MCP server.
  • A full copy per sandbox is affordable at your data size. Measure that before you decide; the script below does it.

Their article ends on the same split: an application that diffs and merges constantly is DumboDB's case, and one that branches and merges rarely may be better served by Argon. We agree with that, and we would add the engine question above to it.

What we are changing

One part of the gap is not required by the design. Argon's log already records which documents a branch wrote after its fork point, so a diff or a merge preview does not need to rebuild and compare every document to find them. Making both compare only changed documents is tracked in issue 112. We are not giving a date.

These gaps are known, and not scheduled:

  • Sandbox readiness. A sandbox is a full physical copy, so it takes longer and uses more storage as data grows.
  • Per-document conflict resolution. A merge plan takes one strategy for all of its conflicts.
  • Indexes and validators in sandboxes. A sandbox starts with the _id index only.

If one of these blocks you, say so in the issue tracker. It changes what gets built first.

Run the measurement yourself

The script needs Docker and Python 3 on the host. It starts MongoDB and a container with Argon from npm, publishes no ports, and removes both when it finishes.

git clone https://github.com/argon-lab/benchmarks
cd benchmarks
scripts/cli_scale_docker.sh 2.4.0 results/cli-scale --sizes 10000,100000,1000000

The million-document tier needs about 10 GB of memory free in Docker, and the whole run took a little over ten minutes on our laptop. The run stops with an error unless every diff and every merge plan lists exactly the documents that were updated, and every merge is found in the main branch. This is the last merge of the million-document tier in our run:

$ argon merge apply 6afd0d1334d33284724663e9 --output json
{
  "applied": 10000,
  "conflicts_resolved": 0,
  "plan_id": "6afd0d1334d33284724663e9"
}

Limits of our measurement

  • One laptop, with MongoDB and the CLI in containers. Other hardware will give other numbers.
  • One collection, small documents, the _id index only, a one-node replica set and no other clients on the database.
  • Five runs per step. That shows how a step grows. It does not establish tail latency.
  • The million-document tier ran once, while unrelated containers were running on the same machine. The two smaller tiers were run twice, with similar results. The report says which samples were affected.
  • We do not know DoltHub's method, so the two sets of Argon numbers are not a controlled comparison.
  • We did not run DumboDB.

Thanks again to Neil and DoltHub for the review. To try Argon, start with the local quickstart. To see how the other branching tools differ, read database branching tools compared.

Frequently asked questions

What is the difference between Argon and DumboDB?
Argon keeps branch history beside a stock MongoDB replica set and copies a branch into a real database when you check it out, so MongoDB itself runs every query. DumboDB is DoltHub's own document database that speaks the MongoDB wire protocol and stores branches in shared storage, so a new branch, a diff and a merge do work in proportion to what changed.
Is DumboDB faster than Argon?
For getting a new branch ready, diffing and merging on large collections, yes, by a wide margin: DoltHub measured it, and our own run of Argon shows the same growth with document count. For ordinary reads and writes on a checked-out branch, DoltHub's numbers have Argon ahead, because those are MongoDB's own reads and writes.
Does Argon copy the data for every sandbox?
Yes. Creating a branch is a metadata write, but a sandbox includes a checkout, which writes a full physical MongoDB database. Its time and storage grow with the data.
Does the time of an Argon diff depend on how many documents changed?
Not in Argon 2.4.0. A diff or merge preview rebuilds the fork point, the branch and its parent in full and compares every document, so it takes about as long for 100 changed documents as for 10,000. Applying a saved merge plan does depend on the number of changes. Comparing only changed documents is tracked in a public issue.
Is DumboDB compatible with MongoDB?
It implements the MongoDB 8.0 wire protocol in its own engine and works with standard drivers and mongosh. Its README, read on November 17, 2026, describes it as pre-1.0 and not yet ready for production, and lists features it does not support, including TTL indexes, capped collections and Atlas Search.
Did Argon benchmark DumboDB?
No. We measured Argon only. Every DumboDB number we refer to is DoltHub's own, from their article.