Rewrite BitRouter vs OpenRouter, fix stale platform-fee claims

components/landing/compare/compare-programs.tsx

@@ -62,7 +62,7 @@ export const COMPARE_REGISTRY: Record<string, CompareRegistryEntry> = {
       { feat: "Routing overhead",                   them: "✗ ~20ms+ (asyncio overhead)",   br: "✓ ~5ms p50" },
       { feat: "Per-run cost attribution",           them: "✗",                            br: "✓" },
       { feat: "BYOK support",                       them: "✓",                            br: "✓" },
-      { feat: "Platform fee (hosted option)",       them: "— self-host only",             br: "✓ 2% stablecoin / 5% card" },
+      { feat: "Platform fee (hosted option)",       them: "— self-host only",             br: "✓ none · 0% markup" },
     ],
     tradeoffs: [
       "You want a Python-native library embedded directly in your application code with SDK-level call hooks",
@@ -86,45 +86,39 @@ export const COMPARE_REGISTRY: Record<string, CompareRegistryEntry> = {
         ],
       },
       "02": {
-        term: "agent_a · bitrouter gateway",
+        term: "billing · $1,000 of inference",
         prog: () => [
-          ["print", <span><Dim>agent_a →</Dim> <span className="lbl">POST /v1/chat/completions</span></span>, 320],
-          ["print", <span><Ok>✓</Ok> <Dim>KYA identity verified</Dim> <Faint>agent_a · run_8x2k</Faint></span>, 200],
-          ["print", <span><Ok>✓</Ok> <Dim>injection check</Dim> <Faint>clean</Faint></span>, 200],
-          ["print", <span><Ok>✓</Ok> <Dim>x402 payment authorized</Dim> <span className="lbl">$0.003 USDC</span></span>, 420],
-          ["print", <span><Err>OpenRouter:</Err> <Dim>✗ no MCP · no KYA · no payments</Dim></span>, 600],
+          ["print", <span className="mut">what the gateway takes on top</span>, 240],
+          ["print", <span><span className="ind">OpenRouter </span> <Err>+$55</Err> <Faint>5.5% to load credits</Faint></span>, 200],
+          ["print", <span><span className="ind">           </span> <Err>+5%</Err> <Faint>on BYOK over the free allowance</Faint></span>, 260],
+          ["print", <span><span className="ind">BitRouter  </span> <Ok>+$0</Ok> <Faint>0% markup · BYOK free</Faint></span>, 420],
+          ["print", <span className="mut">self-hosted · no platform fee at all</span>, 600],
           ["loop", 2000],
         ],
       },
       "03": {
-        term: "router · latency benchmark",
+        term: "router · learning your workload",
         prog: () => [
-          ["print", <span className="mut">routing overhead · p50</span>, 240],
-          ["print", <span><span className="ind">OpenRouter </span> <Err>~30ms</Err> <Faint>hosted SaaS</Faint></span>, 200],
-          ["print", <span><span className="ind">BitRouter  </span> <Ok>~5ms</Ok> <Faint>Rust async binary</Faint></span>, 320],
-          ["print", <span className="fnt">{"  ↓ 6× faster overhead"}</span>, 300],
-          ["print", <span className="mut">at 10k calls/day · saves ~4 min of latency</span>, 600],
+          ["print", <span><Dim>run 001 →</Dim> <span className="lbl">frontier</span> <Faint>$0.21 · tests green</Faint></span>, 300],
+          ["print", <span><Ok>✓</Ok> <Dim>observed · scored · learned</Dim></span>, 200],
+          ["print", <span><Dim>run 240 →</Dim> <span className="lbl">open-weight</span> <Faint>$0.04 · tests green</Faint></span>, 320],
+          ["print", <span><Ok>●</Ok> <Dim>escalates only what needs frontier</Dim></span>, 420],
+          ["print", <span className="mut">static auto-routers never get to run 240</span>, 600],
           ["loop", 2000],
         ],
       },
     },
     rows: [
-      { feat: "Open source & self-hostable",        them: "✗ closed-source cloud",   br: "✓ Apache 2.0 binary" },
-      { feat: "Permissionless provider registry",   them: "✗ curated, closed",        br: "✓ PR-based, open" },
-      { feat: "Agent gateway (MCP / ACP / Skills)", them: "✗",                        br: "✓ built-in" },
-      { feat: "Autonomous agent payments (x402)",   them: "✗",                        br: "✓" },
-      { feat: "KYA agent identity",                 them: "✗",                        br: "✓" },
-      { feat: "Prompt injection detection",         them: "✗",                        br: "✓" },
-      { feat: "Multi-provider failover mid-run",    them: "⚠ limited",                br: "✓ automatic" },
-      { feat: "Routing overhead",                   them: "✗ ~30ms",                  br: "✓ ~5ms p50" },
-      { feat: "Per-run cost attribution",           them: "✗",                        br: "✓" },
-      { feat: "BYOK support",                       them: "✓",                        br: "✓" },
-      { feat: "Platform fee",                       them: "✗ 5.5% card only",         br: "✓ 2% stablecoin / 5% card" },
+      { feat: "Open source & self-hostable",   them: "✗ closed-source cloud",        br: "✓ Apache 2.0 binary" },
+      { feat: "Fees on top of provider price", them: "✗ 5.5% credits · 5% BYOK",     br: "✓ none" },
+      { feat: "Routing",                       them: "⚠ static auto-router",         br: "✓ learns from your runs" },
+      { feat: "Hosted model catalog",          them: "✓ hundreds, incl. long tail",  br: "⚠ ~50, SOTA agentic & coding" },
+      { feat: "Free-tier models",              them: "✓",                            br: "✗ not yet" },
     ],
     tradeoffs: [
-      "You need the widest possible model catalog and don't want to operate any infrastructure",
-      "You're building a consumer-facing app that doesn't require agent-native features",
-      "Your team already has OpenRouter integrations and no migration bandwidth right now",
+      "You need the widest possible model catalog, long tail included",
+      "You want free-tier models rather than production-grade routing",
+      "You need enterprise features we haven't built out yet",
     ],
   },
 
@@ -179,7 +173,7 @@ export const COMPARE_REGISTRY: Record<string, CompareRegistryEntry> = {
       { feat: "Routing overhead",                   them: "⚠ ~15ms p50",                br: "✓ ~5ms p50" },
       { feat: "Per-run cost attribution",           them: "✓",                          br: "✓" },
       { feat: "BYOK support",                       them: "✓",                          br: "✓" },
-      { feat: "Platform fee",                       them: "— varies by plan",           br: "✓ 2% stablecoin / 5% card" },
+      { feat: "Platform fee",                       them: "— varies by plan",           br: "✓ none · 0% markup" },
     ],
     tradeoffs: [
       "Your team already relies on Portkey's prompt management, versioning, and caching workflows",

content/docs/(guide)/overview/bitrouter-vs-openrouter.mdx

@@ -1,23 +1,29 @@
 ---
 title: BitRouter vs OpenRouter
-description: OpenRouter is a closed-source cloud gateway with the widest model catalog; BitRouter is an Apache 2.0 binary you run anywhere, with ~6× less routing overhead and agent-native primitives built in. An honest side-by-side.
+description: Two takes on the same idea. OpenRouter went wide on the catalog; BitRouter went open source, took no cut, and taught the router to learn your workload. An honest side-by-side.
 ---
 
-Every LLM gateway makes the same headline promise: one API, many models, automatic failover. The differences that actually decide the choice show up underneath — how you deploy it, what it costs you in latency on every call, and whether it was built for chat apps or for agents.
+OpenRouter built this category. One key, hundreds of models, a catalog nobody has matched — if you've ever swapped providers without rewriting a line of code, that's largely their doing. We've learned plenty from them, and for a lot of teams they're still the right answer.
 
-## Deployment and overhead
+We're not trying to out-catalog them. BitRouter is a bet that the interesting problem has moved: not *how many models can you reach*, but *which one should this particular call go to* — and who owns the layer making that call. That's harder to build and slower to prove. It's the thing we want to build.
 
-OpenRouter is a closed-source cloud gateway with the widest model catalog on the market. That breadth is real, but it comes with a dependency: there is no self-host option, so your routing layer lives on someone else's infrastructure and adds their network hop to every call — roughly **~30ms of overhead per request**. BitRouter is the inverse trade: an Apache 2.0 binary you own and run inside your own VPC or CI, at **~5ms p50** — about 6× less overhead — with an open, PR-based provider registry instead of a curated one you can't extend.
+## Where we're genuinely different
 
-## What each one routes
+**You can run the whole thing yourself.** BitRouter is Apache 2.0, top to bottom — `bitrouter serve` and the router lives in your VPC, your CI, your laptop. OpenRouter is a closed-source cloud service: if it's down you're down, and you can't read the code that's choosing your models. Self-hosted, there's no platform fee at all.
 
-The sharper divide is what each one routes. OpenRouter routes model requests. BitRouter routes *agent runs*: identity per agent (KYA), an MCP/ACP tool gateway, injection checks, and autonomous stablecoin payments (x402) — none of which exist in OpenRouter. And where OpenRouter's routing is static, BitRouter wraps your loop in an [act → observe → evaluate → learn](/docs/overview/what-is-bitrouter) cycle that tightens routing every run.
+**We don't take a cut.** You pay the upstream provider rate and nothing else — 0% markup on every token. OpenRouter passes inference through too, but bills **5.5% to load credits** and **5% on BYOK traffic** past their free allowance. Bring your own keys to BitRouter and we charge you nothing for it.
+
+**The router learns your workload.** Every gateway can pick a model. BitRouter runs an [act → observe → evaluate → learn](/docs/overview/what-is-bitrouter) cycle over your actual runs, so routing tightens with every request instead of following a preset someone else tuned. That's the whole product — not a feature bolted onto a catalog.
 
 <CompareTable slug="bitrouter-vs-openrouter" />
 
-## OpenRouter is the right call when
+## When OpenRouter is the better call
+
+**You want everything.** We host roughly 50 models, deliberately — the SOTA tier for agentic and coding work. OpenRouter carries hundreds, including the long tail we don't. You can always [bring your own model](/docs/gateway-and-routing/bring-your-own-model), local or cloud, and we don't charge for it — where OpenRouter takes a cut of BYOK traffic.
+
+**You want free models.** OpenRouter has a free tier on some models; we don't. We're focused on making production agent workflows reliable and cheap, and free tiers come with the rate limits and quantization that production loops can't live with.
 
-You need the widest possible model catalog with zero infrastructure to operate, you're building a consumer-facing app that doesn't need agent-native features, or your team already runs OpenRouter and has no migration bandwidth right now. Switching later is a one-URL, one-key change — the [migration guide](/docs/guides/migrate-from-openrouter) walks it in under five minutes.
+**You need deeper enterprise tooling.** OpenRouter has more of it built out today. If there's a requirement we don't meet, [talk to us](/enterprise) — we'd rather hear the gap than guess at it.
 
 ## Next steps
 

content/docs/guides/migrate-from-openrouter.mdx

@@ -14,7 +14,7 @@ BitRouter offers several advantages over OpenRouter for agent workloads:
 | Feature | OpenRouter | BitRouter |
 |---------|------------|-----------|
 | **Deployment** | Cloud-only (closed-source) | Self-host or cloud (Apache 2.0) |
-| **Platform Fee** | 5.5% via Stripe | 2% via stablecoins · 5% via Stripe |
+| **Platform Fee** | 5.5% to load credits · 5% on BYOK | None — 0% markup, BYOK free |
 | **Agent Features** | Basic routing | Headless CLI, agentic payment, MCP/ACP gateway |
 | **Access** | Account registration required | No registration required |