MCX://CONTENT-ADDRESSED-CONTEXT-RUNTIME
// CONTENT-ADDRESSED CONTEXT RUNTIME
Every agent handoff is unserialized state moving between processes that do not trust each other. MCX gives each exchange a content address, an append-only history, and a permission envelope — so context moves between agents the way commits move between branches.
$ npm install @mcxai/sdk # zero peer deps
import { mcx } from "@mcxai/sdk";
const ctx = await mcx.context.create({
data: researchResult,
sources: sources,
acl: teamReadWrite,
});
// → hashed · versioned · permissioned
await mcx.context.get("ctx_82931");RESPONSE · 201 CREATED · 4MS
{
"id": "ctx_82931",
"hash": "sha256:9f2e…c41d",
"version": 1,
"acl": "team-rw",
"log": "append-only"
}BYTES → HASH → LEDGER
WRITES APPEND. NEVER OVERWRITE.
SHA-256 ADDRESSED
Every context object is content-addressed on write
APPEND-ONLY LOGS
Versions are immutable. Nothing silently mutates.
P99 READS < 10MS
Pinned point-in-time reads served from replicas
4-LINE SURFACE
Median integration: create, get, diff — done
Agent A burns ten minutes and forty tool calls producing fifty facts, twenty sources and three decisions. Then you JSON.stringify() it into Agent B's prompt and hope. No schema. No lineage. No rollback. At four agents this is friction. At forty it is an outage.
↓
RESEARCH AGENT
Finds information. Collects sources.
↓
ANALYSIS AGENT
Extracts facts, patterns, structure.
↓
DECISION AGENT
Concludes under constraints.
↓
WRITING AGENT
Produces the final artifact.
↓
THE BACKLOG NOBODY WROTE DOWN
Every serious team rebuilds this substrate in private. Badly, and twice. The second version is always worse than the first, because now it has customers.
MCX is that substrate, extracted once and run properly.
Prompts die at the boundary of a single call. Contexts persist. The request, the research, the fifty facts, the twenty sources, every decision with its rationale, every tool result typed on ingest — registered once as one durable object.
Any agent anywhere in the pipeline resolves ctx_82931 to the same bytes, the same lineage, the same rights. Not a copy. Not whatever the previous stage remembered. The object.
REGISTER
mcx.context.create()
returns id + hash
RESOLVE
mcx.context.get(id)
pinned or HEAD
TYPESCRIPT + PYTHON. TYPED RESPONSES. NO ORCHESTRATOR LOCK-IN — BRING LANGGRAPH, CREWAI, OR BASH SCRIPTS.
WRITE ONCE, ADDRESS FOREVER
const ctx = await
mcx.context.create({
data: result,
sources: srcs,
acl: teamRw,
});
// hashed, versioned,
// ledger opened atomically
→ ctx_82931RESOLVE ANYWHERE IN THE DAG
const shared = await
mcx.context.get(
"ctx_82931",
{ version: 2 }
);
// pin v2 for reproducibility,
// omit for HEAD. same bytes,
// every resolve. guaranteed.STRUCTURAL DELTA, NOT STRING DELTA
await mcx.context.diff(
"ctx_82931",
1, 3
);
// which actor introduced
// which field, at which
// timestamp. exact.✓ Model agnostic — GPT, Claude, Gemini, Llama, yours
✓ Works under LangGraph, CrewAI, custom loops
✓ Self-hostable registry, edge-readable cache
When the final answer is wrong, you do not want logs. You want a range. Diff v1..v3, see which actor introduced the regression, replay from the parent. Your pipeline becomes as debuggable as a commit graph — because underneath, it is one.
CREATED BY agent/research
+50 facts · +20 sources · +requirements
MUTATED BY agent/analysis
+analysis.md · +confidence scores
MUTATED BY agent/decision
+decision.json · verdict recorded
+ analysis.confidence: 0.94 // n=18 verified
+ decision.verdict: proceed
~ facts.count: 50 → 53
- open_questions[]: drained
LINEAGE TRACE · WHO SAW WHAT, AT WHICH HASH
THE WORKFLOW STOPS BEING A BLACK BOX AND BECOMES SOMETHING YOUR TEAM CAN INSPECT, REPLAY AND TRUST.
You keep your models. You keep your agents. MCX is the layer they exchange state through — and the layer nobody else can move for you.
MCX EXCHANGE
STORE · VERSION · ROUTE · GOVERN · REPLAY
AGENT A
GPT
OpenAI
AGENT B
CLAUDE
Anthropic
AGENT C
GEMINI
AGENT D
LLAMA
Meta
✗ THE WRAPPER TRAP
User
↓
MCX
↓
GPT APIRents relevance from a provider who will absorb the feature in the next release. Thin moat. Zero compounding.
✓ THE PROTOCOL POSITION
MCX
│
┌────────┼────────┐
Agent A Agent B Agent C
GPT Claude GeminiCustomers own the intelligence. We own the state substrate. Every agent added makes the layer more necessary.
CONTEXT DB + SCHEMA + VERSIONING + HANDOFFS + ACL + AUDIT + BISECT + RECOVERY — REPLACED BY ONE DEPENDENCY AND FOUR LINES OF CODE.
Durable typed objects. Schemas enforced at write time, not review time. Blobs are sha-pinned; bytes never lie about their content.
Append-only log per object. Every mutation gets a hash and an actor. Sealed versions cannot be rewritten by anyone, including us.
A consumer ledger per version. Which agent resolved which address, read which bytes, at which timestamp. No silent readers.
ACLs travel inside the object, so permissions survive handoffs. The audit trail is the data structure, not a bolted-on feature.
Replay any historical state. Bisect regressions across agents the way you bisect a commit range — until the bad delta confesses.
Point-in-time reads without freezing writers. Roll any context back to a prior hash in one call and let the pipeline re-converge.
Our highest-value customers already run multi-agent systems where information flows between stages — where debugging, governance and reliability convert directly into money saved or incidents avoided.
THE ALTERNATIVE IS NOT NOTHING. IT IS YOUR OWN HALF-FINISHED VERSION OF THIS, MAINTAINED FOREVER.
INSTEAD OF BUILDING: CONTEXT DATABASE + SCHEMA + VERSIONING + HANDOFF SYSTEM + PERMISSIONS + AUDIT LOGS + PROVENANCE + DEBUGGING — THEY INSTALL THE SDK.
// READY WHEN YOU ARE
Agents do the thinking. MCX remembers, manages and moves the work between them — hashed, versioned, permissioned, replayable.
$ npm install @mcxai/sdk