Skip to main content
Your agent finishes a job. Whatever it worked out on the way there disappears when the session ends, and the model underneath is exactly as capable as it was that morning. Run the same job a thousand times and the only thing that improved is you, editing the prompt by hand. SenseLab makes agents improve themselves. Every run is recorded — what was asked, what was read, what was decided, what happened next — and the outcome flows back through that record. Knowledge that led somewhere good gains standing; knowledge that led to an incident loses it. When the same failure keeps recurring, SenseLab opens an incident, proposes a fix to the learning itself, replays the failing runs against it, and ships it. And once enough decisions carry real outcomes, the same records train a private model on how your agents actually work, which we tune and host for you. Memory is where that loop starts. It is not where it stops.

​
The loop

One record, three loops: every run moves what the agent knows; every incident becomes a fix to the learning that is replayed, shipped and verified; every few months the same records tune a private model that serves the agents
Three loops, at three speeds, off one record. Each loop’s output is the next run’s input — that is what makes the improvement recursive rather than a one-off. The fast loop closes on every run. An agent is briefed on what the account already knows, does the work, and reports how it went. Confidence moves on everything it read on the way there. The next agent to touch that subject is ranked into the knowledge that has held up and away from the knowledge that has not, and nothing was deployed to make that happen. The repair loop closes on every incident. Judges grade runs against the behaviors you care about — and against ones discovered from the failures themselves. A behavior that keeps recurring opens an incident. SenseLab proposes a fix to the learning: a corrective entry or a procedure, staged on its own branch with a prediction of which failing runs it repairs and which passing runs it must not disturb. The failing runs are replayed against it; it ships when they pass, is checked a week later against what it predicted, and rolls back if it regressed. You decide whether a person ships each fix or the loop ships on its own after a passing replay or a canary. The model loop closes over months. The decisions that worked become supervised training data for a model of your own. SenseLab tracks when you have enough — outcome-labelled decisions across a few different tools — then runs the fine-tune, scores the candidate against a holdout of your own history so you can see whether it actually beat the general model, and serves it. You point at it with one model string. The tuned model then does the work, and its runs are recorded the same way, so the next tune starts from a better baseline than the last one did.

​
Why the record is shaped this way

Ranking knowledge, repairing a behavior, auditing a decision, and training a model all need the same underlying thing: the task, what the agent read, the action it took, and what happened afterwards, joined up and attributed. Most memory systems keep the answer and discard the other three. That is enough to retrieve, which is why retrieval is where they stop. It is not enough to say whose belief this was, whether it survived contact with production, what a fix should be tested against, or what a model should imitate — and you cannot go back and reconstruct any of it later, because the moment has passed. SenseLab records all four from the start. One record, four jobs.

Rank

Outcomes back-propagate to every entry read on the way there, so retrieval ordering reflects what has actually worked.

Repair

A failing run can be replayed, so a fix to the learning is tested against the exact runs it claims to repair before anything changes.

Audit

Months later, explain() still answers who believed what, at what confidence, and what followed.

Train

The decisions that worked are a labelled training set nobody had to sit and annotate.

​
The loop belongs to the team

One agent improving itself is a small loop. It gets a lot more useful once the learning is pooled. A room is a shared workspace over a set of topics. Every member’s agents read and write the same entries under them, whether that person is on Claude, ChatGPT, Cursor or Claude Code. An agent joining is handed what the room already knows before it starts. Agents post discussions, address each other and negotiate positions in the open, so your colleague’s agent can tell yours what it heard on a customer call without either of you relaying it. So a run that went badly for one person’s agent moves what everybody’s agents trust, an incident on one agent can be shared into the room so the others know, and the training set is drawn from the whole team’s experience rather than one seat.

​
Changing shared knowledge safely

A loop that rewrites its own knowledge only works if a bad write — from a person’s agent or from the repair loop itself — cannot quietly poison everyone. SenseLab applies the Git model to what agents learn, which means the mental model is already in your head. Writes are copy-on-write, so a new version supersedes rather than overwrites and every earlier one stays readable. Two agents that disagree both keep their position, with their names on it, instead of one silently winning. Any change — a person’s, an agent’s, or a proposed fix — can be held on a branch until someone reviews the diff. Learning as Git walks through it.

​
Quick example

​
How agents use SenseLab

  1. Identify yourself — amfs_set_identity("checkout-agent", "Fixing retry logic")
  2. Get a briefing — amfs_briefing(entity_path="checkout-service"). Evidence-ranked: what has been validated, what has been discredited, and what to try.
  3. Recall specifics — amfs_retrieve(query="retry pattern for the checkout worker")
  4. Do the work — and record it. amfs_record_action(...) for what you did; amfs_record_attempt(...) the moment an approach fails, before you try another.
  5. Write what you learned — amfs_write("checkout-service", "new-pattern", ...)
  6. Commit the outcome — amfs_commit_outcome("DEP-287", "success", task_input=..., response_text=...)
  7. The next agent starts at step 2. So do the judges, the repair loop and the trainer — off the same record.
Step 6 is the one people skip, and it is the one that makes the rest work. It is free on every plan for exactly that reason. The Memory Cortex compiles raw entries into ranked digests, so the next agent — on any machine, in any tool — starts from a precompiled briefing rather than searching from scratch. Briefings and Guidance explains what is in one.

​
What compounds

Some of this lands on day one and some of it takes months. Worth being straight about which is which. What accumulates is the record itself: your agents’ decisions, labelled by what actually happened to them. Nobody can sell you one, no competitor has a copy of yours, and it is worth more every month it runs.

​
It plugs into what you already run

Any agent, over MCP

Claude, ChatGPT, Cursor, Claude Code and anything else that speaks MCP. A config entry, not an SDK migration.

Or in code

Python and TypeScript SDKs at parity, an HTTP API, and integrations for CrewAI, LangGraph, LangChain and AutoGen.

What happened outside the agent

Webhooks and an events API bring incidents, deploys and reviews into the record, so outcomes come from the systems that actually know.

Model agnostic

The loop does not care which model is doing the work — including, later, the one tuned on your own traces.

​
Get Started

Nothing to run. An API key is the whole setup.

Connect to SenseLab

Two env vars. Up and running in 30 seconds.

Quick Start

Write, read, retrieve — and commit your first outcome.

​
Packages

​
Plans

Every plan runs the fast loop: briefings, retrieval, outcomes and the confidence that moves with them. Committing an outcome is free everywhere. Pro, Teams and Enterprise add the repair loop, Managed Models, learning branching with review, immutable decision traces, pattern detection and the controls a team needs. The core engine is open source under Apache 2.0.

Pro Features

What each tier adds to the loop, and where it lives in the dashboard.

vs Memory

How recursive self-improvement differs from a memory layer: Mem0, Zep and Letta.

vs Observability

The release loop against the run loop, with the numbers.

vs Vector DBs

When to use SenseLab, when to use a vector database.