A concurrent Agent engine driven by Skill files.
Define a Skill (what to do + who reviews it). SkillForge decomposes → executes concurrently → critiques from multiple perspectives → refines until no flaws remain.
Your needs → Skill Generator → SKILL.md + references/ + config.yaml
↓
SkillForge Engine
┌──────────────────────────────┐
│ ① Concurrent Execution (breadth) │
│ N tasks run in parallel │
│ │
│ ② Result Synthesis │
│ Union schema merge │
│ │
│ ③ Multi-Perspective Loop (depth) │
│ 5 perspectives critique │
│ → refine → converge │
│ │
│ → High-quality output │
└──────────────────────────────┘
The difference: not "call LLM once, take the result." It decomposes, collaborates concurrently, and closes the quality loop.
No tool on the market does all three.
| Tool | What it does | What it doesn't do |
|---|---|---|
| LangGraph | General graph orchestration — you draw the graph, it runs it | No task format, no review perspectives, no key management |
| CrewAI / AutoGen | Multi-agent roleplay — define roles, sequential delegation | Roles defined in Python code; domain experts can't use it |
| loop-cli | Execute → review → score → retry | No task decomposition, no skill format, single-threaded CLI |
| PromptLabs | 5-agent closed loop for prompt optimization | Prompt engineering only, not general task execution |
| Koi Review Pipeline | Multi-reviewer parallel review + voting | One-shot review, no iterative refinement, no decomposition |
| JUDGE LLM / eval harness | LLM evaluation framework + CI/CD gates | Evaluates only — doesn't execute, doesn't revise |
Three in one. From Skill file to high-quality output, one command:
① Task Decomposition ② Quality Loop ③ Production Scheduling
────────────────────────────── ────────────────────────────── ─────────────────
SKILL.md defines N subtasks 5 perspectives critique ApiKeyPool multi-key rotation
→ Pre-sorted by priority concurrently → 429 exponential backoff
→ ThreadPoolExecutor concurrent → Refine → re-critique → Least-loaded scheduling
→ Per-task timeout / isolation → modified_summary convergence → Transparent retry
→ Union schema synthesis → Stratified Global Context → Works with a single key
→ Stopword filtering
Key differences:
- Not a framework. A tool. Write no Python. Skill files (markdown + yaml) are the interface. Domain experts create and maintain them directly.
- Not one-shot review. An iterative closed loop. Loop doesn't stop at "pointing out issues" — it revises, re-reviews, until every perspective says "no issues."
- Not bare execution. Production scheduling. ApiKeyPool is battle-tested via NVIDIA SkillSpector PR #100. Not
while True: call_llm().
| LangGraph / CrewAI | SkillForge | |
|---|---|---|
| Problem | "How do multiple agents collaborate?" | "How does one complex task get done well?" |
| Who defines behavior | Programmers (Python code) | Domain experts (markdown files) |
| Quality assurance | Prompt engineering | Built-in multi-perspective critique engine |
| Best for | Agent orchestration | Quality loop for a single skill |
SkillForge and LangGraph don't compete — they complement. SkillForge can be a LangGraph node: one step in the graph is "run multi-perspective quality audit via SkillForge," results flow downstream.
Project status: Early. Engine code complete (3,012 lines, 40 tests passing), but not yet battle-tested at scale. If you're willing to try it and give feedback, the author is waiting on GitHub Issues.
pip install batch-pool# Generate from a definition file
python -m batch_pool new --from my-audit.yaml
# Or interactive mode
python -m batch_pool new# my-audit.yaml
name: code-security-audit
description: Multi-dimensional code security audit
tasks:
- id: dependency-scan
label: Dependency vulnerability scan
priority: high
- id: injection-analysis
label: Injection vulnerability analysis
priority: high
- id: permission-audit
label: Permission model audit
priority: medium
perspectives:
- correctness
- completeness
- actionabilityGenerated result:
code-security-audit/
├── SKILL.md ← Task index
├── config.yaml ← Runtime config + Loop perspectives
└── references/ ← One checklist per task (fill in the TODOs)
├── dependency-scan.md
├── injection-analysis.md
└── permission-audit.md
Open references/dependency-scan.md and write the analysis dimensions you want the LLM to check:
# Dependency Vulnerability Scan
## Analysis Dimensions
1. Do direct and transitive dependencies have known CVEs?
2. Are licenses compatible with the project?
3. Are there unmaintained dependencies?
## Output Format
{
"category": "dependency-scan",
"findings": [
{
"id": "DEP-001",
"title": "...",
"severity": "LOW|MEDIUM|HIGH|CRITICAL",
"description": "...",
"location": "...",
"remediation": "..."
}
],
"score": 0-100,
"summary": "..."
}# Multi-key mode (recommended)
export BATCH_POOL_API_KEYS="
sk-ds-xxx1|https://api.deepseek.com|deepseek-v4|deepseek
sk-ds-xxx2|https://api.deepseek.com|deepseek-v4|deepseek
"
# Single-key mode
export OPENAI_API_KEY=sk-xxxpython -m batch_pool run ./code-security-audit/ -w 8Output:
SkillForge: code-security-audit — 3 task(s), 8 workers
[1/3] Dependency vulnerability scan → SUCCESS
[2/3] Injection vulnerability analysis → SUCCESS
[3/3] Permission model audit → SUCCESS
Iteration 1/3: 8/12 items modified
Iteration 2/3: 3/12 items modified
Iteration 3/3: 0/12 items modified
✓ Converged at iteration 3
Report saved to ./code-security-audit/report.json
A Skill is a directory with three files:
my-skill/
├── SKILL.md ← Metadata + task list
├── config.yaml ← Runtime config (workers, Loop perspectives, critique criteria)
└── references/ ← One .md file per task
---
name: my-skill
description: One-line description
version: "1.0"
tasks:
- id: task-a
file: references/task-a.md # Relative path
label: Label for Task A
priority: high # high | medium | low
---execution:
workers: 8
default_model: deepseek-v4
loop:
enabled: true
max_iterations: 3
perspectives:
- name: correctness
prompt: Critique from a factual accuracy perspective...
- name: completeness
prompt: Critique from a completeness perspective...
refine_prompt: >
Consider all review comments and revise the original analysis...Full specification: SKILL-SPEC.md.
SkillForge consists of two independent projects, decoupled through the filesystem contract:
Engine (batch_pool/) |
Skill Generator | |
|---|---|---|
| Role | Consumes skill directories, runs concurrency + Loop | Creates and maintains skill directories |
| CLI | batch-pool run |
batch-pool new / batch-pool validate |
batch_pool/
├── engine.py BatchPool.run() main API
├── loop.py Multi-perspective critique engine (core differentiator)
├── api_pool.py Multi-key pool (least-loaded + 429 backoff, SkillSpector-validated)
├── executor.py ThreadPoolExecutor concurrency + soft priority
├── handler.py Generic LLM pipeline (no specialization)
├── client.py Stateless factory (LRU cache + 3-level JSON parsing)
├── synthesizer.py Union schema synthesis
├── discovery.py SKILL.md parsing + built-in contract check
├── reports.py JSON / Markdown / Terminal output
├── progress.py Rich terminal progress
├── config.py Three-layer config merge (CLI > config.yaml > defaults)
└── __main__.py CLI entry point
# Run a skill
python -m batch_pool run <skill_dir> [-w WORKERS] [-f json|markdown|terminal] [-v]
# Validate skill format
python -m batch_pool validate <skill_dir> [--strict]
# Create a new skill (interactive)
python -m batch_pool new [--from definition.yaml] [--force]
# View engine state
python -m batch_pool snapshot <skill_dir>git clone https://github.com/nanzhijin/batch-pool
cd batch-pool
pip install -e ".[dev]"
python -m pytest tests/ -vApache-2.0 © 2026 nanzhijin