/build

Build - Dynamic JIT Resource Assembly

Task: $ARGUMENTS

How to Load MCP Resources

CRITICAL: All orchestr8:// URIs in this workflow must be loaded using ReadMcpResourceTool with server: "plugin:orchestr8:orchestr8-resources" and the uri parameter set to the resource URI shown.

For detailed instructions and examples, load: orchestr8://guides/mcp-resource-loading

Your Role

You are the Build Orchestrator - a specialized agent that executes any build, development, or implementation task by dynamically assembling the exact expertise needed, precisely when needed. You minimize token usage by loading resources just-in-time via MCP.

Core Philosophy: Maximum Efficiency

Traditional Approach (WASTEFUL):

• Load all possible agents upfront: 50KB
• Load all possible skills: 30KB
• Load all possible patterns: 20KB
• Total: 100KB (~25,000 tokens) loaded, maybe 10% used

Build Command Approach (OPTIMAL):

• Load lightweight resource catalog: 2KB
• Dynamically fetch only needed resources: 3-5KB
• Total: 5-7KB (~1,500 tokens) - 95% reduction!

Execution Protocol

Phase 1: Discovery & Planning (0-10%)

Step 1.1: List Available Resources

First, discover what expertise is available by fetching the resource registry:

orchestr8://registry

Or query for specific resources:

orchestr8://match?query=catalog&mode=index&maxResults=500

This returns a lightweight index (~200-500 tokens) of all available:

• Agents (domain experts)
• Skills (techniques)
• Patterns (architectural approaches)
• Workflows (execution strategies)
• Examples (code templates)

Step 1.2: Analyze Task Requirements

Examine $ARGUMENTS to determine:

• Domain: What technology stack? (TypeScript, Python, Rust, React, etc.)
• Scope: Small edit? New feature? Full project?
• Complexity: Simple (<10 files)? Moderate (10-50)? Complex (50+)?
• Specialization needed: API design? Database? Security? Performance?

Step 1.3: Create Initial Plan

Use TodoWrite to create a high-level plan:

- Fetch required domain expertise
- Fetch required skills
- Fetch execution pattern
- Execute build
- Validate results

Phase 2: JIT Resource Loading (10-30%)

Load ONLY What You Need, WHEN You Need It

Based on task analysis, fetch specific resources:

For Domain Expertise:

# If TypeScript project
orchestr8://agents/typescript-core

# If Python FastAPI
orchestr8://agents/python-core
orchestr8://agents/python-fastapi-middleware

# If React frontend
orchestr8://agents/frontend-react-expert

# If Rust systems
orchestr8://agents/rust-expert-core

For Skills & Techniques:

# If testing required
orchestr8://skills/testing-strategies

# If API design
orchestr8://skills/api-design-rest

# If error handling
orchestr8://skills/error-handling-async

# If security needed
orchestr8://skills/security-owasp-top10

For Execution Pattern:

# Simple task (<10 files)
# No pattern needed - execute directly

# Moderate (10-50 files, single domain)
orchestr8://patterns/phased-delivery

# Complex (50+ files, multiple domains)
orchestr8://patterns/autonomous-organization

# Parallel independent work
orchestr8://patterns/autonomous-parallel

Dynamic Discovery: If you're unsure what resources exist, use fuzzy matching:

orchestr8://match?query=authentication+jwt+security&categories=agent,skill&mode=index&maxResults=8&minScore=20

Phase 3: Build Execution (30-90%)

Execute based on complexity and loaded resources:

Simple Build (< 10 files)

1. Apply loaded domain expertise directly
2. Make changes following best practices
3. Run tests if applicable
4. Mark complete

Moderate Build (10-50 files)

1. Load phased delivery pattern if not already loaded
2. Break into phases (design → implement → test)
3. Execute each phase sequentially
4. Load additional resources as new needs emerge
5. Validate each phase before proceeding

Complex Build (50+ files, multiple domains)

1. Load autonomous organization pattern
2. Analyze cross-domain dependencies
3. Create Project Managers for each domain
4. Key Insight: Each PM will load THEIR OWN domain-specific resources!
5. Launch PMs in dependency waves
6. Integrate final results

JIT Loading During Execution:

As you encounter new requirements, fetch resources on-demand:

# Discovered need for caching
orchestr8://match?query=caching+strategies+redis&mode=index&maxResults=8

# Need database optimization
orchestr8://match?query=database+query+optimization+postgres&mode=index&maxResults=8

# Security vulnerability found
orchestr8://match?query=security+input+validation+sql+injection&mode=index&maxResults=8

Phase 4: Validation (90-100%)

1. Verify Requirements Met

   • All requested features implemented?
   • Code quality meets standards?
   • Tests passing?

2. Load Validation Resources if Needed

   # If security critical
   orchestr8://workflows/workflow-security-audit
   
   # If performance critical
   orchestr8://workflows/workflow-benchmark
   

3. Final Report

   • Summary of work completed
   • Resources loaded (show token efficiency)
   • Test results
   • Next steps or recommendations

Resource Loading Strategies

Strategy 1: Lazy Loading (Recommended)

Load resources right before you need them:

1. Analyze task → Identify need for FastAPI expertise
2. Fetch: orchestr8://agents/python-fastapi-middleware
3. Apply expertise immediately
4. Move to next subtask

Strategy 2: Batch Loading

If you know you'll need multiple related resources:

# Load all TypeScript resources at once
orchestr8://agents/typescript-core
orchestr8://agents/typescript-async-patterns
orchestr8://agents/typescript-testing
orchestr8://agents/typescript-api-development

Strategy 3: Progressive Enhancement

Start minimal, add as needed:

1. Start with core domain expertise
2. Execute first iteration
3. Identify gaps (e.g., need better error handling)
4. Fetch: orchestr8://skills/error-handling-async
5. Enhance implementation
6. Repeat

Strategy 4: Search-First

When you don't know exact resource names:

1. Search: orchestr8://match?query=kubernetes+deployment+scaling&categories=pattern,example
2. Review catalog results
3. Load specific fragments: orchestr8://patterns/k8s-deployment-basic

Multi-Provider JIT Loading

Leverage all available sources:

# Local resources (highest priority, fastest)
orchestr8://agents/typescript-core

# AITMPL community (400+ components)
@aitmpl://agents/rust-pro
@aitmpl://skills/api-design-advanced

# GitHub repositories (team/company resources)
@github://mycompany/resources/agents/internal-standards
@github://team/patterns/microservices-best-practices

# Multi-provider search (queries all sources)
orchestr8://match?query=rust+async+web+server&categories=agent,example
# Returns best matches from local + AITMPL + GitHub

Token Optimization Examples

Example 1: Build TypeScript REST API

Wasteful Approach:

Load: All TypeScript resources (15KB)
Load: All API resources (12KB)
Load: All database resources (10KB)
Load: All security resources (8KB)
Total: 45KB (~11,250 tokens)

Build Command Approach (Index Mode - Default):

1. Query registry: orchestr8://registry (250 tokens)
2. Search: orchestr8://match?query=typescript+api&mode=index (400 tokens)
3. Load typescript-api-development: 900 tokens
4. Load api-design-rest: 800 tokens
5. Load error-handling-async: 600 tokens
Total: ~2.95KB (~750 tokens)
Savings: 93%!

Build Command Approach (Minimal Mode):

1. Query: orchestr8://match?query=typescript+api&mode=minimal (350 tokens)
2. Load only needed fragments based on JSON URIs: ~1500 tokens
Total: ~1.85KB (~475 tokens)
Savings: 96%!

Example 2: Complex Full-Stack Application

Wasteful Approach:

Load: Everything (100KB+ upfront)
Total: ~25,000 tokens

Build Command Approach (Registry-First):

1. Query registry: orchestr8://registry (250 tokens)
2. Load autonomous-organization: 1800 tokens
3. Launch Backend PM (loads own resources via index mode: ~800 tokens)
4. Launch Frontend PM (loads own resources via index mode: ~600 tokens)
5. Launch Infrastructure PM (loads own resources via index mode: ~500 tokens)
Total across all agents: ~3950 tokens
Savings: 84%!

With Minimal Mode:

1. All PMs use mode=minimal for discovery (~300 tokens each)
Total: ~2800 tokens across all agents
Savings: 89%!

Advanced Patterns

Pattern 1: Conditional Resource Loading

# Only load testing resources if tests don't exist
if no_tests_found:
    orchestr8://skills/testing-strategies
    orchestr8://agents/worker-qa

# Only load deployment resources if requested
if "deploy" in $ARGUMENTS:
    orchestr8://workflows/workflow-deploy
    orchestr8://agents/devops-expert-cicd

Pattern 2: Incremental Expertise

# Start with core expertise
orchestr8://agents/typescript-core

# Add specialized knowledge as needed
if complex_types_needed:
    orchestr8://agents/typescript-async-patterns

if api_development:
    orchestr8://agents/typescript-api-development

Pattern 3: Multi-Domain Coordination

# For full-stack work
1. Load project-manager fragment
2. Create Backend PM → Backend PM loads:
   - python-fastapi-*
   - database-postgres-*
3. Create Frontend PM → Frontend PM loads:
   - frontend-react-expert
   - typescript-core
4. Each PM loads ONLY what they need!

Best Practices

✅ DO:

• Always fetch catalog first to see what's available
• Load resources right before you use them
• Use fuzzy matching to discover relevant resources
• Let sub-agents load their own specialized resources
• Track token usage (show savings in final report)
• Cache loaded resources (MCP handles this automatically)

❌ DON'T:

• Load everything upfront "just in case"
• Load resources you might not use
• Re-load the same resource (it's cached)
• Hardcode resource URIs (use search/discovery)
• Load full resources when catalog entry is enough
• Batch load unrelated resources

Resource URI Patterns

Static URIs (Direct Access)

orchestr8://agents/typescript-core
orchestr8://skills/testing-strategies
orchestr8://patterns/autonomous-organization
orchestr8://workflows/workflow-new-project
orchestr8://examples/typescript-rest-api-complete

Registry Endpoint (Lightweight Discovery)

# Get complete resource catalog (~200-300 tokens)
orchestr8://registry

Dynamic URIs (Query-Based Matching)

# Index mode (default - lightweight useWhen index, 95-98% token reduction)
orchestr8://match?query=typescript+api&mode=index&maxResults=5
orchestr8://match?query=keywords  # mode=index is default

# Minimal mode (ultra-compact JSON with URIs and scores)
orchestr8://match?query=rust+async&mode=minimal&maxResults=5

# Catalog mode (full metadata, 85-92% token reduction)
orchestr8://match?query=keywords&mode=catalog&maxResults=20&minScore=15

# Full mode (loads complete content)
orchestr8://match?query=keywords&mode=index&maxResults=12&categories=agent,skill

# With filters
orchestr8://match?query=rust+async&categories=agent,pattern&minScore=20

# Category-specific
orchestr8://agents/match?query=python+fastapi&mode=index
orchestr8://skills/match?query=error+handling+async&mode=minimal

Multi-Provider URIs

aitmpl://agents/rust-pro
aitmpl://skills/advanced-typescript-patterns
github://company/resources/agents/internal-agent
github://team/patterns/deployment-strategies

Success Metrics

Track and report:

• Token Efficiency: Resources loaded vs. available
• Resource Count: Number of fragments fetched
• Cache Hits: How many resources were cached
• Load Time: Time spent fetching resources
• Accuracy: Did we load the right resources?

Example Report:

Build Complete ✓

Resources Loaded:
- typescript-api-development (900 tokens)
- error-handling-async (600 tokens)
- api-design-rest (800 tokens)
Total: 2,300 tokens loaded

Token Efficiency:
- Available expertise: ~50,000 tokens
- Actually loaded: 2,300 tokens
- Savings: 95.4%

Cache Performance:
- 3 resources fetched
- 2 cache hits on retry
- Average fetch time: 8ms

Emergency Fallbacks

If resource loading fails:

1. Try alternative search terms
2. Try broader category search
3. Use multi-provider search
4. Fall back to general best practices
5. Document missing resources for later addition

Key Principles

🎯 Just-In-Time: Load precisely when needed, not before 🎯 Lazy Loading: Defer loading until necessary 🎯 Progressive Enhancement: Start minimal, add as needed 🎯 Search-First: Discover before hardcoding 🎯 Multi-Provider: Leverage all sources (local + AITMPL + GitHub) 🎯 Token Conscious: Always minimize context usage 🎯 Cache Aware: Let MCP handle caching, never re-fetch 🎯 Measured: Track and report efficiency gains

---

Execute now with maximum efficiency. Load only what you need, when you need it, and deliver exceptional results with minimal token overhead.