Introduction

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 is a continual learning engine for agents. They write down what they learn and read it back on the next run. Every run is recorded — what was asked, what was read, what was decided, what happened next. Outcomes flow back through that record, so knowledge that led somewhere good gains standing and knowledge that led to an incident loses it, without anyone touching a prompt. Once enough decisions carry real outcomes, those same records train a private model on how your agents actually work, which we tune and host for you. Memory is the first stage of that loop. It is not the whole product.

The loop

The SenseLab continual learning loop: an agent works, the run is recorded, the outcome lands, and what the agent trusts moves — while the same records train a private model that then serves the agents

The important part is that there are two loops, and they run at different speeds off one record. The fast loop closes on every run. An agent is briefed on what the team 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 good knowledge and away from the bad, and nothing was deployed to make that happen. The slow 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, 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, 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, three jobs.

Rank

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

Audit

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

Train

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

The loop belongs to the team

One agent learning from 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, and the training set is drawn from the whole team’s experience rather than one seat.

Changing shared knowledge safely

Pooled learning only works if a bad write cannot quietly poison everyone. SenseLab applies the Git model to memory, which means the mental model is already in your head.

Every developer knows this:          SenseLab does the same for agent memory:

  repo                                 agent brain
  ├── main branch                      ├── main (what the agent knows)
  ├── feature branch                   ├── experiment branch (isolated changes)
  ├── pull request                     ├── pull request (review before merge)
  ├── code review                      ├── diff (what changed in the branch)
  ├── merge                            ├── merge (accept changes into main)
  ├── git log                          ├── timeline (every operation logged)
  └── git revert                       └── rollback (restore to any point)

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. Changes can be held on a branch until someone reviews the diff.

Quick example

from amfs import AgentMemory

mem = AgentMemory(agent_id="review-agent")

mem.write(
    "checkout-service",
    "risk-race-condition",
    "Race condition in order processing under concurrent load",
    confidence=0.85,
)

entry = mem.read("checkout-service", "risk-race-condition")
# → confidence: 0.85, written_by: review-agent

# The line that closes the loop: everything read on the way to this
# outcome moves, and the decision becomes training data.
mem.commit_outcome("DEP-287", "success")

How agents use SenseLab

Identify yourself         →  amfs_set_identity("checkout-agent", "Fixing retry logic")
Get a briefing            →  amfs_briefing(entity_path="checkout-service")
Search for specifics      →  amfs_search("checkout-service")
Read relevant entries     →  amfs_read("checkout-service", "retry-pattern")
Do the work               →  (agent performs its task)
Write findings            →  amfs_write("checkout-service", "new-pattern", ...)
Record outcomes           →  amfs_commit_outcome("DEP-287", "success")
Next agent starts at #2   →  Knowledge compounds across agents and sessions

Step 7 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.

What compounds

Some of this lands on day one and some of it takes months. Worth being straight about which is which.

When	What you get
Week one	Agents stop re-deriving things. A new session opens with a briefing instead of a blank context.
Month one	Enough outcomes have landed that ranking reflects what worked here, not what looked relevant. Bad guidance has started dying on its own.
Month three	The record is long enough to argue with. You can reconstruct why an agent did something, and patterns across failures become visible.
Month six and on	Enough outcome-labelled decisions to tune a model on. From here the agents and the model improve each other.

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, a CLI, and integrations for CrewAI, LangGraph and the rest.

Your storage or ours

Filesystem, Postgres or S3 adapters when you self-host. Nothing to run when you don’t.

Model agnostic

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

Get Started

The fastest way to start is with SenseLab — no infrastructure required.

Connect to SenseLab

Two env vars. Up and running in 30 seconds.

Quick Start

Write, read, and search agent memory.

Packages

Package	Language	Install
`amfs`	Python	`pip install amfs`
`amfs-adapter-postgres`	Python	`pip install amfs-adapter-postgres`
`amfs-adapter-s3`	Python	`pip install amfs-adapter-s3`
`amfs-http-server`	Python	`pip install amfs-http-server`
`amfs-cli`	Python	`pip install amfs-cli`
`amfs-mcp-server`	Python	`pip install amfs-mcp-server`
`@senselab-ai/amfs`	TypeScript	`npm install @senselab-ai/amfs`

Editions

SenseLab is open source under Apache 2.0. SenseLab Open Source is the memory engine and the fast loop: versioned writes, confidence scoring, outcome feedback, causal traces, knowledge graph, hybrid search, tiered memory, pattern detectors, and a git-like timeline on main, with the SDKs, adapters, HTTP API, MCP server and CLI. It is built for one developer’s agents on infrastructure you run. SenseLab is what makes the loop a team’s and closes the slow end of it: rooms, the full Git model with branching and review, multi-tenant isolation, immutable decision traces, governance, a dashboard, and models tuned on your own traces that we train and host. SenseLab Open Source gives you a repo with full history. SenseLab gives you GitHub, and a model that learns from what is in it.

Compare Editions

Full feature comparison between SenseLab Open Source and SenseLab.

vs Vector DBs

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

vs Competitors

How SenseLab compares to Mem0, Zep, Letta, and more.

Product

Getting Started

Guides

Self-Hosting

Core Concepts

Pro Features

The loop

Why the record is shaped this way

Rank

Audit

Train

The loop belongs to the team

Changing shared knowledge safely

Quick example

How agents use SenseLab

What compounds

It plugs into what you already run

Any agent, over MCP

Or in code

Your storage or ours

Model agnostic

Get Started

Connect to SenseLab

Quick Start

Packages

Editions

Compare Editions

vs Vector DBs

vs Competitors

​The loop

​Why the record is shaped this way

Rank

Audit

Train

​The loop belongs to the team

​Changing shared knowledge safely

​Quick example

​How agents use SenseLab

​What compounds

​It plugs into what you already run

Any agent, over MCP

Or in code

Your storage or ours

Model agnostic

​Get Started

Connect to SenseLab

Quick Start

​Packages

​Editions

Compare Editions

vs Vector DBs

vs Competitors

The loop

Why the record is shaped this way

The loop belongs to the team

Changing shared knowledge safely

Quick example

How agents use SenseLab

What compounds

It plugs into what you already run

Get Started

Packages

Editions