Most writing about agents stops at capability: what the models can do, which tools they can call, and how many tasks can run in parallel.
That is not enough. Once a team is actually using agents every day, the harder question becomes operational:
How do you run a system of agents so that it stays aligned, legible, and governable under load?
This piece is a practical operating model for that question.
Alignment velocity is the real bottleneck
The bottleneck in agentic work is not the agents themselves. It is the speed at which a human operator can keep intent aligned with a workforce that produces more than any one person can fully inspect.
That is what I mean by alignment velocity.
Scaling output without scaling headcount only works while alignment holds. Raw agent count is not the competitive variable. Alignment velocity is.
The layered runtime
flowchart TD
A["Supervision\nframe + system improvement"] --> B["Strategic orchestration\nrouting + prioritization + gating"]
B --> C["Tactical workers\nexecution + research + synthesis + QA"]The runtime has three levels:
Tactical -> Strategic -> Supervision
- Tactical workers do framed research, synthesis, evaluation, communication, and execution work.
- Strategic orchestration coordinates, gates, and dispatches in a shared coordination space.
- Supervision improves the system itself and holds the framing logic.
The human operator should live closest to the supervision layer, not sink into the mechanics of every task.
One structure, two axes
The interesting part is that the same structure does double duty.
Vertically, it is an organizational hierarchy for alignment: supervision aligns strategic orchestration, which aligns tactical execution.
Horizontally, it can also be read as a reasoning frame: long-term prior, medium-term cycle, and short-term events. In other words, the same top layer that aligns action also holds the durable frame that conditions reasoning.
That is why the top layer matters so much. It is the slowest-moving layer, the broadest framing layer, and the part of the system that is most expensive to get wrong.
Two concerns at the top
The top of the system actually holds two distinct concerns:
- The frame: the durable prior, the standing thesis, what the work is anchored to.
- The meta-process: the supervisory loop that asks whether the system is getting better at producing.
They share the same abstract shape, but they are not the same thing and should not be merged into a single context blob.
Framing downward, evidence upward
The system has to work in two directions.
flowchart LR
F["Frame / prior"] --> W["Work execution"]
W --> E["Evidence + anomalies"]
E --> R["Revision decision"]
R --> FDownward, the frame conditions the work and aligns the workforce.
Upward, evidence and anomalies must be able to update the frame. Tactical workers surface outliers. The strategic layer notices patterns and drift. The operator decides whether an anomaly is just noise or whether the prior itself needs to change.
That noise-versus-update decision is one of the highest-value judgments in the whole system.
The operator’s job
The operator should not be buried in mechanics.
Their attention is the scarcest resource in the stack, so the system should leave them with only the irreducible judgments:
- deciding when outliers should change the frame
- setting new direction
- confirming high-consequence choices
Everything else should be absorbed by the system.
Voice as the primary modality
I increasingly think the operator’s control surface should be conversational first.
The point is not novelty. It is friction reduction. Talking through a problem with a capable system is often the lowest-friction way to surface direction, critique options, and launch work into the coordination space.
Voice should not mean voice-only. It means voice-primary, with visual surfaces for legibility, oversight, and parallelism.
That visual layer matters because the operator still needs to see:
- what work is in flight
- what has changed
- what the current frame is
- what evidence supports a recommendation
The coordination space
The strategic layer should not be a simple workflow engine running a fixed list of steps. It should be a shared coordination space where every actor, human and agent, is working against a common reality.
That shared reality needs:
- one current picture of goals and context
- visible activity across actors
- a living prior that propagates when it updates
- amortized shared context so work does not have to be rediscovered
- clear routing so work flows to the right actor
- legibility so the operator can intervene at any point
Proven mechanisms
In practice, the most useful patterns I have found are:
- giving every agent a clear system identity
- giving every agent an explicit hierarchy map
- treating escalation as signal rather than failure
- using a dedicated observer layer for drift detection
- making agents propose options instead of asking open-ended diagnostic questions
- placing knowledge at the layer that acts on it
- progressively replacing mechanical protocols with deterministic scripts
Why this matters outside software teams
This operating model matters because AI is making more domains tractable. As systems get better at working with language, screens, evidence, and context, more organizations will try to encode work that used to live only in expert judgment.
When that happens, the challenge is no longer just “can the model do the task?” The challenge becomes:
- what layer should hold the frame?
- who gets to update it?
- where does evidence flow?
- how do you prevent local success from creating system-wide drift?
Those are operating-model questions before they are tooling questions.
Why this matters
Most people still think about agents as tools. I increasingly think the right frame is organizational design.
The hard part is not adding more capable models. The hard part is creating a system where increasing capability does not break your ability to steer.
That is what this operating model is for.