OrchV2 - Context-Aware Agentic Orchestrator

This skill is the meta-orchestrator that intelligently routes product launches through optimal execution paths based on business context detection.

When to Use

Invoke this skill when:

•User says: "create a campaign plan", "what's the best approach", "recommend marketing strategy"
•User provides product details and asks for execution guidance
•User needs budget-optimized scenario recommendations
•User asks: "what will this cost?", "how long will this take?", "what do I need?"
•Beginning any multi-skill orchestration workflow
•Any skill needs to query execution context (recursive invocation)

When NOT to Use

•User already knows exact skills to run (use direct skill invocation)
•Single-skill execution tasks
•User wants to manually control every step without recommendations

What OrchV2 Does

1. Analyzes Product Context

Detects 6 business dimensions:

•Budget Tier: bootstrapped (<$5K), lean ($5-20K), standard ($20-100K), premium (>$100K)
•Launch Channel: Kickstarter, Indiegogo, DTC, SaaS, Enterprise
•Brand Maturity: pre-launch, launch-ready, growth, established
•Timeline Urgency: rushed (<2wks), standard (2-8wks), thorough (>8wks)
•Team Size: solo (1 person), small (2-5), agency (>5)
•Content Depth: minimal, standard, maximum

2. Recommends Scenarios

Generates ranked list of 6 pre-built scenarios:

•🏗️ Brand Genesis - Foundation-building ($4K, 1-2 days, 8 skills)
•🎯 Crowdfunding Lean - Budget Kickstarter ($12.5K, 2-3 days, 12 skills)
•🚀 Crowdfunding Full - Premium campaign ($28K, 4-5 days, 20 skills)
•🛒 Bootstrapped DTC - Organic launch ($8K, 1-2 days, 9 skills)
•🏢 Enterprise GTM - B2B SaaS ($45K, 5-7 days, 12 skills)
•⚙️ Custom Hybrid - Pick & choose with smart recommendations

3. Generates Execution Plans

For selected scenario:

•Ordered list of skills to execute
•Cost estimates (tokens + USD)
•Timeline projections (days)
•Deliverables breakdown (included/excluded)
•Platform-specific constraints

4. Optimizes for Budget

•Substitutes lean variants when over-budget
•Recommends upgrades when under-budget
•Explains cost-benefit tradeoffs
•Shows ROI estimates

Input Variables

Required

•
[PRODUCT] - One of:
- •Path to product.md file
- •Inline product description with brand name, category, description, audience

Optional (Auto-Detected)

•[BUDGET_AMOUNT] - USD budget available
•[LAUNCH_CHANNEL] - kickstarter|indiegogo|dtc|saas|enterprise
•[TIMELINE_WEEKS] - Weeks until launch
•[TEAM_COUNT] - Number of people on team
•[STAGE] - pre-launch|launch-ready|growth|established

Output Preferences

•[OUTPUT_FORMAT] - recommendations|plan|comparison (default: recommendations)
•[SCENARIO_ID] - Specific scenario to use (optional, auto-recommends if missing)
•[LIMIT] - Number of scenarios to return (default: 3)

The Protocol (4 Phases)

Phase 1: Context Detection (Steps 1-3)

Step 1: Parse Product Input

•Extract: brand name, category, positioning
•Identify product type: hardware, digital, service, physical goods
•Parse specifications if provided
•Extract target audience segments

Step 2: Detect Launch Context (if not explicit)

Budget Tier Detection:

code

IF budget_amount provided:
  < $5K → bootstrapped
  $5-20K → lean
  $20-100K → standard
  > $100K → premium
ELSE IF product_price available:
  < $50 → bootstrapped
  $50-200 → lean
  $200-500 → standard
  > $500 → premium
ELSE IF team_count available:
  1 person → bootstrapped
  2-5 people → lean/standard
  > 5 people → premium
ELSE:
  default: standard

Channel Detection:

code

Scan for keywords in category/messaging:
  "kickstarter", "crowdfunding", "backer" → kickstarter
  "indiegogo" → indiegogo
  "shopify", "dtc", "ecommerce" → dtc
  "saas", "subscription", "platform" → saas
  "enterprise", "b2b" → enterprise

IF hardware/wearable/gadget:
  default: kickstarter
ELSE IF software/app:
  default: saas
ELSE:
  default: dtc

Maturity Detection:

code

IF has_existing_brand=false AND has_existing_content=false:
  → pre-launch
ELSE IF has_existing_brand=true AND has_existing_content=false:
  → launch-ready
ELSE IF has_existing_brand=true AND has_existing_content=true:
  IF target_regions > 2:
    → established
  ELSE:
    → growth

Timeline Detection:

code

IF timeline_weeks < 2:
  → rushed
ELSE IF timeline_weeks <= 8:
  → standard
ELSE:
  → thorough

Fallback from budget:
  bootstrapped → rushed
  premium → thorough
  else → standard

Team Size Detection:

code

IF team_count = 1:
  → solo
ELSE IF team_count <= 5:
  → small
ELSE:
  → agency

Fallback from budget:
  bootstrapped → solo
  premium → agency
  else → small

Step 3: Explain Detection Logic For each dimension, state:

•Detected value
•Reasoning (which heuristic triggered)
•Confidence level: high (explicit data), medium (inferred), low (default)

Validation Gate 1:

•All 6 dimensions must have a value (even if default)
•Flag any low-confidence detections
•Suggest user confirm if >2 dimensions are low-confidence

Phase 2: Scenario Matching (Steps 4-6)

Step 4: Score All Scenarios (0-100% match)

Scoring Algorithm:

code

match_score = 0

# Budget alignment (50% weight)
IF budget_tier == scenario.best_for_budget:
  match_score += 50
ELSE IF abs(budget_tier_index - scenario_budget_index) == 1:
  match_score += 25  # Adjacent tier
ELSE:
  match_score += 0

# Channel alignment (30% weight)
IF channel IN scenario.best_for_channels:
  match_score += 30
ELSE IF scenario.best_for_channels is empty:
  match_score += 15  # Universal scenario
ELSE:
  match_score += 0

# Maturity alignment (20% weight)
IF maturity IN scenario.best_for_maturity:
  match_score += 20
ELSE IF scenario.best_for_maturity is empty:
  match_score += 10  # Universal scenario
ELSE:
  match_score += 0

# Return final score (0-100)

Step 5: Generate Pros/Cons for each scenario

Pros Logic:

code

IF match_score >= 80:
  + "Perfect match for your context"
IF budget matches:
  + "Budget aligned ($X,XXX)"
IF channel matches:
  + "Optimized for {channel}"
IF timeline fits:
  + "Timeline matches urgency ({timeline})"
IF features comprehensive:
  + "Complete asset package"

Cons Logic:

code

IF budget over:
  - "Would exceed budget by ${over_amount}"
IF budget under significantly:
  - "Under-utilizes budget (room for upgrades)"
IF wrong channel:
  - "Better suited for {other_channels}"
IF assumes assets user doesn't have:
  - "Assumes existing {missing_asset}"
IF excludes desired features:
  - "Excludes {feature}"

Step 6: Rank by Score (descending)

•Sort scenarios by match_score
•Take top N (default 3)
•Mark highest score as "RECOMMENDED"

Validation Gate 2:

•At least 1 scenario must score >50%
•If no good match, recommend "custom-hybrid" with explanation
•If top 3 scores are very close (<10% apart), flag as "multiple good options"

Phase 3: Cost Estimation (Steps 7-8)

Step 7: Calculate Costs for Top Scenarios

For each scenario:

python

total_tokens = 0
total_usd = 0
skill_breakdown = []

FOR each skill_id IN scenario.skill_ids:
  skill = registry.get_skill(skill_id)
  
  # Base token estimate
  base_tokens = skill.metadata.estimated_tokens
  
  # Apply depth multiplier
  depth_multipliers = {
    "surface": 0.5,
    "focused": 1.0,
    "comprehensive": 1.5,
    "exhaustive": 2.5
  }
  depth_mult = depth_multipliers[scenario.execution_context.depth_level]
  
  # Apply format overhead
  format_overhead = {
    "minimal": 500,
    "standard": 1500,
    "maximum": 3000
  }
  format_add = format_overhead[scenario.execution_context.output_format]
  
  # Calculate
  skill_tokens = int(base_tokens * depth_mult + format_add)
  skill_usd = int(skill_tokens * 0.25)  # $0.25 per 1K tokens
  
  total_tokens += skill_tokens
  total_usd += skill_usd
  
  skill_breakdown.append({
    "skill_id": skill_id,
    "skill_name": skill.name,
    "tokens": skill_tokens,
    "usd": skill_usd
  })

scenario.estimated_tokens = total_tokens
scenario.estimated_cost_usd = total_usd
scenario.cost_breakdown = skill_breakdown

Step 8: Calculate Budget Utilization

code

IF user_budget_amount provided:
  utilization = (estimated_cost / user_budget_amount) * 100
  
  IF utilization > 100:
    warning = f"Over budget by {utilization - 100}%"
  ELSE IF utilization < 70:
    suggestion = f"Under budget by {100 - utilization}%. Consider upgrades."
  ELSE:
    status = f"Good fit ({utilization}% of budget)"

Validation Gate 3:

•Per-skill cost should be 1K-15K tokens (flag if outside)
•Total cost should align with scenario.estimated_cost_usd ±20%
•Budget utilization should be reasonable (50-120%)

Phase 4: Output Generation (Steps 9-12)

Step 9: Generate Recommendations Output (if output_format = "recommendations")

Structure:

markdown

# Scenario Recommendations

## Detected Context
| Dimension | Value | Reasoning |
|-----------|-------|-----------|
| Budget    | lean  | Explicit budget $15K |
| Channel   | kickstarter | Keywords + hardware category |
| ...       | ...   | ... |

## Recommended Scenarios

### #1 - 🎯 Crowdfunding Lean ← RECOMMENDED
**Match Score:** 85%
**Description:** {scenario.description}
**Estimates:** 12 skills | $12,500 | 2-3 days
**Pros:**
- Perfect budget match
- Optimized for Kickstarter
**Cons:**
- Assumes existing brand identity
**Deliverables:** Campaign page, video script, ads, emails...

### #2 - ... (repeat for top 3)

## Next Steps
1. Review recommendations
2. Select scenario
3. Run: `python3 -m orchv2.cli.main plan --scenario <id>`

Step 10: Generate Execution Plan (if output_format = "plan")

Structure:

markdown

# Execution Plan: Crowdfunding Lean

## Scenario Overview
{Description, estimates, context}

## Execution Context
| Constraint | Value |
|------------|-------|
| Budget Tier | lean |
| Tone | conversion-focused, urgent |
| Depth | focused |
| ...

## Skills to Execute
1. Buyer Persona
   - Tokens: 5,000 | Cost: $1,250 | Time: ~8 min
   - Dependencies: None
   - Outputs: persona_name, voice_samples, emotional_drivers

2. Competitor Analysis
   - Tokens: 6,000 | Cost: $1,500 | Time: ~10 min
   - Dependencies: None
   - Outputs: market_gaps, verified_anxieties

... (repeat for all 12 skills)

## Cost Breakdown
| Skill | Tokens | USD |
|-------|--------|-----|
| Buyer Persona | 5,000 | $1,250 |
| ... | ... | ... |
| **TOTAL** | **50,000** | **$12,500** |

## How to Execute
```bash
python3 -m orchv2.cli.main run --scenario crowdfunding-lean

code


**Step 11: Generate Comparison Table** (if output_format = "comparison")

Structure:
```markdown
# Scenario Comparison

## Side-by-Side
| Metric | Crowdfund Lean | Crowdfund Full | Bootstrap DTC |
|--------|---------------|----------------|---------------|
| Skills | 12 | 20 | 9 |
| Cost | $12,500 | $28,000 | $8,000 |
| Timeline | 2-3 days | 4-5 days | 1-2 days |
| ... | ... | ... | ... |

## Deliverables Matrix
| Deliverable | Lean | Full | DTC |
|-------------|------|------|-----|
| Campaign Page | ✅ | ✅ | ✅ |
| Video Script | ⚡ | ✅ | ❌ |
| ... | ... | ... | ... |

Legend: ✅ Full | ⚡ Lean | ❌ Not included

## Recommendation: Crowdfunding Lean (85% match)
{Reasoning}

Step 12: Generate JSON Metadata Block

All outputs must include:

json

{
  "meta": {
    "orchestrator_version": "2.0.0",
    "product_name": "...",
    "detected_context": {
      "budget_tier": "lean",
      "launch_channel": "kickstarter",
      "maturity_stage": "pre-launch",
      "timeline_urgency": "standard",
      "team_size": "small"
    },
    "generated_at": "2026-01-20T18:30:00Z"
  },
  "recommendations": [
    {
      "rank": 1,
      "scenario_id": "crowdfunding-lean",
      "match_score": 0.85,
      "estimated_cost_usd": 12500,
      "estimated_tokens": 50000,
      "timeline_days": "2-3",
      "skills": ["buyer-persona", "competitor-analysis", ...]
    },
    // ... top 3 scenarios
  ]
}

Validation Gate 4:

•Output includes all required sections
•JSON is valid and complete
•Cost estimates are present
•Reasoning is clear and actionable

Output Templates

Generate output using one of three templates:

•recommendations.md - Top 3 scenarios with match scores, pros/cons
•execution-plan.md - Detailed plan for selected scenario with cost breakdown
•scenario-comparison.md - Side-by-side table of multiple scenarios

(See templates/ directory for full templates)

Self-Reference Pattern

OrchV2 can be invoked recursively for context queries:

Example: Campaign Copy Skill Queries OrchV2

code

Step 1: campaign-page-copy skill starts execution
Step 2: Skill needs to know: "Am I in lean or premium mode?"
Step 3: Skill invokes: query_orchv2("execution_context")
Step 4: OrchV2 returns:
{
  "budget_tier": "lean",
  "tone": "conversion-focused, urgent",
  "depth_level": "focused",
  "output_format": "standard",
  "token_limit": 5000
}
Step 5: Skill adapts output accordingly

Context Queries Supported:

•execution_context - Returns ExecutionContext object
•am_i_over_budget(tokens_used) - Returns boolean + remaining budget
•what_scenario - Returns current scenario_id
•what_quality_bar - Returns quality_bar setting
•platform_constraints - Returns list of platform-specific rules

This creates a context-aware agent mesh where any skill can query the orchestrator.

Quality Guardrails

•Always explain detection - Don't just say "lean budget", explain WHY
•Surface uncertainty - Flag low-confidence detections with ⚠️
•Provide alternatives - Show top 3, not just #1
•Explain tradeoffs - Clear pros/cons for each
•Cost transparency - Always show estimates
•Validate assumptions - Ask user to confirm if confidence <medium

Error Handling

Condition	Action
Product data missing	Ask for minimum: brand name + category
Context undetectable	Use defaults + flag low confidence
No scenario >50% match	Recommend custom-hybrid + explain why
Budget too low	Suggest brand-genesis-lean OR increasing budget
Skills registry empty	Fallback to V1 orchestrator skill list

CLI Invocation

bash

# Context analysis
python3 -m orchv2.cli.main analyze-context --product product.md

# Get recommendations
python3 -m orchv2.cli.main recommend --limit 3

# Generate plan
python3 -m orchv2.cli.main plan --scenario crowdfunding-lean

# Compare scenarios
python3 -m orchv2.cli.main compare --scenarios crowdfunding-lean,crowdfunding-full

Python API

python

from orchv2 import ContextAnalyzer, ScenarioRecommender, SkillsRegistry

# Load product
product = load_product("product.md")

# Analyze context
analyzer = ContextAnalyzer()
context = analyzer.analyze(product)

# Get recommendations
recommender = ScenarioRecommender()
matches = recommender.recommend(product, context, limit=3)

# Generate plan
scenario = recommender.get_scenario(matches[0].scenario_id)
registry = SkillsRegistry()
cost = registry.estimate_total_cost(scenario.skill_ids)

print(f"Recommended: {scenario.name}")
print(f"Cost: ${cost['total_usd']:,}")

Integration & Technical Specs

•ID: orchv2
•Version: 2.0.0
•Category: Meta-Orchestration / Strategy
•Complexity: High (coordinates 64+ skills)
•Estimated Tokens: 2,000-5,000 (orchestration overhead only)
•Execution Time: 30-60 seconds (analysis + recommendations)
•Dependencies: None (root-level skill)
•Downstream: All 64 skills can reference orchv2 for context

Metadata

json

{
  "skill_id": "orchv2",
  "version": "2.0.0",
  "source": "both",
  "estimated_tokens": 2000,
  "complexity": "high",
  "quality_tier": "premium",
  "can_run_parallel": true,
  "supports_scenarios": ["all"],
  "provides_context": true,
  "recursive_invocation": true
}