Memorisely
AI Product Design

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.

Each step is a tool the model asks to use, and the software around it carries the action out.

The loop: plan, act, check

Most agents work in a repeating loop:

  1. Plan. Work out what needs to happen next.
  2. Act. Use a tool to take that step.
  3. 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.

The loop only stops when the check passes, so a clear way to check is what keeps the agent on track.

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.
Visibility, approval and recovery in one panel, so people can hand work over without feeling nervous.

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.

Keep reading

View all
View all

Optimize your AI for better experiences, not AI slop.

View all

AI Prototyping Skills

Prototype with AI using clean UI patterns and guardrails so flows feel product-grade, not generic template slop.

$99

AI UI Motion Skills

Motion and micro-interaction patterns that make AI-built UI feel designed, polished, and trustworthy in real products.

$99

Fix AI Slop Skills

Spot AI slop early and fix type, spacing, and components so your product looks intentional, not like a template.

$99

AI Responsive Design Skills

Responsive layout patterns for rails, sidebars, and breakpoints so AI-generated UI adapts cleanly from narrow to wide.

$99

AI Dark Mode Skills

Dark theme tokens, contrast, and surfaces that keep AI-generated UI readable and product-grade, not flat gray on black.

$99

AI Color Token Skills

Neutral and primary ramps with clear steps so AI palettes stay systematic, not a random set of accent hex codes.

$99
View all