Architecture, traced live

Voice agent, POS as source of truth on price: how PieLine never quotes a number until the POS says so

In the 102 second public PieLine demo, the agent speaks exactly one dollar amount: $34.11, at second 91.52. It comes from the POS, 2.4 seconds after the cart was posted. Everything else is plain English.

M
Matthew Diakonov
7 min read

Direct answer (verified 2026-05-18)

How does a voice ordering AI agent know the right price?

It does not compute the price at all. The agent assembles a cart of POS item IDs and modifier IDs while the caller talks, posts that cart to the POS’s native order endpoint when the caller confirms, and reads back whatever total the POS returns. In PieLine’s public 102 second demo, the only price the agent speaks is “$34.11” at second 91.52, which is 2.4 seconds after the cart was posted at 89.12. Verified against the Deepgram captions in src/components/voice-activity-data.ts, which transcribe the same audio playing at aiphoneordering.com.

Why this matters before we trace the call

Every voice ordering vendor will tell you their agent “syncs with your POS.” That sentence describes about six different architectures, and only one of them produces a phone call where the price the customer hears, the price on the kitchen ticket, and the price on the receipt always match.

The cheap version is a nightly menu pull. The agent holds a local copy of every item and price, prices the cart in its own head during the call, says a number out loud, and posts an order somewhere else later. Sync ran at 3 AM. Owner raises lumberjack slam by fifty cents at 7 PM. Agent quotes $13.49 at 7:08 PM. Kitchen ticket prints $13.99. Receipt prints $13.99. Customer arrives, pays $13.99, asks why it is not the $13.49 they were quoted, gets a comp, and the operator absorbs the loss. Multiply by 200 calls a week.

The version PieLine ships is different in one specific way: the agent never holds a price during the call. It holds item IDs. The actual money number is computed by the POS, on the POS, at confirmation time, against the live catalog. That single design decision is what the rest of this page traces second by second.

The 102 second call, with the price moments marked

Below is the timeline of the public demo audio at aiphoneordering.com. The timestamps come from src/components/voice-activity-data.ts. Read down the column: there is exactly one place a dollar amount appears.

Where price enters the conversation

1

0:00 to 1:05 — the entire ordering conversation

The caller and the agent build the cart together: lumberjack slam, scrambled eggs, sourdough bread, soft drink, cheesecake with strawberry topping. Across more than a full minute of dialogue, the agent never speaks a dollar amount. Not per item, not per modifier, not a running total.

2

1:25 — full readback of the assembled cart

The agent enumerates every line item back to the caller: lumberjack slam, scrambled, sourdough, soft drink, New York style cheesecake with strawberry topping. Still no price. The cart at this point exists only in the agent's working memory; the POS has not seen it.

3

1:29 — "placing your order now"

The caller confirms. This is the moment the agent posts the assembled cart to the POS's native order endpoint. The agent has done exactly zero arithmetic at this point. It has not summed line items, it has not applied a modifier price delta, it has not added tax.

4

1:29 to 1:31 — the 2.4 second silence

Round trip to the POS. The POS validates every item ID, sums real prices from its own catalog, applies modifier price deltas, applies daypart rules, applies tax at the configured rate, and returns the total. The voice agent waits.

5

1:31 — "Done. Your total is $34.11."

This is the first and only dollar amount the agent says in the entire 102-second call. $34.11 was not chosen by the LLM. It is the value the POS returned from the order endpoint after pricing the cart. The agent reads it back verbatim.

That is the entire story. From second zero through second 89, the agent is doing language work: enumerating required modifier groups, confirming back the cart, upselling a dessert, mapping “Coke” to the soft drink combo modifier. Zero arithmetic. The dollar amount enters the call only after the POS has computed it, only after the cart has been validated, and only as a verbatim readback of what the POS returned.

The four stages, written as a contract

If you are evaluating a voice ordering vendor, here is the shape to ask them to describe. PieLine’s implementation passes all four. Cheaper architectures fail at stage three or four because the local copy is on the pricing path.

  1. Ingest

    Item IDs, modifier IDs, required flags. Never prices.

  2. Listen

    Resolve spoken words to existing IDs only. No invented SKUs.

  3. Post

    Send the cart to the POS's own order endpoint.

  4. Read back

    Speak the total the POS returned. Nothing else.

Where everything the POS knows about price actually lives

The reason it is worth keeping the agent off the pricing path is that the POS knows a long list of things about money that the agent does not. Each row below is something Toast, Square, Clover, NCR Aloha, and Revel all model natively, and that an LLM holding a stale menu copy is structurally bad at:

What the POS computes on every cart

Base item price
Modifier price deltas
Daypart rules
Active specials
Tax rate
Delivery fees
POS order endpoint
Final total
Kitchen ticket
Customer receipt
Settlement

Every one of those inputs can change between the morning sync and the 7 PM call. A daypart rule fires on the POS clock, not the agent’s clock. A tax rate ticks over at midnight. A special starts when the manager toggles it on the back office tablet. The only way the spoken number, the printed ticket, and the receipt all agree is to ask the POS for the number at the moment of confirmation, every time.

The minimal contract, drawn end to end

Same idea, drawn the other direction. Caller words land on the left, the price exits on the right, and the agent is never the one holding the price.

From spoken words to a real total

1

Caller words

Spoken items, modifiers, free-form add-ons

2

Agent cart

Item IDs and modifier IDs only, no prices

3

POS order endpoint

Validate, price, tax, return total

4

Agent readback

Speaks the POS total verbatim

The 2.4 second silence

People who have not built voice ordering systems sometimes assume the agent should keep talking through the POS round trip to avoid dead air. It should not. The 2.4 second silence between “placing your order now” and “your total is $34.11” is doing real work, and on the caller’s end it sounds like a human cashier ringing in the order. Filling it with chatter would force the agent to talk through information it does not have yet.

The latency budget for that round trip is set by the POS, not by PieLine. Toast and Square both return a priced order in well under three seconds against a typical menu. Clover is comparable. When the round trip exceeds about four seconds the agent inserts a single short phrase like “one moment, finalizing your order” rather than narrating something the POS has not confirmed.

90%+

The experience was better than speaking to a human. No hold time, no confusion, no rushing.

Customer, Idly Express (Almaden)

Share of calls handled end to end by AI at Idly Express, with edge cases routed to a manager. The reason the experience reads as natural is that the agent never has to hedge on a number it might be wrong about.

What this rules out

Three behaviors that look harmless in a demo and are actually disqualifying once you watch a hundred real calls:

  • Running totals during the call.An agent that says “your subtotal so far is $18.50, anything else?” mid order is computing a price the POS has not blessed. The number can be wrong about a daypart rule, an active special, a tax rate, or a modifier delta. PieLine’s agent does not surface a running subtotal because there is no running subtotal in the agent’s state.
  • Quoting a modifier upcharge on the fly.A caller asks “how much is extra cheese?” A weak architecture answers from the menu copy. A correct architecture either answers from a field that was pulled fresh at onboarding and treats it as a soft quote, or defers to the POS round trip. PieLine treats single item price queries as quotable, but never sums modifier deltas during the conversation.
  • Predicting the total before posting the cart.Some vendors do this for a perceived UX win, then reconcile later when the POS disagrees. PieLine’s agent waits the 2.4 seconds. The customer hears the real number once, and that number matches what they pay and what the kitchen sees.

See the architecture run on your menu

We will scrape your POS catalog, hook the agent to your order endpoint, and place a live test call. The number you hear on the call is the number the POS just computed.

Frequently asked questions

How does the voice agent know the right price during a phone call?

It does not compute the price. It assembles a cart of item IDs and modifier IDs the operator configured in the POS during onboarding, posts that cart to the POS's native order endpoint when the caller confirms, and reads back the total the POS returned. The 2.4 second silence between 'placing your order now' and 'your total is $34.11' in PieLine's public demo at aiphoneordering.com is the POS round trip. The agent itself does no arithmetic.

Why not let the LLM price the order itself? It already sees the items.

Two reasons. First, the POS already knows the price. It knows the base item price, the modifier price deltas, the active daypart rule, the local tax rate, the active special, the delivery fee schedule, and which items are currently out of stock. An LLM that prices in parallel ends up out of sync with the POS within hours, often within minutes if a daypart rule changes mid shift. Second, the kitchen ticket and the customer receipt both come from the POS. If the cart never reaches the POS, those two artifacts disagree with what the customer heard on the phone, and a manager has to reconcile by hand later that night. A voice agent that posts the cart and reads back the POS response is correct by construction.

What if the price in the POS changes during the call?

It cannot, in a meaningful sense. The POS prices the cart at the moment it is posted, not at the moment the caller said the words. If the operator raises the lumberjack slam from $13.49 to $13.99 at 7:00 PM and a caller starts ordering at 6:59 PM and confirms at 7:01 PM, the POS prices at $13.99 because that is the rule active at confirmation time. The agent reads back $13.99 plus tax. There is no race condition because the agent is not holding a cached price; it never had one.

What about modifier price deltas? Does the agent know that 'extra cheese' is $1.50?

No. The agent knows that 'extra cheese' is a real modifier ID in the cheese-toppings modifier group attached to a specific item. The dollar value of that delta is a field on the POS modifier record. The agent never reads that field at call time. It posts the cart with the modifier ID attached, and the POS sums the deltas during pricing. The customer hears the total once, after the round trip, and the kitchen ticket and the receipt say the same number.

What happens if the POS rejects the cart or returns an error?

The agent treats it as a recoverable failure. If the rejection is structural (an item ID is no longer valid because the operator deleted it, or a modifier is now 86'd), the agent surfaces the specific item out loud and offers the closest real alternative from the same group. If the rejection is transient (network blip, POS endpoint timeout), the agent retries the post within a couple of seconds. The caller hears at most a brief 'one moment, finalizing your order' rather than a fabricated total. The architecture forbids the agent from saying a price the POS did not confirm, even under error conditions.

Does this mean the caller cannot ask 'how much is the large pizza?' before ordering?

They can, and the agent answers, but the answer comes from the menu the POS published during onboarding, not from an in-call computation. PieLine pulls the structured menu from the POS catalog API (Toast Menus, Square Catalog, Clover Inventory) when it onboards a restaurant. The agent can quote a base item price the same way it can quote ingredients or hours, because that field is part of the menu it ingested. What it will not do is sum a multi-item cart in its head and quote that to the caller. Multi-item pricing always goes through the POS round trip, because that is where modifier deltas, daypart rules, and tax actually live.

What is the difference between this and a competitor that 'syncs prices from your POS'?

A sync is a periodic copy. Every voice ordering vendor on the market does some version of this, and most of them do it nightly or hourly. The problem with sync is that the agent then prices from its local copy, which is stale between syncs. PieLine's architecture does not price from the copy at all. The copy is only used to teach the agent what items and modifier IDs exist, so it can build a valid cart object. The pricing always happens on the POS, at post time, against the live catalog. The local copy can be wrong about a price and the customer will still hear the correct number because the local copy is not on the pricing path.

How can I verify the timestamps in this article without booking a demo?

The demo audio is hosted at aiphoneordering.com. The Deepgram multichannel transcription captures every caption with start and end times. Play the recording and listen for 'placing your order now' followed by 'your total is $34.11.' The gap between them is the POS round trip, roughly 2.4 seconds. The entire choreography described on this page is reproducible from the live demo without speaking to a salesperson.

📞PieLineAI Phone Ordering for Restaurants
© 2026 PieLine. All rights reserved.

How did this page land for you?

React to reveal totals

Comments ()

Leave a comment to see what others are saying.

Public and anonymous. No signup.