The supervision interface for an agentic content pipeline.
One brief in, 36 retailer-ready packages out. Six AI agents do the repetitive work. Humans own every decision that ships.
ShelfFlow turns a single product brief into retailer-ready content through an orchestrated pipeline: AI agents parse, draft, adapt and flag; four mandatory human gates decide what advances. The product problem wasn't generating content. It was making agentic work supervisable at enterprise scale.
I owned the product end to end: strategy and pipeline architecture, agent orchestration boundaries, state machine design, decision authority mapping and the full operator interface.
The supervision surface. Operators track active briefs, pipeline status and AI agent activity across all launches from a single screen.
Teams weren't failing at content creation. They were drowning in coordination. The fix wasn't a faster content tool: it was decision architecture with AI embedded inside it.
A single product launch at an enterprise CPG company means 6 SKUs × 3 retailers × 2 variants = 36 content packages, each with its own spec requirements, character limits and compliance rules. Producing this by hand took weeks: versioning lived in file names, approvals moved through email threads no one could reconstruct, and generative AI existed but wasn't trusted because nothing defined what it was allowed to decide.
Faster drafting wouldn't have solved it. The strategic insight: design the decision architecture first, then embed AI as an accelerator within it. ShelfFlow structures the pipeline as 6 stages with 4 mandatory human gates. Agents operate freely between gates. Nothing crosses a gate without a human.
Six-stage pipeline
Six AI agents, each with a bounded scope. Every agent accelerates work. None can ship content.
ShelfFlow embeds 6 specialised agents across the pipeline, coordinated by a workflow orchestrator that routes tasks, schedules generation jobs and enforces gate rules. Each agent operates within a clearly defined boundary: it can draft, suggest, check or flag, but it cannot approve or publish. No agent can bypass a gate.
The agents absorb the repetitive, high-volume work that made manual workflows collapse: parsing briefs into structured SKU matrices, generating retailer-adapted copy within character limits, cross-checking claims against compliance databases, detecting contradictions across 36 parallel packages. The decisions that carry legal and brand accountability remain with humans.
Embedded AI agents
Every agent drafts or flags. No agent approves. Zero autonomous shipping.
S4 · Generate / select SKUs, trigger agents
S4 · Generating / A/B variants per retailerAgents at work. The operator triggers generation and supervises progress in real time: per-package status, confidence signals and flags surfaced as they happen.
Agent orchestration and authority in one map. Six agents work the lanes between gates; four humans own the gates. The vertical axis is the trust architecture: AI drafts and flags above the line, human accountability signs below it. The operator runs the workflow but holds no gate authority.
Four gates, four roles, one question the system can always answer: who approved this?
In enterprise commerce, shipping wrong content is more expensive than a delayed launch: incorrect claims create regulatory exposure, mismatched specs trigger portal rejections. So the counterweight to agent speed is a hard gate model. Four mandatory gates, no bypass, each owned by a role with explicit authority enforced by the system, not by process docs. A Content Lead approves briefs and drafts but can't sign off compliance. A Compliance Officer owns Gate 3 but has no launch authority.
Authority mapping
The decisions below defined the boundary between agent autonomy and human authority. Each one responded to a specific failure mode observed during research.
| Decision | Chosen | Rejected | Why |
|---|---|---|---|
| AI authority | Draft-only (never ships) | Auto-publish with confidence threshold | Enterprise compliance requires human sign-off on every claim that reaches the shelf. AI that ships autonomously creates regulatory liability. The value of AI here is speed-to-draft, not autonomy. |
| Gate model | 4 mandatory gates, no bypass | Flexible approval chains | Flexibility introduces ambiguity. When a retailer or legal team asks "who approved this?", the system must return one unambiguous answer. Configurable chains make that impossible to guarantee. |
| Staged generation | Brief → Draft → Adapt → Review | Single-step generation | Generating retailer-adapted content in one pass produces output that looks right but fails spec validation. Staged generation lets operators catch problems at each layer before they compound. |
| Batch operations | Batch approve only after individual review | Unrestricted batch approval | v1 allowed batch-approving packages that hadn't been individually reviewed. Testing revealed operators rubber-stamped to save time. Added a "reviewed" flag requirement. Speed without review is liability. |
Decision authority map: who owns which decisions across the pipeline. Agents act autonomously between gates. Humans own every approval that ships.
Every package is a state machine. Rejection isn't an error state. It's a structured feedback loop back to the agents.
Each of the 36 packages runs as an independent state machine: Draft, In Review, Approved, Published, Rejected or Blocked. Nothing else. Every transition requires an explicit human action or a system event, and every change is logged with who triggered it and why. This replaced the ambiguous in-between states of the old workflow: "probably approved", "waiting on someone", "I think legal saw it". Rejected packages route back to the previous stage carrying reviewer notes, which agents use to regenerate. Supervision, not babysitting.
Content package states
Gate 1: Brief validation. Side-by-side diff showing user brief vs. AI-enriched brief. Human confirms or edits before lock.
Gate 4: Full matrix review. Per-cell approval across 18 human decisions, every SKU × retailer combination. "Approve for Launch" is the final gate.
Hold Gate 4 yourself.
A working slice of the decision architecture: approve variants, reject and watch the feedback loop, and try to batch-skip the review — the guardrails are live.
36 packages. 18 approvals. 200+ state transitions. The combinatorial reality that makes manual workflows collapse.
The core complexity of ShelfFlow isn't any single content package. It's the combinatorial explosion when you multiply SKUs by retailers by variants. This is where manual workflows break. Not at package #1, but at package #27, when reviewer fatigue sets in and the differences between Amazon and Walmart specs blur together. ShelfFlow's job is to make package #36 as reviewable as package #1: urgency signals, comparison tools and batch operations all exist to fight decision quality decay.
The content matrix explosion: 1 brief → 6 SKUs × 3 retailers × 2 variants = 36 content packages → 18 approval decisions → 1 launch.
Amazon · Full-fidelity PDP preview
Sephora · Adapted to retailer formatSame SKU, different retailers, completely different specs. Previews render in each retailer's actual page layout so operators review what the customer will see, not an abstraction.
The hardest problem wasn't the AI. It was making 18 approval moments feel fast instead of bureaucratic.
Five operational guardrails constrained every decision: AI assists, never ships. Every transition is auditable. The pipeline is the single source of truth: no side channels, no email approvals. Design for reviewer fatigue, not enthusiasm. Absorb the combinatorial complexity so humans can focus on judgement calls.