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
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 ComposerThe 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
|
Sovereign or Cloud – Costs are OptimizedPer 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 SystemsReasoning 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 userThe 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 FlowThe 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.
|
Prompt Composer
The benefit is concrete:
|
Fusuma (襖) AI Systems ArchitectureThe 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
Solution Overview: Preventing Model Failure and Cost Uptick










