Automating Research and Writing Workflows with CrewAI: Researcher + Critic + Writer Pipeline

A single LLM call writes mediocre content. A CrewAI pipeline with specialized agents produces content that passes fact-checking. Here's how.

Your shiny new RTX 4090 is crying tears of silicon—it's trying to run Llama 3.1 70B alone, but you're still getting blog posts with confident, made-up citations and analysis that wouldn't pass a high school book report. The problem isn't your GPU or the model. It's the architecture. A single LLM, no matter how powerful, is a generalist trying to be a specialist. It's why multi-agent systems outperform single agents on complex tasks by 31% on the GAIA benchmark. You need a team.

This is where CrewAI shifts from a neat demo to a production-grade tool. It moves you from a solo pianist (one LLM call) to a conductor orchestrating a symphony of specialized AI agents. We're building a pipeline today: a Researcher that actually finds facts, a Critic that ruthlessly enforces quality gates, and a Writer that synthesizes it all into coherent prose. This is the agent engineering workflow that scales.

The CrewAI Mental Model: Agents, Tasks, and Process

Before you write a line of code, you need to ditch the chatbot mindset. In CrewAI, you define three core constructs, and their relationships are everything.

Agents are your specialized workers. They have a role, a goal, and a backstory. The backstory isn't fluff—it's a prompt engineering lever to bias the agent's behavior. A "Senior Research Analyst" with 10 years of experience at a journal will produce different output than a "Wikipedia Contributor."

Tasks are the specific jobs you give an agent. Each task has an agent assigned, a description of the work, and crucially, expected_output—a clear specification of what "done" looks like. This is your contract.

Crews are the orchestrators. They take your agents and tasks and execute them according to a process. The two main flavors are sequential (Task 1 -> Task 2 -> Task 3) and hierarchical (a manager agent delegates to worker agents). The crew manages the context passing, handoffs, and execution flow.

The mental model is a factory assembly line, not a conversation. Raw materials (a topic) go in, and a validated, polished product comes out.

Defining Specialized Roles: The Researcher, The Critic, The Writer

Generic agents fail. You must be surgically precise with goals and backstories to prevent role collapse, where all your agents start to sound the same. Here’s the configuration for our content pipeline.

from crewai import Agent, Task, Crew, Process
from langchain_openai import ChatOpenAI
import os


llm = ChatOpenAI(model="gpt-4o", temperature=0.1)

# Agent 1: The Bloodhound
researcher = Agent(
    role='Senior Research Analyst',
    goal='Find accurate, recent, and relevant facts, statistics, and quotes about a given topic. Never invent sources.',
    backstory='A meticulous data journalist from The Economist with a deep skepticism of unverified claims. You use multiple sources to triangulate truth.',
    verbose=True,
    allow_delegation=False, # Researchers don't delegate, they research.
    llm=llm
)

# Agent 2: The Gatekeeper
critic = Agent(
    role='Quality Assurance Editor',
    goal='Ruthlessly identify factual inaccuracies, unsupported claims, logical flaws, and stylistic inconsistencies.',
    backstory='A former academic peer-reviewer known for brutal, constructive feedback. You have no patience for fluff or error.',
    verbose=True,
    allow_delegation=False,
    llm=llm
)

# Agent 3: The Synthesizer
writer = Agent(
    role='Technical Content Strategist',
    goal='Transform verified research and critique into clear, engaging, and well-structured technical prose.',
    backstory='A lead technical writer at Stripe who excels at making complex concepts accessible and compelling.',
    verbose=True,
    allow_delegation=False, # Writer can't delegate writing.
    llm=llm
)

Notice the allow_delegation=False. In a simple sequential pipeline, delegation can create confusing loops. We want a clean, predictable handoff.

Tool Assignment: Locking Down Capabilities By Role

This is a critical security and cost control measure. You don't want your Critic or Writer spontaneously deciding to browse the web. Tools are assigned at the agent level. We'll give the Researcher a search tool using a simple LangChain integration.

from langchain_community.tools import DuckDuckGoSearchRun
search_tool = DuckDuckGoSearchRun()

# Re-initialize the Researcher agent with the tool
researcher = Agent(
    role='Senior Research Analyst',
    goal='Find accurate, recent, and relevant facts...',
    backstory='A meticulous data journalist...',
    tools=[search_tool], # ONLY the researcher gets this.
    verbose=True,
    allow_delegation=False,
    llm=llm
)

# Critic and Writer get no tools. Their job is to process context.
critic = Agent(role='Quality Assurance Editor', tools=[], ...)
writer = Agent(role='Technical Content Strategist', tools=[], ...)

By restricting web search to the Researcher, you prevent redundant, costly tool calls and maintain a clear audit trail for where information originated. This is a foundational pattern for building reliable multi-agent workflows.

Chaining Tasks with Explicit Context Passing

Tasks are where the workflow comes alive. The magic is in the context parameter. You explicitly pass the output of one task as the input to the next, creating a directed acyclic graph (DAG) of work.

# Task 1: Research
research_task = Task(
    description='Conduct a thorough web search for the latest developments, market size, and key players in the AI agent engineering space. Focus on data from 2024-2026.',
    expected_output='A bulleted list of at least 7 verified facts, each with a brief description and a note on the source (e.g., "Grand View Research 2025"). No markdown.',
    agent=researcher,
)

# Task 2: Critique. Context comes from research_task.
critique_task = Task(
    description='Review the provided research findings. Identify any statements that lack a clear source, seem outdated, or are logically inconsistent. Propose specific improvements or requests for clarification.',
    expected_output='A numbered list of critiques. For each, state the original claim and the specific issue (e.g., "Unsupported Statistic", "Potential Logical Gap").',
    agent=critic,
    context=[research_task] # Critic sees the researcher's output.
)

# Task 3: Write. Context comes from BOTH previous tasks.
write_task = Task(
    description='Using the validated research and the critique, write a comprehensive 300-word introductory section for a technical blog post titled "The State of AI Agent Engineering in 2026". Incorporate the facts and address the critiques.',
    expected_output='A polished, engaging blog post section in markdown format, with inline citations for facts.',
    agent=writer,
    context=[research_task, critique_task] # Writer sees everything.
)

# Assemble and run the Crew
crew = Crew(
    agents=[researcher, critic, writer],
    tasks=[research_task, critique_task, write_task],
    process=Process.sequential, # Simple, linear flow.
    verbose=2
)

result = crew.kickoff(inputs={'topic': 'AI Agent Engineering Market and Tools'})
print(result)

This explicit context linkage is what prevents agents from working in isolation. The Writer isn't just writing from its own knowledge; it's synthesizing the specific outputs of its teammates.

Sequential vs. Hierarchical: Picking Your Process

The Process.sequential we used is perfect for our linear research->critique->write pipeline. But CrewAI offers another powerful model: Process.hierarchical. This introduces a manager agent that dynamically delegates tasks to other agents based on the overall goal.

Use Sequential when:

• You have a predefined, linear workflow (like a content pipeline).
• Task dependencies are simple and known upfront (Task B always needs Task A's output).
• You want maximum predictability and minimal overhead.

Use Hierarchical when:

• The path to the goal is uncertain and requires planning (e.g., "Solve this bug in my codebase").
• You need dynamic task decomposition. The manager can break a large goal into subtasks and assign them on the fly.
• You're modeling a real-world team structure with a clear lead.

For our focused three-step pipeline, sequential is the right choice. It's faster and more deterministic. Benchmarks show the overhead: for a 10-step pipeline, LangGraph averages 4.2s total latency while CrewAI comes in at 7.8s (3 agents, GPT-4o backend). The trade-off is CrewAI's simpler abstraction versus LangGraph's finer-grained, faster control.

Implementing Quality Gates: The Validation Callback

What stops the Writer from ignoring the Critic's feedback? Nothing, in our basic setup. You need a validation callback. This is a function that checks the final output (or any task's output) against your criteria and rejects it, forcing a redo or triggering an alert.

Here’s a simple validation function that could be attached to the write_task:

def validate_blog_section(output: str) -> bool:
    """Validate the writer's output."""
    # Check 1: Minimum length
    if len(output.split()) < 250:
        print("Validation Failed: Output too short.")
        return False
    # Check 2: Must contain citations (simple pattern match)
    import re
    if not re.search(r'\(.*\d{4}\)', output): # Looks for (Source 2025)
        print("Validation Failed: No citation found.")
        return False
    # Check 3: Must not contain disclaimer phrases
    disclaimer_phrases = ["I am an AI", "as a language model", "I cannot"]
    for phrase in disclaimer_phrases:
        if phrase in output.lower():
            print(f"Validation Failed: Contains disclaimer '{phrase}'.")
            return False
    print("Validation Passed.")
    return True

# Attach to the task
write_task = Task(
    description='...',
    expected_output='...',
    agent=writer,
    context=[research_task, critique_task],
    callback=validate_blog_section # Output is validated after execution.
)

If validate_blog_section returns False, you can configure your crew to retry the task, escalate, or log the failure. This is how you move from hoping for good output to enforcing it.

Debugging Real Agent Problems: Infinite Loops and Hallucinations

When you run this, things will go wrong. Here are two classic errors and their exact fixes, drawn from the trenches.

Error 1: Agent stuck in infinite loop.

• Symptom: The agent output repeats the same "Thought/Action/Observation" cycle, burning tokens without progress.
• Root Cause: The agent can't satisfy its own reasoning loop, often due to a tool that returns an unhelpful result.
• Exact Fix:
  1. Add a hard iteration limit: In your agent definition, use max_iter=15 (or similar) if your framework supports it.
  2. Implement loop detection: In a custom callback, compare the last 3 "Thought" strings. If they are semantically identical, break the loop.
  3. Add a timeout per step: Use asyncio.wait_for on the agent execution step.

Error 2: Tool returns empty, agent hallucinates data.

• Symptom: Your Researcher's search tool returns "" (no results), but its final output contains detailed, made-up statistics.
• Root Cause: The LLM is pattern-matching. It's trained to fill in an answer, so an empty observation triggers fabrication.
• Exact Fix: Wrap your tool. Don't return an empty string. Return an explicit, structured message that breaks the pattern.

from langchain_community.tools import DuckDuckGoSearchRun

def robust_search_wrapper(query: str) -> str:
    """Wrapper that prevents hallucination on empty results."""
    base_tool = DuckDuckGoSearchRun()
    raw_result = base_tool.run(query)
    # Check if the result is essentially empty
    if not raw_result or len(raw_result.strip()) < 50:
        return "SEARCH_RESULTS: No relevant or verifiable information found for this query. Please try a different search term or consult alternative sources."
    return raw_result

# Use the wrapped tool
search_tool = Tool(
    name="Robust Web Search",
    func=robust_search_wrapper,
    description="Searches the web. Returns explicit 'no results' message if none found."
)

This gives the agent a clear, unexpected observation that is harder to ignore, significantly reducing hallucination.

Managing the Bill: Token Usage and Cost Control

This pipeline isn't free. A ReAct agent uses an avg 8,000 tokens per complex task vs 1,500 for a direct LLM call—that's over 5x more expensive. You're paying for the reasoning steps. Here’s how to manage it:

1. Budget per Agent: Assign less expensive models (like GPT-4o-mini) to less critical agents. Maybe the Critic doesn't need the full power of Claude 3.5 Sonnet.
2. Limit Iterations: As discussed, max_iter on your agents directly caps the reasoning steps.
3. Use Summary Memory: For long-running crews, implement a memory system that compresses history every 5 steps. This prevents context from ballooning. An agent with persistent memory achieves 67% task success on day-7 follow-up vs 23% without memory, but that memory must be managed.
4. Monitor with AgentOps/LangSmith: Integrate these tools to get a per-agent, per-task token breakdown. You can't optimize what you can't measure.

Next Steps: From Pipeline to Production

You now have a working, three-agent CrewAI pipeline that produces validated content. This is the foundation. To move to production:

1. Integrate MCP (Model Context Protocol): Replace the generic search tool with MCP-connected tools for your internal data. With 500+ tool integrations within 3 months of launch, MCP lets your Researcher query your company's Notion, Jira, or database directly, grounding content in proprietary knowledge.
2. Add Human-in-the-Loop: Use CrewAI's callbacks to pause the workflow after the Critic's task and send the output to a Slack channel for human approval before the Writer proceeds.
3. Implement Sophisticated Memory: Move beyond short-term context. Use a vector store to give your agents a long-term memory of past research projects, allowing them to build on previous work instead of starting from zero each time.
4. Orchestrate with LangGraph: For the most complex, stateful workflows, consider using CrewAI agents as nodes within a LangGraph. This gives you the fine-grained control over loops and state that yields the 4.2s latency benchmark, while still leveraging CrewAI's clean agent abstractions.

The AI agent market is projected to reach $47B by 2030. The winners won't be those with the single smartest model, but those who can best orchestrate teams of specialized agents. You've just built your first team. Now go deploy it.