Agentic Workflows Aren’t Always 100% Reliable

There’s a lot of excitement right now around agentic workflows powered by LLMs. And rightly so, the idea of assembling a crew of AI agents, assigning them a chain of tasks, and letting them coordinate to deliver outcomes is incredibly powerful.

But as we put these into real-world systems, We starting to notice a consistent challenge, they’re not always reliable.

‍

Think of a Crew with 5–6 Tasks

Imagine you’ve designed a process with 5 or 6 tasks. You wire up an agentic crew , each agent with its responsibility, and let the workflow run.

Now, most of the time, it works.
But sometimes, maybe 2–3% of the time  a step is silently skipped. An agent might fail to hand over to the next one. Or misunderstand an intermediate result. And the whole chain moves forward, unaware.

For a typical user-facing application, this might be tolerable.
But for mission-critical systems, that’s a problem.

‍

LLMs Aren’t (Yet) 100% Deterministic

Agentic design relies on LLMs making decisions, interpreting context, routing tasks, or adapting outputs on the fly. This is exactly why it’s powerful  but also why it’s hard to guarantee full determinism.

That’s why we, as engineers and architects, need to pause and think before introducing these designs into sensitive systems.

Just because you can build an agentic crew doesn't mean you should.

‍

Where Agentic Workflows Shine

Agent-based execution works great when:

• Outcomes can tolerate a small margin of error or are reviewable
• Tasks are loosely coupled or exploratory (e.g., research assistants)
• You’re building AI copilots, content generation, or internal automation
• You're solving business workflow orchestration with human-in-the-loop review

‍

Where to Avoid

Agentic design should not be used for:

• Mission-critical systems (e.g., payments, healthcare data entry, compliance engines)
• Anything requiring guaranteed 100% step execution
• Low-latency use cases where speed and certainty are paramount (may be, this can be solved)

‍

We are big believer in agentic architectures, but with pragmatic boundaries.
LLMs and agents aren’t here to replace deterministic systems. They’re here to complement them, and we should treat them that way.

Let’s keep pushing the boundaries. Just make sure you know where those boundaries are, in the future posts, we ll discuss about ways to optimize agentic workflow and making them almost 100% reliable.

‍