Schema.org, extended for AI.
The type system of the agent economy: the open Schema.org vocabulary carried verbatim — one URI per type, dereferenceable cold — plus the AI-native superset that extends it for Business-as-Code. The substrate the estate's records are written in, published with a live apex, a public repo, and an npm package. Every liveness claim below checked cold, with its own evidence URL; the gaps wear amber.
Schema.org solved this problem once, for the document web: publishers
and crawlers agree on what a Person, an Organization, a Product
is, because one open namespace says so and resolves when asked. The
agent economy is rebuilding the same tower without the grammar — agents
exchange payloads typed by nothing, every framework mints its own
Agent and Tool from scratch, and a record that says $type: Workflow means whatever the author was feeling. Private vocabularies
don't join. They never have.
That is survivable for chatbots. It is not survivable for an estate
that compiles businesses from records: the records here open with
$type lines, file their ICPs, Motions, and Channels as URIs, and a
machine will read all of it. The line either resolves into a canonical
answer, or the record is written in a private language and the compiler
is folklore.
Resolve schema.org.ai/Brand cold and this is the record — the
breadcrumb, the inheritance, the properties, each linking its expected
types:
Thing / Intangible / Brand
Brand — a name used by an organization or business person for
labeling a product, product group, or similar.
Extends: Intangible (schema.org.ai)
Properties: aggregateRating AggregateRating
logo URL · ImageObject
review Review
slogan Text
+ every inherited Thing property, typed and linked
The seed is carried verbatim — the definitions on the served pages are
Schema.org's own text, share-alike and attributed, so the open standard
stays inspectable under the extension. And the self-reference is the
point, stated as a count rather than a universal: 110 of the estate's
117 pitch records open with $type: https://schema.org.ai/Brand
(grep-verified 2026-07-31); the seven that don't are the legacy core
flagships written before the convention, queued for the alignment
sweep. This deck is the record of the namespace that line resolves
into.
The estate's own $type line dereferences — schema.org.ai/Brand
returned 200 on a cold check (2026-07-31) as the typed record above:
breadcrumb Thing / Intangible / Brand, Extends: Intangible, properties
table with expected types.
The tree has depth — schema.org.ai/CreateAction, two levels below the
root, returned 200 on a cold check (2026-07-31) as a typed record:
Thing / Action / CreateAction, with its own subtypes (WriteAction,
PaintAction, …) in the nav.
This surface is not a brand looking for users — it is the grammar the
portfolio already agrees against, and the agreement is counted, not
asserted: 110 of the estate's 117 pitch records open with a $type
URI minted here (grep-verified 2026-07-31). The seven that don't are
the legacy core flagships written before the convention — carrying no
$type line at all — queued for the sibling-alignment sweep, and this
record states that gap instead of rounding it up. The ICP, Persona,
Motion, and Channel URIs across the estate's frontmatter —
ICP/developer-seller, Persona/public, Motion/B2A,
Channel/namespace-position — are coordinates under this namespace,
and the program's open mint queue (~40 minted-but-unratified URIs)
mints here too. The estate has been writing itself in this language
wave after wave.
Candour about those coordinates: the minted URIs do not dereference
today — /ICP/*, /Persona/*, /Motion/*, and /Channel/* paths
returned 404 on cold checks (2026-07-31). They are load-bearing as a
filing convention inside the estate's records; they become load-bearing
as infrastructure when the mint queue ratifies and the records serve.
This claim flips green when a minted coordinate answers cold.
The role binding and the citation graph are book facts today: the
estate's role register files schema.types → schema.org.ai as active,
and the sibling records that cite this namespace live in the estate's
own repo — neither yet resolvable by a stranger's curl. Both post as
evidence when the register and the records are published.
Thing · Person · Organization · Product
the open vocabulary of the document web, carried unedited under share-alike attribution — the standard is the seed, never a fork
schema.org.ai/Brand · schema.org.ai/CreateAction
the full Thing tree as dereferenceable typed records: breadcrumb, Extends line, properties with expected types — live at the apex today
Agent · Tool · Model · Workflow · Capability · MCP
the types the agent economy actually exchanges, typed in the published npm package and documented in the public repo — apex pages pending, worn in amber below
The superset is why the ".ai" is in the name: Schema.org stops at the
document web, and the extension carries the vocabulary into
Business-as-Code — Agent, Tool, Model, Workflow, Capability,
plus the machine-surface types (API, Webhook, MCP, SDK). Today
that layer ships in code and books, not yet at the apex:
The package is published — the npm registry answered a cold check
(2026-07-31) for schema.org.ai with latest 0.1.0, described as
"Schema.org vocabulary plus the .org.ai superset (Agent, Tool,
Capability, Model, …) as TypeScript types."
The repo is public and dedicated — github.com/dot-org-ai/schema.org.ai
answered a cold check (2026-07-31): public, described as "Foundational
data schemas and types for the .org.ai ontology system," last pushed
2026-07-29.
The superset does not serve at the apex yet: /Agent, /Tool,
/Model, /Workflow, /Capability, and /MCP all returned 404 on
cold checks (2026-07-31), while the base vocabulary's pages serve. The
extension is real in the package and the repo; the name's own front
door owes it a page, and this record says so instead of letting the
".ai" imply it.
The motion is B2D, authoring-led: the substrate is adopted when records
are written — a builder imports the types or keys a $type line —
and there is no funnel, no signup, nothing to buy; adoption is
agreement. Every machine that later reads a record dereferences the
same namespace, which is the B2A leg. That timing rule is the boundary
inside the canon pack, filed explicitly: the twins are each filed to
answer one axis of a reader's question — which industry, who does the
work — by dereference at read time; their own records wear their apex
states today. This substrate serves the writer, once, at the moment the
record is typed. And the masthead
boundary holds by rule: do.industries narrates the whole machine to a
human evaluator; this surface answers one machine question — what kind
of thing is this. One ICP, one motion, on every side of the line.
Concreteness over adjectives, on the substrate's own terms: each door below was checked cold on 2026-07-31 and carries its own state. Serving is a liveness fact about a URL — nothing here asserts coverage or identity beyond what its own evidence shows.
The apex serves under its own identity — schema.org.ai returned 200
on a cold check (2026-07-31): title "Schema.org.ai - Schema.org.ai",
rendering the vocabulary reference with the core-type index (Thing,
Action, CreativeWork, Organization, Person, Product, …) under this
brand's own masthead.
A substrate built for machine callers should hand them the index:
schema.org.ai/llms.txt returned 404 on a cold check (2026-07-31).
The machine index is carried as intent until it serves.
The shared-surface seam, worn from this record's side
(industries.org.ai queue entry, 2026-07-30): the sibling zone
industries.org.ai serves 200 today titled under this brand's masthead
— "schema.org.ai - Schema.org Vocabulary Reference" — and it is a
different build than the apex's own application. This brand's identity
renders on a zone this record does not file as its surface; the twin's
own record carries the seam as its naming amber, and this record
refuses to count that zone as reach.
Price model: none. The repo posts the license — CC BY-SA 4.0, with attribution to Schema.org, whose share-alike terms the extension inherits — and attribution is the only consideration. This is not modesty; it is architecture: a grammar is only authoritative if agreeing with it is free, and every commercial term in the estate lives on the record of the door that charges it. The substrate answers what a thing is; it never competes with the doors that sell what gets done with one.
The front door is schema.org.ai — it serves today. Resolve /Brand
cold and read what comes back.
If this was forwarded to you: schema.org.ai is the type system of an estate built on one thesis — business logic is now executable, so the vocabulary businesses are written in must dereference. It is schema.org, carried verbatim and extended for AI: a live apex serving typed records, a public repo, a published npm package, and the namespace this portfolio's records are written in — 110 of its 117 pitch records open by citing it (grep-verified 2026-07-31; the seven legacy flagships that predate the convention are queued for alignment). Every factual claim above carries its own state and evidence URL, checked cold — including the five ambers it wears openly: the AI superset not yet serving at the apex, the estate's minted coordinates that 404 today, the role register and citation graph still book facts, the unpublished machine index, and the twin zone rendering under this brand's masthead. Judge a type system the way this deck judges itself: resolve a URI and read what comes back. Start at schema.org.ai/Brand.