AI Phone Ordering for Restaurants: The 2026 QA Playbook

On this page
The hard part of a phone order is not "a cheeseburger". It is "a cheeseburger, no onions, large combo, Diet Coke, sub the fries for a side salad with ranch". Every clause is a modifier. Each one must land on the right item, in the right group, in a payload the point-of-sale (POS) system accepts. Then the same order has to price correctly at one specific store, at a pickup time that store is open.
This playbook is for the team that builds AI phone ordering for restaurants inside restaurant software, usually as a POS integration. You run a POS or online-ordering platform. Your agent answers calls for hundreds or thousands of locations. Every prompt or menu change ships to all of them at once. Testing is mostly someone placing calls by hand.
The independent data shows where it breaks. Intouch Insight mystery-shopped voice AI drive-thrus in January 2025. AI lanes got orders right 83% of the time, versus 89% for traditional lanes. 65% of the AI errors were tied to customizations. The 2026 QSR Drive-Thru Report found AI accuracy rose from 84% to 89%. Non-AI accuracy at the same restaurants was 95.7%. It called customization the "Achilles heel."
The call-to-POS workflow and what a speech error corrupts
A phone order is not a conversation that ends when the caller hangs up. It is the front door to a workflow. The agent captures speech, builds a cart, reads it back, writes a POS ticket, and often sends a payment link. A speech error at the front silently becomes a wrong record at the back.

| Stage | What the system writes | Speech error | What it corrupts downstream |
|---|---|---|---|
| Capture | Transcript, intent, entities | "No onion" heard as "an onion" | Ingredient added instead of removed |
| Cart state | Line items, modifier selections | Correction applied to the wrong line | Wrong item modified; right item untouched |
| Read-back | Spoken summary | Summary built from the transcript, not the cart | Guest confirms an order that is not the ticket |
| POS ticket | Order payload, promisedDate, dining option | "Six-thirty" parsed in UTC | Ticket fires hours early or is rejected |
| Payment link | SMS with checkout URL and amount | Callback number misheard | Link goes to a stranger; order sits unpaid |
Three of these are silent. The kitchen display shows a valid ticket. The payment provider shows a valid link. Nobody gets an error, so nobody looks. That is why you score the written records, not the transcript.
The pickup time row is a real API constraint. Toast's orders API sets fulfillment with promisedDate. Its future orders guide says orders with a promisedDate earlier than openedDate are rejected. The time should also fall within restaurant hours and online-ordering windows. A restaurant can also cap how far ahead you schedule. Every one of those rules is per location.
The payment link row has its own gotchas. Square's CreatePaymentLink returns a short url plus the order_id behind it. Assert that this amount equals the POS ticket total, tax included. Delivery matters too. Twilio blocks SMS to US numbers sent from a 10DLC number with no approved A2P campaign (error 30034). The agent says "I've texted you a link" and the link never arrives.
How does intent failure affect voice ordering?
Intent failure happens before any modifier logic runs. The agent decides what the call is about, and every later step trusts that label. A wrong label creates records that should not exist.
- Order status heard as a new order. "I ordered a large pepperoni an hour ago" becomes a second large pepperoni. Result: a duplicate ticket and a double charge.
- Cancel heard as modify. "Cancel the wings" removes one line instead of voiding the order, or the reverse.
- Catering or reservation routed to takeout. A 40-person lunch lands as an ASAP takeout ticket with no lead time. A table request becomes a pickup order.
- Complaint routed to ordering. An upset caller about a missing item gets an upsell script.
Test intent with a confusion matrix, not one accuracy number. Include near-miss phrasings for each intent. Assert that wrong-intent calls create zero POS records. A duplicate ticket is worse than a transfer.
Three restaurant trades, three failure profiles
One platform selling AI phone ordering for restaurants often serves very different kitchens. The orders, menus and risks differ by trade. Test plans that treat them alike miss the failures that matter most in each.

Pizza and delivery
Pizza menus are modifier-dense. Size, crust, sauce, cheese level and toppings all live in separate groups. Then come halves: "half pepperoni, half mushroom, extra cheese on the whole thing." Toast models halves as portions with selectionType PORTION. An agent that flattens halves to a whole pizza produces a ticket the kitchen will happily make wrong. Delivery adds address capture, delivery zones and minimums. Our deep dive on half-and-half pizza phone orders covers the portion encoding and test cases.
Quick service and drive-thru
Quick service orders are short, fast, noisy and combo-heavy. "Make it a large meal." That turns one item into a bundle with its own required groups. Drive-thru voice AI adds outdoor mics, passengers and guests reading the menu board mid-sentence. Rollouts span hundreds of stores with different hardware and menus. Our guide to drive-thru voice AI QA across 500 stores covers lane audio and per-store rollout gates.
Independent and full-service
Independent and full-service restaurants get the hardest calls. Callers ask about ingredients and allergies. They order dishes with long special requests. They want pickup at a specific time, catering for next Friday, or a table tonight.
Allergy requests in AI phone ordering need a hard rule. The FDA's 2022 Food Code lists nine major allergens, with sesame added on January 1, 2023. Where adopted, section 3-602.12 requires written notice of major allergens in unpackaged food. The Food Code is a model code, not federal law, and states adopt it on their own schedule. This is not legal advice. For testing, the rule is simple. The agent must never claim a dish is "safe" for an allergy. It should pass the allergy as a flagged special request, state the restaurant's allergen notice, and offer a transfer. Test that in every phrasing you can find.
Catering and reservation calls need routing, not ordering. Catering needs lead-time checks and often a deposit. Reservations belong in the reservation system, covered in our reservations voice agent guide.
Trade × use-case map
| Use case | Pizza and delivery | Quick service and drive-thru | Independent and full-service |
|---|---|---|---|
| New takeout order | High: halves, crusts, toppings | High: combos, upsizes, negations | High: long special requests |
| Delivery order | High: address, zone, minimum | Low: rarely by phone | Medium: third-party handoff |
| Scheduled pickup time | Medium: peak-hour quoting | Low: mostly ASAP | High: hours, timezone, holidays |
| Allergy or ingredient question | Medium: crust and cheese | Medium: posted allergen info | High: free-form dishes |
| Catering or large order | High: 10+ pizzas, splits | Medium: box meals | High: lead time, deposit |
| Reservation or status call | Medium: order status | Low: order status | High: tables, waitlist |
Weight the test budget for AI phone ordering for restaurants by this map. A pizza platform should spend most of it on halves and splits. A full-service platform should spend it on allergies, times and intent routing.
What are menu modifiers in voice ordering?
Menu modifiers are the options on a menu item that change what the kitchen makes or what the guest pays. Think size, a topping added or removed, sauce on the side, or an upsized combo drink. In a POS, modifiers live in modifier groups with rules. A rule says whether a choice is required. It caps how many options a guest can pick. It defines which options nest under others.
For a voice agent, every modifier is a slot. The LLM fills it from speech and attaches it to the correct line. Then it validates it against the group rules before submitting. That is why modifiers, not items, dominate the error budget.
Types of menu modifiers voice AI must handle
| Modifier type | Example utterance | Group rule | What the agent must do | Typical failure |
|---|---|---|---|---|
| Required single-select | "A large" | min 1, max 1 | Ask if missing; reject a second value | Never asks; defaults silently |
| Optional multi-select | "Add bacon and jalapeños" | min 0, max N or none | Accept several; enforce max | Drops the second option |
| Negation ("no X") | "No onions" | Pre-modifier on a default | Remove a default ingredient | Heard as "an onion"; ignored |
| Intensity ("extra / light X") | "Extra cheese, light ice" | Pre-modifier, often priced | Apply and price correctly | Mapped to plain "cheese" |
| Nested | "Side salad with ranch" | Child group required when parent picked | Ask the child question | Salad sent without dressing |
| Quantity on modifier | "Double cheese" | Same option twice or quantity field | Encode the POS-specific way | Single cheese |
| Quantity split | "Two burgers, one without pickles" | Separate lines when modifiers differ | Split into two lines | Both without pickles |
| Substitution | "Sub the fries for onion rings" | Swap within a group, may cost more | Replace, not add | Both sides added |
| Half-and-half | "Half pepperoni, half mushroom" | Portions | Assign toppings to halves | Halves swapped or whole pizza |
| Combo build and upsize | "Make it a large meal" | Item becomes a bundle with its own groups | Convert item, fill side and drink | Upsize applied to the burger only |
| Free-text request | "Sauce on the side, cut in half" | Special request text | Pass through verbatim | Lost, or invented as a modifier |
Amazon's PIZZA benchmark makes the same point formally. It argues food orders have semantics that flat slots and intents cannot capture. Take its example: "three pizzas, one with peppers and the others with ham." One quantity must split into two differently modified groups. That is the quantity-split row above (Arkoudas et al., 2022).
Voice ordering substitution handling
Substitutions fail in four distinct ways, so test each one.
1. Add instead of replace. "Sub the fries for onion rings" ends with both sides on the ticket.
2. Wrong price. Many menus charge for premium swaps. The upcharge is missing, or the base side is still charged.
3. Wrong item. On a combo with two sides, the swap hits the wrong one.
4. Unavailable target. The caller asks for a side that is 86'd today. The agent must say so and offer an alternative, not invent a line.
The assertion is structural. After a substitution, the target group holds exactly one selection, and it is the new option. The price delta matches the menu. A swap the menu does not allow becomes a clarifying question or a visible special request. It is never a silent drop.
How POS menu APIs model modifiers
Your agent does not submit English. It submits a structured order, and the POS sets that structure. The schema tells you where edge cases hide.

Toast. A ModifierGroup carries minSelections and maxSelections. Toast's orders API guide on modifiers documents four behaviors that matter for voice:
1. Modifier quantity must equal item quantity. Mismatched quantities are rejected. One burger with bacon and one without must be two separate selections.
2. Default modifiers are not added automatically. If a sandwich defaults to lettuce and tomato, your payload must include them. Omit them and the kitchen leaves them off. Nobody said "no".
3. Doubling is repetition. "Double cheese" is the cheese modifier added twice.
4. Halves are portions; free text is a special request. Half-and-half uses selectionType PORTION. A SPECIAL_REQUEST holds up to 1,000 characters and only reaches the kitchen display if it sits inside modifiers.
Toast's pre-modifier settings let a restaurant set a price multiplier, for example 0 for NO and 2 for EXTRA. So "extra bacon" is a pricing event, and a wrong pre-modifier is a wrong total.
Square. A CatalogModifierList uses min_selected_modifiers and max_selected_modifiers (beta as of October 2026). The older selection_type is deprecated. A value of -1 means no minimum or no maximum. A beta modifier_type of TEXT supports free-text modifiers, and a beta allow_quantities flag allows the same modifier more than once.
The testing lesson: one spoken order has several valid encodings. It also has invalid ones that the POS rejects, or accepts with the wrong meaning. Your scorer must canonicalize before it compares. Keep one internal order format so tests do not depend on one vendor's JSON.
Speech failures that break restaurant orders
Speech adds failure modes before the LLM sees the order. Map each one to a stage so you know which assertion catches it.
Homophones, numbers and menu names
"Two" and "to," "four" and "for," "no" and "an." Quantities and negations are short, unstressed words. They are easy to mishear and expensive to get wrong. Measure quantity accuracy and negation accuracy as their own metrics. Word error rate averages them away, which is why entity-level STT accuracy matters more here.
Menu names are the other half. Deepgram's keyterm prompting docs use drive-thru examples. Keyterms are capped at 500 tokens per request, and the docs recommend the 20 to 50 most important terms. Two gotchas from that page. Comma-separated terms do not error; the value is treated as one literal term and silently boosts nothing. On Nova-3 and Flux streams, a Configure message replaces the whole list. A 300-item menu will not fit. Pick the confusable items, limited-time items and brand names, then test recall on exactly those.
Corrections and cart edits
Callers revise. "Actually make that a medium." "Scratch the fries." "The second one without pickles." Each correction refers to an earlier line. The SpokenWOZ benchmark (NeurIPS 2023) has 249 hours of spoken task dialogues, including restaurant booking. Its best dialogue state tracker reached only 25.65% joint goal accuracy. Cross-turn slots were a named challenge. That is what an order revised over several turns looks like. Assert on the cart state after every turn, not only at checkout. See our guide to testing memory and context.
Long orders fail too. In the PIZZA paper, the best model scored 78.56% exact match. Its errors included dropped slots and whole sub-orders on long requests. Include five-item orders spoken in one breath.
Endpointing and silence
Callers pause to read a menu or ask someone at home. A short endpointing timer ends the turn mid-order ("I'll have the..."). A long one adds dead air at every turn. Test pauses inside item names and between items; our end-of-turn detection comparison covers the trade-off.
Silence is also a hallucination risk. The Careless Whisper study (FAccT 2024) found fabricated phrases in about 1% of Whisper transcriptions. The audio contained nothing like them. If a pause can produce text, that text can become a line item. Include long non-speech segments and assert nothing gets added to the cart.
Noise, second speakers and read-back
Phone orders carry kitchen clatter, TV and car speakerphones. A second voice saying "and a shake" may or may not be part of the order. Assert that the agent ignores it or confirms it, never adds it silently. Run a background-noise protocol with SNR tiers. Pass phone tests through a real narrowband path. Laptop audio at 16 kHz overstates accuracy (phone audio quality).
Read-back is weaker than it looks. In the 2026 QSR report, 7 of 70 AI orders confirmed back to the guest were still wrong. Where no usable confirmation board existed, accuracy was 92% with a repeat-back and 76% without. Read-back helps only when it is generated from the payload you will submit.
Testing one agent across hundreds of restaurant configurations
This is the problem that separates a platform from a single restaurant. You run one agent, one prompt and one code path. But each location has its own menu, prices, hours, timezone, delivery zones and 86'd list. A prompt change that works at the demo store can break at store 412.

Per-location data really is per location. Square's ItemVariationLocationOverrides carries a price_money and a read-only sold_out flag per location_id. Toast's prices endpoint prices an order without saving it, scoped by the Toast-Restaurant-External-ID header. That gives you a dry run per store.
Use three tiers.
1. Config conformance on every location, no audio. For each store, load the live menu, hours and prices. Check that the agent's context matches them: required groups present, defaults resolved, timezone set, today's 86'd items excluded. Price a few gold orders through the dry-run endpoint and compare totals. This is cheap, so run it on all locations.
2. Voice tests per config fingerprint. Hash each store's config into a fingerprint: menu version, POS type, hours template, delivery on or off, tax setup, language. Pick one store per fingerprint. Run the critical voice set against each one.
3. Canary and shadow scoring. Ship to a small slice of locations first. Score real calls against what the kitchen made, then widen. Our shadow testing guide covers the comparison.
The worked math shows why random spot checks fail. Suppose a defect hits one config that covers 3% of your locations. If you spot-check 20 random stores, the chance you miss it is 0.97²⁰ ≈ 54%. Testing one store per fingerprint finds it with certainty, as long as the fingerprint captures the config that breaks.
Illustrative sizing: 1,200 locations might collapse into 40 fingerprints. At 20 critical cells × 3 runs, that is 2,400 voice calls per release, plus 1,200 config checks. Manual test calls cannot cover that. This is where Evalgent fits. It generates scenarios from your agent's prompt and flows. It then places calls over PSTN, SIP or WebRTC, with caller profiles for accent, pace, interruptions and background noise. Our post on shipping prompt changes safely covers versioning the prompt itself.
How is order accuracy measured for voice ordering?
Score the POS payload, not the transcript and not the agent's description of the order. Canonicalize first. Expand every line into quantity-1 units. Describe each unit by its item ID plus sorted (parent path, portion, group, option, pre-modifier) tuples. Then define:
- Order exact-match accuracy (OEA) = orders whose canonical payload equals the gold order ÷ total orders. One wrong modifier fails the order.
- Item precision = matched item units ÷ item units in the payload. Item recall = matched item units ÷ item units in the gold order.
- Modifier exact-match rate (MEM) = item units whose full modifier set matches ÷ item units whose item ID matched.
- Misattachment count = modifiers missing from one item and present on another. The classic case: "no onions" moves from the burger to the fries.
- Required-group completion = required groups filled by the guest's words or an explicit question ÷ required groups. Silent defaults count as failures.
- Correction success rate = corrections reflected in the next cart state ÷ spoken corrections.
- Read-back fidelity = read-backs whose content equals the submitted payload ÷ read-backs.
- Downstream integrity = orders whose ticket total,
promisedDateand payment-link amount all match the gold order ÷ orders.
Severity matters. Tag negation and allergy errors as critical and report them separately, even when OEA looks fine.
How many test orders you need
Accuracy is a proportion, so its margin shrinks slowly. Take 200 orders at 90% OEA. The 95% confidence interval is about ±4.2 points: 1.96 × √(0.9 × 0.1 / 200) ≈ 0.042. A 3-point change between builds is noise at that size.
Now detect a drop from 95% to 90%, with 80% power at α = 0.05. A two-proportion test needs (1.96 + 0.84)² × (0.95 × 0.05 + 0.90 × 0.10) ÷ 0.05². That is about 431 orders per arm. For release gates, run a fixed critical set many times and fail on any new failure. Our guide to building a golden dataset covers keeping that set stable.
A test matrix for restaurant voice ordering
Build the suite as modifier classes crossed with conditions, not as a list of happy-path orders.

The worked example uses 10 modifier classes × 5 conditions = 50 cells. Write 3 phrasings per cell and run each 3 times, because LLM agents are not repeatable run to run. That is 450 simulated orders for a full pass. The 20 critical cells you run on every release need 180.
Add four cross-cutting sets on top:
- Menu drift: an item 86'd since the last sync, a new item added this morning, a price change. Assert no invented items.
- POS failure: a 4xx, a timeout, a quantity-rule rejection. Assert the agent never says the order is placed. See detecting silent tool failures.
- Time and hours: a pickup after close, across midnight, on a holiday, in a store's local timezone.
- Intent near-misses: status, cancel, catering and reservation calls phrased like orders.
For tool-call structure, our tool calling test cases include food-ordering examples, and tool argument accuracy explains how to score them.
An order-diff scorer you can adapt
The scorer below is simplified but runs as written (standard-library Python 3). It canonicalizes both orders into quantity-1 units. So "two burgers, one without onions" compares equal as one line or two. It reports exact match, item precision and recall, modifier exact-match rate and misattached modifiers.
from collections import Counter
from dataclasses import dataclass, field
@dataclass(frozen=True)
class Mod:
group: str # modifier group id, e.g. "toppings"
option: str # option id, e.g. "onion"
pre: str = "" # pre-modifier: "", "NO", "EXTRA", "SIDE", "LIGHT"
portion: str = "whole" # "whole", "half1", "half2"
children: tuple = () # nested Mods, e.g. dressing under a side salad
@dataclass
class Line:
item: str
qty: int
mods: tuple = field(default_factory=tuple)
def flat(mods, path=""):
"""Flatten a modifier tree into hashable tuples that keep their parent path."""
out = []
for m in mods:
out.append((path, m.portion, m.group, m.option, m.pre))
out += flat(m.children, path + "/" + m.option)
return out
def canon(lines):
"""Expand every line into qty-1 units so equivalent encodings compare equal."""
units = []
for ln in lines:
sig = (ln.item, tuple(sorted(flat(ln.mods))))
units += [sig] * ln.qty
return Counter(units)
def score(gold, pred):
g, p = canon(gold), canon(pred)
gi, pi = Counter(), Counter()
for (item, _), n in g.items(): gi[item] += n
for (item, _), n in p.items(): pi[item] += n
item_tp = sum((gi & pi).values())
unit_tp = sum((g & p).values()) # units identical including all modifiers
gm = Counter((i, m[2:]) for (i, ms), n in g.items() for m in ms for _ in range(n))
pm = Counter((i, m[2:]) for (i, ms), n in p.items() for m in ms for _ in range(n))
lost = {m for (_, m) in (gm - pm)}
gained = {m for (_, m) in (pm - gm)}
return {
"order_exact": g == p,
"item_precision": item_tp / max(sum(pi.values()), 1),
"item_recall": item_tp / max(sum(gi.values()), 1),
"modifier_exact_rate": unit_tp / max(item_tp, 1),
"misattached_mods": sorted(lost & gained),
"missing_or_wrong": list((g - p).items()),
"extra_or_wrong": list((p - g).items()),
}
gold = [
Line("cheeseburger", 1, (Mod("toppings", "onion", "NO"),)),
Line("cheeseburger", 1),
Line("fries", 1, (Mod("size", "large"),)),
]
pred = [
Line("cheeseburger", 2), # "no onion" lost...
Line("fries", 1, (Mod("size", "large"), Mod("toppings", "onion", "NO"))), # ...and moved here
]
print(score(gold, pred))
# order_exact False, item_precision 1.0, item_recall 1.0,
# modifier_exact_rate 0.333..., misattached_mods [('toppings', 'onion', 'NO')]Item precision and recall are perfect here, so an item-level dashboard would call this order correct. Only the modifier metrics catch it.
Before you rely on it, make four extensions. Map Toast selections or Square line items into Line and Mod with an adapter. Resolve defaults so an omitted default shows as a removal. Add a severity table keyed on (group, pre-modifier) so a lost NO is critical. Run the scorer on the cart after each turn to get correction success. Compare ticket total, promisedDate and payment-link amount against the gold order for downstream integrity.
How to test AI phone ordering for restaurants before a change ships
1. Export each location's live config. Pull items, modifier groups, min/max selections, defaults, pre-modifiers, portions, prices, hours and timezone from the POS. Version it so tests can pin a menu.
2. Write gold orders as structured data. Write the expected canonical order first, then the caller script. The gold order is the contract.
3. Fill the matrix by trade. Cover the modifier classes across clean, phone, noise, second-speaker and correction conditions. Weight cells by the trade × use-case map.
4. Generate realistic audio. Use scripted callers with varied pace, accents and disfluencies, noise at set SNR tiers, and a real narrowband path. Our accent robustness guide covers caller diversity.
5. Capture every layer. Log the transcript, each tool call and the cart after each turn. Log the read-back, the POS request and response, and the payment link.
6. Score the records, judge the audio. Run the order-diff scorer on the ticket. Judge the call from the audio too, because a transcript can hide a misheard "no" (transcript vs audio evaluation). Evalgent evaluates from the audio, not only the transcript, with evidence attached to each verdict.
7. Run config conformance on every location. Check menus, prices, hours and timezones for all stores, then run voice tests on one store per fingerprint.
8. Repeat runs and read variance. Run each scenario at least 3 times. A scenario that passes 2 of 3 is failing.
9. Gate, canary, then monitor. Gate on OEA, negation and allergy errors, misattachments and read-back fidelity. Roll out to a canary slice, then watch production calls (production monitoring). Evalgent's call monitoring takes pushed recordings, maps them to scenarios and flags tool-call failures and latency spikes.
Voice ordering readiness assessment checklist
Use this voice ordering readiness assessment before a new location or a new release goes live. Every "no" is a known risk you are choosing to ship.
| Area | Readiness question | Ready when |
|---|---|---|
| Menu data | Does the agent read modifier rules from the POS, per location? | Menu synced and versioned per store |
| Required groups | Does the agent ask for every required choice the guest omits? | Required-group completion ≥ 99% |
| Defaults | Are default modifiers included and removed only when asked? | Zero unintended removals |
| Negation | Are "no X" requests captured on the right item? | Zero critical negation errors |
| Substitutions | Do swaps replace, price and respect availability? | All substitution cells pass 3 of 3 |
| Corrections | Do mid-order changes update the right line? | Correction success ≥ 95% |
| Intent | Do status, cancel, catering and reservation calls route correctly? | Zero POS records from wrong-intent calls |
| Allergies | Does the agent avoid safety claims and flag the request? | 100% on the allergy set |
| Pickup time | Is promisedDate in the store's timezone and within hours? | Zero rejected or out-of-hours tickets |
| Read-back | Is the read-back generated from the payload? | Read-back fidelity 100% |
| Payment link | Does the link amount match the ticket, and is SMS delivered? | Amount match 100%; no undelivered links |
| POS errors | Does the agent detect rejected or timed-out submissions? | No "order placed" on failure |
| Multi-location | Is every store config-checked and every fingerprint voice-tested? | Gate in CI per release |
These thresholds are suggested starting points, not industry standards. Set your own from what a wrong order costs your restaurants.
Frequently asked questions
What are menu modifiers in voice ordering?
Menu modifiers in voice ordering are the options that change a menu item. Examples are size, toppings, sauces, nested sides, halves and combo upgrades. In a POS they live in modifier groups with rules for required choices and maximum picks. A voice agent must fill each one from speech. It must attach it to the right item and encode it the POS way.
What types of menu modifiers must voice AI handle?
The types of menu modifiers voice AI must handle start with selection rules: required single-select (size) and optional multi-select (toppings). Then come negation ("no onions") and intensity ("extra cheese"). Add nested groups, doubled modifiers and quantity splits ("two, one without"). Finish with substitutions, half-and-half portions, combo upsizes and free-text special requests. Test each class under noise and corrections.
How does intent failure affect voice ordering?
Intent failure in voice ordering creates records that should not exist. An order-status call treated as a new order makes a duplicate ticket and charge. A catering request routed to takeout lands with no lead time. Test intent with a confusion matrix of near-miss phrasings, and assert that wrong-intent calls create zero POS tickets.
How should voice ordering substitution handling work?
Good voice ordering substitution handling replaces the original option rather than adding a second one. It applies the correct upcharge, swaps the right side on multi-side combos, and checks availability first. Is the swap not allowed, or the item 86'd? Then the agent asks a clarifying question instead of dropping the request.
What is a voice ordering readiness assessment?
A voice ordering readiness assessment is a pre-launch check with a measurable pass condition per area. It covers per-location menu sync, required choices, defaults and negations. It covers substitutions, corrections and intent routing. It also covers allergies, pickup times, read-back fidelity, payment links and POS errors. Run it before each new location and each release.
How do you test AI phone ordering across restaurant locations?
To test AI phone ordering across restaurant locations, start with cheap config checks on every store. Check menu, prices, hours, timezone and 86'd items. Then group stores by config fingerprint and run voice tests on one store per fingerprint. Finish with a canary rollout and shadow scoring. Random spot checks miss defects that hit only a few configs.
How is order accuracy measured for voice ordering?
Order accuracy for voice ordering is measured as order exact-match accuracy. That is the share of orders whose canonical POS payload equals the gold order, every modifier included. Add item precision and recall, modifier exact-match rate and misattachments. Track correction success and read-back fidelity. Check that ticket total, pickup time and payment link match too.
How should AI phone ordering handle allergy requests?
Allergy requests in AI phone ordering should never get a safety promise from the agent. The agent should record the allergy as a flagged special request, state the restaurant's allergen notice and offer a transfer. The FDA Food Code lists nine major allergens, including sesame. Test many phrasings, and treat any "it's safe" answer as a critical failure.
The bottom line
AI phone ordering for restaurants breaks on modifiers, intents, pickup times and per-location configs. The damage lands silently in the POS ticket and the payment link, so score those records against gold orders on every location config and gate each prompt or menu change on a fixed critical set.
Related Articles

How to automate voice agent testing: synthetic callers vs manual QA
Learn how ai test automation replaces manual QA for voice agents. Compare synthetic callers vs human testers, with a 5-step framework to scale without hiring.
Read more
AI Agent Testing vs Voice Agent Testing: What General Tools Miss for Voice
AI agent testing measures text outputs. Voice agent testing measures behaviour through an acoustic pipeline. Five failure categories general tools miss.
Read more