ACE's engineering work — NetSuite, Shopify, identity, infrastructure — runs through AI agent sessions across multiple machines, and those sessions are stateless by default: close one, and its decisions and reasoning are gone. AceMem gives them durable, queryable memory. What one session learned about NetSuite role permissions or Shopify pricing tiers is available to the next, on any machine.
Requirements
Memory had to be shared across machines, not per-machine. It had to support team-wide search without exposing anything private in either direction. And it had to fail safe as the tooling around it updated and changed behavior, rather than silently forking state. Before committing to a custom build, the design was benchmarked against the current agent-memory landscape — mem0, LangMem, Honcho, and Supermemory — as reference points for the write path and memory model.
Architecture
All memory lives on a single always-on hub — one place every agent reads and writes, with live updates and a searchable web viewer — so every machine sees the same history. Storage is layered: SQLite as the primary store, a PostgreSQL mirror for durable structured queries, a vector database holding embeddings for semantic search over past work, and a hand-curated index on top as a fast, human-readable entry point. Every other machine is a client of that hub over a private network, and clients hold no state of their own.
Retrieval is hybrid, in the RAG sense: semantic search over vector embeddings answers "have we solved something like this before," structured SQL answers exact lookups, and the curated index is the fast path into both. The corpus isn't scraped documentation — it's the team's own engineering decisions, captured as observations at the end of each agent session and retrieved into the context of the next.
Search is split by visibility
Personal search only ever returns your own observations; team search surfaces what colleagues have explicitly shared, with attribution. A request for an observation that doesn't exist and a request for one that exists but isn't visible to you return the identical 404, so the API never reveals whether something is there.
The viewer UI and MCP tools never see raw datastore credentials either — they go through a device-token proxy, so a compromised client-side token can't be replayed against the database directly. On the client side, every agent run gets its own on-disk worktree snapshot, so parallel agents working the same project can't clobber each other's file-level state mid-run.
Outcome
The practical effect: an ERP permission quirk debugged in May doesn't get re-debugged in August, and a pricing convention decided on one machine is known on every machine. AceMem is live and in daily use, holding on the order of 900,000+ tokens of past engineering work, retrievable at about a 98% reduction in context load versus replaying full session transcripts — agents stay grounded in past decisions without spending their context window to get there.
One design rule came out of real operation: a client machine never falls back to local storage. A tooling update once broke a client's hub connection and an automated session quietly forked to a local database; roughly 700 observations were migrated back once it was caught, and no-local-fallback is now enforced as a standing configuration rule rather than left to judgment.