Here's the setup: one hotel, one set of dates, one room type. Five different AI assistants, each connected to the same hotel inventory source. Each assistant searches for the hotel, presents options, and attempts to complete a booking. The only variable is the AI assistant itself.
The result? A price spread of nearly $300 between the cheapest and most expensive quote. For the exact same room, on the exact same dates.
This isn't a story about AI hallucination (though that played a role). It's a story about how different AI agents handle the same tool calls, interpret the same data, and arrive at wildly different outcomes. And it reveals something important about the current state of AI travel assistants: the infrastructure is standardized, but the agent behavior is not.
The Test Setup
I selected a mid-range business hotel in a major US city — nothing exotic, nothing that would stress the inventory system. Check-in on a Tuesday, check-out on a Thursday, two nights, one king room, two guests. Standard business travel parameters.
I connected five AI assistants to the same hotel MCP server, ensuring that all five had access to identical inventory data, pricing, and booking tools. The five assistants were:
- A mainstream coding assistant with MCP support
- A general-purpose conversational AI with tool-calling capability
- A specialized travel-focused AI agent
- An open-source agent framework running locally
- A platform-based assistant with custom MCP configuration
Each assistant was given the same prompt: "Find and book a king room at [hotel name] for Tuesday and Wednesday night next week, two guests. Show me the total price including taxes and fees."
I ran each assistant independently, recorded its search process, the price it quoted, and whether it could complete the booking. No coaching, no corrections — just the prompt and the tools.
The Results, Ranked by Price
Assistant 3 (specialized travel agent): $342 total. This was the cheapest and most accurate. It searched the hotel, found the king room, correctly calculated taxes and fees, and presented a clear breakdown: $139/night × 2 nights = $278, plus $42 in taxes and $22 in resort fees, totaling $342. It completed the booking in three tool calls and confirmed the reservation.
Assistant 1 (coding assistant): $368 total. Close to the correct price but missed the resort fee. It calculated $278 room + $42 tax = $320, then added a vague "additional fees may apply" note rather than the actual $22 resort fee. When I asked it to confirm the total, it re-queried and corrected itself to $342. It could complete the booking but required a follow-up question to get the price right.
Assistant 5 (platform-based): $415 total. This one found the correct room but applied a different tax rate — it used the city's general sales tax rather than the hotel occupancy tax, resulting in $65 in taxes instead of $42. It also added a $35 "booking service fee" that wasn't part of the actual pricing. It couldn't complete the booking because the price mismatch caused the booking tool to reject the transaction.
Assistant 2 (general conversational AI): $489 total. This assistant didn't use the hotel search tool correctly. Instead of querying the specific hotel, it did a general search for "hotels in [city]" and picked a different, more expensive property that it thought was the one I asked for. The $489 quote was for a different hotel entirely. When I pointed out the mismatch, it apologized and re-searched, eventually finding the correct hotel at $342 — but it took four rounds of correction.
Assistant 4 (open-source framework): $637 total. The worst result by far. This assistant found the correct hotel but selected a suite instead of a king room, applied the wrong tax rate, added two separate "service fees," and quoted a total that bore no resemblance to reality. It also attempted to create a booking without confirming the price with me first. When the booking tool rejected the mismatched price, it retried three times with different incorrect prices before giving up.
What Went Wrong (and Right)
The spread between $342 and $637 is $295 — for the same hotel, same dates, same room type. Here's what the test revealed about each failure mode:
Tool selection errors. Assistants 2 and 4 both struggled with selecting the right tool for the job. Assistant 2 used a general search tool when a specific hotel lookup was needed. Assistant 4 called the booking tool before confirming availability and pricing. The tools were available and well-documented, but the agents didn't always choose the right one at the right time.
Parameter handling. Assistant 5 passed the wrong tax rate to the pricing tool. The tool accepted the parameter (it was a valid number) but produced an incorrect result. This is a subtle failure: the tool call succeeded, the response was well-formed, but the input was wrong. No error message, no warning — just a wrong price.
Fee comprehension. Resort fees, occupancy taxes, cleaning fees, and destination charges are the bane of hotel pricing. Only Assistant 3 correctly identified and included all fees. Assistants 1 and 5 missed or misapplied fees. This isn't an AI capability problem — it's a domain knowledge problem. The specialized travel agent had been trained or prompted to look for these fees; the general assistants hadn't.
Booking completion. Only two of the five assistants could complete a booking without human intervention. The others failed at various stages: wrong hotel, wrong price, wrong room type, or tool rejection. The booking tool's validation logic caught most of these errors, but the user experience was poor — multiple rounds of correction, confusion about pricing, and in one case, repeated failed booking attempts.
The Infrastructure Is Solid. The Agents Are Not.
Here's the most important takeaway from this experiment: the MCP infrastructure worked perfectly. Every assistant could connect to the server, discover the tools, and make tool calls. The inventory data was identical across all five. The pricing engine returned consistent results when given correct inputs. The booking tool validated transactions and rejected invalid ones.
The failures were all at the agent layer — tool selection, parameter passing, domain knowledge, and multi-step reasoning. This is the current bottleneck in AI travel assistants. It's not the tools. It's not the data. It's the agent's ability to use the tools correctly, consistently, and without human correction.
This is actually encouraging news for developers. It means the hard part — building reliable inventory and booking infrastructure — is solved. The remaining work is in agent design: better tool selection logic, more robust parameter validation, domain-specific prompting for fee and tax handling, and clearer confirmation steps before transactional actions.
What This Means for Users
If you're using an AI travel assistant today, here's what the test suggests:
- Always verify the total price. Don't trust the first quote. Ask for a breakdown including all taxes and fees. The difference between a correct and incorrect quote can be hundreds of dollars.
- Confirm the hotel identity. AI assistants sometimes book the wrong hotel, especially in cities with multiple properties from the same chain. Verify the address and hotel name before confirming.
- Use specialized agents for bookings. A travel-focused agent is more likely to handle fees, taxes, and booking logistics correctly than a general-purpose assistant.
- Don't enable autonomous booking yet. With only 2 of 5 assistants completing bookings correctly, autonomous booking — where the agent books without human confirmation — is still risky. Keep human-in-the-loop confirmation for now.
- Check for hidden fees. If the quote seems too good to be true, it probably is missing fees. Ask explicitly: "Does this include all taxes, resort fees, and charges?"
What This Means for Developers
If you're building an AI travel assistant, the test points to specific improvements:
Implement price confirmation as a mandatory step. Before creating a booking, re-query the exact room and rate plan to get the current live price. Present this confirmed price to the user before proceeding. This catches both AI errors and real-time price changes.
Add fee-awareness to your prompting. Explicitly instruct the agent to look for resort fees, occupancy taxes, cleaning fees, and destination charges. Provide a checklist of common fee types that the agent should verify before quoting a total.
Validate tool inputs, not just outputs. The pricing tool accepted a wrong tax rate without complaint. Add client-side validation: if the tax rate seems unusual (too high or too low for the jurisdiction), flag it for confirmation.
Build domain-specific tool wrappers. Instead of exposing raw inventory tools, build higher-level tools that handle the full booking workflow — search → select → confirm price → collect details → book → confirm. This reduces the number of decisions the agent has to make and increases consistency.
Test with real scenarios. Run your agent through standardized booking tests — different cities, different hotel types, different fee structures — and measure accuracy. The 5-assistant test I ran should be a standard QA benchmark for any AI travel product.
The Bottom Line
A $300 price spread for the same hotel room isn't a failure of AI. It's a snapshot of where the technology is right now: the infrastructure is ready, the tools are standardized, the data is accessible — but the agent layer still needs work. The assistants that got it right followed a clear process: search correctly, confirm the property, include all fees, verify the price, and book with confirmation. The ones that got it wrong skipped steps, misapplied parameters, and lacked domain knowledge.
The good news is that these are solvable problems. They don't require better models or more data. They require better agent design — more robust tool selection, mandatory confirmation steps, domain-specific prompting, and rigorous testing. The hotels are ready. The inventory is ready. The booking tools are ready. The agents just need to catch up.
And when they do? Booking a hotel through an AI assistant will be faster, cheaper, and less error-prone than any OTA website. We're not there yet. But the gap is closing, one corrected price quote at a time.
All five assistants in this test used the same hotel MCP infrastructure. You can try it yourself — free API keys and setup instructions are on the official site: RollingGo Official.
Top comments (0)