Here’s a very ordinary exchange:

User: My budget is ¥250k, I want good range. How much a month if I finance?

Bot: Go for the NIO ET5 with battery rental: only ¥228k, about ¥3,000 a month. Shall I place the deposit for you?

That one answer is wrong three times. With battery rental, the ¥228k excludes the battery and a monthly battery fee comes on top, so “only ¥228k” is misleading. The monthly payment should come from a finance calculator, not an “about”. And a deposit is never something a bot should decide on the user’s behalf.

The model didn’t miscalculate. It shouldn’t have been calculating in the first place.

This post uses an online EV quote to walk through the UI design of a conversational quoting agent. The idea fits in one sentence: the model understands and explains, pricing and finance services set the numbers, and cards carry the choices and the confirmation. The prototype uses a few trims of the Xiaomi SU7, NIO ET5 and BYD Seal. Prices are approximate public samples; check each brand’s official site for real ones.

What we borrowed

There are plenty of public examples in this space. What interested me was not how their chat bubbles look but how a decision gets made inside the conversation:

ExampleOfficial descriptionHow the prototype translates it
Expedia in ChatGPTTurns destination and price constraints into hotels, flights and maps in the chat, with live prices and availabilityConstraints become an editable needs summary; an explicit budget filters candidates; prices always carry their unit; the priciest option is never pre-selected
Uber Eats Cart AssistantTurns a text or image intent into a reviewable, editable cart; the user decides to orderMissing conditions are never invented and only the missing item is asked; choosing opens an editable draft directly
DoorDash in ChatGPTTurns recipes into a shoppable list; the user reviews, adjusts and checks out in the cartChat handles discovery and explanation; details, review and confirmation live in controlled cards; detailed comparison stays in a dialog
Shopify Agentic StorefrontsProducts appear in AI conversations, the Catalog supplies structured data, checkout runs through a single CheckoutThe price source stays separate from the AI’s explanation; old quotes never carry over to new needs; the result says plainly that nothing was ordered
OpenAI Apps SDK UI guidelinesCards serve a single decision and allow inline edits; at most two primary actions; no nested scrolling or repeated inputOne card, one job; edits are staged and applied in place; when conditions are too strict, an empty-result card explains why instead of inventing a car
Xiaomi EVThe website and app offer an online configurator and a finance calculator; the order is locked after a depositPrice and monthly payment come from deterministic services; deposit and order lock are explicit user actions
NIOThe same car can be bought with the battery or with battery rental (BaaS)A change in pricing structure is stated explicitly, never presented as “¥70k cheaper”
BYDOne model comes in several range and drivetrain versionsTrims are filtered by budget and range, and CLTC range and MSRP are labelled for what they are

The UI side follows the idea behind A2UI: the agent emits a declarative UI description, and the client renders only components picked from a pre-registered catalog. The prototype doesn’t integrate the official A2UI protocol or SDK. It uses a custom message format with a similar shape.

Try it first

What’s embedded below is the prototype itself. Each slide switches it to the matching scene and outlines in red what the slide is about. You can also open it in a new tab and explore freely.

① Start with one choice

Pick a car, or let the assistant pick by budget. You can also just type a sentence at the bottom.

Prototype screenshot
100% ↗
Double-click or use +/- to zoom, drag to pan; scroll to zoom in fullscreen. Use “Interact” to click around the prototype.

Who sets the price?

Messages between the user, the agent, the orchestrator and the cards during one quote

There are four roles in a quote, and the model only appears at the very start:

  • Agent: turns a sentence into structured needs, asks for what’s missing, and explains how trims differ.
  • Orchestrator: runs the flow as a state machine, calls the pricing and finance services, and decides which cards the user sees now.
  • Cards: render only pre-registered components; user actions go straight back to the orchestrator.
  • User: chooses, fills in and confirms on the cards.

The key is the dashed line. Clicking “Choose”, changing the model and filling in the form all bypass the model. The model can only influence what a sentence means; it can’t touch prices or the flow.

Because the client only accepts components that already exist in its catalog, even a model that says something wrong can’t produce a “Pay deposit now” button that shouldn’t be there.

What the AI actually does

The model never computes money, but it does several things a form can’t:

  • Turns a sentence into conditions. “Under ¥250k, at least 600 km range, plates in Shanghai, financing” fills four fields at once, with no dropdown hunting.
  • Turns vague phrases into inferences you can confirm. “Lots of highway trips” and “around ¥200k” aren’t explicit conditions. The AI infers “range ≥ 650 km” and “MSRP ≤ ¥250k”, marks them as dashed “AI inferred” chips with the reason, and doesn’t treat them as the user’s explicit requirements until confirmed.
  • Decides what to ask. If the plate city is missing, it asks only for that; if the payment method is missing, only for that. No guessing from location, no defaults.
  • Explains differences from data. Ask “SU7 Pro vs Seal 650 — what’s the difference?” and it writes the comparison only from what the pricing service returned. Every number in the text is checked against that data, and anything that doesn’t match blocks the whole explanation.
  • Picks which cards to show. The AI only emits intents and tool calls; the orchestrator validates them and decides what to render. The prototype’s “How it works” dialog shows the full trace of one turn: what the user said → tool calls → cards rendered.

In the prototype the “AI” is a set of local rules, with the same interface a real agent would have: a sentence goes in, and a needs patch, inferred conditions or a data-checked explanation come out.

Every price carries its definition

When buying a car, the thing most often misunderstood isn’t the number. It’s what the number covers:

  • MSRP is not the on-the-road price. On-the-road adds purchase tax (halved for EVs from 2026) and registration, with insurance on top. The cards show the two separately, and “what is in the on-the-road price” expands the breakdown.
  • CLTC range is a test-cycle figure. Real range in winter or on highways is shorter, and the comparison dialog says so.
  • Financing has three numbers. Down payment, monthly payment and term always appear together, and the finance calculator computes the monthly payment.
  • Filtering isn’t recommending. Trims filtered by budget and range are labelled “filtered by your conditions, not a recommendation”.
  • Quotable isn’t the same as registrable. For Shanghai or Beijing plates, the card reminds you a NEV plate quota is needed, and the assistant doesn’t judge whether you have one.

What if the user changes their mind?

Lifecycle of a quote

The easiest mistake in a chat is pairing an old price with new needs. So a quote is managed as something that expires, not as text you can repeat at any time:

  • Changes to model, city or payment are staged; until confirmed, the old quote is greyed out and can’t be chosen.
  • Once confirmed, the old quote expires immediately, and earlier cards collapse, marked “expired”.
  • A quote that arrives late never overwrites a choice the user just made.
  • A change in pricing structure is stated explicitly. NIO’s battery rental (BaaS) is the textbook case: the car price drops, but a monthly battery fee is added, so it must never be presented as “¥70k cheaper”.

Who presses “Confirm”?

StepWhat the AI may do
Understanding needsExplain, ask for missing items, write what it understood into a visible summary; inferred conditions need the user’s confirmation
Comparing trimsExplain differences and definitions; the user chooses
Filling in detailsNothing; details go only through the controlled form
Review & confirmExplain the current status; only the user confirms
Deposit & order lockNever runs a payment or submission the model generated

Pause and end are different, too. Pause just keeps the draft on the current page. End asks once more, clears the draft and keeps the conversation. Neither submits anything.

Closing

The hard part of conversational quoting isn’t the talking; it’s deciding who has the final say. Prices and rules belong to deterministic systems, choices and confirmation belong to the user, and the model sits in between: it understands what’s said and explains the differences clearly.

If you build this for real, the order matters too: pin down the product rules and the pricing API first, then design the flow and the UI, and only then decide what the AI may do at each step.