Memory Systems

Status: memory is not a client of the Curate-Me SDK. There is no from curate_me import ... memory class. Memory is provided server-side in two places: runner session memory (exposed to in-container agents via the MCP server) and a server-side dashboard Memory Visualizer for operators. This page describes those real surfaces and where to access them.

The platform persists context for agents so that work improves over time and agents stay aware of what has already happened. The two surfaces below are the supported ways to read and write that context.

Runner Session Memory (via MCP)

When an OpenClaw agent runs inside a Curate-Me managed runner, the bundled MCP server exposes session memory as tools the agent can call directly. This is the supported, in-container way to give an agent stateful, multi-run awareness — it is not part of the language SDK.

Restore prior session context

// Inside a runner, using the MCP client
const memories = await mcp.call("curate_session_memory", {
  template_id: "daily_report",
  limit: 1,
});

curate_session_memory parameters:

Search across the fleet’s memories

const insights = await mcp.call("curate_memory_search", {
  query: "customer objections pricing",
  limit: 20,
});

curate_memory_search parameters:

See the MCP Server reference for the full tool catalogue and the stateful multi-run agent example.

Memory Visualizer (server-side / dashboard)

Operators can inspect retained memory through the dashboard’s Memory Visualizer, backed by the platform admin API (/api/v1/platform/memory/*). This surface groups retained context by user and exposes profile, pattern, and session views for audit and pruning. It is an operator-facing dashboard feature, not an SDK or runner-agent API.

Typical operator actions exposed by the admin API:

• List users with retained memory and aggregate stats
• Inspect a single user’s profile / pattern / session entries
• Prune a user’s retained memory (POST /api/v1/platform/memory/users/{user_id}/prune)

These endpoints require platform-admin scope and are reached through the dashboard, not the public SDK.

What the SDK does expose

The Curate-Me SDK does not ship a memory client. For the capabilities developers most often reach for instead, use:

• Tracing / spans — Observer SDK to record per-span context, cost, and tokens for an agent run.
• Cost data — client.costs (see Cost Tracking) to read recorded usage; the gateway records cost automatically.
• Running agents — client.agents.run(...) and client.agents.stream(...) (see Creating Agents). Pass any context your agent needs as the input payload; the SDK does not persist it as long-term memory.

from curate_me import CurateMe
 
client = CurateMe(api_key="cm_...", org_id="org_...")
 
# Carry context forward yourself via the run input — the SDK does not
# maintain server-side memory on your behalf.
result = client.agents.run_sync(
    "dev_team",
    input={
        "query": "Summarize today's changes",
        "context": {"previous_summary": "..."},
    },
)

Persistence (server-side)

Runner session memory and the operator Memory Visualizer are persisted by the platform; the SDK and runner agents read from them through the surfaces above. There is no client-side memory store to configure.