Reading an unfamiliar agent stack in a day
A repeatable pass — find the state schema, find the routing, find the interrupts, find the stream — that produces a UI surface inventory for a codebase you have never seen, which is the actual job across ninety products.
This is the last lesson, and it is the only one whose content nobody published. Everything else in this course was checked against a fetched page. What follows is a method, assembled out of four separately verified facts, built for one specific job: walking into a product you have never seen and leaving, the same day, with a list of the interface surfaces it needs.
Say that plainly rather than dressing it up as an industry practice. There is no LangChain, LangSmith or MCP page that recommends this order, or any order. It is this course’s synthesis, and the honest way to offer it is: here is a method that works, test it and keep what survives.
The pass
Four questions, in this order. The order matters: each one narrows what you have to read for the next.
| Ask | Where it lives | What the inventory gets |
|---|---|---|
| 1. Where is the state schema? | The channel declarations and their reducers. In LangGraph, a StateSchema or a legacy Annotation.Root. | Every field the UI can render, and which are transcripts versus fields. This is the API contract. |
| 2. Where does it branch? | Conditional edges and the routing functions behind them; a node returning a control-flow command. | The screens that exist. Every branch a user can be routed down is a state somebody has to design. |
| 3. Where does it stop for a human? | Interrupt calls, and whether a checkpointer is configured at all. | Decision surfaces, and whether “come back later” is even possible. |
| 4. What does it emit while it runs? | The stream mode the client subscribes to, and any custom writer calls inside nodes. | What you can show during the run, and what would need a backend change to show. |
Grep, do not read. Four searches across the repo — the state declaration, whatever adds conditional edges, the interrupt call, the stream call — land you on the four files that matter out of however many there are. Everything else in the codebase is implementation of steps you have already accounted for.
Run it against a stack that is not this one
The reason the pass is written as four questions and not four API names is that the questions survive the framework change. LangGraph is this course’s worked example because it is documented and open source, not because it is a recommendation, and a portfolio company will have picked whatever it picked.
- State might be a typed schema, or a row in a database, or a JSON blob passed between steps. Whatever holds the accumulated run is the contract, and the question “what merges and what overwrites” still decides whether you are rendering a transcript or a field.
- Routing might be conditional edges, or a switch inside a loop, or a model choosing the next tool. It is still true that every branch is a screen.
- Stopping for a human might be a framework interrupt, a durable-execution signal, a protocol-level input request, or a job left in a
pending_reviewrow. All four produce a decision surface; only some of them produce a resumable one. - Emission might be stream modes, server-sent events, a websocket, or polling a status endpoint. The design question is identical: which intermediate truth am I subscribed to, and what did I not subscribe to.
When one of the four questions has no answer, that is a finding, not a gap in your reading. A stack with no durable state cannot offer resume, no matter what the roadmap says. A stack with no branch has one screen. Write the absence down; it is usually the most valuable line in the inventory.
On comparisons, in both directions
You will find pages comparing agent frameworks to durable-execution engines, and pages comparing durable-execution engines to agent frameworks. This course fetched none of them and cites none, so treat what follows as a reading rule rather than a finding about any particular page.
The rule: a comparison published by a party that sells one of the options is marketing, whichever direction it runs. That includes the vendor whose documentation this entire course is built on. LangChain writes the LangGraph and LangSmith documentation and sells the hosted platform those docs lead to, which this course has named in every lesson that leans on those pages. The same discount applies to a durable-execution vendor explaining why you do not need a graph framework, and to a framework explaining why you do not need durable execution.
Which leaves you needing a way to decide without either. The four questions are that way. They are answerable from a codebase, they do not require anyone’s claim about anything, and they produce the only output that matters to you: a list of surfaces.
The deliverable
The pass is not finished when you understand the system. It is finished when a table exists that a product manager and an engineer can both argue with:
| Surface | Trigger | Data source | Resumable? |
| Extraction progress | run starts | stream: updates | n/a |
| Field review | interrupt at review | interrupt payload | yes |
| Low-confidence flag | confidence < 0.7 | state: fields channel | n/a |
| Failure state | error status on run | trace: error field | no |Four columns, one row per surface. The last column is the one nobody else fills in and the one that changes the product: a surface backed by a checkpoint can promise the user their work is held, and a surface that is not has to be honest about that in its copy.
Add one line under the table naming what you could not determine, and who could answer it in ten minutes. An inventory with an explicit unknowns list reads as competence. One with no unknowns reads as a first draft.
Where people get burned
The failure mode of a one-day pass is confusing coverage with depth. You will have four questions answered and a table, and you will not know why the routing function has that third branch, or which of the error states actually happens. Present it as an inventory, which is what it is, and not as an architectural review. The moment you defend a claim the pass did not establish, everything else in the table gets doubted too.
Check your recall
Answer from memory — no scrolling back.
Retrieval check
Name the three things this pass will not tell you, before somebody else names them for you.
Check your answer
Why. You will find the third branch of a routing function and not know what business rule it encodes. The pass locates decisions; it does not explain them.
What actually happens. A branch that exists in code may fire once a year. Frequency comes from traces, not from source, which is why the traces-as-the-observability-substrate lesson pairs with this one rather than competing with it.
Whether the design is good. An inventory tells you what surfaces the system demands as built. It has nothing to say about whether the system should have been built that way, and a one-day pass has not earned the right to that opinion.
Saying these out loud before you present the table is what makes the table trustworthy.
Hands on
Run the pass on somebody else’s repo, then close the artifact
Done when: ARTIFACT.md contains a completed surface inventory for an agent codebase you did not write — four columns, one row per surface, with an explicit unknowns list — produced in one sitting; and its interview answer section is written out in full.
- Pick an open-source agent repo you have never opened. Not a tutorial and not a template: something with enough files that reading it all is obviously not an option. That constraint is the exercise.
- Set a timer. Run the four searches in order — state declaration, conditional edges or equivalent, interrupt call, stream call — and write down which file each landed in before you read any of them properly.
- Fill the inventory table. Surface, trigger, data source, resumable. Where you cannot answer a column, write the question and who would answer it, rather than a guess.
- Stop when the timer stops. Then write two lines: what the pass told you, and what you would need a second day for. If those two lines are the same length, the pass worked.
- Now finish the artifact. Write the interview answer section of
ARTIFACT.mdin full: ninety seconds, out loud, no hedging. What you built, what the graph does that the app-level gate could not, and what the UI had to do about the resume. Say it out loud once before you consider it written. - Last pass over the whole artifact: every table filled, every surprise recorded, every claim you cannot source deleted. That last rule is the one the interview will actually test.
What this does not cover
Everything this pass compresses. The state question is a whole lesson on its own — state-is-the-contract, and the reducer distinction that decides which component you reach for. The branching question is the nodes-and-edges lesson. Stopping for a human is the entire interrupt module, from interrupt-and-resume through to the node re-execution rule in the interrupting-a-tool-call lesson, and what makes a stop durable is the checkpointers-and-threads lesson. Emission is the what-a-run-emits lesson. This lesson is the index; those are the content.
It also does not cover the standing questions the course leaves open on purpose: the exact contract for resuming across a language boundary, which the typescript-side-of-the-wire lesson marks as unverified rather than guessing at, and anything about model quality, prompts or evaluation, which this course has stayed out of from the first page.
That is the course. The one page worth keeping open from here is the primitives map in the reference section: node, edge, state, checkpointer, interrupt, command, thread, each with the surface it implies. Lessons are read once. That page is for the day somebody hands you a graph and asks what you would build.
Read this next — primary source
Graph APILangChain — docs.langchain.com, JavaScript docs, fetched 2026-09-02. Vendor documenting its own product
You met this page in the nodes-and-edges lesson. It earns a second reading here because three of the four questions in this lesson’s pass — state, routing, and the control-flow returns a node can make — are defined on one page, which makes it the single best reference to have open while reading somebody else’s definition. It does not, anywhere, prescribe the pass itself. That is this course’s own construction and no source states it.
Stuck, curious, or think this lesson is wrong? Ask your teaching agent. The lessons are the scaffold; the conversation is where the learning gets unstuck.