APD/M
Agentic Product Development and Management is how we run product and ops work with a multi-agent team, shared durable context, proactive observation, and humans who own outcomes and hard gates. It is a method and a deployable system pattern, and this page describes it the way it actually runs.
What APD/M is
Agents are load-bearing participants in discovery, definition, build, review, ship prep, and learning. Humans stay at strategy, judgment, taste, relationships, ethics, and ship / no-ship.
Agents produce outputs at volume. Humans own whether those outputs create value. The system underneath product, design, and engineering is unified: shared context, shared backlog, shared health signals.
The method is developed and practiced through real systems we build and run. It improves as those systems ship, break, and get retuned.
Seven phases, one gold status
Every build moves through the same numbered phases. One of them is gold: an approval only a person can flip, and nothing past it starts until they do. Agents advance everything else, and a build is not “built” because an agent says so: a verification script flips that status or nothing does. Build first, pitch second.
- 01 Intakevalidate
- 02 Product design
- 03 Tech specwritten to db
- Spec OKhuman gate
- 04 Planspec vs code
- 05 Buildwaves
- 06 Review + QAadversarial
- 07 Deployscript-gated
nothing past spec ok starts until a person flips it. phase 06 is where adversarial review runs.
Scripts block. Models advise. Humans decide.
The core design question in any agentic system is what kind of check guards each claim. We use four, and the order never reverses.
If a check has machine-checkable ground truth, it becomes a script with an exit code: design tokens against the live database row, brand fidelity against the extracted palette, contrast measured on rendered pages in a real browser, image integrity, route vitality, demo completeness. Exit 1 stops the line. Gate scripts are hash-verified at suite start and end, so every report records exactly which gate versions produced its verdicts.
Models review specs against the codebase and judge pitch-readiness before a human ever sees the build. Advisory, always. A model review once passed a site whose images had failed to load; the scripted gate behind it did not. That ordering is doctrine: model review never substitutes for a deterministic gate. And review is never one pass: findings are generated in parallel and adversarially verified before a human sees them.
Taste, strategy, and money stay human. The pipeline has exactly two designed approval gates, and beyond them every irreversible surface is gated by default: production deploy, public brand voice, money movement, destructive operations. A gate is a status only a person can flip, not a prompt an agent can talk its way through.
Some defects no machine can catch: a hero shot of the wrong subject, a page that is technically correct and obviously wrong. For those we do not fake a gate. The suite ends by printing a full-page contact sheet, a designated human-review surface. Knowing where scripts stop is part of the method.
Ownership Ledger
Not a graph but a table, which is the honest form for a claim about authority. What agents propose and execute on the left, what a human decides on the right, and a gate stamped on every row that cannot be undone.
Every finding meets a skeptic
Model review earns its advisory seat through structure, not trust. Reviews run as phases: findings are generated in parallel, then handed to reviewers whose only job is to prove them wrong. Agreement means nothing; survival does. The same shape runs inside build sprints, at the review phase of every client build, and on this site.
Find in parallel, with different lenses
Independent reviewers sweep the same change for different failure classes: correctness, security, fidelity to spec, accessibility, content integrity. Each is blind to what the others surface. Diversity catches what redundancy cannot.
Then try to kill every finding
A second wave is instructed to refute, not confirm, with refuted as the default verdict. A finding that cannot survive its own execution never reaches a human. Plausible-but-wrong dies here, which is the point.
Fixes get re-verified
Confirmed findings are tracked to closure as blockers, debt, or nits, and the re-check runs the same adversarial shape. A fix that only claims to fix something has not fixed it.
This is why model review gets to advise at all.
Rules with dates on them
Guardrails are not brainstormed, they are extracted. When something ships wrong, the failure becomes a rule, the rule gets a date, and enforcement moves to the lowest deterministic layer that can catch it: first the instruction, then a defensive cleanup pass, then a script that aborts the deploy. One rule, three layers, because any single layer fails eventually.
Provenance on every claim
Every line of shipped copy carries a source tag: agent draft, owner-provided, or verbatim quote. Verbatim quotes are never edited. Unreviewed drafts surface in a human review queue instead of shipping silently.
No unreceipted work
An agent may not tell anyone that background work is running unless it holds the spawn receipt from that same turn. Born from a real incident: a confident status report with zero tool calls behind it. Now a dated hard rule.
Writes that refuse to lie
Every pipeline status flip is a conditional write. Zero rows updated is a halt signal, never silent success: it means the world changed underneath the run, and the run stops rather than overwrite a human decision.
How the system is structured
Human owners hold strategy, review, and the ship gate. An orchestrator routes work and holds product context. Specialists cover engineering, ops, content, security, and restricted surfaces. Shared context ties brain, repo, board, metrics, and chat together. Handoffs between roles are typed contracts in the database, not messages in a chat.
Humans own outcomes
Agents propose and execute under review. Accountability stays human, and the statuses that matter can only be flipped by one.
Shared context beats archaeology
Decision log, board, repo, and metrics beat reconstructing work from chat history. Search before guessing is a standing order: no memory hit, no confident claim.
Hard gates
Production deploy, brand voice, irreversible money, and path-changing actions stay gated. Gates are statuses and scripts, not vibes.
A role is three lists
What it does, what it never does, and the contract it hands off through. Denylists are explicit: the BD role cannot deploy, the build role cannot approve itself, no agent owns the public voice.
Role Router
A top-down authority graph. An orchestrator routes work to specialists, all of them reading one shared context, and a single unbroken gold rule sits between the agent graph and production, interrupted only by named gates.
Loops, not prompts
Proactive loops run on schedules, not on requests. A daily product loop collects status and health, cross-checks commits against the board, and surfaces priorities in front of a human. A nightly research loop discovers, audits, scores, and files opportunities. Every loop ends in human-visible output: a loop nobody can read did not run.
The Proactive Loop
The cycle drawn as a sealed circuit: collect, cross-check, surface, execute, circling shared context. The loop has exactly one exit, and that exit runs through a human.
Runs leave receipts
A build that cannot prove itself did not happen. Gates print verdicts, gate scripts are hash-verified so reports record exactly what ran, deploys carry a human signature, and a final scan walks every customer-facing route before the line moves. Zero autonomous deploys is not a promise, it is an invariant the tooling enforces.
Trace
What a client build must pass, in order: six scripted gates with hash-verified provenance, then a contact sheet for what no script can see, then a ship / no-ship status that only a person can flip.
What counts as an APD/M instance
Clear domain + human owner
A real product or ops domain, and a human who owns ship / no-ship.
Agent graph with roles
Orchestrator plus specialists - not one chat blob with every privilege.
Shared context
Surfaces agents can read: repo, board or issues, memory, health and metrics.
Proactive loop
At least one loop (health, standup, pipeline) with human-visible output.
Explicit gates
Deploy, public voice, money movement, and destructive ops stay gated.
We build it. You own it.
Core process, data, and keys for client systems should not live forever inside a rented black box. Commodity SaaS is fine. The spine of the business should be ground you control - systems you run, data you hold, accounts in your name.
APD/M systems we build for products are real deployments with human gates, not seat licenses for a chatbot.
Where we run APD/M
Same method bones. Different domain skills and data. Public writing stays on systems we operate under real load.
Studio product team
Multi-agent product capacity used live every day inside Zavi Digital: research, build, review, ops, and delivery under human ship gates.
Partner product-squad gateway
Dedicated product-squad gateway for partner product engineering work. Orchestrator plus specialists (eng, ops, content, security) with isolation, denylists, and human deploy authority.
External product deployments
Same method bones running against live external product companies. Domain skills and data forked per product; substrate stays shared.
Studio BD engine
Same method DNA on studio ops: research, audit, spec, prebuild, pitch. Human gates on the irreversible steps. Internal ops machine - not a public service SKU.