§ 03 / Prologue
The hard part isn't the model.
It's the layer between the calls: when one agent hands off to another, what happens
when a human steps in, what state survives a restart, how the run replays for an auditor.
Software used to be deterministic — every output traced back to a rule a human wrote.
The applications worth building now make decisions during the run, and that layer is
where intelligence enters them. It's also where state, durability, and observability
have to be rebuilt to support it.
Every platform reinvents that layer with its own conventions — LangGraph, Temporal,
Step Functions, vendor agent frameworks, in-house runtimes — and the implementations
aren't wire-compatible. Code written against one host doesn't move to another. The
debugger you wrote for your runtime can't read someone else's. Customers who pick
a platform inherit its lifecycle, whether they want to or not.
OpenWOP is the wire contract this layer has been missing. It's a protocol, not a
runtime or a framework, that defines how clients and hosts start, stream, interrupt,
resume, replay, validate, and observe durable multi-agent workflows. The layer where
your software thinks becomes portable: something you can move between hosts, inspect
across versions, or replace when the runtime stops serving you.
It's also the layer where agents fail in production. An agent is a loop — reason,
call a tool, observe, repeat — and the failure modes everyone hits are properties of
that loop, not the model inside it: small per-step error rates compound across steps,
every lap costs tokens, an open-ended loop may never decide it's done, and a model
that can call a tool can be tricked into calling the wrong one. A better model doesn't
fix any of those. Bounding the loop does. Because OpenWOP owns the run, the controls
that fence a production agent live in the protocol: a cap on loop iterations and
wall-clock time, a budget that reserves and exhausts spend with breach events, an
approval interrupt that suspends before an irreversible action and resumes
deterministically, and a trust boundary that marks tool and retrieval output untrusted
so poisoned input can't advance an approval gate. The protocol doesn't make the model
smarter — it makes the loop observable, bounded, and fail-closed.
See how the three layers compare →
OpenWOP is the common language for the layer where your software thinks.
