Skill-Aware Orchestration

Orchestrate complex multi-step tasks through a four-phase pipeline that eliminates redundant context processing and reflexive subagent spawning.

When to Use

Task requires multiple analytical perspectives (e.g., compare + critique + synthesize)
Context is large and subtasks only need portions of it
Simple lookups should be self-answered without spawning subagents

When NOT to Use

Single-skill tasks (just use the skill directly)
Tasks requiring tool use or code execution (this is text-analysis orchestration)
Real-time streaming requirements (this is batch-oriented)

Quick Start

import sys
sys.path.insert(0, "/mnt/skills/user/orchestrating-skills/scripts")
from orchestrate import orchestrate

result = orchestrate(
    context=open("report.md").read(),
    task="Compare the two proposed architectures, extract cost figures, and recommend one",
    verbose=True,
)
print(result["result"])

Dependencies

httpx (usually pre-installed; pip install httpx if not)
No Anthropic SDK required
API key: reads ANTHROPIC_API_KEY env var or /mnt/project/claude.env

Four-Phase Pipeline

Phase 1: Planning (LLM)

The orchestrator reads the full context once and produces a JSON plan:

{
  "subtasks": [
    {
      "task": "Compare architecture A vs B on scalability, cost, and complexity",
      "skill": "analytical_comparison",
      "context_pointers": {"sections": ["Architecture A", "Architecture B"]}
    },
    {
      "task": "What is the project budget?",
      "skill": "self",
      "answer": "$2.4M"
    }
  ]
}

Key behaviors:

Assigns one skill per subtask from the built-in library
Uses "self" for direct lookups (numbers, names, dates) — no subagent spawned
Self-answering is an LLM judgment call, not a sentence-count heuristic
Context pointers use section headers (structural, edit-resilient)

Phase 2: Assembly (Deterministic Code)

No LLM calls. Extracts context subsets using section headers or line ranges, pairs each with the assigned skill's system prompt, builds prompt dicts.

Phase 3: Execution (Parallel LLM)

Delegated subtasks run in parallel via concurrent.futures.ThreadPoolExecutor. Each subagent receives only its context slice and skill-specific instructions.

Phase 4: Synthesis (LLM)

Collects all results (self-answered + subagent), synthesizes into a coherent response that reads as if a single expert wrote it.

Built-in Skill Library

Eight analytical skills plus one pipeline skill:

Skill	Purpose
`analytical_comparison`	Compare items along dimensions with trade-offs
`fact_extraction`	Extract facts with source attribution
`structured_synthesis`	Combine multiple sources into narrative
`causal_reasoning`	Identify cause-effect chains
`critique`	Evaluate arguments for soundness
`classification`	Categorize items with rationale
`summarization`	Produce concise summaries
`gap_analysis`	Identify missing information
`remember`	Persist key findings to long-term memory via `remembering` skill (pipeline-only, runs post-synthesis)

API Reference

`orchestrate(context, task, **kwargs) -> dict`

Returns:

{
    "result": "Final synthesized response",
    "plan": {...},
    "subtask_count": 4,
    "self_answered": 1,
    "delegated": 3,
    "memory_ids": ["abc123"],  # populated when remember subtasks ran
}

Parameters:

context (str): Full context to process
task (str): What to accomplish
model (str): Claude model, default claude-sonnet-4-6
max_tokens (int): Per-subagent token limit, default 2048
synthesis_max_tokens (int): Synthesis token limit, default 4096
max_workers (int): Parallel subagent limit, default 5
skills (dict): Custom skill library (merged with built-in)
persist (bool): Auto-append a remember subtask to store findings, default False
verbose (bool): Print progress to stderr

CLI

python orchestrate.py \
    --context-file report.md \
    --task "Analyze this report" \
    --verbose --json

Extending the Skill Library

from skill_library import SKILLS

custom_skills = {
    **SKILLS,
    "code_review": {
        "description": "Review code for bugs, style, and security",
        "system_prompt": "You are a code review specialist...",
        "output_hint": "issues_list with severity and fix suggestions",
    }
}

result = orchestrate(context=code, task="Review this PR", skills=custom_skills)

Persisting Findings with `remember`

remember is a pipeline skill — it executes in Phase 4 after synthesis, not as a parallel subagent. It uses LLM distillation to extract the key insight from the synthesized result, then writes it to long-term memory via the remembering skill.

Two ways to activate persistence

1. persist=True (automatic)

result = orchestrate(
    context=open("report.md").read(),
    task="Compare approaches A and B",
    persist=True,  # auto-injects a remember subtask
    verbose=True,
)
print(result["memory_ids"])  # ['abc123']

2. Planner-emitted (explicit)

The orchestrator planner can emit remember as a subtask when the task description implies storage:

{
  "task": "Store the key findings from this analysis",
  "skill": "remember",
  "context_pointers": {}
}

Requirements

remembering skill must be installed (/mnt/skills/user/remembering or /home/user/claude-skills/remembering)
Turso credentials must be available (auto-detected by the remembering skill)
If unavailable, persistence is skipped silently and memory_ids returns []

Architecture Details

See references/architecture.md for design decisions, token efficiency analysis, and comparison with SkillOrchestra (arXiv 2602.19672).

orchestrating-skills