How Is Caura Built?

Models reason. Harnesses execute. Caura remembers. Caura is the governed agent DB for AI fleets: one persistent memory where every authorized agent builds on what the fleet has already learned — across sessions, models and harnesses. It isn’t a vector database with extra features. It is a memory system with governance built into every operation, and with a way to make memory happen by code rather than hoping the model remembers to call a tool.

Three ways memory happens

The first design decision in Caura is not how memories are stored. It is who decides that a memory operation happens at all. There are three answers, and they all run over the same memory, the same policies and the same permissions.

Deterministic — Rail. Rail wraps your agent’s loop. Before every turn it recalls what the fleet knows and puts it in front of the model; after every turn it writes down what was learned. The model never sees a memory tool, so it cannot forget to remember and cannot be talked out of it. When memory is a compliance or continuity requirement, this is the mode. More in Harness Engineering.

Agentic — MCP tools and REST. The classic path: twelve governed tools exposed to the agent, or a REST API for your application. Claude Code, Cursor, Claude Desktop and any MCP client connect with a URL and a key. Here the model, or your code, decides when to remember and when to recall.

Reflective — the Interviewer. Agents are bad at journaling; they are busy doing the work. So on a schedule the Interviewer reads the trail an agent already leaves behind — a Claude Code transcript, a Cursor log — and asks one question: what here is worth remembering? The answers land as ordinary memories, exactly as if the agent had written them. Nobody in the loop. More in Agents Don’t Journal.

The modes compose. Rail is the floor, the tools are the ceiling, and the Interviewer catches what neither did. Harness integrations — LangGraph, CrewAI, Google ADK, the OpenClaw plugin — sit on top.

What happens on a write

The agent sends plain text. Caura works out who wrote it and for whom it is visible, then enriches it: classifies the kind of memory (a fact, a decision, an outcome, a preference…), pulls out the people, products and technologies it mentions and links them into a knowledge graph, checks whether it contradicts something already known, scores how much it matters, screens it for personal data, and indexes it for search. Long content is split into atomic facts. Out comes a structured, attributed memory the fleet can find.

What happens on a recall

Recall is hybrid: meaning-based search and keyword search together, widened through the knowledge graph so that asking about a customer also surfaces their stack, their team and their recent decisions. Results are ranked by relevance, importance, freshness and how useful they have proved before — and filtered by what the caller is allowed to see, so an unauthorized memory is never even a candidate. Every recall is audited. An agent can ask for the raw results or for a one-paragraph brief synthesized from them.

Write. Recall. Act. Evolve.

Memory improves from the result of using it, not from another recall. That fourth step is what most memory systems don’t have. One story:

1. Any agent writes. 09:14 — a marketing agent notes that a competitor cut API pricing by 40%, visible to the whole fleet.
2. Any authorized agent recalls. 11:02 — an R&D planning agent finds it while drafting the sprint brief.
3. The agent acts on it. 11:40 — the brief ships with the pricing change already factored in. No Slack thread, no handoff.
4. The agent reports. The fleet improves. The outcome flows back: recall retunes for that agent, near-duplicates merge, stale facts retire. Next time, the same question ranks it first.

Governed at the boundary

Governance isn’t a policy layer beside the memory; it runs inside every operation. Four things are always true:

• Four nested boundaries. Organization, tenant, fleet, agent. Tenants never see each other. Agents in a fleet share by default; crossing fleets requires explicit policy.
• Trust tiers. Every agent has an identity and a tier that says how far it can read and write. Elevation is explicit, never implied.
• Keystones. Mandatory policies that come back on every recall and outrank ordinary memories — the rules an agent must obey, not merely know. See Keystones.
• Audit trail. Every read, write and change is logged with who, what and when. Who-wrote-what and who-read-what are always answerable.

Coherent over time

Facts change. In Caura a new fact supersedes the old one instead of sitting next to it, so history stays traceable and only the current version ranks. Contradictions are detected and surfaced rather than retrieved as confidently as truths. A consolidation engine, the crystallizer, merges near-duplicate memories into clean atomic facts and keeps the sources for provenance. Memories move through a full lifecycle — active, confirmed, outdated, archived — and the ones that keep proving useful rise.

Under the hood

A Python/FastAPI service, PostgreSQL with pgvector for embeddings and full-text search, Redis for caching and rate limits, and Next.js for the dashboard and this site. Enrichment and synthesis use the LLM provider you configure. The whole engine is open source and the same code runs at every rung:

• Open source — Apache 2.0 at github.com/caura-ai/caura. Four commands from clone to a working memory layer.
• Caura Cloud — managed by caura.ai, nothing to run. Unlimited agents and fleets on every plan.
• Enterprise — dedicated or on-prem, SSO, SLA, managed operations.

How we measure it

On the public benchmarks Caura scores 82.5% on LoCoMo and 87.0% on LongMemEval while using 96–98% fewer tokens than full context, with 23 ms median search latency — methodology in Caura Benchmarks. Those benchmarks measure single-agent memory. The fleet properties — does one agent’s learning reach the right other agents, does an unauthorized memory stay invisible, does reporting an outcome make the next recall better — need their own evals, and we hold every release to them.

Not a wrapper. Not a feature. A governed agent DB built for fleets whose memory has to be persistent, shared, governed — and compounding.