Bites Has 300 Restaurants. What Can It Change?

By Lazar Milicevic · Published October 12, 2026 · 7 min read

DoorDash processed 970 million orders in one quarter. A 10-person pre-seed startup called Bites has signed up around 300 Bay Area restaurants and lets people order through ChatGPT. You will probably never compete with either. But if customers start asking an AI assistant to place orders instead of opening your app or calling your shop, you need to know where the work breaks, because the failure point is rarely the conversation.

What the numbers say, and what they don't

DoorDash reported 970 million Total Orders in Q2 2026, up 27% year over year. Excluding the Deliveroo acquisition, growth was 17%. Marketplace GOV was $33.1 billion and revenue was about $4.5 billion. Per the 10-Q, "Total Orders" counts everything completed through its Marketplaces and Commerce Platform, so 970M is not a pure marketplace figure.

Bites sits at the other end. The Verge, as relayed by secondary coverage, describes it as a 10-person pre-seed company with around 300 restaurants signed up in the Bay Area. Other sources give higher restaurant counts (some say 600+), and I can't reconcile them, so treat any single number as soft.

Here is what those figures cannot tell you:

• Whether customers prefer AI-led ordering
• Whether restaurants earn more through it
• Whether Bites can leave its home market

DoorDash's CEO said in August 2026 that agentic order volume from AI partners was still low, per PYMNTS. So this is an early experiment, not a verdict. I'm interested in it anyway, because it exposes the structure of every "AI places the order" workflow, in any industry.

Why a convincing chat is not a completed order

An AI assistant that talks well about ordering has done none of the work. A transaction needs to land somewhere real: the item must exist, the restaurant must accept the order, payment must clear, and someone must handle the problem when it doesn't.

Food delivery is a chain of small decisions:

1. Find an option
2. Check what's actually available
3. Handle preferences and modifications
4. Place the order
5. Take payment
6. Resolve anything that goes wrong

An assistant can help with every step and still fail the job if step 2 is a guess or step 6 has no owner. If it can't confirm an item is in stock, submit the right order, or tell the customer the kitchen rejected a change, you get a pleasant conversation wrapped around an unfinished transaction.

This is the same shape OpenAI describes in its Agentic Commerce Protocol: the merchant stays the merchant of record. The merchant handles orders, payments, and fulfillment in its own systems, accepts or declines the order, processes payment through its existing provider, and owns customer support. The AI layer carries the request to you. It doesn't absorb your obligations.

Two real examples show the gap:

• DoorDash's grocery app inside ChatGPT, launched Dec. 17, 2025, doesn't support Instant Checkout. Users hop into the DoorDash app to review the cart and pay. The handoff is still manual.
• DoorDash's text-to-order agent in Apple Messages (beta waitlist announced Sept. 30, 2026) matches a phone number to a profile and pays with the stored method. Bloomberg's testing of an early version found prices that differed from the app.

A price mismatch between the chat and the system of record is exactly the failure I'd expect. It's not a language problem. It's a data-sync problem.

What Bites changed, and what's still unverified

Bites' structural bet is to bypass the marketplace layer. According to reporting on its model, it charges a flat $1 per order instead of a commission. Diners usually pay it; some restaurants absorb it. Orders go directly to the restaurant. Integration runs through POS providers like Toast and Square, and once a POS partner is on board, a restaurant opts in with a button click.

That last detail is the useful engineering lesson. Bites doesn't ask restaurants to rebuild anything. It plugs into the system that already knows the menu, prices, and availability.

The reported business results are interesting but thin:

• The Verge's test order of a pizza and a drink via Bites in ChatGPT cost $56.73 with tip, tax, and fees. The same order on DoorDash cost $70.29. That is one test order, not a representative sample.
• Restaurateur Jay Jayaraman, with 13 restaurants on Bites, estimates about 65% of his delivery orders now come through Bites and 25% through DoorDash, versus roughly 80% DoorDash before. That's his own estimate. He also says he gets "absolutely nothing" from DoorDash on customer data.

Be careful comparing the fees. Bites' $1 is a diner-side surcharge. DoorDash's merchant commissions are 15%, 25%, or 30% on delivery and 6% on pickup, and DoorDash says that bundles listing and marketing, Dasher logistics, customer support, and card processing. Those aren't like-for-like numbers. According to Restaurant Business in January 2026, Bites also relied mainly on drivers from other delivery apps, so check current coverage for where that stands now. Unbundling the commission means someone else now owns the pieces it covered.

Some things I could not confirm, so I'm not stating them: whether Bites' ChatGPT ordering is in OpenAI's official app directory, and how it handles payment (Instant Checkout or something else). One more wrinkle: in August 2026 DoorDash emailed Bay Area restaurants warning that being listed on Bites without consent "could be illegal," depending on the state. Bites' CEO said 14 of his restaurant partners received the letter. That is DoorDash's wording, not a legal finding.

The handoff is the product

Strip away the food and you have a pattern that applies to any small business: request, check, commit, record, escalate. The winner in AI-assisted ordering may be whoever makes fewer mistakes at the handoff, not whoever talks best.

Take a catering order for 30 people. Here's how a safe version works:

trigger:    customer message (email / chat / form)
extract:    headcount, date, window, address, dietary notes
checks:     menu_current? items_available? in_delivery_zone? price_matches_pos?
decision:   all checks pass AND no flagged ambiguity -> prepare order
            allergy unclear OR slot unavailable -> STOP, ask a human or the customer
commit:     human approves (or auto-approves under a defined threshold)
record:     write confirmed order to ordering system + customer record
notify:     send confirmation; log the whole trace

In code, the important part is the stop condition, not the extraction:

def process_request(req, systems, approver):
    order = extract_order(req)                 # LLM: free text -> structured fields

    checks = {
        "menu":      systems.menu.is_current(order.items),
        "available": systems.inventory.in_stock(order.items, order.date),
        "zone":      systems.delivery.covers(order.address),
        "price":     systems.pos.price(order.items) == order.quoted_price,
    }
    failed = [name for name, ok in checks.items() if not ok]

    if failed or order.has_open_questions():   # allergy detail, odd time, etc.
        return escalate(order, reason=failed or order.open_questions)

    if not approver.approve(order):            # money/promise gate
        return escalate(order, reason="approval_declined")

    confirmation = systems.pos.submit(order)   # the real commit
    systems.crm.record(order, confirmation)
    return notify_customer(order, confirmation)

Notice what the model does and doesn't do. It turns messy text into structured fields. Every check hits a real system, not the model's memory. A failed check or an open question ends in a person, not a guess. "Inventing an available slot" is the failure to design against.

Where these workflows usually break

• Stale data. The assistant quotes a price or item that the POS no longer has. Fix: query the system of record at check time, never cache menus in the prompt.
• Silent partial success. The order posts to one system but not the CRM. Fix: treat the commit and the record as one unit, and alert on mismatch.
• No owner for exceptions. The assistant escalates and nobody picks it up. Fix: name a person and a response window before launch.
• Authority creep. The agent gets payment access it doesn't need. Fix: scope credentials to the one action and keep the approval gate explicit.

One workflow to test this week

Don't start with a demo. Start with your own history.

1. Pick one repeat request your team handles every week.
2. Write down its trigger, the three systems a person checks, and the exact point where money or a customer promise is committed.
3. Pull 20 past requests. Mark each as "could have passed the checks automatically" or "needed judgment."
4. Run the workflow in shadow mode, where it proposes and a human acts, and count three things: completed requests, corrections, and exceptions.

Skip the hours-saved estimate. A demo will always look fast. Those three counts tell you whether the workflow is ready.

A simple tracking sheet is enough:

If a large share of your 20 requests need judgment, that isn't a failure. It tells you the automation scope is only the routine part of the work, with exceptions routed to a person. Your split will differ, so measure it.

My take

Bites is small, and its scale proves neither disruption nor failure. The question it raises is worth testing in your own shop: can an assistant carry a real request through your existing systems, with a person approving the exceptions? Run the 20-request audit first. If the answer is yes for even one workflow, you have something worth building.

Want more like this?

I write about practical AI automation and GenAI engineering for solopreneurs and small teams.

Visit bizflowai.io for more.

Connect with me on LinkedIn — Lazar Milićević, senior engineer building AI automations that ship.