Python SDK

Operator Architecture

Multi-agent orchestration. OA owns the state and architecture. You own the runtime.

User, coordinator, juniors

You talk to a coordinator. The coordinator commissions sub-agents through the state machine, stages their results, then accepts into the core thread and reports back. OA owns state, context, and that contract. The host owns models, keys, tools, MCP, and the filesystem.

You

objective

Coordinator

sm.run · core thread

StateMachine

OA owns state · context · sub-agents

commissionstageacceptinstruct

researcher

read-only exploration

coder

implement the change

reviewer

check the work

user

You send an objective to the coordinator. OA appends it to the coordinator thread.

Why it exists

Most agent frameworks own your loop, your messages, and your vendor. Operator Architecture is flexible and manages the state, sub-agent contracts, and coherence for reliable, production use cases.

You own runners

Models, API keys, tools, MCP, filesystem stay in the host. OA never imports your loop.

OA owns the machine

StateMachine, Coordinator, AgentSpec. Stdlib only. No process-global singleton — you hold the instance.

Any AgentRunner

Relay, LangChain, OpenAI Agents, HTTP, or a plain async function. Adapters live in your host.

# pip install operator-architecture
from operator_architecture import (
    StateMachine, Coordinator, AgentSpec, callable_agent,
)

researcher = AgentSpec(name="researcher", runner=callable_agent(research))
coder = AgentSpec(name="coder", runner=callable_agent(code))
reviewer = AgentSpec(name="reviewer", runner=callable_agent(review))

sm = StateMachine(
    coordinator=Coordinator(skill="You operate the state machine…"),
    agents=[researcher, coder, reviewer],
)

staged = await sm.commission("researcher", "Find all uses of vLLM")
accepted = sm.accept("researcher", 1)

Early SDK. The orchestration contract is the stable idea. Full README on PyPI.