How to Use Multiple Skills Together in Orchestrated Workflows in Claude Plugins

Claude plugins support orchestrated workflows through a skill-orchestration pattern where a top-level skill manifest coordinates sub-skills sequentially, while Python orchestrator scripts handle complex backend data processing and mutation generation.

The anthropics/claude-plugins-community repository implements a declarative approach to chaining multiple skills into cohesive user experiences. By combining manifest-driven orchestration with Python automation scripts, developers can create linear, conversational workflows that invoke specialized sub-skills without duplicating logic across the codebase.

Understanding the Skill Orchestration Architecture

The skill-orchestration pattern relies on a conductor skill that delegates tasks to specialized sub-skills in a defined order. According to the source code in the TRES Finance plugin suite, this pattern appears in two distinct implementations that handle different complexity levels.

Chat-level orchestration uses a top-level skill manifest to string together sub-skills conversationally, handling user interactions at each step. Backend orchestration employs Python scripts to preprocess data and generate execution payloads before triggering the next skill in the sequence.

Chat-Level Orchestration with Top-Level Skills

The tres-onboarding skill demonstrates declarative workflow composition through its manifest. Located at tres-finance-plugin/skills/tres-onboarding/SKILL.md, this orchestrator coordinates eight distinct sub-skills including wallet upload, data collection, balance validation, and roll-up rules.

The manifest specifies each step and the target sub-skill name. When a user confirms their intent, Claude sequentially triggers the referenced sub-skill, captures its output, and advances to the next step automatically.

{
  "skill": "tres-onboarding",
  "input": {
    "entity_name": "Acme Corp",
    "wallets": ["0xabc…", "0xdef…"]
  }
}

Claude parses the top-level manifest, requests any missing parameters, then executes the chain:

1. Invoke tres-wallets-upload for wallet ingestion
2. Invoke tres-data-collection-commit for data gathering
3. Continue through validation and rule configuration steps

State tracking occurs within the skill itself, marking steps like "step X completed" to support workflow interruption and resumption.

Backend Orchestration with Python Scripts

Complex data transformations require the orchestrate_reprice.py script found in tres-finance-plugin/skills/tres-asc845-swap-reprice-skill/scripts/orchestrate_reprice.py. This backend orchestrator reads raw MCP JSON, filters and transforms data, and builds execution plans before invoking the ASC 845 swap-reprice sub-skill.

The script implements the build_reprice_plan function from reprice_swaps.py to generate structured execution payloads.

python3 orchestrate_reprice.py \
    --input swap_reprice_input.json \
    --account-name "Swaps Clearing Account" \
    --output reprice_plan.json \
    --mutations-output reprice_mutations.json

This execution performs four critical operations:

• Loads and filters MCP JSON by account name and activity tags
• Calls build_reprice_plan to construct the pricing strategy
• Executes print_preview to generate human-readable output
• Writes reprice_plan.json and mutation payload reprice_mutations.json

Claude then feeds the generated mutations back into the workflow:

{
  "skill": "tres-asc845-swap-reprice-skill",
  "input": {
    "mutations_file": "reprice_mutations.json"
  }
}

The runtime iterates over each mutation entry and calls the MCP's execute endpoint using the GraphQL template embedded in the payload.

Building a Multi-Skill Orchestrated Workflow

To combine multiple skills into a cohesive workflow, follow the architectural pattern established in the repository.

Define the Top-Level Orchestrator

Create a SKILL.md manifest that lists sub-skills and their execution order. Each sub-skill must reside in its own folder under skills/ with its own manifest and required scripts. The orchestrator manifest specifies the sequence and handoff logic.

Develop Modular Sub-Skills

Build individual skills like tres-wallets-upload or tres-data-collection-commit as independent units. Each should handle a discrete task and return structured output that the orchestrator can pass to the next step.

Implement Python Orchestrators for Data Processing

For workflows requiring complex preprocessing, implement orchestrator scripts in the scripts/ directory that parse incoming MCP responses, transform data using utility functions like build_reprice_plan, and generate JSON artifacts for downstream execution.

Handle State Tracking and Resumption

Implement state tracking within the top-level skill to record completed steps. This allows users to pause and resume long-running workflows without losing context, as demonstrated in the tres-onboarding skill's interruption handling.

Summary

• Declarative orchestration uses a top-level SKILL.md manifest to sequence sub-skills conversationally, as demonstrated in the tres-onboarding implementation that chains eight distinct steps.
• Programmatic orchestration employs Python scripts like orchestrate_reprice.py found in tres-finance-plugin/skills/tres-asc845-swap-reprice-skill/scripts/ to preprocess data and generate mutation payloads before triggering specialized skills.
• Modular architecture requires each sub-skill to exist in its own directory under skills/ with independent manifests and scripts, enabling reuse across different orchestrated workflows.
• State management occurs within the orchestrating skill, enabling workflow interruption and resumption across multiple chat sessions.
• Key functions build_reprice_plan and print_preview in reprice_swaps.py handle complex business logic for backend orchestration scenarios.

Frequently Asked Questions

How does Claude determine which sub-skill to execute next in an orchestrated workflow?

Claude reads the ordered list of steps defined in the top-level skill's SKILL.md manifest. After receiving output from one sub-skill, Claude automatically invokes the next sub-skill in the sequence, passing along any required context from previous steps.

Can I combine chat-level and backend orchestration in the same workflow?

Yes, you can implement hybrid approaches. Start with a manifest-driven orchestrator like tres-onboarding for initial data collection and user confirmation, then invoke a Python script like orchestrate_reprice.py to process complex data transformations, and finally return control to Claude to execute the resulting mutations through the appropriate sub-skill.

What happens if a user interrupts a long-running orchestrated workflow?

The tres-onboarding skill implements state tracking by marking specific steps as completed within the conversation context. When the user resumes the session, Claude checks these state markers and continues from the last uncompleted step rather than restarting the entire sequence.

Where should orchestrator scripts be located in the repository structure?

Place backend orchestrator scripts in the scripts/ folder within the specific skill directory that requires complex preprocessing. For example, tres-asc845-swap-reprice-skill/scripts/orchestrate_reprice.py lives alongside the skill's core logic files, keeping the orchestration logic co-located with the specialized functionality it supports.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}