Executive Overview
At its inaugural Config conference in India, cloud-based design leader Figma announced a major expansion of its developer ecosystem, unveiling 20 new partner integrations leveraging the Model Context Protocol (MCP). The cohort of new partners includes prominent productivity, development, and AI platforms such as Amp, ClickUp, Dia, Junie by JetBrains, Linear, Meta Muse, Mistral, Notion, OpenCode, and regional enterprise AI platform Sarvam Agents.
However, behind this strategic expansion lies a growing tension between application platforms and foundational AI providers. Despite expanding Figma’s support for the open-source protocol, Co-founder and Chief Executive Officer Dylan Field has voiced sharp reservations regarding MCP’s structural architecture. Field argues that while the developer community broadly favors open standards, the current implementation of MCP disproportionately benefits frontier AI laboratories—such as Anthropic, the standard’s original creator—at the expense of application platforms and end-user security.
Field’s critique highlights a structural rift within the AI ecosystem: the balance between enabling seamless, cross-platform AI agent workflows and safeguarding sensitive corporate data from asymmetric extraction, potential data leakage, and system abuse. Figma’s dual stance—expanding its integration footprint while publicly challenging the design of the protocol—underscores the complex strategic calculus facing major SaaS platforms as autonomous AI agents become central to modern software design and development.
Detailed Chronology: From Social Media Debate to Config India
The friction surrounding Figma’s integration strategy came to a head in the days leading up to Config India, triggered by developer discussions over tool access and protocol open-sourcing.
+-----------------------------------------------------------------------------------+
| CHRONOLOGY OF EVENTS |
+-----------------------------------------------------------------------------------+
| 1. Creator Critique |
| An MCP co-creator publicly criticizes Figma for lacking native support |
| for open-source tools like Pi. |
| |
| 2. Dylan Field's Rebuttal on X |
| Field defends Figma, pledging Pi support while pointing out that Anthropic |
| does not expose its own artifacts or cloud resources via MCP. |
| |
| 3. Highlighting Systemic Asymmetry |
| Field posts: "The debate is framed as open vs closed... meanwhile issues |
| of asymmetric context sharing are ignored." |
| |
| 4. Formal Announcement at Config India |
| Figma unveils 20 new MCP partner integrations (Linear, Notion, Mistral, etc.) |
| while maintaining caution regarding protocol abuse vectors. |
+-----------------------------------------------------------------------------------+1. The Spark: Integration Friction Over Open-Source Tools
The controversy began when a co-creator of the Model Context Protocol publicly voiced frustration regarding Figma’s lack of immediate native support for Pi, an open-source tool designed to run local agentic workflows. The complaint quickly gained traction across developer channels, framing Figma’s selective implementation as a reluctance to embrace fully open ecosystem standards.
2. The Public Pushback on X
Addressing the criticism on X (formerly Twitter), Field defended Figma’s roadmap while shifting the spotlight onto Anthropic, the organization that initially created and open-sourced MCP. Field highlighted a clear double standard in how openness is defined and enforced across the artificial intelligence landscape.
"Can you help me understand why you don’t make various Anthropic resources available via MCP? Maybe I’m missing something," Field wrote on X, addressing the protocol’s proponents.
He expanded on the topic in a subsequent post:
"I find it interesting that Anthropic (creators of MCP standard) do not expose artifacts / other cloud resources created via MCP. The debate is framed as open vs closed. Everyone always prefers open… obviously. And meanwhile issues of asymmetric context sharing are ignored."
Field later clarified that Figma does indeed plan to support Pi, defusing the specific software dispute while leaving the broader debate over protocol architecture fully exposed.
3. Keynote Clarifications at Config India
During a press briefing at Figma’s first Config conference held in India, Field addressed the debate directly, reiterating that Figma’s push toward ecosystem openness must be balanced with architectural caution. While committing to expand developer access, Field made clear that Figma would not blindly adopt protocols that introduce systemic risks or create uneven advantages for external foundation model vendors.
Supporting Context & Technical Metrics: Demystifying the Model Context Protocol (MCP)
To understand the friction between Figma and frontier AI labs, it is necessary to examine the underlying mechanics of the Model Context Protocol and the structural dynamics of context exchange.
+-----------------------------------------------------------------------------------+
| MODEL CONTEXT PROTOCOL (MCP) VALUE & CONTEXT FLOW |
+-----------------------------------------------------------------------------------+
| |
| [ Frontier AI Labs / LLM Providers ] <== ( Extracts Rich Canvas Data ) |
| (Anthropic, OpenAI) ==> ( Returns Plain Text / Closed Code ) |
| ^ |
| | |
| [ MCP Protocol Standard ] |
| | |
| v |
| [ Enterprise SaaS Ecosystem ] |
| (Figma, Notion, Linear, ClickUp) |
| |
+-----------------------------------------------------------------------------------+
| ISSUE: Asymmetric Value Exchange |
| - SaaS Platforms expose rich, proprietary design structures (Vector nodes, UI) |
| - AI Labs ingest rich context but restrict internal state/artifacts return |
+-----------------------------------------------------------------------------------+What is the Model Context Protocol?
Developed by Anthropic and released as an open standard, the Model Context Protocol functions as an application-level communication bridge—analogous to a universal adapter or standard API interface—designed to connect AI models and autonomous agents directly to external data sources, software applications, and execution environments.
Instead of requiring developer teams to write custom integrations for every tool, MCP provides a standardized format for:
- Context Ingestion: Allowing an LLM to read data from local files, cloud databases, and software platforms.
- Tool Execution: Enabling an agent to invoke native functions inside third-party software (e.g., creating a ticket in Linear, editing a document in Notion, or reading a canvas layout in Figma).
- Prompt Standardization: Structuring how contextual information is passed into the model’s active context window.
The Problem of "Asymmetric Context Sharing"
Field’s core technical criticism centers on the structural asymmetry embedded within the current AI ecosystem. Enterprise SaaS platforms like Figma hold highly structured, proprietary context—such as design tokens, component hierarchies, canvas spatial coordinates, and vector geometry.
When an AI agent connects to Figma via MCP, the protocol allows the model to extract this rich contextual data to execute tasks. However, frontier model providers often keep their own internal runtime states, generated "artifacts," and agent memory loops closed off inside proprietary cloud environments.
This creates a one-way transfer of value:
- SaaS Platforms expose sensitive design IP, canvas structures, and user data across the open protocol.
- Frontier AI Labs consume this structured context to improve model outputs and build stickier agent environments, without reciprocating by exposing their own cloud runtime or generated assets back to the source platforms through the same standard.
Security and Data Abuse Vectors
Beyond competitive dynamics, exposing deep application state through automated protocols introduces significant operational and security risks for complex creative platforms like Figma.
+-----------------------------------------------------------------------------------+
| MCP DATA EXPOSURE & RISK TAXONOMY |
+-----------------------------------------------------------------------------------+
| RISK VECTOR | DESCRIPTION |
+------------------------+----------------------------------------------------------|
| Indirect Prompt | Malicious instructions hidden in canvas data lead agents |
| Injection | to exfiltrate enterprise IP or alter files. |
+------------------------+----------------------------------------------------------|
| Vector & IP Harvesting | Automated scraping of component libraries, vector nodes, |
| | and brand identity systems via agent queries. |
+------------------------+----------------------------------------------------------|
| Privilege Escalation | Agents operating with user-level permissions executing |
| | destructive actions across connected third-party APIs. |
+------------------------+----------------------------------------------------------|
| Uncontrolled Rate | High-frequency agent polling straining real-time design |
| Consumption | sync engines and cloud infrastructure. |
+------------------------+----------------------------------------------------------|Official Statements & Strategic Analysis
During the media briefing at Config India, Dylan Field detailed Figma’s strategy regarding open standards, balancing developer demands against platform governance.
Dylan Field on the Limitations of MCP
"I’m really excited about what we’re doing in terms of opening up our ecosystem. I also think that MCP is not a perfect protocol. And I think that it is something that has tons of room for improvement," Field stated.
"It is advantaged more to frontier labs. Also, I understand everyone online who just wants a protocol that they can use when they want to use their Figma data, and I want them to use it, too."
Field expanded on why Figma maintains a cautious, staged rollout for full protocol permissions, highlighting the potential for data abuse:
"The reason we don’t want to be fully open is that the more data we expose through MCP, the higher the chance of abuse… Most users don’t intend to use MCP or Figma data in a malicious way, but as a platform, we still have to think deeply about those potential edge cases and security risks."
+-----------------------------------------------------------------------------------+
| STRATEGIC PARADOX: ECOSYSTEM OPENNESS VS. PLATFORM GOVERNANCE |
+-----------------------------------------------------------------------------------+
| |
| DEVELOPER DEMAND FOR OPENNESS PLATFORM GOVERNANCE RESPONSIBILITY |
| +--------------------------------+ +----------------------------------+ |
| | • Universal API standards | | • Protection against IP theft | |
| | • Frictionless agent access | VS | • Mitigation of prompt injection | |
| | • Interoperability with tools | | • Rate-limiting & access scopes | |
| | like Pi, Claude, and Linear | | • Preventing asymmetric scraping | |
| +--------------------------------+ +----------------------------------+ |
| |
| [ FIGMA'S BALANCING ACT ] |
| Announce 20 Partners <---> Enforce Sandboxed MCP Access |
+-----------------------------------------------------------------------------------+Strategic Analysis: The SaaS Defense Strategy
Field’s remarks reflect a broader strategic shift among top-tier SaaS companies. As foundational AI models achieve near-parity in basic reasoning, the primary value in software shifts from core code execution to proprietary data, design systems, context, and user workflow history.
For Figma, its canvas represents years of proprietary design systems, complex vector layouts, and collaborative workflow logic. Unrestricted, unmonitored access via open protocols risks reducing application platforms to simple data storage providers for AI model operators.
By expanding its partner ecosystem to 20 managed platforms—including productivity tools like Notion and ClickUp, developer hubs like JetBrains and Linear, and AI frameworks like Mistral and Sarvam Agents—Figma is pursuing a controlled integration strategy. The company is choosing to build explicit, sandboxed partner integrations rather than opening up unrestricted system permissions to arbitrary agent scripts.
Ecosystem Impact: The 20 New MCP Partners
Figma’s rollout of 20 new MCP partner integrations represents a major bridge between design environments, software development tools, and AI workflows.
+-----------------------------------------------------------------------------------+
| FIGMA MCP PARTNER ECOSYSTEM OVERVIEW |
+-----------------------------------------------------------------------------------+
| CATEGORY | PARTNERS INCLUDED |
+----------------------+------------------------------------------------------------+
| Developer & Issue | Linear, Junie by JetBrains, OpenCode |
| Tracking | |
+----------------------+------------------------------------------------------------+
| Enterprise & | ClickUp, Notion, Amp |
| Productivity Hubs | |
+----------------------+------------------------------------------------------------+
| AI Infrastructure | Mistral, Sarvam Agents, Meta Muse, Dia |
| & Agents | |
+----------------------+------------------------------------------------------------+Key Integration Highlights
- Linear & ClickUp: Enables two-way synchronization between Figma canvas components and project tracking tasks, allowing AI agents to automatically convert design changes into actionable engineering specs.
- Junie by JetBrains & OpenCode: Integrates design tokens and asset layers directly into IDE environments, allowing developer agents to pull contextual design data directly into source code generation pipelines.
- Mistral & Sarvam Agents: Expands Figma’s reach across international enterprise AI markets. Supporting Sarvam Agents specifically highlights Figma’s focus on India’s growing developer ecosystem, enabling localized, multi-lingual AI workflows built on top of native Figma files.
- Notion & Amp: Allows teams to maintain real-time design documentation where AI agents dynamically update canvas specs inside centralized knowledge bases.
Future Outlook: The Search for a Balanced Agent Standard
Figma’s strategy illustrates the dynamic tensions shaping the next decade of software integration. As AI transitions from static chatbots to autonomous, action-oriented agents, open protocols like MCP will be critical for cross-platform automation—provided they evolve to address structural imbalances.
+-----------------------------------------------------------------------------------+
| THE EVOLUTION ROADMAP FOR AGENTIC PROTOCOLS |
+-----------------------------------------------------------------------------------+
| CURRENT STATE: MCP 1.0 | FUTURE REQUIREMENTS: MCP 2.0 |
+---------------------------------------+-------------------------------------------+
| • Asymmetric data extraction | • Symmetric, bidirectional context flows |
| • Coarse permission models | • Fine-grained, object-level RBAC |
| • Focus on model access | • Embedded data loss prevention (DLP) |
| • Limited visibility into agent state | • Real-time inspection of agent runtime |
+---------------------------------------+-------------------------------------------+What Needs to Change in MCP?
For open standards like MCP to achieve universal enterprise adoption without friction, several key architectural adjustments are likely needed:
- Symmetric Context Reciprocity: Protocols must ensure that when an enterprise application exposes its state to a model, the model provider reciprocal exposes runtime state, memory loops, and generated artifacts back to the application host.
- Fine-Grained Permissions (RBAC for Agents): Current agent connections often operate with broad user-level access. Future standards must enforce granular, object-level, and variable-level permissions to prevent unauthorized scraping or destructive edits.
- Built-in Prompt Injection Guardrails: Protocols must feature native sanitization boundaries to prevent untrusted context from executing unauthorized actions across connected cloud APIs.
Conclusion
Figma’s announcements at Config India demonstrate a commitment to inter-platform connectivity, paired with a clear-eyed approach to the strategic risks involved. By expanding support for 20 major partners while publicly pushing for improvements to the Model Context Protocol, Dylan Field has set a precedent for application platforms navigating the AI transition.
As software platforms increasingly interact via autonomous agents, the challenge will not simply be connecting systems together, but ensuring those connections remain secure, fair, and mutually beneficial across the entire tech ecosystem.
