The nouns of business, as canon.
One URI per entity type — what a business IS, field by field: identity keys, declared sources of truth, a type lattice extended from the open vocabulary, and the verbs that may act on it. The grammar the estate’s own records are converging on in the open, published so any agent can dereference it. Every liveness claim below checked cold, with its own evidence URL — including the ones about this canon’s own unbuilt front door.
Businesses are being defined for machines to run — agents working deals, closing books, settling claims. But the entities underneath are still private prose. Every business-as-code system re-invents what a Customer IS, which fields a Subscription carries, where revenue truth actually lives; none of it dereferences, and no two systems’ entities agree. The open vocabularies solve half of this: they can tell an agent what a thing means. They carry no sources — nothing says which field is human input, which is synced from a payments processor, which is computed, and which an AI generated and a human accepted.
An agent can only run what a machine can read, and a machine can only read what resolves. That gap — between a semantic vocabulary for humans and an executable entity grammar for machines — is the whole reason this surface exists. The verbs half of the gap belongs to the companion canon; this record holds the nouns.
A noun is a type definition a machine can run a business against. Three
identity keys place it — $id (URL identity for instances), $type
(the semantic type), $extends (its parent in the lattice) — and the
grammar carries a fourth property, $context, the vocabulary binding a
noun’s terms resolve against (inherited down the lattice in the spec’s
own examples). Fixing a context for this canon is a one-way door behind
the fixation gate, and this record does not pre-empt it — which is why
this record itself declares none. Every field declares where its truth
comes from: plain input, AI
generate with context, compute from siblings, sync from an
external system of record, reference through synced data,
aggregate over relations, fuzzy-ground against reference data,
or link to other typed instances.
Types are callable — calling Business(...) extends it, so the lattice
reads Thing → Organization → Business → Startup — and instances are
minted with new, each carrying a $id URL. One grammar answers the
three questions a runtime must ask of any entity: what is it, what does
it carry, and who holds the truth of each field.
const Startup = Business({
$type: 'Startup',
vertical: 'Industry vertical', // input — a human answers
stripe: $.Stripe.Account, // sync — external truth
mrr: $.sum($.subscriptions.amount), // aggregate — derived scope
arr: ($) => $.mrr * 12, // compute — a formula
pitch: 'Elevator pitch for {name}', // generate — AI proposes
})
The grammar exists in public code, not in this deck’s imagination:
dot-do/nouns (@dotdo/nouns) answered 200 on a cold check
(2026-07-31) — identity keys, the field-source grammar, callable
inheritance, and a taxonomy of core business nouns, in the open.
Candour on installability: the repo is public, but neither package name
resolves on the npm registry today (cold checks 2026-07-31). The code is
readable; it is not yet npm install-able under its own name. This
claim flips green when the packages publish.
The enrichment shape is design intent, stated as such: what a noun’s canonical record must carry is reverse-specified by the code in the open repo and by the estate’s own records, and the canon publishes when it can serve it. The substrate it publishes against serves today:
The $type substrate serves — schema.org.ai, the vocabulary this
record’s own frontmatter agrees against and the lattice extends,
returned 200 on a cold check (2026-07-31).
The unusual fact about this canon, same class as its occupations twin:
its demand is not projected, it is recorded — and the record of it is
stated at the exact width a cold read of the repo supports. The
portfolio’s current-generation pitch records — this file included —
open in the noun grammar: $type first, $id second, the record as
the single source of truth; seven legacy-format records predate the
grammar and are queued for regeneration, and dimension keys are still
converging onto minted URIs, alignment sweeps queued estate-side. The
estate’s registry of record goes further and files every domain with
its language coordinates — a noun, a verb, and a gerund on every row,
plus a plural where the name pluralizes (the named-agent rows file
none) — so the books themselves are kept in noun-and-verb grammar. The estate has been
adopting this language before the canon’s apex serves.
The adoption claim, gated rather than rounded up: a cold read of the
studio repo today finds seven records still in the legacy frontmatter
format with no $type at all, and a set of records keying dimension:
as a bare token rather than a minted URI. Both sweeps are queued; this
claim flips green when every record in the portfolio parses in the
grammar this canon is the surface of.
And the runtime layer already answers for it, cold:
The live gateway files the Noun as core infrastructure: on a cold check
(2026-07-31) apis.do answers with its typed link map, and the core
block names six objects — Domain, Noun, Verb, Thing, Action,
Event — each with its own path.
The gateway’s noun path serves — apis.do/nouns returned the nouns
service record on a cold check (2026-07-31): domain nouns.do, category
core, status available, with an also link to the door’s own API
path.
The managed-runtime door serves — nouns.do answered 200 on a cold
check (2026-07-31) under its own masthead (“Build with Semantic Nouns ·
Type-Safe Entity Management at Edge”). Serving is a liveness fact about
that apex, posted here because this record routes readers to it — its
offer and terms are that record’s to make, not this one’s.
A book seam, worn rather than rounded up: the estate’s registry of
record still files the nouns.do door as planned while the door serves
and the gateway’s service record says available — the books lag the
door. The reconciliation rides with that door’s own record; it is
carried here because this deck cites the door.
The grammar is a pair by construction: a noun is what a thing IS — identity, fields, sources, lattice; a verb is what may be DONE — the acts, their subjects, and their consequences. A type without acts is a filing cabinet; acts without types are undefined behavior. The estate’s books keep both columns on every row, and the gateway serves them as separate core objects side by side. The boundary between the canons is by rule: if it names state, it files here; the moment it is an act with a subject and consequences, it files at the companion.
The companion’s apex answers today, posted as a live fact: on a cold
check (2026-07-31) verbs.org.ai returns 200 with the same class of
hosting “Coming Soon — not yet provisioned” placeholder this canon’s own
apex wears. The pair is named end to end; neither canon serves yet.
The companion’s runtime door serves — verbs.do answered 200 on a cold
check (2026-07-31) under its own masthead (“Semantic CRUD Operations”).
As with the noun door: a liveness fact about that apex, nothing more
claimed here.
Candour about the pair’s other half: verbs.org.ai has no record of its own in the estate’s portfolio yet, no public companion repo, and the estate’s role table binds no role to it — its action-side row binds a different door. The registry’s language family and the gateway’s core block both pair Noun with Verb, so this record files the companionship as the gateway and registry file it, and wears the unreconciled role binding openly. When the companion’s record files, the pair’s claims live one per canon.
One motion, B2A: the canon’s consumer is a machine dereferencing a type.
An agent asks what a Deal IS before it works one; a record’s frontmatter
resolves its own $type; a runtime validates an instance against its
noun’s declared sources. The canon completes no transaction — every
motion that ends in money completes on the doors, on their own posted
terms: the .do language doors for the managed runtime, the estate’s
rails and cells for the work itself. Publishing and being
dereferenceable is the entire go-to-market, which is why the only launch
that counts is the apex serving.
What the apex actually serves today, posted as a live fact: on a cold
check (2026-07-31) nouns.org.ai answers 200 with a hosting “Coming
Soon” placeholder — “Domain nouns.org.ai is not yet provisioned,” marked
noindex — not the canon. This deck is the name’s first real record.
Nothing of the canon itself serves yet: no noun URI dereferences, no llms.txt, no machine index. This claim flips green when a cold request to a noun coordinate returns the canonical type record.
The estate’s own roles register files canon.nouns → nouns.org.ai as
active while the apex serves a provisioning placeholder — the books lead
the door, the same inversion the occupations twin wears, and this record
carries the contradiction rather than picking a side silently. Queued
estate-side with the other filing seams.
The canon’s name is nouns.org.ai — the estate’s records are
converging on its grammar, current-generation records already open in
it, and until the apex serves, this record is the name’s front door.
The grammar is public today in the open repo, and the nearest serving
door is nouns.do.
If this was forwarded to you: nouns.org.ai is the noun half of a language pair — verbs.org.ai names what may be done; this names what a business IS — an entity grammar seeded from the open vocabulary and enriched into one dereferenceable URI per type, carrying identity keys, field-level sources of truth, and the type lattice. The estate’s registry and live gateway already write in it, and its portfolio of records is converging on it in the open. Every factual claim above carries its own state, and either an evidence URL checked cold or a named gate — including the six ambers this record wears openly: the canon that does not yet serve at its own apex, the roles-register filing that leads the door, the unpublished packages, the registry row lagging the serving runtime door, the companion canon that has no record of its own yet, and the portfolio’s own grammar convergence, still incomplete and gated rather than rounded up. Judge the grammar the way it will have to be judged to matter: by whether its types resolve, and by how plainly it labels the ones that don’t yet.