Docs that ship code.

01Quickstart

This walks you from zero to a working recall in about five minutes. You'll need a free AgentPrizm account (sign up — the Hobby tier is free forever, see pricing) and any HTTP client — curl is fine.

1. Get your API key

Create a key in the dashboard under API keys. Keys are prefixed ap_. Set it in your environment:

export AGENTPRIZM_API_KEY=ap_xxxxxxxxxxxxxxxxxx

2. Ingest your first memory

Call the REST API directly — no SDK or local install required.

curl https://agentprizm.com/api/v1/agent/memories \
  -H "Authorization: Bearer $AGENTPRIZM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "Procurement freezes Dec 15 → Jan 5. Renewal owner: Priya.",
    "type": "fact",
    "containers": ["acme-co"],
    "source": "call-2026-01-12"
  }'

3. Recall it

curl https://agentprizm.com/api/v1/agent/recall \
  -H "Authorization: Bearer $AGENTPRIZM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "when can we close?",
    "containers": ["acme-co"],
    "limit": 5
  }'

4. Or connect over MCP — zero install

Point any MCP-capable agent (Claude Code, Cursor, Claude Desktop) at our remote MCP endpoint. No subprocess, no package to publish — just URL and key.

{
  "mcpServers": {
    "agentprizm-memory": {
      "type": "http",
      "url": "https://agentprizm.com/api/mcp",
      "headers": { "Authorization": "Bearer ap_..." }
    }
  }
}

02Core concepts

Memories

A memory is a single atomic item — one of six types: fact, lesson, directive, preference, contact, or bookmark. Each memory carries a type, source, confidence, optional tags, and an optional validity window, and belongs to one or more containers.

Containers

Containers partition memory across environments and tenants. sales-agent-prod and sales-agent-staging are isolated; recalls in one cannot see memories in the other.

Hybrid recall

Recall blends semantic (vector similarity) and keyword matching, then layers in fact-validity windows (recency + valid_from / valid_until) and contradiction handling (newer facts shadow older ones). You can pin or down-weight memories with validity and confidence filters.

Validity windows

Memories can carry validFrom / validUntil. Recalls outside the window return the memory with reduced confidence and a stale flag. The agent decides whether to use it or re-verify.

03AgentSkills

A skill is a reusable capability written as a SKILL.md instruction — a named, versioned block of guidance an agent loads to perform a task a particular way. It is distinct from a memory: a skill is an instruction you reuse; a memory is a fact you recall.

Visibility & maturity

Every skill is private by default (scoped to your account, governed like memories) and can later be published to the marketplace. Each skill also carries a maturity flag — draft (work in progress) or stable (exercised and safe to rely on). Maturity is independent of visibility.

Semantic discovery & SKILL.md portability

Skills are embedded on creation, so discovery is semantic — search by meaning, not keyword. Any skill exports to a SKILL.md file you can version in git or share, and any SKILL.md imports back into the registry, making skills reviewable in pull requests.

REST & MCP surface

The skill surface is available over REST — POST /api/v1/agent/skills plus /get, /search, /list, /update, /deprecate, /import, and /export — and over MCP via skill_publish, skill_get, skill_search, skill_list, skill_update, and skill_deprecate.

# Publish a private skill
curl -X POST https://agentprizm.com/api/v1/agent/skills \
  -H "Authorization: Bearer $AGENTPRIZM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "pr-review-house-style",
    "description": "Review a PR against our house style guide and flag deviations.",
    "content": "# SKILL: PR review\nCheck naming, test coverage, and no console.log in committed code. Comment inline; summarize at top."
  }'

04Marketplace

The marketplace is where private skills become public, discoverable, and reusable by other accounts. A browseable web UI lives at /skills.

Publish public

POST /api/v1/agent/skills/publish-public promotes a private skill to the marketplace. Before it goes live the content runs through an automated secret/PII scan, and anti-Sybil caps limit how many skills one account can publish in a window.

Browse, install & fork

Search public skills with POST /api/v1/agent/marketplace/search. Install (/marketplace/install) copies a public skill into your account as a private copy you can adapt without contributing back. Fork (/marketplace/fork) creates a public derivative — forks are public-from-creation, carry immutable lineage, and are copyleft: a fork can never be made private. If you want a private derivative, use install instead.

Reporting

POST /api/v1/agent/marketplace/report flags a public skill (leaked secrets, abuse, IP violations) for the moderation queue. MCP exposes the full surface as skill_marketplace_search, skill_marketplace_get, skill_install, skill_fork, skill_publish_public, skill_unpublish, and skill_report.

05API & tooling

The HTTP API and the remote MCP endpoint are live today — both work from any language or agent with zero local install. The REST API covers the full surface; the MCP endpoint exposes the same tools to any MCP-capable agent.

06Migration guide

Coming from Mem0, Zep, Letta, or your own Postgres + pgvector setup? You can move your data over today by reading from your current store and replaying records into the POST /api/v1/agent/memories endpoint — one memory per row, with type, containers, source, and validity windows mapped across.

# For each record in your existing store, POST it to AgentPrizm:
curl https://agentprizm.com/api/v1/agent/memories \
  -H "Authorization: Bearer $AGENTPRIZM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "content": "...", "type": "fact", "containers": ["prod"], "source": "mem0" }'

Want a hand with a large or one-shot migration? Talk to us — we'll help you map your schema and batch the import. Dedicated importer tooling is on the roadmap.

07Common patterns

Conversation summarization

Run an LLM summary at end of session, then ingest the key takeaways as type: "lesson" or type: "fact" with source: "conversation". Recall on the same container + topic in the next session — confidence-ranked memories surface first. (The /conversations endpoint can extract these for you.)

Preference learning

Capture preferences as type: "preference" with no validity window. Contradictions resolve newest-wins, so a newer preference shadows an older one automatically.

Tool-call grounding

Before any high-stakes tool call, recall the container's recent state and inject the top memories into the system prompt. The agent stops asking questions it has already asked.