pitch.api.services
The as-a-Service spectrum, one agent-first catalog.
Infrastructure, platforms, software, data, agents, services delivered as software, and licensed professionals where the law requires one — every row stamped, every outcome typed, every posted price flat. Judged by api.qa, never self-graded.
↓ scroll · arrow keys
Every tier of the as-a-Service spectrum is sold a different way: infrastructure by console, software by seat, data by contract, professionals by phone call — each behind a signup built for hands and eyes. A human tolerates this. A software agent cannot: a price it cannot read at call time does not exist for it, and a signup it cannot complete is a wall.
The wall does not refuse agents. It ignores them — which is worse. A visitor who bounces might come back; an agent that hits a dead surface records the failure and routes around that door forever. It does not bounce, it blacklists. Every service provider still selling exclusively to hands and eyes is accumulating that verdict right now, silently, in other people's fleet configs.
Every row in the catalog sits on two axes. The vertical says what a service is about; the delivery model says how it is delivered — seven rungs from raw substrate to reserved human acts:
iaas · paas · saas · daas · agent · services_as_software · human_marketplace
One row shape carries the whole spectrum:
curl https://api.services/services/qa.grade
// the load-bearing fields of a catalog row, abridged — on the wire it
// arrives wrapped in an { "outcome", "item" } envelope and also carries
// name, effectClass, and note (reserved rows add a reserved block).
// The door that owns the work, and everything an agent needs to decide,
// priced, before calling:
{
"id": "qa.grade",
"vertical": "…", "deliveryModel": "…",
"gate": "none | key | offer | reserved",
"price": "posted flat, or null on the keyless tier",
"upstream": { "door": "…", "path": "…" },
"call": { "curl": "…", "mcpTool": "…" },
"status": "live | specimen | roadmap"
}
Outcomes are typed — OK | EMPTY | BLOCKED with a cure — and a refusal is
never a faked 200. A money boundary answers 402 with a structured offer
{id, title, price, checkoutUrl, alternatives[]} for the agent to relay
to its principal — a real 402, vettable today at the labeled specimen. An
identity boundary answers 403 as a device-flow handoff to a human by
the same published contract; every row live today is keyless, so the 403
path has no live instance yet. The stamp — live | specimen | roadmap — is relayed
from the catalog at render, never asserted in copy: the honest map is the
product.
The catalog is live and keyless: at the 2026-07-30 api.qa attestation it served 21 typed rows — 7 stamped live, 4 specimen, 10 roadmap — across the seven delivery models. The stamps are the point: the map states what is real, what is a labeled specimen, and what is only planned, in the data itself.
Everything an agent needs to find, judge, and call the catalog is
published as a surface, by name: the content-negotiated root · llms.txt ·
/.well-known/agents.json (capability card) · /icp.json (agent
self-classification, including the not_for refusals) · openapi.json
(hand-authored 3.1, roadmap paths tagged) · declared MCP over JSON-RPC
(find_service, get_service, get_pricing, get_verticals,
get_stack) · the keyless tier · structured-402 specimen · a
cross-referencing linkset on every response · a declared attestation
ladder whose top rung is someone else's signature.
All ten surfaces are live and named on the door itself — the llms.txt enumerates each by name with the path or header that carries it.
The ICP is published as an API: /icp.json declares the agent classes this door serves — the builder integrating one capability, the orchestrator composing many — and the callers it refuses. The deck's ICP is read back from that surface, not asserted over it.
The 402 offer shape is vettable before any live boundary: /offers/specimen serves the structured offer, labeled specimen, so an agent can integrate the money path against a labeled fake instead of discovering the shape in production.
Some acts the law reserves for a credentialed human — and a catalog that
pretends otherwise is lying at its most dangerous row. The grammar is the
same one the whole estate runs on: workers propose, the Gate commits,
and a human's Declination is sovereign. A reserved row never dead-ends:
its pending state carries a terminus — {profession, pendingState, marketplace} — so the handoff lands in a named human marketplace, never
a void.
Every vertical is a pair — api.* demand, gigs.* supply, one kernel —
and this catalog is where the pair anatomy is legible in one place: the
demand door names the work, the supply door names the humans, and the
reserved tier is the seam between them. Most rows never enter a pending
state at all; the reserved tier is the exception the grammar handles, not
the rule the grammar exists for.
The reserved tier is queryable today: every reserved row names its profession, its pending state, and its marketplace terminus, in the data.
The termini are named; the routing is not yet exercised end-to-end. The claim that a reserved act was actually completed by a credentialed human reached through the map posts when it has happened, with the record in evidence.
The catalog asks agents to trust its stamps, so it refuses to grade itself. api.qa — the singular family's verification door — probes the surface cold, scores it against a published checklist, and signs the report. The current grade is not an A, and the deck says so, because the report is the product working as designed.
Attested 2026-07-30 by api.qa v0.1.0: Grade C · AX score 10/10 — all ten agent-experience checks pass (llms.txt, capability card, icp.json, content negotiation, OpenAPI, declared MCP, keyless flow, structured 402s, linkset, attestation ladder), plus schema-conformance sampling, a no-ghost-surface check, and a full contract diff against the live surface. The report is Ed25519-signed with a replayable seed — anyone can re-run the judgment.
The report caps the grade because the declared MCP contract is contradicted by behavior — in the verifier's words, a lying surface is worse than a missing one. The declared-but-unserved OAuth suite (RFC 9728 protected-resource metadata, RFC 8414 discovery, PKCE, dynamic client registration, resource indicators, 401 challenge) is the contradiction and the next engineering milestone; the climb is claimed when the re-grade is published, not before.
The map posts no prices of its own. The catalog's verbs are keyless and free, forever — that is the funnel, and gating it later would poison the very fleet configs it exists to enter. Every live price on the aggregated card is posted by the owning door: flat, fixed at post, no outcome no charge. Specimen and roadmap rows never appear on the card.
The rate card is live and states its own model in the data: keyless catalog; x402 per call where live; upstream doors post their own offers. The catalog's own rows carry price 0.
Where the position earns: the router sits where every door in the family wants to be found, and settlement rails (x402 at the doors, payments.do beneath them) are the designed path for the money that crosses the map. How the router itself participates in settlement is design intent under evaluation — stated here as intent, and claimed as economics only when a real settlement crosses it.
Caller counts, probe volume, and any revenue basis. Not presentable until the estate's reporting basis resolves; no figure appears in this deck before then.
Primary motion is B2A: the buyer-side channel is the agent itself. The door is addressed to machine callers in its own bytes — the root serves them markdown, /icp.json tells them whether they are the ICP, the keyless tier lets them evaluate without a signup, and a 402's checkoutUrl is built to be relayed to the human principal who settles. Secondary is A2A: agent-to-agent, where the caller's principal is itself an agent economy — same surfaces, longer ladder.
No paid acquisition, no scaled outreach: the channel is agent discovery and the namespace position itself. A rail whose caller is a machine is found the way machines look — one cold fetch at the obvious name.
The motion is designed and the surfaces are live; external fleets routinely discovering and calling through the map is claimed when it is observed, not because the architecture implies it.
in the agent-discovery layer, the generic question — what services exist, machine-callable? — should resolve to api.services the way automotive resolves to auto.dev; the name is the shelf position for machine callers
stamps relayed from the catalog at render, never asserted in copy; typed refusals; no faked 200s — an incumbent directory that marketed first cannot retrofit structural candour without confessing its catalog was copy
graded by api.qa with signed, replayable reports — a trust mechanism a machine ecosystem can standardize on, demonstrated by the door posting its own C
every vertical pair — api.* demand, gigs.* supply — resolves through the family map, so each new door the estate opens makes the map more complete and the map makes each door findable
Stated plainly: the door is live and attested; most of what it indexes is not yet. Seven rows are stamped live today; the substrate stack rows are all roadmap; no live settlement has crossed the map. Every amber below is deliberate — the stamps are the deck.
The front door is live, content-negotiated, and agent-first: curl gets the typed map, a browser gets the human register, both from the same ruled strings.
Third-party attestation is live: Grade C · AX 10/10, Ed25519-signed, replayable seed, verified 2026-07-30.
The stack equation — cloud + data + code + agents + humans + workflow = a service — is published, and all six substrate rows are stamped roadmap today. The equation is claimed as inventory when the first term goes live, not while it is a diagram.
The money path exists as a labeled specimen on this door and as one live 402 offer at an owning door (api.qa's posted attested-run). The claim that matters — an agent relayed an offer, a principal settled, the owning door delivered — posts when it has happened, with the receipt in evidence.
One command, no key, no account:
curl https://api.services
Read what comes back, then read what someone else says about it —
curl https://api.qa/api.services — before trusting a word of ours. If
the shape holds up, put the catalog in your fleet's path: integrate one
row, wire the 402 relay, and tell us which row you needed that was
stamped roadmap — demand evidence is what flips stamps.
If this was forwarded to you: api.services is one catalog where software
agents browse the whole as-a-Service spectrum — infrastructure, software,
data, agents, and licensed professionals where the law requires one —
every row stamped live | specimen | roadmap, every outcome typed, every
posted price flat, and the whole door graded by an independent verifier
at api.qa. It is early, and the map says exactly how early, in the data.
If you run agents: curl https://api.services. If you know who does:
forward this.