Google’s Stitch appears to be taking a quiet but calculated step toward making AI-driven design workflows more operational and developer-friendly, with new test features spotted in recent builds that include a
Hatter agent, automated
App Store asset generation, and native
MCP (Model Context Protocol) integration for export to coding tools. The discoveries—reported in development-channel builds on February 16, 2026—don’t yet represent public product launches, but they sketch a coherent product trajectory: Stitch is moving from single-shot UI generation toward multi-step, agentic design reasoning and a smoother handoff between design and code. That shift matters for designers, indie developers, and product teams that want faster iteration loops and fewer tool hand-offs when turning ideas into functioning apps.
Background
What is Stitch and where did it come from?
Stitch is Google’s AI design tool introduced as a rebrand and evolution of Galileo AI at Google I/O 2025. Since launch, the product has positioned itself as a multimodal UI generator that pairs prompt-driven creativity with export paths (notably Figma export) and plugin-style connectors. Early agents like
Flash Agent and
Pro Agent focused on rapid layout generation and higher-fidelity output respectively. In February 2026, Google publicly rolled out the
Ideate agent—a tool optimized for early-stage exploration—demonstrating the company’s intention to expose multiple, role-specific agents inside the same product.
Where these new features were first seen
The recent additions—Hatter, App Store asset generation, and a built-in MCP setup—were observed in development builds and community reconnaissance on February 16, 2026. These signals come from testers and build trackers rather than a public Google announcement, which means they should be treated as early-stage features under active development rather than finished, supported capabilities.
Overview of what surfaced in the update
- Hatter agent: A new agent option in Stitch’s mode selector described with the tagline “create high-quality designs.” It appears alongside Flash, Pro, and Ideate agents.
- App Store Asset Generation: A tool that can automatically create app store-ready assets—multiple screenshots, descriptive text, and an icon—directly from a design prototype.
- Native MCP Integration: A first-party MCP setup in Stitch’s export menu that can generate an API key and connect Stitch to MCP-aware coding tools such as CLI-based assistants and code-focused agents.
Each addition aligns with a broader pattern: Stitch is building toward deeper, longer-running design tasks and tighter integration with developer workflows.
Hatter agent: what it appears to be, and why it matters
What we know so far
Hatter is labeled an
agent rather than simply a model or style option. In current builds it produces outputs that look similar to the standard design flow, but the “agent” label is telling: it implies multi-step task handling, chaining, or stateful workflows rather than a single prompt->result pass.
Why Google might be introducing Hatter
- Multi-step workflows: Agents, by definition, are suited to multi-turn interactions that require context tracking, planning, and conditional decision-making. Hatter could be intended to orchestrate tasks like iterative refinement, cross-screen consistency checks, or feature-driven composition (e.g., building onboarding flows, responsive variants, and localized strings in one pass).
- Deep Design synergy: Public signals suggest Google is exploring a Deep Design capability—an analog to their Deep Think reasoning systems—aimed specifically at UI generation. Hatter could be the operational face of such an approach: applying deeper reasoning about user flows, accessibility constraints, and design systems rather than just pixel layout.
- Higher-level primitives: Rather than returning only screens, Hatter may eventually expose higher-level design outputs: interaction maps, component inventories, or behavior annotations that feed into developer tooling.
Early user implications
- Designers could get a more sophisticated creative partner that reasons about flows and state rather than static screens.
- Product teams may see reduced iteration friction if Hatter can carry context across multiple design tasks (e.g., maintain brand constraints across different screens).
- For now, outputs look similar to Stitch’s baseline generation, so the main value today is potential rather than realized capability.
App Store asset generation: practical shortcut for mobile prototyping
What the feature does
The App Store asset generation tool aims to automatically produce a set of storefront-ready assets from a single Stitch project, including:
- Multiple screenshots tailored to mobile app store display conventions.
- Short descriptive copy or captions for each screenshot.
- A square/rounded app icon suitable for store submission and preview cards.
Why this is a meaningful addition
- Saves context switching: Designers currently prototype UI in one tool and prepare marketing assets in another. Generating store-ready visuals directly from the design saves time and keeps visual fidelity consistent.
- Faster prototypes to demos: Indie developers and small teams often need a quick way to produce compelling listings for beta testers or press. Automated assets accelerate that path.
- Standardized variants: Store listings frequently require several sizes and orientations; an automated pipeline can produce correctly cropped and device-mocked screenshots that adhere to platform guidelines.
Limits and caveats
- Copy quality: Automated descriptions will require human editing. AI-written store copy can be a good starting point but often needs tightening for discoverability and legal compliance (e.g., claims and trademarks).
- Platform nuance: Apple App Store, Google Play, and other stores each have subtle rules and expectations for screenshots, text length, and iconography. True store readiness will likely require manual checks.
- Localization: Generating localized screenshots and copy is possible but requires explicit support; design tools that ignore localization will produce assets that miss global market requirements.
Native MCP Integration: streamlining handoffs to coding tools
What MCP is and why it matters
MCP—Model Context Protocol—is an emerging standard that lets tools exchange model context and task definitions, effectively enabling design tools to connect to coding agents and runtime environments. Previously Stitch users relied on third-party bridges and community connectors to move assets and context into code-focused assistants. A
first-party MCP implementation inside Stitch would:
- Generate an API key for the Stitch MCP server.
- Enable one-click connections from tools like Cursor, Claude Code, Gemini CLI, and others that support MCP.
- Allow code agents to request design context, export assets, and in some cases retrieve component metadata and style tokens.
Practical benefits
- Lower barrier to automation: Developers can pull design artifacts directly into code-generation or scaffolding workflows, skipping manual export/import steps.
- Faster CI/Dev loops: With MCP, a developer could request the latest screens and component definitions and convert them into working UI code via CLI-driven agents.
- Easier orchestration: MCP servers can broker context across multiple agents, enabling multi-tool workflows where a design agent and a code agent collaborate.
Security and governance considerations
- API key management: Automatically generating keys is convenient but increases the need for expiration policies, scoped permissions, and key rotation mechanisms.
- Data leakage risk: Design files often include proprietary user flows, test accounts, or internal copy. MCP connectors must support granular consent and selective exposure.
- Supply chain risk: When designs are pulled directly into code pipelines, developers must validate outputs and maintain human review points to prevent fragile code generation or security regressions.
Deep Design, agentic reasoning, and the product roadmap
Google’s agent work across products suggests a consistent strategy: build specialized agents (Ideate, Pro, Flash, now Hatter) and link them to deeper reasoning systems that can carry context and perform multi-step tasks. Stitch’s move toward MCP and store asset automation shows an emphasis on productive handoffs between design and development.
- Short-term: Expect iterative UI generation features, better export options, and continued improvements to promptability and style controls.
- Mid-term: Agents like Hatter could support multi-screen flows, component inventories, accessibility checks, and responsive variants as first-class outputs.
- Long-term: If stitched together with Deep Design and an Agent Store or skill marketplace, Stitch could become a hub in a larger agentic design ecosystem—designing, validating, and exporting app-ready artifacts into automated build pipelines.
Strengths: what’s compelling about these additions
- End-to-end ergonomics: Reducing the friction between design iteration and developer handoff is valuable. Native MCP integration is a logical and powerful move for cross-tool workflows.
- Specialized agents: Multiple agent types give users tailored experiences—fast drafts, high-fidelity mockups, exploratory ideation—and the potential for a truly role-aware design assistant.
- Productivity gains for small teams: Indie developers and small product teams will gain the most immediate benefit from automated store assets and easier export to code tooling.
- Consistency and speed: Centralizing design generation and export reduces the chance of stale assets; iterations can propagate downstream more reliably.
Risks and limitations: where caution is required
- Feature vaporware risk: Development-build detections don’t guarantee public shipping. Features can be delayed, reworked, or scrapped.
- Overreliance on automation: Automatically generated store assets and code scaffolding risk producing subpar or inconsistent quality if used without human review.
- Security and privacy exposure: Integrating an MCP server and exposing API keys from a design tool increases attack surface; organizations must enforce proper secrets management and scope.
- Intellectual property and licensing: Generated assets (icons, text, images) may have ambiguous provenance or reuse patterns that create legal exposure—especially when teams operate at scale.
- Toolchain lock-in: First-party MCP integration simplifies life for Stitch users but also deepens coupling between Stitch’s output formats and the consuming code tools. That creates migration friction if a team later wants to move away.
How teams should evaluate these features (practical checklist)
- Determine the use case:
- Are you building prototypes for evaluation, or production-ready assets for store submission?
- Assess security policy fit:
- Will Stitch-hosted designs contain sensitive data? If so, require scoped MCP keys and short-lived tokens.
- Validate the asset pipeline:
- Do generated screenshots meet platform guidelines? Do they require localization or legal review?
- Run controlled pilots:
- Test Hatter-generated flows on a sample project; measure iteration speed and rework rate.
- Build verification gates:
- Add human reviews at critical points (store submission, code merge) to prevent low-quality automation outcomes.
Developer-focused guidance: using MCP and stitch outputs safely
- Use short-lived tokens: If Stitch issues keys for MCP, prefer tokens that expire quickly and can be rotated automatically by CI/CD pipelines.
- Scope access by project: Limit MCP connectors to specific projects or design sets rather than broad account-level access.
- Automate validation: Add static checks that validate generated assets for platform constraints—dimensions, size, color contrast, and localization fields—before they move into a release pipeline.
- Store outputs in version control: Exported design artifacts and generated code should be tracked in Git to maintain a history and support rollbacks.
- Treat generated code as scaffolding: Automatically produced UI code should be hardened by developers; treat it as a starting point, not production-ready by default.
Accessibility, localization, and compliance: often overlooked pieces
- Accessibility: Deeper design reasoning must include checks for color contrast, keyboard navigability, and screen-reader semantics. If Hatter is positioned as a “deeper” agent, accessibility should be a baked-in evaluation criterion.
- Localization: App Store assets must be tailored per locale. Automated generation should include language variants and cultural checks for imagery and phrasing.
- Privacy & compliance: Prototypes with user data or screenshots that include PII must be sanitized before export. MCP flows should support redaction or selective export.
Competitive context: who else is moving in this direction?
The market is active: competing design and AI platforms have been adding export and integration features, while coding assistants are becoming more capable of consuming design context. Stitch’s differentiators are its tight integration with Google’s model stack and the move toward first-party MCP support, which could make it easier to orchestrate multi-agent pipelines across design, code, and testing tools.
What to watch for next
- Public availability: Will Hatter, App Store asset generation, and native MCP integration reach general availability? Watch for staged rollouts and developer documentation.
- Deep Design details: Implementation specifics—how Hatter reasons across screens, what constraints it respects, and what outputs it generates—will determine practical utility.
- Governance controls: Look for features that allow admins to restrict MCP exports, rotate keys, and define data access policies.
- Skill and agent marketplace: If Google opens an Agent Store or skill repository for Stitch, third-party integrations could accelerate specialized workflow adoption.
- Quality and reliability metrics: Real-world adoption will hinge on the predictability and quality of outputs. Expect early users to report where automated assets fall short.
Final analysis: a pragmatic view
The changes detected in Stitch’s development channel point to an intentional product evolution: from one-off UI generation to an ecosystem of agents that can reason, iterate, and hand off to developer workflows with less friction. For teams that prize speed and iterative prototyping, these features offer clear upside—especially App Store asset generation for demo-ready presence and MCP integration for streamlined design-to-code flow.
However, the promise comes with predictable trade-offs. The most immediate risks are overreliance on unvetted automation, security exposure from eased integrations, and potential lock-in if first-party connectors become the path of least resistance. Firms should treat these features as productivity multipliers when combined with robust governance, human review, and CI verification gates.
If shipped broadly, Hatter and the associated export enhancements could reshape small-team workflows by compressing the time from idea to working demo. For now, the prudent approach is to pilot—measure gains against rework and governance costs—and require human-in-the-loop verification for any artifact bound for production or public stores. The value is real; the technical and operational controls will determine whether teams realize it safely.
Stitch’s recent development steps are an encouraging sign for designers and builders who want fewer seams between ideation and implementation, but they also demand a disciplined approach to adoption. Watch for public documentation, feature flags, and developer controls as these capabilities mature—those will be the real indicators that Stitch is ready to move from promising experiment to dependable component of modern design and build toolchains.
Source: TestingCatalog
Google tests Hatter agent and App Store tools in Stitch