A clinical product with AI already in it, and an open question about where it should go next. As the sole product designer, I defined how every future AI agent should behave — before any of them were built.
<10s
North star: Verify and approve an agent's work in under 10 seconds
4
Shared status states used across every agent type
0
Silent AI actions, the clinician approved everything
Therasoft already had AI-assisted notes in the product. The question from leadership was broader: where does AI go from here, and how do we expand it without confusing customers or breaking the trust we'd already built? There was no spec and no defined scope — just an open question and the expectation that I'd find principled ground to build from.
Scattering new AI features across a clinical product without a consistent model would fragment the experience and amplify fears customers already had: what data is being captured, when is AI running, and can it be turned off. Some customers wanted AI removed from the product entirely. Getting the model wrong wouldn't just confuse people, it would erode the trust that kept them on the platform at all.
Any AI in a clinical product touches Protected Health Information. The design had to define exactly what the AI ingested, acted on, and discarded — so a clinician could never apply a diagnosis, note, or billing code to the wrong client.
The brief was a single open question. The framework had to exist — and be defensible — before anyone could build a single feature on top of it.
AI-assisted notes had already shipped. Whatever came next couldn't undermine the trust customers had cautiously extended to the AI already in the product.
This wasn't a neutral audience. Some customers wanted AI gone. The design had to earn their trust, not assume it.
Before any of that, I interrogated the premise itself. Leadership wanted AI, but my first job was finding where it genuinely helped — I asked the team and clinicians what took the most time each day, then tested which of those pain points AI could actually reduce, rather than adding features to satisfy a mandate. Only once I knew AI earned its place did the real question begin: how to add it without breaking trust.
I wrote a design-first proposal rather than a feature list. The goal was to establish how AI should behave, which guardrails were non-negotiable, and what the interaction model would look like across every agent type — before engineering began. The bet was simple: get the trust model right once and every future agent inherits it; get it wrong and each new feature compounds the problem.
Three principles anchored everything that followed — verification, user control, and visibility. They weren't framing language; they were the test each design decision had to pass. The HIPAA safeguards weren't a feature on top of that work. They were the precondition for the product existing at all.
The default approach would have been to embed AI wherever it was useful, a button on the calendar, another in notes, another in billing. I rejected that early, because scattering AI across the product is exactly what would have amplified the fears customers already had: not knowing where AI lived, when it was running, or how to switch it off. So the framework did the opposite. One context-aware side panel became the single front door for everything AI — visible, predictable, and closable. The architecture was the trust principle made physical: if people are wary of AI being everywhere, the design answer is to make it live in one place they control.
That panel reads the page you're on and pre-loads the questions you're most likely to ask before you ask them — on the calendar, it surfaces scheduling questions. One click into the agent inbox shows exactly what every agent has done, sorted by urgency: Needs Attention in red, Needs Review in amber, complete in green.
"The focus of this proposal wasn't whether to build AI agents — but how to design them correctly the first time, so they're buildable, scalable, and trusted by clinicians."
- From the original design-first proposal
The context-aware side panel shipped as the single AI entry point across Therasoft. Its questions were preloaded from the most frequently asked support queries, so it answered real user questions before anyone needed to call support.
The result that mattered most wasn't a metric — it was a reversal. Customers who had wanted AI removed from the product entirely chose to keep it, once they could see what it did, control what it touched, and turn it off when they wanted. The three principles established before any screen was built had done their job.
The sections below hold the fuller story — how I scoped an unscoped brief, the constraints that shaped the model, and the reasoning behind each principle.
01
Interrogating the premise before designing a single feature
Principle: AI earns its place by breaking ceilings good design can't reach — not by patching problems better UI already solves.
02
Defining what the AI ingents, acts on, and discards
03
Verification, user control, and visibility of system status
These three principles became the test every later design decision had to pass — not framing language, but a working filter.
04
Reading the page to answer questions before they're asked
05
One view of everything the agents had done
06
The honest scope of what shipped, and what lasted
The panel, the status model, the agent icons, and the interaction principles became the base pattern for Therasoft AI. The product direction changed after my involvement ended — but what was built next was built on this foundation.
The lasting lesson: in a product where users are actively skeptical, trust isn't a tone you write into the copy — it's a structure you design into the behavior. Define how the system has to behave first, and the features that follow are trusted by default instead of fighting for it one at a time.