Fabric: Verified AI-Composed Interfaces

One service contract becomes adaptive interfaces for ChatGPT, web, and voice. Fabric uses GPT-5.6 to compose them, then deterministic checks prove required rules survive.

Comment

Inspiration

AI is moving software beyond fixed pages and predefined workflows. Users will increasingly interact through conversation, while visual and voice interfaces are composed dynamically around the task.

Existing AI interface approaches create a difficult tradeoff:

  • Providers can hand-build every widget and retain control, but must recreate the experience for every surface.
  • AI can compose adaptive interfaces dynamically, but critical disclosures, confirmations, permissions, and transaction rules may be lost.

Fabric explores a third model:

The service defines what must survive. AI decides how it appears. Fabric proves the result.

What it does

Fabric is an AI-native Service-to-UI system for verified, AI-composed interfaces.

A service publishes one structured contract describing:

  • Capabilities and data semantics
  • Required disclosures
  • Confirmation rules
  • Permissions and constraints
  • Valid state transitions
  • Cross-surface obligations

GPT-5.6 uses the contract, runtime data, user context, and target surface to compose an adaptive interface.

The same service can produce different experiences for:

  • ChatGPT
  • Web
  • Voice or conversational surfaces

The presentation may change for each user and modality, but provider-defined requirements must remain intact.

Before an experience is delivered, Fabric runs deterministic conformance checks against structured evidence bindings. It verifies that required information is present, appears in the required modality, and occurs before the relevant transaction state.

A shared state engine also prevents agents and renderers from bypassing required steps such as explicit confirmation.

Demo scenario

Our prototype uses a flight-selection and booking workflow.

The provider contract requires that:

  • Total price is disclosed
  • Baggage information remains accessible
  • Cancellation terms appear before booking confirmation
  • The ranking basis is declared
  • Booking requires explicit user confirmation

Fabric composes different experiences from the same service contract for ChatGPT, web, and voice.

We then deliberately ask GPT-5.6 to create an extremely short booking response that omits the cancellation terms.

Fabric rejects the candidate experience, identifies the missing obligation, and sends structured repair feedback to GPT-5.6. The corrected experience is validated again and accepted.

Finally, the agent attempts to book without explicit confirmation. The shared state engine rejects the transition.

Why it is different

Fabric is not a JSON component renderer.

Traditional schema-driven UI describes widgets such as buttons, cards, and forms. Fabric describes semantic actions, obligations, evidence, and state rules independently of the visual presentation.

Fabric is also not merely generative UI.

GPT-5.6 is free to adapt layout, wording, information hierarchy, and modality. It is not free to remove provider-defined requirements.

The conformance checker does not ask another model whether an output “looks compliant.” It inspects structured Experience IR fields, evidence bindings, modality coverage, and canonical event ordering using deterministic code.

Architecture

Service data + Fabric contract
              ↓
      GPT-5.6 Composer
              ↓
    Candidate Experience IR
              ↓
 Deterministic Conformance Checker
              ↓
   ChatGPT / Web / Voice Renderers
              ↓
 Shared State and Transition Engine
              ↓
   Canonical Semantic Event Log

How we built it

The prototype is being developed as a small vertical slice rather than a complete universal interface standard.

Its core components are:

  • Fabric Contract schema
  • Typed Experience IR
  • GPT-5.6 structured composition
  • Deterministic conformance rules
  • Evidence bindings
  • Generation and repair loop
  • Shared state-transition engine
  • ChatGPT Apps SDK target
  • Web renderer
  • Voice or conversational renderer
  • Live conformance and semantic event panels

Challenges

The central challenge is separating creative presentation from deterministic guarantees.

Some interface qualities, such as visual attractiveness or subjective prominence, cannot be reliably validated with simple rules. For the prototype, Fabric focuses on machine-checkable guarantees:

  • Required semantic content exists
  • Evidence is explicitly bound
  • Required modalities are covered
  • Disclosures occur before specified states
  • Confirmation events exist
  • Invalid transitions are rejected
  • Verbatim legal content remains unchanged

What we learned

AI-composed interfaces need more than a rendering format.

They need a contract that distinguishes:

  • What AI may creatively adapt
  • What the provider requires
  • What the runtime can verify
  • What the execution engine must enforce

This turns interface generation from an unconstrained model output into a testable software pipeline.

What's next

Future versions of Fabric could add:

  • MCP and OpenAPI capability imports
  • Accessibility obligation profiles
  • Brand and compliance contracts
  • More target renderers
  • Cross-service interface composition
  • Contract versioning
  • Conformance certification suites
  • Auditing and observability
  • Enterprise policy integration

Fabric gives AI a language for creating interfaces and gives services proof that it followed the rules.

Built With

Share this project:

Updates