# Business-as-Code: The Full Stack of the Autonomous Service Economy

> do.industries is the full stack of the autonomous service economy: open standards compile into autonomous startups, with credentialed humans in the loop.

Canonical: https://do.industries/
Updated: 2026-10-26

Business-as-Code

## The full stack of the autonomous service economy.

We turn open industry standards into software that does the work, then build the companies that sell it.

[Explore the stack](https://do.industries/#stack) [The manifesto](https://do.industries/manifesto)

claims.ts:

```ts
import $, { ai, db, on, send } from 'sdk.do'

on($.Claim.received, async (claim) => {
  const decision = await ai.adjudicate(claim, {
    schema: $.CoverageDecision,
  })

  if (decision.requiresHuman) {
    await send($.Escalation.created, {
      claim,
      bench: 'gigs.claims',
    })
    return
  }

  await db.create($.Decision, decision)
  await send($.Claim.adjudicated, decision)
})
```

## Infrastructure-as-Code enabled Software-as-a-Service. Business-as-Code enables Services-as-Software.

Six slabs stacked from the foundation up: Seeds, Canon, Engines, Runtime, Headless SaaS and Services-as-Software. The layer being read floats above the stack, and its face shows one claim in that layer's form: a row of a standard, a typed node, a function, a running service, an endpoint with no interface, a signed deliverable.

The open ground truth

### Seeds

Every entity in the economy starts as a row of a published open standard, ingested verbatim and never touched by a model.

[standards.org.ai](https://standards.org.ai), NAICS, O*NET, UNSPSC, APQC, GS1 / EPCIS, OpenAPI, Zapier catalogs

The knowledge layer

### Canon

The canonical, machine-readable knowledge layer of the economy, enriched beyond the standards it cites, open to every agent that can dereference a URL.

[schema.org.ai](https://schema.org.ai), apis.org.ai, problems.org.ai, the dimension properties

Enriched is canonical: the standards are seeds, not ceilings.

Open and unbranded

### Engines

The open, unbranded machinery (functions, workflows, database, API and directory builders) that compiles knowledge into working software.

[ai-functions](https://www.npmjs.com/package/ai-functions), [ai-workflows](https://www.npmjs.com/package/ai-workflows), [ai-database](https://www.npmjs.com/package/ai-database), api-builder, dir, graph-site, [autonomous-startups](https://www.npmjs.com/package/autonomous-startups), [GitHub](https://github.com/dot-do)

The .do register

### Runtime

The managed services autonomous businesses run on, each one itself a business running on this stack.

[platform.do](https://platform.do), [functions.do](https://functions.do), [workflows.do](https://workflows.do), [agents.do](https://agents.do), [database.do](https://database.do), [apis.do](https://apis.do), DB4.AI

**DB4.AI**, the database built for agents. The stack runs on itself: every managed .do service is an autonomous startup on its own stack.

Software without the UI

### Headless SaaS

Every SaaS category, rebuilt without the UI, because the user is an agent.

[headless.ly](https://headless.ly), CRM, billing, support, inventory, HR, + 25 more categories

APIs and MCP first, no human seat required.

+ the artifact doors

### Services-as-Software

Services delivered as software, sold at the moment of need: the deliverable is the product.

[agentic.services](https://agentic.services), patent.click, trademark.click, capcall.click, boardpacks.click, + the .co work-noun estate

## One function, four protocols

Everything here is a semantic function: the same function callable through SDK, CLI, MCP, or HTTP. One import proves it.

SDK (In your TypeScript):

```ts
import $, { send } from 'sdk.do'

await send($.Claim.received, claim)
```

CLI (From your terminal):

```sh
do send Claim.received ./claim-4821.json
```

MCP (Inside your AI assistant):

```ts
await client.useTool('do', {
  script: 'await send($.Claim.received, claim)',
})
```

HTTP (Over plain HTTP):

```sh
curl https://apis.do/send/Claim.received \
  -H "Authorization: Bearer $DO_API_KEY" \
  --json @claim-4821.json
```

## One API per vertical

One canonical API per vertical, engineered to be the answer a model gives when an agent asks.

| Vertical | API substrate | Human bench | Demand door |
|---|---|---|---|
| Automotive | [auto.dev](https://auto.dev) | [Partner](https://startups.studio/apply) | Vin |
| Legal | api.lawyer | gigs.lawyer | patent.click |
| Sales | api.forsale | closers.sale | closers.deals |
| Insurance | api.insure | gigs.claims | the .claims estate |
| Supply chain | [epcis.dev](https://epcis.dev) | customs.broker | [visibility.cloud](https://visibility.cloud) |
| Health / RCM | [Partner to build this vertical](https://startups.studio/apply) |  |  |
| Construction | [Partner to build this vertical](https://startups.studio/apply) |  |  |
| Real estate | [Partner to build this vertical](https://startups.studio/apply) |  |  |

Horizontal default providers, spanning every vertical

[Platform.do](https://platform.do), DB4.AI, [Agents.do](https://agents.do), [Headless.ly](https://headless.ly), [API.QA](https://api.qa)

## Resolved, not browsed

Agents don't browse, they resolve: graded machine capability and credentialed human capability on one spine.

A licensed adjuster on gigs.claims above four claims agents: Intake, Coverage, Payments and Fraud. Each agent works on its own and sends a decision up to the adjuster when its confidence is below 0.80; the adjuster signs it and the agents carry it out.

The credentialed bench behind every agent, selling escalations, review, and signatures, not seats.

Machine capability

[apis.directory](https://apis.directory)

Graded, live, payable APIs. An agent asks for a capability and gets an endpoint back.

Human capability

[gigs.exchange](https://gigs.exchange)

Credentialed people, verified per jurisdiction. An agent escalates and gets a signed decision.

Proof of capability

[api.qa](https://api.qa)

The grader behind both. Every grade and credential is a signed attestation anyone can replay.

## Startups, minted by the stack

Every layer below exists to make them. Claim one, back the fund, or see what has shipped.

### [Build](https://startups.studio)

Founders claim graduated startups and operate them on the stack.

### [Invest](https://startups.studio/invest)

Back the portfolio through Fund I, Longtail Holdings.

### [Partner](https://startups.studio/partner)

Ship as the default provider in the stack every startup launches with.

[See the portfolio](https://startups.studio/portfolio)

## The window is open

Open standards compiled into running businesses, with humans in the loop.

[Build a startup](https://startups.studio)

---

© 2026 Do.Industries, Inc. All rights reserved. Terms: https://do.industries/terms. Privacy: https://do.industries/privacy.