The AI Workflow Tooling Mess

The number of ways to build AI workflows in 2026 is staggering.

You can use CrewAI and define agents with roles and goals that coordinate on tasks. You can use LangGraph and model your workflow as a state machine with explicit transitions. You can use Vellum and describe agents in plain English without code. You can use Claude Code with slash commands and skills that invoke specialized behaviors. You can use MCP servers to connect agents to external tools. You can build custom orchestration on top of raw API calls.

All of these work. None of them are obviously right. The fragmentation reflects genuine uncertainty about what AI workflow development should look like.

The fundamental question: who decides what happens next?

In traditional automation, the developer decides. You write code that specifies control flow. If condition A, do action B, else do action C. The logic is explicit. The behavior is deterministic.

In agentic workflows, the model decides. You give it a goal and let it figure out the steps. The logic is implicit in the prompt and the model's training. The behavior is probabilistic.

The tooling reflects this spectrum.

LangGraph sits toward the deterministic end. You define states and transitions explicitly. The model fills in details, but the overall flow is controlled. This gives you predictability at the cost of flexibility.

CrewAI and similar frameworks sit toward the agentic end. You define agents with capabilities and let them coordinate. The flow emerges from agent interactions. This gives you flexibility at the cost of predictability.

The "describe it in plain English" tools like Vellum push even further. You don't write code at all. You explain what you want and the platform figures out how to accomplish it. The abstraction is appealing. The debuggability is concerning.

What I've learned building production workflows: the deterministic end works better than the agentic end, even for tasks that seem to benefit from flexibility.

The reason is failure modes. When a LangGraph workflow fails, you can trace through the states and find where it went wrong. When an agentic workflow fails, you have logs of model outputs but limited insight into why the model made the choices it did.

In production, you need to explain failures. You need to fix them reliably. You need confidence that the fix actually addresses the root cause. Explicit control flow makes all of this easier.

The counterargument is that explicit control flow limits capability. An agent that can reason about next steps might solve problems that a rigid state machine can't handle.

In my experience, this tradeoff favors control for most business applications. The problems that benefit from agent flexibility are usually problems where failure is acceptable—exploration, research, creative work. The problems that can't tolerate failure need explicit logic, even if the logic is implemented by selecting between LLM calls.

The tooling will probably consolidate. MCP is becoming the standard for tool integration. Some workflow framework will become the default for orchestration. The plain English interfaces will either prove themselves in production or remain prototyping tools.

For now, I recommend picking a point on the spectrum and staying there. If you need predictability, use explicit state machines. If you need flexibility and can tolerate failures, let agents coordinate. Mixing approaches makes debugging worse without making capabilities better.

The mess will sort itself out. It usually does. In the meantime, build for the failure modes you can handle, not the capabilities you hope to unlock.