Caura (formerly MemClaw) — governed shared memory for AI agent fleets. Multi-agent, multi-tenant, MCP-native. Trust tiers, keystone policies, audit trails, knowledge graph, self-improving retrieval. Apache 2.0.
$ npx -y skills add caura-ai/caura --agent claude-code
Repo: caura-ai/caura
What's inside
Caura — formerly MemClaw — is open-source memory for multi-tenant, multi-agent AI fleets. Your agents store what they learn, find what the fleet knows, and get smarter with every interaction — learning from each other instead of repeating mistakes.
Agents write plain text. Caura turns it into searchable, governed, self-improving memory.
One loop, three pillars: write, recall, compound — every interaction makes the next one smarter.
Built for fleets. One agent works, and that's where most teams start — nothing below changes for a single-agent setup. What Caura adds is headroom: scoped memory, cross-agent outcome propagation, and fleet-wide trust tiers are there from the first write, and they keep paying off as agents multiply. Public agent-memory benchmarks (LoCoMo, LongMemEval) measure one agent, one user, one long conversation — the single-chatbot shape. Fleet governance and workload-specific latency still need validation in the environment where they matter. See the generated Performance block and evidence registry for approved benchmark results, or read the benchmarks write-up.
Production case study: eToro uses Caura as a governed shared-memory layer for its AI-agent work. Architecture deep-dive →
The fastest way to see Caura work. Standalone mode runs single-tenant with auth bypassed — start Caura, write a memory, and find it again. (With no key there's nothing to configure: memories are stored without embeddings and found by keyword. Add an AI provider key for semantic search — see Self-Hosted below.)
git clone https://github.com/caura-ai/caura.git
cd caura
cp .env.example .env && echo "IS_STANDALONE=true" >> .env # single-tenant, no API key
docker compose up -d --wait # Postgres + pgvector + Redis + API + scheduler (~30s)
# Write a memory — no API key needed
curl -X POST http://localhost:8000/api/v1/memories \
-H "X-API-Key: standalone" -H "Content-Type: application/json" \
-d '{"tenant_id": "default", "agent_id": "quickstart", "write_mode": "strong", "content": "Our auth service uses JWT with 15-minute expiry."}'
# Find it by keyword — no provider key needed
curl -X POST http://localhost:8000/api/v1/search \
-H "X-API-Key: standalone" -H "Content-Type: application/json" \
-d '{"tenant_id": "default", "query": "JWT expiry"}'
The keyless strong-write response includes memory_type, title, status, and weight — plus a summary under metadata — all derived by a deterministic local heuristic from the single content field. With a configured AI provider, those values are model-inferred and metadata can also include tags.
Want semantic paraphrases? The keyless query deliberately reuses words from the memory. After configuring an embedding provider in the next section, try
"authentication token lifetime"instead — matching that phrase to "JWT with 15-minute expiry" exercises semantic recall.
Connect two MCP clients to the same fleet. Agent A records an operational
lesson with caura_write:
{
"agent_id": "deploy-agent",
"fleet_id": "platform",
"visibility": "scope_team",
"content": "Roll back auth-service with: deployctl rollback auth-service --to <version>."
}
Agent B asks caura_recall from that fleet:
{
"agent_id": "incident-agent",
"fleet_ids": ["platform"],
"query": "How do I roll back auth-service?"
}
The result identifies deploy-agent as the author: one agent learned it, and
another reused it. scope_agent would keep the memory private;
scope_team shares it within the fleet; scope_org enables governed
cross-fleet recall subject to the trust ladder.
For production, give each client its own
agent-scoped credential.
Ready for semantic recall, multi-tenant, a managed host, or an OpenClaw fleet? Pick a path below.
Four paths — pick the one that matches your setup:
| Path | When | Time to first memory |
|---|---|---|
| Managed platform | Quickest. We host the DB + scaling. | ~2 min |
| Self-hosted (Docker) | Privacy / on-prem / air-gapped. | ~5 min |
| OpenClaw plugin | You already run an OpenClaw fleet — install Caura as a plugin against any of the above. | ~3 min |
| Rail SDK | You write the agent yourself, in Python or TypeScript, and want it to recall rules and facts before every turn and store what it learned after. Works against any of the above. | ~2 min |
Get up and running in minutes — no infrastructure, automatic updates, usage analytics, and enterprise-grade security included.
{
"mcpServers": {
"caura": {
"url": "https://caura.ai/mcp",
"headers": { "X-API-Key": "mc_your_api_key_here" }
}
}
}
For a production fleet, provision one agent-scoped credential per agent. See Integrating without the OpenClaw plugin for credential scopes, headers, and provisioning.
Using the tenant-scoped dashboard key? Pass an explicit agent_id on every MCP
tool call; the gateway rejects the reserved mcp-agent default on that path.
Docker Compose starts PostgreSQL + pgvector, Redis, the storage service, the
REST/MCP API, and the core-operations lifecycle scheduler (nightly expiry,
archival, purge and crystallization). The keyless example above is the shortest
path; add a provider for semantic recall.
Already running an OpenClaw fleet? Install Caura as a plugin against either the managed platform or your self-hosted stack:
The plugin claims OpenClaw's memory slot and exposes the same agent-facing
memory tools. Use the
agent installer's one-line setup,
then see the OpenClaw integration guide for
agent prompts and trust levels. Already have nodes running? Keeping them current
— auto-upgrade and the manual re-install — is covered in
docs/plugin-upgrade.md.
The plugin talks only to the Caura server you configure (CAURA_API_URL) and
identifies itself on every request with
User-Agent: openclaw-plugin/<version> (node/<major>), which the server's
self-hosted heartbeat uses to count connected plugin installs, and with
X-Caura-Surface: openclaw_plugin, which labels the audit rows its writes
produce (Audit attribution). It will not send
CAURA_API_KEY over plain http:// to anything but loopback: point
CAURA_API_URL at https://, or set CAURA_ALLOW_INSECURE_HTTP=true in the
plugin .env to accept cleartext on a trusted private network.
Talk to any managed or self-hosted Caura deployment from Python:
pip install caura-client
See the Python client guide for examples and the full API.
The Node 18+ client has no runtime dependencies:
npm install @caura/client
See the TypeScript client guide for installation and package-name compatibility details.
Give an agent memory around every turn. Rail fetches the governance rules and the facts relevant to the current message before your agent runs, hands you prompt-ready context, then extracts and stores what the turn taught. Python and TypeScript share the same semantics; both work against managed and self-hosted Caura.
pip install caura-rail # Python 3.10+
npm install @caura/rail # Node.js 22+
Point it at any Caura with CAURA_URL and CAURA_API_KEY (for the standalone
Docker server above: http://localhost:8000 and standalone), then wrap each
agent turn:
from caura_rail import MemoryScope, Rail, RestMemoryStore
with RestMemoryStore.from_env() as store:
rail = Rail(store, MemoryScope(agent_id="support-1", fleet_id="support"))
with rail.turn("Remember: We deploy in eu-west-1.") as turn:
# Call your model here; turn.context.text holds rules first, then facts.
turn.reply = "Noted. " + turn.context.text
print([w.status for w in turn.writes]) # ['written'], or ['deduplicated'] on a rerun
View @caura-ai’s profileCaura (formerly MemClaw) — governed shared memory for AI agent fleets. Multi-agent, multi-tenant, MCP-native. Trust tiers, keystone policies, audit trails, knowledge graph, self-improving retrieval. Apache 2.0.
@caura-aiFAQ
caura is a Claude Code plugin with 3 hand-picked skills for agent memory work, indexed on Flowy. Install it with the command on its page. It includes caura, memclaw, company-brain. Its skills do not fire on their own yet. Request auto-invocation to have Flowy route them as you prompt. Free and open source.
Is this plugin yours?
Claim it with GitHubSubmit a pluginPromote it