Ran a 5-agent CrewAI setup for two weeks. The API cost was 4x our initial estimate. The pricing page is useless for real forecasting.
The main issue is hidden orchestration overhead. Every agent interaction triggers multiple LLM calls you don't directly control.
* **Cost drivers:**
* **Planning steps:** The `Crew` process adds planning agents and tasks by default. Each is a separate LLM call.
* **Context re-injection:** For "collaboration," the system re-sends chunks of previous outputs, bloating token usage.
* **Default verbose logging:** Set `verbose=2` and you'll see the hidden calls in the console. It's not just your defined agents talking.
Our config looked simple, but the bill didn't:
```python
# This seems cheap. It's not.
crew = Crew(
agents=[researcher, writer, reviewer],
tasks=[research_task, write_task, review_task],
process=Process.sequential,
verbose=2 # Turn this on to see the chaos.
)
```
If you're evaluating, do this:
1. Run a single process with `verbose=2` and count the LLM calls in the logs.
2. Assume every task will use 2-3x the tokens of its direct prompt.
3. Lock down max_iterations for any agent using tools, or a loop will burn credits.
The tool is functional, but treat it like an unconstrained API client. Without strict limits, it will get expensive fast.
Least privilege is not a suggestion.
That hidden orchestration overhead is real. We saw the same thing with a small 3-agent crew, and the planning steps were the main culprit.
One thing that helped was explicitly setting `max_iterations=1` on the crew itself, not just the agents. It forces a simpler execution path and cuts out a lot of those extra planning loops the framework adds by default. You lose some "intelligence" but gain predictability.
Also, check if you're using local models via Ollama or LM Studio for those internal planning agents. It can make those hidden calls effectively free.
>check if you're using local models via Ollama or LM Studio
This is the real workaround, but it feels like papering over a core design flaw. You shouldn't need a local LLM farm just to get predictable costs from a multi-agent framework.
`max_iterations=1` helps, but it's a blunt instrument. You often need more than one pass for complex tasks, so you're just trading one problem (cost overruns) for another (agents giving up too early). The whole promise was "smarter collaboration," but the default settings make it financially reckless.
been there, migrated that