For decades, we’ve built software by writing behavior out explicitly. We design objects, methods, and services. We wire them together with control flow. At the bottom of that wiring sit simple conditionals: compare a value, check a flag, call a method. Agentic systems invert this.
Traditional software has complex control flows and simple conditionals. Agentic software has simple control flows and extraordinarily sophisticated conditionals.
In traditional software, developers encode decisions into the program. In agentic software, developers encode the environment in which decisions get made.
Simple state machines, intelligent transitions
A well-built agent can run on a state machine with very few states:
Understand → Plan → Act → Verify → Deliver
Add a loop from Verify back to Plan, and an escape to a human when the agent gets stuck. You could draw it on a napkin.
The state machine stays simple. The number of states stays small. The sophistication lives in the transitions.
A traditional conditional asks if (status == DONE). An intelligent conditional asks: is this result actually good enough to deliver, or have I missed something the user cares about? Answering it takes the goal, the evidence, and the work so far. That single decision can hold more intelligence than an entire rules engine.
The more sophisticated the conditional, the less behavior has to be written into the graph. A situation that once needed a new branch becomes one more judgment for the model.
Complexity hasn’t disappeared. It has moved out of code paths and into judgment, context, and evaluation. Debugging a bad decision looks nothing like debugging a stack trace.
State machines all the way down
Sophisticated systems emerge when we compose these simple units. A coordinator delegates to planners. Planners delegate to executors. Executors call specialists that search, write code, read documents, or check the others’ work.
Each agent runs the same small lifecycle inside a bounded context. The system is simple locally and sophisticated globally.
That creates a new engineering challenge. Traditional software decomposes computation into functions, objects, and services. Agentic software has to decompose cognition into bounded, composable reasoning units. Decompose too little, and agents drown in context. Decompose too much, and coordination overhead swamps the benefit.
So the boundaries matter enormously. I call them semantic interfaces. An API specifies what data crosses a boundary. A semantic interface also has to carry the meaning: the objective, the context, the constraints, the capabilities, the authority, and what success looks like.
An API says research(topic). A semantic interface says: find enterprise pricing for this product, trust only this year’s sources, include seat minimums, and check with me before signing up for anything.


Two architectures
A serious agentic harness therefore has two architectures.
The execution architecture is the deterministic machinery: state machines, tool execution, permissions, retries, validation and communication. It should be predictable and boring.
The reasoning architecture decides which agents exist, what each owns, how they collaborate, and when they delegate. It can change mid-task. A hard problem may get a hierarchy of specialists, an easy one a single agent. Neither requires changing the execution machinery.
The system can reorganize how it reasons without reorganizing how it executes.
We’re moving from programming workflows to designing environments where good workflows can emerge. In practice, it comes down to three rules:
Keep control flow simple. Put intelligence in the transitions. Decompose reasoning carefully.
