LangGraph vs CrewAI

LangGraph has emerged as the go-to framework for stateful agent workflows, replacing brittle LangChain chains in production. Interviewers want graph thinking — nodes, edges, conditional routing, and checkpointing — not just API familiarity. Essential for any LangChain shop hiring GenAI engineers.

Hard orchestration comparison — LangGraph agent graphs vs durable workflow engines.

**Graph structure** draft → auto_checks → legal_subgraph → manager_subgraph → publish; reject edges loop to draft with comments in state.

**Tracing** Span per node: inputs hash, duration, LLM/tool child spans. thread_id correlates user session.

**Discovery** Instrument legacy script to log state snapshots; draw FSM on whiteboard; identify hidden globals.

**Supervisor pattern** Central node decides next worker or FINISH based on plan and worker outputs — alternative to flat handoff messages.

**Pattern** Planner node outputs list of work items → map workers process each (possibly subgraph) → reducer synthesizes executive summary or ranked list.

**Serving pattern** Stateless API pods; thread state in checkpointer DB; long runs may use queue workers resuming checkpoints.

**Unit layer** Pure functions: conditional edges, state merge logic, parsers — no graph compile needed.

**State schema** ticket_id, customer_tier, messages, retrieved_docs, proposed_actions, sentiment, escalation_reason, resolution_code.

**Retry patterns** Tenacity-style retries inside node or dedicated retry wrapper node incrementing state.retry_count. Exponential backoff for transient MCP errors.

**Parallelism model** LangGraph can schedule independent nodes in same superstep concurrently — e.g., search three sources at once. Reducers combine outputs into unified state field.

**Requirements** Durability across pod restarts, concurrent threads, query by thread_id, retention/compliance deletes, backup/restore.

**Stream modes** graph.stream() / astream_events yield incremental updates — node enter/exit, partial state, LLM tokens. Pick mode matching product needs: chat UI wants messages; ops dashboard wants updates.

**LangChain agents** Higher-level executors (ReAct, tool calling) with less boilerplate. Good for demos and simple loops. Harder to debug complex branching, human interrupts, and precise persistence semantics.

**Why subgraphs** Parent graph orchestrates; subgraphs own domain logic — billing dispute flow, code review pipeline. Teams ship subgraph versions independently.

**Cycle design** Classic ReAct loop: agent → tools → agent. LangGraph makes cycle explicit vs hidden while True loops. Conditional edge from tools checks whether to continue.

**Checkpoint model** Each superstep persists channel values, metadata (thread_id, checkpoint_id), and pending writes. Enables resume after crash, human interrupt, or async long jobs.

**Interrupt API** LangGraph can interrupt execution before or after specified nodes — graph pauses, serializes checkpoint (lg-005), and returns control to host app. User sees proposed action; approver decision written to state; graph resumes from checkpoint.

**Mechanics** After node N runs, a routing function reads state — e.g., last tool call, confidence score, intent label — and returns one or more next nodes. LangGraph supports static maps from route keys to targets. This replaces fragile if/else scattered in agent code.

**Nodes** Each node is a Python/JS function (or runnable) that accepts the current graph state and returns a partial update — not necessarily the full state. LangGraph merges updates using reducers defined on the state schema (e.g., append to a list, overwrite a scalar). Nodes should stay focused: one node might call the LLM, another might invoke tools, another might format output.

Hard AI Agents interview question on long-running agents and checkpoints — architecture, trade-offs, eval, and production patterns.

Medium AI Agents interview question on human-in-the-loop agent workflows — architecture, trade-offs, eval, and production patterns.

AI Agents are the hottest topic in 2025–2026 GenAI interviews, but most candidates confuse agents with chatbots. Interviewers at OpenAI and Anthropic want you to articulate the agent loop — perceive, plan, act, reflect — and explain when tool use justifies agent complexity over a simple chain.