Recommended
AI Agents Basics — Timed Test (3 questions)
No account needed. Answers and explanations arrive when you submit.
What this topic tests
The mix every AI Agents Basics set is built to, and the questions published against it so far. Nothing here is hidden before you start.
| Level | Target share | Published |
|---|---|---|
| Easy | 40% | 0 |
| Medium | 40% | 3 |
| Hard | 20% | 0 |
| Total | 3 |
AI Agents Basics — the theory
An AI agent, in the context of modern AI tools, generally refers to a system that can autonomously plan and execute a sequence of actions to accomplish a goal, rather than simply responding to a single prompt with a single response.
How agents differ from simple chat. A basic AI chat interaction is typically one round: you ask something, the model responds with text, and that's the end of that exchange unless you continue the conversation yourself. An agent, by contrast, is given a goal and then autonomously determines the steps needed to achieve it — which might include searching for information, using tools, reading and writing files, calling external services, and evaluating its own intermediate results — often across many steps, with limited or no need for a human to manually direct each individual step along the way.
Core components of an agentic system. Most agentic AI systems combine a few key elements: a reasoning capability (the underlying model, which decides what to do next based on the current state of the task), a set of tools it can use (search, code execution, file access, external API calls, and so on), and some mechanism for tracking progress toward the goal across multiple steps, since a complex task can't usually be completed correctly in a single action.
Planning and iteration. A defining trait of a genuinely agentic system is the ability to plan a sequence of steps, execute them, observe the results, and adjust its plan based on what it learns — rather than following a rigid, predetermined sequence regardless of what actually happens along the way. For example, if a coding agent runs a test and it fails, an agentic system can read the failure, diagnose the likely cause, and adjust its next action accordingly, rather than blindly continuing as if the test had passed.
Tool use. Giving an agent access to tools — the ability to search the web, execute code, query a database, or call external APIs through something like an MCP server — is what allows it to go beyond just generating text and actually take actions with real effects: retrieving current information, modifying files, or interacting with external systems on your behalf.
Autonomy and oversight. Agentic systems vary in how much autonomy they're given. Some are designed to complete an entire multi-step task with minimal check-ins, while others are designed to pause and ask for confirmation before certain kinds of actions — particularly ones that are hard to reverse, like deleting data or sending a message on someone's behalf. Understanding this spectrum matters practically: more autonomy can mean faster completion of routine tasks, but also means more careful thought about what kinds of actions you're comfortable delegating without a check-in.
Where agents are commonly used today. Agentic AI is increasingly used for tasks like software development (an agent that can read a codebase, make changes, and run tests), research (an agent that can search multiple sources and synthesize findings), and various forms of task automation where a goal can be broken down into a sequence of concrete steps that don't all need to be specified in advance by a human.
Limitations and failure modes. Agents inherit the limitations of the models that drive them, and autonomy amplifies the consequences: a wrong assumption early in a multi-step task can compound through every step built on it, and an agent can pursue a misunderstood goal diligently in the wrong direction. Long tasks also strain an agent's ability to keep track of everything relevant. None of this makes agents impractical — it explains the design patterns that surround them: checkpoints where a human reviews progress, confirmation gates before consequential actions, and verification steps that check the work product rather than trusting the process.
Working with agents effectively. Getting good results from an agentic tool is a skill of its own. The goal should be concrete enough to verify — "make the test suite pass" gives an agent a checkable target in a way "improve the code" does not. Constraints worth enforcing should be stated up front, not assumed. And the finished work deserves review proportional to its stakes, exactly as delegated human work does. The mental model that serves best is delegation to a fast, capable, but literal-minded collaborator: clarity in, verification out.
Agents versus ordinary automation. Traditional automation — scripts, scheduled jobs, rule-based workflows — executes a fixed, predetermined procedure and breaks when reality deviates from it. An agent differs in that it decides its steps at run time and can adapt when something unexpected happens. That flexibility is the value and the risk at once: an agent handles situations its author never anticipated, and that same latitude is why oversight patterns matter in a way they don't for a fixed script.
Why this distinction matters. Recognizing whether a given AI tool is a simple chat interface or a genuinely agentic system helps set the right expectations: a chat interface is well suited to answering a question or drafting a piece of text in one pass, while an agentic tool is better suited to a goal that requires multiple steps, some tool use, and adaptation based on intermediate results — and knowing which kind of tool you're using shapes how you should frame a request to it.
Sample questions
Three questions from this topic, with the answer and the reasoning shown.
Q1MediumWhat distinguishes an AI agent from a basic single-turn chat interaction?
- It can autonomously plan and execute a sequence of actions toward a goalCorrect
- It can only ever respond with a single sentence
- It has no access to any tools
- It requires a human to manually type every single step
Explanation
A single-turn exchange has one shape: text goes in, text comes out, and the interaction ends the moment the response is produced. An agent does not stop there. It emits a tool call, something outside the model executes that call, the result is appended back into the conversation, and the model decides its next move with that result in hand. Anthropic puts the pattern plainly: agents are typically just LLMs using tools based on environmental feedback in a loop. The Claude API version of it is a round trip, repeated. Because it is a loop, it needs an exit, which is either the goal being met or a stopping condition such as a maximum iteration count.
So autonomy here is not mysterious. It is three mechanics: the model can request an action instead of prose, your code runs it, and the result re-enters context.
The wrong answers each miss one of those. Response length was never the distinction, so a one-sentence cap is irrelevant. Tools are not absent from an agent; they are the mechanism. And a human typing every step describes ordinary chat, the thing an agent replaces.
Q2MediumWhat is a defining trait of a genuinely agentic system?
- It can observe results and adjust its plan accordinglyCorrect
- It always follows a fixed sequence regardless of outcomes
- It never uses any external tools
- It cannot process more than one step total
Explanation
Taking many steps is not the trait. A shell script takes many steps. What makes a system agentic is that the outcome of step two can change what step three is: the model reads a tool result, sees that the search returned nothing useful or the test still fails, and chooses a different move than the one it had queued.
Anthropic frames this as an architectural split. Workflows are systems where LLMs and tools are orchestrated through predefined code paths, whereas agents direct their own process. The server-side search loop in the Claude API is the miniature version: the model searches, reads results, determines whether to search again, and iterates until it has what it needs. Gemini function calling has the same shape, since the call-and-return process can repeat over multiple turns.
That is why the fixed-sequence option is worth dwelling on rather than dismissing. A pipeline that runs the same steps regardless of outcomes is a workflow, and often the better engineering choice: predictable, cheap to debug. It is simply not agentic. Tools supply the feedback an agent adjusts on, and a one-step system has nothing left to adjust.
Q3MediumWhy might an agentic system pause and ask for confirmation before certain actions?
- Because some actions are hard to reverse, like deleting data or sending a messageCorrect
- Because it is incapable of taking any action at all
- Because confirmation is required before every single word generated
- Because agents cannot use tools without approval
Explanation
Reversibility is the axis. Reading a file, running a search or listing a directory can be got wrong cheaply; the cost is a wasted turn. Deleting a table, moving money, or sending a message to a real person cannot be undone by trying again. Google warns against computer use for actions where serious errors cannot be corrected, and OpenAI's guidance for computer-use agents lands in the same place: let the agent do as much safe work as it can, then pause exactly when the next action would create external risk.
Production permission systems draw that line in code. A Gemini computer-use response can carry a safety decision marking an action require_confirmation before your client runs it. OpenAI names deleting data, changing sharing settings or API keys, and sending anything to a third party as always-confirm.
Notice how narrow the real rule is. Confirmation targets consequential actions; it is not requested per generated word, which would make the system unusable, and it is not demanded for every tool call. An agent that pauses is obviously capable of acting. Pausing is a judgement about when, not an inability.
Practise all 3 questions
Every published question in AI Agents Basics, with its answer and explanation.