# Design Multi-Agent AI Systems

Multi-agent projects often fail through unclear delegation, unsafe tools, and uncontrolled costs. This skill gives Claude, Codex, and Claude Code structured patterns for coordinated agent architectures.

## Install

```bash
npx skillstore add 2389-research/building-multiagent-systems
```

## Metadata

- - Status: approved
- - Slug: 2389-research-building-multiagent-systems
- - Version: 1.0.0
- - Author: 2389-research
- - GitHub username: 2389-research
- - License: MIT
- - Repository: https://github.com/2389-research/claude-plugins/tree/main/building-multiagent-systems/skills
- - Ref: main
- - Supported tools: Claude, Codex, Claude Code
- - Risk level: medium
- - Risk factors: external\_commands
- - Quality score: 74
- - Public page: https://skillstore.pages.dev/skills/2389-research-building-multiagent-systems
- - Manifest: https://skillstore.pages.dev/api/skills/2389-research-building-multiagent-systems/manifest

## Capabilities

- Guides discovery questions before selecting a multi-agent architecture.
- Explains a four-layer stack for reasoning, orchestration, tools, and adapters.
- Compares fan-out, pipeline, delegation, queue, map-reduce, peer, and MAKER patterns.
- Provides guidance for permission inheritance, resource locks, rate limits, and caching.
- Describes production controls for cleanup, checkpoints, cost tracking, and orphan detection.

## Use Cases

- Design Review Agent Workflows: Plan specialist agents for security, performance, tests, and style with clear aggregation rules.
- Build Production Orchestrators: Define lifecycle, checkpointing, cost tracking, and failure handling before implementation.
- Evaluate Agent Coordination Patterns: Choose between fan-out, pipelines, delegation, queues, map-reduce, councils, or MAKER workflows.

## Prompt Templates

### Select a Pattern

```
Help me choose a multi-agent coordination pattern for this task. Ask the required discovery questions first, then recommend one pattern with trade-offs.
```

### Draft an Agent Architecture

```
Design a multi-agent architecture using the four-layer stack. Include agent roles, tool scopes, state handling, and cleanup behavior.
```

### Harden an Existing System

```
Review this multi-agent design for production risks. Focus on orphan detection, cost tracking, checkpointing, rate limits, and permission inheritance.
```

### Model a Zero-Error Workflow

```
Apply the MAKER pattern to this high-risk workflow. Define decomposition depth, voting thresholds, validation gates, retry rules, and expected cost.
```

## Limitations

- Provides architecture guidance, not a runnable multi-agent framework.
- Requires users to adapt examples to their language, model provider, and runtime.
- Does not verify correctness of deployed agent systems automatically.
- High-risk tool access still needs sandboxing, approval flows, and security review.

## Best Practices

- Ask the discovery questions before designing roles, tools, or orchestration.
- Give sub-agents the smallest practical permission set and explicit timeouts.
- Add checkpoints, cost accounting, and cascading cleanup before production use.

## Anti Patterns

- Spawning unlimited agents without batching, budgets, or lifecycle cleanup.
- Giving child agents broad shell or write access without approval controls.
- Mixing LLM reasoning inside deterministic tool adapters.

## Security Audit

- - Safe to publish: true
- - Audited at: 2026-06-27T16:17:39.193\+00:00
- - Summary: Static analysis reported many high-risk patterns, but review found Markdown architecture guidance and TypeScript-style examples rather than executable scripts or malicious code. The findings are mainly false positives from inline code, schema examples, and illustrative agent snippets. Publish with a warning because the skill discusses shell-capable agents, file access, and self-modifying workflows that require strict permissions in real implementations.

## Stats

- - Views: 248
- - Downloads: 7
- - Favorites: 0
- - Popularity score: 0