By now, we all know the weaknesses of Large Language Models. They hallucinate, they lose context halfway through a long prompt, and they are deadly convinced of their own incorrect answers.
The industry's solution? Agentic workflows.
Instead of asking a single model to generate an answer, we set up an entire department of AI agents. Agent A writes the code. Agent B reviews it. Agent C tests the result and sends feedback back to Agent A.
And honestly: it works wonderfully. The quality of the output skyrockets when models are given the chance to correct their own mistakes before a human even sees it.
But what are we actually building here?
Re-inventing red tape
Without realising it, we have recreated the classic, sluggish corporate bureaucracy, but within our codebases. Where we used to rebel against the excess of managers and committees required to approve every decision, we are now cheering on the exact same process, executed by bots.
We have replaced the intuition of the craftsman with the procedures of a quality control department. And just like real bureaucracy, these layers come with a hefty price tag.
The hidden invoice
The cost of an agentic workflow isn't just the evaporating API budget (although the token burn of an iterating agent loop can be astronomical). The true costs lie in latency and complexity.
1. Latency is the new enemy A simple API call to an LLM takes two seconds. A network of agents deliberating with each other can easily take 45 seconds to a minute. As a developer, you are no longer in the flow, you are waiting for a virtual meeting to conclude. You've traded the speed of a script for the speed of a board meeting.
2. Infrastructure for self-doubt Your simple, straightforward function has now become a complex state machine. You are building orchestration layers, memory management, error handling, and timeout mechanisms, purely to accommodate the self-doubt of an algorithm.
The infinite loop of control
Then there is an even more fundamental problem. If we need a bot to check the first bot, because we don't trust the first one... who checks the checker?
If Agent B makes an incorrect assumption during its review, who calls out Agent B? Do we need an Agent D acting as some sort of virtual Board of Directors? Before you know it, an echo chamber is created where the AI is confirming its own mistakes via proxies.
No managers on the critical path
Does this mean agentic code is useless? Absolutely not. For asynchronous processes where time doesn't matter, such as translating large documents, scraping documentation, or running background data analysis, the higher quality of agents is absolutely worth it.
But as soon as you build real-time applications, or design processes that are directly on the critical path of the user or developer, it's time to stop building virtual departments.
If the worry driving that second checker is that something slipped through, the honest answer is downstream rather than sideways. Instrument the code instead, so production can tell you what actually happened, and skip the agent whose job is to agree with the first one.
Keep it simple. One fast prompt, and let a human be the final checker. An engineer's intuition is still faster, cheaper, and more effective than a bureaucracy of bots.