Created on 2025-08-28 17:32
Published on ---
I’ve spent most of my career on transformation—strategy, operating models, change management and integrated programs. I’m also a computer scientist. The more I work with agentic AI, the more obvious the intersection becomes: an operating model is a machine‑readable spec for how a company should work. If we express that spec cleanly, agents can build from it, run against it, and improve it continuously.
TL;DR
Treat your operating model as code. Compile it into a graph of agents that plan, act, and coordinate with guardrails. Start with a Super‑Agent (the “Chief Orchestrator”) that reads the model, provisions specialist agents, routes work, and enforces policy. Instrument everything so you can learn with reflection and reinforcement learning using verifiable rewards tied to process and outcomes. This turns the operating model from a slide deck into a living operating system.
1) From blueprint to executable spec
Most leaders agree: strategy doesn’t deliver itself—the operating model is the bridge to execution. In management language, it’s how roles, processes, governance, tech, and data combine to deliver outcomes. In engineering language, it’s a spec we can compile. Recent guidance from major firms frames operating models exactly this way: explicit choices about structure, governance, processes, talent, and technology that translate strategy into results.
Key shift: write the operating model in a formal schema (think: capabilities, value streams, processes, RACI, SLAs, policies, data contracts, controls). That schema becomes the single source of truth for agents to read, reason over, and act on.
2) What “agentic” really means in a company
Agentic systems don’t just answer questions; they plan, call tools, take actions, coordinate with other agents and humans, and verify results. Frameworks like AutoGen and LangGraph already provide patterns for multi‑agent orchestration, tool use, long‑running state, and supervision. Use them to express your firm as workflows + policies + tools + data contracts—not as a pile of dashboards.
Agent roles you’ll reuse again and again:
Planner: decomposes goals into steps with dependencies and deadlines.
Executor: calls systems (APIs, RPA, scripts), writes records, files tickets.
Reviewer: checks outputs against policy, SLAs, and controls.
Liaison: handles human‑in‑the‑loop cases and escalations.
Observer: logs traces and metrics to the evaluation store.
Lilian Weng’s canonical overview is a good mental model: planning, memory, tool use, and feedback loops are first‑class components—not afterthoughts.
3) The Super‑Agent pattern (your “Chief Orchestrator”)
Think of a top‑level agent that reads the operating‑model spec, compiles it into an agent graph, provisions the right specialists, and enforces policy:
Inputs
Operating‑model schema (capabilities, processes, RACI, policies, KPIs, risk controls)
System catalog (APIs, tools, permissions)
Data products & contracts
Guardrails (allow/deny lists, rate limits, segregation of duties)
Behaviors
Generate the agent graph (who does what, with which tools, under which controls).
Provision skills (deploy skill packs per process/capability; bind tools).
Route work (queueing, priority, load).
Enforce policy as code at decision points (see below).
Evaluate & adapt (close the loop with reflection + RL).
Outputs
Completed tasks w/ audit trails
Policy and conformance logs
Metrics for reward signals
Why this matters: you don’t need a brittle, monolithic “AI COO.” You need a compiler + scheduler that makes your operating model executable and evolvable. Tools like AutoGen and LangGraph show how to orchestrate and supervise multi‑agent systems today.
\---
4) Policies and controls: encode them, don’t slide‑deck them
Compliance, approvals, SoD, rate limits, PII handling—these must be executable. Use policy‑as‑code (e.g., Open Policy Agent/Rego) so agents can query “may I do X on Y given Z context?” at runtime. OPA is widely used for unified, low‑latency policy enforcement across stacks; it’s a proven pattern to lift into agentic work.
\---
5) Make the company observable: DTO + process mining
A Digital Twin of the Organization (DTO)—a dynamic model tied to operational data—gives agents a live map: who’s doing what, where bottlenecks are, and the state of key flows. Combine DTO with process mining to discover actual flows from event logs and check conformance to your model. You get verifiable traces that support learning, audits, and root‑cause analysis.
\---
6) Learning loops: reflection + RL with verifiable rewards
This is where it gets powerful—and safe.
Reflection: Agents critique their own trajectories and update their next attempt using verbal feedback (e.g., Reflexion) or structured checklists. This improves decisions without retraining weights.
Process supervision: Don’t just reward the final outcome; reward each correct step. OpenAI and DeepMind show process‑based feedback can reduce reasoning errors and produce more reliable chains of action.
AI‑assisted evaluation (RLAIF / LLM‑as‑Judge): Where expert human labels are scarce, use vetted models to supply scalable preference or rubric scores—with safeguards and spot‑checks.
Verifiable rewards: Tie rewards to tamper‑evident signals:
Process rewards from signed event logs (e.g., “all required fields populated,” “policy check passed”).
Outcome rewards from systems of record (e.g., paid invoice, first‑contact resolution).
Quality rewards from human or AI judges with sampling and adversarial tests.
Design this carefully to avoid specification gaming/reward tampering—measure the real thing, not just the easy proxy—and keep humans in the loop for sensitive actions. Recent work shows why this matters.
\---
7) What this looks like in practice (a 90‑day build)
Weeks 1–2 — Model it
Express one end‑to‑end workflow in your schema (e.g., customer issue to fully resolved case).
Map tools/APIs and write the policies (OPA) the flow requires.
Weeks 3–6 — Make it executable
Instantiate the Super‑Agent and 3–5 specialists (Planner, Executor, Reviewer, Liaison).
Wire to systems via APIs; stand up the evaluation store and event logging.
Run in a sandbox with reflection and process‑based checks.
Weeks 7–10 — Operate with guardrails
Move to a limited production cohort with human‑in‑the‑loop at defined checkpoints.
Track % straight‑through, time to resolution, defect rate, escalation rate, policy violations.
Weeks 11–13 — Learn and scale
Convert your metrics into verifiable rewards; run safe RL to improve routing/steps.
Package the working pattern as a reusable skill‑pack + tests; roll to the next workflow.
\---
8) Where to start (and what to avoid)
Start here: pick a high‑volume process with clear rules and measurable outcomes (support resolution, claims adjudication, collections, onboarding). Make policy and data contracts explicit. Keep the first graph small, but fully end‑to‑end.
Avoid:
“Co‑pilot theatre” (assistants with no authority to act).
Opaque scoring (no auditable link from reward → action).
Fragmented identity/permissions (agents need first‑class IDs).
One‑off bespoke agents (template everything you can repeat).
\---
9) What changes when you do this
The operating model stops being a PowerPoint and becomes a runtime.
New capabilities deploy as policy + skill‑pack + test suite, not multi‑month programs.
Risk and compliance become real‑time, not after‑the‑fact.
Improvement is continuous: you measure, reflect, and learn directly from execution traces.
This isn’t wishful thinking; the building blocks exist: multi‑agent orchestration, policy‑as‑code, DTO/process mining, and process‑based evaluation are mature enough to start now.
\---
A question to close
If your operating model is the spec, what’s the first workflow you’d be confident compiling into agents next quarter—and what reward signals would prove it’s truly better?
\---
Further reading (selected)
Operating models: McKinsey—A new operating model for a new world (2025); Bain—Design principles for a robust operating model.
Agentic AI: Lilian Weng—LLM‑Powered Autonomous Agents; Microsoft AutoGen; LangGraph multi‑agent workflows.
Policy‑as‑code: Open Policy Agent—docs & CNCF overview.
DTO & process mining: Gartner—Digital Twin of an Organization (category overview); van der Aalst—Process Mining.
Reflection & process supervision: Reflexion (Shinn et al., 2023); OpenAI—Improving mathematical reasoning with process supervision; DeepMind—process vs outcome feedback.
RLAIF / LLM‑as‑Judge: RLAIF (Lee et al., ICLR 2024); Survey on LLM‑as‑a‑Judge (2024).
Reward tampering/spec gaming: DeepMind—Specification gaming; Anthropic—Reward tampering study.