Hume Remembers the Chat. It Does Not Remember the Caller Between Calls.

Quick answer: Hume's Empathic Voice Interface (EVI) can resume an interrupted conversation. When a call drops, you reconnect with the stored chat group ID and the agent picks up where the conversation left off. That is call continuity, not caller memory. Start a brand-new call with the same person tomorrow and the agent knows nothing about them: no name, no preferences, no record of what was decided last time. If you want cross-call memory for your voice agent, you build it yourself or plug in a shared memory layer.

What Hume actually persists

Hume gives you several real persistence mechanisms, and each one has a precise scope.

Chat resumption. When a WebSocket session opens, Hume returns a chat_id and a chat_group_id. Store the chat group ID and you can reconnect to the same chat later by passing it as the resume parameter on the next handshake. This is built for one situation: the same conversation continuing after an interruption, like a dropped network connection or a user who wants to pick up the same chat later. The prior conversation context comes back intact.

Chat history and transcripts. With data retention enabled, Hume keeps conversation transcripts and chat events. You can pull them back to review what was said, and there is a documented resume-chats flow built on top of the same chat group mechanism. Turn this off with retention disabled, and even resumption stops working. Retention is a gate on every persistence feature.

Session settings. Every session accepts configuration: injected context text, template variables like a caller name or plan, a per-caller voice override, and a custom session ID you define for correlating the session with your own backend events. These let you feed the agent memory at the start of a call.

Custom language model. For full control you can point EVI at your own LLM endpoint. Then the session memory is yours to design: your endpoint receives the conversation and you decide what prior context to include.

Notice the pattern. Hume persists the conversation itself and gives you hooks to inject your own caller data. It does not maintain a caller profile for you. There is no built-in store where "this caller prefers morning calls" or "this customer already declined the upsell twice" accumulates automatically across calls.

What starts fresh on every new call

Unless you explicitly resume a chat group, each call begins with a blank agent. The new session has no access to last week's conversation unless you fetch it yourself and inject it. There is no cross-call entity memory, no automatic summarization of caller history into the next session, and no concept of a recurring caller whose preferences deepen over time.

For one-off conversations this is fine. For the automations this pipeline targets, it is the exact gap that costs you:

• A scheduled voice check-in that calls the same list of people weekly re-introduces itself every time and re-asks questions the caller already answered.
• A follow-up call meant to continue last week's discussion has no notion of "last week" unless your code fetched the transcript and stuffed the summary into the session settings.
• An outbound qualification agent that learns a prospect's objections on call one cannot recognize the same prospect on call two.

The common workaround is DIY: fetch past transcripts from your own database, summarize them, and inject the summary as session context before each call. This works and plenty of teams run it. It is also a small bespoke memory system you now own: the summarizer, the storage, the retrieval policy, the "what counts as worth remembering" logic, and the drift when summaries of summaries quietly lose the details that mattered.

The voice-agent version of a familiar problem

This is the same failure mode scheduled text agents hit, wearing a headset. An n8n workflow wakes up with no yesterday. A Make scenario starts each run blank. A Hume voice agent picks up the phone with no memory of the caller. The substrate is voice, the amnesia is identical.

Voice makes the amnesia more expensive, not less. A text agent that forgets asks a redundant question in a chat log. A voice agent that forgets asks a redundant question out loud, in real time, to a human who notices. Every re-asked question is a small credibility tax on the automation. People forgive a chatbot that forgot. They remember the phone call where the "smart" assistant had no idea who they were.

What a shared memory layer changes

The fix is the same shape as the fix for scheduled text agents: move the memory out of the session and into a shared layer that every run reads and writes.

With Vilix AI, the memory lives in the cloud, not in the call. One account holds the full conversation history, not extracted facts: what was said, what was decided, who prefers what. Anything connected over MCP reads and writes the same memory, so the context your voice agent learns on Tuesday's call is sitting there when Wednesday's scheduled follow-up runs, and when the text agent, the phone app, and the laptop all need the same truth. Newest correction wins everywhere, so correcting a caller preference once fixes it in every tool. It is cloud-hosted with zero infrastructure for you to manage, and the free plan is free forever with a 7-day Pro trial that needs no credit card. Export everything or delete it anytime.

Practically, the wiring looks like this. After each call, the agent (or your backend) saves the durable facts and the conversation to the shared memory. Before each new call, it recalls what it knows about this caller. The session settings you already inject in Hume get their content from the memory layer instead of from a hand-rolled database and summarizer you maintain. Hume keeps doing what it is best at: the empathetic real-time voice interface, the interruption handling, the sub-700ms responses. The memory becomes infrastructure instead of session plumbing.

The honest framing: Hume's resume feature solves dropped calls. Caller memory across calls is a different problem and it belongs in a layer built for it. Voice agents that remember their callers stop sounding like demos and start sounding like staff.

Hume's Empathic Voice Interface handles the real-time conversation. Vilix AI handles what your agents remember between calls: one cloud-hosted memory, shared over MCP, full conversation history, free forever with a 7-day Pro trial and no credit card.