Agents that learnfrom production.

Two SRE agents resolve a production incident by sharing memory through AMFS. Every memory call below is a real request to the SenseLab cloud.

Six AMFS operations for the full path, three if you reject. Against the live SenseLab cloud.

Discover, handoff, learn.

Three calls carry the whole demo. Storing the memory is the easy half. The loop is what makes a fleet get better at its job.

Discover

The Investigator never starts from zero

Its first move is to ask the fleet what it already knows about this service. The ranking happens server side: embeddings blended with recency and confidence, then a reranker. On the incident above it surfaces a pattern written by a release agent and a past incident an on-call agent lived through, neither of which the Investigator has ever seen.

// lib/amfs.ts
await fetch(AMFS_HTTP_URL + "/api/v1/retrieve", {
  method: "POST",
  headers: { "X-AMFS-API-Key": key },
  body: JSON.stringify({
    query,                                   // written by the agent, not by us
    entity_path: "sre-fleet/checkout-service",
    limit: 3,
    include_artifacts: false,
  }),
});

Handoff

The diagnosis travels through memory, not through a prompt

The Investigator writes what it found, versioned and attributed. The Mitigator, a separate agent with its own identity and its own tools, reads it back through the cross-agent endpoint. The server records that one agent read another's memory, so the handoff is auditable after the fact.

// the Investigator writes
POST /api/v1/entries
{ entity_path: "demo-runs/<runId>", key: "checkout-diagnosis",
  value: diagnosis, confidence, agent_id: "investigator-agent" }

// the Mitigator reads, across identities
GET /api/v1/agents/mitigator-agent/read-from/investigator-agent
      /demo-runs/<runId>/checkout-diagnosis

Learn

The outcome is only written once a human has validated it

The model proposes the rollback; a list of protected tools in the code freezes it before anything reaches production. Approve, and the Mitigator commits the outcome, which AMFS back-propagates onto the exact memories that produced the diagnosis. Reject, and nothing is committed: an action that never ran proves nothing.

// app/api/run/route.ts
if (PROTECTED_TOOLS.has(call.name)) {
  emit({ type: "hold", action: { tool: call.name, input: call.input } });
  break;                          // nothing runs until a human decides
}

// app/api/decide/route.ts, once approved
POST /api/v1/outcomes
{ outcome_ref, outcome_type,      // both chosen by the agent
  causal_entry_keys: ["sre-fleet/checkout-service/<key>"],
  agent_id: "mitigator-agent" }

One observation from building this. On this account a success outcome moved the entry's confidence down rather than up, while the outcome counter and the version moved as documented. The page shows the numbers the API returned, and the note is on the card. Worth ten minutes of your time if nobody has flagged it yet.