# The tools agents reach for (and the design layer most setups still miss)

> Claude Code, Codex and Cursor can reach dozens of MCP tools for code, data, deployment and communication, and a growing set of design tools. Most of those design tools cover one layer: accessibility, a Figma file, or how the site looks. This is what agents have available, and what's still missing from most setups.

Source: https://www.thedesignagent.ai/field-notes/the-tools-agents-reach-for · Concepts · 2026-10-03

When a developer sets up Claude Code, Codex or Cursor for a project, they configure the tools available to the agent. A typical setup for a modern web application might include: a GitHub MCP for reading PRs and issues, a Supabase or Postgres MCP for querying the database, a filesystem tool for reading and writing code, a web search tool for documentation lookup, and possibly a Slack or Linear integration for surfacing relevant context.

With these tools, the agent can read the codebase, understand the ticket it's working on, check the database schema, look up library documentation, and query relevant issues. It has access to everything needed to produce technically correct code.

What it usually doesn't have: anything that checks whether the UI it's building will serve the people who will use it.

## What the MCP ecosystem covers today

The MCP ecosystem has grown quickly and covers most of the surfaces a development agent needs to touch. Categories that are well-served:

**Data and APIs.** Database tools (Postgres, Supabase, SQLite), REST API testing, GraphQL introspection. Agents can query real data, test endpoints, and understand schemas.

**Code and version control.** GitHub, GitLab, filesystem access. Agents can read and write code, create PRs, review diffs.

**Project management.** Linear, Jira, Notion. Agents can read tickets, update status, understand project context.

**Communication.** Slack, email. Agents can surface relevant thread context, post updates.

**Deployment and infrastructure.** Vercel, AWS, deployment logs. Agents can deploy, check status, read error logs.

**Documentation.** Web search, docs crawlers. Agents can look up how a library works.

Each of these categories reflects something a developer would reach for when doing their work — and the tools make that reach shorter for the agent.

## The design tools that exist now

When we first wrote this note in May, we called the design category empty. That's no longer true. Scan the MCP registries and skill directories today and you'll find tools that each cover one layer of design:

**Accessibility.** Deque's axe MCP server finds and fixes accessibility violations from inside Claude Code, Copilot and Cursor. Essential, and narrow by design: it tells you whether a screen is *valid* for assistive technology.

**Quality audits.** Chrome DevTools MCP runs Lighthouse, which scores accessibility, SEO and best practices. Again essential, again one layer.

**Design files.** The Figma MCP server gives the agent the components, variables and layout of a real Figma file. It tells the agent what the design *is*, if one exists.

**How the site looks.** Skills like Anthropic's frontend-design and Impeccable shape the agent's styling choices: aesthetic direction, typography, color, polish. They're about designing the site itself.

**Screenshot critics.** A growing number of community MCP servers score a screenshot for "AI slop" or run a generic heuristic pass.

Every one of these is worth having. None of them answers the question that decides whether the UI works: is this the right screen for the person using it, given the job they're trying to do?

> **The gap now:** the ecosystem has tools for accessibility, audits, design files and styling, each covering one layer. What most setups still miss is a design agent in the loop: something that briefs the agent before it builds a screen, reviews the result for job fit, UX and visual quality after, and remembers the project between calls.

## Why single-layer tools came first

The tools that exist for agents map onto surfaces that already had a programmatic answer. Accessibility has WCAG and a mature rules engine. Lighthouse already produced scores. Figma already had an API. Styling guidance fits in a skill file. Wrapping any of these for an agent is relatively straightforward — the data structure exists, the rules exist, the semantics are defined.

Design judgment doesn't have an existing API. There's no endpoint that takes a React component and returns whether it fits the user's job. There's no database of "this layout is appropriate for this job in this domain" that an MCP could query. The knowledge that would power a design judgment tool exists in designers' heads, in pattern libraries, in accumulated domain expertise — not in a structured API waiting to be wrapped.

Building that layer required building the knowledge layer first: a corpus of job patterns, cognitive patterns, and design principles organized by domain; a project memory that holds the personas and jobs for a specific product; a rubric that produces specific, actionable fixes rather than generic advice. That's not an MCP wrapper around an existing tool — it's a design agent.

## What it looks like in the workflow

A design agent works in the loop the way a test runner or a type checker does, but on both sides of the build:

1. **Before the build:** the agent asks for a brief for the screen it's about to build: the user's job, the heuristics and patterns that apply, the project's design tokens.
2. **Build:** the agent writes the UI from the brief.
3. **After the build:** the agent gets a UX review (job fit, heuristics, cognitive load, patterns) and a visual review (brand, hierarchy, aesthetics from a real screenshot), each scored with fixes, applies the fixes and re-checks once.
4. **Across builds:** what the reviews find is remembered, so the next brief starts smarter.

This is the same pattern as test-driven development, except the test is "does this serve the person doing the job" rather than "does this return the expected output." The loop is the same. The feedback mechanism is the same. The thing being checked is different.

Most agent workflows don't have this step today. The agent builds, lints, type-checks, maybe runs an accessibility check, and opens a PR. The design review happens later — in a human review cycle that moves much slower than the build loop. Or it doesn't happen at all, and the UI ships as the agent built it.

That's the gap. TheDesignAgent was built to close it: a design agent in your coding agent's loop, alongside the single-layer tools rather than instead of them. For a wider map of what each tool does, see [the best AI design agents in 2026](/field-notes/best-ai-design-agents-2026).
