When is using an agent architecture an engineering mistake, even when LLMs are involved?

An **agent** is an LLM placed in a loop that decides its own next step at runtime. That flexibility is powerful, but it is not free. Each step pays for an extra reasoning call, the path can branch in ways you did not plan, and the total cost and time are hard to predict. Using an agent becomes an engineering mistake when the execution path is fixed. If the same tools always run in the same order, no matter what comes back from each step, there is nothing for the agent to decide. The dynamic routing is dead weight. The right alternative here is a chain, also called a pipeline or a fixed graph. A chain runs a known sequence of steps every time. It is simpler to write, cheaper to run, faster, and far easier to debug because every run looks the same. A classic example is a document ingestion flow: extract text, split into chunks, embed, then store. Those four steps never reorder based on results. A chain expresses that perfectly, and an agent would only add cost and unpredictability for no benefit. The deciding question is simple. Does the next step depend on the current result in a way that needs a decision? If no, use a chain.

An **agent** is the wrong architecture whenever the execution path is fully determined at design time. If the same tools run in the same order on every run, regardless of intermediate results, there is nothing to route dynamically. The agent's defining feature becomes pure overhead. The appropriate alternative is a chain: a fixed directed graph or pipeline that runs a known sequence of steps. A chain wins on four engineering properties. First, predictability. A five-node chain always makes five LLM calls. An agent might make five or fifty, which wrecks both your latency SLA and your billing cap. Second, cost. The agent pays an extra reasoning call at each step just to decide what is already known. Third, debuggability. Every chain run has the same shape, so a failure is easy to localise. Fourth, simplicity, because there is no loop, no termination policy, and no stuck-agent detection to maintain. Clear chain cases include document ingestion, which extracts then chunks then embeds then stores, and basic retrieval augmented generation, which retrieves then generates. The order never branches on results. The decisive test is one question. Does the next step depend on the current result in a way that requires a runtime decision? If no, reach for a chain.