pitch.functions.do
Ship the function. Skip the infrastructure.
The execution primitive of the estate: write a function, deploy it once, and it runs warm at the edge — behind a front door that serves today, with every gate to the rest stated in the open.
↓ scroll · arrow keys
A builder holding a working function — ten lines of business logic that need to run close to every caller — is offered everything except execution at that unit: a platform to adopt, containers to build, regions to choose, cold starts to engineer around, a control plane to learn and then to staff. The logic took an afternoon; running it is apparently a career. The platforms that run functions in containers and clusters still sell that operation around the function and price the builder into carrying it. The isolate-based edge platforms deleted the container and the cold start — that problem is genuinely solved in more than one place — but what they sell is still a standalone runtime aimed at a human deployer: nothing about the function being discoverable to agent callers, and nothing composing it with workflows and data under one operator and one contract.
The tax lands hardest exactly where the estate's whole premise lives: on builders and businesses too small to carry an infrastructure practice. A primitive you must operate is not a primitive. If the function is the unit of the machine economy — the thing agents call, workflows compose, and businesses meter — then execution has to be sold at the unit, or the unit stays priced like a department.
Three things in this estate are the substrate itself: the studio, the platform, and the runtime. This is deliberately not a fourth. functions.do is the execution primitive the platform operates — the smallest unit of the infrastructure estate, wearing its own door because the builder who arrives holding a function is a different ICP from the business with an infrastructure decision, and a brand here is one ICP and one motion.
In the estate's own registry the coordinate is exact: noun Function, verb execute, type primitive, priority P0. The platform composes this primitive with its siblings — workflows for orchestration, the data surface for state — into the one metered system its own deck describes; the runtime's agents are the machine callers on the other side of it.
// the entire deployment artifact
export default async (event) => {
return { message: `Hello, ${event.name}!` }
}
There is nothing else to author. The engine's design — stated here as the built architecture it is, with its public gates below, not as a live self-serve promise: the deployed function stays a thin stub, kilobytes, holding only the business logic. The heavy capabilities — core runtime, web, data, ML — run as shared runtimes kept warm across all functions and reached over RPC, so cold-start elimination is an architectural property of the substrate rather than a per-function reservation someone pays to hold. The warmth is shared; the density compounds.
Language posture, stated at its actual state: TypeScript is supported — the front door sells exactly that and nothing more ("Write TypeScript functions with full type safety"), and this record matches the front door's own word. Plain JavaScript executes by construction — the TypeScript runtime runs it — but the door does not post it, so neither does this record until the docs surface says otherwise. Python and the WASM targets — Rust, Go, Zig, AssemblyScript, C# — are planned and not implemented, and this record will keep saying "planned" until the docs surface says otherwise rather than rounding a roadmap up to a feature grid. (The gateway's community-maintained Python SDK beta is a client library for calling services, not an execution runtime, and is not claimed here as one.)
The public self-serve loop — sign up, deploy, watch it run warm — is not yet the thing the front door serves, and no latency or availability figure appears in this record until benchmarks publish with their method and window. The architecture is built; the public proof posts behind this gate.
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, metered billing in production, or a usage roll. Those publish behind their own gates.
functions.do serves. The front door a builder would resolve is live, and
it sells exactly this record's offer in its own words — TypeScript
functions deployed globally, cold-start elimination as the headline.
The gateway routes this primitive as a named service today: GET https://apis.do/functions returns a machine-readable JSON record — no
login, no signup — naming the service, its domain functions.do, its
category compute, and its status available.
platform.do serves — the operator's front door, whose own record files
this primitive among its composed runtimes under the same claim
discipline.
agents.do serves — the sibling runtime whose agents are the machine
callers this primitive is built to answer.
Four ambers, worn in the open — the self-serve deploy path with its benchmarks, already stated at its gate on the architecture slide, and the three below — each the exact distance between what serves and what this door intends to be. (The figures gate on the economics slide is the estate's standing stack#1 §A5 disclosure rule, carried by every record in the portfolio — an estate gate, not a fifth product amber.)
The domain's own machine door answers in structured JSON today — and has
nothing behind it: functions.do/api returns a well-formed envelope with
a 404, the very address the gateway's service record points to as this
service's API. A machine that resolves this primitive finds a door that
speaks its language and is not yet open. The claim flips when the catalog
serves at that address.
The estate's own role table files this domain as the runtime.functions
binding of the constitution's runtime — with status pending, while the
sibling runtime.workers binding at agents.do is already active. The
estate does not round up its own registry: the binding is declared here at
its filed state, and this claim flips when the registry does.
Metered per execution is the intended model, and the rate card IS the pricing surface: it binds when it posts at the contract surface — verbs, protocol, rate card, guarantees — not before, and never as prose in a deck. No figure is published or implied until then.
Primary motion is B2D: the buyer is a developer who evaluates in the docs and converts at the first successful deploy — no sales motion, no demo call, no procurement. The evaluation surface is the product surface, which is why the self-serve gate on the architecture slide is the deck's most important amber. Secondary is B2A: the same function, once deployed, is a callable capability an agent discovers through the gateway — and the first step of that motion already serves, because the gateway returns this service's machine-readable record to a caller with no login. 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 smallest grain: fixed cost is keeping the shared runtimes warm; each additional function is a thin stub served at near-zero marginal cost, so blended margin improves with density.
The shared-runtime architecture is the economic design, not just the latency design: warmth is a fixed cost paid once for the substrate, and every additional function amortizes it further. Density compounds in the tenant's favor and the operator's at once — the opposite of per-function reservation pricing, where every tenant pays to hold their own idle capacity. And there is no regulatory floor anywhere in this function: nothing in executing a stub reserves a step for a statutory person, so the implementation mix migrates all the way to Code.
Function counts, execution volumes, and the internal-versus-external split are gated. Each figure publishes with its window and base or it does not publish.
every brand the estate launches runs its logic on the estate stack this primitive anchors — demand generated by the portfolio’s own search process, structural before commercial; the usage roll publishes behind its stack#1 §A5 gate or not at all
the estate’s gateway already routes /functions as a named service to a machine with no login — when the buyer is an agent, being discoverable and callable IS the distribution channel
shared warm runtimes mean each new function makes the substrate cheaper per call — a compounding property a per-function-reservation architecture cannot follow without abandoning its own pricing
functions, workflows, and data are composed runtimes under one operator and, when it posts, one contract — unbundling the primitive re-creates the integration burden the builder came here to delete
The claim ledger lives on the "What serves today" and bindings slides — one posted chip per live door, one amber per gate, each stated once. This slide is the evidence in kind: what a machine actually receives when it resolves this primitive, retrieved cold on 2026-07-30 with no login and no signup.
The gateway's service record. GET https://apis.do/functions
returns this envelope (abridged — the caller-context block is omitted):
{
"service": {
"name": "functions",
"domain": "functions.do",
"url": "https://functions.do",
"description": "Serverless Functions",
"category": "compute",
"status": "available"
},
"links": {
"self": "https://apis.do/functions",
"also": "https://functions.do/api",
"category": "https://apis.do/categories/compute"
}
}
Note links.also: the gateway itself points machine callers at
functions.do/api as this service's own door.
What that door serves today. GET https://functions.do/api answers
in the same structured envelope — with a 404 inside it (abridged):
{
"api": { "name": "functions.do", "from": "https://platform.do" },
"links": {
"home": "https://functions.do",
"self": "https://functions.do/api"
},
"error": { "code": "NOT_FOUND", "message": "Not Found", "status": 404 }
}
A door that speaks the machine's language and is not yet open — the exact shape of the deck's most important amber, shown here as bytes rather than restated as a chip. The gate on the bindings slide flips when a function catalog replaces the error object.
The front door is functions.do — it serves today.
If this was forwarded to you: functions.do is the execution primitive of the startups.studio estate's infrastructure layer — the smallest unit the platform composes and the runtime's agents call. It is deliberately not one of the estate's three substrate properties, and its deck says so; it is the primitive under them, sold to the builder who has a function and refuses to buy a platform to run it. What is live is posted with a URL checked cold; what is not is pending with the gate that flips it — including the four ambers it wears openly: the machine catalog, the estate's own pending registry binding, the rate card, and the self-serve path with its benchmarks. Judge it by what is posted, and by how plainly it labels what is not.