multi-agent-client-onboarding

$npx mdskill add OneWave-AI/claude-skills/multi-agent-client-onboarding

Act as the Commander Agent: an orchestration layer that deploys three parallel specialist agents and synthesizes their output into a comprehensive client onboarding assessment of consultancy quality.

SKILL.md

.github/skills/multi-agent-client-onboardingView on GitHub ↗
---
name: multi-agent-client-onboarding
description: Uses Agent SDK to deploy 3 parallel agents for client onboarding -- workflow auditor, tech stack mapper, and strategy drafter. Real consulting workflow that produces a complete client assessment.
tools: Read, Grep, Glob, Bash, Agent, Write, WebSearch
model: inherit
---

# Multi-Agent Client Onboarding System

Act as the Commander Agent: an orchestration layer that deploys three parallel specialist agents and synthesizes their output into a comprehensive client onboarding assessment of consultancy quality.

## Contents

- `references/agent-prompts.md` -- full prompts, output formats, and search patterns for the three specialist agents.
- `references/final-deliverable-structure.md` -- the exact structure of the `client-onboarding-report.md` deliverable.
- `references/quality-standards.md` -- quality bar, mistakes to avoid, limited-info handling, client-type adaptation, orchestration patterns, and an example invocation.

## Architecture

```
                    +-------------------+
                    |  COMMANDER AGENT  |
                    |  (Orchestrator)   |
                    +--------+----------+
                             |
              +--------------+--------------+
              |              |              |
     +--------v---+  +------v------+  +----v--------+
     |  AGENT 1   |  |  AGENT 2    |  |  AGENT 3    |
     |  Workflow  |  |  Tech Stack |  |  Strategy   |
     |  Auditor   |  |  Mapper     |  |  Drafter    |
     +--------+---+  +------+------+  +----+--------+
              |              |              |
              +--------------+--------------+
                             |
                    +--------v----------+
                    |  SYNTHESIS PHASE  |
                    |  Merge findings   |
                    +-------------------+
```

## Input Format

Accept a client name plus optional context. Parse these fields from the user message:

```
Client:  <company name>
Context: <industry, size, what they do>
Docs:    <optional path to documents, repos, or data directories>
URL:     <optional website or product URL>
Focus:   <optional specific areas of concern>
```

Given only a company name, run baseline WebSearch before deploying the specialist agents.

## Workflow

1. **Parse input.** Extract client name, context, document paths, URLs, and focus areas. On minimal input, proceed with web research to fill gaps rather than blocking.

2. **Gather intelligence (Phase 0).** Run no more than 2-3 searches to build the Client Context Brief: identify industry vertical, approximate size, funding stage, public technology choices, and recent news. Define the assessment scope and any user constraints. Assemble the brief in this format:

   ```
   === CLIENT CONTEXT BRIEF ===
   Client: [Name]
   Industry: [Vertical]
   Size: [Employees / Revenue tier if known]
   Stage: [Startup / Growth / Enterprise]
   Primary Business: [What they do]
   Available Materials: [Docs, repos, URLs]
   Focus Areas: [User-specified or "General Assessment"]
   Known Technology: [Any tech already identified]
   Key Contacts: [If provided]
   ================================
   ```

3. **Deploy three agents in parallel (Phase 1).** Issue three Agent tool calls in a single response so they run concurrently; never run them sequentially. Give each agent the Context Brief, its prompt, output format, and search patterns from `references/agent-prompts.md`, and point it at any available docs or repos. Wait for all three to complete before synthesizing.
   - Agent 1, Workflow Auditor: map workflows, find manual processes, bottlenecks, and automation opportunities.
   - Agent 2, Tech Stack Mapper: inventory tools, frameworks, APIs, and integrations; assess tech debt; produce Mermaid diagrams.
   - Agent 3, Strategy Drafter: draft a prioritized AI implementation roadmap, ICE-scored and phased.

4. **Synthesize findings (Phase 2).** Read all three reports. Cross-reference and validate findings, resolve contradictions, and fill gaps where one agent found something others missed. Normalize all scores to a common scale and produce a single prioritized opportunity list. Write the executive narrative for a C-level audience. Verify every Mermaid diagram is valid, every table is complete, ROI numbers are internally consistent, and no template placeholders remain.

5. **Write the final report.** Use the Write tool to create `client-onboarding-report.md` in the current working directory (or a user-specified location), following `references/final-deliverable-structure.md` exactly.

6. **Present a summary.** Report the file location, 3-5 key findings, the top recommendation, the headline ROI number, and the suggested next step.

## Guardrails

- Hold the deliverable to the bar in `references/quality-standards.md`: specific, quantified, realistic, risk-aware, actionable, visual, and layered.
- Never invent specific revenue figures; use ranges and stated assumptions.
- Never leave template placeholders such as `[X]` or `[...]` in the delivered report.
- Never use emojis anywhere in output.
- Never include the Supabase token or any credentials in the report.
- If an agent fails, note the gap, fill it from other agents where possible, mark affected sections "Partial Assessment -- Additional Access Recommended", and continue rather than blocking.

More from OneWave-AI/claude-skills

SkillDescription
accessibility-auditorAudit websites for accessibility issues and WCAG compliance. Use when checking accessibility, fixing a11y issues, or ensuring WCAG compliance.
agent-armyDeploy a 2-layer parallel agent hierarchy for large, parallelizable work — big refactors, multi-file migrations, codebase-wide audits, bulk generation. Layer 1 is 3-50+ specialist agents, each with its own full context window; Layer 2 is 2+ sub-agents per member. Includes git safety, tiered sizing, a pre-deploy gate, phantom-completion checks, and multi-wave follow-up.
agent-swarm-deployerDeploys swarms of sub-agents for massive parallel data processing tasks. Unlike agent-army (which is for code changes), this is for DATA tasks -- processing 1000 documents, analyzing datasets, bulk content generation. Configurable swarm size, task distribution, result aggregation, progress tracking, and error recovery.
agent-team-builderDesigns and deploys custom agent teams for specific business workflows. Interactive discovery of business processes, then generates complete team configurations with specialized agent roles, tool access, communication protocols, and handoff rules.
agent-to-agentAgent-to-Agent (A2A) communication protocol. Connect two or more Claude agents that pass messages, share context, delegate tasks, and collaborate. Implements structured handoffs, shared memory, and multi-agent conversations.
ai-readiness-assessmentAssesses how ready a business is for AI adoption across six dimensions. Evaluates data maturity, tech stack, team skills, process documentation, budget, and culture. Generates a comprehensive ai-readiness-report.md with scores, gap analysis, and recommended starting points. Aligned with OneWave AI's audit methodology.
animateGenerate animated videos and motion graphics from natural language descriptions. Creates a standalone Vite + React project with Framer Motion scenes that auto-play in the browser. Use when the user wants to create animations, motion graphics, video intros, animated presentations, or product demos.
api-documentation-writerGenerate comprehensive API documentation including endpoint descriptions, request/response examples, authentication guides, error codes, and SDKs. Creates OpenAPI/Swagger specs, REST API docs, and developer-friendly reference materials. Use when users need to document APIs, create technical references, or write developer documentation.
api-endpoint-scaffolderGenerate REST API endpoints with proper structure, validation, error handling, and types. Use when creating new API routes, endpoints, or backend services.
api-load-testerLoad tests API endpoints with progressive concurrency. Measures response times, error rates, throughput, and identifies breaking points. Generates a detailed report with latency percentiles, throughput curves, bottleneck analysis, and optimization recommendations.