Built for agents that run longer than a session.

A refactor spans days. The agent loses repo state between sessions, re-reads files it already understands, and re-litigates decisions the team made on Tuesday — 'which ORM are we standardizing on?' gets answered fresh every morning.

Events capture every action and decision as they happen; typed facts hold the standing decisions with supersession ('use the new ORM' replaces the old thread, with lineage); checkpoints snapshot the refactor's live state — files touched, open threads, failing tests — so a restarted session resumes instead of rediscovering.

The agent stops re-deriving settled decisions. Interruptions — deploys, context resets, a human stepping in overnight — become resume points, not restarts. Reviewers can ask which decision the agent acted on and get a trace, not a shrug.

A long investigation accumulates findings, sources, and contradictions across hours. Rolling summaries keep the conclusions and drop the dead ends — so the agent re-explores them, and can't distinguish 'we ruled this out' from 'we never checked.'

The append-only ledger preserves every dead end with its evidence; derived facts carry provenance back to sources; contradiction detection surfaces conflicting findings explicitly instead of letting one silently win; planned retrieval re-queries bridge entities when a question needs two hops.

Findings compound instead of resetting. Contradictions become objects to resolve — visible in the trace — rather than coin flips inside a summary. The final report can cite what was ruled out and why.

Approvals and hand-offs stretch across days and people. State lives in tickets, chat threads, and inboxes; an interrupted workflow restarts at the last step someone remembers, and nobody can reconstruct who approved what.

Task-scoped state checkpoints the workflow at every step; the audit log and append-only events give a reconstructable record of what happened; org-scoped isolation keeps each customer's workflow sealed; born-pending governance means a learned shortcut ('skip legal for small deals') can't take effect unreviewed.

Workflows survive hand-offs and weekends. 'Why did it do that?' has an auditable answer — the property compliance and ops review actually gate on.

Thousands of customers, each with history. A memory layer that leaks one customer's context into another's answer is a breach, not a bug — and a stale fact ('their plan was upgraded') quoted to the wrong person is a trust-destroyer.

Workspace isolation is structural — every read is scoped at the query layer, and a zero-tolerance gate re-verifies on every release that one user's memory cannot surface for another. Facts supersede with lineage, so plan changes resolve to the current truth. Erasure requests are first-class: a scoped delete with a full audit trail.

Per-customer memory becomes safe to use at all: isolation is enforced, not promised; stale answers leave a visible trail; deletion is an operation, not a project.

Work passes between specialized agents — planner to researcher to writer — and every hand-off loses context. Each agent rediscovers what the last one knew, or drifts from it, and duplicated work is indistinguishable from progress.

A shared, scoped memory layer sits under all of them: one agent's checkpoints and facts are the next agent's starting state; typed memory separates 'what we decided' from 'what we tried'; retrieval traces show exactly what each agent knew when it acted.

Hand-offs transfer state, not vibes. The orchestrator can see what each agent actually used — and two agents never silently act on different versions of the truth.