Why Iron Lake.

1. Compute is a commodity. The pricing is a story.

A vCPU-hour on AWS in 2026 costs roughly what it cost in 2018, in nominal dollars. In real dollars, against the underlying silicon's actual price-per-FLOP curve over the same period, that line should have collapsed. It didn't. The reason it didn't is not a mystery, and it isn't a conspiracy: it's that nobody making the buying decision is doing the multiplication.

Hyperscaler pricing is a story told to a buyer who does not have time to check it. The story has the shape: "look at all these services, look at the security posture, look at the SLAs, look at the global footprint, look at how scary it would be to leave." The story does not have the shape: "here's our amortized hardware cost, here's our power cost, here's our transit cost, here's our actual utilization, here's the multiplier we applied to those four numbers to arrive at the price you pay." That second story is also true. It's just nowhere on the page.

We're going to put that second story on the page. Pricing as a formula committed to a Git repo. Inputs itemized. Utilization published quarterly. A 30–40% gross margin ceiling instead of a target — because below 30 we can't fund the safety circuits, and above 40 we'd be lying about the word "transparent." Egress priced near actual transit cost, not at the eye-watering 40× markup that has become industry-standard punishment for the crime of leaving.

The bet is that there is a customer for whom "I can verify my bill" beats "the brand has a stadium." That customer does not exist in great numbers among humans. It exists in great numbers among the agents that humans are about to start delegating their infrastructure budgets to. Whoever ends up paying our bill, they will be a multiplier on top of an underlying cost we have already published. That is the deal.

2. Owned metal only. The cost floor must be ours.

Renting from a hyperscaler caps your cost floor at theirs. If your whole edge is "we charge less than AWS for the same compute," you've structured your business such that AWS's quarterly margin decision is your business decision, made for you, on a calendar you don't control. That isn't a business. That's a prayer.

Owning the metal is slow. The boxes have to arrive. The rack has to be wired. The substrate has to be deployed by one solo operator, on weekends, with NixOS and a checklist, and when something doesn't work it doesn't work because of a bug in my flake, not a bug in someone else's control plane I'm forbidden from reading. This is the trade. We will not scale the way an AWS-reseller scales. We will scale the way a small fab scales: slowly, deterministically, on a curve we can sketch on paper.

In return, the cost story flows in one direction. When the hardware curve drops, our prices drop. When power gets cheaper (or, more honestly: when our utilization rises and our amortization spreads thinner), our prices drop. When a competitor announces a price cut, we don't have to call a meeting; we have to look at our own formula and decide if our utilization moved. The price is downstream of the math. The math is downstream of the metal. The metal is ours.

There is a version of Iron Lake that runs on Hetzner or OVH or bare-metal-as-a-service somewhere and gets to skip the rack work. That version is faster to ship and cannot keep its promises past year three. We're picking the slower one.

3. Machines are first-class tenants. Stop making them click buttons.

Every cloud you've ever used was designed in a meeting where the primary user was assumed to be a human staring at a dashboard. The IAM model is human. The console is human. The error messages are human-prose. The onboarding flow has a "welcome" video. The billing tab has a graph. The security console is a visual maze designed to communicate compliance at a glance to an auditor with no time.

It's 2026 and a meaningful share of cloud activity is now agents: autonomous LLM-driven processes that read documentation, write code, deploy infrastructure, watch logs, debug errors, kill jobs, retry, escalate. They use the dashboard by imitation — screen-scraping, browser automation, parsing the HTML of pages that were never designed to be parsed, hallucinating widgets that moved in the last UI refresh, paying $0.27 in OpenRouter tokens to find the "delete" button on a settings page that costs the underlying cloud $0.0004 to render. It is grotesque.

We invert this. The API is the product. Not "the API is one of the interfaces" — the API is the surface. Every other modality is a thin adapter: the skill file teaches an agent the API; the MCP adapter exposes the API; the OpenAPI spec documents the API; the CLI wraps the API. There is no second source of truth. There is no feature available only through the dashboard. There is no console action that requires a clicked checkbox.

What this means concretely:

• Errors are structured, not prose. {code, message, retryable, details}. An agent can branch on a boolean.
• State is observable. Timings are exposed. Cost rides every response. The agent's working memory always knows what's happening.
• Idempotency is by header, not by hope. Replay-safe by default.
• Authentication is one bearer token, scoped to one tenant. We do not have an IAM language. We do not have policies. We have keys.
• Documentation is a skill file. It tells the agent how to use Kingdom in the same shape as every other skill the agent has ever loaded.

The dashboards we eventually build will be read-only reflections of API state. A human watching what their agent is doing. Not a place where the official path to deploy a thing is to scroll, click, scroll, click, name something, agree, click. That path is a dead end and we're not building toward it.

4. The free tier is permanent. Treat it like a floor, not a funnel.

Every cloud free tier is a funnel. You're given X credits or Y months or Z requests, and after that the rug comes out. The math of a funnel is: pay to acquire users, win them with subsidized usage, raise the price after they're stuck.

The funnel doesn't work for autonomous agents the way it works for humans. An agent is not "stuck" anywhere. An agent does not develop sunk-cost loyalty to a UI it learned. An agent will move its workload to whichever provider has the right shape for the next task, and it will do it in a five-minute change. The funnel is leaking on a population of users who can't be funneled.

So we treat the free tier as a floor instead. Small enough to be cheap to run — a baseline tenant on Kingdom costs us pennies a month in steady state. Big enough that an autonomous agent can reach for "spin up a Kingdom job" without a credit-card-in-the-prompt conversation. Permanent because we want agents reaching for it reflexively, the way a human reaches for cat without thinking about whether cat is a paid service.

It will be funded by paid usage from agents whose workloads exceed the free floor. It will not be funded by venture capital, because we don't have any, and we don't intend to take any unless we have to. We'll be fine.

5. Self-serve only, forever. Sales is a tax we'd rather skip.

Once you have a sales team, the pricing is no longer the pricing. It's list price, which is a posted number nobody actually pays, behind which lives a forest of negotiated SKUs, annual commits, custom terms, MSAs, and quarterly reviews. The team that runs that forest is paid for, by you, on every invoice that comes out of it.

We don't want to fund that team. We want to put that money into the next box of metal. So: every feature on Kingdom is available to every account at the published price, on the day it ships. There is no enterprise tier. There is no negotiated contract. There is no "talk to us" button on the pricing page, because there is no need to talk. The pricing page is the contract; the API is the implementation; the bill is the invoice. A self-serve startup with three engineers gets exactly the same Kingdom that a Fortune 100 with a procurement team would get, and pays the same rate per unit.

This will close some doors. There are buyers — large, slow, budget-rich buyers — for whom "we can't talk to your sales team" is a dealbreaker, because their procurement process literally requires negotiated terms. We will not get those buyers.

That's okay. The buyer we're optimizing for is the agent that read the skill file, called the API, paid the published price, and moved on. There are about to be a lot of them. Whoever wins the agent-as-buyer market wins on shape, not on golf.