roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Explain how LLM agents plan, call tools and remember, at the depth interviews probe. Covers LLM basics, prompting and reasoning, tools and MCP, RAG and memory, frameworks, evaluation and safety.
1179 of 1179 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 1179 new. 0 cut, outside your plan.
Agent questions are not confined to loops with AI in the title. AI engineer and applied ML interviews usually give them a whole design round, framed as an assistant that must act on a real system, such as one that triages a support queue and files tickets. Some backend and platform loops now add an agent question to system design, and a practical coding round may ask for a small tool-calling loop written live against a model API. The probes are about the machinery around the model. What does the model actually return when it "calls" a tool, and who executes the call? What does the loop do with a tool that times out or returns an error? How does a run end when the model never declares itself done: a step cap, a token budget, a person? What is left of the context window after dozens of tool results, and what do you keep when you compress it? If a fetched web page tells the agent to forward a file, which part of your design stops it? Level shows in what a candidate reaches for first. One who has only demoed agents describes the happy path and the framework that ran it; one who has operated them starts from a failure, such as a loop that repeated one search until its budget ran out or a tool with write access that needed an approval step. The stronger candidate can also say how to score a run whose steps differ every time, and when one agent with better tools beats a team of them.
Everything an agent does is paid for in tokens, so the plan opens beneath the agent, on the model itself. [Context windows](/topics/found-llms-context-windows) come early because a loop appends every tool result to its input and fills the window turn by turn, and [sampling](/topics/found-llms-inference-sampling) explains why two runs of the same task take different paths. Open-Weight Models first weighs [a hosted API against open weights](/topics/found-ai-engineering-model-sourcing-hosted-vs-open) and reads what a [weight licence](/topics/found-ai-engineering-model-sourcing-weight-licensing) actually permits, then puts open weights on your own machine. Running one locally shows what a hosted API hides, above all the [chat template](/topics/ai-huggingface-tokenizers) that turns a list of messages, tool calls included, into the token stream the model actually reads. Agent Foundations is the hinge: [the agent loop](/topics/found-ai-agents) and the [application built around it](/topics/found-ai-engineering-app-architecture) are described end to end before any technique, so later modules have something to attach to. Prompting & Reasoning works up from plain instructions through chain and tree of thought to [ReAct](/topics/found-react-reasoning), which interleaves reasoning with actions and observations and so leads straight into tools. Tools & MCP opens with [structured output](/topics/found-ai-engineering-structured-output), since a tool call is worthless if its arguments do not parse, then takes the vendors' own tool-calling APIs and ends on [MCP](/topics/proto-mcp), the protocol that lets one tool server work across many hosts. Retrieval & Memory decides what the model sees on each turn: [RAG](/topics/found-rag) brings documents in, and [context engineering](/topics/found-context-engineering) budgets, orders and compresses everything competing for the window. Only once one agent is fully described does the plan split work across [several](/topics/found-multi-agent-systems). The frameworks follow the concepts on purpose: [LangGraph](/topics/ai-langgraph)'s state graph, CrewAI's crews and AutoGen's group chat are each one answer to questions the earlier modules have already posed. The last stretch asks whether the agent works and what it costs. [Evaluation](/topics/found-ai-engineering-evaluation) and [tracing](/topics/found-ai-engineering-observability) come before the products that implement them, from LangSmith's traces and datasets to OpenLLMetry's instrumentation on OpenTelemetry. Running at Scale adds streaming, [routing easy requests to cheaper models](/topics/found-ai-engineering-cost-latency-model-routing-cascades) and a [model gateway](/topics/found-ai-engineering-llm-gateway), the one place a team's keys, spend caps and provider failover live once many agents share a few providers. The plan closes on security, where an agent that reads untrusted text while holding real permissions turns [prompt injection](/topics/found-llm-safety-security-prompt-injection-defense) from a wording problem into an access-control one.
Juniors, and anyone who has used models only through a chat window, should make the opening stretch and the tool module hold before anything else: one [tool round trip](/topics/found-ai-agents-tool-use), explained down to the message the model emits and the one your code sends back, answers more interview questions than any one framework. Seniors can skim the fundamentals and spend their hours where design rounds run long: evaluation, cost and security. A backend engineer already thinks in timeouts, retries and idempotent writes, most of what makes a tool safe to call twice, and is usually weaker on sampling and on scoring output that varies. Someone from data science has the reverse profile: evaluation feels familiar, while tool contracts and the threat model are new. Days before the interview, the vendor tools and frameworks are the widest part of this plan and rarely what a loop turns on. With importance raised to must know, put the time that saves into the loop, tool calling and injection. Given months, put one agent together while you study, with two real tools behind an MCP server, every run traced and a small eval set it must pass, and let by topics set the study order so each module arrives as the build needs it. Design rounds ask about the run that went wrong, and you will have one to describe. The software around the agent sits outside this plan: the Python it is usually written in, vector databases as products in their own right, the web service it runs behind and production inference servers such as vLLM. The [AI Engineer roadmap](/roadmaps/ai-engineer) covers that ground. To attack agents rather than defend them, the [AI Red Teaming roadmap](/roadmaps/ai-red-teaming) goes further into adversarial technique than the closing module here.
Agent questions are not confined to loops with AI in the title. AI engineer and applied ML interviews usually give them a whole design round, framed as an assistant that must act on a real system, such as one that triages a support queue and files tickets. Some backend and platform loops now add an agent question to system design, and a practical coding round may ask for a small tool-calling loop written live against a model API.
The probes are about the machinery around the model. What does the model actually return when it "calls" a tool, and who executes the call? What does the loop do with a tool that times out or returns an error? How does a run end when the model never declares itself done: a step cap, a token budget, a person? What is left of the context window after dozens of tool results, and what do you keep when you compress it? If a fetched web page tells the agent to forward a file, which part of your design stops it?
Level shows in what a candidate reaches for first. One who has only demoed agents describes the happy path and the framework that ran it; one who has operated them starts from a failure, such as a loop that repeated one search until its budget ran out or a tool with write access that needed an approval step. The stronger candidate can also say how to score a run whose steps differ every time, and when one agent with better tools beats a team of them.
Everything an agent does is paid for in tokens, so the plan opens beneath the agent, on the model itself. Context windows come early because a loop appends every tool result to its input and fills the window turn by turn, and sampling explains why two runs of the same task take different paths. Open-Weight Models first weighs a hosted API against open weights and reads what a weight licence actually permits, then puts open weights on your own machine. Running one locally shows what a hosted API hides, above all the chat template that turns a list of messages, tool calls included, into the token stream the model actually reads.
Agent Foundations is the hinge: the agent loop and the application built around it are described end to end before any technique, so later modules have something to attach to. Prompting & Reasoning works up from plain instructions through chain and tree of thought to ReAct, which interleaves reasoning with actions and observations and so leads straight into tools. Tools & MCP opens with structured output, since a tool call is worthless if its arguments do not parse, then takes the vendors' own tool-calling APIs and ends on MCP, the protocol that lets one tool server work across many hosts.
Retrieval & Memory decides what the model sees on each turn: RAG brings documents in, and context engineering budgets, orders and compresses everything competing for the window. Only once one agent is fully described does the plan split work across several. The frameworks follow the concepts on purpose: LangGraph's state graph, CrewAI's crews and AutoGen's group chat are each one answer to questions the earlier modules have already posed.
The last stretch asks whether the agent works and what it costs. Evaluation and tracing come before the products that implement them, from LangSmith's traces and datasets to OpenLLMetry's instrumentation on OpenTelemetry. Running at Scale adds streaming, routing easy requests to cheaper models and a model gateway, the one place a team's keys, spend caps and provider failover live once many agents share a few providers. The plan closes on security, where an agent that reads untrusted text while holding real permissions turns prompt injection from a wording problem into an access-control one.
Juniors, and anyone who has used models only through a chat window, should make the opening stretch and the tool module hold before anything else: one tool round trip, explained down to the message the model emits and the one your code sends back, answers more interview questions than any one framework. Seniors can skim the fundamentals and spend their hours where design rounds run long: evaluation, cost and security.
A backend engineer already thinks in timeouts, retries and idempotent writes, most of what makes a tool safe to call twice, and is usually weaker on sampling and on scoring output that varies. Someone from data science has the reverse profile: evaluation feels familiar, while tool contracts and the threat model are new.
Days before the interview, the vendor tools and frameworks are the widest part of this plan and rarely what a loop turns on. With importance raised to must know, put the time that saves into the loop, tool calling and injection. Given months, put one agent together while you study, with two real tools behind an MCP server, every run traced and a small eval set it must pass, and let by topics set the study order so each module arrives as the build needs it. Design rounds ask about the run that went wrong, and you will have one to describe.
The software around the agent sits outside this plan: the Python it is usually written in, vector databases as products in their own right, the web service it runs behind and production inference servers such as vLLM. The AI Engineer roadmap covers that ground. To attack agents rather than defend them, the AI Red Teaming roadmap goes further into adversarial technique than the closing module here.