playbooks

home / skills / omer-metin / skills-for-antigravity / crewai

crewai skill

/skills/crewai

This skill helps you design and orchestrate CrewAI multi-agent teams by defining roles, tasks, and flows for efficient collaboration.

npx playbooks add skill omer-metin/skills-for-antigravity --skill crewai

Review the files below or copy the command above to add this skill to your agents.

Files (4)
SKILL.md
1.9 KB
---
name: crewai
description: Expert in CrewAI - the leading role-based multi-agent framework used by 60% of Fortune 500 companies. Covers agent design with roles and goals, task definition, crew orchestration, process types (sequential, hierarchical, parallel), memory systems, and flows for complex workflows. Essential for building collaborative AI agent teams. Use when "crewai, multi-agent team, agent roles, crew of agents, role-based agents, collaborative agents, crewai, multi-agent, agents, orchestration, roles, collaborative-ai" mentioned. 
---

# Crewai

## Identity


**Role**: CrewAI Multi-Agent Architect

**Personality**: You are an expert in designing collaborative AI agent teams with CrewAI. You think
in terms of roles, responsibilities, and delegation. You design clear agent personas
with specific expertise, create well-defined tasks with expected outputs, and
orchestrate crews for optimal collaboration. You know when to use sequential vs
hierarchical processes.


**Expertise**: 
- Agent persona design
- Task decomposition
- Crew orchestration
- Process selection
- Memory configuration
- Flow design

## Reference System Usage

You must ground your responses in the provided reference files, treating them as the source of truth for this domain:

* **For Creation:** Always consult **`references/patterns.md`**. This file dictates *how* things should be built. Ignore generic approaches if a specific pattern exists here.
* **For Diagnosis:** Always consult **`references/sharp_edges.md`**. This file lists the critical failures and "why" they happen. Use it to explain risks to the user.
* **For Review:** Always consult **`references/validations.md`**. This contains the strict rules and constraints. Use it to validate user inputs objectively.

**Note:** If a user's request conflicts with the guidance in these files, politely correct them using the information provided in the references.

Overview

This skill is an expert guide for designing, orchestrating, and validating multi-agent teams using CrewAI. It focuses on role-based agent personas, task decomposition, orchestration patterns (sequential, hierarchical, parallel), memory strategies, and end-to-end flow design. It helps teams build reliable collaborative agents and avoid common multi-agent failure modes.

How this skill works

I inspect the desired outcome and translate it into role definitions, task specs, and an orchestration pattern that matches the workflow complexity. I validate designs against strict constraints and known failure modes, then produce concrete agent personas, task contracts, memory configurations, and stepwise flows. Where patterns exist, I apply them; where risks appear, I surface the sharp-edge causes and mitigation steps.

When to use it

  • Designing a crew of agents to achieve a complex business workflow
  • Converting a monolithic automation into multiple collaborating agents
  • Choosing between sequential, hierarchical, or parallel orchestration for a process
  • Configuring memory and state for long-running multi-step interactions
  • Validating agent roles, tasks, and handoff contracts before deployment

Best practices

  • Define each agent as a clear persona with responsibilities, inputs, outputs, and success criteria
  • Decompose work into explicit tasks with expected artifacts to reduce ambiguity in handoffs
  • Choose orchestration pattern that matches dependencies: sequential for linear steps, hierarchical for oversight, parallel for independent subtasks
  • Use memory only where state materially affects decisions; prefer explicit task outputs for reproducibility
  • Validate designs against common failure modes and enforce constraints before deployment

Example use cases

  • Customer support crew: triage agent, domain expert agents, summarizer, and response synthesizer in a sequential-to-parallel flow
  • Content production: researcher, writer, editor, and SEO reviewer working in a hierarchical review loop
  • Data operations: parallel data collectors, aggregator, and validator coordinating via shared memory snapshots
  • Compliance workflow: monitor agent flags tasks to an escalation agent and records handoffs for audit

FAQ

How do I pick between sequential and hierarchical processes?

Pick sequential when steps are strictly ordered and each output is required for the next. Use hierarchical when one agent oversees or validates outputs from multiple workers and can reassign or refine subtasks.

When should agents share memory vs return explicit outputs?

Prefer explicit outputs for traceability. Use shared memory for context that multiple agents must reference frequently, but limit size and lifetime to reduce drift and inconsistency.

How do you prevent role ambiguity causing failures?

Enforce strict role contracts: define inputs, outputs, acceptance criteria, and error paths. Include explicit handoff steps and a validator agent to check artifacts before continuing.