Model Agnostic AI-Native Design System Harness

Model Agnostic AI-Native Design System Harness

Project: Raibach IDS (Enterprise Grade Agent Builder and Interactive Design System)
Timeline: June 2026 – Present
Role: Principal Designer – System Designer, UX strategy, React/Python frontend development, theme design
Demo: Studio Demo Raibach-IDS  (access pin is on resume)
Github: Github.com/Raibach 

Project Summary

This project is a continuation of an AI-lifecycle management system discovery phase contract with Southern California Edison. I did deep research into how users adopt and maintain agents in enterprise environments, allowing  users at varied skill levels to build an agentic user interface to manage agent work flows. A working A2UI reference implementation: a React shell (deterministic chrome, auth, routing) hosting a Lit-Web-Components surface that an LLM assembles at runtime from a validated catalog, with FastAPI + PostgreSQL behind it.

I’m in the process now of adding skills and the background data that will link the design system and various sandboxes used by the organization’s different teams or departments. It supports the design system, business requirements and research synthesis by UX teams and it serves the front-end to customers. All agent activity in the system is related to maintaining customer experiences, user flows for customers and the frontend design of your business. It also manages backend collaboration with product teams, fine-tuning DesignOps and governance observability for all stakeholders in one Enterprise grade harness. This case study outlines phase one – the foundation of the system design work.

Every action optimized and what the system costs to run – of course, speed and lower costs are the objective otherwise we would continue to just use our standard deterministic process.  I decided to continue building this project in AI-native using A2UI protocols, which allows the application to fully assemble from a Lit catalog using only AI. It’s wrapped in a React shell which holds the AI-native surface. The goal was to create a model-agnostic sovereign (local) system architected for seamless adoption and user growth.

Every Action Optimized:
What the System Costs to Run

The cost of an AI-native interface depends on how many decisions the model makes; this system is built to minimize them. A model produces the next token from a set of tokenized component repositories –  stored locally, not on Figma cloud. With the catalog fixed and every value bound by path, the set: the model output is deterministic instead of guessing. Reasoning tokens are not used for assemble of the frontend, and that is a huge cost savings, no hidden reasoning expense from cloud services.

 

At enterprise volume: Current cloud pipelines cost company’s about half a cent of model compute per console load at commodity cloud prices; a hundred million loads a year is about half a million dollars. This software  can reduce costs by two-thirds fewer tokens and four times less latency, which means fewer machines for the same work. Assembly can even run on smaller local models because the catalog makes output deterministic; only the conversation interface needs reasoning.

The “Progressive Trust” frameworks proved a single interface for both novices and experts without compromising safety or capability. By centering the design on user confidence rather than technical complexity, I created a foundation for enterprise AI adoption that balances innovation, compliance and optimized computing costs.

Model-Agnostic by Design”:   open standards (A2UI/MCP), no dependency on any one provider, no cloud requirement, assembly on a small local model, the whole stack runnable on local hardware (PostgreSQL, embedded vector store with local embeddings, local models for assembly/conversation/governance), and businesses can wire any local system or any cloud service — the platform is the harness, not the subscription.

 

The Console: Onboarding Users with Role-Based Features

The Console is the central management surface – some cards represent agentic flows. Some cards represent other types of AI computing, a prompt can be a flow or it can be an analysis or output: a card grid of packages, reshuffled and filtered by AI commands over the same assembly channel. A Trace tab records everything the page can see about itself,  network calls with status and duration, events, errors, audit summaries, and main-thread stalls are all visible to CTOs, product teams and designers — so a slow load is explained, not guessed at. I call this Agile observability. The console chat works at the level where the user is – it’s not a global placeholder, it is filtering the system and focusing governance and conversations at the package level.  Each user gets role-based conversation, for the console and  conversations belong to packages. Its output is the system itself filter to the users actual needs: which cards are shown and in what order, what is waiting approvals, notifications, etc. New console behavior arrives through that same conversation, which is where the channel plugins, metrics, and console customization are managed too.

 

 

The Prompt Composer

The working surface: a section editor on the left, compiled output in the middle, and the conversation panel on the right, with version trace, token-cost and status readouts, and per-package chat scoped from the first keystroke. Packages carry role-based capability (what each role sees and can do), provenance, and audit history as first-class metadata — the package is the aggregate root, and governance travels inside it – not in a separate location, rather access is managed by permissions and roles.

The output column is a slot, so a plug-in can take it over and change what the workspace does: Plug-ins arrive as commands in the same console conversation, so the surface scales without the system being rebuilt every 2 years. The pace of AI scaling will probably be even faster than that.

Expand and Scale with Plug-ins

  • Read and annotate documents inside the package, research synthesis without leaving the work
  • Connect to Confluence, so a package reads and writes where the team already documents
  • Connect to other enterprise services through the same channel
  • Work as a design surface, laying out and inspecting interface structure the way a CAD program lays out parts
  • Manage design system elements across levels and brands per team, per product, per brand, each with its own catalog

Sovereign or Cloud – Costs are Optimized

Per console load, three model calls became one: about 11,280 tokens down to 3,551, 68% fewer, and a 27% estimated request-failure rate went to zero.   Each failure removed saves the two attempts it would have spent about 7,500 tokens on a screen that never appeared. The report and alerting system prevents future failures and hardens the performance layer further reducing costs and expanding transparency.

Thinking Systems

Reasoning runs in one mode. Surfaces run without it; as well as tagging, summarizing, and recall, and that is the default, so a AI that forgets its mode still gets the low-cost path. The conversation is the only mode where reasoning runs, because it is the only mode where the deliverables are set by contract and hardcoded registry parameters the model must follow or fail generating a report for correction.  Governance and cost come from the same mechanism: the annotations, the checks, and the catalog are what keep every action minimal.

 

Everything lives in the package. The prompt sections, the compiled output, the conversation, the run trace, the version history, and the governance records are all held in one unit: the package.

There is no separate destination for writing a prompt, holding a conversation, reading a trace, or checking a version. All of it happens in the same package: the editor, the output, and the conversation are three views of one package, not three places to move between. The package is what gets versioned, shared, and audited, and everything it holds stays tied to its prompt ID indefinitely.

The benefit to the user

The work and its record never separate, reopening a package brings back its conversation, output, trace, and history as they were even if shred – all group activity is traced as well, and sharing a package shares all of them in one unit.


Working with Figma

Annotations and the Import Pipeline: the system is sovereign; it never requires the cloud or the Figma canvas layer.

Every component carries a Dev Mode annotation tied to its node ID as the single source of behavior; the import pipeline extracts layout, visuals, and the annotation together and writes each component into the Lit catalog, the allowlist, and the design map with verbatim-vs-inferred provenance. It includes the per-component import report (ANNOTATED / MISSING / NO-NODE / PULL-FAIL) and the data-node-id, and closes with the sovereignty point stated loudly: Figma is the drafting table, not the foundation – if the connection to Figma is lost, the design system loses nothing, because every component, annotation, and provenance record already lives in the repo. Components are added to your own catalog, not rented from a platform.

Key Challenges

The original problem: AI-generated interfaces that are ungoverned will drift and suppress errors.

A runtime models can conceal errors and quietly replace a failed response with stale results. For an enterprise, that means three things at once: no standardization (every session outcome cannot be tracked), no auditability (nothing traces a pixel back to a decision), and silent failure (the screen goes blank or wrong without a record of why or when). Cloud systems like Figma hold the design components, the one artifact that actually states intent sits outside the build entirely, so code and design can drift apart in both directions.

My solution is not reliant on Figma servers. 

User-Centered Solution: Unified Adaptive Flow

The fix is to structure the system so the model cannot misbehave. Fix the catalog, bind values by path, and the answer space collapses – the model must comply instead of choosing next steps (failures are loud and zero trust), which is precisely where checks should be generated for improved performance.

Governance is not a layer added to the product; it is the spine holds it all together allowing continuous improvement.

Prompt Composer

 

The benefit is concrete:

  1. You never reconstruct context. Reopening a package brings back its conversation, its output, and its trace together, so you resume where you left off instead of reassembling what you were doing from separate tools.
  2. One thing to share. Handing someone a package hands them the prompt, the conversations, the output, the version history, and the governance records.
  1. The record travels with the work. When someone asks what produced an output, on which version, under what review, the answer is in the same place the work is, rather than in a separate system you have to reconcile later.

Fusuma (襖) AI Systems Architecture

The philosophy: UI structure that’s not rigid, components that can be detached and recomposed without the whole thing collapsing.

The workspace customization is built like a Japanese sliding-door house (Fusuma 襖): the panels are movable walls, not fixed rooms. Push the chat to the right or the prompt column to the left and the canvas takes the whole floor — then slide either one back and the room returns, chat rail and all.

The deeper idea behind both is what the UI does to present this information as a flexible space that adapts to the user task, not the other way around – one interface does it all: impermanence of space. Rather than committing to permanent rooms, the house breathes with the day, the season, the number of people present.

 

 

Full width canvas – this output space can take over the entire screen, which allows you to import other applications like CAD or schematics for in-field workers.

Development Seat

How design is the code:

Early design exploration showing the solution is not only collaborative by design but also reflects real-world AI teamwork patterns where contributions from multiple experts (Product, engineers, domain leads, reviewers) are combined into certified, reusable response formats.

A deterministic shell, with AI filling slots. The React + Lit shell renders unconditional navigation, frame, error states, slot containers regardless of what the AI does or doesn’t do. The AI decides which prompt blocks, data, and chat populate the left/middle/right slots; it cannot create or remove them. If the AI fails, the shell shows the failure. If it is slow, the shell shows loading delays. The user never stares at a blank page.

Design intent as the source of truth. The Figma-to-Lit pipeline makes the design the specification: every component is extracted node by node, with the designer’s Dev Mode annotations as the single source of its behavior. We are transferring designs into a catalogue. We are not using MCP to call them from a cloud service, even if it is Figma. Each element is registered in three places, and all three must agree:

  1. The allowlist — what may be rendered (tag-registry.ts)
  2. The design map — which Figma node each component came from (registry.json, with provenance)
  3. The catalog schema — what the server validates every AI payload against (catalog.json, per pipeline; unknown components get a 503)

The audit that gates delivery checks exactly this, and it does not accept intent as evidence – only records. A behavioral element that no allowlist entry, catalog entry, design-map entry, or design pattern claims is refused at build time.

Saving time and tokens & the economics of constraint 

With reasoning turned off for surfaces, the same prompt returns the same valid JSON: 251 completion tokens instead of 460, 1.53 seconds instead of 6.05. Assembly moved from three model calls racing against a 10-second contract (about 11,280 tokens per console load, 27% of requests failing with 503 errors) to one call at 3,551 tokens — roughly 68% fewer, with zero failures — because the catalog fixes the answer space and every value is checked.

Governance and Verification

Verification is structural, not cultural. On every build and every change, the pipeline runs:

  • The catalog audit – every component must trace to a drawn node and an annotation; zero blocking findings.
  • Doc-claim drift – a stale number in the documentation fails the build; it does not wait to be remembered.
  • The registers – the open-items register and the corrections ledger, whose recorded counts, cited findings and even tracked status are checked; drift fails the build, and a corrected finding that comes back fails it as a regression.
  •  Automated tests, covering the surface contract, the envelope, the panels, and the failure modes run on Figma to catalog pipelines wiht MCP servers and REST API busting the Figma barrier designed to force companies to upgrade to Figma enterprise accounts for this same ability (Code Connect).

Beyond the build, a governance inspector runs daily on local models: the code prepares an evidence sheet and decides every fact, two models classify it independently, and any disagreement is stored with both answers — a second opinion over the state of the repository itself.


Solution Overview: Preventing Model Failure and Cost Uptick

The solution lives in the architecture. Companies want to prevent errors, not simply document a backlog of failures. That’s not governance. The working doctrine behind the platform is live-verification design engineering: claims are hypotheses; only observed runtime behavior is knowledge. Every assertion earns a mark: verified with a receipt, partial, or specified-not-built and anything unverifiable is demoted until it can be verified.

UX Focus

Documentation synchronizes after behavior, never before; if the record and the runtime disagree, the runtime wins and the record is corrected. Frontend behavior is verified like a person experiences it: does the loading state exist, does failure render as guidance rather than blankness, can the user undo it – basic error correction is managed by the system – thinking systems comes from this process. Humans are busy, they miss things; they are not able to diagnose error in real time. Precisely the reason we use technology is to enhance our ability to perceive the world and understand it. So leaving the user out of the equation, defeats the entire purpose.

Adaptive Design for Varied Skill Levels: Single interface serving novices and experts simultaneously through progressive disclosure, accelerating adoption without compromising capability.

Discovery-Driven Governance: Research revealed that centralization wasn’t about control, it was about user trust through insights. Audit trails, performance tracking, and transparent review workflows built confidence in AI outputs and services.

Scalable Foundation: Personas, journey maps, and information architecture continue to inform enterprise AI strategy beyond the initial discovery phase.

Progressive Disclosure Strategy

The interface adapts based on user behavior. Users can engage with the application to the extent of their capabilities or ignore those features and still get the outcomes that they’re seeking. The only adoption barrier to use ability is the users willingness to engage or the courage to take a chance with the application, which is very forgiving and allows them to quickly undo or step back any process they need to. This fundamentally improves adoption with growing trust, often missing wiht enterprise grade accountability.

Novice path: Pre-built templates, contextual help, guardrails preventing unsafe configurations.

Intermediate path: Template customization, parameter tuning, basic agentic features.

Advanced path: Full control over prompt engineering, multi-agent orchestration, custom tool integration.

This eliminated the need for separate “beginner” and “expert” modes while maintaining safety and governance.

 


Agile observability

The research phase focused on understanding adoption barriers during the discovery phase on the project for Southern California Edison. Users across a diverse base and designing for trust in a high-stakes environment requires Agile observability:

  • Annotate before building. A design without an annotation gets flagged empty by the audit — the missing specification is the work, not an obstacle to it.
  • Governance-first architecture. Audit trails, role capability, and provenance ride inside every package, so adoption and compliance are the same motion rather than competing ones.
  • Keep the laboratory out of the shipping lane. A multi-gigabyte model experiment run alongside the product very nearly took the delivery pipeline down with it. The fix was not to stop experimenting, but to build a wall between the experiment and the line.

Outcomes

  • A live, audited platform built on open standards (A2UI protocols using MCP) with no dependency on any one model provider; models can be replaced without giving up the component tree or the production logic.
  • Zero blocking audit findings across both pipeline catalogs; 372 tests passing; the catalog audit and doc-claim checks running on every change.
  • A 68% reduction in tokens and roughly a 4× reduction in latency per console load, with the 27% request-failure rate eliminated entirely; assembly can run on a small local model because the catalog fixes the answer space.
  • Every element on screen traceable to a design node and an annotation that states what it is for and how it performs.

 

 

 

 

 

 

 

Previous SCE Project Deliverables