What is an Agent?
An agent is a system that can autonomously take sequences of actions — calling tools, reading files, writing code — to complete a goal without requiring step-by-step human instruction.
A model predicts the next token. An agent acts on the world. The difference is autonomy: an agent receives a goal, decides its own sequence of steps, calls whatever tools it needs, and loops until the task is done. You don’t approve each step — you approve the outcome.
What makes something an agent?
Three ingredients separate an agent from a plain model response:
- A goal — a task to complete, not just a prompt to respond to
- Tool access — the ability to read files, run code, search the web, call APIs
- Autonomy — it decides the sequence of actions itself, not you
Strip any one of those three and you no longer have an agent. A model that can answer questions but can’t call tools isn’t an agent. A script that calls tools but needs you to approve each step isn’t really an agent either.
The two meanings of “agent” in GitHub Copilot
⚠️ In GitHub Copilot, “agent” means two completely different things. This is the single biggest source of confusion on this site. Read carefully.
| Agent Mode | Copilot Coding Agent | |
|---|---|---|
| What is it? | An IDE feature for multi-file editing | A separate cloud product |
| Where does it run? | In your IDE, locally | GitHub Actions (cloud) |
| When does it work? | Synchronously, while you watch | Asynchronously, in the background |
| How do you start it? | Switch mode in Copilot Chat | Assign a GitHub Issue |
| What does it produce? | Edited files in your workspace | A pull request |
These are explored in detail on the Agent Mode and Copilot Coding Agent pages.
Agents vs models
A model generates text. It receives a prompt, predicts tokens, and stops. It has no memory, no tools, and no ability to take action between the prompt and the response. What you see is what you get — one shot.
An agent uses a model as its reasoning engine, but wraps it in a loop: observe → plan → act → observe again. The agent reads the state of the world (your files, test results, error messages), calls tools to change it, reads the new state, and repeats until the goal is reached. The model provides the reasoning at each step; the agent provides the persistence.
This means swapping the model inside an agent changes how it reasons, but not whether it acts. An agent with a weaker model is still an agent. A smarter model with no tool access and no loop is still just a model. The distinction is architectural, not about capability.
Third-party agents
Agents aren’t just GitHub’s. Anthropic’s Claude coding agent and OpenAI’s Codex agent are separate products — built by those companies, with their own models under the hood — that you can access from within GitHub Copilot. When you route a task to one of them, you’re asking Copilot to hand the task off to a different agent product entirely.
ℹ️ Public preview: Third-party agents in GitHub Copilot (including Anthropic’s Claude coding agent and OpenAI’s Codex agent) are currently in public preview. Features and availability may change.
Dive deeper
The agent concept only makes full sense in contrast to what came before it. Read What is a Model? first if you haven’t — understanding what a model can’t do is the fastest path to understanding why agents exist.
To see exactly how model and agent differ side by side, the Models vs Agents page is the place to go. For the specific GitHub Copilot implementations, Agent Mode covers the IDE-local experience and Copilot Coding Agent covers the cloud-based, async product.
Related Concepts
- What is a Model? — The reasoning engine inside every agent
- Skills & Tools — The capabilities agents use to act on the world
- What is MCP? — The standard that connects agents to external tools
📍 Layer 2 — The Agent · Back to the AICA Onion
What’s next?
- Models vs Agents — the core distinction, explained side by side