ARIA
Model-based reasoning, interface generation, and refinement.
Made for interface researchers and developers.
Overview
This engineering project is under active development. The scope below describes its intended design; deployment readiness and supported capabilities must be confirmed for each engagement.
An interface generator needs to understand more than a text request. It needs to know what data exists, which operations are available, what the user is trying to accomplish, and how the result should connect to the application.
ARIA organises that information into explicit models and a validated intermediate specification. Reasoning chooses an interface structure using the available context. Rendering consumes that structure through known component mappings. Application data operations remain behind a resolver boundary, giving product teams an identifiable point of integration.
What it provides
Model stack
Represent the product and task
The domain model describes entities, fields, relationships, and operations. The task model describes goals and task structure, while the user model captures preferences, history, and profile information relevant to the experience.
These models give the planner structured context for an interface decision. Traceability information connects generated interface nodes to their declared domain and task references, allowing the system to check whether those references belong to the provided model.
The architecture draws on Model-Based User Interface Development and applies that lineage to a modern TypeScript runtime.
Reasoning and Abstract UI Specification
Intent resolution and context assembly prepare information for the planner. Provider routing separates that planning interface from a single LLM provider. The output is validated against the Abstract UI Specification schema before the rendering stage uses it.
The specification contains a component tree, data bindings, and traceability information. It acts as a stable contract between reasoning and presentation, giving developers a concrete object to inspect and validate rather than requiring them to interpret a generated page as the whole result.
Renderer and application integration
A React renderer maps abstract nodes to registered component implementations. The registry can be extended with product-specific components, while a data resolver connects declared operations to the host application's data layer.
The SDK brings the pipeline together through `useARIA`, exposing the rendered result, specification, generation state, and errors. A pre-authored fallback specification supports a static mode and a recovery path when generation is unavailable.
Runtime adaptation and conversational refinement
The runtime scores interaction signals into user-profile dimensions and compares profile changes to determine whether an adaptation should be considered. Different changes can lead to focused patches or a new plan, with reasoning information attached to the decision.
Conversational refinement lets the user request a change to the interface, while undo provides a way to return to a previous result. The framework therefore connects initial generation to an ongoing interaction loop rather than treating a generated view as a one-time artefact.
Integration example
A product defines a catalogue domain with available fields and operations, supplies a browsing task, and connects a data resolver. The planner generates a validated catalogue interface, which the registered React components render.
The user can then ask for a different presentation through refinement or restore the previous specification through undo. If generation fails, the host can supply its pre-authored catalogue view as the fallback. The product playground makes these stages available for inspection.
Built with
Baobab built the model schemas, reasoning pipeline, renderer registry, runtime adaptation logic, and SDK as separate packages. The architecture preserves a clear boundary between the planner's output and the components that present it.
ARIA demonstrates structured AI integration in a developer framework: models constrain the available context, a schema validates the output, and the host application provides the actual data and component integrations. These boundaries make experimentation easier to inspect and extend.
Questions
Is this available for deployment?
Deployment readiness has not yet been verified for this catalogue entry. Contact us to discuss current scope, release gates, and your requirements.
Who owns this software?
This is owned engineering work from The Baobab, a brand of Fortezza Nuova Enterprise. Deployment and licensing terms are agreed for the relevant product.
Use ARIA in your product
Discuss the capabilities you need, deployment environment, and integration responsibilities. We will confirm current readiness and agree a scope before committing to a release.