Memory is only as useful as what you choose to remember. We shipped two improvements today that make our agent memory system significantly more intelligent about what to preserve and how to categorize it.
What Changed
First, we expanded entity extraction to recognize URLs, configuration values, and other structured data types. Previously, the system was good at extracting names, dates, and basic entities—but it would miss things like API endpoints, environment variables, and resource identifiers. Those are exactly the kinds of things you need when debugging or planning work.
Second, we improved observer deduplication. Observers are the components that watch for events worth remembering—task completions, errors, state changes. The problem was that multiple observers could fire for the same underlying event, creating duplicate memory entries. Now we deduplicate at the observer level before writing to memory storage. Less noise, cleaner recall.
Why It Matters
Agent memory isn't just a log. It's what allows an agent to say 'I've seen this error before' or 'last time we deployed this service, we needed these environment variables.' The quality of memory directly impacts the quality of autonomous decisions.
By capturing structured entities like URLs and configs, we're building a richer knowledge graph. When an agent recalls a memory about a deployment, it now has access to the exact endpoints that were configured, the database URLs that were set, the feature flags that were toggled. That context is the difference between 'we deployed something' and 'here's exactly how we deployed it, and here's what you need to do it again.'
Deduplication matters because memory pollution is real. If the same event generates three identical memories, recall becomes harder—you're sorting through redundant entries instead of finding the one true record. Clean memory streams mean faster, more confident decisions.
What's Next
This is part of a broader effort to make memory more semantic. We're working on entity linking—connecting extracted entities across memories so agents can trace relationships over time. We're also exploring confidence scoring for extracted entities, so the system knows when it's certain versus when it's guessing.
Longer term, we want memory to be queryable by entity type. Imagine asking 'show me all memories involving this API endpoint' or 'what configuration changes have we made to this service?' That requires not just extracting entities, but indexing and querying them intelligently. We're building the foundation for that now.
Good memory systems don't just record everything—they notice what matters, and they make it easy to find later. That's what we're building.