# Caura Documentation

Caura gives AI agent fleets persistent, governed, shared memory. This is a flat index of all documentation pages, intended for AI agents. For full body content concatenated, fetch /llms-full.txt.

## If you are an LLM agent with caura_* tools

Fetch [https://caura.ai/docs/agents.md](https://caura.ai/docs/agents.md) for the canonical skill (the prompt to follow). The HTML form at /docs/agents adds explanatory chrome; the .md form is the raw content. Call `caura_keystones` once at session start before any other action.

## Pages

- [Agent Digests](https://caura.ai/docs/agent-digests): Daily and weekly LLM-generated summaries of what each agent actually did — precomputed server-side for opted-in tenants, read from the dashboard or the reports API.
- [For Agents](https://caura.ai/docs/agents): The Caura skill — the canonical prompt LLM agents follow when they have caura_* tools. Fetch the plain Markdown at /docs/agents.md.
- [Caura Documentation](https://caura.ai/docs): Persistent, governed memory for AI agent fleets. Start here to install Caura, learn the concepts, and connect your agents.
- [Skills](https://caura.ai/docs/skills): Publish a proven workflow to the tenant skills catalog so other agents discover it via semantic search.
- [Architecture](https://caura.ai/docs/concepts/architecture): Every service, resident, and topic in Caura — the core tier that ships in OSS, the platform tier that ships managed, how a write flows through the event bus, and what differs between self-host and managed deployments.
- [Cross-tenant credentials](https://caura.ai/docs/concepts/cross-tenant-credentials): Read across every tenant in your org with a single credential — for admin agents, analytics, and rollups.
- [Governance](https://caura.ai/docs/concepts/governance): Keystones, trust enforcement, the Karpathy Loop, and the Memory Crystallizer.
- [Keystones](https://caura.ai/docs/concepts/keystones): MANDATORY governance rules that agents MUST obey. Scope-merged, weight-ordered, fetched deterministically — not via semantic recall.
- [Memory Pipeline](https://caura.ai/docs/concepts/memory-pipeline): The three paths a memory can take into Caura, and what happens between ingest and the memory becoming recallable.
- [Trust Levels](https://caura.ai/docs/concepts/trust-levels): The 4-tier agent permission scheme — what each level can read and write.
- [Delete your organization](https://caura.ai/docs/getting-started/delete-organization): How to permanently delete a Caura organization, what gets destroyed, and when (and how) you can still recover.
- [Your First Memory](https://caura.ai/docs/getting-started/first-write): Write a memory and recall it — the smallest end-to-end flow.
- [Enterprise — SaaS](https://caura.ai/docs/getting-started/managed): The hosted Caura Enterprise deployment at caura.ai. Caura runs the database, API, and worker for you.
- [On-Prem Enterprise](https://caura.ai/docs/getting-started/on-prem): Caura Enterprise on a customer-managed VM — connected or fully air-gapped — with a license-gated Docker Compose stack.
- [Quickstart](https://caura.ai/docs/getting-started/quickstart): Connect any AI agent to Caura in five minutes — pick managed, self-hosted, or REST.
- [OSS](https://caura.ai/docs/getting-started/self-host): Run the open-source Caura on your own infrastructure with Docker. Apache 2.0.
- [AutoGen](https://caura.ai/docs/integrations/autogen): Give a Microsoft AutoGen agent persistent, governed memory with Caura over MCP.
- [Claude Code](https://caura.ai/docs/integrations/claude-code): Wire Caura into Anthropic's Claude Code CLI.
- [Claude Desktop](https://caura.ai/docs/integrations/claude-desktop): Add Caura as an MCP server in Claude Desktop.
- [CrewAI](https://caura.ai/docs/integrations/crewai): Give a CrewAI agent persistent, governed memory with Caura over MCP.
- [Cursor](https://caura.ai/docs/integrations/cursor): Wire Caura into Cursor's MCP support.
- [LangChain](https://caura.ai/docs/integrations/langchain): Give a LangChain or LangGraph agent persistent, governed memory with Caura — over MCP or the REST API.
- [LlamaIndex](https://caura.ai/docs/integrations/llamaindex): Give a LlamaIndex agent persistent, governed memory with Caura over MCP.
- [Generic MCP](https://caura.ai/docs/integrations/mcp): Connect any MCP-compatible client (Windsurf, Cline, Continue, JetBrains MCP, …) to Caura.
- [OpenAI Agents SDK](https://caura.ai/docs/integrations/openai-agents): Give an OpenAI Agents SDK agent persistent, governed memory with Caura over MCP.
- [OpenClaw](https://caura.ai/docs/integrations/openclaw): Drop Caura into an OpenClaw gateway and every agent in the fleet inherits shared memory.
- [Per-agent keys (no plugin)](https://caura.ai/docs/integrations/per-agent-keys): Bootstrap a long-lived integration without the OpenClaw plugin — provision an agent-scoped credential, identify, and call MCP.
- [REST](https://caura.ai/docs/integrations/rest): Hit Caura directly from any language. No SDK required.
- [The Interviewer](https://caura.ai/docs/interviewer): A third way memories enter Caura — a scheduled reader synthesizes an agent's own durable work trail into typed memories, so nothing important is lost just because the agent forgot to write it down.
- [Protocol](https://caura.ai/docs/interviewer/protocol): How a durable trail becomes typed memories — windows, the forward-only watermark, masking, chunked map-reduce, and idempotent writes. The same contract for every capture source.
- [Setup](https://caura.ai/docs/interviewer/setup): Enable the Interviewer on a tenant, then wire each harness — the OpenClaw plugin, or the caura-interviewer CLI for Claude Code and Cursor workstations.
- [Operational Commands](https://caura.ai/docs/reference/cli): Common commands for self-hosted Caura. Defers to the OSS scripts/ directory for the canonical list.
- [Environment Variables](https://caura.ai/docs/reference/env-vars): The authoritative list lives in the OSS .env.example. Highlights below.
- [Errors and Status Codes](https://caura.ai/docs/reference/errors): The canonical error envelope shared by REST and MCP, plus the HTTP status → code mapping.
- [Authoring skills](https://caura.ai/docs/skill-factory/authoring): Write a skill directly via caura_doc — the required fields, the slug and size rules, create vs update with hash-binding, and how a write is validated and staged.
- [Delivery](https://caura.ai/docs/skill-factory/delivery): How an active skill actually reaches an agent — the MCP pull tier, the OpenClaw push tier, the active-only gate on both, and how the bundled usage skill differs.
- [Forge](https://caura.ai/docs/skill-factory/forge): The server-side resident that mines fleet behavior into skill candidates — how it runs, how operators trigger and observe it, and the knobs that tune it.
- [Skill Factory](https://caura.ai/docs/skill-factory): How Caura turns proven fleet behavior into governed, delivered SKILL.md skills — authored by agents or distilled by Forge, gated through a lifecycle, and pushed to the harnesses that run your agents.
- [Lifecycle & governance](https://caura.ai/docs/skill-factory/lifecycle): The skill status model, who can set each status, the six auto-promotion gates, the Sentinel security scan, and the Skills Inbox review flow.
- [OpenClaw plugin delivery](https://caura.ai/docs/skill-factory/openclaw-plugin): How the OpenClaw plugin's reconciler pushes active skills onto a node — managed vs shared target dirs, the ownership marker, registering on the load path, and per-node observability.
- [Reference](https://caura.ai/docs/skill-factory/reference): One-page reference for Skill Factory — config keys, statuses, auto-gates, endpoints, the skill schema, and the plugin target env var.
- [Skills Inbox](https://caura.ai/docs/skill-factory/skills-inbox): The human-in-the-loop review queue for staged skills — the card an operator sees, the five actions, and how to recover a quarantined skill.
- [Build an agent fleet on Caura Cloud](https://caura.ai/docs/tutorials/cloud-fleet): The managed (Cloud) tutorial — a self-contained, end-to-end build. Wire a governed three-agent fleet to caura.ai: sign up, connect Claude Code, and watch shared memory compound, with just an API key.
- [Content Policy: PII screening & the business-vs-personal gate](https://caura.ai/docs/tutorials/content-policy-setup): Configure the dashboard's Content Policy tab — screen every write for PII, PCI & secrets, and keep personal content out of the shared corporate graph.
- [Your first memories on Caura Cloud](https://caura.ai/docs/tutorials/first-memories): The five-minute Cloud starter — sign up, mint a key, write three memories, recall them with completely different words, and see them in Prism.
- [Governed memory: scopes, trust tiers & keystone policies](https://caura.ai/docs/tutorials/governance-keystones): Who sees what, who can change the fleet's knowledge, and what every agent must obey — visibility scopes, trust tiers, and keystone policies.
- [Tutorials](https://caura.ai/docs/tutorials): Hands-on tutorials for building governed, shared, self-improving memory for AI agent fleets — on managed Caura Cloud or self-hosted OSS.
- [The Karpathy Loop: memory that learns from outcomes](https://caura.ai/docs/tutorials/karpathy-loop): Make shared memory improve with use — report outcomes, reinforce what works, auto-generate rules from failures, and tune retrieval per agent.
- [The knowledge graph: entities, relations & graph-boosted recall](https://caura.ai/docs/tutorials/knowledge-graph): The graph view from Part 2 wasn't decoration — it's the substrate Caura builds on every write, and the reason recall finds memories you never lexically matched. Entity extraction, synonym resolution, evidence-carrying relations, and the graph-expansion search blend.
- [The Memory Dashboard: a browsable window into your fleet's mind](https://caura.ai/docs/tutorials/memory-dashboard): See, search, and govern your fleet's shared memory — from one HTML file and a reverse proxy.
- [Memory hygiene at scale: contradictions, supersession & the crystallizer](https://caura.ai/docs/tutorials/memory-hygiene): What keeps a fleet's shared memory from rotting at scale — automatic contradiction detection and supersession, an 8-state lifecycle, the crystallizer hygiene scan, and caura_insights.
- [Building a Multi-Agent Fleet with Caura and Claude Code](https://caura.ai/docs/tutorials/multi-agent-fleet): Give three agents one shared, governed brain — in about 30 minutes, with zero custom code.
- [The Broker Fleet Screen](https://caura.ai/docs/broker-fleet/dashboard): A field guide to every column, status, panel, and action on the dashboard's Broker Fleet screen — installs, statuses, fleet policy, commands, the reported-agents panel, and revoke.
- [How Onboarding Works](https://caura.ai/docs/broker-fleet/how-it-works): The credential model behind broker onboarding — the register-only join key vs the per-machine install credential, how fleets bind, single-use vs reusable keys, where credentials live, the write-ownership boundary, and the security properties. Read this to plan a fleet rollout.
- [Broker Fleet](https://caura.ai/docs/broker-fleet): What the Caura broker is, how personal and fleet mode differ, and how a fleet of brokers is governed from the dashboard.
- [Onboarding a Broker](https://caura.ai/docs/broker-fleet/onboarding): Install and join a new broker to your fleet with one command — what to run on macOS, Linux, and Windows, what each step does, and how to verify it worked.
- [List Document Collections](https://caura.ai/docs/api-reference/documents-collections): GET /api/v1/documents/collections — list document collections in a tenant (added in PR
- [Search Documents](https://caura.ai/docs/api-reference/documents-search): POST /api/v1/documents/search — semantic + keyword search across stored documents (added in PR
- [Health](https://caura.ai/docs/api-reference/health): GET /api/v1/health — liveness probe.
- [API Reference](https://caura.ai/docs/api-reference): Auto-generated REST reference, sourced from the FastAPI OpenAPI spec.
- [Keystones](https://caura.ai/docs/api-reference/keystones): GET / POST / DELETE /api/v1/keystones — mandatory governance rules.
- [Recall](https://caura.ai/docs/api-reference/recall): POST /api/v1/recall — hybrid vector + keyword + entity search.
- [Stats](https://caura.ai/docs/api-reference/stats): GET /api/v1/memories/stats — aggregate counts (PR
- [Write a memory](https://caura.ai/docs/api-reference/write): POST /api/v1/memories — persist content for later recall.

## Blog

Long-form engineering and research writing, newest first. These cover the design arguments behind the product — memory taxonomies, governance, benchmarks, and trade-offs — rather than API reference. Every post is also available as markdown at <url>.md, and all of them concatenated at https://caura.ai/blog/llms-full.txt.

- [Caura As-Of Recall: The Right Memory for the Right Moment](https://caura.ai/blog/as-of-recall) — September 11, 2026: Your company’s knowledge changes over time. Your agents should understand that. As-Of Recall aligns memory search with the date a question refers to — so “What was our pricing policy last March?” brings forward what was true in March. By measuring freshness from recorded event dates instead of upload dates, imported history gets a real timeline and agents answer historical questions with the right context. One tenant setting, no new fields, off by default.
- [AI Agent Orchestration: Coordinating Specialized Agents at Enterprise Scale](https://caura.ai/blog/ai-agent-orchestration) — September 8, 2026: At enterprise scale, orchestration is a memory problem before it is a routing problem. The four control patterns and where each degrades past a dozen agents, an audit of what seven frameworks actually document about cross-agent memory (none mentions an audit trail), the four governed-memory mechanisms that fix the failures, and four runnable Apache-2.0 reference implementations — plus what the whole thing costs to operate.
- [Multi-Agent Systems Explained: How Fleets of Agents Coordinate Without Stepping on Each Other](https://caura.ai/blog/multi-agent-systems-explained) — September 8, 2026: More agents buy you parallelism and collisions at the same time. The four ways fleets step on each other — duplicate work, constraint contradictions, stale facts, boundary leaks — where orchestrator-worker, handoffs, A2A/MCP messaging and plain vector stores each give out, and the five mechanisms that make a shared store actually enforce coordination. Plus an original finding: in the reference fleet, coordination is enforced 14 times, and never by a prompt.
- [Persistent Memory for AI Agents: From Stateless Prompts to Compounding Knowledge](https://caura.ai/blog/persistent-memory-for-ai-agents) — September 8, 2026: Persistent memory only works when four things hold at once: the fact can be found, is current, traces back to its writer, and is visible only to agents allowed to see it. Most implementations ship the first and skip the rest. The write and recall mechanics, a definition audit of the three founding papers (zero governance primitives in 67 pages), five production failure modes including memory poisoning, and three repos that reproduce each one.
- [What Is AI Agent Memory? Why Context Needs to Survive the Session](https://caura.ai/blog/what-is-ai-agent-memory) — September 8, 2026: AI agent memory is a store outside the model with a write path, a read path, and a lifecycle — the context window is a working set, and RAG is a read path over documents. What persistence costs, the four failure modes it creates (scope, time, resolution, provenance), what governed recall runs before it ranks, and the measured production numbers — including the two failures Caura published about its own service.
- [Agents Don't Journal — The Interviewer, Caura's Reflective Write Path](https://caura.ai/blog/agents-dont-journal) — August 31, 2026: Diligent journaling competes with the task for the same attention, and it loses. The Interviewer is Caura's reflective write path: on a schedule it reads an agent's existing work trail — a Claude Code or Cursor transcript, or an OpenClaw plugin buffer — and synthesizes typed, governed memories after the fact. Two write paths, one governed layer; coverage without the journaling tax. The six-section mapping, the plugin-buffer and disk-parser collectors, the watermark protocol, and why it ships off by default and double-gated.
- [Harness Engineering: Time to Stop Asking Your Agents to Decide What to Remember](https://caura.ai/blog/harness-engineering-deterministic-memory) — August 30, 2026: Memory as a model behavior is a reliability bug: the model forgets to write, writes twice, or writes what a poisoned document told it to — and none of it throws. Deterministic memory moves every write and the baseline read into the harness, where policy is a permission system instead of a prompt. What determinism guarantees (invocation and governance, not correctness), the failure modes it fixes vs. relocates, what the OpenAI Agents SDK, LangGraph, ADK, Zep, Mem0 and Letta actually shipped — verified against their docs — and a 130-line demo where a Gemini agent writes and a Claude agent recalls from one governed store.
- [How AI Agents Share Knowledge — and Learn From Each Other's Mistakes](https://caura.ai/blog/how-agents-share-knowledge) — August 24, 2026: There are only five ways agents share knowledge: message passing, orchestrator state, shared files, a shared vector store, or a governed memory layer. The first four move information; only the last compounds it. The five architectures and where each breaks, the four-step loop that turns one agent's failure into fleet policy, and the wiring for Claude Code, CrewAI, AutoGen, and LangGraph.
- [What Is Agent Fleet Memory?](https://caura.ai/blog/what-is-agent-fleet-memory) — August 23, 2026: Single-agent memory is a nicer chat history. A fleet needs something else: a shared, governed store where every item carries scope, provenance, trust and validity. The taxonomy, the six write gates, why over-retrieval hurts more than forgetting, the five failure modes — and the cases where you should skip all of it.
- [We Built an Agentic Marketing Department](https://caura.ai/blog/agentic-marketing-department) — August 5, 2026: Five agents, twelve live data sources, one governed memory. Caura's growth function stopped being people assembling dashboards and became a fleet that remembers — Beacon on analysis, Outreach on the funnel, Social on engagement, Scout on the outside-in radar, Writer on content. The three properties that separate a department from a demo: one tool surface, governed shared memory, and a human gate automation never widens. Plus the four things still broken in our own store.
- [Buzz Gives Every Agent an Identity. Caura Adds Shared, Governed Memory.](https://caura.ai/blog/buzz-agents-get-an-identity) — July 25, 2026: Block open-sourced Buzz, an Apache-2.0 workspace where every participant — human or agent — holds their own Nostr keypair instead of an API key managed by a vendor, every action lands as a signed event under a hash-chain audit log, and every agent carries its own encrypted engram (NIP-AE). Buzz ships more memory than most agent platforms. An appreciation of what it gets right, plus our initial research into the third kind a fleet needs: the shared, governed tier beside the private one.
- [Opus 5 Won. Fable 5 Forfeited.](https://caura.ai/blog/opus-5-won-fable-5-forfeited) — July 25, 2026: PeerRank's blind run “July25” put five frontier models across 100 questions and 2,922 pairwise matches. Claude Opus 5 won outright at 8.87, leading four of five categories. Claude Fable 5 finished third — four answers came back blank, HTTP 200 with an empty body, and the judges scored what they saw. Plus kimi-k3: second on quality, 18.81 seconds per answer, and a judge panel whose disagreement about how to mark was four times larger than the gaps it was marking.
- [Claude Fable 5 Beat Everyone and Lost](https://caura.ai/blog/claude-fable-5-beat-everyone-and-lost) — July 19, 2026: In PeerRank's blind run “Mondial,” Claude Fable 5 posted the highest head-to-head win rate of four frontier models — then finished third, because its safety layer refused four ninth-grade biology questions and logged the blanks as empty, successful calls averaged into its score. The numbers, the forfeits, and why refusal behavior belongs in fleet selection criteria.
- [Solving the Agent Cold-Start Problem](https://caura.ai/blog/agent-cold-start) — July 2, 2026: A brand-new agent has flawless reasoning and nowhere to stand. Pre-seeded, scoped ingestion (per organization, per department) plus mandatory keystones give it the knowledge base and the rulebook on turn one — governed, auditable, and shared, instead of an ever-growing system prompt.
- [Fable 5 Out-Fights Every Rival — Then Loses to Its Own Guardrail](https://caura.ai/blog/fable-5-loses-to-its-own-guardrail) — July 2, 2026: Claude Fable 5 posts the highest win rate on PeerRank's board — then places third, because a safety classifier refuses ninth-grade biology and logs the refusals as empty, successful calls that get averaged into its score. The numbers, the forfeits, and the fix Anthropic already ships.
- [AI Memory Is a Distributed-Systems Problem](https://caura.ai/blog/governed-shared-memory-paper) — June 23, 2026: Our new arXiv paper formalizes the fleet-memory problem, defines the primitives a governed memory system needs, and measures Caura against a live production service — including the two architectural bugs the measurement caught. The negative results are the point.
- [How a Skill Is Born — From Agent Experience to a Governed Capability](https://caura.ai/blog/how-a-skill-is-born) — June 24, 2026: When several agents independently learn the same lesson, Caura's Skill Factory distills it into a reusable skill — then a deterministic scanner and an active-only gate keep it safe. The mechanism, plus a live run that blocks 6/6 adversarial skills.
- [How to Build a Company Brain With Exactly One Skill](https://caura.ai/blog/one-skill-company-brain) — June 23, 2026: Most teams build organizational intelligence as a pile of bespoke skills — one per capability, one per agent. You don’t need the pile. You need one skill, used properly, over governed shared memory: recall before work, obey the keystones, reuse the playbooks, compound what every agent learns.
- [The Token Tax of Multi-Agent Systems](https://caura.ai/blog/how-to-save-tokens-multi-agent-systems) — June 18, 2026: In a fleet, the tokens that dominate the bill aren’t spent on reasoning — they’re spent on repetition. The memory-infrastructure principles that keep cost flat as the fleet grows.
- [Beyond System Prompts: How Keystones Make AI Agents Obey Policy](https://caura.ai/blog/keystones-deterministic-policy) — May 16, 2026: When your user pushes back and your AI agent caves, the problem isn’t the model — it’s the enforcement layer. Probabilistic enforcement isn’t enforcement; it’s hope. Here’s how Caura’s keystones primitive fixes it.
- [Caura is Open Source — Governed Shared Memory for Agent Fleets](https://caura.ai/blog/caura-oss) — May 11, 2026: Apache 2.0. The whole storage layer, the 12 MCP tools, the OpenClaw plugin, the audit trail — yours to read, run, fork, and ship. Five minutes from git clone to a working multi-agent memory layer.
- [Memory Isn’t Records — How caura_doc Solves the Other Half](https://caura.ai/blog/memory-isnt-records) — May 8, 2026: Six operations and one collection-based primitive that replaces a shelf of side-systems. Customer records, config, skills, playbooks — one tool, with semantic search opt-in per collection.
- [Caura Owns the Multi-Agent Governed Memory Lane](https://caura.ai/blog/multi-agent-governed-memory) — April 19, 2026: Single-agent memory is a solved category with many good vendors. Multi-agent governed shared memory is a new category — and Caura is the one defining it.
- [Fast, Token-Efficient, and Built for Fleets — Caura on LoCoMo and LongMemEval](https://caura.ai/blog/caura-benchmarks) — April 19, 2026: Caura on the two public agent-memory benchmarks: 23 ms p50 search, 96–99% token savings, accuracy comparable to the leaders — and the fleet-shaped problem these benchmarks can’t measure.
- [The Karpathy Loop Changed How We Think About AI Research. Here’s What It’s Still Missing.](https://caura.ai/blog/karpathy-loop) — April 2026: The Karpathy Loop proved autonomous AI research works. But scaling it to agent fleets needs governed shared memory — persistent, structured, and self-improving.
- [The Road to Hyperagents: From Simple Prompts to Self-Improving AI Fleets](https://caura.ai/blog/road-to-hyperagents) — May 13, 2026: How AI agents evolved from stateless chatbots to Karpathy loops and Meta’s self-modifying hyperagents — and why governed shared memory is the missing infrastructure layer.
- [How Is Caura Built?](https://caura.ai/blog/how-caura-is-built) — April 9, 2026: How the governed agent DB for AI fleets is built: three memory modes (Rail, MCP/REST, the Interviewer) over one governed write path and recall path, the Evolve loop that makes recall improve from outcomes, keystones and trust tiers, and the stack underneath. Updated September 2026.
- [Why OpenClaw Changes Everything — and Why One Lobster Isn’t Enough](https://caura.ai/blog/openclaw-changes-everything) — April 8, 2026: OpenClaw turned AI from a tool you prompt into a coworker that lives on your machine. Now enterprises are deploying fleets — and discovering that the hardest problem isn’t the agent.
- [Shared Governed Memory: Why Multi-Agent AI Needs More Than a Vector Database](https://caura.ai/blog/shared-governed-memory) — April 8, 2026: Agent fleets are scaling. Memory isn’t. The missing layer between isolated agents and compounding intelligence is governed shared memory — and building it is harder than you think.

## Use cases

Case studies, integrations, and hands-on tutorials from real deployments, newest first. Where the blog argues the design, these show it running. Every page is also available as markdown at <url>.md, and all of them concatenated at https://caura.ai/use-cases/llms-full.txt.

- [Stale Memory Is a Silent Failure Mode in Long-Running Agent Fleets. Here's How We Fixed It.](https://caura.ai/use-cases/stale-memory-long-running-fleets) — July 19, 2026: A three-agent pricing fleet runs for 14 days. On Day 9 a price changes — and eight confirmed memories still assert the old value, so the synthesis agent reports it with total confidence. No error, no flag. The open-source caura-long-run-fleet demo fixes it with status-governed recall and an async contradiction detector that retires stale facts before the next recall.
- [Why Prompt-Level Data Separation Isn't Enough for Multi-Agent Systems](https://caura.ai/use-cases/prompt-level-data-separation) — July 19, 2026: A system prompt that says “don't surface legal data” runs after retrieval already loaded the GDPR hold into context. The open-source caura-cross-fleet-gov demo enforces the boundary as a SQL fleet predicate instead — three agents on one tenant, isolation that model capability can't widen, plus admin fan-out synthesis across fleets.
- [Multi-Agent Fleet with Shared Memory: Stopping Constraint Contradictions](https://caura.ai/use-cases/multi-agent-fleet-constraint-contradictions) — July 19, 2026: Five agents build a web page in sequence — a performance agent bans external scripts, an SEO agent loads a CDN library, and the page ships violating its own budget. The open-source caura-build-fleet reference pipeline stops it: recall before acting, write after deciding, with least privilege enforced at the MCP tool schema and again server-side via trust levels.
- [SpinachAI Writes It Down. Caura Keeps It True.](https://caura.ai/use-cases/spinach-caura-meeting-memory) — June 28, 2026: SpinachAI turns every meeting into clean structure. Wire it to Caura over MCP and that structure becomes governed memory that corrects itself — when a team reverses a decision, the old one drops out of the live answer instead of sitting there contradicting the new plan. No middleware, just two MCP servers.
- [Secure by Design, One Brain to Share — NanoClaw × Caura](https://caura.ai/use-cases/nanoclaw-shared-brain) — June 23, 2026: NanoClaw sandboxes every agent — secure, but amnesiac. We added a shared, governed cognition layer on top: three channels (a live Telegram agent, plus Slack and Web) on one Caura tenant, a fact crossing channels neither other saw, and PII flagging + keystones enforced on write. The sandbox stays intact; the brain is shared.
- [Learn to Build Multi-Agent Fleets with Caura — A Hands-On, Six-Part Series](https://caura.ai/use-cases/caura-tutorial-series) — June 14, 2026: From “hello fleet” to self-improving, governed memory — one continuous build on a single shared Caura stack. Multi-agent setup, the memory dashboard, scopes & keystones, the Karpathy loop, memory hygiene, and the knowledge graph. All hands-on, all open source.
- [Passes Locally, Fails in CI: Coding Agents That Actually Learn](https://caura.ai/use-cases/passes-locally-fails-in-ci) — June 16, 2026: A new test suite passed clean locally and failed in CI. Our error-investigation agent traced the non-obvious root cause, proved the fix under CI’s own environment, and wrote the lesson to shared memory — so next time it’s an instant recall, not another hour of bisecting.
- [The Code Reviewer That Remembers Why](https://caura.ai/use-cases/code-review-agent-that-remembers) — June 16, 2026: A PR-review agent that opens every review by recalling the team’s operating rules and the design decisions behind the code — enforcing standards without re-briefing, and rejecting a change a fresh-eyes reviewer would have waved through.
- [Prompt Rules Aren’t Access Control. This Is.](https://caura.ai/use-cases/prompt-rules-arent-access-control) — June 5, 2026: Three OpenClaw agents on one self-hosted Caura, with fleet boundaries enforced as a storage-layer query predicate — not a prompt. The sales agent physically cannot read Legal’s compliance holds, and the admin agent surfaces the cross-fleet conflict automatically. Open-source, run it yourself.
- [The Price Changed. Your Agents Didn’t Notice.](https://caura.ai/use-cases/the-price-changed-your-agents-didnt-notice) — June 4, 2026: A long-running research fleet, eight days of stale facts, and the open-source memory where the wrong answers disappear on their own — superseded automatically and suppressed by status, not by a prompt. Plus the writer ≠ verifier ≠ synthesizer pattern that keeps shared memory trustworthy.
- [The New Hire Who Already Knew the Job](https://caura.ai/use-cases/new-hire-knew-the-job) — June 3, 2026: We added a brand-new Anthropic managed agent to a real production fleet in minutes. On its first message it recalled the team’s playbook, answered like a veteran, and wrote back a rule the other agents now follow — across vendor lines, under Caura’s governance, owned by the client.
- [How One Caura User Bridged His Marketing and Dev Agents](https://caura.ai/use-cases/clawshield-bridge) — May 25, 2026: A community case study: Aaron wired OpenClaw and Hermes to one Caura instance over MCP. The dev agent wrote brand rules. The marketing agent enforced them — and caught the human's typo. The role lives in the memory, not in the agent.
- [We Married Claude and ChatGPT. Caura Was the Bestman.](https://caura.ai/use-cases/caura-bestman) — May 22, 2026: Your AI tools don’t talk to each other. They can’t. Caura is the bestman — a shared persistent memory that holds the facts you tell Claude on Monday and hands them to ChatGPT on Thursday. The agent doesn’t live in any one product. The agent lives in the memory.
- [How eToro Built a Company Brain for 300+ AI Agents](https://caura.ai/use-cases/etoro-company-brain) — May 10, 2026: Inside the three-layer architecture a NASDAQ-listed fintech ($5.6B) built so its 300+ specialized agents share memory: 26,500+ memories, 1,372 skills, 23 ms p50 search, one governed Company Brain.
- [Cursor Gets Multi-Agent Memory in 5 Minutes](https://caura.ai/use-cases/cursor-multi-agent-memory) — April 24, 2026: Paste one MCP config block and Cursor remembers across sessions, projects, and teammates. Personal today, governed fleet infrastructure tomorrow.
- [Claude Code Forgets Everything. Here’s the One-Line Fix.](https://caura.ai/use-cases/claude-code-memory-setup) — April 16, 2026: One CLI command gives Claude Code persistent memory across sessions, projects, and machines. Personal today, governed fleet infrastructure tomorrow.