Glossary
A2UI (Agent to User Interface) uses specific terms for its wire protocol, client and server SDKs, and generative UI patterns, defined below in alphabetical order.
A · B · C · D · E · F · G · I · M · N · P · R · S
A
A2UI
Agent to User Interface, an open-source generative UI framework (a platform-agnostic streaming protocol, native renderers, and agent SDKs) that lets agents generate stateful, native user interfaces across web, mobile, and desktop renderers without sending executable code, HTML, or CSS over the wire.
See Overview: How A2UI Works and the v1.0 Protocol Specification.
A2UI message
A single JSON envelope exchanged between an agent and a renderer over a streaming or request-response transport.
Messages flow in two directions: agent_to_renderer envelopes create or delete surfaces, update components and data models, invoke renderer functions, and return agent function results; renderer_to_agent envelopes dispatch user events, invoke agent functions, return renderer function results, and report validation or runtime errors. Because A2UI supports progressive delivery over streaming transports, a message stream may be in progress, completed, or interrupted if transport delivery stops early.
See Messages.
A2UI tag
A delimiter tag in model-to-agent text output, such as <a2ui>...</a2ui> (used by the Express inference format) or <a2ui-json>...</a2ui-json> (used by the Direct JSON format), that marks the start and end of a structured UI block.
Because a single model response can interleave conversational prose with one or more UI blocks, the Agent SDK parser scans for A2UI tags to separate prose from raw UI blocks before compiling those blocks into agent_to_renderer messages.
See Inference Formats.
A2uiGenerator
The top-level coordinator class in an Agent SDK that holds the agent’s supported CatalogConfig entries, optional prompt examples, and default inference format factory (ExpressFormatFactory by default).
For each session or request, calling createProcessor (in TypeScript and Dart) or create_processor (in Python) with the renderer’s capabilities negotiates the active catalogs and returns an A2uiRequestProcessor that generates system prompt instructions and parses and validates model responses against RendererState.
See Agent SDK and How to Integrate A2UI into an Agent.
Action
An interaction handler property on a UI component (such as Button.action), defined by common_types.json#/$defs/Action in v1.0 and common_types.json#/$defs/Action in v0.9.1.
An Action is a oneOf union that specifies one of two behaviors when a user interacts with the component:
- An
event({"event": {"name": "...", "context": {...}}}), which causes the renderer to resolve any bound values and send an outboundactionmessage inrenderer_to_agentto notify the agent of user intent. - A
functionCall({"functionCall": {"@call": "...", "args": {...}}}in v1.0, or"call"in v0.9.1), which invokes a function without dispatching anactionevent message (in v1.0, running locally on the renderer or routing to the agent viacallAgentFunctionwhen unimplemented locally).
See Actions and Functions and Defining actions in the protocol specification.
Agent
The application or service that emits agent_to_renderer messages to build and update UI surfaces on a renderer, and processes inbound renderer_to_agent events and remote function calls.
To decide what UI and data to emit, an agent typically calls a large language model (LLM), coordinates specialized subagents behind an orchestrator, or runs deterministic application logic (for example, in regulated workflows or automated tests). An agent can run on a server over transports such as AG-UI, Agent-to-Agent (A2A), Model Context Protocol (MCP), Server-Sent Events (SSE), or WebSockets, or inside the same client process as the renderer. Agents may be stateful (retaining negotiated catalogs and RendererState across turns) or stateless (receiving renderer capabilities and surface data model metadata on every request).
See Overview: How A2UI Works and How to Integrate A2UI into an Agent.
Agent SDK
A first-party agent-side library (published for TypeScript, Python, and Dart on top of each language’s Core SDK) that manages an agent’s interaction with language models and renderers.
An Agent SDK loads and prunes catalogs via catalog transformers, negotiates renderer capabilities through A2uiGenerator, generates model skills and system prompt snippets, compiles inference format output into wire JSON, and validates payloads against RendererState so errors can be fed back to the model for self-correction.
See Agent SDK for official package names and capabilities.
agent_to_renderer
The v1.0 protocol envelope schema (agent_to_renderer.json) for messages streamed or returned from an agent to a renderer. In v0.9.1, this envelope schema is named server_to_client.json.
Every v1.0 agent_to_renderer message sets "version": "1.0" (v0.9.1 uses "version": "v0.9" or "v0.9.1") alongside one of six message keys:
createSurfaceinitializes a new surface (and in v1.0 can embed initialcomponentsanddataModelinline).updateComponentsadds or replaces component definitions in a surface’s flat component list.updateDataModelinserts, replaces, or deletes ("value": nullin v1.0; omittedvaluein v0.9.1) data at a JSON Pointer path in a surface’s data model.deleteSurfaceremoves a surface and its associated state.callRendererFunction(new in v1.0) invokes an authorized renderer-side function.agentFunctionResponse(new in v1.0) returns thevalueorerrorfor acallAgentFunctionrequest.
See Messages and Envelope message structure in the protocol specification.
Agent turn
The sequence of agent_to_renderer messages (and any accompanying conversational text) sent by an agent in response to a user prompt or Event before the agent waits for the next user input. The end of an agent turn is signaled by the transport layer rather than by an A2UI message.
See Messages and Transport decoupling in the protocol specification.
B
Basic catalog
The optional, general-purpose reference catalog maintained by the A2UI project (https://a2ui.org/specification/v1_0/catalogs/basic/catalog.json in v1.0, basic_catalog.json; https://a2ui.org/specification/v0_9/catalogs/basic/catalog.json in v0.9.1, basic_catalog.json).
The Basic catalog defines 18 standard components (Row, Column, List, Card, Tabs, Modal, Divider, Text, Image, Icon, Video, AudioPlayer, Button, TextField, CheckBox, ChoicePicker, Slider, and DateTimeInput) and 14 functions (formatString, formatNumber, formatCurrency, formatDate, pluralize, required, regex, length, numeric, email, openUrl, and, or, and not). Official framework adapters ship with a built-in implementation that applications can restyle, combine with custom domain catalogs, or replace altogether.
See Catalogs and Basic Component Catalog in the protocol specification.
C
@call
The reserved v1.0 protocol directive key in a FunctionCall object that names the catalog or system function to invoke, for example {"@call": "formatCurrency", "args": {"value": {"@path": "/price"}, "currency": "USD"}}.
In v0.9.1, FunctionCall uses "call" without the @ prefix (common_types.json#/$defs/FunctionCall). Reserving the @ prefix in v1.0 keeps plain JSON objects that have a "call" property from being treated as function calls; literal keys beginning with @ inside DynamicValue objects are escaped by doubling the prefix ("@@call").
See Function call, Actions and Functions, and Functions in the protocol specification.
callAgentFunction
A v1.0 renderer_to_agent message (renderer_to_agent.json#/properties/callAgentFunction) sent by a renderer to execute an agent-side function remotely, such as checking live inventory or verifying an identifier.
When the renderer resolves a FunctionCall’s catalog and finds no local implementation (provided the function is not an @-prefixed system function, is not declared allowedCallers: "agentOnly", and passes any requiresUserActivation and declared argument schema checks), it sends callAgentFunction with surfaceId, a unique functionCallId, and callFunction (@call, the resolved catalogId, and evaluated args). The agent runs the function and replies with an agentFunctionResponse carrying the same functionCallId and either value or error. Not present in v0.9.1, where functions run only on the renderer.
See Actions and Functions and callAgentFunction in the protocol specification.
callRendererFunction
A v1.0 agent_to_renderer message (agent_to_renderer.json#/$defs/CallRendererFunctionMessage) sent by an agent to execute a function registered on the renderer, such as reading client state or triggering an authorized client operation.
The message carries a unique functionCallId, an optional surfaceId whose data model provides the evaluation context (defaulting to an isolated empty root model {} when omitted), and callFunction with @call, a required catalogId, and optional args. Only functions declared with allowedCallers set to "agentOnly" or "rendererOrAgent" (and not requiring user activation) may be called by the agent. After executing or rejecting a well-formed call, the renderer returns a rendererFunctionResponse with the matching functionCallId and either value or error (malformed envelopes report a top-level error message carrying functionCallId). Not present in v0.9.1.
See Actions and Functions and callRendererFunction in the protocol specification.
Capabilities
Metadata payloads exchanged via transport handshakes or per-message transport metadata (rather than as A2UI messages) that advertise which catalogs each side supports:
- Renderer capabilities (
renderer_capabilities.json, sent under thea2uiRendererCapabilitiesmetadata key in v1.0;client_capabilities.jsonundera2uiClientCapabilitiesin v0.9.1) declaresupportedCatalogIdsand optionalinlineCatalogsnested under the protocol version key ("1.0"in v1.0,"v0.9"in v0.9.1). - Agent capabilities (
agent_capabilities.jsonin v1.0;server_capabilities.jsonin v0.9.1) declare the agent’ssupportedCatalogIdsandacceptsInlineCatalogsflag.
See Overview: How A2UI Works and Capabilities and metadata in the protocol specification.
Catalog
A versioned JSON Schema document (catalog_definition.json) identified by a unique catalogId string (conventionally formatted as a URI) that defines the UI components, functions, and Markdown instructions shared between an agent and a renderer.
A catalog is an explicit allowlist: the agent uses it to construct model prompts and validate generated messages, while the renderer binds each declared component to a native UI widget and each local function to client code. Catalogs can define low-level primitives (such as Row, Text, and Button in the Basic catalog) or domain-specific components (such as FlightSelector or HotelCheckout). In v1.0, a single surface can mix components and functions from multiple catalogs by setting catalogId on individual entries.
See Catalogs, How to Define a Catalog, and The component catalog in the protocol specification.
Catalog transformer
An Agent SDK interface (CatalogTransformer) that filters or adapts a catalog before prompt instructions are generated and validation schemas are compiled.
Pruning unused components and functions lowers prompt token consumption and restricts what UI capabilities a model can emit for a specific task or user role. Built-in implementations in the TypeScript, Python, and Dart Agent SDKs include ComponentPruningTransformer (which keeps an allowlist of component names) and FunctionPruningTransformer (which keeps an allowlist of function names). For server-side composite component expansion, see MacroExpander.
See Agent SDK.
CheckRule
A client-side validation rule (common_types.json#/$defs/CheckRule in v1.0; common_types.json#/$defs/CheckRule in v0.9.1) attached to input and interactive components that include Checkable (@checks in v1.0, checks in v0.9.1).
In v1.0, each CheckRule pairs a condition (a DataBinding or FunctionCall evaluating to a ValidationResult object {valid, code, message, severity} or a boolean) with an optional fallback message; in v0.9.1, condition is a DynamicBoolean and message is required. Checks that fail with "error" severity (the default, and what a false boolean coerces to) mark the component invalid and disable controls such as Button, while "warning" and "info" results display non-blocking feedback.
See Actions and Functions and Component Validation & Check Rules in the protocol specification.
ChildList
The schema type (common_types.json#/$defs/ChildList in v1.0; common_types.json#/$defs/ChildList in v0.9.1) used by container components (such as Column, Row, and List) to hold multiple child components in a surface’s flat component list.
A ChildList property accepts one of two forms:
- A static array of
ComponentIdstrings (for example,["header", "body", "footer"]). - A collection template object
{"path": "/items", "componentId": "itemCard"}that instantiatescomponentIdonce for each element of the array atpathin the data model, establishing a collection scope for relative@pathbindings and@indexcalls. Template objects use the plain property name"path"(not"@path") in both v1.0 and v0.9.1.
See Data Model and Data Binding and Collection scopes (relative paths) in the protocol specification.
Component
A declarative UI element defined in a catalog (such as Card, Button, TextField, or a domain-specific FlightStatusCard) and rendered as a native widget by a client framework adapter.
Within a surface, component instances are sent in createSurface or updateComponents as a flat adjacency list rather than a nested tree: each entry has a unique id (following Unicode UAX #31 identifier rules in v1.0), a component type name, optional @catalogId, @accessibility attributes, and @metadata.extensions (bare accessibility in v0.9.1), and references children by ID (ComponentId or ChildList). Every rendered surface requires one component with "id": "root", which mounts inside the reserved immutable Surface container (common_types.json#/$defs/Surface).
See Catalogs and Component model in the protocol specification.
Core SDK
The UI-framework-agnostic foundational library in each language, shared by both Agent SDKs and client framework adapters.
The Core SDK implements protocol message models, Catalog schemas, reactive surface and data model state containers (SurfaceGroupModel, SurfaceModel, ComponentModel, and DataModel, named SurfaceViewModel in Swift and A2uiCoreSurfaceGroupModel, A2uiCoreSurfaceModel, A2uiCoreComponentRegistry, and A2uiCoreDataModel in Kotlin, with A2uiComponentModel in compose-runtime), JSON Pointer resolution, @path and @call expression evaluation, MessageProcessor, and payload validation.
See Core SDK for official package names across languages.
D
Data binding
Connecting a component’s dynamic property (DynamicString, DynamicNumber, DynamicBoolean, DynamicStringList, or DynamicValue in common_types.json) to a path in the surface’s data model via a DataBinding object ({"@path": "..."} in v1.0, or {"path": "..."} in v0.9.1) instead of a literal value.
Display components (such as Text) use one-way reactive bindings that update whenever the bound path changes. Input components (such as TextField, CheckBox, and Slider) establish local two-way bindings that read the current value at the bound path and write user edits back to the local data model immediately without per-keystroke network traffic.
See @path, Data Model and Data Binding, and Data model representation: binding, scope in the protocol specification.
Data model
An isolated, reactive JSON state object maintained per surface on the renderer and shared with the agent that owns the surface.
The agent populates or mutates the data model inline in createSurface (v1.0) or incrementally via updateDataModel using RFC 6901 JSON Pointers. Local user edits remain on the renderer until sent back to the agent selectively in Event context bindings, as resolved arguments to agent-routed function calls (callAgentFunction in v1.0), or in full via transport metadata (a2uiRendererDataModel matching renderer_data_model.json in v1.0; a2uiClientDataModel matching client_data_model.json in v0.9.1) when createSurface sets "sendDataModel": true.
See Data Model and Data Binding and Data model updates: synchronization and convergence in the protocol specification.
E
Envelope schema
A top-level JSON Schema that defines the outer wire structure ("version" plus a single message type key) for an A2UI message exchanged between an agent and a renderer, independent of which catalog defines the UI components and functions:
agent_to_renderer.json(agent_to_renderer) validates v1.0 messages from agent to renderer ("version": "1.0").renderer_to_agent.json(renderer_to_agent) validates v1.0 messages from renderer to agent ("version": "1.0").server_to_client.jsonvalidates v0.9.1 (and v0.8) messages from server (agent) to client (renderer), renamed toagent_to_renderer.jsonin v1.0.client_to_server.jsonvalidates v0.9.1 (and v0.8) messages from client (renderer) to server (agent), renamed torenderer_to_agent.jsonin v1.0.
Each envelope schema also has companion JSON array (*_list.json) and object-wrapped array (*_list_wrapper.json) schemas for batched message delivery.
See Messages and Envelope message structure in the protocol specification.
Event
The agent-bound variant of a component Action (action.event in common_types.json#/$defs/Action) that notifies the agent of user intent, such as clicking a submit button or choosing an item.
An event object declares a required name, an optional context map of literal values or dynamic bindings, and (in v1.0) an optional userMessage (DynamicString). When triggered by the user (provided no component CheckRule fails with "error" severity), the renderer resolves every binding in context and userMessage against the local data model and emits an action message in renderer_to_agent containing name, surfaceId, sourceComponentId, ISO 8601 timestamp, resolved context, and (in v1.0) optional userMessage and metadata.extensions.
See Actions and Functions and action in the protocol specification.
F
Framework adapter
A UI-framework-specific client library (also called a Renderer SDK), built on top of a Core SDK, that renders active surface state from MessageProcessor using native widgets in a target framework such as Flutter, React, Lit Web Components, Angular, SwiftUI, or Jetpack Compose.
Framework adapters include a built-in implementation of the Basic catalog, map A2UI AccessibilityAttributes (label, description, live, hidden) to platform accessibility APIs, and let teams register custom catalog component views and local functions while the adapter handles reactive state updates.
See Renderer SDK for official package names and How to Integrate A2UI into a Client.
Function
A named, typed operation declared in a catalog’s functions map (catalog_definition.json#/$defs/FunctionDefinition) with an argument schema (args) and returnType ("string", "number", "boolean", "array", "object", "validationResult", "any", or "void"). Functions execute logic without sending raw code between the agent and renderer.
In v1.0, whether a function call runs locally or on the agent depends on whether the renderer registers a local implementation, while allowedCallers ("rendererOnly" by default, "agentOnly", or "rendererOrAgent") and requiresUserActivation govern which side and gesture context may invoke it:
- Renderer functions have a local implementation on the renderer and execute with zero network round-trips for tasks such as string and number formatting, input validation, boolean combinators, or user-gesture actions like
openUrl(requiresUserActivation: true, which requires"rendererOnly"). Functions declared withallowedCallersset to"agentOnly"or"rendererOrAgent"(withoutrequiresUserActivation) can also be invoked remotely by the agent viacallRendererFunction;"agentOnly"functions still run on the renderer and cannot be bound to component properties or actions. - Agent functions (new in v1.0) have no local implementation on the renderer and execute on the agent for server-side tasks such as checking inventory or verifying credentials; when the renderer resolves a
FunctionCall’s catalog and finds no local implementation (whether or not the catalog declares the function, and provided the call is not@-prefixed, declared"agentOnly", or blocked byrequiresUserActivation), the renderer dispatchescallAgentFunctionand awaitsagentFunctionResponse. (In v0.9.1, functions execute only on the renderer.)
An A2UI function is distinct from a language model tool:
| Aspect | A2UI function | LLM tool |
|---|---|---|
| Executor | Renderer (renderer functions) or agent (agent functions). | Model host or agent environment outside the UI. |
| Timing | During UI rendering, on user interaction, or as an explicit remote call over the protocol. | During model generation before or while producing a response. |
| Purpose | UI formatting, input validation, client-side effects, or UI-triggered server lookups. | Model reasoning, web search, database queries, or backend operations. |
| Declaration | Declared in an A2UI catalog with typed args, returnType, and caller rules. | Declared in a tool definition passed to the language model. |
See Actions and Functions and Functions in A2UI Content Execution in the protocol specification.
Function call
An invocation of a catalog or system function represented as a FunctionCall object with @call in v1.0 ("call" in v0.9.1), an optional catalogId override, and optional args.
Function calls occur in four places across the protocol:
- Dynamic component property bindings (
DynamicString,DynamicNumber,DynamicBoolean,DynamicStringList, andDynamicValue), re-evaluated reactively when bound data model paths change. - Validation rules (
CheckRule@checks[].conditionin v1.0,checks[].conditionin v0.9.1), returning aValidationResultor boolean to validate inputs and gate controls. - Component
Actionhandlers (action.functionCall), triggered by a user gesture. - Explicit remote procedure call envelopes (
callRendererFunctionandcallAgentFunctionin v1.0).
G
Generative UI patterns
Common application layouts for presenting agent-generated surfaces (none of which are required by the A2UI protocol):
- Chat: Generated surfaces appear in chronological order inside a vertically scrollable conversation view alongside text messages.
- Canvas: A shared workspace where the user and agent iteratively inspect and update one or more persistent surfaces across turns.
- Dashboard: Generated surfaces are arranged by topic or role rather than time and remain pinned in fixed regions of the screen.
- Wizard: Generated surfaces appear step by step to gather structured input for a multi-stage task.
See Overview: How A2UI Works and How to Integrate A2UI into a Client.
I
@index
The reserved v1.0 universal system function (common_types.json#/$defs/IndexSystemFunction) that returns the 0-based index of the current item when rendering a ChildList collection template, called as {"@call": "@index"} or {"@call": "@index", "args": {"offset": 1}} (or ${@index(offset: 1)} inside formatString).
In nested collection templates, @index resolves to the innermost enclosing template’s index; calling @index outside a list template fails evaluation (reporting EXPRESSION_ERROR on dynamic bindings or EXECUTION_ERROR in callRendererFunction).
See Data Model and Data Binding and The @index function in the protocol specification.
Inference format
The structured notation in which a language model writes UI blocks inside A2UI tags before the Agent SDK compiles them into agent_to_renderer wire JSON.
Because inference formats are decoupled from the wire protocol, an agent can switch formats on A2uiGenerator without modifying client renderers. Supported formats include Express (ExpressFormatFactory, the default compact positional DSL that cuts output tokens and decode latency), Direct JSON (DirectJsonFormatFactory, raw JSON message arrays with incremental stream healing), and experimental Python-only formats (Atom and Elemental).
When reading a model response (parseResponse / parse_response or streaming openStream / open_stream), the Agent SDK parser runs three stages:
- Tag unwrapping (
unwrap): Scans model output for opening and closing A2UI tags to separate conversational prose from raw UI blocks. - Compilation (
compile): Translates each raw block from format notation intoagent_to_renderermessages without checking catalogs orRendererState. - Validation and state tracking:
parseResponse/parse_responseandopenStream/open_streamvalidate compiled messages against the active catalogs and updateRendererState.
See Inference Formats.
M
MacroExpander
An asymmetric catalog and message transformer in the Python Agent SDK (a2ui.transformers.macros) that lets developers define coarse-grained composite components on the server with the @macro decorator and lower them into standard catalog primitives before wire transmission.
MacroExpander.transform_to_inference_catalog augments a base catalog with component schemas synthesized from @macro function type annotations and docstrings for model prompting, and MacroExpander.transform_to_transport expands macro components emitted by the model into primitive createSurface and updateComponents subtrees so client renderers need no custom widget code.
See Using Macros and Agent SDK.
MessageProcessor
The stateful controller class in each language’s Core SDK (A2uiMessageProcessor in Kotlin) that processes incoming agent_to_renderer (and v0.9.1 server_to_client) message streams.
MessageProcessor validates incoming payloads against registered catalogs, mutates reactive surface and data model state containers (SurfaceGroupModel, SurfaceModel, ComponentModel, and DataModel, named SurfaceViewModel in Swift and A2uiCoreSurfaceGroupModel, A2uiCoreSurfaceModel, A2uiCoreComponentRegistry, and A2uiCoreDataModel in Kotlin, with A2uiComponentModel in compose-runtime), resolves JSON Pointers and @call expressions, enforces function caller and user-activation rules, emits outbound renderer_to_agent messages (action, callAgentFunction, rendererFunctionResponse, and error), and builds renderer capabilities and a2uiRendererDataModel metadata snapshots.
See Core SDK and How to Integrate A2UI into a Client.
N
NoAI information
Data categorized by an application as inaccessible to AI models and agents, such as payment card details, credentials, or regulated personal records.
Which fields count as NoAI information depends on the product and workflow (for example, medical history may be excluded from AI context in a billing app while required in a clinical diagnostic tool). In generative UI interfaces, keeping NoAI inputs outside agent-bound Event context maps, outside arguments to function calls that can route to the agent via callAgentFunction, and off "sendDataModel": true surfaces (while visually distinguishing AI-connected inputs from private inputs) lets end users see which data can reach a model.
See Synchronizing state back to the agent in Data Model and Data Binding.
P
@path
The reserved v1.0 protocol directive key in a DataBinding object that points to a value in a surface’s data model using an RFC 6901 JSON Pointer, such as {"@path": "/reservation/guestEmail"}.
A path starting with / resolves from the root of the surface data model, while a path without a leading slash (such as {"@path": "guestName"}) resolves relative to the current item in an enclosing ChildList collection template. In v0.9.1, DataBinding uses "path" without the @ prefix (common_types.json#/$defs/DataBinding). Even in v1.0, updateDataModel.path and ChildList template path use plain "path" because they are fixed schema fields rather than dynamic value unions.
See Data binding, Data Model and Data Binding, and Path resolution & scope in the protocol specification.
R
Renderer
The client-side runtime inside a host application that advertises supported catalogs via capabilities, applies agent_to_renderer messages through MessageProcessor, renders surfaces as native widgets via a framework adapter, maintains per-surface data models, runs local functions, and sends renderer_to_agent messages back to the agent.
See Renderer SDK and How to Integrate A2UI into a Client.
renderer_to_agent
The v1.0 protocol envelope schema (renderer_to_agent.json) for messages sent from a renderer to an agent. In v0.9.1, this envelope schema is named client_to_server.json.
Every v1.0 renderer_to_agent message sets "version": "1.0" (v0.9.1 uses "version": "v0.9" or "v0.9.1") alongside one of four message keys:
actiondispatches a user-triggeredEventwith its resolvedcontext.callAgentFunction(new in v1.0) requests remote execution of an agent-side function.rendererFunctionResponse(new in v1.0) returns thevalueorerrorfor an agent-initiatedcallRendererFunctionrequest.errorreports validation errors (VALIDATION_FAILED,UNALLOWED_PARENT,UNALLOWED_CHILD) or runtime faults (EXPRESSION_ERROR,EXECUTION_ERROR,INTEGRITY_ERROR,INVALID_FUNCTION_CALL), allowing the agent to prompt the model for self-correction.
See Messages and Renderer-to-agent event messages in the protocol specification.
S
Surface
An isolated, non-nesting UI region created with a globally unique surfaceId via createSurface, populated with a flat adjacency list of components rooted at "id": "root", backed by its own data model, and removed via deleteSurface.
Creating a surface implicitly instantiates the reserved immutable Surface container (common_types.json#/$defs/Surface) with "child": "root". Surfaces cannot nest inside one another, though a host application can display multiple surfaces at the same time (such as separate cards in a chat timeline or panels in a dashboard).
See Overview: How A2UI Works, Messages, and createSurface in the protocol specification.