A Product Surface for Design Agents
The useful agent interface is not chat. It is a compact set of tools that expose document state, controlled edits and visual verification.
read → act → see
Chat is a good place to express intent. It is a poor substitute for a product API.
A design agent needs to know what is selected, how nodes relate, where the viewport is and what the rendered result looks like. It also needs a constrained way to change content without corrupting the document.
Four steps in the core loop
The core loop is to inspect the document, make a bounded edit, check the rendered result and bring in assets when needed. Current MCP tools expose those operations directly.
A compact interface is easier to reason about than hundreds of UI-level actions. It gives the agent the semantics of the product without asking it to imitate every mouse movement.
- get_editor_state and batch_get: inspect the focused page and nodes.
- batch_design: apply typed document edits as an undoable content batch.
- get_screenshot: inspect a rendered page or node.
- import_image: add image content to Project Assets.
Operations are better than clicks
A click is ambiguous without the current layout and focus state. A typed operation can express exactly which node and property should change.
The human still uses direct manipulation because it is fast and expressive. The agent gets typed, reviewable content operations. Both interfaces meet in the same document history.
Connect external agents through local MCP
The in-product agent uses native document tools directly. The documented local MCP server registers 13 inspection, editing, source, comment and activity tools. Use the command copied by the running app to connect an external agent, and control the local server in Settings.
Both surfaces target the same document, but their contracts are intentionally distinct: the built-in agent gets product-native actions, while external agents get scoped inspection and batch design tools.
Agent-ready is an architectural property
Adding chat after the editor is built can produce useful commands, but deep agency depends on the underlying model. Stable identity, transactions, screenshots and undo have to be designed together.
The interface is only the visible tip. The real work is making every action safe enough that a human can delegate without surrendering control.
The best design-agent API is small, semantic and built on the exact document the human is editing.
The takeaway