orchestr8 — Summary

Slug: orchestr8
GitHub: https://github.com/seth-schultz/orchestr8
Stars: 65
License: MIT
Language: TypeScript (Node.js 18+)
Version: 8.0.6 (README: v8.0.0-rc3)
Status: Active (last commit 2026-05-02)

What It Is

orchestr8 is a Claude Code plugin that provides Just-In-Time (JIT) knowledge loading via MCP. It is NOT an execution orchestrator — it is a resource discovery and context management system.

The core insight: "Stop loading everything. Start loading exactly what you need, when you need it."

Instead of loading 200KB of knowledge upfront, orchestr8 loads a 2KB catalog, then dynamically fetches exactly the resources needed for the current task.

Key claim: 95-98% token reduction vs. loading all resources upfront.

Resource Library (v8.0)

• 383 total resources indexed
• 154 agent resources (domain experts: TypeScript, Python, Go, Rust, React, FastAPI, etc.)
• 103 skill resources (techniques: testing, security, error handling, etc.)
• 36 workflow templates (adaptive, parallel, phased, etc.)
• 32 pattern resources (architectural patterns, organized into families)
• 31+ example files (extracted code examples)
• 77 additional example fragments (code example library)
• 1,675 useWhen scenarios (automatic matching)
• 4,036 indexed keywords (search terms)
• 207+ cross-references between resources

What It Is NOT

orchestr8 is NOT:

• An agent runner or execution orchestrator
• A task management system
• A multi-agent coordinator
• A workflow engine

Resources (agents, skills, patterns) are knowledge fragments loaded into Claude's context, not active processes.

Primary Entry Point

/now command — the only slash command. Loads the resource catalog, semantically matches relevant expertise, then dynamically fetches what's needed.

Three Resource Providers

1. Local — custom private resources (offline-capable)
2. AITMPL — 400+ community components (api.aitmpl.com)
3. GitHub — team/company repositories (version-controlled)

orchestr8 — Overview

Origin and Positioning

Created by Seth Schultz. Website: https://orchestr8.dev

From the README: "I spent six months watching AI agents waste tokens loading knowledge they'd never use. The breakthrough? Just-in-time expertise."

The JIT Loading Problem

Traditional approach:

All TypeScript patterns: 15KB
All database guides: 10KB
All security practices: 8KB
Total waste: ~11,000 tokens (before starting)

orchestr8 approach:

Lightweight registry: 250 tokens
Matched expertise: 800 tokens
Total: ~1,050 tokens (only what's needed)
Result: 90% savings

v8.0 Three-Phase Optimization

The v8.0 release completed a major optimization initiative:

Phase 1 — Example Extraction: 37 files optimized, ~45,000 tokens saved, 77 new example fragments with orchestr8:// URI references.

Phase 2 — Structural Organization: 6 skill families (Performance, Security, Testing, Observability, IaC, Error Handling), 9 pattern families (Event-Driven, Database, Architecture, etc.), 207+ cross-references.

Phase 3 — Progressive Loading: 2 major agents split into core + advanced modules (Python, Rust), 5 workflows enhanced with JIT loading (78% average token reduction), 52-83% savings in typical usage.

Index Modes

Four optimization modes for resource loading:

AITMPL Community Registry

orchestr8 connects to api.aitmpl.com — a community registry of 400+ agent/skill/workflow components. This gives any Claude Code install access to community-contributed expertise fragments without a separate install.

Security: SHA Verification

CHECKSUMS.txt.asc     — GPG-signed checksums
ORCHESTR8_PUBLIC_KEY.asc — Public key for verification
verify_all_shas.sh    — Verification script
verify_shas.py        — Python verification script

Resources can be verified against published checksums. Unique security posture for a Claude Code plugin.

orchestr8 — Architecture

Distribution

• Install: /plugin marketplace add seth-schultz/orchestr8 (Claude Code Marketplace)
• Manual: Clone + npm install + configure .orchestr8rc.json
• Type: Claude Code plugin (plugin.json + MCP server)

Repo Structure

orchestr8/
├── .claude-plugin/
│   └── marketplace.json        # Marketplace registration
├── plugins/orchestr8/
│   ├── .claude-plugin/
│   │   └── plugin.json         # Plugin.json with MCP server
│   ├── commands/               # 40 slash commands
│   │   └── now.md              # Primary entrypoint
│   ├── dist/
│   │   └── index.js            # Compiled MCP server (Node.js)
│   ├── src/                    # TypeScript MCP server source
│   ├── resources/
│   │   ├── .index/             # Resource indexes
│   │   │   ├── keyword-index.json
│   │   │   ├── quick-lookup.json
│   │   │   └── usewhen-index.json
│   │   ├── agents/             # 154 domain expert fragments
│   │   ├── skills/             # 103 technique fragments
│   │   ├── workflows/          # 36 workflow templates
│   │   ├── patterns/           # 32 architectural patterns
│   │   └── examples/           # 31+ example files
│   ├── prompts/                # MCP prompts
│   ├── .orchestr8rc.example.json  # Config template
│   └── CHECKSUMS.txt.asc       # GPG-signed checksums
├── verify_all_shas.sh
└── verify_shas.py

MCP Server

"orchestr8-resources": {
  "command": "node",
  "args": ["${CLAUDE_PLUGIN_ROOT}/dist/index.js"],
  "env": {
    "PROMPTS_PATH": "${CLAUDE_PLUGIN_ROOT}/prompts",
    "RESOURCES_PATH": "${CLAUDE_PLUGIN_ROOT}/resources",
    "CACHE_SIZE": "100",
    "LOG_LEVEL": "info",
    "NODE_ENV": "production"
  }
}

Resource URI Scheme

All resources addressable via orchestr8:// URIs:

orchestr8://agents/typescript-expert
orchestr8://skills/jwt-authentication
orchestr8://patterns/event-driven-architecture
orchestr8://workflows/build-rest-api
orchestr8://guides/mcp-resource-loading

Loaded via ReadMcpResourceTool with server: "plugin:orchestr8:orchestr8-resources".

Caching Architecture

LRU cache with configurable TTL:

• Prompts: 1 hour TTL
• Resources: 4-7 days TTL
• Cache size: 100 entries (configurable via CACHE_SIZE env)
• Cache hit: sub-millisecond response

Config: .orchestr8rc.json

Three resource providers, each independently configured:

{
  "resourceProviders": {
    "aitmpl": {
      "enabled": true,
      "apiUrl": "https://api.aitmpl.com",
      "cacheTTL": 3600000,
      "categories": ["agents", "skills", "workflows", "patterns", "examples"],
      "rateLimit": { "requestsPerMinute": 60 }
    },
    "github": {
      "enabled": false,
      "repos": ["username/repo1"],
      "branch": "main",
      "auth": { "token": "ghp_...", "type": "personal" }
    },
    "custom": {
      "enabled": false,
      "endpoints": [{ "name": "my-api", "url": "https://..." }]
    }
  }
}

Config priority: env vars > project config > user config > defaults

Index Architecture

Three index files power resource discovery:

orchestr8 — Components

Commands (40 slash commands)

Agent Resources (154)

Domain expert fragments. Examples by category:

AI/ML: ai-ml-engineer-core, ai-ml-engineer-nlp, ai-ml-engineer-computer-vision, ai-ml-mlops, ai-ml-engineer-llm-specialist, ai-ml-engineer-recommendation-systems

Cloud: aws-specialist, azure-specialist, gcp-specialist, cloudflare-specialist

Search: algolia-specialist, elasticsearch-specialist

Blockchain: blockchain-solidity-expert, blockchain-web3-integration

Backend: api-designer-rest, api-designer-graphql, api-integration-specialist

Frontend: angular-specialist (and many more)

Architecture: architect, agent-architect, assumption-validator

Agent Design: agent-designer-fragment-structure, agent-designer-metadata-optimization, agent-designer-principles, agent-designer-workflow

Total: 154 agent resource files.

Skill Resources (103)

Reusable technique fragments organized into 6 families:

• Performance — profiling, optimization techniques
• Security — auth, encryption, audit
• Testing — unit, integration, e2e
• Observability — logging, tracing, metrics
• IaC — infrastructure as code patterns
• Error Handling — retry, circuit breaker, etc.

Total: 103 skill resource files.

Workflow Resources (36)

Ready-to-use execution strategies:

• adaptive-workflow, parallel-workflow, phased-workflow
• Language-specific: Python workflow, TypeScript workflow, etc.
• Domain-specific: REST API, ML pipeline, security workflow

Pattern Resources (32)

Architectural patterns organized into 9 families:

• Event-Driven, Database, Architecture (microservices, monolith, etc.)
• Others: Security, Performance, Testing, Observability, IaC, Error Handling

Resource Index (3 files)

orchestr8 — Uniqueness and Positioning

Category: Different Kind of Tool

orchestr8 belongs in a different category than other frameworks in this batch. Where stoneforge, bernstein, kagan, martinloop, and greatcto are workflow orchestration and agent management systems, orchestr8 is a context management system that uses orchestration vocabulary.

This distinction matters for the research catalog: orchestr8 represents the architectural pattern of "JIT knowledge loading as a Claude Code plugin" — distinct from "running multiple agents."

Differs from Seeds

Versus all multi-agent seeds (claude-flow, taskmaster-ai, agent-os): those frameworks manage task execution. orchestr8 manages knowledge access. The token efficiency angle is unique — no seed framework treats context window utilization as a first-class design constraint.

Versus superpowers (the closest seed): superpowers provides a skill/command library. orchestr8 provides a JIT-loaded resource library with semantic matching, multi-source providers (AITMPL + GitHub), and caching. The loading mechanism is fundamentally different.

Distinctive Features

1. JIT semantic resource loading — 4,036-keyword index + 1,675 useWhen scenarios for automatic expertise matching. No other framework reviewed uses semantic fuzzy matching for resource discovery.

2. AITMPL community registry — External API endpoint (api.aitmpl.com) providing 400+ community-contributed agent/skill/workflow resources. The only framework with a cloud-hosted community resource marketplace.

3. GPG-signed resource verification — CHECKSUMS.txt.asc, ORCHESTR8_PUBLIC_KEY.asc, verify_all_shas.sh. No other Claude Code plugin reviewed has resource integrity verification.

4. Progressive loading architecture — Resources split into core + advanced modules (Python agent has core module + advanced module). Load only the core (300 tokens) unless advanced features needed (+400 tokens). 52-83% additional savings.

5. 95-98% token reduction claim — The framing of multi-agent expertise as a token efficiency problem (not a capability problem) is architecturally novel.

6. 383 resource fragments — The largest knowledge library in this batch. 154 agent fragments, 103 skill fragments, 36 workflow templates, 32 patterns, 31+ examples.

7. Multi-source provider architecture — Local + AITMPL + GitHub with independent caching and rate limiting. Other frameworks have one knowledge source.

Observable Failure Modes

1. Name confusion: Users expecting an orchestration platform (from the name) find a context loader. README positioning is accurate but the name creates expectations.

2. AITMPL dependency: Key feature (400+ community resources) depends on api.aitmpl.com availability. If the API goes down, only local and GitHub resources remain.

3. No persistent state: orchestr8 cannot track what happened in previous sessions. Teams needing cross-session continuity must add a separate state management tool.

4. Last commit 2026-05-02: Slightly older than other batch members. Still active but slower update cadence.

5. Prompt-level orchestration: The "Chief Orchestrator" framing in /now is a Claude prompt construct, not a system property. Claude's behavior is as good as the prompt; unusual requests may fall outside the framing.