Agentic AI Interview Kit
The comprehensive, open-source study guide for mastering agentic AI concepts, design patterns, architecture design, and real-world implementations -- built for engineers preparing for interviews and practitioners building production systems.
What Is Agentic AI?
Large language models can do more than answer questions. When you give an LLM the ability to observe its environment, reason about what to do next, act by calling tools or APIs, and learn from the results, you have built an agent. Agentic AI is the discipline of designing, building, and evaluating these autonomous systems.
Unlike traditional software that follows a predetermined control flow, agentic systems exhibit:
- Autonomy -- they decide which steps to take without explicit human instruction for every action.
- Tool use -- they interact with external systems (databases, APIs, code interpreters) to accomplish goals.
- Memory -- they maintain context across interactions, both short-term (within a conversation) and long-term (across sessions).
- Planning -- they decompose complex goals into sub-tasks and execute them in a reasoned order.
- Self-correction -- they evaluate their own outputs and retry or adjust when something goes wrong.
This matters because agentic AI is rapidly becoming the architecture of choice for building intelligent applications -- from autonomous coding assistants and research agents to multi-agent orchestration platforms that coordinate dozens of specialized agents.
An agent is a Model + Harness: a capable foundation model plus the harness around it -- the loop, tools, memory, context management, guardrails, and observability. Models keep getting stronger, and production-grade harness infrastructure (tool protocols, vector databases, observability platforms) has made agentic AI practical for real-world systems. Most of the engineering skill is now in the harness: start with What Are Agents? and Context Engineering. Interview questions in this space are growing fast.
What You Will Learn
This guide is organized into eight progressive sections. Each section builds on the previous one.
1. Foundations
Prerequisite knowledge that every agentic AI engineer must have. Covers LLM internals, prompting techniques, embeddings, RAG pipelines, fine-tuning tradeoffs, and evaluation metrics. If you are new to LLMs, start here.
2. Core Concepts
The building blocks of agentic systems. Covers the agent loop (Observe-Think-Act), tool use and function calling, memory architectures (short-term, long-term, episodic), planning and reasoning strategies (ReAct, Plan-and-Execute, Tree of Thought), and guardrails.
3. Design Patterns
Proven architectural patterns for building agents. Covers single-agent patterns (router, chain, state machine), multi-agent patterns (supervisor, peer-to-peer, hierarchical), human-in-the-loop patterns, and error recovery strategies.
4. Frameworks
Hands-on walkthroughs of the most popular agentic AI frameworks. Covers LangChain/LangGraph, LlamaIndex, CrewAI, AutoGen/AG2, OpenAI Agents SDK, and Semantic Kernel. Each walkthrough includes architecture diagrams and working code.
5. Code Walkthroughs
Pattern-focused code examples that teach you the building blocks. Covers ReAct agents, RAG with tools, multi-agent crews, LangGraph workflows, tool calling, and evaluation harnesses.
6. Architecture Design
Interview-ready system design for agentic applications. Each topic follows an interview format: problem statement, clarifying questions, requirements, architecture diagrams, component design rationale, data flow, scaling strategies, cost analysis, and trade-offs. Covers 19 architecture design problems across general-purpose agents, developer tools, platforms, and domain-specific applications.
7. Real-World Projects
Complete, production-grade implementations with runnable code. Four projects covering different frameworks and use cases: a customer support agent (LangGraph), a deep research agent (LangGraph), a code assistant (custom implementation), and a data pipeline agent (LangChain). Each project includes a framework decision rationale explaining why that framework was chosen.
8. Interview Prep
Targeted preparation for agentic AI interviews. Covers common questions organized by difficulty, sample answers, whiteboard exercises, and a study plan.
How to Use This Guide
This guide follows a progressive learning path. Each section assumes you have absorbed the material in the sections before it.
For each topic, you will find:
- Concept explanations -- clear, concise descriptions of what the concept is and why it matters.
- Mermaid diagrams -- visual representations of architectures, flows, and relationships.
- Python code examples -- practical, runnable code that demonstrates the concept.
- Interview angles -- how the topic is likely to appear in an interview.
- Deep dives -- collapsible sections with additional depth for advanced readers.
Each page is designed to be read in 10-15 minutes. The entire guide can be completed in a focused weekend of study, or spread across a week of daily sessions.
Quick Start: Where Should You Begin?
Choose your starting point based on your experience level.
| Experience Level | Start Here | Estimated Time |
|---|---|---|
| New to LLMs | Foundations: LLM Fundamentals | Full guide (20-25 hours) |
| Comfortable with LLMs, new to agents | Core Concepts | Sections 2-7 (15-18 hours) |
| Built simple agents, want depth | Design Patterns | Sections 3-7 (10-12 hours) |
| Experienced practitioner, interview prep | Interview Prep | Section 8 + review (5-8 hours) |
If You Have One Hour
Read these three pages in order:
- LLM Fundamentals -- understand the engine.
- Core Concepts: The Agent Loop -- understand the architecture.
- Design Patterns Overview -- understand the playbook.
If You Have One Day
Work through Foundations and Core Concepts end to end. Build the code examples as you go.
If You Have One Week
Complete the full guide. Spend extra time on Architecture Design and Real-World Projects, as these sections most closely mirror what you will encounter in senior-level interviews.
Prerequisites
To get the most from this guide, you should be comfortable with:
- Python 3.10+ -- all code examples use Python.
- Basic ML concepts -- you do not need to be a researcher, but familiarity with neural networks, loss functions, and gradient descent helps.
- REST APIs -- you will work with LLM provider APIs (OpenAI, Anthropic).
- Software engineering fundamentals -- data structures, design patterns, distributed systems basics.
Many code examples call LLM APIs. You will need API keys from providers like OpenAI or Anthropic. Where possible, we provide alternatives using open-source models that run locally.
Model and Price Reference
Examples in this guide read model IDs from environment variables (AGENT_MODEL, AGENT_EMBEDDING_MODEL). The current example IDs and list prices live in one place:
Model IDs, tiers, and prices change often. Every example in this guide reads the model ID from an environment variable instead of hardcoding it. Prices below are list prices per 1M tokens in USD, checked on 2026-10-12; treat them as an assumption to refresh, never as a constant in code.
No universal default model. Snippets in this guide read model IDs from environment variables, and the value you export must belong to the same provider SDK the snippet uses. An Anthropic ID will not work in an OpenAI snippet, and vice versa. Examples below are scoped per provider; they are not interchangeable.
# Anthropic snippets (anthropic SDK, langchain-anthropic)
export AGENT_MODEL="claude-sonnet-5-5"
# OpenAI snippets (openai SDK, langchain-openai)
export AGENT_MODEL="gpt-6.1-sol"
Export only the one that matches the provider your snippet imports. When a snippet passes the ID to
LangChain v1 create_agent (or init_chat_model) as a single string, LangChain expects
provider:model form, for example anthropic:claude-sonnet-5-5 or openai:gpt-6.1-sol; build it with
f"{provider}:{os.environ['AGENT_MODEL']}" or export the prefixed value. Provider-specific clients
(ChatAnthropic(model=...), OpenAI().chat.completions.create(model=...)) take the bare ID.
Embeddings use separate variables, because API and local models are different kinds of ID:
export AGENT_EMBEDDING_MODEL="<api-embedding-model-id>" # hosted embedding API (OpenAI, Google, ...)
export AGENT_LOCAL_EMBEDDING_MODEL="<sentence-transformers-model-name>" # local SentenceTransformer
export AGENT_RERANKER_MODEL="<cross-encoder-reranker-name>" # local reranker (CrossEncoder)
export AGENT_NLI_MODEL="<nli-cross-encoder-checkpoint>" # local NLI entailment checker
| Tier (prose label) | Example API ID | Input / 1M tok | Output / 1M tok | Source (checked 2026-10-12) |
|---|---|---|---|---|
| Frontier | claude-fable-5-1 | $10 | $50 | Anthropic pricing, models overview |
| Strong / general (example model) | claude-sonnet-5-5 | $2 | $10 | same |
| Fast / cheap | claude-haiku-5-5 | $0.10 (prompts up to 100K tokens) | $0.50 | same |
| Frontier (OpenAI) | gpt-6-astra | $10.00 | $50.00 | OpenAI pricing |
| Strong / general (OpenAI) | gpt-6.1-sol | $2.00 | $10.00 | same |
| Fast / cheap (OpenAI) | gpt-6-luna | $0.10 | $0.50 | same |
| Embeddings (Google API) | gemini-embedding-2 | $0.20 (text input) | n/a | Gemini pricing |
| Embeddings (OpenAI API) | text-embedding-3-small | <UNVERIFIED> | n/a | ID confirmed in the embeddings guide; no price on the pricing page |
| Embeddings (local) | any SentenceTransformer name | your own compute cost | n/a | no vendor price |
Anthropic's four current models list a 1M-token context window and 128K max output; Haiku-tier long prompts (over 100K tokens) are priced higher ($0.50 input / $2.50 output). Batch, Flex, Fast, and Ultrafast modes on OpenAI use different rates; the table shows Standard, short-context rates.
Unverified placeholders (explicit, not invented):
| Item | Status |
|---|---|
OpenAI embedding price (text-embedding-3-small and similar) | The embeddings guide (https://developers.openai.com/api/docs/guides/embeddings, checked 2026-10-12) confirms the ID text-embedding-3-small exists, but no price appears on the pricing page. Price is <UNVERIFIED>; read it from your own config. |
| Open-weight models (Llama, Mistral, etc.) | Priced by your host or your own GPU cost; no single vendor price. <UNVERIFIED> |
Cost formula used throughout the guide (symbolic, rates from config):
# p_in / p_out are USD per 1M tokens, loaded from your pricing config -- not defaults.
cost = (in_tokens * p_in + out_tokens * p_out) / 1_000_000
Contributing
This is an open-source project. If you find errors, want to add content, or have suggestions, please open an issue or pull request. The goal is to make this the best freely available resource for agentic AI interview preparation.
Notation and Conventions Used in This Guide
Throughout this guide, we use the following conventions:
- Bold terms indicate key vocabulary that you should know for interviews.
Code blocksare used for API parameters, model names, and inline code references.- Mermaid diagrams are used for architecture and flow visualization.
- Admonition blocks (tip, info, warning, danger) highlight important callouts.
- Collapsible sections (like this one) contain supplementary material for deeper understanding.
- All code examples are written in Python and tested against Python 3.10+.
- Token counts and cost estimates are based on pricing as of early 2026 and may change.