agents

ReAct is the pattern behind most tool-using agents. What matters is why interleaving reasoning with actions (and observing results) beats reasoning alone or acting alone. Here is the answer that ties the prompt pattern to real agent behavior.

Tool calling powers every agent. The signal is grasping that the model executes nothing: it emits a structured request your code runs, then you hand the result back. Here is the loop and the details that determine reliability.

Your assistant scores 4.6 out of 5 on every individual turn and still loses the user by turn eight. Per-turn averages hide the failures that actually cancel subscriptions, and here is the session-level eval that catches them.

An emerging alternative to stuffing the window or building an index: keep the context outside the prompt and let the model write code to inspect it, recursing into the pieces. Knowing when it does not pay is most of the score.

Agents get reached for too often. A strong answer pushes past the hype: most tasks are better served by a single structured call, and agents pay off only under particular conditions. Here is when one is worth it and how to stop it from compounding errors.

Multi-agent is the pattern most often reached for without cause in AI today. The signal is holding back unless the task genuinely calls for specialization or parallelism, knowing the supervisor and handoff patterns, and grasping why coordination magnifies failure.

MCP standardized how agents connect to tools and data, but tool design is what determines reliability. The signal is knowing what MCP actually standardizes and the principles behind a tool the model can call correctly from its description alone.

Reflection is the pattern in which an agent critiques and revises its own work. The signal is knowing when it truly helps (external feedback grounds the critique) versus when self-critique on its own is theater.

Plan-and-Execute and ReAct are the two leading agent control patterns. The signal is knowing the upfront-plan versus step-by-step tradeoff, why one costs less, and why most production agents wind up blending them.

Context engineering is the discipline that took over from 'prompt engineering' for serious agent work. The signal is grasping that what you place in the context window (and what you omit) shapes behavior more than clever wording. Here is the answer.

Code-execution agents are powerful and risky: arbitrary model-generated code runs on your infrastructure. The signal is genuine isolation (containers/VMs), resource limits, and network/filesystem restrictions, not 'trust the model.' Here is the answer.

Tool selection and parameter extraction are where agents quietly break. The strongest answer treats the tool spec as the only thing the model sees, then repairs the design, not the model. Here is how.

One model can behave completely differently depending on the harness wrapped around it. The signal is recognizing that the scaffolding frequently sets agent quality more than the underlying model does. Here is the answer.

A computer-use agent operates a real browser or desktop via screenshots and clicks. The signal is the perceive-decide-act loop together with the containment for an agent that can click, buy, or delete anything. Here is the answer.

An agent that performs actions is far riskier than one that only talks. The signal is action-level guardrails: least privilege, argument validation, human approval for irreversible actions, and a blast-radius mindset. Here is the answer.

Standard RAG retrieves once and generates; agentic RAG makes retrieval an iterative, reasoning-driven loop. The signal is the agent deciding whether, what, and when to retrieve, then re-retrieving until the evidence holds.

An agent that retries the same failed action 40 times means a runaway bill and a stuck user. Termination is something you build into the harness, not something the model reliably decides. Here is the control layer.

Real tools time out, rate-limit, and hand back malformed JSON. An agent that assumes every call succeeds is a demo, not a product. Here is the error-handling layer that keeps it running in production.

Real users type 'what about the new policy?' with no context. Retrieving on those four words yields noise. Here is how strong systems disambiguate before they ever reach the retriever.

When a chain of LLM calls and tools yields a wrong final answer, 'the model was bad' is not a diagnosis. You need visibility into every step. Here is the tracing layer that turns a black box into something debuggable.

Frameworks promise speed and hand you abstraction you'll eventually fight. Rolling your own is more code but full control. Here is the honest tradeoff, and why many production teams end up thinner than they started.

The industry uses 'agent' for anything that calls an LLM. The distinction that matters is how much control you hand to the model, and more autonomy is not better. Here is the spectrum and the decision rule.

A live-coding round that tells apart engineers who have shipped agents from those who have only read about them. Interviewers want a genuine plan-act-observe loop, tools that query a real SQL database, guardrails that block the obvious failures, and a concrete evaluation plan, rather than one prompt masquerading as an agent.

Linear agents lock into one path and can't backtrack. Tree-of-Thoughts and LATS add search over reasoning paths. The signal is knowing what they buy, what they cost, and when a cheaper loop wins.

A context window is not memory. Real agents need a storage architecture: working buffer, episodic recall, and consolidated facts. The signal is the read/write paths and how you keep memory from decaying.

Tools fail: timeouts, rate limits, bad arguments, garbage output. A naive agent retries blindly or quits. The signal is classifying errors and matching each to the right recovery, with hard caps.

Multi-agent systems coordinate through handoffs and shared state. The signal is knowing the orchestration topologies, what a clean handoff protocol carries, and why naive multi-agent often loses to a single good agent.

Most people know MCP exposes tools. The deeper signal is the complete primitive set (resources, prompts, sampling, roots) and the patterns: server composition, sampling for nested LLM calls, and scoping access safely.

Final-answer accuracy conceals how an agent got there. The signal is trajectory-level metrics: tool-selection and argument accuracy, step efficiency, and matching against reference paths, plus when exact-match is the wrong yardstick.

Per-step accuracy looks fine, yet a 50-step task fails. The signal is grasping compounding error and the techniques (decomposition, verification, checkpointing) that keep long-horizon agents from collapsing.

Agents can critique and retry their own work. The signal is knowing how Reflexion's verbal feedback loop operates, when self-critique genuinely helps versus when it is theater, and what makes it real.

Autonomous agents still need humans at the right moments. The signal is designing checkpoints: where to interrupt, what to surface, how to persist and resume state, without reducing the agent to a click-through rubber stamp.

Any content an agent reads can smuggle in instructions that hijack it. The signal is knowing why filtering can't fully solve injection and which containment controls actually bound the damage when it succeeds.

Agents re-send growing context every step, so cost scales worse than linearly. The signal is knowing where the tokens go and the levers (caching, model routing, context trimming, step caps) that shrink the bill.

Screen-driving and browser agents break in ways chat agents never hit: stale DOM, pages that keep shifting, misplaced clicks. What interviewers watch for is the grounding and reliability methods that move a flaky demo toward something dependable.

The CRM says the balance is $0 and the ledger says $412. An agent left to its own devices will average them into something confident and wrong. Designing the precedence before the model has to guess is the whole answer.

An hour-long agent run is a distributed workflow wearing an LLM hat. The signal is designing serializable state with step-level checkpoints, and knowing why resume is easy while replaying a side effect is not.

Tool calling costs one LLM round trip per action. Code costs one round trip for a loop over 500 records. The signal is knowing exactly what you trade away when you let the model write the program instead of the call.

Interviewers ask about these by name and listen for whether you have read the source or only the README. The signal is explaining the runnable interface, why an agent needs a cyclic graph rather than a chain, and what the layers hide.

Agent latency is a step-count problem disguised as a speed problem. The winning move is removing round trips, not shaving milliseconds off each one, and knowing which step you can delete is the whole interview.

A proactive agent runs on a trigger, with no human watching at the moment of action. That inverts the risk model, and the interviewer is listening for whether you separate notifying from acting.

The agent loop assumes an observation is a short string, and images break that assumption in both directions. The signal is a context policy that keeps pixels out of the transcript and a verification step for the files the agent produces.

Everyone says 'cap the budget'. The signal is the enforcement mechanism: a budget object that travels with the run, checked before each call rather than after, with reserved headroom for a final answer and correct accounting across sub-agents.

The runaway loop gets all the attention. The failure that actually ships is the agent that declares victory on step 4 with half the work missing. The signal is a finish tool the harness can reject, and a completion check that reads the artifact instead of taking the model's word for it.

Agent PR volume scales with compute; human review capacity does not. Most candidates answer 'add an AI reviewer' and miss the real design problem: deciding which changes deserve human judgment at all. Interviewers want a risk-tiered pipeline you would trust in production.

Every agent is a loop around this function. The candidates who fail it raise an exception on a bad tool call; the ones who pass hand the error back to the model as a tool result and let it fix itself on the next turn.

The modern agentic system-design question. The signal is the plan, search, read, synthesize, verify loop with per-claim citations, plus keeping cost and latency bounded. The hard parts are not the writing.

Support is the flagship applied-AI use case, exercising agents, RAG, tools, and the critical human handoff. The signal is knowing when to answer, when to take action, and when to escalate, safely.

AI code review succeeds or fails on precision: a handful of noisy comments and the team silences the bot for good. The signal is grounding in the diff plus repo context, unforgiving false-positive control, and winning developer trust one accepted comment at a time.

Code migration is a high-value agentic task with a strict correctness bar: the migrated code has to still work. The signal is grounding in the real repo, transforming in verifiable chunks, and gating on tests, never one huge LLM rewrite.

The trap is swapping the classifier for an LLM. The real-time, imbalance, and adversarial constraints stay put. The signal is a hybrid: a fast calibrated model scores inline, LLMs investigate the gray zone off the hot path.

A Devin-style agent that carries an issue all the way to a merged PR is the hardest kind to make reliable, since every step can fail and errors pile up. Here is the architecture and the loop that keeps it honest.

An agent that clicks through a real website is slow, brittle, and a single wrong click away from a costly mistake. The architecture comes down to perception, action, and guardrails around irreversible steps. Here is how to build it.

'What was revenue by region last quarter?' looks like text-to-SQL, yet production analytics agents break on ambiguity, wrong joins, and confidently wrong numbers. Here is the architecture that makes the answers trustworthy.

With direct injection the user attacks the prompt. With indirect injection the payload sits inside a page, doc, or email the model reads. The signal is recognizing that retrieved and tool data is untrusted and can hijack the model. Here is the answer.

When an agent holds private data, reads untrusted text, and can talk to the outside, injected instructions can steal data. This 'lethal trifecta' is the defining agent vulnerability. The fix is architectural, not a better prompt.

The number is bait. Interviewers use this to see whether you treat a benchmark delta as a decision or as a claim to be audited, and whether you can price latency, cost, and on-call burden against accuracy. Here is the answer that scores.

The classic closer, and most candidates answer it with a horoscope or a list of tool names. The signal is whether you hold an actual view, can justify it from what is already happening, and know what it means for the job.