Build a Blog Writing Crew with CrewAI

Build a multi-agent AI system with CrewAI to write blog posts.

Introduction

⚡️ 30 Second Summary

You have probably used AI chatbots to help you write before, but what if instead of one AI doing everything, you could build a whole team of AI specialists that each handle a different part of the job?

In this project, you will build a multi-agent system using CrewAI where three AI agents (a Researcher, a Writer, and an Editor) collaborate in a sequential workflow to produce a polished blog post on any topic you choose.

What You'll Build

A Blog Writing Crew: a team of three AI agents configured with distinct roles, goals, and backstories that work together in sequence to research, draft, and edit a complete blog post.

By the end of this project, you'll have:

  • 🤖 A CrewAI project scaffolded with the CLI, complete with YAML configuration files for agents and tasks.
  • 🔬 Three specialized AI agents (Researcher, Writer, Editor) each with their own role, goal, and backstory defined in agents.yaml.
  • 🔗 Three chained tasks wired together in a sequential workflow using crew.py.
  • 📝 A generated markdown blog post saved to output/blog_post.md, created entirely by your AI crew.
  • 💎 Secret Mission: Add a fourth Social Media Manager agent that creates Twitter/X thread and LinkedIn post summaries from the blog post.

Want a complete demo of how to do this project, from start to finish? Check out our walkthrough with Maya.

Do I need to pay to do this project?

Nope. This project uses the Google Gemini API free tier via Google AI Studio, so there is no cost and no credit card required. You just need a Google account to get your API key.

Not sure if this project is right for you? Check if it matches your goals

If you're up for a bit of a challenge, quiz yourself on the key concepts up ahead in this project.

Set Up Your Environment

To build our blog writing crew, we need a few tools installed on our computer. CrewAI is a Python framework, so we need Python and a package manager to install it. We also need an API key to connect our crew to an AI model that powers their thinking.

In this step, we will install Python, a package manager called uv, and the CrewAI CLI. Then we will grab a free API key from Google to use Gemini as the brain behind our agents.

In this step, get ready to:

  • Install Python and the uv package manager.
  • Install the CrewAI CLI.
  • Get a free Gemini API key.

Install Python

Python is the programming language that CrewAI is built on. Let's make sure you have it installed.

🍎 macOS

  • Open the Terminal app. You can find it by pressing Cmd + Space and typing Terminal.

🖼️ Windows

  • Open PowerShell. You can find it by pressing Win + S and typing PowerShell.
  • Run this command to check if Python is already installed:
python3 --version

✔️ I see a version number

You should see something like Python 3.12.x or higher. As long as it is 3.10 or above, you are good to go.

ⓧ Command not found

No worries, let's install Python.

  • Head to python.org/downloads and download the latest version for your operating system.
  • Run the installer and follow the prompts.

Still seeing an error after installing?

You may need to close and reopen your terminal for the changes to take effect. How do I fix my Python installation?

  • Run python3 --version again to confirm the installation worked.

Install uv and the CrewAI CLI

uv is a fast Python package manager that CrewAI uses under the hood. We will use it to install the CrewAI command-line tool.

  • Check if uv is already installed by running:
uv --version

✔️ I see a version number

You already have uv installed. Skip ahead to installing the CrewAI CLI below.

ⓧ Command not found

No worries, let's install uv.

🍎 macOS/Linux

  • Copy and paste this command into your terminal:
curl -LsSf https://astral.sh/uv/install.sh | sh

🖼️ Windows

  • Open PowerShell and run:
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

What is uv?

uv is a fast Python package manager built in Rust. It replaces older tools like pip and virtualenv with a single, much faster tool. CrewAI uses uv under the hood to manage your project's dependencies and virtual environment.

  • Now install the CrewAI CLI using uv:
uv tool install crewai

Seeing a PATH warning?

If uv shows a warning about your PATH, run uv tool update-shell and then close and reopen your terminal. How do I fix PATH issues with uv?

  • Verify that CrewAI is installed by running:
uv tool list

You should see crewai listed in the output.

Get a Free Gemini API Key

Our crew needs an AI model to do its thinking. We will use Google's Gemini model, which is free to use.

  • Go to Google AI Studio.
  • Sign in with your Google account.
  • Click Get API Keys in the bottom left to navigate to the API Keys page.
  • Click on API Keys in the left panel.
  • Click Create API Key.

I see a project selection dropdown

  • Select Create API key without a project from the dropdown.
  • Give your key a name like blog-writing-crew and click Create API Key.

I see a key name field

  • Give your key a name like blog-writing-crew and click Create API Key.
  • Copy the generated key and save it somewhere safe. You will need it in the next step.

Keep your API key private.

Never share your API key publicly or commit it to a repository. Treat it like a password.

Your environment is ready and your tools are installed. Next up, you will put them to work and create your very first CrewAI project.

Create Your CrewAI Project

You've got your tools installed and your API key ready. The next thing we need is a project structure for our blog writing crew. Think of it like setting up an office before hiring your team.

CrewAI comes with a CLI that scaffolds an entire project for you, complete with config files, Python code, and a ready-to-go folder structure. But where do we tell our agents which LLM to use? That's where the environment variables come in.

In this step, get ready to:

  • Create a new CrewAI project using the CLI.
  • Explore the project structure.
  • Configure your API key and model settings.

Create Your Crew Project

  • Return to your Terminal.
  • Navigate to your Desktop so the project is easy to find:
cd ~/Desktop
  • Run this command to scaffold a new crew project:
crewai create crew blog-writing-crew

What does this command do?

crewai create crew blog-writing-crew tells the CrewAI CLI to generate a new project called blog-writing-crew. It creates all the folders and files you need to define agents, tasks, and the crew that orchestrates them. It also configures your AI provider and stores your API key in the project's .env file.

The CLI will ask you to select a provider. This is the AI model provider your crew will use for thinking.

  • Type the number next to gemini in the list and press Enter.
  • When prompted to choose a model, select gemini/gemini-2.5-flash. Type that option's number and press Enter.

Don't see gemini-2.5-flash in the list?

Select any available Gemini model for now. You can update the model later by opening the .env file in your project and changing the MODEL value to gemini/gemini-2.5-flash.

  • When prompted for your API key, paste the Gemini API key you saved in the previous step and press Enter.
  • Navigate into your new project folder:
cd blog_writing_crew
  • Open the blog_writing_crew folder in your code editor (VSCode/Cursor).

Explore the Project Structure

Your new project has a specific layout. Each file has a purpose in how your crew operates.

  • Run this command in your terminal to see the project's files and folders:
ls -R

Here is what the structure looks like:

blog_writing_crew/
├── .env
├── .gitignore
├── AGENTS.md
├── pyproject.toml
├── README.md
├── knowledge/
│   └── user_preference.txt
├── tests/
└── src/
    └── blog_writing_crew/
        ├── __init__.py
        ├── main.py
        ├── crew.py
        ├── tools/
        │   ├── custom_tool.py
        │   └── __init__.py
        └── config/
            ├── agents.yaml
            └── tasks.yaml

What are all these files?

Here is what each key file does:

  • config/agents.yaml is where you define your agents and their roles, goals, and backstories.
  • config/tasks.yaml is where you define the tasks each agent will perform.
  • crew.py is the Python code that wires everything together and orchestrates the crew.
  • main.py is the entry point that kicks off the crew when you run the project.
  • .env is where you store your API key and model configuration.

How does a CrewAI project work?

Think of a CrewAI project like a small company. You have agents (the team members), tasks (the jobs they need to do), and a crew (the manager that runs the whole operation). In the next few steps, you will:

  1. Define your agents in agents.yaml (who they are).
  2. Define your tasks in tasks.yaml (what they do).
  3. Wire them together in crew.py (how they collaborate).
  4. Kick it all off in main.py (run the crew).

Verify Your API Key and Model

The crewai create command already saved your API key and model selection to the project's .env file. Let's open it up and make sure everything looks right.

  • In your code editor's sidebar, find and click on the .env file in your project root folder.

You should see two lines:

GEMINI_API_KEY=your_actual_key_here
MODEL=gemini/gemini-2.5-flash

What do these two lines mean?

GEMINI_API_KEY authenticates your requests to Google Gemini. MODEL tells CrewAI which specific model to use for all your agents. Gemini 2.5 Flash is fast, capable, and free to use.

🙋‍♀️ Something look wrong?

Make sure GEMINI_API_KEY has your full key with no extra spaces around the = sign. If the MODEL value is different, update it to gemini/gemini-2.5-flash and save the file. Still stuck?

Your project is scaffolded and your LLM is configured. Next up, you will define the three agents that make up your blog writing team.

Define Your Agents

Your CrewAI project is scaffolded and your API key is connected. The next thing we need is the team itself: the AI agents that will research, write, and edit your blog post.

Think of agents like team members. Each one needs a clear identity so they know what their job is, what they are trying to achieve, and what kind of expertise they bring. But how does an AI agent know what kind of expert it is? In CrewAI, you define all of this in a single configuration file called agents.yaml.

In this step, get ready to:

  • Replace the default agents with three custom agents.
  • Configure each agent with a role, goal, and backstory.

Replace the Default Agents

Your project came with some placeholder agents, but we need agents that are built for blog writing. You will replace the defaults with three specialists: a Researcher, a Writer, and an Editor.

Let's add them one at a time so you can understand each agent's role.

  • In your code editor, navigate to src > blog_writing_crew > config.
  • Click on agents.yaml to open it.
  • Select all the existing content in the file by pressing Cmd+A (macOS) or Ctrl+A (Windows), then delete it.

Add the Researcher Agent

The Researcher is responsible for digging into a topic and finding the most important information. This agent's output will be the foundation for the entire blog post.

  • Paste the following into your now-empty agents.yaml file:
researcher:
  role: >
    {topic} Research Analyst
  goal: >
    Find the most important and interesting information about {topic}
  backstory: >
    You are a thorough researcher who digs deep into any subject.
    You find the most relevant facts, trends, and key insights
    that will form the foundation of an excellent blog post.
  • Save the file by pressing Cmd+S (macOS) or Ctrl+S (Windows).

What are role, goal, and backstory?

Each agent in CrewAI needs three fields that shape how it behaves:

  • The role tells the agent what job title it has.
  • The goal tells it what outcome to aim for.
  • The backstory gives it a persona and expertise to draw from when generating responses.

Together, they guide the large language model to produce output that matches the agent's specialty.

💡 What is {topic}?

Notice how the researcher uses {topic} in its role and goal. This is a variable placeholder that gets filled in at runtime. When you eventually run your crew, you will pass in a topic like "AI in Healthcare" and CrewAI automatically swaps {topic} for that value. This means your crew can write about any subject without changing the configuration.

Add the Writer Agent

The Writer takes the Researcher's findings and turns them into an engaging blog post. Think of this agent as your content creator.

  • Add the following below the researcher configuration in agents.yaml:
writer:
  role: >
    {topic} Blog Writer
  goal: >
    Write an engaging, well-structured blog post about {topic}
  backstory: >
    You are a skilled writer who turns complex research into
    compelling blog content. You write in a way that is easy to
    read, well-organized, and keeps the reader hooked from
    start to finish.
  • Save the file.

Add the Editor Agent

The Editor is your quality control. This agent reviews the Writer's draft and polishes it into a final, publication-ready piece.

  • Add the following below the writer configuration in agents.yaml:
editor:
  role: >
    Senior Content Editor
  goal: >
    Polish and refine the blog post for clarity, grammar, and flow
  backstory: >
    You are a meticulous editor with an eye for detail. You
    review content for grammar, clarity, and overall flow,
    ensuring every piece of content is publication-ready.
  • Save the file.

Your agents now have their identities. Next up, you will give them specific tasks to complete so your crew knows exactly what work to do.

Define Your Tasks

Your three AI agents know who they are, but they don't know what to do yet. Right now, if you ran your crew, the agents would have no instructions to follow and nothing would happen.

To produce a blog post, we need to tell each agent exactly what job to complete and what their finished work should look like. In CrewAI, these instructions are called tasks. You will create three tasks that chain together: first research the topic, then write a blog post from that research, then edit and polish the final draft.

In this step, get ready to:

  • Define three sequential tasks in the tasks.yaml file.
  • Connect each task to its responsible agent.

Open Your Tasks Configuration

  • In your code editor's sidebar, navigate to src > blog_writing_crew > config and click on tasks.yaml to open it.
  • Select all the existing content by pressing Cmd+A (macOS) or Ctrl+A (Windows), then delete it.

You are going to replace it with three task definitions that chain together: research, write, then edit. Let's add them one at a time.

Define the Research Task

The first task in the chain is research. The Researcher agent will gather key facts and insights about the topic.

  • Paste the following into your now-empty tasks.yaml file:
research_task:
  description: >
    Research {topic} thoroughly. Find key facts, recent trends,
    and interesting angles that would make a compelling blog post.
    Focus on providing accurate, up-to-date information.
  expected_output: >
    A structured research brief with 8-10 key points about {topic},
    including relevant facts, statistics, trends, and unique angles
    that can be used to write an engaging blog post.
  agent: researcher

What is expected_output?

Each task has a description (what to do) and an expected_output (what the finished work should look like). The expected_output gives the AI agent a clear target to aim for, which leads to better, more focused results.

Notice the agent: researcher field at the bottom. This tells CrewAI which agent is responsible for this task. It maps directly to the researcher key you defined in agents.yaml.

Define the Writing Task

The second task takes the Researcher's output and turns it into a full blog post. The Writer agent handles this one.

  • Add the following below the research task in tasks.yaml:
writing_task:
  description: >
    Using the research brief provided, write an engaging blog post
    about {topic}. The post should have a compelling introduction,
    3-4 well-structured main sections, and a strong conclusion.
    Make it informative yet accessible to a general audience.
  expected_output: >
    A complete blog post in markdown format, approximately 800-1000
    words, with an engaging title, introduction, 3-4 main sections
    with subheadings, and a conclusion.
  agent: writer

Define the Editing Task

The final task is editing. The Editor agent reviews and polishes the Writer's draft into a publication-ready piece. This task also includes an output_file field that saves the final result to a file.

  • Add the following below the writing task in tasks.yaml:
editing_task:
  description: >
    Review and polish the blog post for clarity, grammar, flow,
    and engagement. Ensure the tone is consistent, the structure
    is logical, and the content is compelling. Fix any errors
    and improve readability.
  expected_output: >
    A final, polished blog post in markdown format ready for
    publication. The post should be well-structured, error-free,
    and engaging.
  agent: editor
  output_file: output/blog_post.md
  • Save the file.

Notice how these three tasks form a pipeline:

  1. The researcher agent produces a research brief.
  2. The writer agent takes that brief and turns it into a blog post.
  3. The editor agent polishes the final post and saves it to output/blog_post.md.

Why does only the last task have output_file?

The output_file field on editing_task tells CrewAI to save the final result to a file. Only the last task in the chain needs this because earlier outputs are passed directly to the next agent in memory.

Your tasks are defined and chained together. Next up, you will wire everything together in the Python code and bring your crew to life.

Wire Up the Crew in Python

You have three agents and three tasks defined in YAML, but right now they are just text files sitting in a folder. To turn those definitions into a working crew, you need a Python file that reads the configurations, creates the actual objects, and tells CrewAI how to run them.

Think of it this way: the YAML files are the blueprints, and crew.py is the construction manager that brings those blueprints to life.

In this step, get ready to:

  • Update crew.py to connect your agents and tasks into a crew.
  • Update main.py to pass a topic to your crew.

Update the Crew File

The crew.py file is the heart of your CrewAI project. It uses special decorators to link your YAML configurations to Python objects. Each method name must exactly match the keys you defined in your YAML files.

  • In your code editor's sidebar, navigate to src > blog_writing_crew and click on crew.py to open it.

The default crew.py came with placeholder agents and tasks from the CrewAI template (like researcher and reporting_analyst). You need to replace these with methods that match the three agents and three tasks you just defined in your YAML files.

  • Select all the existing content by pressing Cmd+A (macOS) or Ctrl+A (Windows), then delete it.
  • Paste the following code. This is Part 1: the imports and agent methods.
from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task

@CrewBase
class BlogWritingCrew():
    """Blog Writing Crew"""

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            verbose=True
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            verbose=True
        )

    @agent
    def editor(self) -> Agent:
        return Agent(
            config=self.agents_config['editor'],
            verbose=True
        )

What do these agent methods do?

Each @agent method creates a Python object from your YAML configuration. For example, self.agents_config['researcher'] pulls the role, goal, and backstory you defined for the researcher in agents.yaml. The method name (researcher) must exactly match the key in your YAML file.

  • Now add Part 2: the task methods directly below the agent methods (still inside the class):

Indentation matters in Python!

Parts 2 and 3 must be indented with 4 spaces to stay inside the BlogWritingCrew class. If your code is not indented correctly, Python will not recognize these methods as part of the class and you will get an IndentationError when you try to run your crew. Double-check that each @task and @crew decorator lines up with the @agent decorators above it.

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config['research_task']
        )

    @task
    def writing_task(self) -> Task:
        return Task(
            config=self.tasks_config['writing_task']
        )

    @task
    def editing_task(self) -> Task:
        return Task(
            config=self.tasks_config['editing_task'],
            output_file='output/blog_post.md'
        )

What do these task methods do?

Each @task method creates a task object from your tasks.yaml configuration. Notice the editing_task also has output_file='output/blog_post.md'. This tells CrewAI to save the final result to a file.

  • Finally, add Part 3: the crew method below the task methods:
    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True
        )

What does the crew method do?

The @crew method ties everything together. It collects all your agents and tasks and tells CrewAI to run them in sequential order, one after another.

  • Save the file.

What are decorators?

Decorators in Python are special functions that modify the behavior of other functions. In CrewAI, decorators like @agent, @task, and @crew tell the framework how to automatically connect your methods to the YAML configuration files. The @CrewBase decorator on the class sets everything up so self.agents_config and self.tasks_config pull directly from your YAML files.

What happens if I get a method name wrong?

✔️ My code looks right

Great, you are all set! Move on to updating the main file below.

I want to verify my code

Compare your crew.py against this complete version. Pay close attention to the indentation. Every method should be indented with 4 spaces inside the class.

from crewai import Agent, Crew, Process, Task
from crewai.project import CrewBase, agent, crew, task

@CrewBase
class BlogWritingCrew():
    """Blog Writing Crew"""

    @agent
    def researcher(self) -> Agent:
        return Agent(
            config=self.agents_config['researcher'],
            verbose=True
        )

    @agent
    def writer(self) -> Agent:
        return Agent(
            config=self.agents_config['writer'],
            verbose=True
        )

    @agent
    def editor(self) -> Agent:
        return Agent(
            config=self.agents_config['editor'],
            verbose=True
        )

    @task
    def research_task(self) -> Task:
        return Task(
            config=self.tasks_config['research_task']
        )

    @task
    def writing_task(self) -> Task:
        return Task(
            config=self.tasks_config['writing_task']
        )

    @task
    def editing_task(self) -> Task:
        return Task(
            config=self.tasks_config['editing_task'],
            output_file='output/blog_post.md'
        )

    @crew
    def crew(self) -> Crew:
        return Crew(
            agents=self.agents,
            tasks=self.tasks,
            process=Process.sequential,
            verbose=True
        )

Update the Main File

The main.py file is the entry point that kicks off your crew. You need to update the inputs dictionary so your crew knows what topic to write about.

  • Open src/blog_writing_crew/main.py.
  • Find the run function and look for the inputs dictionary. It should already have a topic key with a default value.
  • Change the topic to something you are interested in, for example:
inputs = {
    'topic': 'The Future of AI Agents'
}
  • Save the file.

How does the topic reach your agents?

Remember the {topic} placeholder you used in your YAML task descriptions? When you pass a topic in the inputs dictionary, CrewAI automatically replaces every {topic} placeholder across your task configurations with this value.

Everything is connected. Your agents know their roles, your tasks define their work, and crew.py ties it all together into a sequential workflow. Time to install the dependencies and watch your crew in action.

Run Your Blog Writing Crew

Your agents, tasks, and crew are all configured and wired together. The only thing left to do is install the project dependencies and actually launch your CrewAI crew to see your AI agents collaborate in real time.

But wait. We defined Google Gemini as our language model, so we need to make sure CrewAI knows how to talk to it. We also need to install all the project dependencies that CrewAI's scaffolded project requires.

In this step, get ready to:

  • Install dependencies and run your crew.
  • Watch your agents collaborate to produce a blog post.
  • Experiment with a different topic.

Install Dependencies

Before running your crew, you need to install the Google Gemini integration package and lock all project dependencies.

  • In your terminal, make sure you are inside your blog_writing_crew project folder. You can confirm by running ls. You should see a file called pyproject.toml in the output.
  • Run this command to add the Google Gemini integration to your project:
uv add "crewai[google-genai]"

What does this command do?

uv add "crewai[google-genai]" adds the Google Gemini integration as a dependency to your project. The [google-genai] part is called an "extra". It tells uv to install the additional packages CrewAI needs to communicate with the Gemini API.

  • Run this command to lock and install all project dependencies:
crewai install

What does crewai install do?

crewai install locks all dependency versions and installs everything your project needs to run. Think of it like a final setup step that makes sure all the packages are ready.

✔️ It worked

You should see a message confirming that dependencies were installed successfully. You are ready to run your crew.

ⓧ I see an error

That's okay! Let's troubleshoot:

  • Check that CrewAI is installed correctly.
  • Check that uv is installed.
  • Make sure you are inside your CrewAI project directory (the folder containing pyproject.toml).
  • Try running the commands again.

Still stuck?

Get help with your error or share your error with the NextWork community!

  • Create the output directory that your editing task writes to:
mkdir -p output

What does this command do?

Remember how your editing_task in tasks.yaml has output_file: output/blog_post.md? That tells CrewAI to save the final blog post into an output folder. But that folder does not exist yet. The mkdir -p output command creates it so CrewAI has somewhere to write the file. Without this folder, the crew would fail when trying to save the final result.

Run Your Crew

  • Run your crew with this command:
crewai run

Watch the terminal output carefully. You will see each agent thinking through their task in real time. The Researcher analyzes the topic and produces a research brief with key points and supporting details. The Writer takes that brief and drafts a complete blog post. The Editor reviews and polishes the draft into the final version.

✔️ It worked

You should see all three agents complete their tasks, with the final output saved to output/blog_post.md.

ⓧ I see an error

That's okay! Let's troubleshoot:

IndentationError

Python is very strict about indentation. If you see an IndentationError or unexpected indent, your code spacing is off in crew.py.

  • Open crew.py and check that every method inside the BlogWritingCrew class is indented with exactly 4 spaces.
  • The @agent, @task, and @crew decorators should all be at the same indentation level (4 spaces in from the class definition).
  • The return statements inside each method should be indented 8 spaces (4 for the class + 4 for the method body).
  • Make sure you did not accidentally mix tabs and spaces. In your code editor, enable "Show Whitespace" to check. How do I fix mixed tabs and spaces?
  • If you pasted Parts 1, 2, and 3 separately, make sure Parts 2 and 3 are indented inside the class, not at the top level.

Other errors

  • Check that your GOOGLE_API_KEY environment variable is set correctly. How do I check this?
  • Check that your agents.yaml and tasks.yaml files have no syntax errors. How do I validate my YAML files?
  • Make sure the output directory exists by running mkdir -p output.
  • Try running crewai run again.

Still stuck?

Get help with your error or share your error with the NextWork community!

What is happening behind the scenes?

When you run crewai run, CrewAI executes your sequential workflow. Each agent receives the output of the previous agent's task as context. The Researcher's brief feeds into the Writer's draft, and the Writer's draft feeds into the Editor's final polish. This is multi-agent collaboration in action.

  • Open the generated blog post at output/blog_post.md to see the final result.

Try a Different Topic

Before running a new topic, rename your existing blog post so it does not get overwritten.

  • In your terminal, rename the existing output file:
mv output/blog_post.md output/blog_post_1.md
  • Open main.py and change the topic to something different, for example "How to Learn Programming as a Beginner".
  • Save the file.
  • Run crewai run again.

Check output/blog_post.md to see a completely different blog post generated by your crew. Your first blog post is safely saved as output/blog_post_1.md.

You have just built and run your first multi-agent AI system. Three AI agents collaborated to research, write, and edit a blog post, all orchestrated by CrewAI. Ready for a bonus challenge?

Secret mission

Your blog writing crew works great, but what if it could also create social media content from the blog post? In this secret mission, you will add a fourth agent to your CrewAI crew: a Social Media Manager that turns polished blog posts into Twitter/X threads and LinkedIn posts.

In this secret mission, get ready to:

  • Add a social_media_manager agent to your crew.
  • Create a social_media_task that generates social media content.
  • Run the expanded crew and check your social media output.
  • Experiment with the agent's backstory to change the output tone.

Add a Social Media Manager Agent

Clean Up Your Resources

Clean Up Your Resources

Decide whether to keep your resources running, pause them to come back later, or delete them entirely. This project runs entirely locally, so there are no ongoing costs.

Resources you used:

  • Gemini API key (stored in .env file)
  • CrewAI project directory (blog_writing_crew)
  • Python virtual environment (managed by uv)
  • Generated blog post output files.

✔️ Keep everything running

No action needed. Choose this if you're still actively building or want to keep testing right away.

Your project files are stored locally with no ongoing costs. The Gemini API free tier does not charge you for idle keys.

✋ Pause - I'll come back to this later

Shut down running processes to free up memory, but keep all your files and data so you can pick up where you left off.

Since CrewAI runs as a script and exits when finished, there are no background processes to stop. Your project is already paused.

To pick up where you left off later, navigate to your blog_writing_crew directory and run crewai run again.

ⓧ Delete - I don't want to use this again

Remove all project resources and start fresh if you ever want to rebuild.

  • Delete the project directory:

🍎 macOS/Linux

rm -rf blog_writing_crew

🖼️ Windows

Remove-Item -Recurse -Force blog_writing_crew
  • Optionally, revoke your Gemini API key in Google AI Studio if you no longer plan to use it.

p.s. Does it say "Still tasks to complete!" at the bottom of the screen?

This means you still have screenshots left to upload, or questions left to answer!

  1. Press Ctrl+F (Windows) or Command+F (Mac) on your keyboard.
  2. Search for the text Return to later.
  3. Jump straight to your incomplete tasks!
  4. 🙋‍♀️ Still stuck? Ask the community!

That's a Wrap!

That's a Wrap!

Nice work! 🚀 You've just built a multi-agent AI system that writes complete blog posts using CrewAI.

You've learned how to:

  • 🛠️ Install CrewAI and scaffold a project using the CLI.
  • 🤖 Configure three AI agents with distinct roles, goals, and backstories.
  • 🔗 Define sequential tasks that chain together: research, write, and edit.
  • 🐍 Connect everything in Python and run your crew with the Gemini API.
  • 📝 Generate a complete blog post written entirely by AI agents.
  • 🧠 Understand the core CrewAI concepts: Agents, Tasks, crews, and sequential processes.
  • 💎 Add a Social Media Manager agent to create Twitter/X threads and LinkedIn posts from the blog.

Ready to quiz yourself? 💪