# api.services

> api.services is one catalog where software agents browse the whole as-a-Service spectrum: 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.

The villain is the procurement wall: every tier an agent needs 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. The wall does not refuse agents. It ignores them, which is worse: an agent does not bounce, it blacklists.

Every row stamped live | specimen | roadmap: the honest map is the product.

## Probe the map (keyless: no key, no account)

```sh
curl https://api.services/services
```

The full catalog as typed JSON. OK | EMPTY | BLOCKED with a cure. 402 is a structured offer. 403 is a device-flow handoff. Never a faked 200. Filter with `?vertical=`,
`?model=`, `?gate=`, `?status=`, `?effect=`. The keyless tier is the
top of the funnel: /services, /verticals, /stack, and /pricing answer 2xx
with no key, forever.

## The ladder

The vertical says what a service is about. The delivery model says how it is delivered. Two axes on every row; the human gate is exactly one value on the second.

- Infrastructure-as-a-Service (`?model=iaas`): Raw substrate behind an API: databases, compute, storage you call, never rack.
- Platform-as-a-Service (`?model=paas`): A managed runtime: you ship the service, the platform runs everything under it.
- Software-as-a-Service (`?model=saas`): Finished software behind an API: the tool itself is the product.
- Data-as-a-Service (`?model=daas`): A record per request: the answer is the product, typed and priced per read.
- Agent-as-a-Service (`?model=agent`): A named agent holds the job end to end: you call the role, not the tool.
- Services-as-Software (`?model=services_as_software`): A professional service delivered as software: the outcome, not the seat, is the product.
- Licensed-Human Marketplace (`?model=human_marketplace`): Reserved acts routed to credentialed professionals: the human gate, kept real where the law requires it.

Every stamp is relayed from the catalog at render, never asserted in copy.

## Read a row

```sh
curl https://api.services/services/qa.grade
```

One catalog row in full: the door URL that owns the work, a copy-pasteable
curl, the MCP tool name, the gate, the posted price, the stamp, and the cure
when the act is reserved.

## Read the rate card

```sh
curl https://api.services/pricing
```

No outcome, no charge. Every price flat, posted, and fixed at post. Prices are posted by the owning doors and aggregated here; specimen
and roadmap rows never appear on the card.

## Read the family map

```sh
curl https://api.services/verticals
```

The map is a router, not a toll. The pair anatomy (api.* demand, gigs.* supply) lives in the
reserved tier below.

## Read the stack

```sh
curl https://api.services/stack
```

cloud + data + code + agents + humans + workflow = a service. The equation was already the ladder. Each term carries its rungs of the delivery
ladder. All six substrate rows are stamped roadmap today; settlement
(payments.do, x402) and identity (id.org.ai) are prose, not extra rows.

## Other surfaces

All ten AXP surfaces, by name:

- Content-negotiated root: `GET /` (Accept: text/html gets the human
  register; everything else gets this document; both import the same ruled
  strings from src/copy.ts, zero drift)
- llms.txt: `GET /llms.txt` (this document)
- agents.json: `GET /.well-known/agents.json` (capability card)
- icp.json: `GET /icp.json` (agent self-classification plus the not_for
  refusals)
- openapi.json: `GET /openapi.json` (hand-authored OpenAPI 3.1; roadmap
  paths tagged roadmap)
- Declared MCP: `ALL /mcp` (JSON-RPC 2.0; tools: find_service, get_service,
  get_pricing, get_verticals, get_stack)
- Keyless tier: `GET /services`, `GET /verticals`, `GET /stack`,
  `GET /pricing` (2xx with no key, forever)
- Structured 402s: `GET /offers/specimen` (the offer shape, labeled
  specimen)
- Cross-referencing linkset: every response carries
  `Link: service-doc, service-desc, describedby`
- Attestation ladder: agents.json `attestationLadder`; the third-party
  grade is `curl https://api.qa/api.services`

## 402s are offers, not errors

A money boundary answers HTTP 402 with a structured offer
`{id, title, price, checkoutUrl, alternatives[]}`. This door posts no prices of its own: every live price is
posted and settled at the owning door. The map is a router, not a toll. Vet the shape before you hit
a live boundary:

```sh
curl https://api.services/offers/specimen
```

## Reserved acts

Workers propose. The Gate commits. A human's Declination is sovereign. Pending states: PENDING_SIGNER | PENDING_ADJUSTER | NEEDS_HUMAN. NEEDS_HUMAN carries a terminus: {function, marketplace, sla}.
NEEDS_HUMAN → a marketplace, never a void. 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.

Every vertical is a pair: api.* demand, gigs.* supply, one kernel. One supply pool wearing many brand doors.

```sh
curl 'https://api.services/services?gate=reserved'
```

Every reserved row names its profession, its pending state, and its
marketplace terminus.

## Attestation

Judged by api.qa, never self-graded: curl https://api.qa/api.services