Git-like Timeline

SenseLab models everything an agent learns as a Git repository. Each write, outcome, cross-agent read, and compiled brief is recorded as an event on the agent’s timeline — like commits in Git. This is what lets the loop change shared knowledge safely. A fix to what agents know can be made on a branch, replayed against the failures that prompted it, reviewed as a diff, merged when it holds up, and rolled back if it regresses — the same discipline you apply to code, applied to learning. For the dashboard side of all of this, see Learning as Git.

The Mental Model

When an agent is created in SenseLab, it implicitly gets a repository with a main branch. Every operation the agent performs is logged as an event on that branch:

Events on an agent's main branch: branch created, write, cross_agent_read, brief_compiled, outcome — each with the fields it records

Event Types

Every operation produces a typed event on the agent’s timeline:

Event Type	Description	Triggered By
`write`	Memory entry created or updated	`mem.write()`
`read`	An entry was read	`mem.read()`
`outcome`	Outcome committed, confidence back-propagated	`mem.commit_outcome()`
`cross_agent_read`	Another agent read this agent’s shared memory	`mem.read()` / `mem.read_from()`
`brief_compiled`	Brain brief / digest compiled by the Cortex	Cortex worker
`webhook`	External context ingested via webhook	Webhook endpoint
`snapshot_taken` / `snapshot_recovered`	Memory snapshot created or restored	Snapshot tooling
`consolidation_proposed` / `consolidation_approved` / `consolidation_rejected` / `consolidation_auto_merged`	Memory consolidation activity	Consolidation
`branch_created`	New branch created from this agent’s memory	Pro: `create_branch()`
`branch_merged`	Branch merged back into main	Pro: `merge_branch()`
`branch_closed`	Branch closed without merging	Pro: `close_branch()`
`access_granted`	Branch access granted to a user/team/API key	Pro: `grant_branch_access()`
`access_revoked`	Branch access revoked	Pro: `revoke_branch_access()`
`tag_created`	Snapshot tag created on a branch	Pro: `create_tag()`
`rollback`	Memory rolled back to a point in time	Pro: `rollback()`
`cherry_pick`	Entries cherry-picked from a branch to main	Pro: `cherry_pick()`
`fork`	Agent memory forked to a new agent	Pro: `fork()`

Querying the Timeline

Python SDK

from amfs import AgentMemory

mem = AgentMemory(agent_id="deploy-agent", adapter=adapter)

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

HTTP API

curl "https://amfs-login.sense-lab.ai/api/v1/agents/deploy-agent/timeline?limit=50" \
  -H "X-AMFS-API-Key: <your-api-key>"

Response:

{
  "agentId": "deploy-agent",
  "events": [
    {
      "event_type": "write",
      "branch": "main",
      "summary": "Wrote checkout-service/retry-pattern v2",
      "details": {
        "entity_path": "checkout-service",
        "key": "retry-pattern",
        "version": 2,
        "confidence": 0.85
      },
      "created_at": "2026-04-03T14:30:00Z"
    }
  ],
  "count": 1
}

MCP

amfs_timeline(agent_id="deploy-agent", limit=50)

Branches (Pro)

On Pro, Teams and Enterprise you can create branches from an agent’s main timeline — just like Git branches. SenseLab uses them itself: every fix the repair loop proposes is drafted on its own branch and only merged into main when it ships. Branches let you:

Experiment safely — write to a branch without affecting main memory
Share selectively — grant read or read/write access to specific users, teams, or API keys
Review changes — see the diff between a branch and main before merging
Merge or discard — bring branch changes into main, or close the branch

Creating a Branch

from amfs_branching.sdk import extend_with_branching

mem = AgentMemory(agent_id="deploy-agent", adapter=adapter)
extend_with_branching(mem)

mem.create_branch("experiment/retry-v3", description="Testing aggressive retry")

Writing to a Branch

All read/write operations accept a branch parameter:

mem.write(
    "checkout-service",
    "retry-pattern",
    {"max_retries": 5, "backoff": "linear"},
    confidence=0.7,
    branch="experiment/retry-v3",
)

Or via the HTTP API:

curl -X POST https://amfs-login.sense-lab.ai/api/v1/entries \
  -H "Content-Type: application/json" \
  -H "X-AMFS-API-Key: <your-api-key>" \
  -d '{
    "entity_path": "checkout-service",
    "key": "retry-pattern",
    "value": {"max_retries": 5, "backoff": "linear"},
    "confidence": 0.7,
    "branch": "experiment/retry-v3"
  }'

Reading from a Branch

curl "https://amfs-login.sense-lab.ai/api/v1/entries/checkout-service/retry-pattern?branch=experiment/retry-v3" \
  -H "X-AMFS-API-Key: <your-api-key>"

Access Control

Branch access is enforced at the API level. When a request targets a non-main branch, the caller’s API key is checked against the branch access grants:

mem.grant_branch_access(
    "experiment/retry-v3",
    grantee_type="api_key",
    grantee_id="amfs_sk_agent_b_key",
    permission="read_write",
)

Permission	Can Read	Can Write
`read`	Yes	No
`read_write`	Yes	Yes

Requests without access receive a 403 Forbidden response.

Viewing the Diff

diffs = mem.diff_branch("experiment/retry-v3")
for d in diffs:
    print(f"{d.diff_type}: {d.entity_path}/{d.key}")

Merging

from amfs_core.models import MergeStrategy

result = mem.merge_branch("experiment/retry-v3", strategy=MergeStrategy.FAST_FORWARD)
print(f"Merged {result.merged_entries} entries")

Pull Requests

For team workflows, create a PR for review before merging:

pr = mem.create_pull_request(
    "Aggressive retry strategy",
    source_branch="experiment/retry-v3",
    description="Testing 5x retries with linear backoff",
)

mem.review_pull_request(pr.id, "approved", comment="Looks good")
mem.merge_pull_request(pr.id)

Tags and Rollback (Pro)

Rollback

Restore memory to a previous state:

mem.rollback(tag_name="v1.0-stable")

Or roll back to a specific timestamp:

from datetime import datetime, timezone

mem.rollback(timestamp=datetime(2026, 4, 1, tzinfo=timezone.utc))

Fork (Pro)

Clone an agent’s entire memory into a new agent:

count = mem.fork("deploy-agent-v2")
print(f"Forked {count} entries to deploy-agent-v2")

Architecture

An agent repository: a main timeline of events with an experiment/retry-v3 branch forking from one of them

The timeline records everything on main from your first write, with nothing to turn on. Branching, merging, tags, rollback, cherry-pick, fork, and branch access control are available on Pro, Teams and Enterprise — see Learning Branching for the model and Learning as Git for the dashboard.

Product

Getting Started

Guides

Self-Hosting

Core Concepts

Pro Features

Git-like Timeline

The Mental Model

Event Types

Querying the Timeline

Python SDK

HTTP API

MCP

Branches (Pro)

Creating a Branch

Writing to a Branch

Reading from a Branch

Access Control

Viewing the Diff

Merging

Pull Requests

Tags and Rollback (Pro)

Tags

Rollback

Fork (Pro)

Architecture

​The Mental Model

​Event Types

​Querying the Timeline

​Python SDK

​HTTP API

​MCP

​Branches (Pro)

​Creating a Branch

​Writing to a Branch

​Reading from a Branch

​Access Control

​Viewing the Diff

​Merging

​Pull Requests

​Tags and Rollback (Pro)

​Tags

​Rollback

​Fork (Pro)

​Architecture

The Mental Model

Event Types

Querying the Timeline

Python SDK

HTTP API

MCP

Branches (Pro)

Creating a Branch

Writing to a Branch

Reading from a Branch

Access Control

Viewing the Diff

Merging

Pull Requests

Tags and Rollback (Pro)

Tags

Rollback

Fork (Pro)

Architecture