Why ECP
Reasoning is the most powerful thing an AI system does, and the most expensive. Every reasoned step costs latency and tokens, and returns a slightly different answer each time. Some tasks are worth that cost. Most, once you have worked them out, are not. ECP (Execution Control Protocol) is built on a simple belief: reason once, run many times, iterate fast. Once you have reasoned about how a task should be done, you can capture that approach and run it deterministically — without paying to re-derive it on every run.Reason once, run many times
People already work this way. You reason hard about how to drive a car exactly once. After that you drive without re-deriving it, and your deliberate attention is free for the road’s genuine novelty. Deliberate thought becomes practiced execution. Agents should work the same way. The reasoning that designs an approach is valuable. Repeating that reasoning on every run — for steps whose answer no longer changes — is waste, and it reintroduces non-determinism exactly where you do not want it. ECP is the layer where a reasoned approach becomes a captured, executable workflow.Two kinds of reasoning
ECP separates when you reason from when you run.
Author-time reasoning does the design work up front. Runtime reasoning is reserved for the steps that actually need a model in the loop. Everything else runs deterministically.
The determinism spectrum
Steps are not all-or-nothing. ECP lets you place each one deliberately on a spectrum:
The default in most agent stacks is to reason everywhere. ECP makes the other end of the spectrum a first-class choice, so you spend reasoning where it earns its cost and lean on determinism where it does not.
Iterate fast
A captured workflow is an artifact, not an ephemeral chain of thought — so changing it is cheap and surgical. You adjust a step, patch a manifest, or re-encode between Fluent, JSON, and TOON, then re-run against the same governed environment. You refine the approach without re-reasoning it from scratch.What this fixes
Capturing execution this way addresses what tends to break as agents move from prototype to production:- Tool permissions become explicit instead of implicit
- Actions are auditable, because the workflow is the record
- Context and mounts stay consistent across runs
- Execution environments are reproducible
- Governance is part of the environment, not bolted on afterward
What ECP gives you
- Workflows — versioned, portable graphs (Fluent/TS or JSON)
- Environments — runtime + extensions + policies that bind a host
- Deterministic ops — validate, describe, search, encode, decode, patch, run
- Hosts — Node CLI, browser runtime, MCP adapter
- Composability — same operational APIs after
env.init(), regardless of host