agent-orchestration-advisor

Purpose

Guide product managers through designing multi-agent workflows—breaking complex, repetitive PM tasks into parallel, specialized AI agents rather than linear, sequential processes or manual execution. Use this to transition from "document-heavy administrator" to "systems-level orchestrator" who coordinates a "living system" of AI agents, human teams, and market data interacting continuously.

Key Shift: From linear project management (one task at a time) to orchestration (multiple agents working simultaneously, each with clear boundaries and handoffs).

This is not about prompt writing—it's about architecting workflows where AI agents handle repetitive research, synthesis, and validation while PMs focus on strategy and decision-making.

Input

Works best with: The workflow or recurring task you want to orchestrate — described in a sentence or two, however manual or messy it is today.
Also useful: Where it breaks down now (too slow, too sequential, too dependent on you), the tools your team already uses, and whether you've worked through context-engineering-advisor first (it's the prerequisite discipline).

Anything supplied with the invocation itself — text after the skill name, a pasted context dump, or an appended ARGUMENTS: line — counts as answers already given. Use it and skip whatever it covers; don't re-ask.

Arriving empty-handed? That works too. The advisor opens by asking which PM workflow eats the most of your week, then walks the four orchestration dimensions against it.

Example invocation: Design an orchestration for our weekly competitive intel: today one PM spends 6 hours scraping, summarizing, and briefing — sequentially.

Key Concepts

Orchestration vs. Project Management

Critical Insight: Orchestration is not about replacing humans—it's about force-multiplying human judgment by automating repetitive, time-consuming tasks.

---

The Four Dimensions of Orchestration

1. Coordination of Multi-Agent Workflows

Breaking complex tasks into specialized agents that run in parallel.

Example:

Manual (Old): PM spends 8 hours compiling competitive intel, then 4 hours synthesizing customer feedback, then 3 hours identifying roadmap gaps = 15 hours sequentially

Orchestrated (New): Three agents run simultaneously:

- Agent A: Competitive intel (research agent)
- Agent B: Customer synthesis (synthesis agent)
- Agent C: Roadmap gap analysis (analysis agent)
- Total time: 8 hours (limited by slowest agent), PM reviews outputs in 2 hours = 10 hours total, 5 hours saved

Key Principle: Shift from manual selection to hypothesis orchestration—agents generate hypotheses, PM validates and decides.

2. Leadership of Cross-Functional AI Pods

Governing diverse teams (data scientists, ML engineers, compliance, ethicists) to ensure solutions are scalable, ethical, and aligned.

What it includes:

Embedding diversity-aware workflows

Risk management (not afterthought)

Ethical orchestration (ensuring AI doesn't "go rogue")

Cross-functional alignment (engineering, compliance, design)

PM Role: Guardian of Governance—ensures AI systems reflect company values.

3. Launch Control Tower Function

Real-time monitoring of organizational readiness across functions using agentic systems to flag gaps before critical failures.

What it monitors:

Support readiness (docs, training, escalation paths)

Marketing readiness (messaging, assets, GTM plan)

Operations readiness (infrastructure, scaling, monitoring)

Key Principle: Agentic systems act as early warning system—flag gaps before they become blockers.

4. Strategic Intent Alignment (Context Engineering Applied)

Feeding AI agents the correct mix of mission, constraints, and priorities to ensure automated decisions reflect company values.

Connection: This is context engineering at the orchestration layer. See context-engineering-advisor for foundations.

What agents need:

Product constraints (what we will/won't build)

Strategic priorities (what matters most right now)

Operational definitions (shared glossary)

Evidence standards (what counts as validation)

---

The Four AI Management Workflows (Productside Blueprint)

Every PM must master these workflows to move fast while staying grounded:

Context Engineering ✅ (Foundation)

- Create AI workspace that remembers product domain, research, JTBD, personas, constraints
- Skill: context-engineering-advisor

Synthetic Evals 📋 (Quality Assurance)

- Automated validation tests for AI reasoning
- Generate synthetic data, run workflows against traces
- Eliminates 80% of hallucination risk

Agentic Workflows ← We're here

- Agents handle repetitive tasks (competitive intel, customer synthesis, roadmap gaps)
- PM focuses on strategy

Vibe Coding 📋 (Rapid Prototyping)

- Generate clickable prototypes from context workspace
- Collapse feedback loops from weeks to hours
- Connection: pol-probe-advisor (Vibe-Coded PoL Probes)

---

AI-Shaped Problems (Teresa Torres)

What makes a problem "AI-shaped"?

Previously difficult to scale due to human involvement (e.g., synthesizing 50 user interviews)

Falls short with current non-AI solutions (e.g., manual competitive tracking)

Requires consistency at scale (e.g., risk analysis across 100 features)

Key Insight: "While AI makes building easier, choosing what to build remains the primary challenge." Orchestration helps with the "building" part so PMs can focus on "choosing."

---

The Four Big Risks (Marty Cagan, AI Era)

The orchestrator manages these risks across the organization:

---

Anti-Patterns (What This Is NOT)

Not about replacing PMs: Orchestration amplifies judgment, doesn't eliminate it

Not about automating everything: Some tasks require human empathy and context

Not about complexity for its own sake: Only orchestrate when it saves significant time or improves quality

Not about "set it and forget it": Orchestrated workflows require monitoring and maintenance

---

When to Use This Skill

✅ Use this when:

You have repetitive PM tasks that take 5+ hours per week (competitive analysis, customer synthesis, roadmap maintenance)

You're doing sequential work that could be parallelized (research, then synthesis, then analysis)

You need consistency at scale (analyze 50 features for risk, synthesize 100 customer interviews)

You're spending time on execution instead of strategy

❌ Don't use this when:

The task is one-time or infrequent (not worth orchestration overhead)

Human judgment is critical at every step (empathy-driven work)

The task is already fast enough (don't over-engineer)

You haven't built context engineering foundations first (see context-engineering-advisor)

---

Application

This interactive skill uses adaptive questioning to design multi-agent workflows step-by-step.

---

Step 0: Gather Context

Agent asks:

Before we design your orchestrated workflow, let's gather context:

Current PM Work:

What repetitive tasks take the most time each week? (competitive analysis, customer synthesis, roadmap updates, etc.)

How much time do you spend on these tasks? (hours per week)

Are these tasks sequential (one after another) or could they run in parallel?

Desired Outcome:

What would "good enough" automation look like? (80% reduction in manual work? Higher consistency?)

What parts require human judgment? (final decisions, empathy, ethical considerations)

Technical Context:

Do you have context engineering foundations? (constraints registry, operational glossary—see context-engineering-advisor)

What AI tools do you currently use? (Claude Projects, ChatGPT, custom agents)

You can describe briefly or paste examples.

---

Step 1: Assess if Task is AI-Shaped

Agent asks:

Let's determine if your task is suited for orchestration. Which statement best describes your situation?

Select one:

"I spend 10+ hours per week on repetitive research/synthesis tasks"

- Examples: Compiling competitive intelligence, synthesizing customer feedback, tracking feature requests
- Assessment: High potential for orchestration

"I have a task that requires multiple sequential steps, and each step is time-consuming"

- Examples: Research competitors → Synthesize findings → Identify gaps → Update roadmap (15 hours total, done sequentially)
- Assessment: Good candidate for parallelization

"I need consistency at scale—analyzing many similar items"

- Examples: Risk analysis for 50 features, synthesizing 100 user interviews, tracking 20 competitors
- Assessment: Perfect for orchestration (agents ensure consistency)

"I have a task that's mostly human judgment and empathy"

- Examples: Stakeholder negotiation, team coaching, ethical trade-offs
- Assessment: Not a good candidate for orchestration (keep human-driven)

User response: [Selection]

Agent analyzes:

Based on your selection:

Options 1-3: Proceed to workflow design

Option 4: Recommend keeping task human-driven; suggest alternative approaches (e.g., use AI for research, but keep decision-making human)

---

Step 2: Decompose Task into Agent-Specific Subtasks

Agent asks:

Let's break your task into discrete subtasks, each handled by a specialized agent.

For the task you selected, what are the distinct steps?

Example Decomposition (Competitive Intelligence):

Manual Process (Old):

Research 10 competitors' product pages (3 hours)

Track recent feature launches (2 hours)

Analyze pricing changes (2 hours)

Synthesize into competitive landscape doc (3 hours)

Identify strategic gaps (2 hours)

Total: 12 hours, done sequentially

Orchestrated Process (New):

Agent A (Research): Scrape competitors' product pages, extract features

Agent B (Launch Tracker): Monitor competitors' release notes, blog posts, social media

Agent C (Pricing Analyzer): Track pricing pages, identify changes

Agent D (Synthesis): Compile findings from A, B, C into structured report

Agent E (Gap Analysis): Compare our roadmap vs. competitor features, flag gaps

Total: Agents A-C run in parallel (3 hours), then D and E run sequentially (2 hours) = 5 hours + 1 hour PM review = 6 hours total (50% time saved)

Agent offers:

I'll help you decompose your task. Describe your current process step-by-step, and I'll identify:

Which steps can be agent-handled

Which steps can run in parallel

Which steps require human judgment

User response: [Describe process]

Agent provides: Decomposed workflow with agent assignments.

---

Step 3: Design Parallel vs. Sequential Flows

Agent asks:

Now let's design the workflow topology—which agents run in parallel vs. sequentially.

Three Flow Patterns:

Pattern 1: Full Parallel (Fastest)

[Agent A] ─┐
[Agent B] ─┼─→ [PM Review] → [Decision]
[Agent C] ─┘

All agents run simultaneously

PM reviews all outputs together

Use when: Agents are independent (no dependencies between them)

Pattern 2: Pipeline (Sequential with Handoffs)

[Agent A] → [Agent B] → [Agent C] → [PM Review] → [Decision]

Each agent depends on previous agent's output

Use when: Later agents need earlier agents' results

Pattern 3: Hybrid (Parallel + Sequential)

[Agent A] ─┐
[Agent B] ─┼─→ [Agent D] → [Agent E] → [PM Review] → [Decision]
[Agent C] ─┘

Some agents run in parallel, feed into sequential agents

Use when: Early steps are independent, later steps synthesize

For your task, which pattern fits best?

Options:

Full Parallel — All agents are independent

Pipeline — Each agent needs the previous one's output

Hybrid — Mix of parallel and sequential

Not sure — [Agent analyzes your decomposition and recommends]

User response: [Selection]

Agent provides: Visual workflow diagram with agent dependencies.

---

Step 4: Define Agent Boundaries and Handoffs

Agent asks:

Now let's define what each agent knows (context boundaries) and how agents hand off to each other.

For each agent, define:

Agent Name & Purpose (What's its job?)

Context Needed (What information does it need?)

- Always-available (from context engineering)
- Retrieved on-demand (specific to this run)

Output Format (What does it produce?)

Handoff to Next Agent (What gets passed? What gets filtered?)

Example (Competitive Intelligence Orchestration):

Agent A: Competitor Research Agent

Purpose: Scrape 10 competitors' product pages, extract features

Context Needed:

- Always-available: List of competitors (from constraints registry)
- Retrieved: Competitor URLs (from database)

Output Format: Structured JSON: {competitor, features[], last_updated}

Handoff: Passes JSON to Agent D (Synthesis Agent)

Agent D: Synthesis Agent

Purpose: Compile findings from Agents A, B, C into structured report

Context Needed:

- Always-available: Report template, writing tone (from context workspace)
- Retrieved: Outputs from Agents A, B, C

Output Format: Markdown document with sections: Overview, Key Features, Pricing, Launch Activity

Handoff: Passes report to Agent E (Gap Analysis Agent)

Agent offers:

I'll help you define boundaries for each agent. For your workflow, let's define:

What context each agent needs (always-available vs. retrieved)

What format each agent produces (JSON, Markdown, structured data)

How agents hand off (what's passed vs. filtered)

User response: [Describe agent needs]

Agent provides: Complete agent boundary definitions + handoff specifications.

---

Step 5: Implement Strategic Intent Alignment

Agent asks:

To prevent agents from "going rogue," we need to feed them the correct mix of mission, constraints, and priorities.

Strategic Intent Checklist (Per Agent):

Mission: What is this agent's primary goal?

- Example: "Identify competitive threats that could impact Q2 roadmap"

Constraints: What must the agent NOT do?

- Example: "Do not recommend features outside our strategic focus areas"
- Example: "Do not scrape data from sites that prohibit it (check robots.txt)"

Priorities: If the agent must choose, what matters most?

- Example: "Prioritize features launched in last 30 days over older features"

Evidence Standards: What counts as valid information?

- Example: "Only cite information from official product pages, release notes, or verified blog posts"

Connection: This is context engineering applied to orchestration. See context-engineering-advisor for deeper guidance.

Agent offers:

For each agent in your workflow, let's define:

Mission (what's the goal?)

Constraints (what's out of bounds?)

Priorities (what matters most?)

Evidence standards (what counts as valid?)

User response: [Define strategic intent per agent]

Agent provides: Strategic intent document for each agent.

---

Step 6: Set Up Launch Control Tower Monitoring

Agent asks:

The Launch Control Tower provides real-time monitoring to flag gaps before they become critical failures.

What to Monitor (Three Dimensions):

1. Agent Performance:

Are agents completing tasks on time?

Are outputs meeting quality standards?

Are agents staying within token/cost budgets?

2. Organizational Readiness (If Launching a Feature):

Support readiness: Docs updated? Training complete? Escalation paths defined?

Marketing readiness: Messaging finalized? Assets created? GTM plan locked?

Operations readiness: Infrastructure scaled? Monitoring in place? Rollback plan ready?

3. Risk Flags:

Are agents producing unexpected outputs? (potential hallucination)

Are agents violating constraints? (ethical/compliance issues)

Are handoffs failing? (Agent B not receiving Agent A's output correctly)

Monitoring Approach:

Option 1: Manual Dashboard

Weekly PM review of agent outputs

Spot-check quality, compare to golden datasets

Manual risk flag identification

Option 2: Automated Monitoring

Agents log outputs to central dashboard

Automated evals run on each output (see Step 7)

Alerts triggered when quality drops below threshold

Option 3: Hybrid

Automated evals + weekly PM review

Alerts for critical issues, PM spot-checks others

Which monitoring approach fits your team's maturity?

Options:

Manual Dashboard (Lower maturity, smaller scale)

Automated Monitoring (Higher maturity, larger scale)

Hybrid (Recommended for most teams)

User response: [Selection]

Agent provides: Monitoring plan with specific metrics and alert thresholds.

---

Step 7: Create Evaluation Plan

Agent asks:

To ensure orchestrated workflows produce high-quality outputs, we need an evaluation framework.

The Four Eval Types (From Research):

Evaluation Process:

Collect Traces: Log inputs and outputs for each agent run

Review Weekly: Annotate traces to categorize failure modes

Build Failure Mode Taxonomy: Common errors (hallucination, constraint violation, low quality)

Create Automated Evals: Target common failure modes with Golden Datasets or Code Assertions

Iterate: Refine agent prompts/context based on eval results

For your workflow, which evals make sense?

Options:

Start with Golden Datasets — Create 20 examples of good outputs for each agent

Start with Code Assertions — Define structural rules (e.g., output must be valid JSON with required fields)

Start with Human Evals — PM reviews every output for first 2 weeks, identifies patterns

All three — Comprehensive eval strategy (recommended for critical workflows)

User response: [Selection]

Agent provides: Evaluation plan with specific eval types, frequencies, and success criteria.

---

Step 8: Implementation Plan & Next Steps

Agent synthesizes:

Here's your complete orchestrated workflow plan:

┌─────────────────────────────────────────────────────────────┐
│ ORCHESTRATED WORKFLOW: [Your Task Name]                    │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│ TOPOLOGY: [Full Parallel / Pipeline / Hybrid]              │
│                                                             │
│ AGENTS:                                                     │
│ • Agent A: [Name] - [Purpose]                              │
│ • Agent B: [Name] - [Purpose]                              │
│ • Agent C: [Name] - [Purpose]                              │
│                                                             │
│ FLOW:                                                       │
│ [Agent A] ─┐                                                │
│ [Agent B] ─┼─→ [Agent D] → [PM Review] → [Decision]        │
│ [Agent C] ─┘                                                │
│                                                             │
│ CONTEXT BOUNDARIES:                                         │
│ • Always-available: [List]                                  │
│ • Retrieved on-demand: [List]                               │
│                                                             │
│ STRATEGIC INTENT:                                           │
│ • Mission: [Per agent]                                      │
│ • Constraints: [Per agent]                                  │
│ • Priorities: [Per agent]                                   │
│                                                             │
│ MONITORING:                                                 │
│ • Approach: [Manual / Automated / Hybrid]                   │
│ • Metrics: [List]                                           │
│ • Alert thresholds: [List]                                  │
│                                                             │
│ EVALUATION:                                                 │
│ • Golden Datasets: [Y/N]                                    │
│ • Code Assertions: [Y/N]                                    │
│ • Human Evals: [Frequency]                                  │
│                                                             │
│ TIME SAVINGS:                                               │
│ • Manual (old): [X hours]                                   │
│ • Orchestrated (new): [Y hours]                             │
│ • Savings: [X-Y hours per week]                             │
└─────────────────────────────────────────────────────────────┘

Implementation Roadmap:

Week 1: Build Context Foundations

If not already done, complete context-engineering-advisor

Create constraints registry, operational glossary

Document strategic intent for each agent

Week 2: Implement First Agent

Start with simplest agent (usually research or data collection)

Test with 5 real examples

Validate output quality

Week 3: Add Remaining Agents

Implement agents 2-5 (depending on your workflow)

Test handoffs between agents

Validate full workflow end-to-end

Week 4: Set Up Monitoring & Evals

Implement chosen monitoring approach

Create Golden Datasets (if selected)

Run first week of human evals, identify failure modes

Week 5+: Iterate & Scale

Refine agent prompts based on eval results

Add automated evals targeting common failures

Scale to more use cases

Success Criteria:

✅ Time savings: 30%+ reduction in manual work

✅ Quality: Agent outputs meet quality bar 80%+ of time

✅ Consistency: Outputs follow template/format 95%+ of time

✅ Monitoring: Alerts catch issues before PM notices

✅ Evaluation: Failure mode taxonomy documented, automated evals in place

Agent offers:

Would you like me to:

Export this workflow plan as a Markdown document?

Provide implementation templates (agent prompt templates, monitoring dashboard, eval checklists)?

Recommend tools for building this orchestration (Claude Projects, custom APIs, orchestration platforms)?

---

Examples

Example 1: Competitive Intelligence Orchestration

Context:

PM at B2B SaaS company

Tracks 10 competitors

Manual process: 12 hours per week (research, synthesis, gap analysis)

Goal: Reduce to 6 hours with orchestrated workflow

Workflow Design:

Agents:

Agent A (Research): Scrapes competitors' product pages, extracts features

Agent B (Launch Tracker): Monitors release notes, blogs, social media for new launches

Agent C (Pricing Analyzer): Tracks pricing pages, identifies changes

Agent D (Synthesis): Compiles findings from A, B, C into structured report

Agent E (Gap Analysis): Compares our roadmap vs. competitors, flags strategic gaps

Topology: Hybrid (A, B, C in parallel → D → E → PM Review)

Strategic Intent:

Mission (Agent E): "Identify competitive threats that could impact Q2 roadmap"

Constraint (Agent E): "Do not recommend features outside our strategic focus areas (enterprise security, AI-powered analytics)"

Priority (Agent B): "Prioritize features launched in last 30 days"

Monitoring:

Hybrid approach: Automated evals + weekly PM review

Metrics: Agent completion time, output quality score (LLM-as-Judge)

Alert: If Agent E flags >5 critical gaps (potential strategic threat)

Evaluation:

Golden Datasets: 20 examples of well-synthesized competitive reports

Code Assertions: Output must be valid JSON with required fields (competitor, features[], pricing[], launch_date)

Human Evals: PM reviews one full workflow run per week

Result:

Time: 12 hours → 6 hours (50% savings)

Quality: Consistent format, no missed competitors

Strategic value: Gap analysis flags threats 2 weeks earlier than manual process

---

Example 2: Customer Feedback Synthesis

Context:

PM at consumer app

Receives 200+ pieces of feedback per week (app reviews, support tickets, NPS comments)

Manual process: 8 hours per week (reading, tagging, synthesizing themes)

Goal: Reduce to 2 hours with orchestrated workflow

Workflow Design:

Agents:

Agent A (Ingestion): Collects feedback from App Store, Google Play, Zendesk, NPS surveys

Agent B (Tagging): Tags feedback by category (bug, feature request, usability, performance)

Agent C (Sentiment): Classifies sentiment (positive, neutral, negative, critical)

Agent D (Theme Extraction): Identifies recurring themes across feedback

Agent E (Prioritization): Scores themes by frequency + sentiment intensity

Agent F (Synthesis): Generates weekly synthesis report with top 5 themes + example quotes

Topology: Pipeline (A → B → C → D → E → F → PM Review)

Strategic Intent:

Mission (Agent D): "Identify unmet customer needs that could become roadmap opportunities"

Constraint (Agent E): "Do not deprioritize critical bugs, even if infrequent"

Priority (Agent F): "Focus on themes affecting 10+ users in last 7 days"

Monitoring:

Automated: Dashboard shows agent completion status, error rate

Alerts: If Agent C flags >10 "critical" sentiment items (escalate to PM immediately)

Evaluation:

Golden Datasets: 50 examples of well-tagged, well-synthesized feedback

LLM-as-Judge: Weekly eval of Agent D's theme extraction quality

Human Evals: PM spot-checks 10% of tagged feedback

Result:

Time: 8 hours → 2 hours (75% savings)

Quality: Themes now backed by quantitative data (frequency, sentiment)

Strategic value: Identified 3 high-impact themes that became Q2 roadmap features

---

Example 3: Risk Analysis at Scale

Context:

PM at enterprise platform

Needs to analyze 50 features for risk (security, compliance, performance, usability)

Manual process: 15 hours (30 minutes per feature)

Goal: Reduce to 5 hours with orchestrated workflow

Workflow Design:

Agents:

Agent A (Security Risk): Analyzes feature for security vulnerabilities (data exposure, auth issues)

Agent B (Compliance Risk): Checks feature against regulatory requirements (GDPR, HIPAA, SOC2)

Agent C (Performance Risk): Estimates load impact, identifies scaling concerns

Agent D (Usability Risk): Flags complex workflows, accessibility issues

Agent E (Synthesis): Compiles risk scores, generates risk matrix

Topology: Full Parallel (A, B, C, D run simultaneously → E → PM Review)

Strategic Intent:

Mission (All agents): "Flag risks that could delay launch or harm customers"

Constraint (Agent B): "Must cite specific regulatory requirements (not vague warnings)"

Priority (Agent E): "Prioritize risks by impact × likelihood (standard risk matrix)"

Monitoring:

Automated: Dashboard shows risk distribution (low/medium/high/critical)

Alerts: If any feature scores "critical" risk (escalate to PM + leadership)

Evaluation:

Golden Datasets: 30 examples of well-analyzed features with known risks

Code Assertions: Risk scores must be {low, medium, high, critical}—no other values

Human Evals: Security team reviews Agent A outputs monthly

Result:

Time: 15 hours → 5 hours (67% savings)

Quality: Consistent risk scoring across all 50 features

Strategic value: Identified 3 critical risks that would have been missed in manual review

---

Common Pitfalls

1. Orchestrating Before Context Engineering

Failure Mode: Building agent workflows without context foundations (constraints, glossary, evidence standards).

Consequence: Agents produce inconsistent outputs, violate constraints, hallucinate.

Fix: Complete context-engineering-advisor first. Build constraints registry, operational glossary, strategic intent documents.

---

2. Over-Orchestrating Simple Tasks

Failure Mode: Creating complex multi-agent workflows for tasks that take <2 hours per week.

Consequence: Orchestration overhead (setup, monitoring, maintenance) exceeds time saved.

Fix: Only orchestrate tasks that take 5+ hours per week or require consistency at scale.

---

3. No Evaluation Plan

Failure Mode: "Set it and forget it"—agents run without quality checks.

Consequence: Quality drift over time, unnoticed hallucinations, constraint violations.

Fix: Implement Golden Datasets + weekly Human Evals at minimum. Build failure mode taxonomy, create automated evals.

---

4. Ignoring Handoff Failures

Failure Mode: Assuming agents will correctly pass data to each other without testing.

Consequence: Agent B receives malformed data from Agent A, produces garbage output.

Fix: Test handoffs explicitly. Validate data format at each handoff. Use Code Assertions to enforce structure.

---

5. Forgetting the &quot;PM Review&quot; Step

Failure Mode: Treating orchestrated workflows as fully autonomous—no human oversight.

Consequence: Agents make decisions that lack context, empathy, or strategic alignment.

Fix: Always include PM Review step. Agents generate hypotheses/recommendations; PM validates and decides.

---

References

Related Skills

context-engineering-advisor (Interactive) — Prerequisite: Build context foundations before orchestration

ai-shaped-readiness-advisor (Interactive) — Assesses Agent Orchestration maturity (Competency #2)

pol-probe-advisor (Interactive) — Vibe Coding connection (rapid prototyping)

discovery-process (Workflow) — Use orchestrated agents in discovery phase

External Frameworks

Dean Peters — The Product Manager as an Orchestrator (Productside research)

Dean Peters — Productside Blueprint (Four AI Management Workflows: Context Engineering, Synthetic Evals, Agentic Workflows, Vibe Coding)

Teresa Torres — Continuous Discovery Habits (5 AI PM disciplines: Context Engineering, Orchestration, Observability, Evals, Maintenance)

Marty Cagan — Empowered (4 big risks: Value, Usability, Feasibility, Viability)

Tools & Platforms

Claude Projects — Simple orchestration with multiple agents in one project

LangChain — Framework for building agent chains

LangGraph — State machine orchestration for complex workflows

n8n / Zapier — No-code workflow automation (simpler orchestrations)