From context to interface.

AFS gives a task a named, inspectable view of the resources it can work with.

A path identifies a resource within a namespace, so operations can refer to it explicitly.

A provider implements resource operations; a mount places that provider in a namespace.

Naming a resource is useful only when consumers can understand what operations on it mean.

A Small World presents the resources relevant to one observer, rather than exposing the whole system.

An entry path and the resource’s original location are different things.

Location, supported operations and caller authority are separate questions.

Reading the same address and receiving changes are separate steps.

A shared address does not decide how stale edits are handled.

Finding relevant content differs from selecting records by explicit conditions.

Missing, unsupported, denied and conflicting operations need different responses.

AFS-UI treats the interface as a projection over operational context that humans and agents can work with.

A visual control can correspond to named structure, state and actions, rather than only a region of pixels.

Separating context from projection lets multiple views refer to the same operational objects.

A display presents and accepts interaction; a session groups the operational state associated with an interaction context.

Inspection should expose the actual structure of the active view and its relationship to state.

Computation and the place where a person sees and controls it can be separated.

Compatible resource addresses and operations let parts cooperate without sharing every implementation detail.

Agentic UI Protocol describes interface structure and its connections to state and actions.

Read identities, types, properties and children through one task card.

Reading resources, writing input and updating properties are distinct connections.

Trace an interface event to an explicit operation target.

Capability declarations and degradation determine how a structure reaches its target.

Eighteen core types provide an entry into the interface vocabulary.

Organizing content and interfaces into a website is another layer of work.

One describes interface contracts; the other organizes a Web site implementation.

Distinguish core primitives, Web-only types and theme components, then browse the default theme.

view organizes child nodes and expresses their arrangement.

text expresses words, heading levels and supported formats.

media expresses media kind, source and alternative information.

input describes an input control; change represents value changes.

action expresses a triggerable action or navigation entry.

overlay expresses dialogs and other overlaid interfaces, with explicit open or closed state.

table uses column definitions and row data for comparable records.

time expresses dates, clocks, countdowns and related time information.

chart expresses data visualization; Web drawing has its own implementation.

map addresses geographic locations, map centers and markers.

calendar organizes events into month, week, day or agenda views.

chat is a core type, but needs a supporting session target.

rtc reserves a name for real-time communication; it is not yet a usable calling control.

explorer describes a resource-browser subsystem; the runtime must support its expansion and presentation.

editor supports code or text editing; saving depends on explicit connections.

canvas provides freeform drawing; the application connects saving and sharing.

surface provides an embedding boundary for resources or remote AUP.

afs-list presents AFS resource collections as lists, grids and other arrangements.

Compare responsibilities, addresses, state and interaction contracts.

Render agent-provided interface descriptions through client-supported components.

Bring interactive HTML interfaces from MCP tools into supporting hosts.

Separate the standard from implementation tooling and legacy compatibility.

Agent–application event exchange differs from interface description.

It provides implementation tools for generative interfaces in Flutter.

Compare its design workflow separately from runtime protocols.

Compare scope, resolution and available operations.