Databases became infrastructure because applications needed a reliable way to manage state. Agent systems will need infrastructure for learning: a shared layer that carries knowledge across agents and models, connects it to real outcomes, and continuously improves what the system trusts.
The idea was straightforward. A group of agents would monitor production systems, catch incidents before humans did, and learn from every deploy and every failure.
The kind of system that gets smarter the longer it runs.
We got far enough to see it work, then hit a wall.
The agents couldn't share what they knew. One agent would investigate an incident, find the pattern, and fix it. The next agent had no way to build on what the first one learned.
Two agents working on the same service could reach different conclusions, and neither could see what the other had already established. A similar incident would fire two weeks later, and the agents would repeat the same investigation.
We tried shared markdown files, a vector store, and bigger prompts with more context. None of it held.
As the history built up, agents pulled stale information, drowned in context that didn't apply, and repeated approaches that had already failed.
The agents remembered more. They didn't learn.
Nothing we tried could tell what still applied, what had worked, or what should be trusted next. And nothing connected what an agent knew and decided to what actually happened afterward.
We stopped building the AI SRE and started building the infrastructure underneath it.
Agents generate valuable knowledge every time they work.
They solve problems, make decisions, test approaches, discover what works, and find out what doesn't.
But most AI systems have no way to turn that experience into learning.
One agent solves something another agent already solved. Different agents repeat the same research. Failed approaches come back because nothing learned from the failure. Switch models or tools and valuable knowledge gets fragmented again.
As you add more agents, the problem gets more expensive: repeated work, unnecessary tokens, conflicting decisions, and valuable experience that never makes the system better.
AI systems don't just need more memory. They need a way to learn from what happens.
A markdown file can store what happened. It doesn't know what's still true, what failed, or what should be trusted.
A vector store can retrieve what's similar. Similarity doesn't tell an agent whether the information actually led to the right outcome.
And memory can carry information forward. But remembering what happened isn't the same as learning from it.
What's missing is the feedback loop between what an agent knew, what it did, and what happened next.
An agent uses a pattern and the fix holds. That should matter.
Another agent follows an approach and it fails. That should matter too.
SenseLab connects those outcomes back to the knowledge the agents used. What works gets reinforced. What fails loses confidence. Contradictions can be surfaced instead of becoming another piece of context.
Over time, the system gets better at knowing what to trust.
And because that knowledge is shared, what one agent learns can improve what other agents, models, and teams do next.
That's where memory becomes continual learning.
SenseLab is infrastructure for AI systems to learn continuously.
It turns what agents learn into shared memory across agents, models, and teams, then uses real outcomes to improve what the system knows and trusts.
Every agent contributes to the same growing body of knowledge.
When agents act on that knowledge, the results feed back into it.
What works gets stronger. What fails gets weaker. What the system learns becomes available to the agents that come next.
The result is a feedback loop where work creates experience, experience creates knowledge, and outcomes make that knowledge better.
Agents repeat less work, use fewer tokens rebuilding what the system already knows, and make decisions with knowledge shaped by what actually worked before.
In our original AI SRE, that means the first agent investigating an incident can start with what the system has already learned. It adds what it discovers and acts on it.
When the outcome comes back, SenseLab updates the knowledge behind that decision.
The next agent doesn't just retrieve what happened last time. It starts with what the system learned from it.
Rooms handle the team side. Every member's agent reads and writes the same entries under a shared set of topics, so there's no private copy to drift. An agent that joins gets what the room knows before it starts work.
Those records do a second job. A decision that went through the loop already has its outcome attached, which is the expensive part of a training set. The next thing we ship is a model tuned on the ones that worked, scored against your own history first.
SenseLab works across agents, models, and tools. Use Claude Code, Cursor, CrewAI, LangGraph, AutoGen, or your own agents through MCP or SDK.
The knowledge and learning layer stays independent of whatever model or framework sits on top.
As agents take on more work, they generate more than outputs.
They generate experience.
Which approaches worked. Which failed. Which decisions held up. Which assumptions turned out to be wrong.
Today, most of that experience disappears into logs, conversations, vector stores, and disconnected memory systems. More agents generate more experience, but the system itself doesn't necessarily learn from it.
We think that has to change.
Databases became infrastructure because applications needed a reliable way to manage state. Agent systems will need infrastructure for learning: a shared layer that carries knowledge across agents and models, connects it to real outcomes, and continuously improves what the system trusts.
Without it, every team building serious agent systems eventually has to rebuild some version of the same thing: shared knowledge, confidence scoring, outcome feedback, cross-tool context, decision lineage, and the training data nobody thought to keep.
That's the layer we're building with SenseLab.
Bruno brings deep infrastructure experience. He built middleware and OLAP databases that process millions of transactions a day, and led teams of 200-plus people on critical, large-scale products.
Dai is an engineer turned product leader, with a background in infrastructure and go-to-market for products used by more than a million developers.
Together, they've already built and sold two startups, acquired by Juniper (now part of HPE) and Mirantis.
Between them, they've spent twenty years building infrastructure that powers products for companies such as Visa, Disney, and Nike.
They're doing it again with SenseLab, now for AI agents.
Free tier. No credit card. Connect through MCP or SDK in under five minutes.
Start building shared knowledge across your agents and connect what they learn to real outcomes.
If you want to self-host, the full codebase is available on GitHub under Apache 2.0.
record_context() and capture the full causal chain behind an action: what was read, at what confidence, what external input arrived, what was decided. Pro persists traces with integrity checking. Most competitors have no equivalent.
A vector database answers one question: what is most similar to this query? It returns the nearest embeddings and stops there.
SenseLab answers the questions that actually decide whether an agent should act: who learned this, how confident should we be, what happened the last time someone acted on it, who else on the team knows it, and can I see the reasoning six months later.Those are not two flavours of the same product. A similarity index has no notion of an author, a version, an outcome or a teammate, and no amount of metadata columns adds one. Everything on this page that a vector database does not do is something you would be signing up to build and then maintain.
An access log can tell you that an agent read a memory at a particular time. Decision lineage captures what those memories said at that moment, how confident the system was in each, and what happened afterward.
SenseLab seals a signed trace at outcome commit, holding the entries read, their exact versions and confidence at read time, and the result.
Edit a sealed trace and verification fails on a hash mismatch. This makes tampering visible rather than impossible, since someone holding both the database and the signing key could still rewrite it.
Row-level security is enforced on the memory tables, and API keys can be scoped to entity-path patterns with read or write permission.
A gate runs before every write and can allow, redact, or block sensitive information before it enters memory.
SenseLab flags contradictions instead of silently treating every new entry as true.
If knowledge contributes to a failed decision, its confidence can decrease. Every version stays on record, so you can inspect what changed and roll back when needed.
Less than five minutes. Connect through MCP or SDK with no framework rewrite required.
Works with Cursor, Claude Code, CrewAI, LangGraph, AutoGen, and LangChain.
Free tier. No credit card. Connect in minutes.
.jpeg)
