← Back to Skills Marketplace
liuchang8877

Agent Team Pipeline

by liuchang · GitHub ↗ · v1.0.0 · MIT-0
cross-platform ⚠ suspicious
222
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install agent-team-pipeline
Description
Use when needing to coordinate multiple AI agents in parallel for code development, testing, and review
README (SKILL.md)

Agent Team Pipeline

Overview

Coordinate OpenClaw as the brain dispatching multiple Codex instances in parallel: one for coding, one for testing, one for code review. Each agent works in an isolated git worktree to avoid conflicts.

When to Use

  • Need to implement a feature with separate code/test/review phases
  • Want parallel execution of independent tasks
  • Building a mini development team workflow

Not for:

  • Single simple tasks (use single agent)
  • Exploratory discussions requiring multi-round dialogue

Core Pattern

User → OpenClaw (brain) → Codex Coder → Codex Tester → Codex Reviewer
                        → Codex Tester (parallel)
                        → Codex Reviewer (parallel)

Setup

1. Create Isolated Worktrees

cd /Users/liuchang/.openclaw/workspace
git worktree add -b coder /Users/liuchang/agent-coder HEAD
git worktree add -b tester /Users/liuchang/agent-tester HEAD
git worktree add -b reviewer /Users/liuchang/agent-reviewer HEAD

2. Task Distribution Script

#!/bin/bash
CODER_DIR="/Users/liuchang/agent-coder"
TESTER_DIR="/Users/liuchang/agent-tester"
REVIEWER_DIR="/Users/liuchang/agent-reviewer"

case "$1" in
    coder)
        cd "$CODER_DIR" && codex exec "$2"
        ;;
    tester)
        cd "$TESTER_DIR" && codex exec "$2"
        ;;
    reviewer)
        cd "$REVIEWER_DIR" && codex exec "$2"
        ;;
esac

3. Workflow

  1. Coder receives task, writes code to agent-coder/
  2. Tester receives code, writes tests to agent-tester/
  3. Reviewer reviews code, provides feedback
  4. Loop: Coder addresses feedback → Reviewer confirms

Quick Reference

Role Worktree Command
Coder agent-coder codex exec "implement X"
Tester agent-tester codex exec "test X"
Reviewer agent-reviewer codex exec "review X"

Example

# Coder: Implement feature
codex exec "创建登录功能,使用 JWT"

# Tester: Write tests  
codex exec "为 ../agent-coder/login.py 写测试"

# Reviewer: Review code
codex exec "审查 ../agent-coder/login.py"

Common Mistakes

  • No worktree isolation → Use git worktree to prevent file conflicts
  • Sequential when parallel → Coder+Tester+Reviewer can run in parallel
  • Skipping review loop → Always verify fixes with reviewer before accepting

Real-World Impact

Successfully implemented hello.py example:

  • Coder created initial code
  • Tester wrote pytest file
  • Reviewer suggested main() + __main__ protection
  • Coder applied fixes
  • Reviewer confirmed compliance
Usage Guidance
This skill appears to be a workflow pattern for running multiple agent roles, but it assumes host-side capabilities that it does not declare. Before installing or running it: (1) verify you have and trust the 'codex' CLI and git on your machine; (2) edit the SKILL.md/scripts to point at safe workspace paths (avoid hardcoded /Users/liuchang paths) or run in an isolated sandbox/VM; (3) inspect any 'codex exec' invocations because they execute arbitrary instructions and could run code that reads/writes files in your workspace; (4) if you intend to use this with real code, test the workflow in a disposable repository to ensure it doesn't touch sensitive data. If you need to proceed, update the skill metadata to declare required binaries (git, codex) so the capability and requirements match.
Capability Analysis
Type: OpenClaw Skill Name: agent-team-pipeline Version: 1.0.0 The skill bundle describes a multi-agent orchestration workflow for code development, testing, and review using git worktrees and a 'codex' CLI tool. While it contains hardcoded absolute file paths specific to a user environment (/Users/liuchang/), which is a poor practice for portability, the logic is consistent with its stated purpose and lacks any indicators of malicious intent, data exfiltration, or unauthorized system access.
Capability Assessment
Purpose & Capability
The skill's stated purpose (coordinate coder/tester/reviewer agents using isolated git worktrees) matches the instructions, but the SKILL.md assumes the presence of system tools (git, a 'codex' CLI) and uses absolute user paths. The registry metadata lists no required binaries or environment variables, which is inconsistent with the runtime steps that clearly need git and a 'codex' executable.
Instruction Scope
The instructions direct filesystem operations (git worktree creation under /Users/liuchang, cds into agent-specific directories) and invoke 'codex exec' with arbitrary task strings. They reference absolute paths in a specific user's home and relative paths that may access other worktrees (e.g., reviewing ../agent-coder/login.py). This grants the skill broad discretion to read/write and execute within the user's workspace and to run arbitrary commands via the 'codex' tool — actions beyond a pure orchestration description and not limited or sandboxed by the SKILL.md.
Install Mechanism
There is no install spec (instruction-only), which reduces installer risk. However, the runtime assumes external binaries (git, codex) are present and executable; the skill does not declare these requirements in the registry metadata. Because nothing is installed by the skill itself, disk-write risk from an installer is low, but runtime execution risk remains due to invoking host tools.
Credentials
The skill requires no declared environment variables or credentials, which is reasonable, but it hardcodes user-specific filesystem paths (/Users/liuchang/...) and implicitly requires access to the user's git repositories and working directories. The lack of declared binaries/env requirements while assuming access to system tools and a specific user's home is a proportionality mismatch and a usability/security concern.
Persistence & Privilege
The skill is not always-enabled and does not request elevated platform privileges. It does not include installation steps that would persistently modify other skills or system-wide settings. Autonomous invocation is allowed (platform default) but not combined with other high-risk indicators here.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install agent-team-pipeline
  3. After installation, invoke the skill by name or use /agent-team-pipeline
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v1.0.0
- Initial release of agent-team-pipeline skill. - Enables coordination of multiple AI agents (coder, tester, reviewer) in parallel for code development workflows. - Uses isolated git worktrees for each agent to avoid conflicts. - Includes task distribution pattern and example setup/scripts. - Designed for multi-phase features, not simple or open-ended tasks.
Metadata
Slug agent-team-pipeline
Version 1.0.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is Agent Team Pipeline?

Use when needing to coordinate multiple AI agents in parallel for code development, testing, and review. It is an AI Agent Skill for Claude Code / OpenClaw, with 222 downloads so far.

How do I install Agent Team Pipeline?

Run "/install agent-team-pipeline" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is Agent Team Pipeline free?

Yes, Agent Team Pipeline is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does Agent Team Pipeline support?

Agent Team Pipeline is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created Agent Team Pipeline?

It is built and maintained by liuchang (@liuchang8877); the current version is v1.0.0.

💬 Comments