Documentation

What is caller memory?

Caller memory is the ability of an AI voice agent to recognize a phone number and recall who it belongs to and what happened on prior calls — delivered before the agent's first word, not looked up mid-conversation.

That's the whole definition. Everything below is what it takes to actually deliver it.

Caller memory vs. conversation memory

These get collapsed together constantly, and the collapse is where most "AI agent memory" products lose the phone.

Conversation memory — what most memory APIs build — assumes the agent already knows who it's talking to. A logged-in user sends a message; the system embeds it, stores it, retrieves related history later. The identity question is already answered before memory does any work.

Caller memory starts one step earlier. A phone rings. The only input is +15551234567 — no message, no session, no logged-in user. Before the agent can say anything useful, something has to answer: who is this, and what do we know about them? That's an identity-resolution problem, not a retrieval problem, and it has to resolve in the gap between pickup and the first word — a budget measured in hundreds of milliseconds, not the seconds a chat spinner gets away with.

Mnemix does both — conversation memory across calls, plus the caller-identity resolution that has to happen first for voice. The distinction matters because a product built only for the first (most memory APIs) has nothing to say about the second.

What resolves, and when

A cold call — a phone number Mnemix hasn't seen — triggers two things in parallel:

  1. Memory lookup. Same-number history: has this caller called before, what happened, what's on file.
  2. Real-world enrichment. Identity resolution from Trestle and Twilio Lookup — carrier, line type, and (where available) the name/company behind the number — for callers with no prior history.

Both come back in a single response, known for a repeat caller or freshly enriched for a first-time one. A returning caller resolves from cache in milliseconds; a genuinely new number is the one case where enrichment does real work. See Architecture for how the hot path keeps this fast, and Enrichment for how real-world identity gets folded into governed memory.

Where it lives in the API

Caller memory isn't a separate product — it's what POST /v1/recall_and_enrich returns. Call it once, before the agent's first turn:

curl -sS -X POST https://mcp.mnemix.ai/v1/recall_and_enrich \
  -H "Authorization: Bearer $MNEMIX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "phone_number": "+15551234567", "trigger": "answered" }'

The response carries caller (identity), memory (prior-call summary and recent history), and enrichment (real-world identity for a cold caller) — everything the agent needs to open with "Hi Mike, calling about Thursday's appointment?" instead of "Who am I speaking with?"

Next steps

  • Quickstart — wire this into a live call in five minutes.
  • API reference — the full request/response shape for all three endpoints.
  • Architecture — how the hot path stays fast enough for voice.