What is a team display mode and how do I choose it?

Display mode determines how information from multiple agents is shown. Choose modes that maximize clarity for humans overseeing the team and ensure consistency with routing conventions.

How many scenarios should I test for team validation?

Aim for 20-50 scenarios to adequately exercise coordination patterns, edge cases, and fallback behavior before production.

What should I do if a fallback is triggered during execution?

Refer to the predefined fallback behavior in your coordination rules, document the trigger conditions, and use the fallback path to maintain safety and continuity while diagnosing the root cause.

implement-agent-teams

npx machina-cli add skill yu-iskw/google-cloud-observability-plugin/implement-agent-teams --openclaw

Files (1)

SKILL.md

2.3 KB

Implement Agent Teams

Implement team setup and coordination patterns for multi-agent workflows, including display modes and operational constraints.

Workflow

Validate complexity: Confirm team is needed (score 9-10). Can multiple specialized sub-agents work independently?
Define team objective: Clear goal requiring coordinated multi-agent execution
Identify members: Specialized agents with non-overlapping responsibilities
Set boundaries: Clear ownership and handoff contracts between agents
Configure metadata: Team metadata and task routing conventions
Plan coordination: Sequential vs parallel execution patterns
Document rules: Coordination rules and display mode choices
Evaluation strategy: How to test team-based workflows (20-50 scenarios)
Run checks: Environment and config validation
Verify fallbacks: Limitations and fallback behavior

Progressive Disclosure

Best Practices (Anthropic Guidelines)

Complexity decision framework: ../implement-claude-extensions/references/decision-framework.md
Context management patterns: ../implement-claude-extensions/references/context-management.md
Evaluation strategy: ../implement-claude-extensions/references/evaluation-strategy.md

Team Design

Team setup structure: references/team-setup.md
Coordination contracts: references/team-coordination.md
Display mode selection: references/team-display-modes.md
Team best practices: references/team-best-practices.md
Known limitations: references/team-limitations.md

Validation Tools

Team config checker: scripts/check-team-config.sh
Environment verifier: scripts/verify-team-env.sh

Templates

Team config example: assets/templates/team-config-example.json
Team task example: assets/templates/team-task-example.md

Related Skills

Umbrella routing and component comparison: ../implement-claude-extensions/SKILL.md
Sub-agent design: ../implement-sub-agents/SKILL.md

Sources

Source

git clone https://github.com/yu-iskw/google-cloud-observability-plugin/blob/main/.claude/skills/implement-agent-teams/SKILL.md

View on GitHub

Overview

This skill guides the setup and validation of Claude agent teams for multi-agent workflows. It covers defining a clear team objective, selecting members with non-overlapping responsibilities, setting ownership and handoff contracts, configuring metadata and routing conventions, and planning coordination (sequential vs parallel) with robust evaluation and fallback practices.

How This Skill Works

The workflow builds a team design with defined roles, boundaries, and display mode choices, supported by templates for team config and task examples. Validation is performed via a team config checker and an environment verifier to ensure the configuration is sound before execution.

When to Use It

Coordinating complex tasks that require multiple specialized agents with non-overlapping responsibilities.
Validating that a proposed multi-agent setup has clear ownership, handoffs, and coordination rules.
Configuring team metadata and routing conventions to ensure consistent task distribution.
Deciding between sequential vs parallel execution patterns for a workflow and documenting rules.
Before deployment, running environment and config checks and outlining fallback behavior.

Quick Start

Step 1: Validate complexity score (9-10) to justify a team and confirm need for specialized sub-agents.
Step 2: Define team objective, identify members, and set ownership/handoff contracts.
Step 3: Configure metadata and task routing; run checks with the team config checker and environment verifier.

Best Practices

Follow the Complexity decision framework to justify multi-agent teams.
Adopt context management patterns to preserve state across agents.
Define an Evaluation strategy with 20-50 test scenarios to validate team interactions.
Document coordination rules and display mode choices to guide operators.
Use the Team config checker and Environment verifier to validate setups before run.

Example Use Cases

A tri-agent data pipeline: data collector, analyzer, and reporter coordinating outputs.
Customer-support workflow with sentiment analysis, knowledge retrieval, and escalation agents.
Compliance review team with ownership contracts, audit trails, and review handoffs.
Content creation flow: draft agent, reviewer agent, and QA agent with clear handoffs.
Data orchestration: orchestrator agent coordinates validator and storage agents with routing metadata.

Frequently Asked Questions

Add this skill to your agents