CAIN-42 · Protect identities, keys & data

CAIN Memory

Long-term memory for agents that cannot be poisoned or quietly rewritten.

Last reviewed 2026-10-01

Live   Core platform · agent

What it is

Governed persistent memory for autonomous agents.

Where it fits

Part of Protect identities, keys & data: Who the agent is, what it may touch, and what it must never leak. Every CAIN-42 product runs behind the same rule: an AI agent's action is checked before it runs (identity, authority, policy, risk), decided as allow, hold for a human, or block, and recorded as signed evidence. Unknown or error never becomes allow.

Use it

• Open it https://cainstudio.online/memory
• Documentation https://cainstudio.online/docs/memory
• API endpoint: https://cainstudio.online/fabric/memory/stats — needs your API key (get a free key)

Recorded status: PRODUCTION. "Live" on this page means its link answered when the catalog was last checked (2026-10-01T18:22 UTC).

Live now

Checked from your browser when this page opened, not from a cached list.

Fire a real decision

Send an action through the live CAIN-42 pipeline from this page, with no account, and watch every stage decide. This is the same pipeline every product here sits behind; it runs for a throwaway demo tenant and is rate limited.

For AI engineers

Every product sits behind one decision path: your agent proposes an action with the exact arguments, CAIN runs it through identity, authority, policy, risk, trust and quorum consensus, and answers ALLOW, REQUIRE_APPROVAL or DENY with an Ed25519-signed record. A timeout, outage or unknown verdict never becomes ALLOW. A brand-new agent has no trust history, so its first actions usually come back REQUIRE_APPROVAL.

Python (zero dependencies)

pip install https://cainstudio.online/cainstudio-0.3.0-py3-none-any.whl
export CAIN_API_KEY=...   # free key: https://cainstudio.online/signup

import cainstudio

@cainstudio.guard()
def transfer(amount_usd: float, to: str) -> str:
    ...  # runs only if CAIN allows this call, with these arguments

try:
    transfer(5000, "acme")
except cainstudio.ApprovalRequired as e:
    print("held for a human:", e.approval_id)
except cainstudio.ActionBlocked as e:
    print("refused:", e.decision.reasons)
except cainstudio.CainUnavailable:
    print("CAIN unreachable: not run")   # fail-closed

See a real decision with no account

cainstudio try          # live pipeline, stage by stage
cainstudio try --list   # the other attack scenarios

MCP clients (Claude Code, Cursor)

claude mcp add --transport http cain https://cainstudio.online/mcp

More: Python SDK · TypeScript SDK · framework integrations · AI quickstart · decision signing key

Tested guarantees in this area

Every rule in these niches has its own page with its recorded result.

• Memory, data & privacy: 92 tested invariants — What agents remember and what must never leak.
• Identity, authority & delegation: 964 tested invariants — Who an agent is, what it may do, and who allowed it.

Related

• CAIN Context — Controls what information an agent sees before it decides.
• CAIN Identity — Gives every agent and person a verifiable identity, so CAIN always knows who is acting.
• CAIN Private — A private space for your agents with governed memory, tools and MCP connections.
• Credential broker — Agents use your API keys without ever seeing them, so a hijacked agent cannot steal them.
• LeakGuard — Stops passwords, keys and personal data from leaving in text sent to an AI tool.

Full documentation

The complete reference, also at /docs/memory.

CAIN Memory#

Governed persistent memory for autonomous agents.

Overview#

CAIN Memory gives autonomous agents persistent, adaptive, governed, tenant-isolated memory that can be written, managed, retrieved, verified, corrected, forgotten, and audited.

Trust Model#

Memory Types#

• episodic - Events and experiences
• semantic - Facts and knowledge
• procedural - How to do things
• preference - User preferences
• task - Task-related information
• working - Temporary working memory
• factual - Verified facts
• experience - Agent experiences
• instruction - Instructions and directives
• observation - Observations

API Endpoints#

Store Memory#

POST /fabric/memory/store
X-API-Key: {key}
{
  "agent_id": "agent-1",
  "memory_type": "semantic",
  "content": "The server runs on port 8399",
  "source": "tool",
  "confidence": 0.95
}

Retrieve Memory#

GET /fabric/memory/get/{memory_id}
X-API-Key: {key}

List Memories#

GET /fabric/memory/
X-API-Key: {key}

Update Memory#

PATCH /fabric/memory/update/{memory_id}
X-API-Key: {key}
{
  "content": "Updated content"
}

Delete Memory#

DELETE /fabric/memory/delete/{memory_id}
X-API-Key: {key}

Change Trust Level#

POST /fabric/memory/trust/{memory_id}
X-API-Key: {key}
{
  "trust_level": "revoked",
  "reason": "Incorrect information"
}

Get Stats#

GET /fabric/memory/stats
X-API-Key: {key}

Health Check#

GET /fabric/memory/health

Security Features#

• Poisoning Defense: Detects prompt injection, indirect injection, and malicious content
• Tenant Isolation: Memories are strictly isolated by tenant
• Admission Control: Every memory passes admission evaluation
• Provenance Tracking: Full chain of custody for each memory

Admission Control#

Every memory write passes through admission control evaluating:

• Provenance: Where did this information originate?
• Source Reliability: Is the source trustworthy?
• Factual Confidence: How certain is the accuracy?
• Novelty: Does this contradict existing trusted memory?

A memory produced by an agent must NOT automatically become authoritative.

Pricing#

Status#

LIVE: CAIN Memory API is operational at https://cainstudio.online/fabric/memory/ (verified 2026-09-08, returns 2 memories for test tenant).