# How the Five Parallel Sub-Agents Divide Work in cangjie-skill: Architecture and Implementation

> Learn how cangjie-skill uses five parallel sub-agents Principle Glossary Framework Counter Example and Case extractors to efficiently divide prompt processing and specialized extraction tasks simultaneously.

- Repository: [kangarooking/cangjie-skill](https://github.com/kangarooking/cangjie-skill)
- Tags: architecture
- Published: 2026-08-15

---

**The cangjie-skill repository distributes prompt processing across five specialized parallel sub-agents—Principle, Glossary, Framework, Counter-Example, and Case extractors—each handling a distinct extraction task simultaneously.**

The **cangjie-skill** project implements a multi-agent extraction system that breaks complex inputs into parallelizable units. By dividing work among five purpose-built sub-agents, the architecture avoids single-agent context limits while producing richly structured outputs.

## The Five Parallel Sub-Agents in cangjie-skill

Each sub-agent operates as an independent **extractor** with a narrowly defined responsibility. The division of labor follows a facet-based approach, where every agent extracts one dimension of meaning from the source material.

| Sub-Agent | Responsibility | Source File |
|-----------|---------------|-------------|
| **Principle Extractor** | Identifies underlying principles, rules, and doctrines | [`extractors/principle-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/principle-extractor.md) |
| **Glossary Extractor** | Extracts and formats key terms with their definitions | [`extractors/glossary-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/glossary-extractor.md) |
| **Framework Extractor** | Detects structural models, schemata, and frameworks | [`extractors/framework-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/framework-extractor.md) |
| **Counter-Example Extractor** | Finds contradicting examples and challenging arguments | [`extractors/counter-example-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/counter-example-extractor.md) |
| **Case Extractor** | Extracts concrete case studies and real-world illustrations | [`extractors/case-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/case-extractor.md) |

These extractors are invoked simultaneously by the **stage-1 parallel extract** workflow documented in [`methodology/02-stage1-parallel-extract.md`](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/02-stage1-parallel-extract.md).

## How the Parallel Extraction Workflow Operates

The main driver orchestrates the five sub-agents through a three-phase process:

1. **Chunking** — Splits large prompts into processable segments when necessary
2. **Dispatch** — Forwards each chunk to all five extractors concurrently
3. **Merging** — Combines individual outputs into a unified structured response

Because agents run in parallel, total latency equals the slowest extractor's runtime rather than the sum of all five. This design also provides **fault isolation**: if one extractor fails, the others continue contributing, and the merge step handles missing sections gracefully.

## Implementation Pattern for Parallel Sub-Agent Execution

The repository uses a thread-based concurrency model to launch extractors. Below is representative pseudocode reflecting the actual implementation pattern:

```python
from concurrent.futures import ThreadPoolExecutor, as_completed
from extractors import (
    principle_extractor,
    glossary_extractor,
    framework_extractor,
    counter_example_extractor,
    case_extractor,
)

def run_parallel_extractors(prompt: str) -> dict:
    # Map each extractor function to a human-readable label

    extractors = {
        "principle": principle_extractor,
        "glossary": glossary_extractor,
        "framework": framework_extractor,
        "counter_example": counter_example_extractor,
        "case": case_extractor,
    }

    results = {}

    # Execute all extractors concurrently

    with ThreadPoolExecutor(max_workers=len(extractors)) as executor:
        future_to_name = {
            executor.submit(func, prompt): name for name, func in extractors.items()
        }
        for future in as_completed(future_to_name):
            name = future_to_name[future]
            try:
                results[name] = future.result()
            except Exception as exc:
                # If one extractor fails we still keep the others

                results[name] = f"Error: {exc}"

    return results

```

The function returns a dictionary keyed by sub-agent name. A separate assembly step (elsewhere in the codebase) stitches these pieces into the final skill output.

## Key Source Files for Understanding the Division of Work

| File | Purpose |
|------|---------|
| [`SKILL.md`](https://github.com/kangarooking/cangjie-skill/blob/main/SKILL.md) | High-level skill description including parallel extraction stage |
| [`methodology/02-stage1-parallel-extract.md`](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/02-stage1-parallel-extract.md) | Chunking strategy and extractor orchestration details |
| [`extractors/principle-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/principle-extractor.md) | Prompt template for Principle Extractor |
| [`extractors/glossary-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/glossary-extractor.md) | Prompt template for Glossary Extractor |
| [`extractors/framework-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/framework-extractor.md) | Prompt template for Framework Extractor |
| [`extractors/counter-example-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/counter-example-extractor.md) | Prompt template for Counter-Example Extractor |
| [`extractors/case-extractor.md`](https://github.com/kangarooking/cangjie-skill/blob/main/extractors/case-extractor.md) | Prompt template for Case Extractor |

## Performance and Reliability Characteristics

The parallel sub-agent architecture in cangjie-skill delivers two primary operational benefits:

- **Latency reduction** — Wall-clock time capped at slowest single extractor
- **Graceful degradation** — Partial results preserved even when individual agents fail

This design pattern suits large or complex inputs where monolithic extraction would exhaust context windows or produce incomplete analysis.

## Summary

- The **cangjie-skill** repository employs **five parallel sub-agents** to divide extraction work: Principle, Glossary, Framework, Counter-Example, and Case extractors.
- Each sub-agent is defined in its own `extractors/` file with specialized prompt templates.
- The [`methodology/02-stage1-parallel-extract.md`](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/02-stage1-parallel-extract.md) workflow handles chunking, dispatch, and result merging.
- Parallel execution uses `ThreadPoolExecutor` with fault-tolerant error handling.
- The architecture minimizes latency and ensures robust output even with partial agent failures.

## Frequently Asked Questions

### What happens if one of the five parallel sub-agents fails in cangjie-skill?

The system continues processing. As shown in the implementation pattern, exceptions are caught per-extractor and stored as error strings in the results dictionary. The final merge step can handle missing or errored sections without discarding valid output from functioning agents.

### Why five sub-agents specifically rather than more or fewer?

The five extractor types correspond to distinct epistemological facets: principles (rules), glossary (terminology), frameworks (structure), counter-examples (critical perspective), and cases (concrete illustration). This decomposition provides comprehensive coverage without fragmentation that would complicate merging.

### How does cangjie-skill handle prompts exceeding a single extractor's context limit?

The [`methodology/02-stage1-parallel-extract.md`](https://github.com/kangarooking/cangjie-skill/blob/main/methodology/02-stage1-parallel-extract.md) workflow implements **chunking**—splitting large inputs into segments, running extractors against each segment, and deduplicating or reconciling results during the merge phase.

### Where is the parallel orchestration logic actually implemented?

The coordination logic resides in the methodology documentation and associated driver code referenced from [`SKILL.md`](https://github.com/kangarooking/cangjie-skill/blob/main/SKILL.md). The extractor definitions themselves are prompt templates in `extractors/*.md` files, while the execution follows the `ThreadPoolExecutor` pattern demonstrated above.