LangGraph Interview Questions for 10 Years Experience

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.

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

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

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

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

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

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

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.

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

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

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

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

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

Enterprise RAG interviews test system design at scale: ACL-aware retrieval, audit logging, and ingestion pipelines for millions of documents. This is a staff-level question appearing at Microsoft, Salesforce, and Fortune 500 AI teams. Walk through a complete architecture with security boundaries and operational concerns.

Multi-agent orchestration is a senior/staff-level system design question gaining traction at Google DeepMind and Microsoft. Learn the supervisor pattern, shared state management, and how to avoid the 'too many agents' anti-pattern that sinks most candidate answers.