Runtime Substrate for Multi-Agent Fleets.
Replayable federated context for multi-agent runtime, managing what each agent in the fleet sees, believes, and remembers — with complete provenance.
curl -fsSL https://ezra128.vercel.app/install.sh | bash Three steps.
Running in minutes.
Six things one
platform handles.
Most tools solve federation or memory — for a single agent. Ezra does both, for any number of agents, as one runtime.
Pushdown Data Access
Connect to MongoDB, Snowflake, BigQuery, REST. The database does the math — the model gets typed summaries with provenance, never raw dumps.
Three-Tier Recall
Hot, warm, cold. Automatic eviction, compaction, and salience-ranked hydration. Each agent gets the most relevant slice of what the fleet has ever known.
Four-Strategy Reconciliation
When agents disagree, four strategies resolve it before the model sees it: last-write, highest-trust, manual escalation, or your own custom resolver.
Branching Replay
Reconstruct what any agent knew at any prior moment. Mutate state. Run forward. Diff against reality. The compliance and counterfactual artifact.
Per-Agent Scopes
Every agent sees only what its permission scope allows. Enforced at the platform layer on every memory query and data fetch — not in the prompt.
Flat Latency at N
Adding agents doesn't slow per-agent decisions. O(1) hot tier, scope-filtered shared tiers, independent mesh fetches. Constant latency, linear throughput.
The 8-step router.
Per agent. <40ms.
Every agent call runs through eight steps in the same order. Each agent gets its own pipeline instance. The output of every step is observable, replayable, and pinned to the belief store.
A fleet that spawns
and shares.
One session graph binds N agents — spawned and terminated as the operation needs. Each has its own scoped view, but they share one belief store and one tiered memory.
Hot, warm,
and cold.
Memory is not flat. The runtime evicts, compacts, and hydrates across three tiers — so each agent always sees the most relevant slice, filtered by its permission scope.
Five things no other
platform ships.
Persistent memory is table-stakes. The wedge is what sits one layer above it: provenance, audit, per-agent replay, time-travel, and cross-agent reconciliation.
Pushdown execution
The database does the math. Typed queries to MongoDB, Snowflake, BigQuery — the model never touches raw rows.Versioned belief audit
Every commitment any agent made, every fact it relied on, attributed by agent_id. Queryable and exportable at any timestamp.Branching replay
Reconstruct any agent's view. Mutate state. Run forward with a new model or policy. Diff branches. The compliance and eval surface.Time-travel federated query
Run any query as of any prior timestamp. Source-native where it exists. Best-effort with explicit provenance where it does not.Cross-agent reconciliation
When agents commit conflicting beliefs, four strategies resolve it: last-write, highest-trust, manual escalation, or a custom application-defined resolver.Three ways in.
Pick one.
Ezra is framework-agnostic. ADK is the primary path. The Python SDK covers LangGraph and LangChain. REST covers everything else.
Direct Python integration for agents built with Google ADK. No MCP indirection. Best for production fleets on Google Cloud.
Six methods for LangGraph, LangChain, or any custom framework. Adopt belief audit alone, or memory, or replay.
Thirteen endpoints. Bearer or OIDC auth. Use from any language or external system.
Four rooms it
belongs in.
Wins back weeks of glue code per agent. Federation, memory, and belief tracking for the entire fleet.
Per-agent permission scopes enforced on every query and fetch. The security chokepoint for the fleet.
The belief history is the SOC2, GDPR, and financial-audit artifact. Branching replay is the root-cause tool.
Performance stays flat as the fleet scales. Constant per-agent latency, linear total throughput. Provable.
Ezra is the
multi-agent platform
for enterprises.