AgentCall vs Spellar vs Otter: Cross-Call Memory for AI Phone Agents [2026]

Short version: Spellar 3.0 hit #1 on Product Hunt today with the pitch “AI meeting companion with cross-meeting memory.” Otter, Fathom, Granola, and Read.ai sit in the same category. They all do the same thing: listen to your meetings, transcribe them, and build a memory layer their product owns. AgentCall plus your own agent implements the same loop for phone calls, except your agent owns the memory. The brain, the data, and the recall logic stay on your side. This post explains the difference, shows a working end-to-end demo I ran today, and covers one real implementation gotcha worth knowing about.

TL;DR — Just want the product page? Cross-Call Memory for AI Phone Agents has the pitch, working code, comparison table, and a Start Free CTA. This post is the deeper why.

Meeting AI Already Won the Memory Pattern

The reason Spellar shot to #1 today is that the cross-meeting memory pattern is genuinely useful. You sit in a call on Tuesday, mention a commitment, and on Friday your AI assistant surfaces it. The tool becomes more valuable the more meetings it listens to, because the memory accumulates.

Spellar, Otter, Fathom, Granola, and Read.ai all converge on the same product shape:

• A bot or local listener joins your meeting.
• It transcribes audio.
• It writes a summary into a vendor-owned memory store.
• The vendor's chat UI lets you ask, “What did we agree last Tuesday?” and the vendor's LLM answers from the vendor's memory.

That works well for meetings, because meetings happen on platforms these tools can hook into (Zoom, Meet, Teams). It does not work for phone calls, because phone calls happen on the carrier network. A Spellar bot cannot join a phone call. And it does not work if you want to own the data, because the memory lives inside the vendor.

Phone Calls Are Where the Decisions Happen

Meetings are scheduled. Phone calls are urgent. Sales follow-ups, customer escalations, after-hours support, the call from your cofounder on a Saturday, the contractor confirming a Wednesday job. The conversations that move money tend to happen on phones, not on Zoom.

That is exactly the surface where a memory layer matters most, and it is the surface no meeting AI tool covers.

The AgentCall Plus Bring-Your-Own-Brain Pattern

AgentCall handles the phone side: a real US or Canada number, a managed AI voice agent that answers, transcripts and recordings, and webhooks for the lifecycle events. On the other side is a small bridge that sits between AgentCall and your own agent platform. The bridge is a reference implementation, MIT-licensed and open source, that you deploy as a Cloudflare Worker on a subdomain you own. The brain that consumes it is bring-your-own. Hermes is the example used in this post and in the reference docs, but Claude, GPT, Gemini, or a self-hosted model with a few lines of glue all work the same way. The bridge does two things:

• Pre-call: when someone calls your AgentCall number, AgentCall asks the bridge for the latest context block. The bridge returns whatever your agent pushed (today's brief, the caller's history, current priorities), and AgentCall merges it onto the AI's system prompt before the call connects.
• Post-call: when the call ends, AgentCall POSTs the full transcript plus a structured summary to your webhook. The bridge forwards it to your agent, your agent stores it in its own memory, and tomorrow's context references today's call.

Your agent is the brain. AgentCall is the phone. The bridge is the wire between them. The memory lives wherever you want it to live: a vector store, a Postgres table, a Notion doc, a JSON file on your VPS.

Bravo Tango 5: The Demo I Ran Today

Before writing this post I ran the loop end-to-end on my own number. Here is exactly what happened.

Call 1. I dialed my AgentCall number. The agent picked up. I said, “Remember this test code: Bravo Tango five.” The agent confirmed it heard me. I hung up.

Behind the scenes: the transcript arrived at my bridge endpoint about eight seconds after I hung up, my agent stored the code as part of the memory block, and the next pre-call context now contained the sentence “Test code on file: Bravo Tango 5.”

Call 2, about five minutes later. I called the same number again. The agent picked up. I asked, “What is the test code I gave you?” The agent said, “Bravo Tango five.” I hung up.

That is the entire claim of this product, demonstrated on two calls about five minutes apart. The memory is real, it survives the hang-up, and it lives in code I own. If I swap my agent from Claude to GPT to a local model tomorrow, the memory comes with me, because the memory is a file on my side, not a row in someone else's database.

AgentCall vs Spellar vs Otter: The Comparison

The honest tradeoff: meeting AI tools win on time-to-value. Install the Chrome extension or invite the bot and you are done in 60 seconds. AgentCall plus your own brain is more work to wire up, but you end up with a memory layer you control and a phone surface those tools cannot reach.

A fair update from a year ago: the meeting AI category is moving toward agent-readable interop too. Otter shipped an MCP server in late 2025 so other AI tools can query meeting data. Fathom now publishes a public API. Granola exposes an LLM picker inside the app. That trend validates the thesis behind AgentCall plus a bring-your-own brain: meeting data should be addressable by whatever agent the customer uses, not locked inside one product. The difference is direction of default. With Otter or Fathom, the primary copy lives in their database and you export. With AgentCall plus your own brain, the primary copy lives on your side and the bridge is just the wire.

How AgentCall Plus Hermes Cross-Call Memory Works

The wire-level shape is two HTTP calls. One inbound to your bridge when AgentCall needs context, one outbound from AgentCall to your bridge when a call ends. That is the whole protocol.

Pre-call: AgentCall asks your bridge for the latest context block.

# Your agent pushes a fresh brief to the bridge on a cron
curl -X POST https://hermes.your-domain.com/hermes/push \
  -H "X-Hermes-Push-Key: $HERMES_PUSH_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contextBlock": "Caller history: David called Tuesday about the Acme deal. Agreed to follow up Wednesday 2pm. Test code on file: Bravo Tango 5."
  }'

Post-call: AgentCall POSTs the transcript to your webhook with an HMAC signature.

# Subscribe once, runs forever
curl -X POST https://api.agentcall.co/v1/webhooks \
  -H "Authorization: Bearer ac_live_xxxxxxxxxxxxxxxx" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://hermes.your-domain.com/agentcall/transcript",
    "events": ["call.transcript"]
  }'

Your bridge receives the transcript, verifies theX-AgentCall-Signature header, and forwards the payload to your agent. Your agent does whatever it wants with it: vector embedding, structured extraction, a flat append-only log, anything. Full payload schema and reference parsers in JavaScript and Python are at /docs/post-call-webhook. The bridge itself is documented at /docs/hermes.

One Real Gotcha: Cloudflare Bot Fight Mode

I hit this today while wiring up the demo, so it goes in the post.

My Hermes brain runs as a Python script. The bridge sits on a Cloudflare Worker on my own subdomain, with Cloudflare's Bot Fight Mode turned on by default. The Python script POSTed to the bridge using urllib, the standard library default. Cloudflare returned HTTP 403 with Error 1010 and the messagebrowser_signature_banned. The script kept retrying. The bridge never saw the requests.

Cause: Cloudflare Bot Fight Mode flags requests with the default Python urllib User-Agent string as bot traffic and blocks them at the edge. It never reaches your Worker code, so there is nothing to debug in the Worker logs. The block happens above your application.

Fix: either send the request with curl from a subprocess (which uses its own User-Agent that Cloudflare accepts), or set a non-default User-Agent header on your urllib request. Both work. Example:

# Option A: shell out to curl
import subprocess, json
subprocess.run([
  "curl", "-sS", "-X", "POST",
  "-H", f"X-Hermes-Push-Key: {push_key}",
  "-H", "Content-Type: application/json",
  "-d", json.dumps({"contextBlock": brief}),
  "https://hermes.your-domain.com/hermes/push",
], check=True)

# Option B: set a real User-Agent on urllib
import urllib.request, json
req = urllib.request.Request(
  "https://hermes.your-domain.com/hermes/push",
  data=json.dumps({"contextBlock": brief}).encode(),
  headers={
    "Content-Type": "application/json",
    "X-Hermes-Push-Key": push_key,
    "User-Agent": "hermes-brain/1.0",
  },
  method="POST",
)
urllib.request.urlopen(req)

The reason this is worth documenting: if you put your bridge behind Cloudflare and you are not seeing your context pushes land, check Cloudflare's Security Events tab before you go hunting in Worker logs. Error 1010 in the Security Events tab is the giveaway.

Why Customer-Owned Memory Matters

The two patterns serve different audiences. If you are a sales rep whose memory needs span Zoom meetings, install Otter and never think about it again. That is the right tool for that job.

If you are a founder running your own agent, a developer building an AI product on top of a phone surface, or a small business that wants its customer call history to live in its own systems forever, the ownership story flips. You want:

• Brain portability. Switch from Claude to GPT to a local model without re-ingesting years of memory.
• Data portability. Move from one storage layer to another (Postgres to a vector DB to a flat file) without asking a vendor for an export.
• Composability with the rest of your stack. The same memory that answers the phone can write tomorrow's email, update your CRM, or post to Telegram. It is just a file your agent reads.
• No vendor lock-in on the memory layer. AgentCall is the phone provider. If you ever leave, you keep every transcript and every memory block, because they were never on our servers in the first place.

What This Costs

AgentCall Free includes one US local number and 5 minutes of inbound AI voice per month. Pro is $19.99/month plus $0.40/minute for inbound AI voice, all-inclusive (carrier minutes, AI voice, transcription, webhook delivery). Both tiers get the pre-call context webhook and the post-call transcript webhook. See pricing for the full breakdown.

The bridge is open source (MIT-licensed) and runs on Cloudflare Workers' free tier. Your agent platform costs whatever it costs: most are free if self-hosted, or you bring your own LLM credits.

Get Started

If you already have an agent platform you trust and you want it to answer the phone with memory, start at /docs/hermes for the pre-call bridge and /docs/post-call-webhook for the transcript loop. The full walkthrough takes an afternoon.

If you do not have an agent platform yet but you like the pattern, the worked example post covers a CEO and his AI strategist running the same loop end-to-end.

Spellar won today. Cross-meeting memory is a great pattern. For phone calls, where the urgent decisions actually live, the same pattern works, with one important twist: you own the memory.

Related Reading

• How to Give Your AI Agent a Phone Number That Remembers Every Call
• AgentCall vs Twilio: Why You Don't Need an Inbound Webhook
• Voice AI Infrastructure: Phone Numbers for AI Voice Agents
• Pre-call context webhook docs
• Post-call transcript webhook docs
• AgentCall product overview
• All blog posts