Context & Opportunity
Misalignment is costly, leading to rework, delayed launches, and decision bottlenecks. I identified an opportunity to redesign how these functions collaborate.
At an organizational level, this model reduces coordination overhead, accelerates decision-making, and allows the organization to scale product delivery without increasing team size at the same rate.
Old model
Leaner Documentation, Faster Cycles
Large, catch-all PRDs replaced with scoped, feature-specific documents. Faster iteration per workstream.
Flexible System, Not Fixed Sequence
The workflow adapts to each product. Some products start with a prototype, not a PRD.
Upfront Calibration Cost
Tuning agents and behavior tests took time; justifying the investment was the hardest sell.
Solution
From Roles to Agents
This system replaces the linear PM → Design → Engineering handoff with a multi-agent graph-based architecture. Four domain-specific agents, operating at L2 Collaborator autonomy, generate structured artifacts from a single PRD source of truth, while an L3 Delegator Orchestrator manages activation and event detection. Agents surface uncertainty through inline assumption tags, enabling directed review instead of exhaustive human verification.
What We Got Wrong
Failed hypothesis #1
Demonstrating agent output quality would be enough to get buy-in. What mattered wasn't output quality but where humans stayed in control.
Failed hypothesis #2
Full visibility oversight was needed for every agent. Exception visibility solved it: agents flag uncertainty, humans review only that.
Failed hypothesis #3
Semantic memory would be needed to maintain context. Structured .md files provided workspace memory without the complexity.
Process
The PM writes the PRD in Confluence; the PM Agent translates it into a structured .md file in GitHub, establishing the single source of truth for the cycle.
I defined how each human and each agent relate to each other before designing anything else. Each relationship determines what the agent communicates, when it escalates, and how much autonomy it holds. Everything else follows from that.
Five agents, each with a defined role. The Designer Agent generates UXDD and design spec from the PRD. The Engineer Agent does the same for TDD and openspec. Both tag uncertain decisions with [ASSUMPTION] for human review. The QA Agent extracts those assumptions into standalone files. The PM Agent validates cross-document coherence and generates evals. The Orchestrator monitors GitHub, detects events, and activates the right agent at the right time — no agent calls another directly.
GitHub centralizes specs, validations, and evals versioned by cycle. Git history acts as the system's memory, no separate semantic memory required.
Each failure generates a report directed to the responsible agent; the QA Agent validates integrity before proceeding. The fix is confirmed via human PR, reactivating the cycle from that point.
Once Designer, Engineer, and PM sign off, the Orchestrator archives the cycle's artifacts. Any new version or feature restarts the process from the PRD, with full traceability via git.
Controversial Decisions
Workspace memory over semantic memory
Agents don't need to remember, they need to read specific files. I chose .md files over semantic memory, trading recall for full git auditability.
Graph-based orchestration, not open-ended reasoning
The Orchestrator follows predefined paths, not open-ended reasoning. I traded flexibility for predictable behavior in a production workflow.
QA Agent has more autonomy than DA and EA
Validation is deterministic. I gave QA Agent more autonomy than DA and EA, despite it being the newest agent in the system.
Want to know more about this project?
Read more on my Medium
