Stripe Bought OpenRouter. Eight Days Later, Someone Built the Open One.

On August 19, Stripe agreed to buy OpenRouter for a reported $7 billion. Ninety employees. Zero models trained. One API that sat between everyone and every model on Earth, and apparently that was worth more than most of the labs making the models.

I wrote about that deal last week. The takeaway was uncomfortable: the middleman won, and the middleman was never open.

Eight days later, this hit the top of Hacker News:

Show HN: We built open OpenRouter that turns usage into a better model.

Eight. Days. That's the 2026 acquisition-to-open-source-clone speedrun, and it's faster than most companies take to update their org chart after an acquisition.

The clone is called Experiential, it's Apache 2.0, and it's more interesting than the usual "we wrapped the same APIs in a repo" effort — because of the second half of that Show HN title. Turns usage into a better model. The gateway doesn't just move your requests around. It wants to learn from them and hand you a model you own at the end.

That's either the most obvious idea in gateway-land or a genuinely new one. After going through the repo and the launch thread, my verdict is: both, with caveats. Let's get into it.

What Stripe actually bought

Quick refresher in case you spent last week touching grass.

OpenRouter was the boring layer of AI. Every lab has its own API, its own auth, its own rate limits, its own billing quirks. OpenRouter wrapped all of them into one interface — one key, 400+ models. When the best model for your workload started changing every few weeks, being multi-model stopped being optional, and OpenRouter became the default way to do it. By the time Stripe showed up, it was pushing 10 trillion tokens a day.

Here's the part that matters for this story: Stripe didn't buy the code. The code is an API wrapper. Stripe bought the traffic — 10 trillion tokens a day of other people's AI usage, plus the routing intelligence that only exists because that traffic flowed through. The asset was everybody else's log files.

Keep that in mind. It's the whole plot.

What Experiential is

The surface-level pitch is exactly what you'd expect from "open OpenRouter": one OpenAI-compatible endpoint (it also speaks Anthropic Messages, which is a nice touch), sitting in front of hosted providers, your own API keys, and your own GPUs. Run it locally with a pip install experiential and an exp command, or use their hosted version. Routing, access control, spend tracking. The things every gateway does.

Two details on that surface are worth noting, though.

First, the pricing model: BYOK requests are free pass-through. Their line is "pay provider prices, never a cent more" — every request itemized, the provider's price passed straight through. Which is a direct shot at the entire gateway industry, most of which quietly skims a margin on routing and hopes you don't spreadsheet it.

Second, the attribution. Their demo dashboard breaks spend down by agent — support agent $1,904, research $1,212, triage $495 — and includes, I promise this is real, a line item for Qwen running on your own GPUs: 31.4 million tokens, $0.00. When your dashboard treats "local model, zero cost" as a first-class billing entry rather than a curiosity, you're building for a specific worldview. More on that at the end.

The engineering is respectable for a project that only went public yesterday. They started building in June, wrote it in Python, then rewrote the hot path as a compiled Rust data plane. The docs claim under a millisecond of added overhead on pass-through requests; the public CI badge currently clocks the full local gateway at about 20ms. That gap between marketing and badge is almost comforting — it means a human is still writing the docs. Either way, 20ms next to an LLM call that takes 2 to 40 seconds is noise.

The obvious comparison is LiteLLM, which has been the default open-source gateway for a couple of years now. Someone in the HN thread asked the question directly: isn't this just LiteLLM? The answer from the team is the whole differentiation, so it's worth quoting in spirit: LiteLLM moves your requests. Experiential wants to learn from them. That's the product.

The part that's actually interesting

Here's the workflow that made me write this post.

Step one: you point your existing agent at the gateway, or feed it OpenTelemetry traces from whatever you're already running. Then exp build support-agent — it builds a simulation from your traces and fits a router against your actual workload. Not a benchmark. Not a vibes-based "Claude for creative, GPT for math" chart from a blog post. Your traffic.

Step two: once the router has been running on your traffic, exp optimize model fine-tunes an open-source model on that same data, via Tinker — Thinking Machines' fine-tuning API. Yes, that Thinking Machines, Mira Murati's outfit, the same one whose open-weights debut we covered a while back. And continual RL on top is on the roadmap, which means the model keeps training on your live traffic.

So the loop is: your agent traffic becomes training data, the training data becomes a router, the router becomes a fine-tuned model you own, and the model becomes the thing your agent runs on — at open-weights prices, on hardware you control if you want.

Now think back to what Stripe bought. OpenRouter monetized the fact that everyone else's traffic flowed through their pipes — ten trillion tokens a day of it, sold for $7 billion. Experiential's pitch is the inversion: your traffic is your asset. Stop renting the insight that's sitting in your own logs. Turn it into a model that belongs to you.

If that actually works the way the demo suggests, it's a quiet little economic argument against the entire frontier-API status quo: when a fine-tuned open model beats the frontier model on your workload specifically, "just use the biggest model" stops being the default answer. The log file becomes the moat. Your log file.

There's a smaller money-saver hiding in it too. The router doesn't just pick models — it picks reasoning effort levels. One example the team tossed out in the thread: Opus 5 at low reasoning effort performs roughly the same as Opus 5 at high effort for a big chunk of requests. If a router can figure out which requests those are, you're getting frontier quality at a fraction of the token burn, automatically. That's not a benchmark flex; that's a line item on next month's invoice.

The honest part: routing usually disappoints

I'd be lying if I said I'm unreservedly bullish on model routers, because the graveyard is real. Everyone builds one. Everyone's demo is impressive. Then production happens.

The classic killer is caching. Providers give you big discounts on cached input tokens, and a router that switches models per request murders your cache hit rate. "Cheapest model for each request" routing frequently costs more than picking one good model and staying put, because you traded a 90% input discount for a 30% model discount. Someone in the thread raised exactly this, and it's the right objection.

The team's answer is more interesting than the feature list: they rarely switch. The router mostly switches at task boundaries, not mid-conversation, and — this is the part I appreciate — the most common conclusion of the routing optimization is apparently "one model is already at the pareto front for this task, just use it always."

Which invites the obvious heckle: if the answer is usually "use one model," why do you need a gateway at all? And the answer is that you don't know which model until your own traffic tells you — and the answer changes next month, because the model rankings change next month. That perpetual churn is literally why OpenRouter got rich. A tool that re-derives the answer from your live workload every month is a reasonable response to a market that refuses to sit still.

Other caveats, in the spirit of honesty: the repo had about 500 stars as of this morning. It's a small team, the gateway market is already crowded with incumbents (LiteLLM, Portkey, Helicone, Kong, and friends), and the hosted marketplace angle could, in the worst timeline, become exactly the markup middleman this post is celebrating an alternative to. Twenty milliseconds is not sub-one-millisecond. Watch the telemetry defaults — they're anonymized and disable-able, but they're on by default, which tells you the business plan involves a hosted product, not just a libre repo.

But here's the thing about Apache 2.0: the failure mode is you fork it and keep your routing. The failure mode of the closed alternative is that Stripe owns your routing. Those are not the same failure mode.

The pattern is the story

Zoom out, because the eight-day gap is the actual news.

A layer of the AI stack gets acquired for $7 billion, and within a week the open-source replacement is on the front page of Hacker News. That's not a one-off — it's the same pattern playing out everywhere in 2026. Frontier labs ship closed systems, and open weights eat the bottom of the market months later at a tenth of the price. The moat keeps evaporating from below while the acquirers keep paying up top.

The practical lesson if you build anything on this stack: never sign a long-term contract with a toll booth that someone can fork. And the more subversive lesson is the one Experiential is selling — the most valuable training data your company will ever have is already sitting in your own logs, doing nothing. That was true before last week. It's just that last week put a $7 billion price tag on what everyone else's logs are worth, which has a way of focusing the mind.

At CopperRiver, this is why we've bet on open models — GLM, DeepSeek, Qwen, Kimi, MiniMax — instead of renting one frontier API and hoping the pricing holds. The "your GPUs, $0.00" line on Experiential's dashboard isn't a demo flourish. It's the whole thesis. You don't need to own the model of the month; you need the layer that keeps working when the model of the month changes, the prices reshuffle, or the vendor gets acquired mid-quarter.

Speaking of which: if you want a desktop AI assistant that already runs on this stack — one that browses the web, runs terminal commands, reads your files, and routes across open models without you babysitting a spreadsheet of API keys — that's literally what CopperRiver does. Plans start at $9 a month, which is less than the coffee you'll drink watching your agent work.

The middleman won last week. Fine. The rest of us will keep the receipts — and the logs.