orchestr8

Autonomous software development workflows with 95% less context usage

Stop loading everything. Start loading exactly what you need, when you need it.

What's New • Features • Quick Start • Web Dashboard • Documentation

🎉 What's New in v8.0

Comprehensive 3-Phase Optimization Completed

We've completed a major overhaul that achieved 80,000+ tokens saved across all resources while dramatically improving discoverability and organization.

Key Achievements:

383 Resources Indexed (up from 323, +18.6% growth)
207+ Cross-References added for improved navigation
77 New Example Files extracted for better reusability
Token Efficiency: 52-83% savings in real-world usage

Phase 1: Example Extraction

37 files optimized with code examples moved to dedicated fragments
~45,000 tokens saved through example externalization
77 new example files created with orchestr8:// URI references
Improved resource reusability and maintenance

Phase 2: Structural Organization

6 skill families created (Performance, Security, Testing, Observability, IaC, Error Handling)
9 pattern families organized (Event-Driven, Database, Architecture, etc.)
42 resources reorganized with hierarchical structure
207+ cross-references added for seamless navigation
~4,145 tokens net savings

Phase 3: Progressive Loading

2 major agents split into core + advanced modules (Python, Rust)
5 workflows enhanced with JIT loading (78% average token reduction)
7 resources documented with progressive loading strategies
Token efficiency: 52-83% savings in typical usage patterns

Updated Statistics

Total Resources: 383 fragments
Domain Experts: 147+ specialized agents
Reusable Skills: 90+ proven techniques
Design Patterns: 25+ architectural patterns
Ready-to-Use Examples: 77+ implementation samples
useWhen Scenarios: 1,675 automated matching scenarios
Indexed Keywords: 4,036 unique search terms

Token Efficiency in Action

JIT Loading: 77-83% reduction in workflow token usage
Progressive Loading: 52-82% savings for complex agents
Example Extraction: ~45,000 tokens saved overall
Total Impact: 80,000+ tokens saved across all resources

🎯 What is orchestr8?

I spent six months watching AI agents waste tokens loading knowledge they'd never use.

The breakthrough? Just-in-time expertise.

orchestr8 is a Claude Code plugin that transforms AI-assisted development through intelligent resource loading via Model Context Protocol (MCP). Instead of cramming 200KB of knowledge into every conversation, it loads a lightweight 2KB catalog—then dynamically fetches exactly what's needed.

The result? 95-98% token reduction. Faster responses. Better conversations. Zero wasted context.

Why This Matters

Traditional approach loads everything upfront:

All TypeScript patterns: 15KB
All database guides: 10KB
All security practices: 8KB
Total waste: ~11,000 tokens before you've even started

orchestr8 loads on-demand:

Lightweight registry: 250 tokens
Matched expertise: 800 tokens
Total used: ~1,050 tokens — only what you need

That's 90% savings on every single workflow.

✨ Features

The orchestr8 Difference

Traditional vs orchestr8 Comparison

What makes orchestr8 different:

| Traditional Approach | orchestr8 Approach | Impact | |---------------------|-------------------|---------| | Load all resources upfront | Query lightweight registry | 95% token reduction | | Static expertise bundles | Dynamic semantic matching | 40% more relevant | | Manual resource selection | Automatic fuzzy matching | Sub-15ms discovery | | Single knowledge source | Multi-provider (Local + AITMPL + GitHub) | 400+ community resources | | Context window struggles | Composable micro-fragments | 10-20% usage vs 85-95% |

Core Capabilities

🔍 Dynamic Resource Matching Semantic fuzzy matching finds relevant expertise automatically based on queries, tags, and capabilities. 1,675 useWhen scenarios and 4,036 indexed keywords ensure precision.

⚡ Multi-Source Providers

Local: Your custom private resources (fastest, offline-capable)
AITMPL: 400+ community components (proven patterns)
GitHub: Your team/company repositories (version-controlled)

🎯 JIT Loading & Progressive Assembly Workflows load ~2KB upfront, fetch 50KB+ on-demand. Registry-first architecture with four optimization modes:

index: 200-500 tokens (95-98% reduction)
minimal: 300-500 tokens (ultra-compact JSON)
catalog: 1,500-2,000 tokens (full metadata)
full: Complete content when you need it

NEW: Progressive Loading enables 52-83% token savings by loading core modules first, then advanced features only when needed.

🤖 Expert AI Agents (147+ Total) Specialized domain experts for TypeScript, Python, Go, Rust, React, FastAPI, and more—loaded dynamically based on your project. New modular architecture splits complex agents into core + advanced modules.

🧩 Resource Fragments (383 Total) Composable knowledge pieces organized into families:

Skills: 90+ reusable techniques with hierarchical families
Patterns: 25+ architectural patterns with 207+ cross-references
Examples: 77+ ready-to-use implementation samples
Guides: Step-by-step implementation instructions

💨 Smart Caching LRU cache with configurable TTL: 1hr for prompts, 4-7 days for resources. Sub-millisecond response on cache hits.

🔥 Hot Reload Watch mode with automatic reload during development. Instant feedback loop.

📊 Health Monitoring Real-time provider health, statistics dashboard, and comprehensive observability.

Token Optimization in Action

Token Usage Comparison

Real-world example:

Task: Build TypeScript REST API with JWT authentication

Without orchestr8:
- Load all TypeScript resources: 15KB
- Load all API patterns: 12KB
- Load all security guides: 8KB
- Load all database patterns: 10KB
Total: 45KB (~11,250 tokens) 😱

With orchestr8 (progressive loading):
- Query registry: 250 tokens
- Load typescript-core agent: 600 tokens
- Load security-auth-jwt skill: 400 tokens
- JIT fetch express-jwt-auth example: 350 tokens
Total: ~1,600 tokens ✅

Savings: 86% reduction! 🚀

With v8.0 optimizations:
- 77 extracted examples reduce duplication
- 207+ cross-references improve navigation
- Progressive loading defers advanced features
- Result: Even more efficient context usage

🚀 Quick Start

Prerequisites

Claude Code (latest version)
Node.js ≥ 18.0.0 (manual installation only)
npm ≥ 9.0.0 (manual installation only)

Installation

Option 1: Plugin Marketplace (Recommended)

The easiest way to get started:

# Step 1: Add the orchestr8 marketplace
/plugin marketplace add seth-schultz/orchestr8

# Step 2: Install the orchestr8 plugin
/plugin install orchestr8@seth-schultz

# Step 3: Verify installation
/help
# You should see /orchestr8:* commands listed

Interactive Installation:

/plugin
# Select "Browse Plugins" → Search for "orchestr8" → Click "Install"

Plugin Management:

# Enable/disable
/plugin enable orchestr8@seth-schultz
/plugin disable orchestr8@seth-schultz

# Uninstall
/plugin uninstall orchestr8@seth-schultz

Option 2: Manual Installation

For development or contributing:

# Clone and build
git clone https://github.com/seth-schultz/orchestr8.git
cd orchestr8/plugins/orchestr8
npm install
npm run build
npm test

# Link to Claude Code settings (.claude/settings.json)
{
  "mcpServers": {
    "orchestr8": {
      "command": "node",
      "args": ["/absolute/path/to/orchestr8/plugins/orchestr8/dist/index.js"]
    }
  }
}

Team Configuration

For teams, add to .claude/settings.json for automatic installation:

{
  "plugins": {
    "marketplaces": ["seth-schultz/orchestr8"],
    "installed": ["orchestr8@seth-schultz"]
  }
}

Your First Workflow

# In Claude Code, try this:
/orchestr8:new-project Build a TypeScript REST API with JWT authentication

# What happens:
# 1. ✅ Matches relevant resources (typescript-developer, security-auth-jwt)
# 2. ✅ Loads only needed fragments (~2KB total)
# 3. ✅ Assembles complete implementation plan
# 4. ✅ Provides step-by-step guidance

# Total tokens used: ~2,000 vs traditional ~11,000 (82% savings!)

Workflow Execution Flow

Workflow Flow Diagram

Available Commands

| Command | Purpose | Wh

Orchestr8

Install / Use

README