Type the verb. Trust the effect.
The action primitive of the estate: the named, typed, permissioned verb that triggers fire, workflows sequence, and agents invoke — behind a front door that serves today, with every gate to the rest stated in the open.
Every automation reduces to the same sentence: when X, do Y. The market serves the halves unevenly. The when-half is genuinely solved in more than one place — event buses, schedulers, webhooks, thresholds, and the estate's own when-door among them. The do-half is where the wiring lives: a raw API key handed to a scheduler, a retry wrapper that double-charges because idempotency was somebody's afternoon project, an agent granted a credential that opens an entire API when the automation needed permission to do exactly one thing. The integration platforms sell connectors by the thousand, but the verb behind a connector is untyped at the boundary and permissioned by whatever key the platform holds. The effect itself — a named verb with a typed input, a permission scope of its own, and exactly-once execution as a declared property — is nobody's product.
The tax lands hardest exactly where the estate's whole premise lives: on builders and businesses too small to staff an integration practice. An automation whose verbs cannot be enumerated is not governed; it is merely running. If the machine economy runs on automations — the firings agents request, businesses permit, and ledgers must survive — then the effect has to be sold as a declared verb, or the do-half stays priced like a department.
Three things in this estate are the substrate itself: the studio, the platform, and the runtime. This is deliberately not a fourth. actions.do is the action primitive the platform operates — the effect boundary of the infrastructure estate — wearing its own door because the builder who owns what an automation may do is a different ICP from the builder holding compute, the owner of a sequence, or the owner of a firing condition, and a brand here is one ICP and one motion.
In the estate's own registry the coordinate is exact: noun Action, verb act, type primitive, category primitives/execution. The seams are short and each is a rule, not a vibe. A function is arbitrary compute with a return value; the moment the thing has a name in the business grammar, a permission scope, and consequences something else is allowed to fire, it is an action — functions.do keeps the compute, this door keeps the verb. A workflow is the sequence across time; the action is the single step's effect — workflows.do keeps the sequence. A trigger is the condition that decides when; the action is what may then be done — the when-half files at the sibling pair-door, the what-half files here. The runtime's agents are the callers deciding to act; the platform operates all of it as the one metered system its own deck describes.
WHEN — the firing condition: a subscription, a schedule, a threshold. The when-door owns the decision that something should happen. Registry grammar: noun Trigger, verb trigger.
WHAT — the permitted effect: a named, typed, permissioned verb, safe to fire exactly once. This door owns what may then be done. Registry grammar: noun Action, verb act.
The boundary is a rule either record can apply without asking the other: if the artifact is a condition, it files at the when-door; the moment it is a verb with a subject, a permission scope, and consequences, it files here. Nothing overlaps, because a condition never touches the world and a verb never decides when. Together the two doors complete the estate's automation grammar — when X, do Y — and each is evidenced on its own feet below.
triggers.do serves — the pair's when-door is live at its own apex.
The gateway routes the when-door as a named service today: GET https://apis.do/triggers returns a machine-readable JSON record — no
login, no signup — naming the service, its domain triggers.do, and its
status available.
export default action('Invoice.send', {
input: InvoiceRef, // typed at the boundary, not at the caller
permission: 'billing:send', // the verb's own scope — never the whole key
idempotency: 'invoiceId', // exactly once at the effect, however
// many times the automation asks
run: async (invoice, $) => {
// the one place this effect touches the world
},
})
What is on this slide is the intended contract, and this deck says so
plainly: no SDK is published under this record's contract, and nothing
here is a live self-serve claim. (A package named actions.do does
exist on npm — the estate's own legacy SDK from the drivly/ai era,
published April 2025, predating this record; it ships a CRUD client
over the gateway, a different contract than this slide, and the seam is
posted in kind on the bindings slide.) The shape follows the grammar the estate already
writes — the sibling orchestration record's engine subscribes with
$.on.Noun.verb and emits with $.send('Noun.verb', …); the action is
the same grammar's imperative mood, the verb those sentences name. The
declaration carries four properties as declared facts rather than
per-integration disciplines: a name in the shared Noun.verb grammar, a
typed input, a permission scope belonging to the verb rather than the
caller, and an idempotency key that makes exactly-once a property of the
primitive instead of a retry wrapper someone maintains.
The contract above is design intent. No SDK is published under this record's contract — the unscoped npm name is held by a Drivly-era legacy package shipping a gateway CRUD client, not the declared verb — no docs surface of this door's own documents it, and the machine catalog does not yet serve. This record describes the intended shape and claims nothing about public availability until the package, its docs, and the catalog post — and no benchmark or reliability figure appears here until one publishes with its method and window.
Concreteness over adjectives: each door below was checked cold on 2026-07-31 and carries its own state and its own evidence URL — never one URL evidencing several domains. Serving is a liveness fact, not a tenancy claim: nothing here asserts external tenancy, metered billing in production, or a usage roll. Those publish behind their own gates.
actions.do serves. The front door a builder would resolve is live, and
it sells composable actions with typed orchestration under this brand's
own name. The page's framing goes further than this record does — its
hero sells composing actions into workflows, which is the sibling
orchestration door's grain, and its meta carries a speed figure this
record does not adopt. The page predates the record; what this claim
posts is the liveness fact.
The gateway routes this primitive as a named service today: GET https://apis.do/actions returns a machine-readable JSON record — no
login, no signup — naming the service, its domain actions.do, its
description Actions Service, its category core, and its status
available.
platform.do serves — the operator's front door, whose own record files
this primitive's siblings among its composed runtimes under the same
claim discipline.
functions.do serves — the sibling primitive holding the compute a
named verb runs on.
workflows.do serves — the sibling composed runtime whose sequences
this door's verbs are the steps of.
Ambers worn in the open — each one the exact distance between what serves and what this door intends to be. (The figures gate on the economics slide is the estate's standing stack#1 §A5 disclosure rule, carried by every record in the portfolio — an estate gate, not an extra product amber.)
The domain's own machine door answers with a human page today — and not
even this brand's: actions.do/api returns the gateway's own apis.do
page, while the gateway's service record lists that address under
also as this service's own machine door. A machine following the
estate's own pointer lands on another brand's surface, written for
people. The claim flips when the catalog serves at that address as
structured JSON.
The estate's own registry files this coordinate planned, priority P1, while the front door serves — the books lag the door. The estate does not round up its own registry, in either direction: the live apex is posted above as a liveness fact, the filed status is reported here at face value, and this claim flips when the registry does.
A package named actions.do IS published on npm — the estate's own
Drivly-era legacy SDK (versions 0.0.1 and 0.1.0, published April 2025
from the prior drivly/ai repo, directory sdks/actions.do,
description "SDK for performing tasks within workflows"). Its 0.1.0
tarball ships dist/index.js and dist/index.d.ts with a CRUD client
over the gateway — actions.list/get/create/update/delete, depending
on apis.do 0.1.0 — a different contract than this record's declared
verb, from an era that predates the record. The name is occupied by a
predecessor; whether this record adopts the package or re-keys it is
queued in the program doc.
The declared-verb contract on the architecture slide is design intent — restated here in the ledger so no reader mistakes the specimen for a shipped SDK, or the legacy package above for this contract. The record's own package, docs, and catalog post behind this one gate.
The estate's role table carries no runtime binding for this primitive —
unlike the sibling functions and workflows records, there is no
runtime.actions row to wear at its filed state. The table's only
actions row is canon.actions → actions.org.ai, filed active: a
canon-layer coordinate, a different door, and nothing about it is
claimed here.
Primary motion is B2D: the buyer is a developer who evaluates in the docs and converts the first time a declared action fires exactly once — retried under the hood, never duplicated at the effect. No sales motion, no demo call, no procurement; the evaluation surface is the product surface, which is why the SDK-docs-and-catalog gate is the deck's most important amber. Secondary is B2A: a declared action is precisely the thing an agent should be handed instead of an API key — a typed, permissioned verb — and the first step of that motion already serves, because the gateway returns this service's machine-readable record to a caller with no login. Purchase and settlement for the machine motion gate on the contract surface, exactly as the sibling records state for theirs.
Layer-1 economics at the effect grain: fixed cost is operating the action substrate — the catalog, the permission checks, the idempotency ledger; each declared verb is metadata and each firing is a thin, logged execution, so blended margin improves with density.
The declared verb is the economic design, not just the governance design: an action is declared once and fired many times, so the substrate's cost tracks firings while its value compounds with the catalog — every verb added makes the automation surface more complete and the door harder to leave. There is no regulatory floor in the primitive itself: nothing in executing a permissioned verb reserves a step for a statutory person, so the implementation mix migrates all the way to Code. Verbs that do carry a floor — a filing, a claim, a regulated disbursement — live behind the estate's regulated cells' own doors, which compose this primitive rather than being flattened into it.
Action counts, firing volumes, permission-scope telemetry, and the internal-versus-external split are gated. Each figure publishes with its window and base or it does not publish.
every brand the estate launches automates on the estate stack this primitive guards — demand generated by the portfolio’s own search process, structural before commercial; the usage roll publishes behind its stack#1 §A5 gate or not at all
the estate’s gateway already routes /actions as a named service to a machine with no login — when the buyer is an agent, being discoverable and callable IS the distribution channel
the when-door and this door file as one grammar — a competitor selling either half alone re-creates the wiring seam between condition and consequence that the pair exists to delete
a business that has declared its verbs here — typed, permissioned, idempotency-keyed — must re-wire every one of them to leave; each verb added is metadata for the estate and migration work for a competitor
The claim ledger lives on the "What serves today" and bindings slides — one posted chip per live door, one amber per gate, each stated once. This slide is the evidence in kind: what a machine actually receives when it resolves this primitive, retrieved cold on 2026-07-31 with no login and no signup.
The gateway's service record. GET https://apis.do/actions
returns this envelope (abridged — the gateway's own api identity block
and the caller-context block are omitted):
{
"service": {
"name": "actions",
"domain": "actions.do",
"url": "https://actions.do",
"description": "Actions Service",
"category": "core",
"status": "available"
},
"links": {
"home": "https://apis.do",
"self": "https://apis.do/actions",
"api": "https://apis.do/actions",
"also": "https://actions.do/api",
"events": "https://apis.do/actions/events",
"category": "https://apis.do/categories/core"
}
}
Note links.also: the gateway itself points machine callers at
actions.do/api as this service's own door.
What that door serves today. GET https://actions.do/api answers
with a human page — and not even this brand's: the bytes are the
sibling gateway's own apis.do marketing page (title "APIs.do - Connect
Any API with Type-Safe Integration"), written for people. A machine
following the gateway's own links.also pointer lands on the wrong
brand's surface — the exact shape of the deck's most important amber,
stated here as what the bytes are rather than restated as a chip. The
gate on the bindings slide flips when structured JSON at this door's
own address replaces the sibling's page.
The front door is actions.do — it serves today.
If this was forwarded to you: actions.do is the action primitive of the startups.studio estate's infrastructure layer — the named, typed, permissioned verb that the estate's triggers fire, workflows sequence, and agents invoke. It is deliberately not one of the estate's three substrate properties, and its deck says so; it files in the same wave as its pair, the when-door, and together they complete the automation grammar: when X, do Y. What is live is posted with a URL checked cold; what is not is pending with the gate that flips it — including the ambers it wears openly: the machine door still serving the sibling gateway's human page, the SDK contract that exists as design intent while a legacy package from a prior era holds the npm name, and the estate's own registry still filing the coordinate as planned while the door serves. Judge it by what is posted, and by how plainly it labels what is not.