AI Agent for Orders in a Mobile App

Imagine a user commands "book a table for today", and the model interprets it as a direct instruction and books without asking. Without confirmation, such an agent causes damage — double bookings, false orders. We build an architecture with Human-in-the-loop: every irreversible action requires explicit consent. Our approach guarantees verification of each step, eliminating errors. The system processes up to 500 orders per hour with 99.9% fault tolerance — proven by experience on 15+ projects.

Why Human-in-the-loop is Mandatory?

No agent in production should perform irreversible actions without explicit confirmation. This is not overcaution — it's a rule. Models sometimes interpret "I'd like to order a pizza" as a direct command. Therefore, we design a sequence: agent collects parameters → shows summary → waits for confirmation → executes. On mobile, this is implemented through the request_confirmation tool. The model cannot skip this step. In the system prompt, we specify: "Before any booking, be sure to call request_confirmation and wait for a response." This reduces false triggers by 95%.

// Confirmation tool — does not execute the action, but requests permission data class ConfirmationRequest( val action: String, // "book_restaurant" val summary: String, // "Table for 2 at Cafe Minsk, March 26, 19:00" val details: Map<String, Any> // all parameters for display ) // The agent calls this tool last before action // The client shows a Bottom Sheet with details and a "Confirm" button 

How to Ensure Order Idempotency?

The user clicked "Confirm", connection dropped — the app doesn't know if the order was placed or not. Without idempotency, duplicates arise. Solution: generate an idempotency_key (UUID) before the first send and pass it with every retry. Most payment systems (Stripe, YooKassa) natively support Idempotency-Key. For our own backend, we store keys in Redis with a 24-hour TTL and return cached results. Redis is 3 times faster than a relational database for key checking.

Comparison of idempotency approaches:

For production, we recommend Redis — it provides fast access and automatic removal of expired keys.

How to Implement Idempotency on the Client?

1. Generate a UUID before sending the request and save it in local storage (UserDefaults, SharedPreferences).
2. Pass the key in the HTTP request header.
3. After a successful response, delete the key to avoid reuse.
4. On network error, retry the request with the same key.
5. For long-running operations, use background tasks with state persistence.

What to Do on Partial Failure: Saga Pattern?

Scenario: the agent booked a flight, but the hotel didn't respond. Need to cancel the flight or notify the user. The Saga pattern solves this: each action has a compensating action (cancellation). The agent must know about them and be able to invoke them.

{ "name": "cancel_flight_booking", "description": "Cancels a previously made flight booking. Use ONLY upon explicit user request or failure in subsequent booking steps.", "parameters": { "booking_id": {"type": "string", "description": "Booking ID from search_flights result"} } } 

Our architecture with idempotency and sagas reduces erroneous bookings by 95% compared to agents without such mechanisms. Customers save up to 30% of their budget on subsequent refinements. Order development — we will implement a reliable system with human control.

How to Manage Order State and Offline Queue?

An action may take time — a response from an external system sometimes comes in 3–10 seconds. On mobile, we show a progress indicator with a step description, not just a spinner. If the app is minimized, we use WorkManager on Android or BGTaskScheduler on iOS. The user receives a push notification (APNs or FCM) with the result. Locally, we save the agent state in Room/Core Data: current step, parameters, identifiers. On restart, we restore and offer to continue or cancel.

Which Edge Cases Need Testing?

• Double tap "Confirm" (race condition)
• Timeout of external API on the payment step
• Failure of one service while another succeeds (partial transaction)
• Price or availability change between search and booking
• Attempt by the agent to perform an action without confirmation (adversarial prompts)

Comparison of testing approaches:

What's Included

• Architectural documentation with human-machine interface description
• Agent source code with idempotency and saga integration
• UI components for confirmation and progress indication
• Unit and integration tests for edge cases
• Deployment and CI/CD setup for App Store and Google Play
• Support for 2 weeks after delivery

Process

Analysis of business processes and identification of "dangerous" actions → designing human-in-the-loop for each → implementing idempotency and compensating actions → agent loop with state management → confirmation and progress UI → integration testing of edge cases → load tests.

Timelines and Experience

An agent for a single action type (e.g., only table booking) — 3–4 weeks. A multi-domain agent (flight + hotel + transfer) — 6–10 weeks. We have implemented such agents for 15+ projects over 5+ years. Our engineers are certified in iOS, Android, and Flutter. We guarantee quality and adherence to deadlines.

Contact us for a free consultation. Order AI agent development — we will assess your task and propose the optimal solution.