My team has been doing a lot of agentic development at work lately. AI is an incredibly powerful tool, and when it is used well, it can significantly advance a software system. Over the past several months, we have been working to better understand agentic development and what actually makes these systems effective.
What we have uncovered is not new. It is something that has been around for a very long time. All complex systems are built as a hierarchy of responsibilities, and AI systems are no exception.
The Consumer–Provider Paradigm
To understand why this matters, it helps to look at how responsibility is structured in any complex system.
I call this the Consumer–Provider Paradigm. It is the idea that every part of a system depends on something beneath it and is responsible for providing something to what comes above it. Nothing exists on its own. Each part both receives and contributes, and the system holds together through that flow.
As I wrote in Striving for Quality:
“It is the idea that every part of a structure depends on certain levels beneath it and contributes something to the levels above it. Each part in a complex system is both a consumer and a provider. The levels beneath it are its dependencies, and the part itself must become a dependency for the levels above it. It consumes what it needs from lower levels, and it provides something of value to the levels that rely on it. Nothing operates on its own. This upward flow of value is what keeps the structure intact.”
Responsibility is what defines that relationship. It determines what a module is expected to provide and sets the boundary for what it should consume. When that responsibility is clear, the module has a place in the system. When it is not, the module begins to drift.
What Agentic Development Actually Is
Agentic software development makes this structure visible in a way that traditional software does not.
Instead of writing fixed sequences of logic, we create agents that are given roles and allowed to act. Each agent is defined by a system prompt, consumes context, depends on tools, and produces outputs that other parts of the system rely on. These agents are then composed together into larger systems.
As these systems grow, they naturally form layers. Agents call tools, tools invoke other agents, and those agents depend on additional tools. What begins as a simple interaction becomes a structure of interdependent parts.
At a technical level, this can look complex. But the underlying pattern is simple. Each agent is a module that consumes and provides.
Why Agentic Systems Must Follow This Structure
Because of this, agentic systems must follow the Consumer–Provider Paradigm if they are going to work well.
An agent must depend on lower-level modules to provide what it needs, and it must provide something clear and reliable to the layers above it. Its responsibility defines both sides of that relationship. It defines what it consumes and what it produces.
When this structure is respected, the system begins to integrate. Each agent has a defined role. Each layer contributes something specific. The system becomes easier to reason about because responsibility is distributed in a way that aligns with the structure.
When it is not respected, the system begins to lose clarity. Agents overreach into responsibilities that belong to higher layers, or fail to carry the responsibilities that belong to them. Either way, the structure weakens, and the quality of the system declines.
What We Are Seeing in Practice
This is why we keep seeing the same pattern in practice.
When an agent is given too much responsibility, the quality of its work declines. The outputs become less precise. The reasoning becomes less reliable. The system becomes harder to build on. But when the responsibility is narrowed, something changes. The outputs become clearer. The behavior stabilizes. The system begins to take on structure.
As I wrote in Striving for Quality:
“When responsibility is taken seriously, systems grow in strength, resilience, and clarity. When responsibility is neglected, they slide into disorder or stagnation.”
That is exactly what we are seeing in these systems.
Narrow, Generic, and Free
There is a natural instinct to solve this by expanding the agent. We give it more context, more tools, broader instructions, hoping that increased capability will produce better results. In practice, the opposite happens. The agent becomes less predictable because its responsibility is no longer defined with enough clarity to guide its behavior.
We see this even in the practical limits of these systems. As the number of tools available to an agent grows, its effectiveness tends to decline. It has more options, but less clarity. The additional capability does not improve the outcome. It introduces confusion.
What also works is more discipline.
The agent must be given a responsibility that is narrow enough to be clear, but still generic enough to apply across many situations. If it is too narrow, it becomes brittle and cannot adapt. If it is too broad, it becomes unfocused and loses coherence. The quality of the system depends on holding that line.
This is where freedom becomes necessary. An agent with a well-defined responsibility must be allowed to fulfill it. If it is overly constrained, it cannot adapt. If it is given freedom without a clear boundary, it becomes chaotic. The system stabilizes only when both are present.
What This Reveals
What becomes clear through this work is something that is easy to overlook when building software. Quality does not come from expanding what a module can do. It comes from defining what it is responsible for and allowing it to fulfill that responsibility well. Agentic systems do not introduce a new way of building. They reveal the structure we were always depending on.
I am very proud of the work my team has done to get to this point. They have been working hard over the past several months, not just building these systems, but learning through them. The challenges have been real, and so has the effort. But through that work, we have gained a much clearer understanding of what makes agentic systems effective.
What we have learned did not come from theory alone. It came from building, from struggling, and from paying attention to what actually works. And in that process, we have not just built better systems. We have come to better understand the structure that makes them possible.
LongLoft - Code Writer 