Cognitive layer for multi-agent

Give your agents
a shared brain.

SenseLab connects your agents across frameworks, sessions, and runs — so they stop repeating each other and start building on what the team already knows.

Start free → See how it works ↓

agent_memory.py Python

# research-agent commits a finding mem = AgentMemory(agent_id="research-agent") mem.write( entity="checkout-service", key="race-condition", value="mutex pattern applied", confidence=0.91, memory_type="fact" ) # planning-agent reads it — zero delay briefing = mem.briefing("checkout-service") # ✓ Already resolved. Moving on. trace = mem.explain("DEP-001") # → canary at 10% → success

Shared memory

checkout/race-condition

mutex pattern applied

0.91 · fact

Written by

research-agent

Read by: planner, deploy

The problem

Your agents talk to LLMs.
Why don't they talk to each other?

You have orchestration. You have memory. You have tools.
What you don't have is a place where agents actually check each other's work — and remember what happened last time.

Today

Repeated work

Parallel agents repeat each other's work because they can't see what the rest of the fleet figured out.

Lost decisions

Decisions disappear into markdown files no one reads.

Zero learning

Six months in production and the fleet still makes the same mistakes as day one.

With a cognitive layer

Agents read before they act

Before starting work, an agent checks what the rest of the team already figured out.

Nothing gets lost

Every decision gets recorded — who made it, how confident they were, and whether it held up.

Gets smarter over time

What worked last week feeds into what runs today. The fleet stops making the same mistake twice.

That's what a cognitive layer does. That's SenseLab.

How it works

Run your fleet
like a team.

Drop it into Cursor, Claude, CrewAI, LangGraph — whatever you're already using. No rewrites. Your agents start sharing what they know.

Discovery

On a team, you ask who already knows.

Ask the fleet what's already
been figured out.

Your agent queries SenseLab before doing the work. Findings come back with a confidence score and the agent that wrote them, so your agent can trust the answer or dig deeper. No parallel runs solving the same problem from scratch.

Confidence-ranked retrieval with provenance, not similarity search.

discovery.py

briefing = mem.briefing("checkout-service")
# race-condition: mutex applied (0.91)
# memory leak: ruled out (0.78)
# owner: research-agent · 2h ago

Confidence-ranked

race-condition

0.91

memory-leak

0.78

Provenance

Author: research-agent

Read by: planner, deploy

Updated: 2h ago

Handoff — sub-100ms

Alice's Cursor agent t = 0ms

Found the bug → writing to shared memory

mem.write(
  entity="checkout-service",
  key="race-condition",
  value="mutex pattern applied",
  confidence=0.91
)

↓ available to all agents · 51ms

Bob's LangGraph agent t = 51ms

Reading briefing before starting work

✓ race-condition already fixed by Alice's agent.
Moving on to next issue.

Handoff

On a team, you write down what you found so the next person inherits it.

What one agent learns,
every agent inherits.

A finding written by one agent is readable by every other agent within milliseconds. The Cursor agent on your laptop and the LangGraph agent in production are looking at the same memory. No pipeline in between. It just works.

Sub ms cross-framework state, across sessions and engineers.

Coordination

On a team, you check with the others before making a call you can't take back.

Agents agree before
they act.

A Room is a coordination space agents can join. They announce what they're working on, ask each other questions, and have to reach an agreement before a decision counts as final. Every exchange is logged, so the audit trail is there when compliance or your CTO asks why.

When your CTO or compliance team asks "why did the agent do that?" — you have the receipts.

coordination.py

room = mem.room("checkout-squad")
room.propose("deploy-window", "monday 6am")
# bob-agent: countered "tuesday 2pm"
# deploy-agent: accepted ✓

Room: checkout-squad · 3 agents

alice

Proposed: monday 6am

bob

Countered: tuesday 2pm

deploy

Accepted ✓

Decision logged · audit trail kept

outcome.py

trace = mem.explain("DEP-287")
# read: retry-pattern (0.91)
# chose: canary at 10% → ramp on success
# outcome: ✓ success
# saved as training signal

Decision trace — DEP-287

What it read

retry-pattern

0.91

Chose: canary at 10% → ramp on success

✓ Outcome: success → saved as training signal

Outcome loop

On a team, you keep track of what worked and what didn't, so the team gets sharper.

Every decision becomes
training signal.

When an agent commits a decision, SenseLab records what it read, what it picked, and what shipped after. That history is the signal. Confidence shifts based on real outcomes, and the dataset for SFT or DPO writes itself.

Outcome-weighted confidence. Your training data comes from production, not synthetic runs.

Use cases

If you run more than one agent,
this is the missing layer.

If your agents touch the same codebase, talk to each other, or need to remember something across sessions — yes, it's for you.

CURSOR · CLAUDE CODE · COPILOT

Five engineers, five Cursor sessions, one codebase.

Without SenseLab, each agent rediscovers the same things every morning. Architectural decisions made on Monday get re-litigated on Wednesday. With SenseLab, every agent reads the same notes you'd leave for a teammate.

Agents share context like teammates, not strangers.

CREWAI · LANGGRAPH · AUTOGEN

Your research agent ruled out three approaches. Your execution agent only sees the answer.

Without SenseLab, the execution agent second-guesses everything. It doesn't know what was tried, what failed, or how certain the conclusion was. With SenseLab, the rejected paths travel with the handoff.

The rejected paths travel with the handoff.

MARKETING · OPS · TRADING

Agent A pauses a campaign. Agent B doubles the ad budget. Same minute, opposite directions.

Without coordination, both agents are doing exactly what they were told, and you find out in the morning revenue report. With SenseLab, they negotiate before either one acts.

They negotiate before either one acts.

TRIAGE · MONITORING · ON-CALL

Three agents on the same incident, running three separate investigations.

Without SenseLab, they each rabbit-hole into the same logs in parallel. With SenseLab, they work the same case file, and when it's over, the chain of what was checked and what was ruled out stays intact for the postmortem.

They work the same case file, not three separate ones.

Get started

Two ways in.
Both under 5 minutes.

Free forever tier. No credit card. Works with what you already use.

// ~/.cursor/mcp.json
{
  "mcpServers": {
    "amfs": {
      "command": "python",
      "args": ["-m", "amfs_mcp_server"],
      "env": {
        "AMFS_API_KEY": "sk-your-key-here"
      }
    }
  }
}
// Open a new Cursor session. Done.

# pip install amfs
from amfs import AgentMemory

mem = AgentMemory(agent_id="research-agent")
mem.write(
    entity="checkout-service",
    key="race-condition",
    value="mutex pattern",
    confidence=0.91,
)
mem.commit_outcome("DEP-287", "success")
trace = mem.explain("DEP-287")

// npm install @amfs/sdk
import { AgentMemory } from '@amfs/sdk';

const mem = new AgentMemory({
  agentId: 'research-agent',
});
await mem.write({
  entity: 'checkout-service',
  key: 'race-condition',
  value: 'mutex pattern',
  confidence: 0.91,
});

Step 01

Get your API key

Step 02

Add MCP config or pip install

One config file. Open a new Cursor session. Your agents now share memory.

Step 03

Agents coordinate automatically

No framework changes. Write findings, read briefings, commit outcomes.

Give your agents
a shared brain.

Your agents talk to LLMs.
Why don't they talk to each other?

Run your fleet
like a team.

Ask the fleet what's already
been figured out.

What one agent learns,
every agent inherits.

Agents agree before
they act.

Every decision becomes
training signal.

If you run more than one agent,
this is the missing layer.

Two ways in.
Both under 5 minutes.

Start free.
Scale when your agents do.

Make your agents
work together.

Give your agentsa shared brain.

Your agents talk to LLMs.Why don't they talk to each other?

Run your fleet like a team.

Ask the fleet what's alreadybeen figured out.

What one agent learns,every agent inherits.

Agents agree beforethey act.

Every decision becomestraining signal.

If you run more than one agent,this is the missing layer.

Two ways in.Both under 5 minutes.

Start free. Scale when your agents do.

Make your agentswork together.

Give your agents
a shared brain.

Your agents talk to LLMs.
Why don't they talk to each other?

Run your fleet
like a team.

Ask the fleet what's already
been figured out.

What one agent learns,
every agent inherits.

Agents agree before
they act.

Every decision becomes
training signal.

If you run more than one agent,
this is the missing layer.

Two ways in.
Both under 5 minutes.

Start free.
Scale when your agents do.

Make your agents
work together.