UX CASE STUDY · AI SYSTEMS · 2026, ongoing
An AI agent that runs itself, without running off.
AXOS plans work, writes code, drafts my outreach, and reports back on its own. Every risky move runs through a governor I designed: a budget breaker, a safety guard, and a review queue where I stay in the loop. The brief was simple to say and hard to build: make an agent I can hand real work to and still trust with my repos and my money.
I designed it, built it, and shipped it: the React dashboard, the FastAPI backend, the three-tier routing, and the governor itself. The design goes all the way down, and I wrote the code that backs it.
The Problem vs. The Solution
Most AI agents land in one of two piles. Either it's a chat box that forgets everything the moment you close it, or it's a script running with permissions skipped that you quietly pray won't delete your home folder. I wanted the thing in the middle: something that could actually do the work but that I could leave alone with a codebase and a weekly budget. That turned out to be a design problem more than an engineering one.
The trust problem
Trust in an autonomous system comes down to three things: what it shows you, what it asks before it acts, and what it physically cannot do. Those are interface decisions. I wrote the constraints down before I built anything, and they shaped every screen.
The governor
The home screen is a dashboard, not a chat window. The governor is on the wall: budget as a percentage of the weekly cap, breaker status, live system vitals, and the one toggle that actually matters, SUPERVISED versus AUTO.
The Impact
It's shipped, governed, and running my week. These numbers are the shape of the system rather than a launch metric: the discipline is the deliverable.
Key Design Decisions
Trust is built screen by screen. These five calls shaped the product, each one made against a constraint I'd written down before building.
AXOS is the platform; OrcA is the agent you talk to. The giant wordmark is the system nameplate, the persona is in the masthead, and every reply is signed by it.
Splitting the two kept the interface honest. You're addressing an agent that lives inside a system, the way Siri lives inside iOS. The orca-pod metaphor (projects are pods, the task board is the hunt, analytics is sonar) gives a dry ops tool personality without turning decorative.
Front and center on the home screen: the weekly budget as a percentage, breaker status, live system vitals, and the SUPERVISED/AUTO toggle. Flip AUTO on and the header switches to HANDS OFF.
The scariest part of an autonomous agent is not knowing what it's spending or whether it's about to go sideways. Moving budget from dollars to a percentage was deliberate: it maps directly to the number the breaker actually trips on, and there's no ambiguity about what mode you left it in.
Every run lands in a costed ledger, and SONAR turns that into plain analytics. AXOS routes each task to the cheapest tier that can handle it, and the breakdown makes that visible.
The charts aren't the point. The point is that a probabilistic system earns trust by being auditable. Most tasks never reach the expensive tier, and when OrcA spends, I know where it went.
AXOS suggests; I decide. Every weekday it drops a grounded to-do list built from my real context. Nothing auto-sends, drafts are editable, and a genuine fork parks the task and asks.
Starting a conversation opens a real chat window instead of firing the task off silently, so I can watch the answer land and steer from there. Asking beats guessing.
The agent can read across my drives but physically cannot delete anything it didn't create without my go-ahead. Autonomous file-writing runs only touch git repositories and only run with AUTO on.
Every change is reversible with one command, and the rule rides along in every single run. I built the guardrails as defaults instead of warnings: the safest path is the one it's already standing on.
Handing work to an agent, both ways
The operator's side of the loop. The old flow is every agent setup I tried before building this; the new one is my actual morning.
- 01Re-explain the whole context in a fresh chat box
- 02Copy anything useful out by hand before the tab dies
- 03Babysit any script that has write access
- 04Reconstruct after the fact what it did and what it cost
- 05Start over from zero tomorrow
- 01Read the weekday brief, grounded in my real projects
- 02Edit what's worth doing, approve it into the queue
- 03Watch the run land, costed, in the ledger
- Re-explain the whole context in a fresh chat box
- Copy anything useful out by hand before the tab dies
- Babysit any script that has write access
- Reconstruct after the fact what it did and what it cost
- Start over from zero tomorrow
- Read the weekday brief, grounded in my real projects
- Edit what's worth doing, approve it into the queue
- Watch the run land, costed, in the ledger
Six views, one system
A dark, high-density ops console that still has a point of view: big Archivo type, one hot magenta, mono labels for the machine-readable bits, an orca mark up top. Masthead doubles as the nav on every route.
Design Process
Constraints first, screens second. I wrote down what the agent must never do before designing what it would show, then built front to back and fixed the problems only shipping reveals.
- ▸Wrote the hard constraints before any screen
- ▸Named the trust problem: visibility, consent, hard limits
- ▸Split the platform (AXOS) from the persona (OrcA)
- ▸Dashboard-first home screen, not a chat window
- ▸Orca-pod metaphor across all six views
- ▸One visual system: big Archivo type, one hot magenta, mono labels
- ▸React, FastAPI, and SQLite, front to back
- ▸Three-tier routing: free local check, small gate model, Claude for the real work
- ▸Guardrails built as defaults instead of warnings
- ▸Shipped it, then lived in it daily
- ▸Fixed the silent launcher, the flashing consoles, the truncated replies
- ▸Lifted chat into a stable window after feeling the board jump
The part that isn't in a Figma file
I built the whole thing front to back, and the hard problems were the ones you only find by shipping. The desktop launcher looked finished but opened nothing: it ran the server headless, which tripped a logging call before the port could bind. Console windows flashed every few seconds until I traced them to the dashboard's own background checks. Chat replies were dying mid-sentence because an old preview truncation had quietly become the only copy being saved. And the chat card jumped between board columns as its status changed, so I lifted the conversation into a stable window that stays put while the card moves behind it. None of that shows up in a static file; all of it decides whether a person keeps using the tool the next day. What's next: a real small-screen pass, keyboard navigation and screen-reader labels verified to WCAG AA rather than assumed, and deeper repo access for plain chat. The brief was vague and slightly nervous, a trustworthy autonomous agent. It's now legible, governed, reversible, and running, and I wrote the code that backs it. If you want to see it move, I can walk you through a live run.
Let's build something impactful.
I'm currently open to new opportunities in UX/UI Design, Product Design, and GovTech transformation roles.