Claude-skills orchestrating-skills

install

source · Clone the upstream repo

git clone https://github.com/oaustegard/claude-skills

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/oaustegard/claude-skills "$T" && mkdir -p ~/.claude/skills && cp -r "$T/orchestrating-skills" ~/.claude/skills/oaustegard-claude-skills-orchestrating-skills && rm -rf "$T"

manifest: orchestrating-skills/SKILL.md

source content

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

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

/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).