Auraa Semantic Flow

Transient, Data-Driven Interfaces for Agent-Human Collaboration

Every new agent capability runs into the same constraint: the frontend. What takes hours on the backend takes days in the interface layer. Your AI roadmap is not held back by the models.

Key takeaways

One definition, two surfaces

The same descriptor renders on web and conversational surfaces.

14-type catalog

Confidence-scored approvals, pipeline groupings, wizard chains.

Transient by design

Interfaces expire on completion. No stale state to maintain.

Under two hours

A full approval wizard shipped with no new frontend code.

About this white paper

Interfaces agents build, not engineers

Auraa Semantic Flow gives agents a catalog of structured interaction types so they can present complex proposals to humans without a single custom frontend page. This paper documents the InteractionDescriptor pattern, the transient lifecycle model, and the fourteen-type section catalog drawn from real enterprise deployments.

  • Written by the team that built and operates the platform
  • Includes the trade-offs we accepted, not only the wins

Read the architecture before you build it.

Twenty minutes of reading that can save a migration. No form, no gate, straight to the PDF.

Questions

Questions architects ask us

Free text responses require the human to parse and interpret the agent's output before acting. For a multi-part proposal (multiple pipeline changes, each with confidence scores, policy implications, and approval requirements), a prose response forces the reviewer to extract structure from narrative. Buttons work for binary decisions but cannot represent the nuance of a multi-step approval with partial acceptance, conditional flags, or dependency chains between components. A richer interaction model represents the proposal's structure explicitly, so the reviewer can engage with each component directly.
The InteractionDescriptor is a JSON-serializable envelope that fully describes an agent-human interaction: its type, the sections it contains, the data in each section, the actions available to the reviewer, and the completion conditions. Because it is defined in a single backend definition, the same InteractionDescriptor renders on a web interface as a structured form or wizard, and on a conversational surface (such as a chat interface or voice assistant) as a structured dialogue. Teams write one backend definition and get both surfaces without additional frontend work.
In a traditional frontend, interfaces persist until explicitly removed. An approval page for a pipeline change that was approved last month still exists in the application state and must be cleaned up. The transient lifecycle model makes interfaces ephemeral: they are created when an agent needs human input, presented to the reviewer, and automatically expired on completion. There is no stale interface state to manage, no cleanup job to run, and no accumulation of historical interaction records that need pruning. The maintenance overhead of managing interface state disappears entirely.
The 14-type catalog was built from real enterprise scenarios encountered during Auraa's production deployments. The types cover the range of interactions between agents and human reviewers: confidence-scored approvals (where the agent presents its confidence level alongside the proposal), pipeline groupings (where related changes are presented as a set for batch review), execution progress (where the agent reports intermediate state during a long-running operation), and multi-step wizard chains (where a complex decision is broken into sequential steps with branching logic). Each type has a defined structure, rendering spec, and completion model.
The whitepaper documents a multi-step pipeline configuration wizard that includes policy preview (showing the reviewer the governance implications of each configuration choice before committing), conflict detection (identifying cases where the proposed configuration conflicts with existing tenant policies), and a full approval workflow. The entire wizard was delivered in under two hours with no new frontend code. The underlying agent capability was ready; Semantic Flow eliminated the interface development time that would otherwise have been the bottleneck.