pitch.llm.do
Every model. One contract.
The intelligence gateway of the estate: one metered door to every language model. Its machine doors serve today; its human apex is down; and this deck says which is which, with evidence for both.
↓ scroll · arrow keys
An AI product's quality and cost curve is now a portfolio decision: extraction wants one model, reasoning another, bulk classification a third — and the right answer to each reshuffles quarterly. But every provider sells that decision as a marriage: its own key, SDK, rate limits, billing, outage calendar, and deprecation schedule. A product using three providers carries three of everything, and every model improvement anywhere in the market becomes a migration project inside the codebase.
The payment call and the phone call already solved this: one contract over a market of interchangeable suppliers, with the supplier choice demoted to configuration. The model call — bought from a supplier market that reshuffles quarterly — is still wired like it's 2023: provider by provider, by hand, in the application layer.
Three things in this estate are the substrate itself: the studio, the platform, and the runtime. This is deliberately not a fourth. llm.do is the intelligence gateway the platform composes — filed in the estate's own registry at an exact coordinate: noun LLM, verb generate, category ai/models, type service, priority P0. It wears its own door because the builder holding model calls is a different ICP from the business with an infrastructure decision, and a brand here is one ICP and one motion.
The seam with the siblings is the demand design: functions running on the execution primitive and agents running on the runtime are this door's native callers — when their work is a model call, this is the door it goes through. The estate does not round that design up to a usage claim: what the siblings send through this gateway today publishes behind the same gate as every number in this record.
The contract's shape is fixed, and it is the whole product: one key (not one per provider), one bill (not one per provider), one call shape — the model named explicitly, or selected by a declared routing policy over capability, cost, and latency — and failover behind the door, so a provider outage is the gateway's problem, not a paging event in the tenant's app. The published package record describes the SDK, in its own words, as a Vercel AI SDK provider — the design point that would make adopting the gateway a provider swap in config, and leaving it the same. That provider shape is stated here as the record's description, not as a posted capability: the importable build is an amber below, with the gate that flips it.
The SDK is published and resolvable cold: the npm registry serves the
llm.do package record — versions 0.0.1 and 0.1.0 — described in its
own words as an "Intelligent AI Gateway for routing requests to optimal
language models with Vercel AI SDK provider support."
The package record resolves; the package does not yet import. Checked
cold 2026-07-30: both published tarballs (0.0.1 and 0.1.0) contain only
package.json, README.md, and a build-info file — no code at the
declared dist/index.js entry — so npm install llm.do resolves and
the import fails. This is the ICP's first cold check, and this record
reports its result at face value: the SDK is a published name and a
described design, not yet a shipped build. The claim flips when a
tarball ships the importable build its own manifest declares.
The routing policy — declaring capability, cost, and latency bounds instead of naming a model — is the contract's intended second half, and its public call shape is not yet published. This deck describes the shape and claims nothing about its availability until the reference posts.
"Optimal" is the package's word, and this record declines to adopt it in present tense: no claim that the gateway picks better models than a human would survives here until benchmarks publish with their method and window. Routing quality is intent, gated — not a superlative.
Concreteness over adjectives: each door below was checked cold on 2026-07-30 and carries its own state and its own evidence URL — never one URL evidencing several domains. Serving is a liveness fact, not a tenancy claim: nothing here asserts external tenancy, routed production traffic, or a usage roll. Those publish behind their own gates.
The machine door serves. llm.do/api returns a structured JSON
self-description to a caller with no login — naming the service, calling
itself an "Intelligent AI Gateway," and pointing at its own docs, repo,
and SDK.
The docs door serves. llm.do/docs is live — the estate's
services-as-software documentation hub, with llm.do among its named SDK
surfaces.
The pricing surface serves and posts its plans: a $0/month pay-as-you-go tier with usage-based billing, a $500/month Scale tier, and contact-priced Enterprise. Plan tiers are posted product facts on that live surface; per-model rates are not there, and the gap is an amber on the next slide.
The estate's gateway routes this service as a named record today: GET https://apis.do/llm returns machine-readable JSON — no login — naming
the service llm, its domain llm.do, its category ai, and its
status available.
The repository the machine door points at is public and resolvable cold. The URL evidences that the repository resolves — nothing here asserts development activity.
platform.do serves — the operator this gateway is designed to be
composed under, holding its record to the same claim discipline. The
URL evidences that door's liveness only, not any filing.
The composition is design intent, not yet a filed fact: platform.do's own record does not yet list llm.do among its composed surfaces, and this deck does not cite a liveness URL as evidence of a filing. The claim flips when the sibling record files it.
Each amber below is the exact distance between what serves and what this door intends to be — named as a checkable gate, not blended into present-tense marketing.
The apex is down. https://llm.do returned HTTP 500 on 2026-07-30 —
checked cold three times — a deployed application answering with an
error page while its own subpaths serve. A deck that counts liveness in
green chips does not get to skip the front door: this claim flips when
the apex answers 200 cold, and until then no sentence in this record
says "llm.do serves."
There is no model catalog an agent can enumerate without credentials: a request for a models listing at the machine door returns a permission-denied error to an unauthenticated caller — a refusal, not a listing. A catalog may exist behind credentials; none serves cold, and a gateway an agent cannot enumerate cold is a promise this deck declines to make in present tense. The claim flips when the catalog serves — the models, listed, at an address a machine can read without special standing.
The one capability this deck sells — a routed model call — is not yet a
posted fact. Checked cold 2026-07-30: the OpenAI-style path
llm.do/v1/chat/completions answers a POST with a not-found page, and a
POST to llm.do/api/chat returns 401 Unauthorized. A call path may
exist behind credentials, but no documented call shape has been verified
cold end-to-end, and this record does not round an auth wall up to a
served capability. The claim flips on the first routed call a cold
caller can reproduce from the docs.
The plan tiers are posted; the per-model card is not. Metered per-call pricing per model binds when it posts at the pricing surface — not before, and never as prose in a deck. No per-token figure is published or implied in this record.
Primary motion is B2D: the buyer is a developer who evaluates in the docs and the posted surfaces and converts at the first routed call — no sales motion, no demo call, no procurement. The evaluation surface is the product surface, which is why the apex amber is the deck's most urgent gate: a B2D door converts where humans land. Secondary is B2A: a gateway whose callers are programs is machine-addressed by construction, and the first step already serves — the estate's gateway returns this service's record to a machine with no login, and the service's own machine door answers in structured JSON. Purchase and settlement for the machine motion gate on the contract surface, exactly as the sibling records state for theirs.
Layer-1 economics at the gateway: fixed cost is operating the routing, metering, and failover layer once; each additional tenant and call rides the same layer at near-zero marginal cost, so blended margin improves with routed volume.
A gateway's economics are a routing position's economics: the layer is built once and every call amortizes it, while the expensive part — the inference itself — is a pass-through the tenant was already buying, now metered on one bill. There is no regulatory floor anywhere in this function: nothing in routing a model call reserves a step for a statutory person, so the implementation mix migrates all the way to Code. The commercial frame is posted where it belongs — the plan tiers on the live pricing surface — and everything finer-grained is gated.
Routed-call volumes, tenant counts, and the internal-versus-external split are gated. Each figure publishes with its window and base or it does not publish.
tenants bind to one call shape while the models behind it churn — the faster the model market moves, the more expensive it becomes to leave the one integration that absorbs the churn
the estate’s gateway routes /llm as a named service to a machine with no login today — when the caller is a program, being discoverable and callable IS the distribution channel
the estate’s own functions and agents are the door’s designed callers — demand generated by the portfolio’s own stack, structural before commercial; the usage roll publishes behind its stack#1 §A5 gate or not at all
llm.do is the category noun in the estate’s namespace — a position taken by holding the name and serving the contract, not by advertising against incumbents
Serving is a liveness fact, not a tenancy claim: each posted URL below evidences that one door resolves — not that anyone occupies it.
llm.do/api serves — the machine door answers in structured JSON, no
login.
llm.do/docs serves — the documentation door is live.
llm.do/pricing serves — the plan tiers are posted on the live surface.
apis.do/llm serves — the estate's gateway lists this service,
status available, to a machine with no login.
The SDK package record resolves cold at the npm registry — published, versioned, and described in its own words.
The importable build remains an amber — the published tarballs carry no code at the declared entry; the SDK is a resolvable record, not yet a shipped build.
agents.do serves — the sibling runtime whose agents are the machine
callers this gateway is built to answer.
functions.do serves — the execution primitive whose functions are the
door's other native caller.
The apex remains an amber: the front door a human resolves answered 500 on 2026-07-30, and this record reports it at face value until it answers 200.
The catalog remains an amber — the machine door refuses an unauthenticated models listing rather than serving one — the gate that matters most for the B2A leg.
The routed call remains an amber — the one capability this deck sells is not yet a posted fact, and it flips on the first routed call a cold caller can reproduce from the docs.
The per-model card remains an amber — plans are posted, rates are not.
The machine door is llm.do/api and the docs are at llm.do/docs —
both serve today.
If this was forwarded to you: llm.do is the intelligence gateway of the startups.studio estate's infrastructure layer — one metered contract over every language model, sold to the builder whose product is a portfolio of model calls and who refuses to marry a provider to make it. It is deliberately not one of the estate's three substrate properties, and its deck says so. What is live is posted with a URL checked cold — the machine door, the docs, the posted plans, the gateway record, the SDK's package record — and what is not is pending with the gate that flips it, including the ambers it wears openly: its own apex, the importable SDK build, the model catalog, the first cold-verified routed call — the one capability this deck sells — the per-model card, the routing-policy surface, and the benchmarks behind any claim of routing quality. Judge it by what is posted, and by how plainly it labels what is not.