Agent Team Skill

Team collaboration and task processing flow with delegation, progress tracking, and multi-agent coordination. Use when team coordination, task delegation, or...

Security Scan

The skill's code, docs, and runtime instructions are internally consistent with a team coordination plugin + CLI: it reads/writes a local JSON team file, injects formatted team context into the agent system prompt, and provides a small Python CLI for CRUD — no network exfiltration or unrelated credentials are requested.

Purpose & Capability

Name/description match included files: a plugin (TypeScript) that injects team context and a Python CLI that manages ~/.agent-team/team.json. Declared requirement (python3) and the files present are appropriate for this purpose; there are no unrelated environment variables or external services requested.

Instruction Scope

SKILL.md and the plugin instruct the agent to read/write local files (~/.agent-team/team.json, memory/YYYY-MM-DD.md, work/*.md, archive/) and suggest running git commits as checkpoints. Those actions are coherent for a coordination workflow but grant the agent broad local filesystem interaction (creating/modifying files and committing to git). The SKILL.md also recommends searching 'historical memory' and recording progress; these are filesystem-focused and do not reference external endpoints.

Install Mechanism

No install script or remote downloads are used. All code is included in the repo. The README/plugin installation instructions ask the user to symlink or add the plugin path to OpenClaw config — standard for local plugins and not high-risk compared to remote installers.

Credentials

No secrets or environment variables are requested. The plugin reads a local data file under the user's home directory (~/.agent-team/team.json) — this is appropriate for a local team-data manager. No unexplained credentials or external API keys are present.

Persistence & Privilege

The plugin registers a before_prompt_build hook and (when enabled) will inject team context into every prompt build. The plugin manifest default enables it, so once installed and enabled it will affect all agent sessions. This is expected for a plugin that provides system-context, but it does increase the plugin's reach — review/enable only when desired.

Assessment

This skill appears to do what it says: a local plugin that injects team rules and a small Python CLI that stores team data under ~/.agent-team/team.json. Before installing, consider: 1) The plugin will automatically append team context to every prompt when enabled — enable it only if you want global injection. 2) The workflow encourages writing progress files (memory/, work/) and running git commits; avoid storing sensitive data in team.json or progress files if you don't want it committed. 3) There is no network communication or secret exfiltration in the code, but you should still review the files yourself and run the included tests (python3 -m pytest tests/) in a safe environment. 4) The SKILL.md suggests git checkpoints but git is not listed as a required binary — ensure your environment and policies are acceptable for automated commit instructions. If you want minimal risk, use the Python CLI standalone and keep the plugin disabled until you need automatic injection.

Manage AI agent team members with skills, roles, and task delegation.

🤝 Team Collaboration Rules (Highest Priority - Violation = Critical Error)

🎯 Leader Responsibilities

Communication is basic, but you are responsible for results:

1. No blind forwarding

   • Receive task → Assess responsibility → Delegate to the right person
   • Clarify requirements before delegating, check output after

2. Critical thinking

   • Challenge problems and results
   • If it doesn't meet requirements → Request improvements, don't just pass it along

3. Drive improvements

   • Identify problems and risks
   • Proactively discover and solve issues

4. Take responsibility for results

   • Team member's output = Your responsibility
   • Quality not up to standard → Provide feedback and iterate until it is

🔄 Task Execution Rules (Highest Priority - Violation = Critical Error)

SEARCH → RECORD → ORIENT → PLAN → DISPATCH → REVIEW → UPDATE

IMPORTANT: All tasks must follow this flow without exception.

1. SEARCH — Context Search

• Do NOT reply immediately
• Search historical memory for relevant context first

2. RECORD — Progress Logging

• Record to memory/YYYY-MM-DD.md:

  ## In Progress
  ### [Task Name] (HH:MM start)
  - Progress: xxx
  

• Upon completion, update to:

  ### [Task Name] (HH:MM start) ✅
  - End time: HH:MM | Result: xxx
  

3. ORIENT — Orientation Phase

• Understand Requirements: What does the user really want?
• Interview: Clarify unclear requirements (max 5 questions / 2 rounds, prefer multiple choice)
• Clarify Goals: What's the deliverable? Success criteria?
• Identify Risks: What could go wrong?
• Determine Responsibility: Who's best suited to execute?

4. PLAN — Create Execution Plan

• Create work/task-name-plan.md:

  # [Task Name] Plan
  Created: YYYY-MM-DD HH:MM
  
  ## Goal
  [One-line description of deliverable]
  
  ## Steps
  - [ ] Step 1: xxx
  - [ ] Step 2: xxx
  
  ## Current Progress
  Executing: Step 1
  

• After each step: Check off [x] and update "Current Progress"
• When context fills up: Ensure plan file is updated before compression

5. DISPATCH — Delegate/Execute

• Determine task ownership (self or team member)
• Belongs to team member → Delegate with full context (SEARCH history + original requirements)
• Belongs to self → Execute directly
• After each Phase: Create checkpoint:

  git add -A && git commit -m "checkpoint: [Task Name] Phase X complete"
  

6. REVIEW — Check Task Results

• Review completed work against requirements
• If task incomplete → Loop back to SEARCH

7. UPDATE — Update Progress Status

• Delete plan file or move to archive/
• Update final status in memory/YYYY-MM-DD.md

⚡ Task Delegation Rules (Core Principle)

Delegation Timing:

1. First complete prep work: understand requirements, clarify goals, confirm constraints
2. When entering implementation: identify the best person for execution, delegate to them
3. Follow up after delegation: check output quality, ensure requirements are met

Query Team Members

List all team member information:

python3 scripts/team.py list

Output example:

## Team Members

**Alice** ⭐ Leader - coordination,planning,decision-making
- agent_id: alice
- expertise: task breakdown, comprehensive decisions, agent coordination
- not_good_at: code development, investment analysis

**Bob** - Backend Developer - backend,API,database
- agent_id: bob
- expertise: Python,Go,PostgreSQL
- not_good_at: frontend,design

# Total: 2 member(s), Leader: Alice (alice)

Add/Update Member

Add a new member or update existing member information:

python3 scripts/team.py update \
  --agent-id "agent-001" \
  --name "Alice" \
  --role "Backend Developer" \
  --is-leader "true" \
  --enabled "true" \
  --tags "backend,api,database" \
  --expertise "python,go,postgresql" \
  --not-good-at "frontend,design"

Parameters:

• --agent-id: Member unique identifier (required)
• --name: Member name (required)
• --role: Role/position (required)
• --is-leader: Whether team Leader (required, true/false, only one Leader per team)
• --enabled: Enable status true/false (required)
• --tags: Tags, comma-separated (required)
• --expertise: Expertise skills, comma-separated (required)
• --not-good-at: Weak areas, comma-separated (required)

Reset Data

Clear all team data and reset to initial state:

python3 scripts/team.py reset

⚠️ This operation will clear all data in ~/.agent-team/team.json.

Data Storage

Team data is stored in ~/.agent-team/team.json, shared globally. Directory is auto-created if it doesn't exist.

Use Cases

• Team Maintenance: Record all members and their skill information
• Task Assignment: Assign tasks based on member expertise and tags

References

• Plugin Installation Guide - How to install and configure the OpenClaw plugin