The CrewAI Quickstart No One Writes: Beyond Hello World, Into Something Real

Every tutorial gives you two agents and a print statement. This one gives you a complete, working intelligence system you can actually use — with tools, memory, file output, and real output quality.

There is a tutorial graveyard on the internet.

It is filled with CrewAI quickstart that all look the same. Two agents. One task. A crew.kickoff() call. A print(result) at the bottom. You run it, something appears in the terminal, and then you sit there wondering: now what?

The hello world problem in agent frameworks is worse than in most domains — because hello world actually runs. It produces output. It looks like it worked. So you follow the tutorial to completion, feel briefly satisfied, and then discover that the gap between what you just built and something you could actually use is enormous.

CrewAI is a lightweight, lightning-fast Python framework for orchestrating autonomous AI agents. It gives developers high-level simplicity and low-level control, optimised for production-ready multi-agent workflows that care about reliability, observability, and cost efficiency. That description is accurate. The average tutorial does not get you there.

This article does. By the end, you will have built a Company Intelligence Crew — a three-agent system that takes a company name, researches it live from the web, analyzes its market position, and produces a structured competitive intelligence brief saved as a file you can actually use. Something you could run on a client before a meeting, or drop into a sales workflow, or hand to a teammate.

Real inputs. Real tools. Real output. Let’s build it.

“The difference between a demo and a system is not the number of agents. It is whether you would trust the output with your name on it.”

What Every Tutorial Gets Wrong

Before we write a line of code, it is worth being precise about what the standard quickstart is missing — because those gaps are exactly what this build fixes.

No tools. A CrewAI agent without tools is an agent that cannot reach beyond its training data. It can only synthesize what it already knows. That is useful for brainstorming and summarization. It is useless for anything that requires current, specific, verifiable information. Every real-world crew needs at least one agent with live web access or data retrieval capability.

No expected_output. This single field is the most underused feature in the entire framework. When you skip it, the model decides for itself what a complete response looks like — and it will optimize for length and fluency over precision and usefulness. Setting expected_output is the difference between getting a report and getting a word salad of the right approximate length.

No file output. Printing to the terminal is fine for development. It is useless in practice. A competitive intelligence brief you cannot save, share, or reference later is not a deliverable — it is a demo. Real crews save their output somewhere.

No memory. The default quickstart runs stateless. Every kickoff starts from scratch. For a one-shot tool this is fine. For anything that benefits from context across sessions — a recurring research workflow, a crew that handles similar queries repeatedly — stateless is a significant limitation.

Vague agent definitions. “You are a helpful assistant” is not a role. It is the absence of a role. The backstory, goal, and role definition are the primary levers you have over agent behavior. Vague definitions produce generic output. Specific definitions produce specific output.

The build below addresses all five gaps. This is not a toy. It is the minimum viable crew for a real use case.

What You Are Building: The Company Intelligence Crew

The project: a three-agent crew that produces a competitive intelligence brief on any company you name.

Why this project: It is immediately useful (you can run it before a sales call or partnership meeting), it requires live web research (so tools are not optional), it has clear quality criteria (a brief is either useful or it is not), and it scales naturally (you can adapt it to any research domain).

Three agents:

A Researcher who uses live web search to gather current information — funding rounds, product launches, leadership changes, recent news. Evidence-first, source-cited, uncertainty-flagged.

An Analyst who takes the raw research and extracts strategic signal — market position, competitive differentiation, growth indicators, potential risks. Skeptical of press releases, focused on what the data actually shows.

A Writer who turns the analysis into a clean, structured brief a busy person can read in three minutes. Precise, no filler, formatted for the reader.

Three tasks, three outputs, one saved file.

Tools extend the abilities of agents beyond language processing, enabling real-world action. The Crew represents the overarching team structure that manages agents, tasks, and tools — defining how agents interact, assigning workflows, and coordinating execution strategies.

Setup: The Right Way

CrewAI requires Python 3.10 or higher (up to Python 3.13) and works on macOS, Linux, and Windows. You will also need an API key from at least one LLM provider — OpenAI, Anthropic, Google Gemini, or Azure OpenAI are all supported through CrewAI’s built-in LiteLLM integration.

The setup that tutorials skip telling you about: your environment variables. Set them before you write any crew code:

# Create and activate a clean environment first
python -m venv crewai-env
source crewai-env/bin/activate     # Windows: crewai-env\Scripts\activate

# Install CrewAI with tools support
pip install crewai crewai-tools

# Your .env file needs these - never hardcode API keys
OPENAI_API_KEY=your_openai_key_here
SERPER_API_KEY=your_serper_key_here   # For live web search

The Serper API key is what most tutorials omit entirely. It powers the SerperDevTool — the web search capability that makes the Researcher agent actually useful. Serper offers a free tier with 2,500 queries per month. Get the key at serper.dev before you write the first agent.

Create a load_dotenv() call at the top of your script. Every API key in a hardcoded string is a future security incident.

Building the Crew: All Three Agents

import os
from dotenv import load_dotenv
from crewai import Agent, Task, Crew, Process
from crewai_tools import SerperDevTool

load_dotenv()
# Tools - assigned to agents that actually need them
search_tool = SerperDevTool()

# Agent 1: Researcher
# Evidence-first. Cites sources. Flags what it cannot verify.
researcher = Agent(
    role="Competitive Intelligence Researcher",
    goal=(
        "Find current, verified information about {company}. "
        "Prioritise recent news (last 6 months), funding events, "
        "product launches, leadership changes, and customer signals. "
        "Cite sources. Flag anything you cannot verify."
    ),
    backstory=(
        "You spent a decade in competitive intelligence for a top-tier "
        "consultancy. You distinguish between press releases and evidence. "
        "You never speculate - if you are uncertain, you say so explicitly."
    ),
    tools=[search_tool],
    max_iter=3,          # Cap iterations to control cost
    verbose=True
)

# Agent 2: Analyst
# Extracts signal from noise. Grounds every claim in research.
analyst = Agent(
    role="Strategic Market Analyst",
    goal=(
        "Analyse the research on {company}. Identify their current market "
        "position, key competitive differentiators, growth trajectory, "
        "and the top 2 risks or concerns the research surfaces."
    ),
    backstory=(
        "You have analysed hundreds of companies for investment and "
        "partnership decisions. You are deeply skeptical of hype. "
        "Every assertion in your analysis points back to evidence "
        "from the research you received."
    ),
    max_iter=2,
    verbose=True
)

# Agent 3: Writer
# Precision over volume. Formats for a busy reader.
writer = Agent(
    role="Intelligence Brief Writer",
    goal=(
        "Write a clean, structured competitive intelligence brief on "
        "{company} from the analyst's findings. "
        "Format for a senior professional who has 3 minutes to read it."
    ),
    backstory=(
        "You write intelligence briefs for C-suite executives and "
        "investors. You have been told 'no fluff' so many times it is "
        "now a reflex. Every sentence earns its place."
    ),
    max_iter=2,
    verbose=True
)

Three things to notice about these definitions:

First, {company} appears in the goal — this is a CrewAI input variable. When you call crew.kickoff(inputs={"company": "Stripe"}), every {company} in every agent goal and task description gets replaced with the actual value. One crew, any company.

Second, max_iter is set explicitly on every agent. Without it, agents can loop indefinitely on ambiguous tasks. Three iterations is enough for a researcher with good search results. Two is sufficient for analysis and writing.

Third, tools are assigned only to the Researcher. The Analyst and Writer do not need web search — they work from the research output. Assigning tools to agents that do not need them adds token overhead on every call.

Building the Tasks: Where Most People Leave Money on the Table

Tasks are where output quality is actually determined. Most developers write one-sentence descriptions and wonder why the output is generic.

# Task 1: Research
research_task = Task(
    description=(
        "Research {company} thoroughly. Search for:\n"
        "1. Company overview (founding, size, stage, HQ)\n"
        "2. Core product or service and primary customer segment\n"
        "3. Recent news from the last 6 months (funding, launches, partnerships)\n"
        "4. Key leadership and any recent changes\n"
        "5. Any public signals about growth, revenue, or traction\n\n"
        "Run at least 3 separate searches to triangulate findings. "
        "For each major claim, note the source and date."
    ),
    expected_output=(
        "A structured research summary of 400–600 words covering all 5 areas. "
        "Each major claim followed by its source in parentheses. "
        "A 'Confidence' note at the end flagging anything unverified. "
        "No speculation beyond what the sources support."
    ),
    agent=researcher
)

# Task 2: Analysis
analysis_task = Task(
    description=(
        "Using only the research provided, analyse {company}'s strategic position.\n\n"
        "Address:\n"
        "- Where they sit in their market (leader, challenger, niche player)\n"
        "- Their clearest competitive advantage (one specific, defensible thing)\n"
        "- Growth trajectory (accelerating, steady, or signals of slowdown)\n"
        "- Top 2 risks or uncertainties the research surfaces\n\n"
        "Do not introduce information not in the research. "
        "If the research is insufficient to answer a point, say so."
    ),
    expected_output=(
        "A 300–400 word strategic analysis covering market position, "
        "competitive advantage, growth trajectory, and top 2 risks. "
        "Each point supported by a specific reference to the research. "
        "Bullet points allowed for the risks section only."
    ),
    agent=analyst,
    context=[research_task]    # Receives research output as context
)

# Task 3: Intelligence Brief
brief_task = Task(
    description=(
        "Write a competitive intelligence brief on {company} "
        "for a senior professional preparing for a meeting or decision.\n\n"
        "Structure:\n"
        "## Company snapshot (3–4 sentences)\n"
        "## What they do and who they serve (2–3 sentences)\n"
        "## Strategic position (from analysis - 3–4 sentences)\n"
        "## Key recent developments (3 bullets, dated)\n"
        "## Watch points (2 bullets - risks or uncertainties)\n"
        "## Bottom line (1–2 sentences - what should the reader take away)\n\n"
        "Total length: 300–400 words. No filler. No hedging beyond what the analysis warrants."
    ),
    expected_output=(
        "A formatted intelligence brief with the exact 6-section structure above. "
        "300–400 words total. All claims traceable to the research and analysis. "
        "Readable by someone who has not seen any prior context."
    ),
    agent=writer,
    context=[research_task, analysis_task],   # Both prior outputs as context
    output_file="output/intelligence_brief.md" # Saved to disk automatically
)

The context parameter is the mechanism behind sequential information flow. Task 2 receives the full output of Task 1 as part of its prompt. Task 3 receives both. This is how the writer produces a brief grounded in real research without the writer agent needing to search the web itself.

The output_file parameter on the final task saves the brief to output/intelligence_brief.md automatically after the crew runs. Create the output/ directory before running or the write will fail silently.

Assembling the Crew and Running It

import os

# Create output directory
os.makedirs("output", exist_ok=True)

# Assemble the crew
crew = Crew(
    agents=[researcher, analyst, writer],
    tasks=[research_task, analysis_task, brief_task],
    process=Process.sequential,
    memory=True,       # Enable long-term memory across sessions
    verbose=True       # Essential during development
)

# Run it on any company
if __name__ == "__main__":
    company_name = input("Enter company name: ").strip()

    print(f"\nRunning intelligence crew on: {company_name}\n")
    print("=" * 60)

    result = crew.kickoff(inputs={"company": company_name})

    print("\n" + "=" * 60)
    print("Brief saved to: output/intelligence_brief.md")
    print(f"\nSummary:\n{result.raw[:500]}...")

Run it:

python intelligence_crew.py
# Enter company name: Anthropic

Watch verbose=True scroll through the terminal. This is not noise — it is the most valuable debugging instrument in the framework. You can see exactly what the Researcher searched for, what the Analyst concluded, and where the Writer made decisions. Read it during development. Turn it off when you ship.

Five Things No Tutorial Tells You

1. The quality ceiling is set by the Researcher, not the Writer.

If the research task returns thin, vague, or poorly sourced output, nothing the Analyst or Writer does can fix it. The brief will be thin, vague, and poorly sourced. The most important investment in a research crew is the first agent’s definition and tools. Get the Researcher right first.

2. verbose=True is a debugger, not a feature.

Every experienced CrewAI developer reads the verbose output during development — it tells you which agent is looping, which tool call returned empty results, and where the context chain is breaking down. Turn it off before any production deployment. Verbose mode adds latency and generates massive log volumes at scale.

3. context=[] is how you pass information between tasks, not delegation.

A common beginner mistake is to enable allow_delegation=True and expect agents to coordinate automatically. Delegation is for hierarchical crews with a manager agent. For sequential pipelines, context=[previous_task] is how output flows from one agent to the next. Use the right mechanism for your process type.

4. The {variable} pattern in goals and descriptions is your reusability lever.

CrewAI supports multiple LLM providers out of the box through its LiteLLM integration — but the real flexibility for reuse comes from template variables. A crew with {company} in every goal and description runs on any company with a single kickoff(inputs={"company": "..."}) call. The same pattern works for {topic}, {industry}, {date_range}, or any dimension you want to make configurable without rewriting the crew.

5. Memory is opt-in and compounds from day one.

memory=True is one line. When enabled, CrewAI stores session context and can retrieve relevant prior runs semantically. A crew that researches ten companies across ten sessions and has memory enabled starts building a richer context for its research than a stateless crew ever could. Turn it on before your first real run, not after.

Making It Actually Yours: Three Immediate Adaptations

The Company Intelligence Crew as built is the foundation. Here is how to adapt it immediately for different use cases:

Turn it into a competitive landscape tool. Modify the Researcher’s goal to compare {company} against {competitor}. Add a fourth agent — a Comparator — whose task is to synthesize the two research streams and identify where each wins and loses. The context parameter handles the synthesis.

Add a daily briefing mode. Replace {company} with {topic} and modify the Researcher's description to focus on news from the last 24 hours. Schedule it with a cron job. The brief lands in your output/ folder every morning.

Route to different LLMs by agent. The Researcher does most of the token-heavy work — web search results are verbose. Route it to a cheaper, fast model (Haiku, GPT-4o-mini). Reserve a stronger model for the Analyst and Writer where reasoning quality matters more. A one-line llm= assignment on each agent handles routing.

What You Now Have

Compare what you built against the hello world tutorial you started from.

The hello world crew: one agent, no tools, no expected output, one vague task, a string printed to the terminal.

The intelligence crew: three specialized agents, live web search, explicit output specifications on every task, context passing between tasks, memory enabled, output saved to a file you can use.

The gap between those two things is not complexity — the intelligence crew is about 80 lines of readable Python. The gap is knowing which fields matter, why they exist, and what each one is actually doing to the system.

This crash course walks you from hello world to a production-grade multi-agent workflow with CrewAI. That is what you have now. Not a demo that runs once in the terminal. A crew you can hand to someone and say: here, run this, it actually works.

The hello world phase is over. What comes next is deciding what real problem you want to solve with it.

Practical Takeaways

Always set expected_output on every task. This single field has more impact on output quality than any other setting in CrewAI. Be specific about format, length, and structure.

Assign tools only to agents that need them. Every registered tool adds token overhead on every call for that agent. Keep tool access scoped to the minimum necessary.

Use {variable} in goals and descriptions from the start. It costs nothing and turns a single-use script into a reusable system.

Read verbose output during development. The execution trace tells you exactly where things are breaking down — usually in the first agent’s research quality, not in the final agent’s writing.

Create your output directory before running. output_file will fail silently if the directory does not exist. One os.makedirs("output", exist_ok=True) at the top solves this permanently.

Turn on memory before your first real run. Switching from stateless to stateful mid-project means early runs did not contribute to the context pool. Start with memory on.

The Real Quickstart Starts Here

Every hello world was the right place to begin. It just was not the right place to stop.

The Company Intelligence Crew you built today is the right place to stop being a beginner. From here, the variables are your use case, your tools, your quality criteria, and your output format. The mechanics are the same. The decisions are yours.

Pick a company that matters to your work right now. Run it. Read the brief that comes out of output/intelligence_brief.md. Judge it on whether you would actually use it.

If you would — you have a system. If you would not — you know exactly which agent to fix and why.

That is what the hello world never taught you. Now you know.

If this is the kind of depth that actually moves you forward — follow Think in AI Agents. Every article is built around real builds, real decisions, and real output quality — not demos that impress in a terminal and disappear.

What are you building with CrewAI right now? Drop it in the comments — the use cases from this community shape what gets covered next.

If this saved you two hours of frustrating experimentation — clap. It helps other developers find this instead of the hello world tutorials.