Trace `run_pipeline` in the minimal LangGraph example. It walks the graph's topological sort and merges each node's returned dict into one state object [7]. The three nodes call a requests tool, a GPT-4-turbo completion and a Postgres insert, and each returns a dict; error handling appears in none of them [7]. A for loop over a topological sort is a scheduler in roughly the way that `while True` is a supervisor.
So the task-20 observation follows from the design, not from bad luck. Recovery logic was never in the framework, which means it goes into every node you write, along with retries and output validation [8]. The author's compensating benefit is real and worth naming: state stays transparent, so you always know which node failed and why [8]. That is a legible debugging cost. Boilerplate you can see in a diff is cheaper than state you cannot inspect.
The budget is where the design pressure actually shows. One cent per task, one to six LLM calls per task, against GPT-4-turbo or Claude 3 Opus [4][5]. At the top of the call range that leaves about $0.0017 per model call [3], while the median task payload is 100KB of text or semi-structured data [3]. The one-cent target is only reachable if most of that 100KB never reaches the model. The latency envelope is tighter still: under 15 seconds median across up to six calls is 2.5 seconds per call, including the API or database round trip that every task carries [5][4][2][4].
For the numbers to transfer, your workload has to look like this one: I/O-bound, at least one API or DB call per task, LLM-assisted rather than LLM-dominated [2]. If your agents make one long generation over a large context instead of several small calls between I/O steps, the cost curve does not carry over. The boilerplate finding does, because it is about error handling per node rather than tokens per task [8].
CrewAI's reported ceiling is the useful counterweight. The teardown says it delivers on first use, until you orchestrate beyond roughly 10 agents or tasks, at which point the task abstraction starts leaking [10]. That is a different purchase: less code now, a rewrite at a threshold you can estimate.
Two caveats on the evidence. The deadlock on task 22 and the $48 overnight bill are the author's illustration of the stakes, not measurements [12]. For scale, $48 is about 45 full passes of the whole 107-task suite at the stated one-cent target [1][2]. And the material available stops mid-sentence in CrewAI's scale gripes, with no AutoGen section and no per-framework cost or latency figures [11], despite the subtitle promising how cost and performance curves behave past 100 tasks [1]. The failure taxonomy is usable. The ranking implied by the headline is not yet checkable.
In my context I would take LangGraph's code volume, because more than a quarter of these tasks involve chaining, error recovery or fuzzy duplicate detection, which is where inspectable state pays for itself [6][5][8]. A task family that stays under ten agents and needs no cross-DAG coordination is the case where CrewAI's brevity is worth having [10][8].
