Define the service. Skip the second company.
The commercial primitive of the estate: one typed object turns a working capability into a priced, guaranteed, callable service — behind a front door that serves today, with every gate to the rest stated in the open.
A builder whose capability already works — the functions execute, the workflow completes, the agent answers — is offered everything except the thing itself. Pricing lives at a billing vendor. Access lives in a gateway config. Terms live in a contracts folder. Guarantees live in a support rotation someone has to staff. The capability took a month; making it sellable is apparently a company — a second one, founded around the first, out of vendors. Everything below the business boundary became a declarative primitive over the last two decades. The sellable service — the unit the whole exercise exists to produce — never did.
The estate's masthead states the thesis in one sentence: Infrastructure-as-Code enabled Software-as-a-Service, and Business-as-Code enables Services-as-Software. This door is where that thesis stops being an argument and becomes a declaration: if services are becoming software, the service must be a primitive — one typed object a builder declares — not a bundle of vendors assembled by hand.
Three things in this estate are the substrate itself: the studio, the platform, and the runtime. This is deliberately not a fourth. services.do is the commercial primitive the platform operates, and the pack's axis locates it exactly: execute (functions.do) → orchestrate (workflows.do) → persist (database.do) → settle (payments.do) → serve (this door). Every rung before it faces inward, toward the builder's own system. The service is the first primitive with a customer on the other side of it — the rung where the composed stack crosses a business boundary.
In the estate's own registry the coordinate is exact: noun Service, verb serve, type primitive, priority P1. One ICP, one motion, per the estate's rule: the builder who owns a working capability and needs it sellable is a different person from the builder holding a function, the owner of a sequence, or the agent-native business — which is why this door exists at all.
import { Service, POST } from 'services-as-software'
const service = Service({
name: 'translation-service',
description: 'AI-powered translation, delivered as software',
// the business overlay — model typed here, rates posted at the card
pricing: { model: 'per-use' },
// the callable boundary
endpoints: [
POST({
name: 'translate',
path: '/translate',
handler: async (input) => run(input),
}),
],
})
That is the published SDK's own shape — abridged, and figure-free by this record's rules: pricing models are typed in the declaration; rates post at a rate card or not at all. The SDK's frame is the door's frame: a service is a superset of a digital worker with a payment and business overlay, built to cross company boundaries — which is why the package composes the estate's other primitives (functions, data, workers) underneath rather than reinventing them.
The SDK is published and public: the npm registry serves
services-as-software — "Primitives for building AI-powered services
that operate as software" — latest 2.4.0 at the 2026-07-30 check, with
Service and endpoint constructors, pricing-model types, and client,
provider, and metrics primitives in its documented surface.
The public loop — declare a Service, serve it from the door, watch a caller reach it — is not yet the thing the front door serves, and no latency, availability, or scale figure appears in this record until benchmarks publish with their method and window. The SDK is public; the door's own self-serve 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.
services.do serves. The front door resolves and answers 200 — and what
it serves today is stated plainly on the next slide rather than rounded
up here: the platform template's service-mesh page, not yet the Service
primitive's own surface.
The gateway's catalog serves this domain as a named service today: GET https://apis.do/services returns the machine-readable catalog — no
login, no signup; 318 named services at the 2026-07-30 check — including
this domain's own row: name services, domain services.do, category
core, status available.
The SDK's public registry record serves cold — the second machine surface a builder can resolve today, independent of the apex.
platform.do serves — the operator's front door, whose own record files
this primitive's siblings under the same claim discipline.
One naming fact worth reading twice: the gateway's collection endpoint
for its entire catalog is /services. The noun this door owns is the
noun the whole estate's machine surface organizes by.
Five ambers, worn in the open — the self-serve path already stated at its gate on the declaration slide, the declared-here-discovered-there loop stated at its gate on the pair slide ahead, and the three below. (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 sixth product amber.)
The coordinate seam, this record's largest candour: the live apex serves a page titled "Orchestrate Distributed Microservices — Service Mesh at the Edge," and the estate's registry description column files the same ("Service mesh") with status planned/P1 despite the lit door. This record files the door as the Service primitive of Services-as-Software — on the registry's own noun and verb, the published SDK, and the masthead's stated thesis — and wears the fact that neither the apex nor the registry description says so yet. The re-filing is queued for ratification; an adverse ruling reverts this record, not the evidence.
The domain's own machine artifacts do not serve today: services.do/api
renders the browser application rather than a structured envelope, and
services.do/llms.txt answers 500 — both checked cold 2026-07-30. A
machine that resolves this primitive today should use the gateway's
catalog row; the claim flips when the door speaks its own machine
language at its own address.
Metered on the service's own pricing model is the intended shape, and the rate card IS the pricing surface: it binds when it posts — not before, and never as prose in a deck. No figure is published or implied until then; the SDK README's example rates are examples, and this record does not adopt them.
The estate runs both sides of the service boundary, as two doors with a rule between them. services.do is the supply-side primitive: where a builder's capability becomes a declared, priced, guaranteed service. api.services is the demand-side catalog: where machine buyers discover, price, and call across the whole as-a-Service spectrum — every row stamped live | specimen | roadmap, graded by a third party. One boundary, two faces: what gets defined here is what gets resolved there.
The demand-side twin serves today: api.services answers cold as the agent-first catalog its own record describes, under its own claim discipline and its own third-party grade.
The loop that matters — declared here, discovered there, called by an external agent — has not run end-to-end, and this record says so. It posts when it has happened, with both records in evidence.
Primary motion is B2D: the buyer is a builder who evaluates in the SDK and the docs and converts at the first defined service — the first time a working capability becomes a priced, callable object without a second company around it. The evaluation surface is the product surface, which is why the self-serve gate on the declaration slide is the deck's most operative amber. Secondary is B2A: a defined service is machine-callable by construction, and the estate's demand-side catalog is where agent buyers resolve supply. Purchase and settlement for the machine motion gate on the contract surfaces, exactly as the sibling records state for theirs.
Layer-1 economics at the commercial rung: the overlay is software all the way down — defining, metering, and guaranteeing one more service adds near-zero marginal cost, so blended margin improves with the number of services declared.
The primitive itself has no regulatory floor: nothing in declaring, pricing, or serving a Service object reserves a step for a statutory person, so its implementation mix migrates all the way to Code. Where a service's DELIVERY requires a licensed human — legal work, insurance acts — the floor belongs to that vertical, and the estate's regulated cells carry it; the declaration composes the cell, it never absorbs the statute. That separation is the design: floors live in verticals, never in the primitive.
Service counts, call volumes, settlement figures, and the internal-versus-external split are gated. Each figure publishes with its window and base or it does not publish.
the estate’s masthead states Services-as-Software as its business model; this door is that noun’s declaration — a namespace position that compounds every time the thesis is argued anywhere, by anyone
supply defined at this primitive, demand resolved at api.services — vendors hold one shard of the service boundary; the estate holds the pair and the rule between them
every service the estate’s own brands ship is a candidate declaration on this primitive — demand generated by the portfolio’s own search process, structural before commercial; the roll publishes behind its stack#1 §A5 gate or not at all
execution, orchestration, state, and settlement under one operator — unbundling the overlay re-creates the vendor assembly the builder came here to delete
The claim ledger lives on the serving and seams slides — one posted chip per live surface, one amber per gate, each stated once. This slide is the evidence in kind: what a machine actually receives when it resolves this primitive today, retrieved cold on 2026-07-30 with no login and no signup.
The gateway's catalog row. GET https://apis.do/services returns
the full machine-readable catalog; this domain's own row, verbatim:
{
"name": "services",
"domain": "services.do",
"url": "https://services.do",
"description": "Services Service",
"category": "core",
"status": "available"
}
The SDK's registry record. GET https://registry.npmjs.org/services-as-software answers with the
package document (abridged):
{
"name": "services-as-software",
"dist-tags": { "latest": "2.4.0" },
"description": "Primitives for building AI-powered services that operate as software"
}
Two machine surfaces serve today, and neither is the domain's own door —
that door renders a browser application at /api and answers 500 at
/llms.txt, which is exactly the shape of the seams slide's second
amber, shown here as behavior rather than restated as a chip. The gate
flips when the catalog serves at the domain's own address.
The front door is services.do — it serves today.
If this was forwarded to you: services.do is the commercial primitive of the startups.studio estate's infrastructure layer — the last rung of the pack's axis, where execution, orchestration, state, and settlement compose into a thing with a customer — and the .do front door of the estate's stated thesis, Services-as-Software. 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; what is not is pending with the gate that flips it — including the five ambers it wears openly: the coordinate re-filing (its own apex does not yet wear this positioning, and the deck says so against its own interest), the domain's machine door, the rate card, the self-serve path, and the declared-here-discovered-there loop. Judge it by what is posted, and by how plainly it labels what is not.