Agent vs. Assistant vs. Copilot: Three Ways to Delegate to AI
An assistant answers, a copilot suggests inside your task and an agent runs steps on its own. How to tell them apart and what design each one needs.
Where is the line?
The difference is not in the brand or the technology. It is in who runs the steps. In an assistant, the person does almost all the work and the AI answers. In a copilot, the person keeps carrying the work and the AI proposes the next step without taking it. In an agent, the AI decides and runs steps on its own, uses tools and adjusts what it does based on the results.
Anthropic gives a useful technical definition: agents are systems where the model dynamically directs its own process and tool usage, while in workflows the model and tools are orchestrated through code paths defined in advance (Building effective agents). What makes something an agent is who chooses the steps, not how many calls it makes to the model.
Product names do not help. In an October 2024 post, Microsoft described Copilot as “your personal, private assistant” and agents as systems that operate autonomously on behalf of a process or a company (Microsoft). In GitHub’s documentation, on the other hand, a single product, GitHub Copilot, has an “assistive” mode (it suggests code as you type and you review and apply each suggestion) and an “agentic” mode (you describe a goal and Copilot can work through multiple steps, while you remain responsible for reviewing and approving) (GitHub Docs). For more on that tool, see GitHub Copilot.
These categories are a way of thinking about design, not an official classification. One product can have all three, and each mode asks for a different kind of control.
What changes in each mode?
| Aspect | Assistant | Copilot | Agent |
|---|---|---|---|
| Who starts it | The person, with a question | The person, while writing or editing | The person, with a goal |
| Who executes | The person | The person, with suggestions | The system, with tools |
| Unit of work | One answer | One suggestion | A task with several steps |
| Main control | Edit or discard the answer | Accept or ignore each suggestion | Approve actions and review the result |
| Typical risk | A wrong answer someone copies | A suggestion that distracts or gets accepted unread | A wrong action that changes something real |
What kind of design does each one need?
- Assistant: a clear input field, a readable answer, citations or sources when they matter, and a simple way to ask for another version. If the assistant lives inside a screen, see inline AI.
- Copilot: discreet suggestions that appear where the person is already looking and can be ignored at no cost. If they interrupt, people turn them off. AI autocomplete is one example.
- Agent: visible progress while it works, approval points before actions that change data, a log of what it did and a real way to undo it.
The agent is the one that needs trust design the most. Its loop of steps and tools is explained in the agent loop article: the model evaluates, requests tools, receives the results and repeats until it finishes (Agent SDK, Anthropic). The more it acts without asking, the more it matters that the person understands what happened and can correct it. That is what the levels of autonomy, action approval and undoing agent actions are for. If you need the base definition, it is in what is an AI agent.
How do you decide which to use?
Ask first what the person wants: an answer or a result.
- If they need an answer they will use themselves, an assistant is enough.
- If they are doing something and want help in the moment, without switching tasks, a copilot works.
- If they want something to get done, with several steps, tools and changes in real systems, you need an agent with controls.
A common mistake is putting an agent where an assistant would do. That adds latency, cost and risk with no benefit for the user. Anthropic recommends finding the simplest solution that works and increasing complexity only when needed.
An agent is also a poor fit when the cost of an error is high and there is no way to review it before it happens, or when the task is so short that the person does it faster by hand.
How is the change of mode made visible?
A product can move from assistant to agent without the person noticing, and that is a design problem. If a question that used to receive only an answer starts creating files or sending messages, the person needs to know the mode changed. Useful signals: a label that says it can make changes, a confirmation step the first time and a visible log of what was executed. The practical rule is that the person always knows who is acting: themselves, a suggestion they can ignore, or the system, which has already run something.
Example
Illustrative example: a product team has three AI features in its design tool. The first, “explain this component,” is an assistant: it answers and the person decides. The second, a layer-name suggester while the person edits, is a copilot: it appears in the side panel and one key dismisses it. The third, “reorganize the button variants and update the pages,” is an agent: it shows a plan, asks for approval and leaves a log to undo. Each one has a different design, even though all three use the same model.
What can you do tomorrow?
Take one function of your product or your workflow and classify it with three questions: does the person want an answer, a result or help in the moment? Write the answer in one sentence. If it is a result, list which actions the system would take and which ones need approval. If it is help in the moment, define how many suggestions per minute are too many. That way you avoid building an agent where an assistant would do.
Common mistakes
- Selling everything as an agent to look more advanced.
- Using a copilot for a task that needs review before it is applied.
- Designing an agent with no way to undo and no action log.
- Mixing the three modes in one interface without making clear who acts at each moment.
- Classifying by product name instead of by behavior: “Copilot” can be assistive or agentic depending on the mode.