Quick Start

SenseLab gives each agent a persistent brain. When an agent writes, it’s forming a memory — logged on the agent’s timeline. When it recalls, it’s accessing its own experience. When it reads shared knowledge, it benefits from what other agents have learned.

This guide assumes you’ve connected to SenseLab. If you haven’t, do that first — it takes 30 seconds.

There are two quite different ways to use SenseLab, and most people only need the first:

In your IDE

Your coding agent calls memory itself over MCP. You talk to it in plain English — no code to write.

In your own code

You call the SDK directly to build memory into your own agents and services.

All agents share the same memory pool. The agent_id marks who wrote each entry. By default, every memory is shared — any agent can read it. Agents can also write private memories that only they can access.

In Your IDE

If you connected Cursor, Claude Code, Claude Desktop, or Codex, your agent already has the memory tools. You never call them yourself — you just talk to the agent, and it decides when to reach for memory.

Check it’s working

Ask your agent:

Check SenseLab and tell me what's in my memory.

If it comes back with a count of entries, you’re connected — a brand new account reporting zero entries still counts, because it had to reach your account to know that. If the agent says it has no way to check, restart your IDE: MCP servers are only picked up at startup.

Save something

Anything you’d otherwise repeat to every new chat is worth saving:

Remember that our staging database resets every night at 2am UTC,
so any data I ask you to seed needs to be re-seeded in the morning.

The agent picks an entity path and key and calls amfs_write for you. Durable decisions, gotchas, and preferences are all fair game — it stores personal context just as happily as code.

The part that matters: recall somewhere else

This is the whole point, so it’s worth doing once deliberately. Open a different tool — if you saved from Cursor, use Claude Desktop — and ask:

What do you know about our staging database?

It answers from the memory you saved in the other tool, on the other client. That is the thing a per-tool chat history cannot do.

If the agent claims it doesn’t know, it likely answered without searching. Tell it to search SenseLab first — or name the tool, amfs_retrieve, if it still won’t. The SenseLab Skill exists to make that automatic — the install script sets it up on Claude Code.

Get briefed before it works

Before an agent touches a codebase, one call gets it the compiled context — what’s known, what’s risky, and who else has worked there:

Get a SenseLab briefing on myapp/checkout before you start.

Close the loop

When a task ends, have the agent record how it went. Outcomes feed back into confidence, so memories that led somewhere good get trusted more and memories that led somewhere bad get trusted less:

Save how this session went to SenseLab — it worked.

Everything then shows up on your dashboard — the agents that have been active, what they wrote, and the decision trace behind it.

Agents work best when told when to use memory. Add the SenseLab Skill so yours sets an identity, searches before answering, and commits outcomes without being asked each time.

In Your Own Code

Everything below uses the Python SDK directly. Reach for this when you’re building your own agent or service rather than working through an IDE. See the TypeScript SDK guide for the same thing in Node.

1. Create Your Brain

Every agent gets its own brain via AgentMemory:

import os

from amfs import AgentMemory
from amfs_adapter_http import HttpAdapter

mem = AgentMemory(
    agent_id="review-agent",
    adapter=HttpAdapter(
        base_url="https://amfs-login.sense-lab.ai",
        api_key=os.environ["AMFS_API_KEY"],
    ),
)

The agent_id is the agent’s identity. Everything it writes is tagged with this ID, and it can later recall only its own memories.

The adapter is what connects you to your account. Without it AgentMemory writes to local storage — the filesystem in Python, memory in TypeScript — and every example below will appear to work while your dashboard stays empty. Install it with pip install amfs-adapter-http.

2. Form a Memory

When your agent learns something, write it to memory:

entry = mem.write(
    "checkout-service",       # entity_path — what this knowledge is about
    "retry-pattern",          # key — name for this piece of knowledge
    {                         # value — any JSON-serializable data
        "pattern": "exponential-backoff",
        "max_retries": 3,
        "base_delay": "200ms",
    },
    confidence=0.85,
)

print(entry.version)                 # 1
print(entry.provenance.agent_id)     # "review-agent"
print(entry.shared)                  # True (default — visible to all agents)

Every write creates an immutable copy-on-write version. Writing the same key again creates version 2, preserving the full history.

3. Keep Things Private

Not everything should be shared. Use shared=False for internal reasoning, scratchpad notes, or sensitive context:

# Private memory — only this agent can see it
mem.write(
    "checkout-service",
    "internal-analysis",
    {"risk_score": 0.92, "reasoning": "Error rate doubled after last deploy"},
    shared=False,
)

# Shared memory — the conclusion that other agents should know
mem.write(
    "checkout-service",
    "risk-assessment",
    "High risk: error rate trending up since v2.3.1",
    confidence=0.9,
)

Private entries are invisible to other agents across all methods — read(), search(), list(), and read_from() all skip them. Only the owning agent can access its private entries via recall() and my_entries().

4. Recall Your Memory

Ask your brain: “What do I know about this?”

entry = mem.recall("checkout-service", "retry-pattern")

print(entry.value)       # {"pattern": "exponential-backoff", ...}
print(entry.confidence)  # 0.85

recall() returns only entries written by this agent, including private ones. If another agent wrote a different version, recall() ignores it — it’s this brain’s direct experience.

5. Read Shared Knowledge

Ask the shared pool: “What does anyone know about this?”

entry = mem.read("checkout-service", "retry-pattern")

read() returns the latest shared version by any agent. Private entries from other agents are never returned. Both read() and recall() return None if no matching entry exists.

6. Learn from Another Agent

Explicitly pull knowledge from a specific agent’s brain:

entry = mem.read_from("deploy-agent", "checkout-service", "deploy-config")

if entry:
    print(f"Learned from deploy-agent: {entry.value}")

read_from() makes cross-agent knowledge transfer explicit and trackable. It only returns shared entries — you cannot read another agent’s private memories. The read is logged in the causal chain so you can always trace where knowledge came from.

7. See What’s in Your Brain

List everything this agent has written:

my_memories = mem.my_entries()
for e in my_memories:
    print(f"{e.entity_path}/{e.key} (v{e.version}, shared={e.shared})")

# Filter to a specific entity
checkout_memories = mem.my_entries("checkout-service")

my_entries() returns both shared and private entries — it’s your complete brain.

8. Learn from Experience

When something significant happens, record the outcome. SenseLab automatically adjusts confidence scores on related entries:

from amfs import OutcomeType

# An incident followed the retry pattern, so confidence in it erodes
updated = mem.commit_outcome(
    outcome_ref="INC-1042",
    outcome_type=OutcomeType.CRITICAL_FAILURE,
)

Failures erode confidence and successes reinforce it, so knowledge that keeps working is trusted more over time and knowledge that misleads fades:

Outcome	Effect on confidence
`SUCCESS`	×1.03
`MINOR_FAILURE`	×0.92
`FAILURE`	×0.90
`CRITICAL_FAILURE`	×0.85

If you don’t pass causal_entry_keys, SenseLab uses auto-causal linking — it applies the outcome to every entry the agent read during the current session.

9. Know Who You’ve Learned From

Track inter-agent memory relationships:

# Which agents have I read from?
reads = mem.cross_agent_reads()
# {'deploy-agent': [{'entity_path': 'checkout-service', 'key': 'deploy-config', 'read_count': 2}]}

# Just the agent IDs
agents = mem.agents_i_read_from()
# ['deploy-agent']

10. Watch for Changes

Get notified in real-time when knowledge changes:

def on_change(entry):
    print(f"Updated: {entry.entity_path}/{entry.key} v{entry.version}")

handle = mem.watch("checkout-service", on_change)

# ... later, stop watching
handle.cancel()

11. Context Manager

Use AgentMemory as a context manager for clean shutdown:

with AgentMemory(agent_id="review-agent") as mem:
    mem.write("svc", "key", "value")
# Background threads cleaned up automatically

12. View Your Timeline

Every operation is recorded on your agent’s git-like timeline — like commits in a repo:

events = mem.timeline(limit=10)
for event in events:
    print(f"[{event.event_type}] {event.summary}")

With SenseLab Pro, you can create branches, merge changes, and share memory selectively. See Git-like Timeline for details.

The Mental Model

What you want to do	Method	Sees private?	Who wrote it?
Form a shared memory	`write()`	—	You (this agent)
Form a private memory	`write(shared=False)`	—	You (this agent)
Recall your own knowledge	`recall()`	Yes (yours only)	Only you
Read shared knowledge	`read()`	No	Anyone (latest)
Learn from a specific agent	`read_from(agent_id)`	No	That specific agent
See all your memories	`my_entries()`	Yes (yours only)	Only you
Know who taught you	`cross_agent_reads()`	—	Other agents
See your memory timeline	`timeline()`	—	You (events log)

Next Steps

MCP Setup

Connect every IDE on your machine, and add the memory skill.

Configuration

YAML config, adapters, and environment variables.

Core Concepts

Understand CoW, confidence, and outcome propagation.

Git-like Timeline

How agent memory works like Git.

Python SDK Guide

Full SDK reference with advanced features.

Product

Getting Started

Guides

Self-Hosting

Core Concepts

Pro Features

In your IDE

In your own code

In Your IDE

Check it’s working

Save something

The part that matters: recall somewhere else

Get briefed before it works

Close the loop

In Your Own Code

1. Create Your Brain

2. Form a Memory

3. Keep Things Private

4. Recall Your Memory

5. Read Shared Knowledge

6. Learn from Another Agent

7. See What’s in Your Brain

8. Learn from Experience

9. Know Who You’ve Learned From

10. Watch for Changes

11. Context Manager

12. View Your Timeline

The Mental Model

Next Steps

MCP Setup

Configuration

Core Concepts

Git-like Timeline

Python SDK Guide

In your IDE

In your own code

​How Memory Sharing Works

​In Your IDE

​Check it’s working

​Save something

​The part that matters: recall somewhere else

​Get briefed before it works

​Close the loop

​In Your Own Code

​1. Create Your Brain

​2. Form a Memory

​3. Keep Things Private

​4. Recall Your Memory

​5. Read Shared Knowledge

​6. Learn from Another Agent

​7. See What’s in Your Brain

​8. Learn from Experience

​9. Know Who You’ve Learned From

​10. Watch for Changes

​11. Context Manager

​12. View Your Timeline

​The Mental Model

​Next Steps

MCP Setup

Configuration

Core Concepts

Git-like Timeline

Python SDK Guide

How Memory Sharing Works

In Your IDE

Check it’s working

Save something

The part that matters: recall somewhere else

Get briefed before it works

Close the loop

In Your Own Code

1. Create Your Brain

2. Form a Memory

3. Keep Things Private

4. Recall Your Memory

5. Read Shared Knowledge

6. Learn from Another Agent

7. See What’s in Your Brain

8. Learn from Experience

9. Know Who You’ve Learned From

10. Watch for Changes

11. Context Manager

12. View Your Timeline

The Mental Model

Next Steps