MemState

MemState

Memory infrastructure for agents

Memory that evolves with your agent.

MemState is long-term memory for agents that does the bookkeeping for you. The agent sends observations (what it noticed) and asks for relevant context when it needs to think; MemState decides how to ingest, revise, and forget so retrieval returns the current truth, not a stale copy.

Agent integration → How it works
The problem

Agent memory is not a database problem.

The store you use when an agent is learning over time has to do more than write and read rows. It has to turn raw observations into structured memory, reconcile what was true yesterday with what is true today, and let irrelevant material fade — all without destroying the history that makes the current answer defensible.

A plain database overwrites. A vector store ranks by similarity but has no idea what is fresh. A document store can't safely reason about the consequences of a change. MemState treats all of these as first-class concerns of the memory layer, so the agent loop only emits observations and questions.

How it works

Three ideas you need to know.

01

Everything is a topic.

A topic is one self-contained unit of knowledge — a person, a project, a document, a concept. It carries its own fields, its own embedding, and typed links to other topics. One read returns the full picture of one thing; you don't chase pointers across a generic graph to reassemble it.

02

Every field keeps its history.

When a value changes, MemState doesn't overwrite it. It appends a new revision and marks it as the current value; the previous revision stays in place with its timestamp and its source. Retrieval returns the latest version by default; a question that needs the story can ask for history explicitly.

03

Memory maintains itself.

After every write and every read, a background reasoner looks at the store. It consolidates duplicates, attenuates topics that stopped being used, and archives the ones that fall below a relevance threshold. None of this adds latency to the request — it runs after the response is sent.

What MemState promises

Two guarantees worth depending on.

Promise 1 — Current truth by default Every retrieval returns the most recent, non-archived value for each field. A caller that doesn't ask for history will never accidentally see a superseded value as if it were current.
Promise 2 — Transitions respect policy Every change to the store goes through one of four well-defined operations — ingest, retrieve, revise, or forget. Ingest and retrieve are what the agent calls; revise and forget are driven by MemState policy after those calls. Limits on history length, salience thresholds, and archival rules are enforced uniformly. No back door.
What's in the box

What you get.

  • Observation-driven memory — you ship what the agent saw; MemState maps it onto topics, fields, and links and preserves prior values.
  • Context on demand — the agent asks in natural language; MemState returns the relevant topic memory (structured fields, summary, links), with optional neighborhood and timelines when needed.
  • Honest history — every field remembers its past values with timestamps and sources, so the agent can explain how it got to today.
  • Active memory stays loud — things the agent actually uses stay easier to find; idle threads quietly step aside.
  • Gentle cleanup — duplicates and stale units are merged or archived without deleting the trail that made answers trustworthy.
  • Linked context — connect topics the way people connect ideas: related work, dependencies, and references.
  • Your stack, your surface — integrate from application code, drive from a UI, or let an LLM use tools — one memory underneath.
Keep reading

Explore the system.