What changes when CrewAI goes to production
In development, inputs are small, you are watching the terminal, and Ctrl+C is your safety net. Production is different: real customer data, unsupervised execution via API calls or cron, and cost that compounds silently.
A three-agent crew (researcher, analyst, writer) costs $0.15 in dev. In production with real documents: $3.50 per run. At 100 runs/day, that is $10,000/month. The dev-to-production gap is routinely 10-25x.
The fix is not smaller data. It is instrumenting the crew so you know where money goes and can set hard limits.
Cost tracking for multi-agent crews
Crews amplify cost through multiplicative scaling: N agents x M iterations x K tool calls. A crew of 4 agents at 5 iterations with 2 tool calls each produces 40 billed LLM calls from one crew.kickoff(). Wrap with AgentGuard's Tracer for per-call cost tracking:
from crewai import Crew, Agent, Task from agentguard import Tracer, HttpSink tracer = Tracer(sink=HttpSink("ag1_your_key")) crew = Crew( agents=[researcher, analyst, writer], tasks=[research_task, analysis_task, writing_task], verbose=False, # Disable in production ) with tracer.trace("quarterly-report-crew") as run: result = crew.kickoff() print(f"Crew cost: ${run.total_cost:.2f}") print(f"Total LLM calls: {run.step_count}")
The tracer instruments every LLM call across every agent. No changes to agent definitions or tasks. The trace captures the full execution graph: which agent, which task, which tool, how many tokens, and what it cost.
Per-agent cost attribution
Total crew cost is useful. Per-agent cost is actionable. If the researcher consumes 70% of the budget, you can optimize its prompts or switch to a cheaper model. Without attribution, you are optimizing blind.
from agentguard import Tracer, HttpSink tracer = Tracer(sink=HttpSink("ag1_your_key")) with tracer.trace("crew-run") as run: # Tag each agent's work as a child span with run.span("researcher", metadata={"agent": "researcher", "model": "gpt-4"}): research_result = researcher.execute_task(research_task) with run.span("analyst", metadata={"agent": "analyst", "model": "gpt-4"}): analysis_result = analyst.execute_task(analysis_task) with run.span("writer", metadata={"agent": "writer", "model": "gpt-3.5-turbo"}): final_report = writer.execute_task(writing_task) # In the dashboard, filter by agent tag to see: # researcher: $2.10 (60%) analyst: $1.05 (30%) writer: $0.35 (10%)
Each span captures tokens, cost, latency, and metadata. Filter by the agent field in the dashboard to see cost distribution across crew members.
Budget caps for the entire crew
Tracking tells you what happened. Budget caps prevent the worst. BudgetGuard sets a hard dollar limit on the entire crew. When cost crosses the threshold, it raises an exception that stops the crew cleanly.
from agentguard import Tracer, HttpSink, BudgetGuard tracer = Tracer(sink=HttpSink("ag1_your_key")) tracer.add_guard(BudgetGuard(max_dollars=10.0)) # Hard cap for crew with tracer.trace("crew-run") as run: try: result = crew.kickoff() except BudgetExceeded as e: # Crew stopped mid-run — save partial results print(f"Budget exceeded at ${e.actual_cost:.2f}") result = run.partial_result()
The budget is enforced globally. If the researcher burns $8 of a $10 budget, the analyst gets $2 before the guard fires. Set budget based on expected cost with margin: if runs typically cost $3-5, a $10 cap catches runaways while allowing variance. For batch jobs, set budget per run so one bad input cannot drain the batch.
Loop detection across crew members
In single-agent systems, loops are obvious. In crews, they are subtler: Agent A delegates to Agent B, which requests clarification from Agent A, creating a cross-agent loop neither recognizes. LoopGuard detects repetition across the full execution graph, tracking tool calls and delegation patterns across all agents.
from agentguard import LoopGuard # Detect repeated patterns across all crew agents tracer.add_guard(LoopGuard(max_repeats=3)) # LoopGuard catches: # - Agent A calling the same tool 3x with identical args # - Agent A delegating to Agent B, who delegates back to A (ping-pong) # - The full crew producing identical outputs on consecutive iterations
This matters especially in CrewAI's hierarchical mode, where a manager can re-delegate the same task to specialists indefinitely. LoopGuard ensures the crew moves forward or stops, but never spins.
Remote kill switch for runaway crews
Crews can run for minutes or hours. A cost spike or anomaly might require stopping immediately. The kill switch is a server-side signal that propagates to all agents. Click "Kill" in the dashboard and the crew stops within seconds, regardless of which agent is executing.
tracer = Tracer( sink=HttpSink("ag1_your_key"), enable_kill_switch=True, ) with tracer.trace("long-running-crew") as run: try: result = crew.kickoff() except KillSignal: # Operator killed the run from the dashboard print("Crew terminated by operator") result = run.partial_result()
No redeployment, no SSH. Stop a runaway from any device with a browser. The kill event is recorded in the trace with timestamp and operator identity for post-incident review.
Logging and compliance
Every decision a CrewAI agent makes should be traceable. Regulated industries in finance, healthcare, and legal require it. AgentGuard captures every LLM input, output, tool call, delegation, and guard trigger.
Each trace has a shareable URL. Retention: 30 days free, 1 year on paid plans, with JSONL export. Traces plus guard logs plus kill audit trails provide a complete compliance record.
Complete production setup
Here is the full recommended configuration combining all guards:
from crewai import Crew, Agent, Task from agentguard import Tracer, HttpSink, BudgetGuard, LoopGuard # --- AgentGuard setup --- tracer = Tracer( sink=HttpSink("ag1_your_key"), enable_kill_switch=True, ) tracer.add_guard(BudgetGuard(max_dollars=10.0)) tracer.add_guard(LoopGuard(max_repeats=3)) # --- CrewAI setup --- researcher = Agent( role="Research Analyst", goal="Find accurate, relevant data", backstory="Senior researcher with domain expertise", llm="gpt-4", ) analyst = Agent( role="Data Analyst", goal="Evaluate and synthesize findings", backstory="Quantitative analyst focused on accuracy", llm="gpt-4", ) writer = Agent( role="Report Writer", goal="Produce clear, actionable reports", backstory="Technical writer for executive audiences", llm="gpt-3.5-turbo", # Cheaper model for writing ) crew = Crew( agents=[researcher, analyst, writer], tasks=[research_task, analysis_task, writing_task], verbose=False, ) # --- Run with full protection --- def run_crew(input_data: dict) -> str: with tracer.trace("production-crew", metadata=input_data) as run: try: result = crew.kickoff(inputs=input_data) return result except BudgetExceeded: return f"Budget limit reached at ${run.total_cost:.2f}" except LoopDetected: return f"Loop detected — returning partial result" except KillSignal: return "Run terminated by operator"
Four layers of protection: cost tracking with per-agent attribution, hard budget cap, cross-agent loop detection, and remote kill switch. Alert rules in the dashboard add a fifth layer via webhook or email when thresholds are crossed.
Deploy this and you know exactly what your crew costs, where money goes, and that no single run can blow your budget. That is the difference between running CrewAI in production and hoping it works.