Build Event-Driven AI Agent Pipelines
You can turn any repetitive, multi-stage job into a reactive AI pipeline: a table holds the work items, each stage has its own agent, and every agent reacts when a row's status changes — advancing the row by writing the next status. There is no central orchestrator and no waiting; the pipeline runs itself row by row.
Reactive Pipeline Builder
Turn a repetitive, multi-stage job into a reactive, status-driven agent pipeline.
Build event-driven pipelines, queues, and multi-stage processes where each stage reacts to a status change on a table mind — no central orchestrator and no waiting
What you can do
Model a table mind as the pipeline state store
Create one entry-bound worker per stage
Wire each stage to a document trigger on status
Try saying
“Build a pipeline that processes each row in this table”
“Create a multi-stage content workflow”
“Run an agent on every item in a queue”
When the assistant uses this
Use when the user wants a repeatable workflow, queue, or multi-stage agent pipeline where each item moves through stages.
How does Reactive Pipeline Builder work?
Loads the canonical pipeline prompt for modeling a table mind as the state store, creating one entry-bound worker per stage, and wiring each stage to a document trigger that reacts when a row's status changes — so workers advance the pipeline by writing the next status, with no central orchestrator and no fan-in wait.
What phrases trigger this Skill?
“build a pipeline”
“create a workflow”
“multi-stage process”
“process each row”
“queue of items”
“react to status changes”
Frequently asked questions
How does a status-driven pipeline work?
Each work item is a row in a table with a status field. A trigger watches the table; when a row's status changes, the agent responsible for that stage wakes up, does its work on that row, and writes the next status — which wakes the next stage. The table is both the queue and the audit trail.
Why no central orchestrator?
Because each stage reacts independently to status changes, there is no single workflow run that can stall or fail mid-graph. Items move at their own pace, stages can be added or changed without rewiring the whole flow, and you can see exactly where every item is by reading the table.
What kinds of work fit this pattern?
Anything where items move through stages: content production (idea → draft → review → publish), lead processing (new → qualified → contacted), document processing, order handling, research queues. If you'd describe it with a status column in a spreadsheet, it fits.
Can a human be one of the stages?
Yes — a review gate is just a status only a human sets. The pipeline pauses naturally at that row until someone approves it, then the next agent picks it up. No special approval infrastructure needed.