Cheapy: The War Tripled Flight Prices Home, So I Taught an AI Agent to Watch Them

At a glance

• What: Cheapy — an agent-first MCP server and Python package that finds and watches cheap flights, returning strictly structured results that AI agents can act on.
• Why: the 2026 Middle East escalation sent oil — and Europe–Vietnam airfares — to record highs, right when my sister and her young son needed to fly home for the summer.
• My role: solo builder. Spec-first workflow with AI coding agents: 402 commits and about thirty gated design docs in roughly three weeks.
• Stack: Python 3.12 · Pydantic · Typer · MCP stdio · SQLite.
• Result: a watchlist alert surfaced a Düsseldorf → Ho Chi Minh City round trip at EUR 1,707.49 for two, against quotes of roughly €3,000 at the time. Booked.
• Code: github.com/chuanman2707/Cheapy

The problem

In the spring of 2026, the war in the Middle East pushed oil prices to record highs, and long-haul airfares followed. The route my family cares about — the Netherlands to Vietnam — went from ordinary to absurd: round trips that used to be unremarkable were suddenly quoted at two to three times their normal price.

This wasn't an abstract chart for me. My sister lives in the Netherlands with her young son, and every summer they fly home to Vietnam — the one stretch of the year when the family gets to see the boy in person instead of waving at him through a phone screen. This year, every time we checked the fares, the numbers were worse. For the two of them, quotes hovered around €3,000. In the family group chat, "have you looked at tickets yet?" was slowly turning into "maybe we skip this year."

The standard answer is to set a price alert and wait. But generic alerts watch one route, one airport pair, one set of dates. The actual question was fuzzier: cheapest reasonable option within that summer window, from any airport my sister can realistically reach, with a checked bag, without a 40-hour itinerary. That's not a form you can fill in on a booking site. It's a conversation — which is exactly what AI agents are good at holding.

I couldn't do anything about oil prices. But I build software for a living, and I could refuse to let a fare chart decide whether my family got its summer. So I built the watcher myself.

Why an MCP server, not another price-alert app

MCP (Model Context Protocol) is the open standard that lets AI agents like Claude call external tools. The agent holds the fuzzy human intent; the tool does one thing precisely and returns structured data. That split is the whole design philosophy of Cheapy.

I didn't want a prettier flight UI. I wanted to say to an agent: "find the cheapest way to get them home that week, nearby airports are fine, one bag" — and have the agent translate that into precise tool calls, compare structured results, and explain the trade-offs back to me. So Cheapy exposes exactly one high-level MCP tool, search_cheapest_flights, and keeps the surface area an agent has to understand deliberately small.

The tool supports exact searches and expanded ones — flexible date windows and nearby-airport candidates — and a SQLite-backed watchlist so an agent (or a scheduled job) can re-run a search and compare against history. That last feature is the one that ended up paying for the whole project.

Spec first, code later

I wrote Cheapy with AI coding agents doing most of the typing, and the discipline that made that work was writing the specification before any code existed. On May 8 I wrote a master spec: scope, contracts, provider architecture, what phase one would refuse to do. Then I had a separate AI review it adversarially. The verdict came back: "go with gates" — the direction was sound, but the contracts had holes that would cause rework if implementation started immediately.

So the first real artifact wasn't code. It was Contract V1 — the locked request and response schema — plus a list of gates the build had to pass through. Three weeks later the project was done: 402 commits, about thirty design and plan documents, each implementation phase reviewed before the next one started.

The engineering that mattered

Four decisions carried most of the weight:

• A strict contract as the source of truth. Every response — offers, provider statuses, warnings, currency groups, search-plan metadata — validates against strict Pydantic models. An agent never scrapes prose to find a price; mixed currencies are never silently converted or falsely compared. If the data isn't comparable, the contract says so.
• Protocol hygiene. An MCP stdio server dies strangely if anything non-protocol leaks to stdout. Cheapy treats stdout as sacred: protocol only, all diagnostics to stderr, enforced by tests.
• Isolated, honest providers. Google Flights, Traveloka, and Skyscanner adapters live behind a registry, each quarantined so its quirks can't leak into the core. The hard parts were here: making providers whose only interface is a browser behave like stable APIs — keeping long-lived authenticated sessions valid for my own searches, and recovering cleanly when they expire — and running live providers in child processes behind a process bridge so a hung browser can't take down the server.
• Offline by default. The regular test suite never touches the network; live provider smoke tests are a separate, opt-in lane. Anyone can clone the repo and get a green build without credentials or luck.

See it work

Here is a real session, screenshots and all: I ask Claude Code for cheap round-trip flights from Amsterdam to Ho Chi Minh City, and the agent calls search_cheapest_flights live.

I ask it to widen the search to flexible dates. The tool re-runs against a window of nearby departure and return dates and reports back a ranked table — along with an honest caveat about how much of that window it actually had budget to check.

That's the whole interaction model: fuzzy question in, one MCP tool call, structured offers and honest caveats out. The exact discovery that got my sister's ticket used the watchlist instead of a live chat — same contract, running unattended.

The payoff

The watchlist had been quietly re-running the search for the summer window. In June it flagged an option the airport-pair alerts would never have shown me: fly from Düsseldorf instead of Amsterdam — a nearby-airport candidate Cheapy had expanded automatically.

Round trip, Düsseldorf to Ho Chi Minh City, out July 13, back August 14. One connection each way, 25kg checked baggage. EUR 1,756.33 for the two of them before a small miles discount — EUR 1,707.49 paid. Against the ~€3,000 quotes we'd been staring at, the tool had just saved about 43% on tickets that actually got booked.

My sister and her young son flew home in July. As I write this, their outbound flight has just landed in Ho Chi Minh City — eighteen hours, one connection, and on the other side of the arrivals gate, the summer that a fare chart very nearly cancelled. That booking is the entire success metric of this project — not stars, not downloads. The tool existed to get two people home at a sane price during a fare spike, and it did.

What I'd tell other builders

1. Write the spec before the agents write code. An adversarial AI review of my own spec found the contract holes while they were still cheap to fix. The 402 commits that followed were fast because the contracts were locked first.
2. Strict contracts are what make tools agent-usable. The difference between a scraper and an agent tool is a schema. If an agent has to parse prose, you built a demo; if it can trust the types, you built infrastructure.
3. Solve a real problem, then write about it. A fare spike with a name and a face beats any portfolio-ware. The constraint of "my sister actually needs this ticket" made every scope decision obvious.