Portfolio · AI product design

Mono

I explored how to give a finance agent a controlled way to interpret intent, choose a workflow, and return an interface people can inspect.

Year
2026
Role
Solo product designer & builder
Duration
2 weeks
Industry
Personal finance
Tools
LangChain · React
Visit Mono
  • AI interaction design
  • Generative UI
  • Design systems

At a glance

The challenge

Flexible conversation needs a dependable path from intent to data, interface, and action.

My approach

Let the Agent choose and compose supported components. Define their data, states, and confirmation rules.

The exploration

A working implementation of intent-led responses, component contracts, and reviewable actions.

01 / My role

I designed what the Agent can compose—and how people stay in control.

Mono is my independent exploration of conversational personal finance. I owned the product flows, UI system, component contracts, and implementation, from interpreting a request to confirming a record.

Working exploration · A recorded view of the system in use. The workflow and handoff diagrams below explain the design behind its responses.
  • Set the interaction model

    Define how intent, missing information, and user decisions shape the workflow.

  • Define the UI contract

    Specify supported components, required data, and user actions.

  • Build the vocabulary

    Connect visual rules and reusable cards to a working renderer.

02 / Design direction

How much freedom should the model have over the interface?

I compared three ways to give a model a role in the UI. My design problem was consistency: each request may need a different answer, while amounts, time ranges, and save actions need a stable structure.

  • Select a prepared view

    Predictable presentation, with composition limited to predefined screens.

  • Compose components · chosen

    Flexible answers within a designed vocabulary of data and interaction contracts.

  • Generate interface code

    More presentation freedom, with a larger validation and execution surface.

I chose declarative composition. Information architecture connects the task to a component; progressive disclosure lets the answer expose the details needed for that task. This direction came from design and technical exploration.

03 / Agent workflow

From intent to a workflow, then to an interface.

I structured the Agent around a LangChain intent router and task-specific chains. Product code dispatches the request, retrieves or calculates the required data, and prepares a supported UI response.

From intent to an interface

Intent routing. The request and available context enter LangChain, which returns a structured intent for product code to dispatch.

Mono: from intent to a structured interfaceLangChain routes a request to a task chain or domain service, missing information prompts clarification, and a structured response is checked and rendered by product-owned components.READY FOR UIMISSING INPUTREPLY + CONTEXT01 / INPUTRequest + contextMessage · time · currencyAvailable user context02 / MODELLangChain routerPromptTemplate → modelwithStructuredOutput03 / PRODUCT CODEDispatch & executeTask chain / domain serviceParse, retrieve, or calculateFOLLOW-UPClarify & continueAsk for missing informationCarry the request forward04 / STRUCTURED OUTPUTResponse contractIntent · component · dataFeedback · schema check05 / CLIENTProduct-owned UIRegistry + dedicated viewsDefined styles and actionsProcessing pathClarification returnStructured-UI path shown. Text-only replies bypass UI composition.
Agent workflow · LangChain handles structured intent routing and task chains; product code handles dispatch, data services, response validation, and rendering. Text-only replies bypass UI composition.

When required information is missing, the workflow asks a follow-up and carries the request forward. The model does not have to finish the task in a single response.

04 / UI contract

The output is a contract the product knows how to render.

I defined the handoff as intent, component, data, and feedback. Schemas constrain the output; the component vocabulary defines what can be rendered and which interactions it supports.

  • Model · interpret

    Preserve the request’s meaning and produce structured intent and task output.

  • Services · ground

    Provide records, context, and calculations to the response.

  • Client · render

    Map supported output to registry components or dedicated business views.

The interface vocabulary includes what a component can do, not just how it looks.

I paired visual tokens with component names, props, data requirements, and action rules. These make the design system usable as an implementation contract.

05 / Human handoff

Preparing a change and saving it are separate steps.

I placed an explicit review between Agent output and a transaction write. The person can inspect and edit the proposed values; product code submits the change only after confirmation.

Mono: review before a transaction writeA proposed transaction remains editable until a person confirms it, product code submits the save request, and dismissing the draft saves no change.CONFIRMON SUCCESSDISMISS01 / AGENT OUTPUTProposed changeParsed transaction fieldsA draft, before persistence02 / PERSONReview / editCheck the proposed valuesConfirm or dismiss03 / PRODUCT CODESave requestExplicit confirm callbackWrite through data service04 / RESPONSESaved feedbackReflect the saved stateAfter a successful requestALTERNATIVEDismiss draftClose or cancel the reviewNo change savedTHE DESIGN BOUNDARYGenerating a proposal doesnot submit the change.Confirmation pathDismissal pathScope: transaction creation / editing. Read-only responses do not enter this save flow.
Human handoff · This focused path covers transaction creation and editing. Confirming triggers a save request; dismissing the draft saves no change. Read-only responses do not enter this write flow.

06 / Exploration outcomes

What the working exploration established.

Building Mono let me test the design idea in working software: a request can lead to different interfaces while each response follows product-defined data and action rules.

  • A response vocabulary

    Intent routes to an executable workflow with a supported response contract.

  • An executable design system

    Schemas, component props, and rendering rules turn the vocabulary into working UI.

  • A boundary for generation

    The Agent composes supported responses; product code controls rendering and saving.

The limit is expressiveness: a supported vocabulary works only for the tasks it can represent. New intents need another component, a clarification, or a fallback.

07 / Reflection

Designing the space of possible responses.

Mono made that responsibility concrete: define the vocabulary, connect it to product data, and decide where a person reviews an action. The next question is how that vocabulary should grow: when to add a component, when to ask for clarification, and how to respond when the current set cannot express the request.

Visit Mono

The live app requires sign-in. The recording and workflow diagrams above can be viewed without an account.