EngineeringJune 6, 2026

Agents with operational memory

Why agents need memory

An agent without memory is stateless in the worst way. Every session starts from zero. It cannot remember what it looked up last time, what it already tried, or what the state of the platform was when it last ran. So it re-derives everything, which is slow, expensive, and unreliable — and for operational agents that are supposed to act on real platform state, unreliable is the dealbreaker.

Riven runs internal agents on Forge, the agent workbench. For these agents to be useful they need to do more than call a model once. They need to reason over current platform state, act, and carry context forward. That requires durable operational memory. We call ours MemPalace.

What MemPalace is

MemPalace is the durable operational memory layer for Riven's internal agents. It does two things:

Store platform state. Facts the agent has observed or derived — configuration, prior results, decisions, the shape of a prior investigation — are written to MemPalace rather than held in a transient context window.
Search that state. When an agent starts a new session, it queries MemPalace for relevant context instead of rebuilding it from scratch.

The point is not to give the model a longer context window. It is to give the agent a place to put things it should not have to relearn.

How an agent uses it

A typical operational flow looks like this:

The agent receives a task — for example, reconciling model pricing against vendor list rates.
It queries MemPalace for prior context: what it found last run, what was in flux, what it already ruled out.
It queries live platform state for the current numbers.
It acts — compares, flags drift, writes a result.
It writes the outcome back to MemPalace, including what changed and what to watch next time.

Step 2 is what makes the agent reliable across sessions. Without it, every run is a cold start and the agent repeats work or contradicts itself. With it, the agent resumes a thread of reasoning rather than starting a new one.

Why this matters for reliability

Agent failure modes are usually memory failure modes in disguise. An agent that hallucinates a config value often does so because it has no record of the real one and no way to look it up. An agent that contradicts itself between sessions does so because it has no memory of what it said before. An agent that repeats expensive lookups does so because it cannot remember that it already did them.

MemPalace addresses these directly. The agent has a source of truth for platform state it can search, and a durable record of its own prior reasoning. The model still does the reasoning; the memory layer keeps the reasoning grounded and consistent.

The relationship to the model catalog

This is not abstract. The platform the agents reason over is real: 160+ models behind one OpenAI-compatible API at https://api.rivenai.io/v1, with per-model docs at docs.rivenai.io/docs/model-guides. An operational agent might need to answer "which models support a 1M token context" or "what is the current input rate for Kimi K3." Those answers live in platform state, not in the model's training data.

# An agent querying MemPalace for prior context, then the live API for current state
prior = mempalace.query("kimi-k3 pricing drift last 7 days")
live = riven_client.models.retrieve("kimi-k3")

# reconcile and write back
result = reconcile(prior, live)
mempalace.write("kimi-k3 pricing check", result)

What is next

MemPalace is internal infrastructure today, serving the agents we run on Forge. The interesting direction is making operational memory a first-class capability developers can use for their own agents — the same durable, searchable store, exposed through the platform. Memory is the difference between an agent that demos well and an agent you can rely on. We are building for the second case.