Agentic AI Engineering Interview Prep
Test & Track Your Readiness

The correct mental model for agents: a loop where an LLM decides what to do next, acts using tools, observes outcomes, and repeats until done. The spectrum from simple pipeline to full autonomy. Why agents are fundamentally different from chatbots. The four agent archetypes (reflex, model-based, goal-based, utility-based) and where modern LLM agents sit. Real examples of agents that work vs agents that fail.

ReAct (Reasoning + Acting) from the original paper to production implementation. Explicit vs implicit chain-of-thought. Step-back prompting. The Plan-and-Execute pattern. Tree of Thoughts for complex multi-path problems. Reflexion for iterative self-improvement. LATS (Language Agent Tree Search). How each pattern performs, fails, and when to choose one over another.

Building a robust tool layer for agents: tool schema design principles (what makes a good tool description), tool namespacing and organisation, synchronous vs asynchronous tools, tool versioning, the tool registry pattern, result formatting for optimal LLM consumption, error handling and retry logic in tool execution, sensitive-tool guardrails, and the 10 most common tool architecture mistakes.

Maximising agent throughput with parallel tool calls: identifying independence in tool call graphs, the fan-out pattern, assembling results from async parallel operations, handling partial failures in parallel batches, deduplication of redundant calls, streaming partial results to the user, the latency model for parallel agents, and real performance numbers from production agentic systems.

The four memory types every agent engineer must understand: working memory (in-context), episodic memory (past interaction records), semantic memory (persistent facts and knowledge), and procedural memory (learned behaviours). How each maps to implementation choices. The memory lifecycle — write, index, retrieve, prune. Why naive context accumulation breaks at turn 20 and what to do instead.

Implementing persistent memory beyond the context window: vector stores for semantic recall (Qdrant, Weaviate, pgvector), key-value stores for structured fact storage (Redis, DynamoDB), graph databases for relationship-rich memory (Neo4j, ArangoDB), the hybrid retrieval pattern for memory, memory importance scoring and forgetting curves, cross-session memory sharing for multi-user agents.

Breaking complex tasks into executable subtasks: hierarchical task networks (HTNs), the BFS vs DFS planning debate, dynamic re-planning when subtasks fail, dependency graph construction for parallel execution, the oracle problem (knowing when a subtask is done), plan validation without human review, and the failure modes of over-decomposition and under-decomposition.

The agent loop in code: the canonical while-loop architecture, turn budgets and token budgets, detecting loop termination (done vs stuck), structured stopping conditions vs open-ended loops, the finish-tool pattern, streaming agent steps to the UI, handling tool errors mid-loop without crashing the agent, context window management across many turns.

Building agents that can pause, resume, and hand off to humans: interrupt points at tool calls, pre-approval patterns for destructive actions, the checkpoint-restore pattern for long-running agents, conversation handoffs between agent and human, asynchronous HITL via webhooks or queues, resuming after days (not just seconds), and the UX patterns for agentic applications with human oversight.

The three fundamental multi-agent topologies: Supervisor-Worker (hierarchical, explicit delegation), Peer-to-Peer (flat, direct agent-to-agent communication), and Debate/Critique (agents challenge each other to improve quality). When each topology wins, how to route tasks between agents, shared state vs message-passing architectures, the consistency problem in multi-agent systems, and real production multi-agent designs.

How agents communicate reliably: message schemas, typed agent interfaces, the message bus pattern, dead-letter queues for failed inter-agent messages, consensus protocols for multi-agent agreement, the coordination problem when two agents target the same resource, event-driven agent architectures, agent-to-agent trust and authentication, and the A2A (Agent-to-Agent) protocol emerging from Google.

LangGraph from conceptual model to production deployment: the graph-as-state-machine abstraction, nodes and edges, conditional routing, StateGraph vs MessageGraph, parallel branches, the interrupt/resume API, persistence with checkpointers (MemorySaver, PostgresSaver), streaming events, LangGraph Cloud deployment, debugging with LangSmith, and the architectural decisions behind choosing LangGraph over a custom loop.

The multi-agent framework landscape compared: AutoGen (Microsoft) with its conversation-centric multi-agent model, CrewAI with role-based crews and task delegation, OpenAI Swarm for lightweight handoffs, the new AutoGen 0.4 async-first architecture. Framework selection criteria, integration patterns, when to use a framework vs build from scratch, and the hidden costs of framework abstraction.

Agentic RAG beyond the basics: CRAG (Corrective RAG) with knowledge refinement, Self-RAG with reflection tokens, iterative retrieval with convergence criteria, the retrieval-reason-refine loop, multi-hop agentic retrieval for complex multi-document reasoning, routing between RAG and parametric knowledge, calibrating retrieval confidence, and when agentic RAG introduces more failures than it solves.

Evaluating agents is fundamentally harder than evaluating single LLM calls. Trajectory evaluation vs outcome evaluation. Turn-level vs session-level metrics. Task success rate, tool call accuracy, over-refusal rate, loop efficiency (turns to completion), cost per successful task. Public benchmarks (SWE-Bench, WebArena, GAIA, AgentBench). Building your own eval harness for domain-specific agents. The LLM-as-judge patterns that work for multi-step agents.

Making agents reliable enough for production: graceful degradation when tools fail, retry budgets with backoff, the dead-end detection problem (when the agent is stuck but doesn't know it), sandboxing side effects, reversible-first action design, minimum-privilege tool scoping, escalation paths to humans, circuit breakers for runaway loops, and the reliability requirements for autonomous vs supervised agent modes.

MCP (Anthropic, Nov 2024) as the USB-C for AI tool integrations: the client-server architecture, the three resource types (prompts, resources, tools), the transport layer (stdio and HTTP/SSE), building an MCP server, consuming MCP servers from agents, the growing MCP ecosystem (filesystem, GitHub, Slack, databases), security considerations for third-party MCP servers, and why MCP matters for the future of agentic systems.

Agents that see and interact with computer screens: the anthropic computer-use API, screenshot-observe-act loops, UI grounding (mapping visual elements to actions), accessibility tree vs pixel-based grounding, latency and cost profile of vision-based interaction, reliability patterns (element verification before click), sandboxed execution environments (Docker, VMs), the Operator model for web automation, and the current limits of computer use in production.

Agents that write, test, and ship code: the SWE-Bench benchmark and what 40% → 50% solve rates actually mean, the scaffolding layers around code agents (file system access, shell execution, test runners, git operations), the edit-test-debug loop as an agent pattern, static analysis integration, the context management challenge for large codebases, Claude Code as a case study, security and containment for code execution agents.

Observability for systems that don't follow a request-response pattern: span trees for agent loops (run → step → tool call → tool result), token and cost attribution across steps, intermediate state capture for debugging, quality scoring at each step, the latency breakdown per turn, real-time streaming event dashboards, alerting on agent failure modes (stuck loops, tool errors, refusals), and the tooling landscape (LangSmith, Phoenix Arize, AgentOps).

Everything that goes wrong when you put agents in production and how to prevent it: rate limit handling across concurrent agent runs, cost explosion from runaway loops (with real numbers), queueing strategies for agent job scheduling, time-out and budget enforcement at the infrastructure level, multi-tenant agent isolation, canary deployments for agent prompt/tool changes, disaster recovery for long-running agents, and the operational maturity model for agentic systems.

The unique attack surface of autonomous agents: indirect prompt injection through tool results (a retrieved document tells the agent to exfiltrate data), privilege escalation when agents have broad tool access, confused deputy attacks, data exfiltration via encoded tool calls, the OWASP Agentic AI Top 10, sandboxing strategies for code and shell execution, network egress controls, the principle of least privilege applied to agent tool scopes, and red-teaming methodology for agentic systems.