Agent & Subagent Questions (2026)
Covers AI agents, agentic AI, and subagents. See also all interview topics. These assume you already know the concept — if a section here is unfamiliar, read its linked concept page first; the questions test judgment on top of the concept, not the concept itself.
In this guide
AI Agent
What stops an agent loop from running forever?
The model itself deciding the task is done isn't a safety net you can fully rely on — real systems also enforce a hard limit: a maximum number of steps, a timeout, or a check that catches when the agent has stopped making progress and is just repeating itself.
Is a chatbot that calls one tool and answers an "agent"?
Not really, if it always calls the same tool the same way and stops — that's closer to a single-step workflow with one tool bolted on. It becomes agent-like once the model is choosing whether and which tool to call, and can decide to take more than one step based on what it finds.
Does using an agent always cost more than a single model call?
Per request, usually yes — an agent makes several model calls and often several tool calls before it's done, where a single call makes one. But compare total cost, not per-request cost: a workflow that breaks the moment reality doesn't match what was coded often costs more once a person has to step in and fix it by hand.
Beyond being wrong, how do agents typically fail in practice?
Getting stuck — retrying the same failed action, or drifting through steps without making real progress toward the goal. That failure mode looks nothing like a wrong answer; the agent just never stops, which is exactly why step limits and progress checks matter as much as getting each individual decision right.
Agentic AI
Your team swaps in a much more powerful model but leaves every step of the pipeline exactly as fixed as before. Did the system just become more agentic?
No. Agentic-ness is a property of how much the surrounding application lets the model decide, not of how capable the model is. The same top-tier model can sit inside a fully scripted pipeline or a fully autonomous one — swapping the model changes answer quality, not who's in control of the next step.
A tool takes a text prompt and returns one generated image, then stops. Is that agentic AI?
No — that's generative AI with no decision-making layered on top. One prompt in, one output out, nothing to decide between. It would start becoming agentic only if the system judged its own output, decided to try again with a different approach, or took a further action based on what it produced.
Your manager says "let's make this system more agentic." What's the first question you'd ask back?
Which specific step, currently decided by code, should be handed to the model instead — and what happens if the model gets that particular choice wrong. "More agentic" isn't a single toggle; it means moving one identifiable decision from fixed logic to the model, so the useful question is which decision, not whether to flip a switch.
A system is free to search internal documentation and draft a reply on its own, but must get a person's sign-off before sending anything externally. Does that restriction mean it isn't really agentic?
No — autonomy within boundaries isn't a contradiction, it's a design choice. A system can genuinely decide its own steps for everything up to the boundary and still count as agentic; requiring approval for one specific, higher-stakes action doesn't roll it back to a fixed workflow.
Someone wants an agentic system to auto-approve expense reports under $50 — check the receipt, check the policy, approve or reject. Is that a good use of an agentic design?
Probably not. The steps are already fully known — there's no point where the right move depends on something that can't be predicted in advance — so a fixed workflow handles it more cheaply and more predictably. Handing that decision to a model adds a place for it to go wrong without buying anything, since nothing about the task actually needs judgment along the way.
Subagent
Two subagents are running in parallel and one needs information the other is finding out. How do you handle that?
You mostly don't — that's outside what parallel subagents are for. Each one runs in its own isolated context with no direct channel to the other, so if a task genuinely needs subagents to share information mid-work, either run them one after another so the second one gets the first one's result as input, or that part of the task isn't actually independent enough to split into parallel subagents in the first place.
Two parallel subagents are both told to edit the same file. What goes wrong?
Whichever one finishes last silently overwrites the other's changes, since neither knows the other is running. Parallel subagents are safe for independent reads and independent output, not for writes that can collide — a task that needs two agents editing the same file should be sequential, or split so each owns a different file.
How do you decide whether a task is one subagent's job or should be split into several smaller ones?
Split it when the pieces are genuinely independent and one piece failing shouldn't block the others — that's also what makes parallel execution possible. Keep it as one subagent when the steps depend on each other in order, since splitting a naturally sequential task just adds coordination overhead for no benefit.
Should a subagent's tool permissions ever be broader than the agent that spawned it?
No — that would let a delegated task reach further than the task that delegated it, which defeats the reason for scoping a subagent's tools in the first place. A subagent's permissions should be equal to or narrower than its parent's, never wider.
If a subagent's summary turns out to be wrong, how would the parent agent know?
Often it wouldn't, unless there's some independent way to verify the result — that's the core tradeoff of context isolation. Some designs mitigate this with a separate review pass rather than trusting a subagent's self-report.
How is a subagent different from a tool call?
A tool call executes a fixed function and returns data. A subagent is a full agent — it can reason, plan, and make its own tool calls — before returning a result. Its job is open-ended within its scope; a tool call's isn't.
Multi-Agent System
You're building a system to summarize 50 independent survey responses. Good candidate for a multi-agent approach?
Probably not. The responses are independent, so they could run in parallel, but summarizing 50 short responses is already cheap and fast for one agent. Paying a roughly fifteen-times cost multiplier only makes sense when the task is genuinely slow or expensive to do sequentially — not just because the pieces happen to be independent.
Two agents return confident but different answers to the same subtask. What does that tell you about your design?
That a reconciliation step is missing. Agents disagreeing isn't a bug to patch afterward — a real multi-agent design decides upfront how conflicts get resolved, whether that's a lead agent adjudicating or a defined tie-breaking rule.
Does adding more agents always mean more parallelism?
No. Agents can also be organized hierarchically, with one coordinating several, or sequentially, with one agent's output feeding the next — neither of which runs anything at the same time. Parallel execution is one benefit a multi-agent system can offer, not a defining feature of having more than one agent.