Agents, tools and MCP explained
What makes an AI agent different from a chatbot, and why designers should care.

Zander Whitehurst
8 min read
For a while, using AI meant chatting with it. You asked a question, it replied and you copied the useful bits into your work. That is changing quickly. More tools now describe themselves as agents, and they do far more than reply. They read files, write code, run it, check the result and keep going until the job is done.
For designers, this matters in two ways. Agents are changing how we build, especially as we work closer to code. And agents are increasingly part of the products we design.
Chatbot versus agent
A chatbot takes your message and gives you a reply. If you want something done, you take its answer and do it yourself.
An agent takes a goal and works towards it. It decides what steps are needed, carries them out, looks at what happened and adjusts. Ask it to "add a dark mode toggle to the settings page" and it will find the right files, make the changes, run the project and fix anything that breaks.
A chatbot is like asking a colleague for advice over coffee. An agent is like handing them a ticket and letting them get on with it, checking in when they need a decision.
Tools: how an agent takes action
The model at the heart of an agent can only produce text. On its own, it cannot open a file or click a button. What turns it into an agent is access to tools.
A tool is a specific action the agent is allowed to request, such as:
- Reading and writing files. Opening a component, editing it and saving the change.
- Running commands. Starting a dev server or running tests.
- Searching. Looking through a codebase or the web.
- Connecting to other apps. Reading a Figma file, a ticket or a document.
When the model needs to do something, it asks to use a tool. The software around it carries out the action and passes the result back. The model provides the reasoning. The tools provide the hands.
The loop: plan, act, check
Most agents work in a repeating loop:
- Plan. Work out what needs to happen next.
- Act. Use a tool to take that step.
- Check. Look at the result. Did the code run? Does the page match the design?
The loop repeats until the agent decides the goal is met or it needs your input.
This loop is what makes agents powerful, and it is also where they go wrong. If the check step is weak, an agent can confidently march in the wrong direction. Give it a clear way to check its work, such as a screenshot to compare against or tests to run, and it becomes far more reliable. A good check is often worth more than a longer prompt.
MCP: a standard connector
Every tool an agent uses has to be connected somehow. In the past, each AI product built its own custom integrations, and every one worked differently.
MCP, the Model Context Protocol, is an open standard for making those connections. It defines a common way for software to offer tools and information to agents. If an app provides an MCP server, any agent that supports MCP can connect to it.
Think of it like USB for AI. Before USB, every device had its own plug. MCP aims to give agents one standard port for the apps they need to reach.
Figma MCP is a good example. It lets an agent read the structure, variables and components of your design files directly, instead of guessing from a screenshot. I have covered it in depth in a separate post, but it is the clearest illustration of why this standard matters to designers.
Designing with agents
Agents like Claude Code and Cursor are now genuinely useful for designers. You can build working prototypes, adjust real components and test ideas in code without waiting for an engineer. To get good results:
- Give a clear goal. Describe the outcome and what done looks like.
- Share your standards. Project rules files and your design system tell the agent what good means.
- Connect the right sources. MCP connections give it accurate information.
- Work in small steps. One component is easier to review than a full page.
- Review every change. The agent is fast, but you are still responsible for quality.
The first time I handed an agent a real task, I asked it to tidy the spacing on our course pages and went to make a cup of tea. When I came back, it had fixed the spacing, refactored three components I had not mentioned and renamed a file the whole site depended on. Nothing was technically wrong. I just had not told it where to stop. Scope is part of the brief.
We teach this way of working, with Claude Code, Cursor and Figma MCP, in our AI Product Design Bootcamp.
Designing products that include agents
Agents are also becoming features in the products we design. An agent works on someone's behalf, which brings new needs:
- Visibility. Show what the agent is doing and why, not just a spinner.
- Control. Let people pause, stop or redirect the work.
- Approval. Ask before actions that are costly, public or hard to undo.
- Review. Present results so they are easy to check, such as a summary of changes.
- Recovery. Make it simple to undo what the agent did.
The core design challenge is trust. Too many approvals and the agent becomes tedious. Too few and people feel nervous handing anything over. Finding the right balance for each action is a design decision, and designers are well placed to make it.
The takeaway
An agent is a model with tools and a loop. It plans, acts and checks its way towards a goal. MCP gives agents a standard way to connect to the apps they need, including Figma. You can use agents to build faster today, and you will increasingly be designing the experiences that let other people trust them.
Memorisely