The industry has spent two years treating agents as a new category of thing. They are not. Agents are software, and they benefit from the same engineering principles that have always mattered: modularity, testability, observability, clear interfaces. The fact that there is an LLM call somewhere in the execution path does not change the nature of what you are building.
Once you accept this, the architecture becomes obvious. You do not build one agent. You build many small, atomic agents — each with a defined input, a defined output, and a clear purpose. Each can be tested independently. Each can be swapped, improved, or retired without touching the rest of the system.
The teams that struggle the most with agents are the ones who treat the LLM as a magic ingredient that absolves them from doing software engineering. They write a prompt, they get a demo, they ship it. Then it drifts. Then it breaks. Then they cannot figure out why because they never built the observability or the test fixtures that any other piece of production software would have.
The teams that ship treat agents like services. There is a contract. There are inputs and outputs. There are tests against known-good behavior. There is a deployment pipeline. There is monitoring. The LLM is an implementation detail inside the box. What lives outside the box is the same engineering discipline that has always mattered.
This is the agent mesh — not a theoretical framework, a practical architecture for getting AI into production. It is the only way out of the mega-agent fantasy that keeps stalling enterprise rollouts. Many small units, each one boring, each one verifiable.
If you are building in this space, audit your team's mental model. Is the agent a prompt with vibes? Or is it a service with a contract? The answer determines whether you are building a demo or a system.
Related Essays
The Declarative Atomic Agent
An atomic agent is a single declarative spec — input, output, purpose, constraints. That property is what makes the mesh composable, auditable, and cheap to optimize.
The Mega-Agent Fantasy Is Already Falling Apart
Enterprise AI is not one omniscient agent. The mega-agent fantasy collapses on contact with production, and the failure mode is always the same.
Sessions Replace Tasks, Runs, and Threads
When the same object has three names, your architecture is drifting. Tasks, runs, threads, chats — all of it is just a session. One container, many shapes of work.
Key takeaways
- Agents are software with an LLM call in the execution path. They are not a new category.
- The same engineering principles apply — modularity, testability, observability, clear interfaces.
- Once you accept agents are software, the architecture becomes obvious: many small atomic units.
FAQ
What changes when you treat agents as software?
You stop optimizing prompts in isolation and start engineering systems. Versioning, tests, interfaces, deploy pipelines. The boring stuff that separates a demo from a deployment.
Does this mean prompt engineering does not matter?
It matters less than people think and at a different layer than people think. Inside an atomic agent, prompts are an implementation detail. The contract between agents is what determines whether the system works.