Outcome memory · private beta

Your agent remembers what sounds related.
Not what actually worked.

So it walks back into the wall it hit three sessions ago. Nothing ever told it that path was a dead end. Hebbrix is the memory layer that keeps what worked.

Start free →See the difference →
agent · memory.recall()
recall("deploy the staging build")
↳
"how to deploy to staging"
nearest match · sounds related
↳
"last staging deploy failed until WS_TOKEN was set"
what actually worked · kept because the outcome mattered
Try a query
The gap

Two ways to remember. Neither asks the question that matters.

Similarity search
“What looks like my query?”
Retrieves by resemblance. It surfaces what sounds related, whether or not it ever helped.
Temporal validity
“Is this fact still true?”
Tracks whether a fact holds over time. Better, but it still can't tell a good outcome from a bad one.
Outcome memory · Hebbrix
“Did acting on this actually work?”
Keeps memory based on what led to a good result. The question that decides whether your agent improves.

Detecting that something failed is the easy part. Keeping what worked, and dropping what didn't, is where every system quietly breaks.

What we're building

A learning layer that keeps what worked.

1234
Agent acts
Your agent answers, calls a tool, or ships a step using the memory we surfaced.
Outcome observed
A signal comes back: it worked, it failed, the user moved on. The result gets recorded.
Memory updates
What worked is kept and gets stronger. The rest fades.
Next decision improves
The next recall surfaces what actually helped last time. The loop compounds.
↻ and it compounds
The drop-in

Change one line. Keep your stack.

Point your existing OpenAI client at Hebbrix. Memory is retrieved and injected into context automatically, so your agent remembers without any extra calls, no migration, and no rewrite.

from openai import OpenAI

client = OpenAI(
    api_key="HEBBRIX_API_KEY",
    base_url="https://api.openai.com/v1"  # change one line
)
Under the hood

The machinery behind outcome memory.

Five retrieval layers, a knowledge graph, and memory decay, all pointed at one job: surfacing what worked, fast, inside the API you already call.

Outcome-weighted recall
Five retrieval strategies run in parallel, then re-ranked by what actually led to good results, not just what sits nearest in embedding space. Sub-second.
Memory that decays on purpose
Memories that earned a good outcome strengthen. The rest fade on a curve modeled on human memory, so old dead ends stop resurfacing.
Knowledge graph, not just text
Agents reason over who knows whom, what changed, and when a fact was replaced. Relationships, not just resemblance.
A drop-in for the API you use
Change one URL. Outcome memory wraps your existing chat-completions call. No migration, no rewrite, portable across models.
Where it stands
0.0%
LOCOMO score
Long-term memory benchmark

Recall accuracy on LOCOMO, the standard benchmark for long-term conversational memory.

Give your agent a memory that compounds.

If you're running agents in production and this is costing you real time, start free. Or tell us where it hurts, and we'll help wire it into your workflow.

Start freeTalk to a founder

For teams running agents in production. 1,000 free credits a month, no credit card.