What this prompt does
This prompt designs a multi-agent AI system for a [system_purpose]. It defines agent roles ([agent_roles]) with capabilities, an orchestration pattern ([orchestration_type]), task decomposition, an inter-agent communication protocol, shared memory, per-agent tools ([tools]), human-in-the-loop checkpoints at [review_points], error handling with fallback chains, a per-run cost budget (max [budget]), and decision/tool-call tracing, implemented with [agent_framework]. It explicitly handles agent loops, stuck states, and conflicting outputs.
The structure works because multi-agent systems fail in specific, predictable ways: agents loop, get stuck, or disagree. Pinning down the [orchestration_type] and [review_points] before wiring anything forces those failure modes into the design instead of discovering them in production. The per-task [budget] and tracing are the guardrails that keep these systems from quietly burning money, and the fallback chains give each agent a defined path when it cannot complete its task.
When to use it
- Designing a workflow that needs several specialized agents (
[agent_roles]), not one big prompt. - Choosing and documenting an orchestration pattern before building (
[orchestration_type]). - Adding human-in-the-loop checkpoints at high-stakes
[review_points]. - Putting a hard cost ceiling (
[budget]) on agent runs that could otherwise loop expensively. - Building observability so you can trace which agent made which decision.
- Handling the real failure modes: loops, stuck states, and conflicting agent outputs.
Example output
You get an architecture: defined [agent_roles] with capabilities and prompt templates, an orchestration design for [orchestration_type], a task-decomposition strategy, a communication protocol, shared-memory design, per-agent [tools] mappings, human checkpoints at [review_points], fallback chains, a per-run cost budget capped at [budget], tracing for agent decisions and tool calls, per-agent evaluation metrics, and a visual workflow diagram, targeting [agent_framework].
Pro tips
- Keep
[agent_roles]few and distinct; overlapping roles cause agents to duplicate work or argue over ownership. - Choose
[orchestration_type]deliberately; a supervisor/hierarchical pattern is easier to reason about than a free-for-all. - Set a real
[budget]and enforce it in code; an unbounded agent loop is the classic way these systems burn money. - Place
[review_points]only where the cost of being wrong is high; checkpointing everything defeats automation. - Lean on tracing from the first run; without it, debugging a multi-agent failure is nearly impossible.
- Design explicit handling for conflicting outputs (a tie-breaker or escalation), not an implicit "last agent wins."
