Hundreds of Orders Reveal More Than a Demo
Demonstrating an AI Agent that places food orders is relatively straightforward. The resulting experience can look impressive.
A user says, “Order me lunch with a little less heat, extra protein, and delivery within 20 minutes.” The Agent searches menus, compares restaurants, and submits the order. The whole process takes about 30 seconds.
Real-world use adds several layers of friction:
- The user says “lunch,” but the Agent must determine whether it is lunchtime now or whether it is time to plan dinner.
- “A little less heat” could mean no spice at all or only mildly spicy food.
- Delivery estimates depend on the address, the restaurant, and courier capacity at that moment.
- Coupons, membership discounts, food costs, and service fees must be calculated together.
- The final checkout price may differ from the budget the Agent gave the user.
That makes the “hundreds of orders” more revealing than a successful demo. A demo shows that a model can complete a task once. Order volume tests whether users are willing to hand over the entry point, context, and payment controls to an Agent during real tasks.
One crucial denominator is still missing.
If only a few teams are testing the integration, hundreds of orders may not constitute failure. If thousands of Agents already have access, hundreds of orders would indicate that the product model is flawed. Ars Technica did not provide enough data to distinguish between those possibilities. There is no basis for filling that gap with a speculative conclusion about DoorDash.
What can be established is this: integration capability has not yet translated into order volume at scale.
Technical Integration Is Only Half the Chain
Connecting an AI Agent to DoorDash does not mean the Agent has completed a purchase.
The transaction can be divided into five stages:
- Intent recognition: The Agent understands what the user wants to eat, along with constraints such as budget, time, and party size.
- Product search: It finds candidate restaurants using live menus, inventory, and delivery ranges.
- Preference confirmation: It handles ambiguous instructions such as “a little less heat,” “the usual,” or “less salt.”
- Payment authorization: It displays the amount clearly, asks the user to confirm it, and handles coupons, refunds, and cancellations.
- Delivery correction: Someone must take responsibility for incorrect addresses, missing items, absent dishes, or late deliveries.
Models and software can handle most of the first four stages. The fifth is difficult to automate with the Agent alone.
If an item is missing, did the model misunderstand the note, or did the restaurant fail to prepare it? Who absorbs the loss? Can the Agent issue a refund directly, or must it send evidence to customer support? If the Agent purchases a $68 set without approval, can the user reverse it with one tap?
Adding another confirm() call to the API does not answer these questions. They are fundamentally questions about Agent permissions:
- What may the Agent recommend?
- What may the Agent add to the cart?
- What order value may it submit?
- Which actions require user confirmation?
- What remedies may the Agent take after an error?
A good purchasing Agent is not a search engine with better answers. It is closer to an operator with limited permissions.
Consumers Have Little Reason to Install Another Agent
Suppose an Agent remembers that a user avoids peanuts, prefers Thai restaurants, and orders from only one place on Wednesday lunch, then finds a matching meal on DoorDash.
Why would the user still open DoorDash?
For frequent customers, the DoorDash app is already a short path. Addresses, payment methods, and favorite locations are saved. Search results are fast enough. Even if an Agent saves another ten seconds of tapping, users still have to absorb a separate set of switching costs:
- Moving to a different entry point.
- Granting the Agent access to purchase history.
- Handing payment details to a third party.
- Accepting new recommendation and privacy boundaries.
- Verifying that the Agent actually understands the user’s preferences.
The benefit is “fewer taps.” The cost is “a new way to spend money.”
This explains why Agents tend to fit ride-hailing, travel, and booking use cases more easily. Those tasks are infrequent and involve many steps, so booking across several websites or arranging a ride can save meaningful time. Food delivery is different. Opening DoorDash, choosing a restaurant, and tapping once is a short workflow that users already know well.
Trust is also asymmetrical.
If the Agent buys the wrong meal, the user will remember the loss. If it saves a few dozen seconds, the user may never feel the need to thank it.
Platform and Agent Incentives Are Not Aligned
By allowing external Agents to integrate, DoorDash acknowledges that they may become new traffic sources.
That raises a series of questions. How does DoorDash identify traffic from each Agent? Which party owns the order? Must Agent developers pay to send users to the platform? After the platform takes its commission, how much remains for the Agent developer?
Suppose an Agent completes 100 orders for a user, with 60 from DoorDash and 40 from other platforms. If the user still opens DoorDash directly the following week, did the Agent create value, or merely process orders that were going to happen anyway?
Common attribution methods include:
- Assigning the order to the Agent that generated the click.
- Assigning it to the Agent that completed the final payment.
- Giving part of the commission to the Agent that first enabled the purchase.
- Paying the Agent a fixed fee when the user completes the entire order inside it.
Each rule changes the Agent’s business model.
If attribution is weighted too heavily toward the platform, Agent developers have little reason to invest in product development. If it is weighted too heavily toward the Agent, the platform may lose control of the customer relationship and transaction.
An open API is only an entry point. The difficult part is the revenue-sharing agreement.
Without a closed commercial loop, integration is closer to an experimental feature. Developers can call the API, and the platform can observe usage, but neither side has a strong incentive to solve authorization, settlement, and after-sales issues.
Start Narrow Before Pursuing Universal Shopping
A more realistic path is not to build an Agent that can buy anything immediately.
Start with narrow use cases that involve many steps, occur infrequently, and have clear tolerance for error. Examples include:
- Ordering lunch for a group meeting.
- Ordering weekday dinner within a defined budget.
- Filtering restaurants for users with allergies and requiring merchants to confirm ingredients.
- Automatically reordering after a delivery delay, subject to a price ceiling.
- Tracking recurring orders and asking users to confirm when the menu changes.
These use cases share two characteristics:
- The time saved by the Agent is perceptible.
- The ordering rules are easier to define in advance.
Evaluation should also shift from demo counts and registrations toward business outcomes:
- Seven-day and 30-day repeat purchase rates.
- Orders per active user.
- Average order value and platform revenue.
- Cancellation, refund, and food-loss rates.
- The percentage of Agent orders modified by users.
- Human support intervention rates when anomalies occur.
- Attributed order share and Agent customer acquisition cost.
The “percentage of orders modified by users” deserves particular attention.
It is a closer measure of Agent reliability than order volume. If users add items through the Agent and then remove ingredients, change restaurants, or update addresses, the recommendation layer is not accurate enough, and the authorization layer has not aligned expectations with the actual order.
The technical route is not mysterious. An Agent can connect to tools through a protocol such as MCP, but a protocol answers how a tool should be called. It does not decide whether the tool should be called, who is responsible for errors, or how outcomes are settled. Those questions still need to be encoded in product rules and contracts.
Editorial Takeaway
DoorDash’s hundreds of orders are not a final verdict on AI Agents. They are a reminder that technical narratives often obscure: models are good at generating content, but purchasing Agents must handle entry points, permissions, accountability, and value distribution.
The prediction is that Agents will establish themselves first in low-frequency, high-friction shopping scenarios, such as group meals and travel dining. Everyday food delivery will remain the domain of the app. Platforms may also avoid allowing Agents to become the sole entry point, instead placing them in the pre-checkout recommendation layer while users retain control of confirmation and payment.
What distinguishes this round from earlier Agent demonstrations is that it has reached real transactions. It has also exposed weak incentives for users to switch and the lack of an attribution agreement between the parties. The available material still does not reveal how many active users the hundreds of orders represent or how long the integration has been open. Without those denominators, the trend can be assessed, but no verdict on DoorDash can be justified.
References
- Ars Technica: Basically no one is using AI agents for their DoorDash orders
- Hacker News: Related discussion