MongoGov: One Day to Give Agent Memory a Code Review

Built in one day, from scratch, at Agents in Context Toronto (MongoDB), Nov 14, 2026 — problem track: "Memory You Can Govern."
The problem with a support agent that remembers
A support agent with memory sounds obviously good, until you watch how the memory gets in. One fix works once, gets a thumbs-up, and quietly becomes permanent team knowledge. A new ticket that merely looks like an old one retrieves the old fix at high similarity and applies it with confidence. And a fix that was right in March keeps coming back in November, because nothing ever withdraws it.
MongoGov is the version where memory has to earn its place:
Nothing becomes team knowledge until a named human approves it, and every use leaves a receipt.
Code review, but for memory
The mental model that made it buildable in a day: treat every learned fix the way a team treats code.
- A candidate fix is a pull request — it does nothing until someone merges it.
- Promotion by a different person is the merge.
- An evidence check is a failing CI check — a recalled fix with weak evidence is blocked, even at 0.93 similarity.
- Supersede and forget are the revert.
- The actor stamps on every record are the blame.
Six rules run the whole system: human approval before a memory goes active (G1), team isolation inside the vector search itself (G2), the evidence veto (G3), a confidence floor that holds tickets for human review instead of auto-closing them (G4), correction and forgetting by people, never by a clock (G5), and a hash-chained receipt for every step, so a killed run can resume without repeating finished work (G6).
The demo story is one support ticket, end to end: it comes in, the agent works it the slow way, a human promotes what it learned — and the next similar ticket takes the fast path, while a lookalike ticket with a trap fix gets vetoed. The 85-second film below is that story.
Watch the 85-second demo on YouTube →
What we measured that day
Same incident, five repeat tickets, in the Atlas sandbox:
| Condition | Tool calls (5 repeat tickets) | Mean calls |
|---|---|---|
| Empty memory | 7, 7, 7, 7, 7 | 7.00 |
| After human approved the fix | 6, 3, 3, 3, 3 | 3.60 |
Three lookalike tickets — similar words, different fault — stayed on the slow path (7 calls each), resolved correctly, and the wrong memory was vetoed 3 times out of 3. A run killed mid-flight resumed from its receipts 10 times out of 10 without repeating completed work. 34 tests in total.
And the limits, because they are part of the result: all tickets in this sandbox measurement were synthetic, and the similarity scores are probably optimistic. The --as NAME approval stamp is an unauthenticated label, not identity verification — MongoGov claims a governance workflow, not access control. One honest gap: a lookalike whose nearest memory is a well-approved fix is not vetoed, and no such case was in the held-out set.
Then we pointed it at real tickets
The sandbox tickets were synthetic — I wrote them, so of course they behaved. The same day, we also ran MongoGov against a real corpus: 8,469 actual customer-support tickets (a public Kaggle dataset, CC0, used via its Hugging Face mirror; the customer email column was never touched).
Real data taught us things synthetic data could not. First, the mess is real: 36.9% of the tickets — 3,126 of them — had the identical, contentless body: "I'm having an issue with the {product}. Please assist." That is the queue a support team actually faces. A memory system fed raw tickets learns from that, which is exactly why governance is not decoration — it is the filter between a ticket queue and team knowledge.
The recall machinery held at scale. In a run seeded with 923 memories answering 1,505 queries against a real Atlas cluster, repeat tickets found the right fix family 97.4% of the time (520 of 534), and recall latency stayed flat at about 200 ms from p50 to p95. In a smaller smoke test before it, repeats matched 6 of 6 and truly contentless tickets were blocked 6 of 6 — and the block came from the track-record check, not from similarity.
Two honest failures came with it. About 40% of the scale-run seeds never became searchable during the run — an index-visibility plateau we measured, not a recall failure — which mechanically depressed the transfer score to 24%. And the vague-ticket result reversed at scale: 280 of 300 "vague" tickets still attached to a memory, because at scale those tickets carried a real issue paragraph under the vague opening, so the gate attached them by design. The clean 6-of-6 block applies to genuinely empty tickets only.
So the two testbeds answer different questions. The sandbox measured the governance effect (7 calls down to 3.60). The open data checked whether the recall underneath survives contact with real tickets — mostly yes, with the failures named above. The open-data runs are supporting evidence, not the headline; the headline stays the sandbox numbers.
What I would do differently
MongoGov did not make the final six, and the reason taught me more than the build did. Look at the evidence on this page: the project was proved — a staged sandbox eval, a kill-and-resume test, a tamper test, and a 1,505-query run against real tickets, all inside one day, all code written that day. What it did not have was an equally grounded story: one ordinary ticket, on one ordinary Tuesday, in the queue a support team actually works. I led with technical depth; the teams that landed led with a visible moment and plain words, depth underneath.
That is the lesson I now carry into any MVP: prove it enough to be honest, then spend the remaining effort on the day-to-day story — the Swiss Army knife kind of story, small, useful, and instantly understood — because a well-proved system nobody can picture in their own workday does not ship. It is also why the demo film tells one ticket's story instead of listing rules. That lesson is now how I present everything, including this site.
Why it is on this site
MongoGov is a one-day exploration of the governance questions behind my longer-running project, Agent Memory Bridge — how a later session recalls project decisions, with their sources and revision history. AMB itself has no approval queue: whatever an agent's tool call saves is saved, so what gets kept depends on what I ask my agents to store. The hackathon asked the stricter question — what if a memory needed a different person's approval before any agent could use it, and left a receipt every time it was used? That experiment is what this page documents. The hackathon version runs on MongoDB Atlas; the questions carry back into the longer project. I came away with more questions than answers, and I'm glad I went.