Workflows.

The feature design for automations people build, run, and trust — the screens, the states, and the rules an engineer can build against. Companion to workflows.html (why we adopt Slack's model and where it breaks) and workflow-milestones.html (what ships when).

A Workflow is up to 5 triggers, up to 100 sequential steps, and at least one checkpoint before anything external — the policy line the engine already enforces: external steps can never drop below one checkpoint unless workspace policy allows. Steps run in order, variables flow forward, and runs are journaled end to end. One execution is a run; runs pause at checkpoints and resume from the journal.

How to read this doc
  • Five themes, W1–W5. Each theme holds features (W1.1) and each feature holds stories (W1.1-S1) with acceptance criteria as checkboxes. Story IDs are the unit of work.
  • Every feature carries a phase chip. Phase 1 shipped 11 Aug · Phase 2 by 21 Aug · Phase 3 early Sep. Priority and effort chips read as in the product spec.
  • Constraints come before features. Surfaces says what each step type can actually render where; Invariants (WINV-1…10) are the lines no story may cross. Read both before any W section.
  • Two matrices audit the rest. Phase → story map proves every milestone item has a story and every story has a phase. Gap matrix proves each of the twelve Slack gaps has a named answer — or an honest Open.
  • Mockups are directional. Solid frames are visual intent; dashed frames are structure only. Example data is fictional.

The noun: this spec says Workflow

The ratified glossary in ../quiet-sky-launch/product-spec.html reads Routine — "never say: playbook · workflow." This document uses Workflow throughout and inverts that row. That is a deliberate contradiction, recorded here rather than smuggled in.

Decision · vocabulary

Adopted: Workflow is the product noun. A Routine becomes "a workflow with a schedule trigger." run, checkpoint, verified done, and test run all survive unchanged — this flips one row, not the vocabulary.

Why. Three reasons, in order of weight. (1) The engine already says workflow — the data model, the service boundary, and the milestone doc all use it, so "Routine" was a UI-only word paying rent in one place. (2) Slack translatability — an admin arriving from Workflow Builder should not have to learn a new noun for the same object; that is the whole premise of the adoption argument. (3) The milestones already shipped it — Phase 1 went to production on 11 Aug calling them Workflows, so the glossary is already behind the product.

What this costs. The glossary was ratified weeks ago; flipping it costs credibility if done quietly. The editorial sweep of product-spec.html (glossary, T4.2, T5-E2), pricing.html (Free card, Team bullet), and the Command Center prototypes is not done and is not in this spec's scope. Until it is, those documents say Routine and this one says Workflow. That is a known, dated inconsistency — tracked as WQ1, which is the only place it gets resolved.

Owner productLogged Aug 2026Resolves WQ1Blocks any public copy using either noun
Watch out: one release of dual labeling — "Workflows, formerly Routines" — is the migration, not an instant rename. Existing Routines auto-render as schedule-triggered workflows; run history, checkpoint decisions, and verified strips carry over unchanged (W3.4). If the sweep slips past the dual-labeling release, users see both nouns with no bridge.
The backlog at a glance

Feature index.

Twenty features across five themes. Phase is where it ships (from workflow-milestones.html); priority is what it's worth if the phase slips.

IDFeatureWhat it buysPriEffortPhaseDepends on
W1.1Describe → compiled planThe front door. English in, an argueable contract out.P0L1agent step
W1.2The builder canvasAdd, edit, reorder, delete — the deterministic half of authoring.P0L1W2.*
W1.3Variables that flow forwardStep 4 can use what step 1 found, visibly.P0M1W1.2
W1.4Branch · loop · waitControl flow. "For each client" becomes sayable.P1L12W1.2, W1.3
W1.5Test run — writes stubbedSee what would go out before anything goes out.P0M1W3.*
W2.1Workspace stepsMessages, forms, delivery — the in-house step set.P0L1—
W2.2Connector stepsJira, GitHub, Slack now; Google Workspace next.P0L12Vault, OAuth
W2.3Agent stepsActs where no connector exists. The G4 answer.P0L1verifier
W2.4App steps & the expansion botNew blocks and connectors land without a release.P1XL12App Builder
W3.1CheckpointsAllow once · Allow always · Deny — journaled. INV-1P0M1journal
W3.2Forms, questions & choicesThe run asks a person and waits, durably.P0L1W3.1
W3.3Failure, retry & resumeA failed step isn't a dead run. G6P0M1journal
W3.4VersioningEditing a live workflow can't orphan a run. G8P1M2database
W3.5Run history & exportEvidence that leaves the app. G7P1M12W3.4
W4.1The trigger setEight ways in, seven translated from Slack.P0L12—
W4.2Up to five triggers, one workflowNo more keeping two copies in sync. G2P1M2W4.1
W4.3Scope & filtersOne Room, several, or all. G3P1M12W4.1
W5.1Managers, publish & permissionsWho can build, find, run, copy.P1M2workspace
W5.2TemplatesA proven workflow another team can install.P2L3W5.1, Vault
W5.3Team bot & borrowed secretsTeam-scale automation without shared passwords.P2XL3Vault, W5.1
W5.4Metering & estimatesOne meter, no premium classes. G12P1M2W3.5
The constraint layer · read first

Surfaces aren't equal.

A workflow runs in one engine but asks its questions in four places, and they can't all render the same widget. The milestones name this in a footnote; here it's a design decision with rules. Every fallback in this table is a designed state, not a bug we tolerate.

Legend: Native — the real widget. Fallback — a designed degradation, always disclosed to the user (WINV-7). Unavailable — the step cannot be authored for that surface; the builder blocks it rather than failing at run time.

Interactive stepWeb / Mobile appMatrix RoomSlack P2
Checkpoint
approval gate
NativeCard with Allow once · Allow always · Deny, provenance line, expiry. NativeSame three verbs as a tappable in-room card. Also /approve <id>. FallbackPhase 1: DM'd link to the web card. Phase 2: native Block Kit buttons.
Collect info in a form
multi-field
NativeOne modal, all fields — text, number, dropdown — validated together. FallbackMulti-field forms don't render in a Matrix client. Degrades to one free-text prompt per field, asked in order, with a "3 of 4" counter and a recap before submit. FallbackPhase 1: link out. Phase 2: native modal.
Ask a question
single free-text
NativeInline prompt in the run panel. NativeA message; the reply resumes the run. FallbackPhase 1: link out. Phase 2: native.
Button choices
choice()
NativeOption buttons in the run panel; the tap picks the branch. NativeMatrix-only in v1 — a tappable card posts in the room and a tap resumes the run. UnavailableUntil Phase 2's Slack app. Authoring a Slack-delivered choice() is blocked, not silently downgraded.
Send a message NativeRun panel + notification. NativeSend to a room, reply in-thread, @-mention members. NativeAvailable in Phase 1 via authenticated Slack API calls.
Direct-message a person Native— Native— NativePhase 1, via the Slack connector.
Live step panel
watch it run
NativePer-step status, timings, tokens, cost. FallbackNo live panel in-room. Start and finish messages only, each linking to the full run. FallbackSame: two messages and a link.
Builder / authoring NativeCompile screen and canvas. Mobile is view + approve, not authoring. FallbackDescribe-in-chat authoring works in-room; the canvas doesn't. The agent posts a compiled plan and a link to edit it. UnavailableNo plan to author workflows from Slack. Trigger and respond only.
#bugs · Matrix Room form step · fallback state
mika
This room can't show a form, so I'll ask one at a time — 4 questions.
1 · Which component? auth2 · Severity? high3 · Who should own it?
Question 3 of 4
Who should own it? Reply with a name, or tap Skip.
Workflow · bug triage · run 87 · you'll see a recap before anything is submitted
The disclosure is the first line, not a tooltip. WINV-7: the user is told the surface degraded before they answer the first question — never after, and never not at all.
Watch out: the sequential-prompt fallback changes the semantics of a form, not just its skin. A web form validates all fields together and can cross-check them; four sequential prompts can't, so a rule like "severity must be high if component is auth" fires on the last answer and may force a re-ask. Forms with cross-field validation should be authored web-only until that's designed — see WQ4.
The constraint layer · non-negotiable

Invariants.

Ten lines no story may cross. A feature that needs one relaxed doesn't get shipped with an exception — the invariant gets renegotiated in public, with a dated decision. WINV-1 and WINV-2 inherit directly from the platform's INV-1 and INV-6.

IDInvariantHow it's enforced
WINV-1Nothing external happens without a checkpointAt least one checkpoint precedes the first external step — enforced at compile, not at run time. Only workspace policy can lower this floor, and only an owner can change that policy. Telemetry event unapproved_external_action should never fire.
WINV-2Every run row traces to who said goEach external action in the journal carries the checkpoint id and mode (allow_once / allow_always) that authorized it. A row without provenance is a bug, not a blank field.
WINV-3In-flight runs finish on the version they startedA run pins its workflow version at start. Publishing an edit creates a new version; running instances and pending checkpoints are untouched (W3.4). G8
WINV-4A resumed run never double-fires a side effectEvery external call writes its outcome to the journal before returning. On resume the step is skipped if its effect is recorded — the milestones' crash-safe steps, restated as a rule.
WINV-5A failed step never silently ends a runFailure escalates: retry ×2 → pause → notify the owner → wait for a human. "Run ended" is never the first thing the owner learns. G6
WINV-6A test run writes nothing externalReads execute against real systems; every write, send, and connector mutation is stubbed and shown as what would have gone out. No flag, no config, no exceptions. G1
WINV-7Surface degradation is disclosed, never silentWhen a step can't render natively (Surfaces), the fallback states plainly that it's a fallback, before the user acts. Steps marked Unavailable are blocked in the builder, not degraded at run time.
WINV-8Untrusted input can't borrow trusted accessWebhook and external payloads are clamped to a minimal tool profile. Connected-account tokens are owner-only; outbound calls cannot reach internal targets.
WINV-9Agent-step results are verified, not assertedAn agent step's success is confirmed by the independent verifier with expandable evidence, or reported as failed. "Done" without evidence is not a state this feature can produce. G10
WINV-10No step type changes a workflow's billing classEvery step type is available on every paid tier. Adding a connector or agent step meters more runs against the pool and says so in the estimate before the run — it never reclassifies the workflow. G12
mika · DM needs you
mika
6 drafts are ready for this week's client updates. Nothing sends until you approve. 1
Checkpoint 2
Send 6 update emails to client contacts via Gmail?
Workflow · monday client report · v4 · run 142 · waiting 4 min 3
1WINV-1 made visible. The promise is stated before the ask, in the agent's own words. The user should never have to infer that nothing has happened yet.
2Three verbs, always the same three. Allow once · Allow always · Deny. "Allow always" carries a scope — this connector, this workflow — shown on tap, never assumed to mean everything.
3WINV-2 and WINV-3 in one line. The version the run is pinned to, the run number, and the wait time. Editing the workflow now would not change this card.
Theme W1 · Priority P0–P1 · Phase 1–2

Authoring.

Slack bolted AI generation onto a form-first builder. We invert it: English is the front door and the compiled plan is the contract — but the canvas is a first-class citizen, not a fallback, because the plan has to be argueable step by step. The milestones call these two doors full agent and flow builder; they are one feature with two entrances.

describe in English→ compiled plan · the contract→ edit on the canvas→ test run · sends stubbed→ publish

Every arrow is reversible. You can arrive at the canvas without describing anything, and you can go back to English after editing — the plan and the canvas are two views of one step list, not two authoring modes with a one-way door between them.

FEATURE W1.1

Describe it; get a plan you can argue with

P0Effort LPhase 1Agent + compiler exist
Benefit. The distance from "I wish this happened every Monday" to a runnable automation is one sentence and one read-through. For the business: this is the feature that makes automation a chat product rather than a builder product — and the reason a non-technical user finishes what they start.
Depends agent step (W2.3) · CAPS catalogBlocks W1.5 test runInstrument workflow_compiled · workflow_plan_edited · workflow_published

Problem. A form-first builder asks the user to know the step vocabulary before they can express the intent. Most people can describe the outcome and cannot name the steps — so they either give up at the empty canvas or build something wrong and only find out at run time.

Starting point: the agent already plans multi-step work and the engine already compiles a step list to a runnable script. What's missing is showing the plan as a reviewable contract — with checkpoints already placed — before the first run.

The compile contract

Compilation is deterministic in one respect that matters: checkpoint placement is a separate pass, not a suggestion from the model. The compiler walks the generated steps, finds the first one flagged external, and inserts a checkpoint before it. The plan the user reads has already satisfied WINV-1; they are approving the shape of the work, not remembering to add a safety gate.

// compile(text) → plan, then a separate checkpoint pass plan = { steps: [ { id, capId, label, config, parentId, branchKey } ], triggers: [ { capId, config } ], vars: [ { name, producedBy, readBy[] } ], // drives W1.3's pills inserted: [ "chk_auto_1" ] // what the compiler added, called out in the UI } // the floor, in code — this is WINV-1 insertCheckpoints(steps, policy): if !policy.requireCheckpoint: return steps // "unless workspace policy allows" before the first step where CAPS[capId].external and no checkpoint covers it, splice an auto checkpoint. A manual approval step already satisfies the floor.
Whether the floor is one checkpoint per workflow (as written) or one per external step is WQ2 — a one-line change, deliberately not decided in code.

Stories

W1.1-S1Describe → compiled plan preview
  • One free-text field with three worked examples; no required fields, no step picker, no connector picker
  • Returns a numbered step list within 10s p95, each step showing its category tag (Workspace · Connector · Agent · App) and the connector it will use
  • Auto-inserted checkpoints are visually distinct and labelled "added — nothing external runs before this"
  • Anything the compiler couldn't resolve appears as a named gap ("which Jira project?"), not a guess
  • Steps requiring a capability above the workspace's current phase render locked, with what unlocks them and when
W1.1-S2Argue with the plan
  • Refine by replying in English ("skip clients with nothing shipped") — recompiles, and diffs against the previous plan rather than replacing it silently
  • "Edit steps" opens the same plan on the canvas (W1.2) with no data loss in either direction
  • Removing the auto checkpoint is refused with the reason and who can change it, not greyed out without explanation
  • The plan is a draft — private, unpublished, not schedulable, and clearly marked so
W1.1-S3Author from a Room
  • Describing a workflow to the agent in a Matrix Room produces the same compiled plan, posted in-room as a message
  • The in-room plan carries a link to the canvas; per Surfaces the canvas itself is not rendered in-room
  • Publishing from chat requires the same test-run prompt as the web path — the surface changes, the gate doesn't
W1.1-S4Full-agent mode
  • A one-line goal can be saved without compiling to fixed steps — the agent decides the path at run time (the milestones' authoring Mode 1)
  • Even undecided, the external boundary is fixed at authoring time: the user names which connectors are in scope and the checkpoint still precedes any external act
  • The run view shows the path the agent actually took, so an agent-mode run is auditable after the fact even though it wasn't planned before

Mockup — the compiled plan

New Workflow draft — not yet published
Schedule Mondays 8:00 Asked in chat "run the client report" + add trigger
Every Monday, pull last week's Jira activity per client, draft an update email for each, and send after I approve.
mika
Here's the plan — 5 steps, one checkpoint:
1 · Pull last week's activity — 6 projects · Jira 2 · Summarize per client · Agent step 3 · Draft 6 updates · Gmail 4 · Send to each contact · checkpoint — added, needs you 5 · File replies, close the run
One thing I guessed: "last week" means the previous Mon–Sun. Say so if you meant rolling 7 days.
Before it runs
Test run first? External sends are stubbed — you'll see exactly what would go out.
Two triggers on one workflow (W4.2) — Slack would need two workflows kept in sync by hand. Step 4 says added: the compiler placed it, and the plan says so rather than pretending the user asked for it.
FEATURE W1.2

The canvas — a Slack admin's muscle memory

P0Effort LPhase 1Blocks catalog exists
Benefit. Deterministic authoring for people who know exactly what they want, and the review surface for everyone else. For the business: an admin migrating from Workflow Builder recognises this screen in three seconds, which is the entire translatability argument made concrete.
Depends W2.* step catalogBlocks W1.3, W1.4Instrument step_added{cap} · step_reordered · step_deleted

Problem. An English plan is a good start and a bad end state. Editing step 3's Jira project by describing it again is worse than clicking it, and reviewing a 20-step workflow as prose is worse than reading a list.

Starting point: Phase 1 already ships add / edit / reorder over typed blocks. This feature is the presentation contract on top: step cards that carry category, variables, and phase state.

Step card anatomy — the one component this whole theme rests on

monday client report the Builder · canvas view
1
Pull last week's activity · Jiraoutputs {{projects}} · 6 found
Connector
2
Summarize per client for each clientreads {{projects}} · writes {{client.summary}}
Agent
3
Branch · anything shipped this week?two paths · else: skip the client, stay quiet
Workspace
3a
Draft update email · Gmailuses {{client.summary}} · {{client.contact}}
Connector
4
Checkpoint — send 6 emailsneeds a person · journaled · survives restart & edits
Checkpoint
5
File replies, close the runverified by the maker/checker
Workspace
Slack's canvas with three additions: a loop badge, an agent step, and a checkpoint that survives a restart. Everything else — variables, branches, numbered cards — reads exactly as a Slack admin expects.
1Number, then title, then the data contract. Every card's second line says what it reads and what it writes. This is how a 20-step workflow stays legible without a graph view.
2Category tag, right-aligned, always present. Four values only (W2). The tag is how a user learns which steps cost connector access and which cost agent budget.
3Nesting is one level and indent-only. 3a under 3. No canvas, no arrows, no minimap — the flat-list-with-indent choice is deliberate and is the honest half of the G11 answer.

Stories

W1.2-S1Assemble from the palette
  • Palette groups steps by the four categories; each entry states its phase and whether it's external
  • Adding a step inserts it after the selection, or at the end if nothing is selected — never at the top by surprise
  • Steps above the workspace's phase are visible but locked, showing what unlocks them; they cannot be added or published
  • Adding an external step to a workflow with no checkpoint inserts one automatically and says it did
W1.2-S2Edit a step in place
  • Each step type has a typed config form — no free-text JSON for first-party steps
  • Connector steps show which connected account will be used and whose token it is (owner-only per WINV-8)
  • Invalid config is blocked at the step, with the reason on the card; a workflow with an invalid step can be saved as a draft but not published
W1.2-S3Reorder and delete
  • Move up / move down and delete on every card; renumbering is immediate
  • Moving a step above the checkpoint that guards it moves the checkpoint too, or refuses — the floor cannot be defeated by reordering
  • Deleting a step that produces a variable read downstream warns and names the readers before confirming
  • The 100-step cap is enforced with a count visible from step 80 onward
W1.2-S4Draft, save, publish
  • Drafts are private to the author until published (W5.1)
  • Publishing requires: at least one trigger, no invalid steps, no locked steps, and the checkpoint floor satisfied
  • Publishing an already-live workflow creates a version rather than mutating it (W3.4)
FEATURE W1.3

Variables that flow forward, visibly

P0Effort MPhase 1Engine passes values already
Benefit. The difference between a workflow that works and one the user can debug. Seeing {{client.summary}} on the card that writes it and the card that reads it makes data flow checkable without a run.
Depends W1.2Blocks W1.4 loop scopingInstrument var_referenced · var_unresolved

Problem. Invisible data flow is where automations break silently. A step reads a value that a reordered predecessor no longer produces, and nobody finds out until a run posts an empty message to a client.

Stories

W1.3-S1Pills, not strings
  • {{name}} references render as pills on the card; hovering names the producing step
  • Inserting a variable is a picker over what's actually in scope at that position — not a free-text guess
  • Trigger payload fields are variables like any other ({{message.text}}, {{issue.key}})
W1.3-S2Unresolvable references are caught before publish
  • A reference with no producer above it marks the step invalid and names the missing variable
  • Reordering that breaks a reference reports it immediately, on both cards involved
  • A run that hits an unexpectedly empty variable pauses at that step rather than sending an empty result — a defensive floor, not a substitute for the authoring check
W1.3-S3Loop scope is explicit
  • Inside a loop, the item variable is namespaced ({{client.*}}) and only resolvable within the loop body
  • Referencing a loop-scoped variable after the loop is an authoring error with a suggested fix (collect into a list)
FEATURE W1.4

Branch, loop, wait — the control flow Slack lacks

P1Effort LPhase 1 branchPhase 2 loop · waitLoop replay is new build
Benefit. "For each client…" becomes sayable, and "wait until they reply" stops meaning "poll every 5 minutes." For the business: two of the three most-cited Workflow Builder complaints, answered by name. G5 G9
Depends W1.3 variable scoping · journal replayBlocks the Monday-report scenario at Phase 1Instrument loop_iterated{count} · wait_resumed{cause}

Problem. Without loops, a workflow serving six clients is the same five steps pasted six times, and adding a seventh client is an edit in six places. Without a wait-until-condition, "chase the ones who haven't replied by Thursday" isn't expressible at all.

Starting point: branch ships in Phase 1. The journal supports durable waits — that's what makes checkpoints survive restarts. Loop is the genuinely new engineering: deterministic replay over a list that may have changed since the run started is not a rename of anything.

Stories

W1.4-S1Branch — pick a path
  • Conditions over variables and trigger payload; each path is an indented step group under the branch card
  • An explicit else path, and "else: do nothing" is a first-class choice that produces a went quiet run rather than a failure
  • One level of nesting in the UI; a branch inside a branch is refused with the reason (see G11)
W1.4-S2Loop over a list
  • Any list-valued variable can be looped; the card states the item variable and the iteration count found at run time
  • The list is snapshotted at loop entry — items added mid-run are not picked up, and the run log says how many were pinned
  • A per-item failure doesn't kill the loop: the item is marked failed, the loop continues, and the run ends completed with 1 of 6 failed
  • A checkpoint inside a loop asks once for the batch by default, with per-item as an explicit opt-in — six approval cards for six clients is a bug, not thoroughness
  • Loops don't nest, and the iteration cap is enforced against the 100-step budget
W1.4-S3Wait — minutes to months, or until a condition
  • Wait for a duration, until a timestamp, or until a condition becomes true (a reply lands, an issue closes)
  • Condition waits carry a required timeout and a designed expiry path — never an indefinite park
  • A waiting run survives a restart and doesn't consume agent budget while parked; the run row reads waiting, not running
  • Waits are visible in run history with what they're waiting for, so a stuck workflow is diagnosable without logs
Watch out: loop + checkpoint is the sharpest interaction in this spec. Batch-approve is the right default and it means one Allow once authorizes six external sends — so the card must say six, list what they are, and the journal must record all six against that one checkpoint id (WINV-2). Get this wrong and "checkpoint before anything external" becomes technically true and practically hollow.
FEATURE W1.5

Test run — writes stubbed, reads real

P0Effort MPhase 1Ships in Phase 1
Benefit. The only way to test a Slack workflow is to run it live against real channels. Here you see exactly what would have gone out, to whom, before anything does. For the business: this is what makes publishing feel safe, which is what makes people publish. G1
Depends W1.1, W3.* runtimeBlocks publish confidenceInstrument workflow_test_run{outcome}

Problem. Testing by running is how automations post to real channels during development. The fix isn't a sandbox workspace nobody maintains — it's a run mode where reads are real and writes are shown, not sent.

Stories

W1.5-S1Run it with the sends stubbed
  • Reads execute against real systems, so the data is real; every write, send, and connector mutation is stubbed (WINV-6)
  • Each stubbed step shows the exact payload that would have gone out — recipients, subject, body, API call
  • Test-run banner is present on every screen of the run and in any message the run produces
  • Test runs appear in history marked test, and are excluded from the run meter
W1.5-S2Test one step, not the whole thing
  • Any step can be run alone with its inputs supplied by hand or taken from the last run
  • Useful specifically for connector auth and API-call config, where the failure is usually in step 1 of 12
W1.5-S3Interactive steps in a test run
  • Checkpoints, forms, and choices render for real in a test run — the point is to see the card you'll get
  • A decision made in a test run authorizes nothing; Allow always is offered but scoped to the test and says so
Theme W2 · Priority P0–P1 · Phase 1–2

Steps.

Four categories, and the fourth is the one Slack can't build. Slack's step set is three: Slack steps, connector steps, custom steps needing a developer and a CLI deploy. Ours adds agent steps — a sub-goal with tools, a budget, and success checks — which is how we live honestly with having a fraction of Slack's connector count.

CategorySlack's equivalentWhat's in itPhase
Workspace stepsSlack stepsSend a message · DM a person · reply in-thread · collect info in a form · ask a question · button choices · approval gate · set variables · branch · wait · loop12
Connector stepsConnector stepsActions on a connected account. Phase 1: Jira, GitHub, Slack. Phase 2: Google Workspace, then rolling.12
Agent steps"Generate AI Response" — text onlyA sub-goal with tools, a budget, and success checks, verified by the maker/checker.1
App stepsCustom steps Deno SDK + CLI deployA Skill described in chat and built by App Builder. No SDK, no deploy, no paid gate.12
FEATURE W2.1

Workspace steps — the in-house set

P0Effort LPhase 1Shipped 11 Aug
Benefit. Everything a workflow does that doesn't need someone else's API. Message delivery is the payoff step of most workflows — the automation is only useful when its result lands where people are.
Depends Rooms · Matrix deliveryBlocks every scenarioInstrument step_ran{cap, surface, ms}

Problem. An automation that finishes in a log nobody reads hasn't finished. Delivery — to a room, a thread, a person, with @-mentions that actually notify — is a first-class step, not an afterthought bolted onto the end.

Stories

W2.1-S1Messages & delivery
  • Send to a named room, reply into the triggering room, reply in-thread to the triggering message, or DM a person
  • @-mentions in delivered messages resolve and notify; an unresolvable mention is an authoring error, not silent plain text
  • Message bodies interpolate variables with the W1.3 picker; an empty required variable pauses instead of sending a hollow message
W2.1-S2Set variables & shape data
  • A step that computes or reshapes values without calling anything external — the glue that keeps API-call steps from needing custom code
  • Never external, so it never triggers the checkpoint floor
W2.1-S3Call an API
  • Full HTTP: method, URL, headers, body, with variable interpolation throughout
  • Attaching a connected account injects its token automatically — the user never pastes a credential into a step (W2.2)
  • Outbound calls cannot reach internal targets (WINV-8); a blocked target names the rule, not a generic network error
  • Any non-GET call is treated as external and forces the checkpoint floor
FEATURE W2.2

Connector steps — honest about the count

P0Effort LPhase 1 · Jira · GitHub · SlackPhase 2 · Google Workspace
Benefit. The tools teams already live in, reachable from a workflow with a token nobody had to copy. For the business: connector count is our weakest number against both Slack and Zapier, so the strategy is depth on a few plus agent steps for the rest — stated, not hidden. G4
Depends OAuth · VaultBlocks the Monday-report scenario (needs Gmail, Phase 2)Instrument connector_connected · connector_step_ran{vendor, ok}

Problem. Slack ships ~70+ connectors and Zapier thousands; Phase 1 ships three. Pretending otherwise loses the room in the first demo question. The answer is to be precise about which three are wired end-to-end (trigger events and authenticated calls), and to make the agent step the honest bridge for everything else.

Starting point: Jira and GitHub are wired both ways in Phase 1 — events in, authenticated API calls out. Slack is calls-out only. That asymmetry is real and shows in the trigger picker (W4.1).

Stories

W2.2-S1Connect an account once, use it anywhere
  • OAuth per connector, per user; the token lives in the Vault, masked, and is injected into steps at run time
  • Connected-account access is owner-only — an untrusted run can't borrow it (WINV-8)
  • A revoked or expired token surfaces on the workflow before its next scheduled run, not as a failed run at 8:00
W2.2-S2The catalog says what each connector can actually do
  • Every connector lists its available actions and whether it emits trigger events — no connector appears in the trigger picker unless it does
  • Actions that write are flagged external and force the checkpoint floor
  • A connector above the current phase is visible and locked with its target phase, never absent
W2.2-S3When there's no connector
  • The palette offers the agent step as the named alternative, with what it can and can't guarantee
  • Requesting a connector logs it and feeds the expansion bot's queue (W2.4); the user is told where the request went
Watch out: "13 connectors" appears in workflows.html; Phase 1 ships three, Phase 2 adds Google Workspace and more. Both numbers are true at different dates and neither is safe in public copy without one. Any external claim cites a phase.
FEATURE W2.3

Agent steps — the category Slack can't ship

P0Effort LPhase 1Agent + verifier exist
Benefit. Slack's AI step writes text. Ours acts — in systems with no connector, watching for replies, syncing both ways — and the verifier confirms the result with evidence. For the business: this is the answer to the connector-count question and the only step type a competitor can't copy without our agent. G4 G10
Depends agent runtime · verifier · budgetBlocks W1.1 compile qualityInstrument agent_step_ran{verified, budget_used}

Problem. Two problems at once. Deterministic steps can't handle the long tail of tools, and a text-generation step can't do anything about it. An agent step closes both — at the cost of being the one step whose runtime and spend are genuinely variable.

Stories

W2.3-S1Hand the agent a sub-goal
  • The step declares an outcome, the tools and connectors in scope, a budget, and success checks — not a prompt alone
  • Tool scope is a hard boundary: an agent step cannot reach a connector the step didn't declare
  • Outputs are named variables usable downstream like any other step's (W1.3)
W2.3-S2Verified, or failed — never asserted
  • The independent verifier checks the success criteria and attaches expandable evidence (WINV-9)
  • A failed check reports what failed and routes to W3.3's escalation — never a silent retry, never a "done" with no evidence
  • The run view shows the path the agent took: tools called, in order, with results
W2.3-S3Budget and estimate before the run
  • Every agent step carries a budget ceiling; exceeding it pauses the run and asks, rather than spending on
  • The workflow's pre-run estimate includes agent-step variance as a range, not a point (W5.4)
  • Actual spend per agent step appears in run history next to the estimate — so the estimate is checkable, which is the only thing that keeps it honest
Watch out: agent steps make run cost genuinely variable, and the anti-premium-surprise promise (WINV-10) lives or dies on estimate quality. If estimates are consistently wrong we have shipped Slack's billing surprise with better copy. Estimate-vs-actual is a launch metric, not a nice-to-have.
FEATURE W2.4

App steps and the expansion bot

P1Effort XLPhase 1 seedPhase 2 rampCatalog growth is the mechanism
Benefit. The step catalog and the connector list grow without a release. Slack's custom step needs a developer, the Deno SDK, and a CLI deploy; ours needs a description in chat. For the business: this is how a three-connector launch becomes credible — the number moves weekly and visibly.
Depends App Builder · SkillsBlocks the long tail of W2.2Instrument app_step_created · catalog_item_added{kind}

Problem. Every automation product eventually meets a step nobody built. Slack's answer requires a developer. Ours has to be reachable by the same person who described the workflow in the first place, or the escape hatch only helps the people who didn't need it.

Starting point: the milestones commit an always-on expansion bot in all three phases — Phase 1 seeds the catalog past the launch set, Phase 2 ramps, Phase 3 lands team-governed items. The mechanism exists; this feature is the surface that makes its output legible.

Stories

W2.4-S1Describe a Skill, get a step
  • An App step is authored by describing it in chat; App Builder produces it and it appears in the palette as a normal step card
  • App steps declare whether they're external, and are subject to the same checkpoint floor as any other step
  • No paid gate on authoring App steps (WINV-10)
W2.4-S2The catalog is visibly alive
  • New blocks and connectors land on a rolling basis and are dated in the palette — "added this week" is a real filter
  • Connector requests from W2.2-S3 are visible in a queue with status, so asking doesn't feel like shouting into a form
Theme W3 · Priority P0–P1 · Phase 1–2

Runtime & trust.

Where the engine stops being an implementation detail and becomes the pitch. The runtime is durable and journaled — closer to Temporal than to an agent loop. Slack's run ends when a step fails, orphans in-flight runs when you edit the workflow, and keeps its logs inside the app. Three of the twelve gaps live here and all three fall to properties the engine already has.

FEATURE W3.1

Checkpoints — the translated Button, with a guarantee

P0Effort MPhase 1approval() ships in Phase 1
Benefit. The pause that makes automation safe to publish. Same shape as Slack's Button, different guarantee: the decision is journaled, so it survives a restart, survives an edit to the workflow, and expiry escalates to the owner instead of silently vanishing. For the business: this single card is the aha moment of the whole product.
Depends journalBlocks W3.2, W1.1 compile passInstrument approval_actioned{verb, source, ms_waited}

Problem. Trust in automation is not built by accuracy claims; it's built by a reliable pause. And a pause is only reliable if it can't be lost — by a deploy, by an edit, or by an expiry that quietly gives up.

Starting point: approval(), the journal, and the three house verbs all ship in Phase 1. This feature is the interaction contract on top — scope semantics for Allow always, expiry escalation, and the provenance line.

Stories

W3.1-S1Three verbs, one meaning each
  • Allow once authorizes this step in this run, nothing more
  • Allow always requires a visible scope before it applies — this connector, this workflow, this recipient set — and never means "everything, forever"
  • Deny stops the run cleanly at that step; prior steps' effects stand and are listed, because a clean stop is not a rollback
  • Every decision is journaled with who, when, from which surface, and via which mode
W3.1-S2The card carries its provenance
  • Workflow name, version, run number, and wait duration on every checkpoint card (WINV-2, WINV-3)
  • What exactly will happen — "send 6 emails to client contacts via Gmail" — with the payload expandable, not summarized away
  • Restrict-to-people: the author names who may decide; others see the card as read-only with who it's waiting on
W3.1-S3Expiry escalates; it doesn't vanish
  • Every checkpoint has an expiry; on expiry the run escalates to the workflow owner rather than failing or silently proceeding
  • An escalated checkpoint is still decidable — the run stays parked, and the history row says it was escalated
  • A checkpoint survives publishing an edit to its workflow: the pending decision belongs to the version it started on
W3.1-S4Decide from anywhere
  • Native on web, mobile, and in a Matrix Room; /approve <id> as the keyboard path
  • Phase 1 Slack: the card is a DM'd link to the web decision. Phase 2: native (Surfaces)
  • A decision made on any surface is the same journal entry — the surface is recorded, not privileged
FEATURE W3.2

Forms, questions & choices — the run asks and waits

P0Effort LPhase 1Durable wait-resume ships
Benefit. A workflow can involve a person mid-flight without becoming a form-filling chore or losing its place. For the business: human-in-the-loop is what lets automation into processes people won't fully hand over — which is most of the valuable ones.
Depends W3.1 · durable wait-resume · SurfacesBlocks the bug-triage scenarioInstrument prompt_shown{kind, surface} · prompt_answered{ms}

Problem. Asking a person mid-run means parking indefinitely, and the surfaces can't all render the same widget. A form is a modal on web and impossible in a Matrix client — so either the step is web-only, or the degradation is designed. We designed it.

Stories

W3.2-S1Collect info in a form
  • Text, number, and dropdown fields with required/optional, validated together on web and mobile
  • In a Matrix Room the step degrades to one prompt per field, in order, with an "n of m" counter and a recap before submit — disclosed up front (WINV-7)
  • Answers become named variables (W1.3)
  • Forms with cross-field validation are authorable web-only until the sequential path handles them (WQ4)
W3.2-S2Ask a question · button choices
  • A single free-text question renders natively everywhere except Slack in Phase 1
  • choice() posts a tappable card; the tap both answers and picks the branch (Matrix-native in v1)
  • Choices are blocked at authoring time for surfaces that can't render them — never degraded at run time
W3.2-S3Parked runs are safe and legible
  • A run waiting on a person survives a restart and resumes at exactly that step (WINV-4)
  • Parked runs read waiting on @maya in history, with what's being asked and for how long
  • Every prompt has a timeout with a designed path — reprompt, escalate, or end as went quiet; never an indefinite park
FEATURE W3.3

Failure isn't fatal

P0Effort MPhase 1Crash-safe steps ship
Benefit. The failure Slack shows you as a dead run is a recovered one here — and the owner heard about it without asking. For the business: Run 139 is the sales pitch. A Gmail timeout at 8:05 that finished at 8:41 without anyone watching is the demo that closes an ops buyer. G6
Depends journal · side-effect recordingBlocks unattended scheduling credibilityInstrument step_failed{cap, cause} · step_retried{n} · run_resumed{source} · owner_notified

Problem. In Slack a failed step ends the run: no retries, no resume, thin notifications. For anything scheduled and unattended that's disqualifying — the first transient API timeout means a silently missing client report.

Starting point: the engine records side effects before returning, so a resumed run never double-fires. Retry and resume are policy over an existing journal, not new durability work.

The escalation ladder

step fails→ retry ×2 · backoff→ pause · notify the owner→ human resumes→ resume from the journal

Stories

W3.3-S1Retry, then stop guessing
  • Transient failures retry twice with backoff; the retry count is visible on the step while it happens
  • Failures that won't improve on retry (auth revoked, 4xx, blocked target) skip straight to escalation instead of burning two attempts
  • A retried step never repeats a recorded side effect (WINV-4)
W3.3-S2Pause and tell the owner
  • After retries the run parks and DMs the owner with the step, the cause, and what happens next — the owner never learns from a missing result (WINV-5)
  • The notification carries the actions: Resume, Skip this step, End the run
  • A parked-on-failure run holds its place indefinitely without consuming budget
W3.3-S3Resume from the journal
  • Resume restarts at the failed step with the run's original variables and pinned version (WINV-3)
  • Completed steps are not re-run; the run log shows the gap and what filled it
  • The history row states the whole arc in one line: failed at step 3 · retried ×2 · resumed from journal · owner notified · finished 8:41
W3.3-S4Going quiet is a success, not a failure
  • A workflow whose branch conditions produce no work ends as went quiet — a distinct, non-alarming state
  • No drafts, no digest, no noise; the history row says why nothing happened

Mockup — the four run states in one list

Workflow · monday client report run history · v4
Run 142 — 6 sent, verifiedcheckpoint: approved by @maya · 8:31 · evidence attached
Mon 8:24
Run 141 — 6 sent, verifiedcheckpoint: approved by @maya · 8:12
Mon 8:09
Run 140 — went quietnothing shipped that week — no drafts, no digest, no noise
Mon 8:02
Run 139 — failed at step 3, recoveredGmail timeout · retried ×2 · resumed from journal · owner notified · finished 8:41
Mon 8:05
Export log · CSVevery run carries the workflow version it ran on
Four states, four dots: verified, verified, went quiet, recovered. Nothing in this list is a dead run — which is the claim the whole theme exists to support.
FEATURE W3.4

Edits don't orphan runs

P1Effort MPhase 2Needs the database move
Benefit. Editing a published workflow stops being destructive. In Slack, an edit can orphan in-flight runs and pending buttons; here a run finishes on the version it started on. For the business: this is what makes a workflow safe to iterate on while people depend on it. G8
Depends Phase 2 database moveBlocks W3.5 export, W5.2 templatesInstrument workflow_version_published · run_pinned_version

Problem. Without versioning, publish is a mutation. Anyone with a long-running or parked workflow is choosing between improving it and not breaking what's running — so they stop improving it.

Starting point: the journal already records what a run did step by step. Versioning is giving that record a version key and pinning it, which is why it waits for the Phase 2 database move rather than shipping on the current storage.

Stories

W3.4-S1Publish creates a version
  • Each publish increments a version; the version is shown in the builder, on run rows, and on checkpoint cards
  • Version history lists what changed between versions, by whom and when
W3.4-S2In-flight runs are untouched
  • A run pins its version at start and finishes on it, including after a resume days later (WINV-3)
  • Pending checkpoints and parked prompts survive an edit; their cards keep their original text
  • The builder says how many runs are currently on older versions before you publish
W3.4-S3Unpublish and roll back
  • Unpublishing stops new runs and leaves in-flight ones alone
  • Rolling back republishes an earlier version as a new version — history is append-only, never rewritten
FEATURE W3.5

History is evidence, and it leaves the app

P1Effort MPhase 1 viewPhase 2 export
Benefit. Per-run status, checkpoint decisions, and verified strips — exportable, because audits happen outside the app and debugging happens in a spreadsheet. For the business: audit export is a Command-tier line item and a procurement checkbox. G7
Depends W3.4 versions · journalBlocks W5.4 metering credibilityInstrument run_history_opened · run_log_exported{format}

Problem. Slack's activity is viewable in-app only. That fails two different people: the auditor who needs records outside the tool, and the builder debugging why Thursday's run went quiet.

Stories

W3.5-S1The run list
  • Every run with its number, outcome, version, trigger that started it, duration, and cost
  • Outcomes are the designed set: verified · went quiet · recovered · waiting · denied · failed · test
  • Filterable by outcome and version; a failed-then-recovered run reads as recovered, not failed
W3.5-S2The run detail
  • Step-by-step timeline with per-step status, timings, tokens, and cost (the milestones' telemetry, surfaced)
  • Checkpoint decisions inline: who decided, which verb, from which surface, how long it waited
  • Agent-step evidence expandable in place (WINV-9)
  • The verified strip at the end — "6 sent, verified — every send confirmed with evidence"
W3.5-S3Export
  • CSV export of the run list and of a single run's steps, including the version each ran on
  • Export includes checkpoint provenance — an export without who-said-go is not an audit record (WINV-2)
  • Export is available to workflow managers and workspace owners; the export itself is an audited action
Run 142 completed · v4
1
Pull last week's activity · Jira1.2s · 6 projects · 0 tokens
OK
2
Summarize per client · Agent18.4s · 6 iterations · 24k tokens · $0.31 · verified
OK
3
Checkpoint — send 6 emailsallow once · @maya · web · waited 6m 41s
Approved
4
Send to each contact · Gmail3.1s · 6 sent · authorized by chk_204
OK
6 sent, verified — every send confirmed with evidence · total $0.34 · 41s of work across 7m 12s
Export this run · CSVauthorized by chk_204 · allow_once
Cost sits next to the step that spent it, and every external send names the checkpoint that authorized it. The verified strip is the answer to "did it actually happen" — and WINV-2 is the answer to "who let it."
Theme W4 · Priority P0–P1 · Phase 1–2

Triggers.

Eight ways in — seven are Slack's, translated, and one is ours alone. Two of Slack's twelve gaps are trigger-shaped: one trigger per workflow, and channel-scoped triggers that bind to a single channel. Both are addressed by treating triggers as a list attached to a workflow rather than a property of it.

FEATURE W4.1

The trigger set

P0Effort LPhase 1 · fivePhase 2 · webhook · AIC
Benefit. A workflow is only as useful as its ways in. Schedule absorbs Routines entirely; "when asked in chat" is the conversational door Slack doesn't have. For the business: the trigger list is the first thing a migrating Slack admin scans for parity.
Depends Rooms · connector events (W2.2)Blocks W4.2, W4.3Instrument trigger_fired{kind} · workflow_scheduled

Problem. Slack has seven triggers and no conversational one. We need parity for translatability plus the one that only makes sense if you have an agent — and we need to be precise about which of ours actually exist in Phase 1.

TriggerSlack ancestorWhat's differentPhase
On a scheduleOn a scheduleAbsorbs Routines entirely. Interval or cron; expressible in plain language — "every Monday 8:00."1
When a message is postedMessage posted (keyword)Filters on keyword, mention-only, room, owner-only. Phase 1 is one room; several or all is W4.3. G31
From a link or buttonFrom a linkAn authenticated deep link that works in Rooms, DMs, and the Command Center — not bound to one channel. G31
When a Connector event firesList updated + connector triggersAbsorbs both Slack concepts. Phase 1: Jira and GitHub only (issue / PR / comment / status) — Slack is calls-out only.1
Manual—Run on demand from the Workflows tab. The trigger you use while building.1
When asked in chatnone — ours alone@agent "run the client report now." Needs a metering rule: when is a request a run and when is it conversation? (WQ3)2
From a webhookFrom a webhookInbound payloads are auto-clamped to a minimal tool profile before touching anything (WINV-8).2
When an AIC message lands—An assistant message as a signal inside a flow — chains agent conversations into automation.2
When a person joinsPerson joins channelNot specified here. Named in workflows.html, absent from all three milestone phases. Needs a phase before it's public.—
When a reaction is usedEmoji reactionNot specified here. Presumes Rooms ship emoji reactions — unconfirmed. See WQ6.—

Eight specified, two struck. The two struck rows are the honest half of this table: workflows.html promises eight triggers including join and reaction; the milestones fund neither. They stay visible and struck rather than quietly dropped, because a trigger table is exactly the artifact someone will screenshot.

Stories

W4.1-S1Attach a trigger, configure it typed
  • Each trigger type has a typed config — cron for schedule, filters for message, event list for connector
  • Trigger payload fields become variables usable from step 1 (W1.3)
  • Triggers above the current phase appear locked with their target phase, never hidden
  • A connector with no event support doesn't appear in the connector-event picker at all
W4.1-S2Schedule in plain language
  • "Every Monday 8:00" and a cron expression are two views of one config; both display the next three fire times in the workspace timezone
  • A schedule on a workflow with a broken connector is flagged before its next fire, not after (W2.2-S1)
W4.1-S3Shareable links
  • An authenticated deep link others can run, subject to the workflow's run permissions (W5.1)
  • Link runs record who ran it; the link can be revoked without touching the workflow
FEATURE W4.2

Up to five triggers on one workflow

P1Effort MPhase 2Authoring layer is new
Benefit. The Monday report runs on its schedule, on demand from chat, and from a webhook — without existing three times. In Slack the same five steps behind a schedule and a button is two workflows kept in sync by hand, forever. G2
Depends W4.1Blocks —Instrument trigger_attached{kind, count} · trigger_fired{kind}

Problem. One trigger per workflow forces duplication, and duplication drifts. The second copy gets a fix the first doesn't, and nobody notices until the two produce different results.

Starting point: the journal doesn't care what started a run — it records the cause either way. Multi-trigger is an authoring and dispatch concern, not a runtime one. It is, however, genuinely unproven in the authoring layer, which is why it sits in Phase 2 rather than being claimed as shipped.

Stories

W4.2-S1Attach up to five
  • Triggers are a list on the workflow; the sixth is refused with the cap stated, not silently dropped
  • Each trigger can be enabled or disabled independently without unpublishing the workflow
  • Mixed types on one workflow are normal — schedule plus chat plus webhook is the intended case
W4.2-S2Runs know what started them
  • Every run records its triggering cause and payload; history is filterable by trigger
  • Steps can branch on the trigger — "if this was manual, skip the digest"
  • A trigger payload field that only some triggers provide is an authoring warning, with which triggers lack it
W4.2-S3Concurrency is a choice, not a surprise
  • Per-workflow concurrency policy: run in parallel, queue, or skip if already running
  • Default is queue — two triggers firing within seconds shouldn't double-send
  • Skipped runs appear in history as skipped with the reason, so the absence is explained
FEATURE W4.3

Scope & filters — one Room, several, or all

P1Effort MPhase 1 · one roomPhase 2 · several or all
Benefit. Ten channels stops meaning ten copies of the same workflow. For the business: this is the gap that makes Workflow Builder unusable at scale for support and triage teams — precisely the teams who automate most. G3
Depends W4.1 · Rooms permissionsBlocks triage at team scaleInstrument trigger_scope_set{n_rooms} · trigger_filtered{reason}

Problem. A channel-scoped trigger binds to one channel. A team watching ten rooms for the same keyword maintains ten workflows, and the eleventh room silently isn't covered.

Stories

W4.3-S1Scope a trigger to a set
  • One room, an explicit list, or the whole workspace; the card states which and how many
  • Workspace-wide scope requires the author to hold visibility in those rooms — scope can't be used to read rooms you can't see
  • Rooms created after the workflow are included only for workspace-wide scope, and the card says so
W4.3-S2Filters that prevent noise
  • Keyword, mention-only, owner-only, and author filters on the message trigger
  • Filtered-out events are counted but not run; the count is visible so a silent workflow is diagnosable
  • A workflow triggering itself is detected and refused, not left to loop
Theme W5 · Priority P1–P2 · Phase 2–3

Governance, team & price.

Governance copies Slack outright — it's the part they got right. Pricing does not: there is no premium workflow class here. Phase 3 is where workflows stop being personal — team bots and borrowed secrets — which is also where the security surface gets sharpest.

FEATURE W5.1

Managers, publish & permissions

P1Effort MPhase 2Copied from Slack deliberately
Benefit. Who can build, who can run, who can copy — answered the way Slack admins already expect, so nobody has to learn a new permission model to migrate. For the business: an admin dashboard listing every published workflow is the difference between a tool and shadow IT.
Depends workspace & membershipBlocks W5.2 templatesInstrument workflow_published · manager_added · workflow_run{by}

Problem. A workflow with real access and no owner is a liability. When the person who built it leaves, someone must be able to find it, read it, and turn it off.

Stories

W5.1-S1Workflow managers
  • The builder is a manager by default; managers can edit, unpublish, delete, and add managers
  • Drafts are private to the author until published
  • A workflow always has at least one manager; removing the last one is refused, and deactivation reassigns to the workspace owner
W5.1-S2Publish & run permissions
  • Who can find it, who can run it, who can copy it — set at publish, changeable after
  • Running a workflow never grants access to the connectors it uses; the run acts with the owner's access, not the runner's (WINV-8)
  • Every run records who started it
W5.1-S3The admin dashboard
  • Every published workflow in the workspace with its managers, triggers, connectors, and run volume
  • Sortable by external-action volume — the list an admin actually wants is "what's sending the most on our behalf"
  • Admins can unpublish; they can't silently edit someone's workflow
FEATURE W5.2

Templates — checkpoints intact, secrets never included

P2Effort LPhase 3Depends on the Vault story
Benefit. A proven workflow another team can install. For the business: this is the nearest answer we have to Slack's template ecosystem and years of admin muscle memory — and the honest read is that it needs time and proof, not just a spec.
Depends W5.1 · W3.4 versions · VaultBlocks the Library's workflow shelfInstrument template_installed{source} · template_published

Problem. Every team rebuilds the same digest, the same triage, the same onboarding flow. Sharing them is only safe if the sharing mechanism provably cannot carry a credential.

Stories

W5.2-S1Publish a workflow as a template
  • Steps, structure, checkpoints, and trigger shapes carry; connected accounts, secrets, and room bindings do not
  • The template preview lists what the installer must supply before it can run
  • Secret-stripping is demonstrable, not asserted — the preview shows exactly what's included
W5.2-S2Install one
  • Installing creates a normal draft workflow owned by the installer — never a live one
  • Checkpoints arrive intact and cannot be stripped in transit; an installed workflow satisfies WINV-1 on arrival
  • The Library ships a starting set: a CEO digest, a manager digest, an onboarding flow, a bug triage
Watch out: "secrets never included" must be demonstrable before the Library opens. A single template that carries a token is the kind of incident that ends the feature — and cross-workspace sharing (which Slack Connect users will ask about on day one) is explicitly out of scope, with templates as the nearest story.
FEATURE W5.3

Team bot & borrowed permissions

P2Effort XLPhase 3New build · sharpest security surface
Benefit. Team-scale automation without a shared password in a doc. A workflow can borrow the team bot's permissions and secrets under governance, instead of running on whichever person happened to build it. For the business: this is what makes workflows survive someone's departure.
Depends Vault · W5.1 · team bot serviceBlocks team-owned scheduled automationInstrument delegation_granted{scope} · delegated_call{cap, actor}

Problem. Today a workflow runs with its owner's access, which means an automation the team depends on breaks when one person leaves and is over-privileged while they stay. The alternative teams reach for — a shared account — is worse.

Starting point: the Vault, per-user encryption, and masked credentials exist. What's new is delegation: a workflow acting with the team bot's access rather than a person's, which means every invariant in this doc has to hold when the actor isn't a human.

Stories

W5.3-S1A workflow runs as the team bot
  • A workflow can be configured to act with the team bot's identity; the run's actor is recorded as the bot, with who authorized the delegation
  • The team bot's identity is visible in every message the workflow sends — never disguised as a person
W5.3-S2Borrowed secrets, scoped
  • Delegation is per-connector and per-workflow, granted by a workspace owner, revocable, and expiring
  • A delegated secret is never readable by the workflow's author — only usable by the run
  • Every delegated external call is audited with both the bot and the human who authorized the delegation (WINV-2)
W5.3-S3Checkpoints still need a person
  • A delegated workflow's checkpoints route to named humans; the bot cannot approve its own external actions
  • If no human is available the run parks and escalates — a delegated run never self-authorizes (WINV-1)
Watch out: W5.3-S3 is the load-bearing story of Phase 3. Delegation exists to remove humans from the routine path, and the pressure to let the bot approve its own sends will be immediate and reasonable-sounding. That pressure is where WINV-1 either holds or quietly becomes optional.
FEATURE W5.4

Metering — one meter, estimated before the run

P1Effort MPhase 2Runs meter exists
Benefit. Adding a second connector step never changes a workflow's billing class. In Slack it silently can. For the business: no premium workflow tier means no reason to avoid the steps that make workflows valuable. G12
Depends W3.5 run records · pricingBlocks public pricing copyInstrument run_estimated{low, high} · run_metered{actual} · spend_cap_hit

Problem. Usage-based pricing on variable-cost steps is a trust problem before it's a billing problem. Users under-build to avoid surprises, which makes the product worse and the revenue smaller.

TierWorkflowsThe meter
Free · $03 Connectors · 3 Workflows — a five-trigger workflow counts as oneMetered daily agent allowance · checkpoint on everything external
Team · $25/seatAll Connectors · unlimited WorkflowsPooled workspace credits · a run is the unit · estimates before runs · admin spend caps
Command · $60/seatEverything in TeamSSO, SCIM, audit export — self-serve

Stories

W5.4-S1Estimate before the run
  • Publishing and manual runs show an estimated cost range; agent-step variance is a range, never a point
  • The estimate names which steps drive it, so the user can see what to change
  • Estimate vs. actual is visible in run history — the estimate is checkable by the person who relied on it
W5.4-S2No step type reclassifies a workflow
  • Every step type is available on every paid tier (WINV-10)
  • Adding a connector or agent step meters more runs against the pool and says so — it never changes billing class
W5.4-S3Caps and walls that don't lose work
  • Admin spend caps at the workspace level, with an 80% warning before the wall
  • Hitting a cap pauses runs at a step boundary and notifies — it never abandons a run mid-flight or double-charges on resume
  • Free-tier limits state the counting rule on the card: three workflows, and a five-trigger workflow is one
Traceability · audit

Phase → story map.

Every capability the milestones commit, mapped to the story that specifies it. Read in both directions: an unmatched milestone item is a story that doesn't exist, and a story with no phase is work nobody has scheduled. Four rows below are unmatched on purpose — they're named at the bottom rather than quietly omitted.

Phase 1Shipped · Tue 11 Aug
Foundation — build and run a workflow end to end. Triggers, typed blocks, forms and approvals, three connectors, live run panel, safety.
Phase 2By 21 Aug
Scale & integrate — webhooks, AIC-driven steps, a Slack app, Google Workspace, a database, its own service. Versioning and export land here too.
Phase 3Early Sep
Team & trust — team bots, borrowed permissions and secrets, templates.

Phase 1 — Foundation

Milestone capabilitySpecified byNotes
Trigger · Message (keyword, mention-only, room, owner-only)W4.1-S1 · W4.3-S1/S2Phase 1 is one room; several or all is Phase 2.
Trigger · Shareable linkW4.1-S3Authenticated deep link, revocable.
Trigger · Schedule (cron)W4.1-S2Plain language and cron are one config, two views.
Trigger · Connection (Jira & GitHub events)W4.1-S1 · W2.2-S2Slack is calls-out only — no Slack events in Phase 1.
Trigger · ManualW4.1-S1—
Authoring Mode 1 · full agentW1.1-S4One-line goal, path decided at run time; external boundary still fixed at authoring.
Authoring Mode 2 · flow builder + deliveryW1.2-S1/S2/S3 · W2.1-S1—
Block · Collect info in a formW3.2-S1Matrix fallback designed in Surfaces.
Block · Ask a questionW3.2-S2—
Block · Approval gateW3.1-S1/S2/S3/S4The checkpoint. WINV-1.
Block · BranchW1.4-S1One level of nesting.
Block · Call an API (HTTP + auth)W2.1-S3Non-GET is external and forces the floor.
Block · Use a connected accountW2.2-S1Token injected, owner-only.
Block · Set variablesW2.1-S2 · W1.3Not named in the milestones; the variable model is unusable without it.
Block · AI stepW2.3-S1/S2/S3Specified as the agent step — a superset of "AI step."
Delivery · send to channel / reply in room / DM / in-thread / @-mentionsW2.1-S1—
Human-in-the-loop · button choicesW3.2-S2choice(), Matrix-native v1.
Human-in-the-loop · durable wait-resumeW3.2-S3WINV-4.
Connectors · Jira, GitHub, SlackW2.2-S1/S2Jira and GitHub both ways; Slack calls-out only.
Run · live step panelW3.5-S2Not available in-room — see Surfaces.
Run · inline promptsW3.2-S1/S2—
Run · test runW1.5-S1/S2/S3WINV-6.
Run · telemetry (tokens, cost, duration)W3.5-S2 · W5.4-S1Per-step, next to the step that spent it.
Safety · trust tiers, owner-only account accessWINV-8 · W2.2-S1 · W5.1-S2—
Safety · network hardeningWINV-8 · W2.1-S3Blocked target names the rule.
Safety · crash-safe steps (no double-fire)WINV-4 · W3.3-S1/S3—
Failure handling · retry, pause, notify, resumeW3.3-S1/S2/S3WINV-5. G6
Matrix · in-room choice() cardsW3.2-S2 · SurfacesMatrix-only v1, stated as such.
Matrix · room-scoped triggersW4.3-S1/S2—
Matrix · forms don't render in a Matrix clientSurfaces · W3.2-S1 · WINV-7The footnote, promoted to a designed fallback.
Continuous expansion bot · seeds the catalogW2.4-S1/S2—

Phase 2 — Scale & Integrate

Milestone capabilitySpecified byNotes
Webhook triggersW4.1-S1 · WINV-8Payloads clamped before they touch anything.
AIC message → drive the flowW4.1-S1Listed as a trigger; chaining agent conversations into automation.
Trigger · When asked in chatW4.1-S1 · WQ3The trigger only we have, and the one no milestone names. Blocked on the metering rule.
Slack app supportSurfaces · W3.1-S4 · W3.2-S2Native cards replace Phase 1's link-out. Authoring stays out of Slack.
User-triggered agent actionsW4.1-S3 · W5.1-S2Run permissions decide who may; the run still acts with the owner's access.
Move data to a databaseW3.4 (enables) · W3.5-S3Infrastructure. Versioning and export are the features it unlocks.
Separate workflow serviceinfrastructure — no user-facing storyDeliberately unmatched. Named below.
More connectors · Google WorkspaceW2.2-S2 · W2.4-S2Gmail unlocks the Monday-report scenario.
Continuous expansion bot · ramps outputW2.4-S2Catalog dating is the visible half.
(not in milestones) Loop & wait-until-conditionW1.4-S2/S3Spec-added. workflows.html promises both; no phase funds them. Placed here as the earliest credible slot. G5 G9
(not in milestones) Multi-trigger, up to fiveW4.2-S1/S2/S3Spec-added. Unproven in the authoring layer. G2
(not in milestones) VersioningW3.4-S1/S2/S3Spec-added. Rides the database move. G8
(not in milestones) Run history exportW3.5-S3Spec-added. Needs versions to be meaningful. G7
(not in milestones) Managers, publish & permissionsW5.1-S1/S2/S3Spec-added. Phase 3's team features assume it.
(not in milestones) Metering & estimatesW5.4-S1/S2/S3Spec-added. Blocks public pricing copy. G12
(not in milestones) Trigger scope · several rooms or allW4.3-S1Spec-added. Phase 1 ships one room only. G3

Phase 3 — Team & Trust

Milestone capabilitySpecified byNotes
Team bot & bot servicesW5.3-S1Bot identity always visible in what it sends.
Borrowed permissions & secretsW5.3-S2/S3The bot can never approve its own external actions.
Continuous expansion bot · team-aware growthW2.4-S2 · W5.1-S3—
(not in milestones) TemplatesW5.2-S1/S2Spec-added. Needs the Vault story demonstrable first.
What this audit found
  • Every Phase 1 capability has a story. Thirty rows, no gaps. That's expected — Phase 1 shipped, so the milestone list is a description of built software.
  • Eight capabilities in this spec have no milestone home. Loop, wait-until-condition, multi-trigger, versioning, export, permissions, metering, and multi-room scope are all promised by workflows.html and funded by no phase. They're placed in Phase 2 as the earliest credible slot, but that placement is this document's assertion, not a commitment anyone made. Six of the twelve Slack gaps depend on them.
  • Templates are placed in Phase 3 with no milestone support either. They're the answer to Slack's template ecosystem and they depend on a demonstrable Vault story.
  • One milestone item has no user-facing story, correctly. "Separate workflow service" is infrastructure. It appears here so the map has no silent omissions, not because it needs a spec.
  • Two triggers in workflows.html are specified nowhere. "When a person joins" and "when a reaction is used" are struck in W4.1's table — the reaction trigger presumes Rooms ship emoji reactions, which is unconfirmed (WQ6).
Watch out: the second bullet is the real finding of this whole document. workflows.html reads as a description of a finished product; the milestones fund about two-thirds of it. Anything built from the strategy memo alone will assume loops, versioning, and multi-trigger exist. They are specified here and scheduled nowhere.
Traceability · audit

Gap matrix — G1 to G12.

The twelve documented failures of Slack's Workflow Builder, each mapped to the story that answers it and an honest status. workflows.html's scorecard claims ten answered, one mitigated, one open. Measured against what's actually scheduled, that count doesn't hold — the difference is stated per row rather than argued.

IDSlack's gapOur answerSpecified byPhaseStatus
G1No step-level testingTest run — reads real, writes stubbed; plus single-step testingW1.5-S1/S2/S3 · WINV-61Answered
G2One trigger per workflowUp to five triggers as a list on the workflowW4.2-S1/S2/S32Specified · unscheduled
G3Single-channel scopeTriggers watch one Room, several, or allW4.3-S1/S212Partly answered
G4<100 connectorsThree connectors at launch, plus agent steps that act where none exists, plus a catalog that grows without a releaseW2.2 · W2.3 · W2.412Open — mitigated, not erased
G5No loopsLoop over a list, with a snapshotted list and batch-by-default checkpointsW1.4-S22Specified · unscheduled
G6Weak failure handlingRetry ×2 → pause → notify the owner → resume from the journalW3.3-S1/S2/S3 · WINV-51Answered
G7Logs aren't exportableCSV export of run lists and single runs, with checkpoint provenanceW3.5-S32Specified · unscheduled
G8No versioningPublish creates a version; in-flight runs pin theirs and finish on itW3.4-S1/S2/S3 · WINV-32Specified · unscheduled
G9Coarse delaysWait minutes to months, or until a condition, with a required timeoutW1.4-S32Specified · unscheduled
G10One-way onlyAgent steps watch for replies and sync back, verified with evidenceW2.3-S1/S2 · WINV-91Answered
G11Complexity cliffEnglish authoring, compiled plans, visible variable flow, one-level nesting — and a 100-step capW1.1 · W1.3 · W1.2-S31Mitigated — not immune
G12Premium billing surprisesNo billing classes; one meter, range-estimated before the run, checkable afterW5.4-S1/S2/S3 · WINV-102Specified · unscheduled
The honest count
  • Four answered and shipped: G1, G6, G10, G11-as-mitigation. All four are Phase 1, all four are the strongest things to demo, and three of them are properties of the journal rather than features we built for this.
  • Six specified but unscheduled: G2, G5, G7, G8, G9, G12. Every one depends on a spec-added feature that no milestone funds. They are real designs with no date.
  • One partly answered: G3. Phase 1 ships room-scoped message triggers — the one-room case, which is exactly Slack's limitation. Several-or-all is the part that closes the gap.
  • Two don't fall to architecture: G4 (connector count) and G11 (complexity). Agent steps mitigate G4 and English authoring mitigates G11; neither is erased, and the 100-step cap keeps G11 alive by design. Also unanswered by architecture: Slack's template ecosystem and years of admin muscle memory — W5.2 is the plan, and it needs time and proof, not a spec.
  • Versus workflows.html's scorecard: it claims ten answered. Six of those ten are answered by design and by nothing on a calendar. The architecture arguments hold; the tense doesn't.
Measurement

Telemetry — the event dictionary.

Every event a feature must emit, and what it feeds. Naming follows the house convention: object_verb, snake_case, properties in braces. The ratified routine_* events are renamed to workflow_* — the same noun decision as everything else, applied to the event names so dashboards don't outlive the vocabulary.

EventFires whenFeeds
workflow_compiled{steps, inserted_checkpoints}A description compiles to a plan (W1.1-S1)Authoring funnel start. Replaces routine_compiled.
workflow_plan_edited{via}A plan is refined in English or on the canvas (W1.1-S2, W1.2)Which door people finish in — the two-modes question, answered with data
workflow_test_run{outcome, stubbed_n}A test run completes (W1.5-S1)Authoring funnel middle. Replaces routine_test_run. Test-before-publish rate is the trust proxy.
workflow_published{version, triggers_n, has_agent_step}A workflow goes live (W1.2-S4, W3.4-S1)North star — describe → published. Replaces routine_scheduled.
step_added{cap} · step_reordered · step_deletedCanvas edits (W1.2-S1/S3)Which steps people actually reach for; palette ordering
var_referenced · var_unresolved{step}Variable use and authoring errors (W1.3)Authoring-error rate — the G11 health signal
trigger_attached{kind, count} · trigger_fired{kind}Triggers configured / firing (W4.1, W4.2)Multi-trigger adoption; which ways in matter
trigger_filtered{reason}An event matched a trigger but was filtered out (W4.3-S2)Diagnosing "why didn't my workflow run" without logs
run_started{trigger, version} · run_completed{outcome, verified}Run lifecycle (W3.5-S1)Retention engine adoption — runs per workflow per week
approval_actioned{verb, source, ms_waited}Any checkpoint resolved, anywhere (W3.1)Trust metric — median time-to-approve, falling means trust forming
approval_expired{escalated_to}A checkpoint expires and escalates (W3.1-S3)Whether escalation works, or just moves the silence
prompt_shown{kind, surface, fallback} · prompt_answered{ms}Forms, questions, choices render and resolve (W3.2)Surface health — the fallback property is how we learn whether degradation is acceptable (WQ4)
step_failed{cap, cause} · step_retried{n} · run_resumed{source}The escalation ladder (W3.3)Recovery rate — % of failed runs that finish. The G6 claim, measured.
owner_notified{cause}A run parks and tells its owner (W3.3-S2)Whether owners learn from us or from a missing result
loop_iterated{count, failed_n} · wait_resumed{cause}Control flow at run time (W1.4)Loop adoption and per-item failure rate
agent_step_ran{verified, budget_used, tools_n}An agent step completes (W2.3)Verified-done accuracy; agent-step cost variance
run_estimated{low, high} · run_metered{actual}Estimate shown / run metered (W5.4-S1)Estimate accuracy — the G12 promise is only as good as this ratio
run_log_exported{format, scope}History leaves the app (W3.5-S3)Audit-export usage; a Command-tier justification
connector_connected · connector_step_ran{vendor, ok}OAuth completes / a connector step runs (W2.2)Connector depth vs. breadth; which of the three carry the load
catalog_item_added{kind} · connector_requested{vendor}The expansion bot ships something / a user asks (W2.4)Whether the catalog is visibly alive, and what to build next
delegation_granted{scope} · delegated_call{cap, actor}Team-bot delegation (W5.3)Phase 3 adoption; delegated-access audit trail
unapproved_external_actionShould never fire — alert, not analyticsGuardrail — any occurrence is a stop-ship incident (WINV-1)
double_fired_side_effectShould never fire — alert, not analyticsGuardrail — a resumed run repeated a recorded effect (WINV-4)
Watch out: renaming routine_* to workflow_* breaks any dashboard built on the old names. The rename ships with the dual-labeling release, both names emit for that one release, and the old ones stop after — same migration shape as the noun itself (the decision).
Measurement

Success metrics.

One number per phase, plus guardrails that hold throughout.

Phase 1 · authoringDescribe → published% of started descriptions that reach a published workflow, and the median time. The whole English-first bet is this number.
Phase 1 · trustTest-before-publish rate% of first publishes preceded by a test run. High means W1.5 is doing its job; low means people are publishing blind.
Phase 1 · reliabilityRecovery rate% of runs that hit a failure and still finish. The G6 claim, measured — a falling number is the failure ladder not working.
Phase 2 · retentionRuns per workflow per weekPublished-and-forgotten is the failure mode. Secondary: % of workflows with more than one trigger.
Phase 2 · monetizationEstimate accuracyActual within the estimated range, ≥90%. Below that, WINV-10's promise is copy, not a guarantee.
Guardrails · alwaysZero unapproved external actions · zero double-firesAbsolute. Either firing is a stop-ship incident, not a metric to trend.
The bar

Definition of done.

Six conditions. A story that meets its acceptance criteria and fails one of these isn't done — it's demoable.

Every story, before it ships
  • WDOD-1 · Invariants hold. All ten WINV lines verified for this story's paths, including the failure paths. A story that touches external actions ships with a test that would catch unapproved_external_action.
  • WDOD-2 · States designed. Empty, loading, partial, waiting, failed, denied, expired, went-quiet, and phase-locked. A step type ships with its locked state and its per-surface fallback, not just its happy path.
  • WDOD-3 · Strings clean. Approved vocabulary only (glossary). No "routine," no "playbook," no "permission prompt." Fallback copy states that it's a fallback (WINV-7).
  • WDOD-4 · Instrumented. The events in the story's facts row emit with their properties, and are visible on a dashboard before the story closes — not added in a follow-up.
  • WDOD-5 · Reversible. Anything the story can do to the outside world can be stopped, denied, or explained afterwards. Every new step type declares whether it's external, and is wrong-by-default toward external.
  • WDOD-6 · Accessible. Keyboard-complete, focus visible, contrast met. Checkpoint decisions and form prompts are reachable without a pointer — including /approve <id> as the keyboard path.
To resolve

Open questions.

Owned by product unless noted. WQ1 exists because this document created it.

Nine, in order of what they block
  • WQ1 · The noun contradiction. This spec says Workflow; the ratified product-spec.html glossary says Routine and lists workflow as banned. Both are current. Resolving means either sweeping four documents or reversing the decision — and until it's resolved, no public copy can safely use either noun. Blocks: all external copy. Owner: product, with a date.
  • WQ2 · Where's the checkpoint floor? WINV-1 as written is one checkpoint before the first external step. The stricter reading is one before every external step. The loose reading lets a single approval authorize a Jira write, a Gmail send, and a Sheets append. A one-line change in the compiler; a large change in what the guarantee means. Blocks: W1.1 compile pass. Owner: product + security.
  • WQ3 · When is a chat request a run? "When asked in chat" is the trigger only we have, and it sits on the seam between conversation and automation. If @agent "run the client report" is a metered run but "summarize last week's Jira" is conversation, users will find the seam and argue with it. Needs a rule before the trigger ships. Blocks: W4.1 Phase 2, W5.4. Owner: product + pricing.
  • WQ4 · Is the Matrix form fallback acceptable? Four sequential prompts is a designed degradation, not an equivalent — it can't cross-validate fields and it's slower to answer. Options: ship it as designed, restrict forms to web-only in Rooms, or build native Matrix form rendering. Decide with prompt_answered{fallback} data from Phase 1. Blocks: W3.2-S1 completion. Owner: design + product.
  • WQ5 · Who funds the eight unscheduled features? Loops, wait-until-condition, multi-trigger, versioning, export, permissions, metering, and multi-room scope are specified here and scheduled nowhere (phase map). Six of the twelve Slack gaps depend on them. Either Phase 2 grows or the gap scorecard gets rewritten. Blocks: the gap matrix being honest in public. Owner: eng + product.
  • WQ6 · Do Rooms have emoji reactions? workflows.html lists a reaction trigger; it presumes a surface feature nobody has confirmed. Same for "when a person joins." Confirm before either goes in a public trigger table. Blocks: W4.1 table going public. Owner: eng.
  • WQ7 · Batch or per-item checkpoints in a loop? W1.4-S2 makes batch the default — one approval for six sends. It's the right default and it's also the reading of WINV-1 that gives the least protection per approval. Confirm with security that a batch card listing all six satisfies the invariant's intent. Blocks: loop + external combination. Owner: security. Related: WQ2.
  • WQ8 · Loop determinism on a changing list. W1.4-S2 snapshots at loop entry, which makes replay deterministic and makes mid-run additions invisible. For a triage loop over an open issue list, invisible may be wrong. Is snapshot-at-entry right, or does it need a re-check pass? Blocks: loop implementation. Owner: eng.
  • WQ9 · What happens to the 100-step cap? The cap keeps G11 alive by design and nobody has checked it against real workflow sizes, because Phase 1 workflows are days old. Watch the distribution; if p95 is near 40 the cap is fine, and if it's near 90 the flat-list-with-indent model is already failing. Blocks: nothing yet. Owner: product, revisit at 60 days.
Vocabulary

Glossary.

The vocabulary for this feature, defined once. If a word isn't here it doesn't go in the UI. The first row is the one this document inverts — see the decision and WQ1.

TermMeansNever say
WorkflowUp to 5 triggers, up to 100 sequential steps, at least one checkpoint before anything external. One execution is a run.routine · playbook · automation (as a label)
runOne execution of a workflow. The metered unit and the history unit. Runs pause at checkpoints and resume from the journal.execution · job · instance
checkpointThe pause before anything external: Allow once · Allow always · Deny. Journaled, survives restarts and edits, expiry escalates.confirmation · permission prompt · button · gate
triggerWhat starts a run. A list on the workflow, not a property of it — up to five.event (for the trigger itself) · hook
stepOne unit of work in a workflow, in one of four categories: Workspace · Connector · Agent · App.block (except "flow-builder blocks" internally) · action · node
externalA step property, not an opinion: it changes something outside the workspace. External steps force the checkpoint floor.write · side-effecting (in UI copy)
variableA named value produced by one step and readable by later ones. Rendered as a pill: {{client.summary}}output · field · token
branchA condition that picks a path. One level of nesting; "else: do nothing" is a valid path.condition · if-step · fork
loopRepeat steps once per item in a list. The list is snapshotted at entry.for-each (in UI copy) · iterate
waitPause for a duration, until a time, or until a condition — with a required timeout.delay · sleep · pause (that's what a checkpoint does)
test runA run where reads are real and every external write is stubbed and shown. Canonical over "dry run."dry run · preview · sandbox
verified doneCompletion confirmed by the independent verifier with expandable evidence. Shown as the verified strip.done ✓ (without evidence) · complete
went quietA run that correctly did nothing — conditions produced no work. A success state, not a failure.skipped · empty · no-op
recoveredA run that failed a step, retried or resumed, and finished. Reads as recovered in history, never as failed.failed-then-succeeded · retried
surfaceWhere a step renders and asks: web · mobile · Matrix Room · Slack. Surfaces are not equal and the differences are designed.platform · client · channel
fallbackA designed degradation when a step can't render natively on a surface. Always disclosed before the user acts.workaround · limitation · degraded mode
ConnectorA linked external tool via OAuth. Phase 1: Jira, GitHub, Slack.integration · app (for connections)
workflow managerSomeone who can edit, unpublish, delete, and add managers. The builder is one by default.admin (that's workspace-level) · owner
versionWhat a publish creates. A run pins one at start and finishes on it.revision · draft (a draft is unpublished)
templateA workflow another team can install — structure and checkpoints intact, secrets never included.blueprint · preset · recipe

ai.com · Workflows — feature spec & backlog · v1 · August 2026 · Internal · Confidential. Companion to workflows.html (strategy, Slack comparison, G1–G12) and workflow-milestones.html (delivery phases). Deliberately diverges from ../quiet-sky-launch/product-spec.html on one glossary row — see the decision and WQ1. Mockups are directional, not final design; dashed frames are structure only; all example data is fictional.