CrewAI: orquestar equipos de agentes de IA

CrewAI propone metáfora organizacional: agents como empleados con roles (analista, researcher, writer), trabajando en tasks, organizados en crews (teams). Diferente approach a LangGraph (state graphs) y AutoGen (conversations). Para teams queriendo express workflows en términos humans entienden, CrewAI ofrece abstraction natural.

El modelo

Primitives:

• Agent: LLM con role, goal, backstory, tools.
• Task: unit de work con description y expected output.
• Crew: group de agents collaborating.
• Process: sequential o hierarchical execution.

from crewai import Agent, Task, Crew

researcher = Agent(
    role='Senior Researcher',
    goal='Find cutting-edge information',
    backstory="You are expert researcher...",
    tools=[search_tool]
)

writer = Agent(
    role='Tech Writer',
    goal='Write clear articles',
    backstory="You write for a tech audience...",
)

research_task = Task(
    description="Research latest in LLMs",
    expected_output="Detailed report",
    agent=researcher
)

writing_task = Task(
    description="Write article based on research",
    expected_output="Polished article",
    agent=writer
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, writing_task],
    process=Process.sequential
)

result = crew.kickoff()

Leíble para product managers, no solo engineers.

Process types

Sequential

Task 1 → Task 2 → Task 3. Output de uno → input del next.

Hierarchical

Manager agent coordinates workers. Manager decide qué tasks assign.

Custom

Define tu process logic.

Tools

Agents pueden usar:

• Built-in: search, code execution, file operations.
• Custom: tu Python functions.
• LangChain tools: compatibility layer.

from crewai_tools import SerperDevTool, FileReadTool

researcher = Agent(
    role='Researcher',
    tools=[SerperDevTool(), FileReadTool()],
    # ...
)

CrewAI vs LangGraph

CrewAI: prototyping rápido, human-comprehensible. LangGraph: production-grade, debuggable.

CrewAI vs AutoGen

AutoGen (Microsoft):

• Conversation-based.
• Agents talk to each other.
• Free-form dialogues.

CrewAI:

• Task-based.
• More structured.
• Clearer flow.

Para flows bien definidos, CrewAI. Para exploration, AutoGen.

Modelos y providers

Agnostic:

from langchain_openai import ChatOpenAI
from langchain_anthropic import ChatAnthropic

llm = ChatOpenAI(model="gpt-4o")
# or
llm = ChatAnthropic(model="claude-3-5-sonnet-20240620")

researcher = Agent(
    role='Researcher',
    llm=llm,
    # ...
)

Switch entre proveedores trivial.

Memory

Agents pueden tener memory:

• Short-term: dentro de ejecución.
• Long-term: across runs (via vector DB).
• Entity memory: tracking entities mentioned.

agent = Agent(
    # ...
    memory=True,
    verbose=True
)

Mejor para multi-session interactions.

Casos donde brilla

• Content workflows: research + write + edit pipelines.
• Customer support: triage + resolve + escalate agents.
• Data analysis: collect + analyze + visualize + report.
• Business processes: legal review, contract analysis.
• Prototyping: ideas rápidamente testables.

Limitations

Honest:

• Less debuggable que LangGraph state machines.
• Deterministic flow harder to enforce.
• LLM inconsistency: roles pueden “merge” en execution.
• Observability limited.
• Production-grade: younger que alternatives.
• Task dependencies implicit vs explicit.

Enterprise features

CrewAI tiene enterprise tier:

• Custom deployment.
• Priority support.
• Advanced security.
• Team collaboration.

Paid para production seria.

Flows y Autonomy

Recent CrewAI additions:

• Flows: control explicit over execution.
• Routing: conditional logic.
• Listeners: reactive patterns.

Hace CrewAI más adaptable a complex logic vs originally rigid crew structure.

Integración con tools empresariales

• Slack integration for chat-driven crews.
• Zapier: connect con 5000+ apps.
• REST APIs exposure.
• Databases: connectors.

Productive para automation workflows reales.

Ejemplo producción-ready

from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

# Define agents
market_researcher = Agent(
    role='Market Researcher',
    goal='Identify market trends',
    backstory='Expert analyst...',
    tools=[SerperDevTool()],
    llm=ChatOpenAI(model="gpt-4o")
)

competitor_analyst = Agent(
    role='Competitor Analyst',
    goal='Analyze competitor strategies',
    backstory='Strategist...',
    tools=[SerperDevTool()]
)

report_writer = Agent(
    role='Report Writer',
    goal='Synthesize findings',
    backstory='Senior writer...'
)

# Tasks
research = Task(
    description='Research market for {product}',
    expected_output='Market report',
    agent=market_researcher
)

analyze = Task(
    description='Analyze competitors based on research',
    expected_output='Competitor analysis',
    agent=competitor_analyst,
    context=[research]
)

report = Task(
    description='Write exec summary',
    expected_output='Executive summary',
    agent=report_writer,
    context=[research, analyze]
)

# Crew
crew = Crew(
    agents=[market_researcher, competitor_analyst, report_writer],
    tasks=[research, analyze, report],
    process=Process.sequential,
    verbose=2
)

result = crew.kickoff(inputs={'product': 'AI code assistant'})

Lineas mínimas para workflow completo.

Costes

Coste = tokens LLM × agents × tasks × iterations.

Para crews complex con GPT-4:

• Simple crew (2 agents, 3 tasks): ~$0.50-2 per run.
• Complex crew (5 agents, 10 tasks): ~$5-20 per run.

Factor en pricing productivo.

Conclusión

CrewAI es el framework multi-agent más accesible en términos mental model. Ideal para PMs, domain experts, y developers queriendo express workflows en terms humans entienden. Para production serio con debugging y control, LangGraph gana. Para exploration conversacional, AutoGen. Para PoCs rápidos y workflows business-focused, CrewAI es winner. Sus additions (Flows, Hierarchical) cierran gap hacia production-grade.

Síguenos en jacar.es para más sobre multi-agent systems, LLMs y orchestration.