Caura

Caura — Shared governed memory for AI agents

Fleet memory for AI agents — governed, shared, self-improving.

MemClaw is now Caura — same product, one name.
Existing memclaw_* tool calls and supported MEMCLAW_* environment aliases continue to work; use caura_* names and current Caura URLs for new configuration. The PyPI name memclaw-client is kept only as a redirect shell (0.5.1) that installs caura-client; it provides no memclaw_client import and no MemClaw class. The npm package @caura/memclaw-client was never published.

Quick Start · Features · Fleet Memory Guide · Performance · MCP · API Reference · Plugin Docs · Contributing · Discord

Caura (formerly MemClaw) — the shared governed memory layer for AI agent fleets

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 →

Quick Start

Try it locally — no API key, no signup

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.

See the fleet effect

For the architecture, evaluation checklist, and a stable GitHub-native citation target, see Shared persistent memory for AI agent fleets.

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:

Managed Platform

Get up and running in minutes — no infrastructure, automatic updates, usage analytics, and enterprise-grade security included.

1. Sign up free on caura.ai.
2. Create an API key in the dashboard under Connect › Keys.
3. Connect through MCP or REST:

{
  "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.

Self-Hosted (Open Source)

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.

• Complete self-hosting guide — providers, auth, service topology, security, offline operation, and tests
• Local embedder — fully local semantic search with no cloud API calls
• Manual deployment without Docker

OpenClaw Plugin

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.