Build, import, and run enterprise agents in a governed runtime. Operon combines authoring, orchestration, model routing, policy enforcement, and decision traces across supported providers and deployment environments.
Operon connects supported model providers and enterprise systems through its runtime. Actions dispatched through that runtime carry policy checks, identity, decision lineage, and required human approvals. Coverage depends on which execution paths you connect.
Imported agents compile into Operon's governed runtime. Existing executors can use a governance wrapper for configured outbound model calls. In both cases, the connected execution path determines what Operon can enforce.
Discovery alone does not put an agent under policy. Review the model calls, tools, credentials, and routes that must cross an enforcement point, including any paths that remain outside it.
Natural language, visual canvas, Markdown, direct DSL, or one-click import from LangGraph, n8n, CrewAI, AutoGen, Copilot Studio, or custom Python. Every authoring path produces typed, validated artifacts the runtime can execute.
Smart routing across providers, fallback chains, cost guardrails, environment profiles. Scale from a single agent to federated fleets across regions and legal entities, under the same governance.
Actions dispatched through the governed runtime evaluate against OPA/Rego policy before execution. Decisions are recorded in the Evidence Data Trace, and required approvals route to a human with full context.
Four layers (authoring, compilation, runtime, deployment) share one continuous audit trail. The full architectural treatment lives on the CTO page.
A Fleet is a governed team: a Lead orchestrating Workers, watched by a Guard and a Scout. A Hive is the deployment it runs inside. There is no ladder of progressively larger boxes — Fleets federate as equals, under one governance layer, from one agent to ten thousand.
A single governed agent with its own role, policies, and audit trail. Authored, compiled, signed, audited end to end.
A Lead orchestrating Workers, with a Guard that intervenes and a Scout that observes. This is the production unit, and it lives in exactly one Hive.
One dispatch bus and one knowledge graph the agents query for routing rules, platform norms, and accumulated patterns. A Fleet has a Hive; a Hive is not a bag of Fleets.
Mission, Architecture, Execution, Observation, Intervention, Synthesis, Retrospective. Seven phases, each owned by a named role rather than left to emerge.
Fleets federate into composite fleets under a union agreement. An Agent Mesh is a transient group of peers coordinating during execution, led by a Lead or Guard.
More intelligence. More agents. One governance layer.
LangGraph, n8n, CrewAI, AutoGen, Copilot Studio, custom Python: every existing graph compiles into the same governed intermediate representation. Your prior work isn't replaced; it's adopted.
Every import is a stranger's code entering your environment, and Operon treats it that way. The graph is analysed statically before anything runs. The archive is validated before it is unpacked. Code nodes are scanned against a blocked-pattern list covering network access, filesystem and process access, and dynamic evaluation — eval, new Function, child_process, subprocess, __import__ — and every match carries a severity rather than a bare flag, so a hardcoded os.environ read and an outbound socket don't land in the same bucket.
Hardcoded credentials are found and named: bearer tokens, AWS access keys, GitHub and Slack tokens, private key blocks. Tool names are checked against reserved namespaces, so an imported agent cannot shadow a platform capability by claiming its name. Every discovered tool is then evaluated against your own OPA policy, and the gate passes only when there are zero blocking violations. Where the incoming execution context leaves something unspecified, restrictive defaults apply — the safe answer is the default answer.
What does need to execute, executes inside a pooled, lifecycle-managed container with a hook at the Python import boundary. And the scrutiny doesn't stop once the agent is through the gate: imported agents are given a behavioural baseline, and deviations from it surface afterward, which is when the interesting failures actually happen.
Analysed statically. Never executed to find out what it does.
Archive validated before unpacking. Secrets found and named.
Your OPA policy decides. Zero blocking violations, or no import.
Baselined after admission, so drift is visible later.
Three doors in, and only one of them expects you to write code. Describe what you want in a sentence, write it as reviewable Markdown, or draw it on the canvas. All three compile to the same typed artifacts and land under the same policy, so the authoring surface is a preference rather than a permission level.
Natural-language authoring. Operon generates the agent definition, the workflow graph, and the policy bindings. Output is editable in the canvas, the Markdown spec, or the DSL, your call.
Graph-based composition for workflow logic, fleet membership, and policy gates. Live validation against the type system. Every edit is a deterministic compile.
Skills are checked-in Markdown. Versioned, reviewable, signable. SKILL.md is the unit of agent capability: discoverable, composable, and portable across every agent in the estate.
Forms Builder and Site Builder generate human-facing interfaces (intake, review, approval, dashboards) that share the same policy layer as the agents behind them. One operating model, end to end.
Request access. We'll match you to the right edition and the right next conversation.
Tell us your organization and the AI platforms you already run, and we'll match you to the right edition. We reply within one business day.