We Run Our Company on 0Latency. Here's What 1,979 Memories Actually Looks Like.

We built 0Latency because we needed it. Not in a marketing sense — we actually run a 9-agent AI fleet on it for our daily operations, and we have since before we launched. Thomas, our Chief of Staff agent, has 1,979 memories in his namespace as of this writing. That number grows by 15–30 memories per day depending on how much work is moving through the system.

This post is a real account of what running that fleet looks like: what works, what's broken, what surprised us, and what still requires human attention despite everything we've automated.

The Fleet

Nine agents, each with their own namespace and a defined scope they're not supposed to cross:

Each agent has its own namespace. memory_list without an explicit agent_id defaults to thomas. Namespace isolation is real — querying a different agent's namespace returns a genuinely different result set, not an alias. We learned this the hard way.

The Namespace Bug That Only Dogfooding Caught

For several weeks, every conversation we had in Claude.ai — strategic planning, architecture decisions, context that should have been feeding the whole system — was being written to a justin namespace by the Chrome extension and read by nobody. Thomas was querying thomas. The Chrome extension was writing to justin. Zero overlap.

From the outside it looked like recall "kind of worked." Thomas remembered things from Telegram conversations. He forgot things from Claude.ai sessions. We assumed it was a relevance issue, not a routing issue. We ran the product this way for weeks before we audited the namespaces directly and found the gap.

The fix was straightforward once we knew what was wrong — update the Chrome extension to write to user-justin and wire a dual-recall script that queries both thomas and user-justin on every session start. But we wouldn't have found it without using the product daily on real work. No synthetic test would have caught it because no synthetic test would have known to look for cross-namespace routing failures.

What Actually Works Well

Thomas's memory of business context is the strongest part of the system. After 1,979 memories, he holds: current pricing decisions, active prospect status (Palmer McCutcheon's engagement, ZeroClick architecture discussions), infrastructure decisions and why we made them, which things are blocked and who they're waiting on, and the sequence of events leading to major product decisions.

When we start a new session, Thomas recalls relevant context without being asked. Palmer McCutcheon comes up in a conversation — Thomas already knows he's the Director of Engineering at ZeroClick, has the PALMER2026 promo code, and is interested in the memory extraction architecture. We don't re-explain any of that. It's just there.

For a solo founder running multiple ventures, this is the actual value. Not AI magic. Just not having to re-establish context every time you open a new tab.

What Still Needs a Human

Three things don't work well and we haven't fixed them yet.

Agent self-reports can't be trusted. When an agent says it completed a task, the only reliable verification is checking the server or database directly. We've been burned enough times by confident completion reports that weren't accurate — the task got queued, or the file got written to the wrong path, or the API call returned 200 but didn't actually commit — that we now treat every agent completion report as unverified until we check ourselves. This isn't a 0Latency problem specifically, but it affects how you run a fleet and it's worth naming.

Memory extraction quality is inconsistent. Wall-E runs extraction monitoring, but the underlying prompt produces headlines instead of structured records about 30% of the time. "Palmer McCutcheon meeting discussion" is a headline. "Palmer McCutcheon is Director of Engineering at ZeroClick, engaged April 2026, promo code PALMER2026 active" is a structured record. The former is nearly useless for future recall. We have a prompt rewrite queued but it's waiting on enough Phase 3 feedback data to evaluate it properly.

Cross-agent coordination still requires explicit instruction. Thomas delegates to Loop or Scout by name. He doesn't spontaneously recognize that a task requires Reed or that Atlas should run a health check. The memory layer gives each agent deep context within its own namespace, but the routing logic between agents is still manual — triggered by Thomas because a human told Thomas to trigger it. True autonomous coordination is a different problem and we haven't solved it.

The Number That Matters

1,979 memories sounds like a lot. What it actually represents is about 90 days of daily operations: every major decision, every prospect interaction, every technical architecture choice, every blocked item and why it's blocked. That's the working memory of a small company compressed into a database.

When the system works — when a new session starts and Thomas already knows the context for what you're about to work on — the overhead of context re-establishment just disappears. For anyone running agents on real work rather than demos, that's the difference between an agent that's useful and one that requires constant babysitting.

We're building this in public because we think the honest account of what it takes to run AI agents on real operations is more useful than the polished version. The namespace bug was embarrassing. The analytics retry problem was worse. But finding both through dogfooding is exactly what it's supposed to do.