When it happens, the right thing fires.
The automation primitive of the estate: the event side's binding surface, where the events the world emits are bound to the actions the estate runs — declared as records, operated at fleet grain — behind a front door that serves today, with every gate to the rest stated in the open.
A builder who reacts to events — when a record changes, sync it; when a payment lands, provision; when the clock strikes, roll the batch — shops a real market, and this deck names it honestly at both grains. Event routers solved rule-based delivery, cron services the clock, webhook relays retries per hook — one binding at a time, solved well. And the category goes further: the modern job platforms sell fleet-grain operation too — routing, monitoring, dead-letter queues, recovery on one surface — and this record does not pretend otherwise. The contrast is scoped, not universal. What the category cannot carry is what this estate is: a binding declared in the same noun.verb grammar the sequence engine already subscribes with, so the firing surface and the sequence surface speak one language instead of meeting at an integration; a service the gateway already returns to an agent with no login; a substrate occupied by construction. Bolted on at an integration seam, even a capable platform leaves the builder operating the seams — what is bound to what, in the language the processes actually speak, stays an archaeology project. The builder can write any single trigger in ten minutes. Operating all of them, across the seams, is the job nobody wanted.
The remaining tax lands hardest exactly where the estate's whole premise lives: on builders and businesses too small to staff the vigil — the monitoring stack, the dead-letter triage, the 3am page. If the machine economy runs on events — the changes agents notice, businesses react to, and clocks produce — then the binding of event to action has to be sold as a declaration, or the moment of firing 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. triggers.do is the automation primitive on the event side — the binding surface the platform composes with its other capabilities — wearing its own door because the operator of an event fleet is a different ICP from the owner of any single process, and a brand here is one ICP and one motion.
In the estate's own registry the coordinate is exact: noun Trigger, verb trigger, type primitive, category primitives/automation, priority P0, status implemented — action phrase "Triggers at scale." The seams are short, and the event-side one is the load-bearing rule: a firing starts a sequence, and workflows.do owns everything after the firing — retries inside steps, waits measured in days, escalation across kinds of labor. This door owns the firing itself: what is bound to what, under what condition, whether each firing happened, and what recovers it when it fails. If the question is "what happens next," it is the sibling's door; if the question is "what fires, when, and did it," it is this one. The batch pair actions.do gets the same one sentence, stated here from this side: a trigger is the condition that decides when — a subscription, a schedule, a threshold; an action is what may then be done — a named, typed, permissioned effect. If the artifact is a firing condition, it files here; the moment it is a verb with a subject, permissions, and consequences, it files at the pair door. Together they complete the estate's automation grammar: when X, do Y. functions.do executes the unit of work a firing invokes; the runtime's agents emit the events on one side of the binding and receive the firings on the other; the platform operates all of it as the one metered system its own deck describes. And the registry's event-bus coordinate — events.do, the pipe beneath the binding — is filed implemented at P0 while holding no zone anywhere today; this record cites it as a registry fact and claims nothing about it serving, with the gap worn as an amber below.
There is nothing else to author on the event side. The grammar — stated
here as the built architecture it is, with its public gates below, not
as a live self-serve promise: a binding subscribes to events by noun
and verb, the same $.on.Noun.verb language the estate's workflows
engine already runs, so the firing surface and the sequence surface
speak one language rather than meeting at an integration. What this
door adds above the grammar is the fleet surface its front door sells:
centralized routing of events to their bound actions, monitoring at
population grain, and recovery when a firing fails — the operational
questions ("what is bound, did it fire, what is dead") answered as
records a human or an agent resolves rather than dashboards a human
watches.
The trigger grammar lives in the estate's engine — a private,
unpublished repository with no public docs of its own; the sibling
workflows.do record states that gate in full and this record inherits
it rather than restating it as availability. The apex's own View Docs
links resolve to the platform's docs at docs.platform.do, which
document the platform's services, not a trigger SDK's primitives. This
record describes the design and claims nothing about public
availability until the package and its docs post — and no benchmark,
latency, or reliability figure appears here until one publishes with
its method and window.
// The trigger grammar is the estate's own event language.
// Every subscription in the engine is a binding: noun.verb in, action out.
$.on.Order.placed(async (order, $) => {
// what happens next is the sibling's door (workflows.do);
// that this handler fired — routed, retried, recovered,
// and on the record — is this one's.
})
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.
triggers.do serves. The front door a builder would resolve is live,
and it sells exactly this record's coordinate: event-driven automation
at scale — fleets of triggers with centralized monitoring, intelligent
event routing, and failure recovery. The page's own framing goes
further than this record does: its copy promises automatic load
balancing across global edge locations and AI-optimized trigger
performance, a story this record deliberately does not claim. The page
predates the record; what this claim posts is the liveness fact.
trigger.do serves — and the singular zone answers with this door's
own page: the same Triggers.do front door, served from the same
deployment. The alias behaves as filed. What this claim does not assert
is the registry's agreement — that seam is the pending Claim on the
bindings slide.
The gateway routes this primitive 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, its
description Event Triggers, and its status available.
workflows.do serves — the event-side sibling whose sequences this
door's firings start, and whose record states the boundary rule from
its own side under the same claim discipline.
platform.do serves — the operator's front door, whose own record
files this primitive's layer under the same claim discipline.
functions.do serves — the sibling primitive whose units of work a
firing invokes.
agents.do serves — the sibling runtime whose agents emit the events
on one side of the binding and receive the firings on the other.
actions.do serves — the batch pair's what-door is live at its own
apex, and its record states the when/what boundary from its own side
under the same claim discipline.
Ambers worn in the open — each one the exact distance between what serves and what this door intends to be.
The domain's own machine door answers with a human page today — and not
even this brand's: triggers.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 door. A machine that resolves this
primitive finds a door opening onto another brand's page written for
humans. The claim flips when the catalog serves at that address in the
machine's own language.
The grammar is built architecture in the estate's private engine, with no published package and no docs of its own — the apex's View Docs links resolve to the platform's docs. The most important amber for the B2D motion, because for this ICP the docs are the brand, and this deck declines to claim them in present tense.
The registry files the singular trigger.do as its own planned P1
coordinate — noun Trigger, "Event trigger / Triggers fired" — while
the pack files the zone as this door's alias, and the live zone sides
with the pack: the singular apex serves this door's own page today.
The estate does not round its own registry up or down: the
disagreement between the books and the zone is declared here at face
value, queued in the doctrine doc, and this claim flips when the
registry does.
The registry files the event-bus coordinate — events.do, noun Event,
verb emit, P0, implemented — and the bus is the pipe beneath every
binding this door holds. But events.do has no zone anywhere in the
estate's accounts today: the name does not resolve, and the doctrine
doc queues it as a P0 registry entry with no zone. The books lead the
door, and this record reports the books at their filed state without
claiming the door.
Metered per firing is the intended model, and the rate card IS the pricing surface: it binds when it posts at the contract surface — verbs, protocol, rate card, guarantees — not before, and never as prose in a deck. The registry's pricing column files the tier as free; tier language publishes when the card does, and no figure is published or implied until then.
Primary motion is B2D: the buyer is a developer who evaluates in the docs and converts at the first firing they did not have to babysit — the first time a binding retries, recovers, and reports without a dashboard vigil. No sales motion, no demo call, no procurement; the evaluation surface is the product surface, which is why the SDK-and-docs gate on the architecture slide is the deck's most important amber. Secondary is B2A: "when this, do that" is the native shape of an agent's intent, so a trigger is the noun an agent already thinks in — 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 event edge: fixed cost is operating the binding substrate; a declared trigger at rest holds a record, not compute, so a tenant's fleet costs the substrate almost nothing until events actually fire — and blended margin improves with density.
A binding at rest is the economic design, not just the correctness design: a declared trigger that has not fired holds a record, not a process, so the cost of a tenant's fleet tracks its firings rather than its size. Density compounds in the tenant's favor and the operator's at once — the opposite of the vigil model, where every binding pays rent in human attention whether or not it ever fires. And there is no regulatory floor anywhere in this function — nothing in routing an event to an action reserves a step for a statutory person, so the implementation mix migrates all the way to Code.
Binding counts, firing volumes, recovery-rate telemetry, and the internal-versus-external split are gated. Each figure publishes with its window and base or it does not publish.
Serving is a liveness fact, not a tenancy claim: each posted URL below evidences that one door resolves — not that anyone occupies it.
triggers.do serves — the primitive's front door is live, selling this
record's own coordinate: trigger fleets with routing, monitoring, and
recovery.
trigger.do serves — the singular zone answers with this door's own
page, behaving as the alias this record files it as.
apis.do/triggers serves machine-readable JSON — the gateway's service
record for this primitive resolves for a machine with no login, status
available.
The domain's own machine door — today answering with the gateway's own
apis.do human page, listed under also in the gateway's record — is
the next gate for the B2A leg: a primitive an agent cannot read is a
promise, and this deck declines to make it in present tense.
The grammar is built architecture in the estate's private engine, with no published package and no docs of its own. The most important amber for the B2D motion, and this deck declines to claim it in present tense.
The registry's singular-coordinate filing and the live zone disagree; this record reports both at face value and flips when the books do.
The bus beneath the binding is registry-filed at P0 and holds no zone anywhere today — the books lead the door, reported at face value.
The front door is triggers.do — it serves today.
If this was forwarded to you: triggers.do is the automation primitive of the startups.studio estate's infrastructure layer — the event side's binding surface, where the events the world emits are bound to the actions the estate runs, operated at fleet grain. It is deliberately not one of the estate's three substrate properties, and its deck says so; it is the event-side counterpart of workflows.do — that door owns the sequence after the firing, this one owns the firing itself — sold to the operator of a trigger fleet who refuses to staff a vigil around the moment of firing. What is live is posted with a URL checked cold; what is not is pending with the gate that flips it — including the six ambers it wears openly: the machine door still serving another brand's human page, the unpublished SDK and docs, the registry's singular-coordinate seam, the event-bus coordinate with no zone, the unposted rate card, and the gated firing-and-recovery telemetry. Judge it by what is posted, and by how plainly it labels what is not.