SuperAPI AI Directory
Partner with us中文AI newsFavorites
All toolsAI agentscaura

caura

Caura (formerly MemClaw) is an open-source shared memory layer for multi-agent AI fleets, licensed under Apache 2.0. It lets multiple AI agents write what they have each learned into a unified, governed memory system and retrieve what the entire fleet already knows, so they can learn from one another and avoid repeating mistakes. Agents only need to write plain text, and Caura turns it into searchable, governed, self-improving memory. The core loop is built on three pillars: write, recall, and compound. The product supports multi-tenancy and multi-agent setups, natively supports MCP (Model Context Protocol), and offers trust tiers, critical policies, audit logs, a knowledge graph, and self-improving retrieval. Caura offers two deployment paths: a hosted platform and self-hosting (open source), along with a Python client, a TypeScript client, an OpenClaw plugin, and a Rail integration. According to the materials, eToro uses Caura as the governed shared memory layer for its AI agent work. Existing memclaw_* tool calls and MEMCLAW_* environment variable aliases remain available, while new configurations are recommended to use the caura_* names and the current Caura URL.

Open website

About this tool

Purpose

Caura (formerly MemClaw) is an open-source memory layer for multi-tenant, multi-agent AI fleets. Its positioning is "governed shared memory": it lets agents store what they have learned, retrieve what the entire fleet already knows, and become smarter with every interaction—agents learn from one another instead of repeating mistakes.

The official description frames it as one loop with three pillars: write, recall, and compound—that is, every interaction makes the next one smarter.

Key Capabilities

Memory Pipeline

  • Single LLM enrichment: each write automatically classifies content into one of 7 memory types (the server itself writes outcome, rule, and insight), generates a title/summary, scores importance, flags PII, and extracts entities—all from a single content field.
  • Hybrid search: pgvector semantic similarity + full-text keyword matching + knowledge graph expansion (up to 2 hops), ranked by a composite score of similarity, importance, freshness, and graph weighting.
  • Real-time knowledge graph: each write extracts people, organizations, places, and concepts as entities and relationships. Entity resolution first performs exact name matching, then deterministic canonical name matching, and then semantic similarity (cosine >0.85) matching.
  • Contradiction detection: detects conflicting memories through RDF triple comparison + LLM semantic analysis and automatically supersedes them, with full contradiction chain tracking.

Self-Improving Memory

  • Outcome-based learning (Karpathy Loop): after acting on recalled memories, agents report success/failure, the system reinforces what worked, and on failure it automatically generates preventive rule-type memories.
  • Crystallization: the LLM merges near-duplicate memories into canonical atomic facts with full provenance; an 8-state lifecycle automatically retires outdated data.
  • Per-agent retrieval tuning: each agent optimizes its own retrieval configuration based on feedback (top_k, min_similarity, graph_max_hops, hybrid weights), so search quality improves cumulatively with interactions.

Governance and Multi-Tenancy

  • Tenant isolation: row-level database separation by tenant; every write automatically detects and flags PII (represented in memory metadata as contains_pii / pii_types).
  • Visibility scope: each memory is tagged at write time—scope_agent (private), scope_team (shared within the cluster, default), scope_org (cross-cluster). Cross-cluster recall requires authorization rather than being open.
  • Agent trust levels: four levels control cross-cluster read, write, and delete.
  • Full audit log: every write, delete, and state transition records tenant and scope context.
  • Agent activity digest: for organizations that opt in, generated server-side at a cadence set by the organization (agent_digest.enabled defaults to off; agent_digest.cadence defaults to daily, with weekly or both as options); zero cost for tenants that do not opt in.

Other capabilities

  • MCP server: built-in Model Context Protocol at the path /mcp (Streamable HTTP), able to connect to any MCP client such as Claude Desktop, Claude Code, Cursor, Windsurf, and others. Clients can discover 12 tools (the original text is interrupted here).
  • Multi-provider LLM: each tenant can configure a primary + backup provider chain (OpenAI, Gemini, Anthropic, OpenRouter); zero-configuration tenants use platform defaults.
  • Document storage: JSONB structured collections coexisting with semantic memory, used for exact field queries (customer records, configuration, task lists).

How to use

Local trial (no API key, no registration required)

Standalone mode runs as single-tenant and bypasses authentication: start Caura, write a memory, then retrieve it. With no key, no configuration is required, memories do not generate embeddings, and lookup is by keyword. Add an AI provider key to enable semantic search. The strong write response without a key includes memory_type, title, status, weight, and summary under metadata, all generated by deterministic local heuristics targeting a single content field; after configuring an AI provider, these values are inferred by the model, and metadata may also include tags.

Four paths

  1. Hosted platform: sign up for free at caura.ai, copy the API key from the dashboard, and connect via MCP or REST. For production clusters, it is recommended to configure one agent-scoped credential per agent.
  2. Self-hosted (open source): Docker Compose starts PostgreSQL + pgvector, Redis, the storage service, the REST/MCP API, and the core operations lifecycle scheduler (nightly expiration, archiving, purging, and crystallization). The documentation provides a complete self-hosting guide (providers, authentication, service topology, security, offline operation and testing), a local embedder (fully local semantic search with no cloud API calls), and manual deployment without Docker.
  3. OpenClaw plugin: when an OpenClaw cluster is already running, Caura can be installed as a plugin, pointing to either the hosted platform or a self-hosted stack. The plugin occupies OpenClaw's memory slot and exposes the same agent-facing memory tools.
  4. Client integration: provides a Python client (conversation from any hosted or self-hosted Caura deployment) and a TypeScript client (Node 18+, no runtime dependencies), plus Rail, which provides memory before and after each agent turn, retrieves governance rules and facts relevant to the current message, hands prompt-ready context to the caller, and extracts and stores what was learned during the turn.

MCP configuration: the self-hosted example uses http://localhost:8000/mcp Use X-API-Key: standalone; the hosted platform uses caura.ai. Claude Code does not read MCP servers from settings.json; they must be registered with claude mcp add; the Claude Desktop configuration file is located at ~/Library/Application Support/Claude/claude_desktop_config.json on macOS or %APPDATA%\Claude\claude_desktop_config.json on Windows; in Cursor, add it under Settings > MCP Servers > Add Server.

Credential scope: For team or production use, it is recommended to use agent-scoped credentials instead of tenant-scoped keys. On the hosted platform, they can be provisioned atomically via POST /api/v1/admin/agent-keys/provision (or the /settings/organization/api-credentials wizard), generating credentials + an Agent row + initial trust + cluster membership in a single round trip. Both types of keys use the mc_ prefix, and the scope is set when the credential is generated. When using tenant-scoped credentials, agent_id must be passed explicitly on every MCP tool call; the gateway rejects the reserved default value mcp-agent on that path.

When to use

  • Teams starting with a single agent and later scaling to an agent cluster: no changes are needed in a single-agent setup, and from the first write Caura provides scoped memory, cross-agent result propagation, and a cluster-level trust hierarchy.
  • Production environments that need a governed, auditable cross-agent/cross-team/cross-vendor memory plane (such as the eToro case mentioned in the materials).

Limitations and items to be verified

  • Public agent memory benchmarks (LoCoMo, LongMemEval) measure single-agent, single-user, single-long-conversation settings—that is, the single-chatbot form. Cluster governance and workload-specific latency still need to be verified in the corresponding environments.
  • LoCoMo accuracy: under its documented LoCoMo semantic judge protocol, using the retrieval-augmented agentic-v1 pipeline, Caura scores 77.9% (1,199/1,540).
  • LongMemEval reference judge: under the benchmark's GPT-4o reference judge, Caura correctly answers 461 of the 500 LongMemEval_S questions (92.2%).
  • LongMemEval secondary judge: the same 500 frozen answers score 90.2% (451/500) under a secondary Gemini 3.5 Flash-Lite judge.
  • LongMemEval token efficiency: on LongMemEval_S, the median compressed retrieval context is 22,410 tokens, a 79.2% savings versus the 107,706-token full haystack (context only); when counting all reader calls, it is 75.4%.

Naming change note

MemClaw is now renamed Caura—the same product, one name. Existing memclaw_* tool calls and supported MEMCLAW_* environment aliases continue to work; for new configurations, use the caura_* names and the current Caura URL. The PyPI name memclaw-client is retained only as a redirect shell (0.5.1) for installing caura-client, and it does not provide a memclaw_client import or a MemClaw class. The npm package @caura/memclaw-client was never published.

Related tools

Browse category