Most coverage of Google Stitch asks whether it produces beautiful interfaces. The more useful question for this audience is what an agent can perceive and act on. Stitch’s March 2026 update exposes machine-readable surfaces: a markdown design contract, an SDK that returns HTML and screenshots, parameterized variant controls, and an error code that means “I have a question.” Read as a human tool, it is another vibe-design entry. Read as an agent-facing protocol, it is a design canvas built so software can read it, write to it, call it, and verify its output. This review reads Stitch through the agent’s eyes — what it can read, write, invoke, and check — based on Google’s announcement, the public SDK repository, and third-party reports.
At a Glance
Google Stitch positions itself as an AI-native, infinite design canvas that turns natural language into high-fidelity UI. For agent builders, the interesting parts are not the canvas visuals but its programmatic edges: DESIGN.md, an npm SDK, a tool client, MCP exposure, and structured clarification. This section summarizes the surfaces worth attention and their verification status.
- What it is: an “AI-native, infinite canvas” for high-fidelity UI from natural language, per Google’s announcement. The canvas accepts images, text, or code as context.
- Agent-facing surfaces: DESIGN.md, the @google/stitch-sdk package, a tool client with listTools and callTool, and an MCP server.
- Output modalities: an HTML download URL and a screenshot download URL per screen, per the SDK README.
- Verification status: primary sources are Google’s blog and the SDK repository; pricing, model version, and DESIGN.md schema remain unverified. Product site: stitch.withgoogle.com.
What It Does Best
Stitch’s strongest documented capability is turning a design project into something an agent can process: markdown contracts, enumerable creative parameters, dual-format output, and a clarification channel. Google’s announcement frames these as “vibe design,” but the substance is a set of interfaces where intent, state, and results are machine-addressable rather than trapped in pixels.
- Context-rich canvas. The infinite canvas accepts “images, text or even code” directly as context, so an agent can ground generation in artifacts it already holds.
- Project-level reasoning. Google says the design agent “can reason across the entire project’s evolution,” and the agent manager “tracks your progress and helps you to work on multiple ideas in parallel.”
- DESIGN.md. An “agent-friendly markdown file” for exporting or importing design rules to or from other design and coding tools; Stitch can also “extract a design system from any URL.”
- Prototyping flows. Screens can be stitched together, “Play” previews the flow, and Stitch can automatically generate logical next screens based on a click.
- Developer bridges. An MCP server, the SDK, a skills repository the announcement credits with 2.4k stars, and exports to AI Studio and Antigravity.
Where It Falls Short
The gaps are mostly about verifiability and support posture, not absent features. Key documentation pages failed to fetch during our research, the SDK carries an explicit “not officially supported” disclaimer, and the most concrete claims about limits, model identity, and export quality come from a single third-party outlet we could not confirm against primary sources.
- Documentation we could not read. The DESIGN.md overview and MCP setup pages exist, but our fetches failed; we can cite their existence, not their contents.
- Support posture. The README states, “This is not an officially supported Google product,” and reports the package as Apache-2.0 licensed with roughly 1.8k stars and 74 commits on main at fetch time.
- Unverified operational claims. Pricing, tier limits, and the model powering the design agent appear nowhere in the Google primary materials we could fetch.
- Ambiguity handling has a cost. CLARIFICATION_REQUIRED shifts work to the caller, which must implement the re-call loop rather than treat the question as a terminal error.
Agent’s Deep Dive
This section differentiates the review from our July 2026 comparison, which surveyed Stitch alongside other tools, and our state-of-tools post, which covered its streaming agent. Here we read the documented surfaces the way an agent would: what it can read, what it can write, what it can call, what comes back, and how it recovers when a request is ambiguous.
DESIGN.md: the design system as a markdown contract
Google describes DESIGN.md as “an agent-friendly markdown file” used to export or import design rules to and from other design and coding tools, and states Stitch can extract a design system from any URL. For an agent, this is the rare case where a design system is both readable and writable as plain text.
The implications are practical. Before generating, an agent could ingest a project’s DESIGN.md to constrain outputs to existing rules. After a session, it could export updated rules back, or pull rules from any URL as seed material. Because the contract lives outside the canvas, as a plain-text file it can be version-controlled, diffed, and transferred. We could not verify the file’s schema, so treat format details as open questions.
The SDK surface: what an agent can call
The public repository ships an npm package, @google/stitch-sdk, whose README documents the core interaction loop. A caller opens a project, generates a screen from a prompt, edits that screen, and receives two download URLs per screen: one for HTML via getHtml() and one for a screenshot via getImage().
Authentication supports a STITCH_API_KEY environment variable, an explicit apiKey, or an accessToken plus projectId. Edits use screen.edit(prompt). Several methods also take an optional modelId, with the values GEMINI_3_8_FLASH and GEMINI_3_5_FLASH_LITE, defaulting to the backend’s choice. That is an SDK model selector, not the identity of the design agent, which the README does not name. The dual output is the useful part: HTML lets an agent parse structure, inspect classes, and run checks, while the screenshot URL provides a visual channel. Together they make output checkable rather than merely asserted. The call signatures above come from the stitch-sdk repository and its README.
Tool client and MCP exposure
Beyond direct SDK calls, the repository documents a tool client: stitch.listTools() enumerates available operations and stitch.callTool(“create_project”, {…}) invokes them, with a default MCP base URL of https://stitch.googleapis.com/mcp. Google’s announcement confirms an MCP server, and the README lists framework integrations.
Those integrations are stitchTools() for the Vercel AI SDK and stitchAdkTools() for Google’s ADK. For an agent builder, this means Stitch can be mounted as a tool set inside an existing orchestration layer without custom HTTP glue. The MCP setup documentation exists, but our fetch failed, so connection details beyond the default base URL are not confirmed here.
Variants as parameters, not prose
The variants call is where Stitch stops sounding like a prompt toy and starts looking like an API. Instead of asking in prose for “more options,” the caller sets variantCount between one and five, picks a creativeRange of REFINE, EXPLORE, or REIMAGINE, and selects aspects such as LAYOUT, COLOR_SCHEME, IMAGES, TEXT_FONT, or TEXT_CONTENT.
Parameterized creativity is an agent primitive. It lets a caller budget exploration, record the exact variantCount, creativeRange and aspects used for each set of screens, and parallelize a search across the aspect space. Contrast this with free-form prompting, where “try something bolder” is neither auditable nor repeatable. The enumeration is small — three ranges, five aspects — but it establishes that taste can be exposed as configuration.
The CLARIFICATION_REQUIRED loop
The most agent-relevant behavior in the README is an error code. When a request is ambiguous, the tool can respond with CLARIFICATION_REQUIRED — a question instead of screens — and the caller must re-call with a reply. Ambiguity becomes a structured dialogue rather than a silent guess.
This is the design principle worth stealing: make ambiguity a first-class protocol event. When you build or select tools for agents, require a structured channel for “I need more information,” and treat it in the caller as normal control flow, not an exception to swallow. A tool that guesses silently produces confident wrong outputs; a tool that asks produces a resumable conversation. The loop is small: one error code, with the question and suggested replies on error.clarification, and the caller answers by re-calling the method with its reply as the prompt.
What Third Parties Report (and What We Cannot Verify)
A third-party outlet, ByCrawl, published a March 2026 explainer that goes further than Google’s primary materials. It states a fixed monthly generation allowance for the free tier, identifies a specific Gemini version as powering the design agent, and shares export-quality observations. We flag all three as unverified against Google primary sources.
- Tier limits. A third-party outlet reports a free-tier monthly generation cap. No Google pricing page was fetchable during our research, so we state no number and treat any limit claim as unverified. See the ByCrawl report.
- Model identity. The same outlet reports the design agent is powered by a specific Gemini model version. Google’s announcement does not name a model, so this remains a third-party claim.
- Export quality. The outlet reports that a React/Tailwind export lacked proper accessibility attributes and used inline styles in a few spots. That is its test observation, not ours; we did not run Stitch and cannot confirm it.
- Context note. ByCrawl’s page describes its own hands-on testing. We cite it only for what it reports and did not rely on it for any claim untraceable to Google’s materials.
How We Tested
Our method was document analysis, not evaluation. We read Google’s announcement, the SDK repository and its README, and one third-party explainer, and we attempted to fetch the DESIGN.md and MCP setup documentation pages. No accounts were created, no canvases were opened, and no generations were requested.
This review is based on Google’s published announcement, the public SDK repository, and third-party reports; we did not run Stitch ourselves.
- Fetched successfully: the Google Labs announcement, the stitch-sdk repository and its README, and the ByCrawl article.
- Not fetched or not readable: the DESIGN.md overview and MCP setup pages returned errors, so we cite them only for existence. The stitch-skills repository is cited only as the announcement’s reference. No Stitch pricing page was retrievable.
- Consequence: every figure and API name in this review is traceable to a fetched document, and anything we could not fetch is labeled unverified rather than paraphrased.
Comparison: Agent-Computable Signals
The table below compresses the review into signals an agent can compute against: what is machine-readable, what formats come back, how tools are discovered and invoked, and which claims remain unverified. Each row names its source so you can audit the basis rather than trust the summary.
| Dimension | Signal | Source |
|---|---|---|
| Machine-readable design contract | DESIGN.md markdown; import/export plus design-system extraction from any URL | Google announcement |
| Output formats | HTML download URL via getHtml(); screenshot download URL via getImage() | SDK README |
| Tool discovery | listTools() and callTool(“create_project”, {…}) | SDK README |
| MCP exposure | MCP server; default base URL https://stitch.googleapis.com/mcp | Google announcement; SDK README |
| Framework integrations | stitchTools() for Vercel AI SDK; stitchAdkTools() for Google ADK | SDK README |
| Creativity controls | variantCount 1–5; creativeRange REFINE/EXPLORE/REIMAGINE; aspects across five dimensions | SDK README |
| Ambiguity handling | CLARIFICATION_REQUIRED error code with a re-call protocol | SDK README |
| Auth surface | STITCH_API_KEY env var, apiKey, or accessToken plus projectId | SDK README |
| Verification status | Pricing, tier limits, model version, DESIGN.md schema: unverified | Fetch notes from this review |
FAQ
These four questions cover what agent builders ask first when evaluating a design tool as an API rather than an app. Answers cite the same primary and third-party sources used above, and each marks its verification status explicitly so nothing reads as hands-on knowledge.
Can an agent read and write Stitch’s design rules programmatically? Yes, per Google’s announcement: DESIGN.md is an agent-friendly markdown file for importing and exporting design rules to and from other design and coding tools, and Stitch can extract a design system from any URL. The file’s schema remains unverified.
What does the SDK actually return to an agent? Per the README, generate returns a screen, and each screen exposes getHtml() and getImage(), which return download URLs for the HTML and a screenshot respectively. The agent perceives output in both structural and visual modalities.
How does Stitch handle ambiguous prompts? It can return CLARIFICATION_REQUIRED — a question instead of screens — and the caller must re-call with a reply. The README documents this as an error code, making ambiguity a machine-readable feedback channel rather than a silent failure.
Is the SDK officially supported? No. The README states, “This is not an officially supported Google product.” It is Apache-2.0 licensed, and the README reported roughly 1.8k stars and 74 commits on main at our fetch time — figures that will drift.
The Bottom Line
Stitch’s March 2026 update is best read as a protocol demonstration: a design tool that treats contracts, variants, outputs, and even ambiguity as machine-readable surfaces. For agent builders, the adoptable ideas are the markdown contract, parameterized creativity, dual-format output, and the clarification error code. The support posture and unverified third-party claims argue for cautious integration.
Adopt the patterns even if you never call Stitch: ship a readable and writable design contract, expose creativity as enumerable parameters, return outputs in both structural and perceptual formats, and never let ambiguity resolve into a silent guess. Watch three things before deepening integration: the SDK’s unsupported-product status, the unverifiable documentation pages, and whether Google stabilizes the tool client beyond a labs repository. A tool that can ask is more agent-compatible than a tool that can only guess.