Multi-agent PRD automation with MetaGPT, Ollama and DeepSeek

Learn how to build an AI-powered tool with MetaGPT, DeepSeek and Ollama that helps product managers quickly create comprehensive product requirement documents (PRDs) by using a team of specialized AI agents.

MetaGPT is a multi-agent framework developed by DeepWisdom, a tech startup focused on developing open source tools that automate work by using artificial intelligence, multi-agent systems and agentic workflows.

Unlike a single-agent approach, where one model attempts to handle all aspects of the task, this multi-agent system assigns each agent a specific role and clearly defined responsibilities. By following structured workflows and reviewing each other’s outputs, the team collectively generates a high-quality PRD that is more aligned with stakeholder goals, better organized and less prone to oversight.

Before we begin, here’s a few terms to help familiarize yourself with the application’s tech stack:

MetaGPT: A framework that structures large language model (LLM) agents into collaborative roles, enabling them to work together like a coordinated team.
Ollama: A local runtime for running and managing open source LLMs directly on your personal computer or workstation.
DeepSeek: An open source language model optimized for tasks like research, reasoning and technical writing.

Creating PRDs can be time-consuming but artificial intelligence can assist by accelerating the process of completion.

Multi-agent collaboration is implemented in frameworks like MetaGPT, an AI tool that orchestrates the coordination of multiple role-playing agents to complete a complex task. A complex task can be considered anything that requires more than one step to complete.

AI PRD creation is an excellent use case for multi-agent collaboration because it mirrors a real-world product development process, where multiple stakeholders contribute to stages such as research, planning, review and refinement. To get the full advantage of AI-generated content, one should consider using a multi-agent system versus a single chatbot like OpenAI’s ChatGPT or Microsoft’s Copilot.

MetaGPT uses specialized AI agents with distinct roles where each different role can be customized to fit nearly any workflow with minimal coding. This flexibility is possible because of the LLM’s strong ability to understand natural language. Users define agent behaviors and workflows through prompt engineering and lightweight software development.

The goal of MetaGPT is to enable effective multi-agent collaboration. By simulating a structured team, it enables role-specific reasoning and task delegation, producing more context-aware and consistent outputs like high-quality PRDs.

Later in this tutorial, we’ll show how a single agent generates an initial PRD draft—similar to using a stand-alone chatbot. We’ll then compare this draft to the final, more accurate PRD produced through multi-agent collaboration. This method will demonstrate how teamwork improves quality beyond what one agent can achieve alone.

DeepSeek, developed by DeepSeek-AI, is a family of cutting-edge open-source LLMs optimized for reasoning tasks, structured content creation and efficient AI development workflows. In this project, we use deepseek-r1, a performant base model ideal for automating product documentation.

Here’s why DeepSeek stands out for building PRDs with a multi-agent system like MetaGPT:

• Structured output for automation: DeepSeek models generate consistent markdown output, which aligns well with workflows that require formal document structures such as PRDs or technical specs.
• Reasoning capabilities: The model supports multiagent interaction loops by handling sequential reasoning and revision steps.
• Performance benchmarks: According to published benchmarks, DeepSeek’s models perform competitively with other open-source models in the 7–13B parameter range, including those from Mistral, LLaMA and IBM® Granite® models. Granite, developed by IBM Research®, is designed for enterprise-grade use cases, with a strong emphasis on governance, robustness and structured business reasoning.
• Local inference: Running deepseek-r1 through Ollama on local GPUs enables lower-latency experimentation without relying on external application programming interfaces (APIs) like OpenAI or Microsoft Azure endpoints (no need for an API key!). This approach can be useful for workflows requiring data privacy or offline development.
• Language support and context window: DeepSeek offers strong multilingual support, including Chinese, and includes a reasonably long context window, which supports extended memory across multiagent sessions.

While DeepSeek is used in this tutorial, the same multi-agent system can be configured to run with other LLMs compatible with Ollama, Hugging Face or OpenAI’s API. The choice of model depends on the tradeoff between reasoning accuracy, output structure, resource availability and intended deployment environment.

MetaGPT uses the concept of standard operating procedures (SOPs) to align human and AI collaboration by structuring workflows based on real-world teams (that is, a software company or product development team).

A SOP provides detailed, step-by-step guidelines for completing a specific task or process. MetaGPT applies this concept by decomposing complex tasks (like creating a PRD) into clear, actionable steps.

Each action is assigned to a designated “team member” or role-playing AI agent.

MetaGPT agents operate within a structured, role-based system designed to simulate and coordinate their tasks through collaborative workflows.

Each agent follows an organized agentic workflow grounded in four core concepts:

1. Role: A specialized persona to achieve a specific purpose (project manager, designer, analyst).
2. Action: The ability to perform certain tasks (write, review, research and more).
3. Memory: Individual memory is stored as a list of message objects that include past interactions, observations and actions. These messages are published to a shared message pool for communication between agents. Memories inform agent actions.
4. Environment: A common space (the global message pool) to access information from other agents without direct interaction. This space acts as a shared context for all agents.

Together, these components form the foundation for agent autonomy and task execution in MetaGPT. Next, we’ll explore how these agents communicate and collaborate to complete multistep tasks like generating a PRD.

MetaGPT agents follow a coordinated process where each agent contributes to a shared goal. Each agent processes information and reasons based on its role, takes action and shares results with others. This approach enables a dynamic, step-by-step collaboration that builds toward the final output

MetaGPT agent workflow:

1. Observe: The agent reviews the current states (for example, the latest PRD draft).
2. Think: Using the LLM, it decides what to do next based on its roles and the available information.
3. Act: The agent performs its assigned task–such as writing, reviewing or researching.
4. Share: The agent logs its output and broadcasts a message to the shared environment for other agents on the team to access.
5. Next agent: The process moves to the next agent who picks up where the last one left off and repeats the process until consensus is reached.

Agents iterate on this structured loop, building on each other’s work in each round until reaching a final, more complete and accurate output.

With MetaGPT, it’s possible to build a fully automated AI product development team by customizing agent roles, SOPs, PRD templates, stakeholder priorities and overall project goals. The framework is extensible, allowing teams to adapt it to specific workflows and requirements.

Now that we understand how individual agents operate and collaborate, let’s look at how this process is orchestrated at the application level in the full PRD generation workflow.

This section acts as a step-by-step guide to understand the workflow of this multiagent PRD generation application’s team of MetaGPT agents.

Let’s define a structured agentic workflow with our MetaGPT team by creating a SOP. This SOP breaks down the complex task of creating a PRD into clear, actionable steps, assigning each to a specialized agent.

A well-defined SOP clarifies each agent’s role and actions. This structure promotes accountability and smooth execution across the PRD lifecycle: drafting, research enrichment, peer review and revision.

Team roles:

• Product manager (team lead): Orchestrates the workflow, drafts the initial PRD, collects research and reviews feedback, revises the document and saves all versions. The project manager (PM) agent leads the process and coordinates the other agents. 
  
  
• Researcher: Enriches the PRD with relevant research and supporting data.
  
  
• Reviewer: Reviews the PRD and provides actionable feedback for improvement.

1. User idea: The user provides a project idea (“Write a PRD for a banking application for wealth management”) through the command line.
2. Team setup: The app creates a team and assigns the roles: product manager, researcher, reviewer.
3. Drafting: The product manager (as team lead) generates and saves the initial PRD as DraftPRD.md that outlines the products goals, user personas, key features and functional requirements.
4. Research: The researcher reviews the draft and provides supporting research.
5. Review: The reviewer examines the draft and gives feedback.
6. Revision: The PM collects the research and review feedback, revises the PRD and saves the final document as PRD.md.
   
7. Output: The final PRD (with research and revisions) is saved as a markdown file in the project directory.

This SOP ensures that the project manager leads the team, coordinating all contributions to automate the creation of a research-backed and reviewed PRD.

To run this tutorial effectively, users need the following requirements:

• Operating system: macOS, Linux or Windows
• Memory (RAM): >= 16 GB
  
• Disk space: >= 10 GB free (for Python environment, Ollama models and generated files)
• Ollama: Installed and running locally (default port 11434)
• Python version: 3.11.x

Note: Running larger models or multiple agents might require more memory (32 GB+ recommended for best performance). Intermittent timeout errors can occur. If you encounter timeout errors, try restarting the process and ensuring your system has sufficient resources.

These steps can be followed here or within the aptly named project folder on GitHub. 

First, create a virtual environment to avoid Python dependency issues. This project works most stable with Python 3.11.

Install the latest development version of MetaGPT.

Important: For this tutorial, you must install MetaGPT by using the command above. Do not install MetaGPT from PyPI or other sources, as only the latest development version is supported here.

Install Ollama by using any of the following methods dependent on your OS:

For macOS (using Homebrew)

Download from the official Ollama website (macOS, Linux, Windows)

After installation, you can start the Ollama server and pull a model (deepseek-r1:8b) with:

To configure the Ollama and Deepseek to work with MetaGPT, we need to create and edit a config file.

Initialize the MetaGPT configuration:

This action creates a file at~/.metagpt/config2.yaml

Edit the file to configure your LLM with the following steps:

1.        In a terminal window, run the following command to open the config file in the nano editor:

2.        Edit the file to match this Ollama configuration that uses the deepseek-r1:8b model.

Note: If the fieldapi_key: appears in the YAML file, do not leave it blank. Either provide a valid key or remove the field entirely. The program will not run ifapi_key: exists and is empty.

1. After you’ve made the preceding changes, press Ctrl + O  to save, then press Enter to confirm.
2. PressCtrl + X to exit nano

Your LLM configuration changes are now saved!

For additional config examples, see the two provided in the MetaGPT docs here and here.

MetaGPT agents are built from two main components:

• Actions: Discrete tasks or operations an agent can perform (for example, writing a PRD, conducting research).
• Roles: Defines the agent’s responsibilities and which actions it can take (for example, project manager, researcher).

AnAction is a Python class that defines a specific task for an agent.
Actions tell each agent what to do and how to interact with the language model.

Each action typically includes:

•  APROMPT_TEMPLATE : The instruction or message sent to the LLM (for example, “Write a PRD in markdown format”).
•  Arun()  method: Fills in the prompt template, sends it to the LLM and returns the model’s response.
• Optionally, aparse_text() method: Processes the LLM’s output to extract the relevant information (such as markdown, code or JSON).

Require imports for actions:

• re is for regular expressions (used inparse_text )
• os is for file operations (used inSavePRD )
• Action is the base class for all actions in MetaGPT

The role class represents an AI agent or team member in the workflow. Roles instruct the model how to act and define which specific part of the process it should follow (such as managing, researching or reviewing).

Each role typically includes:

• __init__ : Initializes the role, sets up its actions and defines what events or messages it should watch for.
  
  
•  _act : Executes one or more assigned action when it’s the agents turn to act. This method defines the agent’s behavior in the workflow.

Required imports for roles:

• Role is a base class for all agent roles in MetaGPT.
• Message is used to return results from actions.
• logger is used for logging output and debugging information.

MetaGPT organizes the workflow into rounds, which are iterative cycles where agents collaborate to improve the PRD. Each round consists of the following steps:

Round 1: Initial draft

• The project manager creates and saves the first PRD draft based on the user’s prompt.
  
• The researcher and reviewer receive this draft for their tasks.

Round 2 (and beyond): Review and revision:

• The researcher generates supporting research for the PRD.
  
• The reviewer provides feedback on the PRD draft.
  
• The project manager revises the PRD using the new research and review feedback, then saves the updated version.

Repeat

• The process can repeat for multiple rounds, allowing the PRD to be incrementally improved with each cycle.

Multiagent PRD generation workflow diagram:

In the next step, you’ll build a team of agents for PRD AI automation.
We’ll define each agent’s role and connect its relevant workflow actions.

In this section, you’ll see how to define agent actions, create agent roles and assemble a team to automate PRD generation, research and review.

Here are the agent actions that the PRD team will perform by using theAction class:

Core tasks

The following 5 action classes define the core tasks performed by the agents in this AI-powered PRD generation workflow:

1. WritePRD creates the PRD.
2. SavePRD saves the PRD to disk.
3. ConductResearch generates supporting research.
4. PerformReview reviews the PRD.
5. RevisePRD revises the PRD based on feedback.

Here are the agent roles that represent the multiagent PRD team. Below is the code that specifies which actions they perform.

Core workflow and role definitions

The following agents collaborate to automate each step of the PRD creation process:

• ProjectManager (Pam) creates, saves and revises the PRD.
• Reviewer (Rico) reviews the PRD and provides feedback.
• Researcher (Rita) generates supporting research for the PRD.

Use theTeam class to hire agents and run the workflow. This app uses Typer to run the process interactively from the command line.

• @app.command() : Tells Typer that the following function (main ) is a command that can be run from the terminal.
• main(...) : The main function that runs the program. It takes three arguments:
  • idea : The project idea (for example, “A PRD for a banking application for wealth management.”)
    
  • investment : An optional investment amount (default:3.0 ). This action simulates the team’s budget and can affect agent decision-making and planning.
  • n_round : Optional argument specifying how many rounds the simulation should run (default:2 ).

• runner() : An asynchronous function that runs the workflow:
  • team = Team(use_mgx=False) : Creates a newTeam object representing a group of AI agents. Theuse_mgx=False option disables the advanced MGX communication mode by using standard team behavior.
  • team.hire([...]) : Hires (adds) the agents to the team.
  • team.idea = idea : Sets the team’s project idea from the CLI input.
  • team.invest(investment=investment) : Allocates the team’s “funding,” influencing how agents simulate planning and resource allocation.
  • team.run_project(idea) : Starts the project with the given idea.
  • await team.run(n_round=n_round) : Runs the workflow for the specified number of rounds, allowing agents to iteratively improve the PRD.

Important note:
The documents and outputs generated by this tutorial use large language models (LLMs), which are probabilistic and can occasionally produce incomplete, inaccurate or inconsistent results.
Always review and validate all generated content yourself.
LLMs are helpful tools, but cannot fully replace the expertise and judgment of a real product development team.

To run the program with default values forn_round andinvestment :

This command will launch the team of agents, automate the PRD creation process and iterate for the specified number of rounds.

Summary of team creation process

• Actions define what each agent can do.
• Roles represent agents and connect them to actions.
• The Team class brings agents together to automate the PRD workflow.

This modular approach allows room for fine-tuning the process of automating complex product development tasks.

When you run the application, the agents collaborate to produce and refine a PRD.

• Draft PRD (DraftPRD.md ): The initial PRD created by the project manager agent.
• Review feedback: Suggestions and critiques from the reviewer agent.
• Research report: Supporting technical and market research from the researcher agent.
• Final PRD (PRD.md ): The revised PRD, incorporating review and research.

The final PRD.md file includes a section titled document revision notes that summarizes the key changes made during the review and revision process. This section helps stakeholders quickly understand what was updated in the document.

Here are the main enhancements found in the final PRD for the wealth manager application:

• Measurable goals added: Added success metrics like clear KPIs including NPS scores and time reductions to inform MVP and optimization.
• User roles: Defined roles and permissions for advisors, clients and staff.
• Integrations: Specified APIs and security protocols for data flow.
• Document revision notes: Summarized key changes for easy tracking.
• User stories: Expanded and clarified scenarios for actionable requirements.
• Research: Incorporated go-to-market strategy like pricing models and technical data to support decisions.

• DraftPRD.md : Initial requirements document.
• PRD.md : Final, revised requirements document.
• (Optional) Research.md : Market and technical research supporting the PRD.

By following this tutorial, you’ve learned how to automate the creation and refinement of a product requirements document by using MetaGPT and Ollama. You set up a multi-agent team, defined custom actions and roles and ran an iterative workflow that produces high-quality, actionable PRDs. This modular approach can be adapted for other collaborative AI tasks, making it a powerful tool to streamline AI product management.