Multi-Agent Analytics Crew: Prototype in CrewAI, Port to LangGraph

Tier: Advanced · Workflow area: Agentic systems

This playbook builds the pipeline twice on purpose: CrewAI to get a working prototype in an hour, then a LangGraph port to measure what the convenience costs. 2026 benchmarks put role-framework token overhead at up to ~3x an explicit graph for the same task; measuring that on your own workload is the deliverable.

When to use

• •
  A report you produce on a schedule from the same 3–5 data sources, where the structure is stable but the content changes.
• •
  You are choosing an orchestration framework for your team and need evidence, not vibes.
• •
  Interview preparation: "compare CrewAI and LangGraph" is now a standard senior GenAI question.

Single-source, single-step summaries do not need multiple agents — one well-prompted call beats a crew on cost, latency, and debuggability.

Prerequisites

• •
  pip install crewai langgraph (separate virtualenvs recommended — dependency trees clash).
• •
  Two or three real data inputs for the report: a metrics CSV, a set of release notes or tickets, a search/API source.
• •
  An LLM API key with token-usage reporting so you can pull exact input/output token counts per run.

The workflow

1. 1.

   Fix the task spec first. One page: report sections, data inputs, quality bar (e.g. "every claim cites its source", "numbers match the CSV exactly"). Both implementations run against this same spec — otherwise the comparison is meaningless.

2. 2.

   Build the CrewAI prototype. Three agents with role/goal/backstory (researcher: gather and extract; analyst: compute and interpret numbers; writer: assemble the report), sequential process, tools for file reading and search. Get it producing an acceptable report; note wall-clock time to build.

3. 3.

   Instrument token usage. Capture per-run input tokens, output tokens, number of LLM calls, and latency — from the framework's usage metrics or your provider dashboard. Run the report 3 times and average.

4. 4.

   Port to LangGraph. Same three stages as explicit nodes with a typed state dict (raw_findings, analysis, report). No role prompts or backstories — each node gets a tight task prompt plus only the state fields it needs. This is the point: you control exactly what context each step sees, instead of the framework replaying conversation history between agents.

5. 5.

   Run the same 3-run measurement on the LangGraph version. Build the comparison table: tokens/run, calls/run, latency, $/report, build time, and a subjective quality check (blind-compare two reports, or score both against your spec with a rubric judge from the evals module).

6. 6.

   Write the recommendation memo. One paragraph: which framework for this workload, at what cost delta, and what would change the decision (e.g. "CrewAI if the report structure churns weekly; LangGraph once it stabilizes").

Tool variants

• CrewAI hierarchical process (manager agent delegates) — try it once to see token usage climb further; useful when task decomposition itself is dynamic.
• AutoGen / OpenAI Agents SDK as the prototype layer — same experiment shape, same measurement.
• Claude with subagents (Agent tool patterns)provider-native delegation; compare if your stack is Anthropic-first.

Verification

• •
  Both implementations satisfy the same task spec on the same inputs — verified by rubric or blind review, not impression.
• •
  Token counts come from measured usage data, not estimates; 3-run averages with the raw numbers saved.
• •
  The comparison table includes build-time cost, not just runtime cost — the honest trade-off includes engineering hours.
• •
  Numbers quoted in both reports reconcile with the source CSV.

Pitfalls

• Comparing different specs. If the CrewAI version writes a richer report than the LangGraph version, you measured verbosity, not framework overhead. Pin the output contract.
• Backstory bloat. Multi-paragraph agent personas are pure token overhead on analytical tasks; keep CrewAI prompts as lean as the graph's.
• One run per variant. LLM pipelines are variant enough that single runs mislead; three runs minimum.
• Concluding "LangGraph always wins." For fast-changing task structures, CrewAI's prototyping speed is real value; the memo should state conditions, not a universal verdict.

Restricted-environment variant

Both frameworks are OSS and run fully locally against a self-hosted vLLM/Ollama endpoint — token measurement still works via the endpoint's usage fields. For client data, keep source documents local and disable any framework telemetry (both frameworks have opt-out env vars; check current docs) before running on real content.

Success criteria

• •
  Two working implementations of the same report from the same spec.
• •
  A measured comparison table (tokens, calls, latency, $/report, build hours) with raw data.
• •
  A one-paragraph framework recommendation with explicit decision conditions.
• •
  You can articulate why the token gap exists mechanically, not just that it does.