Figma Launches Agent Feature Spec, Code Layers Enters Open Beta

Figma is drawing boundaries for AI agent behavior on its platform. According to its latest announcement, Figma will roll out a series of new features designed to define how agents work on the platform, while the much-anticipated Code Layers feature has officially entered open beta.

Agent Feature Spec: Not Just "Permission," But "Constraint"

As AI agents begin to permeate design tools, a core question surfaces: how much autonomy can agents have? Who is responsible for an agent's modifications? Figma's newly introduced features are essentially answering these questions.

Although the official announcement offers limited details, judging from the feature naming and industry trends, this is not a simple "AI assistant" upgrade, but a permissions and collaboration framework oriented around agent behavior. It may involve the level of agent access to design files, granular control over modification permissions, and the traceability of agent behavior in multi-user collaboration scenarios.

For design teams, this means the agent is no longer a black box — every step it takes operates within rules defined by the platform. This addresses the most thorny trust issue when AI agents enter production workflows.

AI Agent here does not refer to traditional autocomplete or suggestion-based AI assistants, but to software entities with a certain degree of autonomous decision-making and execution capability. Unlike tools that passively respond to user instructions, agents can typically perceive environmental states, plan multi-step operations, invoke external tools or APIs, and accomplish goals with minimal human intervention. In the context of design tools, agents can automatically organize layers, batch-modify components, sync design tokens, or even generate interface structures based on requirement descriptions.

The stronger an agent's autonomy, the more critical permission boundaries and accountability become. So-called granular permission control refers to whether a platform can refine an agent's access and modification permissions down to specific files, layer types, or operation categories — for example, allowing style reading but prohibiting component deletion. Traceability requires the platform to record every operation an agent performs, including the operator's identity (human or agent), timestamp, and scope of impact, so that errors can be rolled back or attributed. These mechanisms together form the precondition for agents to enter production workflows.

Code Layers Open Beta: The Boundary Between Design and Code Blurs Further

In sync with the agent feature spec, Figma announced that Code Layers has entered open beta. This feature was previously tested with select users and is now open to a broader audience.

The core value of Code Layers lies in bridging the gap between design context and code output. In traditional workflows, visual mockups produced by designers in Figma require manual slicing, annotation, and communication before being converted into front-end code. Code Layers allows code logic to be embedded at the layer level, so that design files themselves carry more engineering semantics.

When agents are allowed to work on the Figma platform, the significance of Code Layers is further amplified — agents can not only manipulate visual elements, but also understand and generate code snippets associated with layers. The synergy between the two product lines is quite evident.

Code Layers can be understood as adding a special type of layer to a design file's layer structure — one that does not directly render visual pixels but carries code snippets, component properties, or style logic associated with adjacent layers. Traditional design deliverables are static visual annotations, and engineers need to manually restore styles based on annotations; Code Layers, by contrast, makes design files themselves carry engineering semantics — for example, the corner radius, spacing, and color of a button layer can be mapped to CSS variables or component props.

The gap between design context and code output has long relied on manual translation and communication to bridge. Code Layers attempts to build this mapping relationship into the design tool itself, allowing code generation tools or AI agents to directly read the logic information on layers and reduce ambiguity. When an agent needs to modify an interface, it can not only adjust the visual presentation but also synchronously update associated code snippets, thereby maintaining a higher degree of consistency between design and code.

Platform Strategy: Figma Is Defining the Collaboration Rules of the AI Era

Looking at these two updates together, Figma's strategy becomes increasingly clear: it is not content to be a design tool that AI calls upon, but aims to become the rule-maker defining how AI participates in design collaboration.

This path differs from the AI strategies of competitors such as Adobe. Adobe is more focused on embedding generative capabilities into existing tools, while Figma chooses to first build the underlying protocol for agent operation. In the short term, this may be less intuitive than "one-click interface generation"; in the long term, whoever defines the behavioral norms for agents controls a key node in the ecosystem.

Code Layers' open beta provides concrete deployment scenarios for this set of rules. Specs and scenarios complement each other: specs without scenarios are castles in the air, while scenarios without specs are difficult to scale.

Practical Impact on Design Teams

For teams using Figma daily, the impact of these updates is multi-layered.

In the short term, Code Layers' open beta means the design delivery process may change — the mapping relationship between design files and code repositories will become tighter, and front-end engineers will receive not static annotations but layer structures with logical context.

In the medium term, the agent feature spec will determine whether teams are willing to hand repetitive design tasks (such as component organization, style syncing, and responsive adaptation) to automated agents. The clarity of the permission model directly affects whether agents can enter production environments.

In the longer term, the system Figma is building may give rise to new roles — similar to an "agent administrator" or "AI collaboration spec specialist" — responsible for configuring agent permissions, auditing agent behavior, and optimizing human-machine collaboration workflows.

Industry Signal: Design Tools Enter the Protocol Competition Phase

This Figma update sends a clear industry signal: the competitive dimension of design tools is shifting from feature richness to protocol definition power.

When all mainstream design tools possess AI capabilities, the difference no longer lies in "whether AI can be used," but in "what rules AI operates under." Figma has chosen to answer the latter first, and the effectiveness of this move depends on acceptance by the developer community and design teams.

Code Layers' open beta data and the actual adoption rate of the agent feature spec will be key indicators for observing whether this strategy holds. At present, the market remains in a wait-and-see and exploratory stage regarding Figma's AI roadmap, and this update provides observers with a more concrete basis for evaluation.

One-line Summary

Figma launches agent behavior specs and Code Layers open beta, aiming to define AI design collaboration rules.

Paragraph Summary

Figma announced two major updates: first, establishing behavior specs and a permission framework for AI agents on its platform, clarifying agent access levels, modification permissions, and traceability; second, opening Code Layers to public beta, bridging design context and code output. Together, they show Figma is shifting from a design tool to a rule-maker for AI collaboration, differentiating itself from embedded AI strategies of rivals like Adobe. In the short term, Code Layers will change design delivery workflows; in the medium term, the agent permission model determines whether automated tasks can enter production environments; in the long term, it may create new agent management roles. Industry competition is shifting from feature richness to agent protocol definition power, and Figma's success depends on community adoption.