LangGraph Scenario Based Interview Questions

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.

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

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.

**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.

**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.

Hallucination in RAG systems is the #1 production failure mode cited in AI engineering interviews. Your interviewer wants a systematic debugging framework — not a list of buzzwords. Learn how to measure faithfulness, fix retrieval precision, and layer mitigations the way senior engineers at Databricks and Meta actually ship RAG.