Agents that remember you across conversations
Long-term memory lands: agents extract facts and preferences from past conversations and recall them in brand-new ones, with continuity that survives sessions.
Tell an agent once that your emails must stay under 75 words, and every future conversation should
already know it. With v1.73 and v1.74, agents on the BYOA runtime get exactly that: two layers
of memory backed by AWS AgentCore Memory, both opt-in, both built to never break chat.
This is different from the mission working notes that shipped in v1.60. Those are a team's
memory between scheduled checks. This is the chat loop's memory of you: what you said, what you
prefer, carried across sessions.
What's new
- Conversation continuity (
v1.73): persisted conversations get an AgentCore Memory session. The loop loads its history from Memory and appends each completed turn, so core can stop resending the whole conversation every turn. - Long-term memory (
v1.74): two extraction strategies distill past conversations into structured records per user:vocion_facts(semantic facts) andvocion_preferences. Each memory-enabled turn retrieves the most relevant records (top 5 per namespace) and injects them as a context preamble. - Postgres stays the system of record. Memory is the loop's context source; the UI's data path is untouched. The preamble goes on the model input only, so stored messages stay pristine.
- Graceful everywhere. Every Memory failure degrades silently: continuity falls back to the payload history, recall falls back to no preamble. Memory must never break chat, and it doesn't.
Why we built it
Stateless chat loops rediscover the user every session. Anything you told the agent yesterday (constraints, formats, context about your accounts) has to ride along in the conversation payload or be repeated. Continuity fixes the mechanical half: the loop keys a Memory session per persisted conversation and owns its own history. Long-term memory fixes the human half: extraction strategies run against completed turns and produce records that survive the conversation that created them.
The default continuity mode is belt and suspenders: payload history still rides along, and the
loop prefers whichever source is at least as complete. That protects conversations that predate
Memory and survives failed writes. Set VOCION_MEMORY_AUTHORITATIVE=1 to omit payload history and
take the real token savings.
How to use it
Provision the Memory store once (idempotent; it also creates the two extraction strategies):
ENV=dev bash infra/agentcore/provision.sh
Then enable it on the runtime artifact with a single env var:
VOCION_AGENTCORE_MEMORY_ID=<memory-id>
That's it. From here the behavior we verified live against the real SSE route: state a preference
in one conversation ("emails strictly under 75 words"), and the extraction strategy turns it into
a structured record in about a minute. Open a brand-new conversation and the agent recalls it
correctly. The recall crossed sessions through long-term memory, not chat history; with
VOCION_MEMORY_AUTHORITATIVE=1 set and payload history omitted, the agent answered from Memory
alone.
Records are namespaced per user (/facts/<actor>, /preferences/<actor>), so one person's
preferences never leak into another's context.
What's next
- Flipping
VOCION_MEMORY_AUTHORITATIVEfrom opt-in to default once pre-Memory conversations age out, which turns the continuity layer into a straight token saving. - The same memory plumbing is available to every agent that moves to
harness.provider: runtime(see the BYOA runtime post from yesterday).
Links
- GitHub releases: https://github.com/vocion/vocion-core/releases/tag/v1.73.0 and https://github.com/vocion/vocion-core/releases/tag/v1.74.0
- Dashboard surface:
/dashboard/chat - Code:
packages/agent-runtime/src/memory.ts,infra/agentcore/provision.sh