Build an AI Agent Pipeline with Python: 3-Agent Code Tutorial

An AI agent pipeline chains multiple AI agents together so each one handles a specific step: research, analysis, writing, review. Instead of asking one chatbot to do everything, you build a production line where each agent specializes in one task.

This tutorial shows you how to build a working AI agent pipeline in 30 minutes. You will create a 3-agent content pipeline (Researcher → Writer → Reviewer) that takes a topic and produces a polished blog post.

What Is an AI Agent Pipeline?

An AI agent pipeline is a sequence of AI agents where the output of one agent becomes the input for the next. Each agent has:

• A role (researcher, writer, reviewer)
• A system prompt that defines its expertise
• input/output format so agents can hand off data
• An LLM backend (Claude, GPT-4o, Gemini, or local models)

Pipeline vs Single Agent

The pipeline produces better output because each agent focuses on one task. A researcher is better at research than a general-purpose model asked to "research and write."

Architecture Overview

[Input Topic] → [Researcher Agent] → [Writer Agent] → [Reviewer Agent] → [Final Output]
                     ↓                      ↓                     ↓
              Web search +           Draft blog post        Check quality,
              fact gathering         from research          fix errors, rate

Agent Definitions

Agent 1: Researcher

• Input: Topic string
• Output: Structured research (key facts, sources, data points)
• Model: GPT-4o ($0.02-0.05/run)

Agent 2: Writer

• Input: Research output from Agent 1
• Output: Draft blog post (1,500-2,000 words)
• Model: Claude Sonnet ($0.03-0.10/run)

Agent 3: Reviewer

• Input: Draft from Agent 2
• Output: Polished blog post with quality score
• Model: Claude Sonnet ($0.02-0.08/run)

Total cost per run: $0.07-$0.23

Step 1: Set Up Your Environment

pip install anthropic openai python-dotenv

Create a .env file:

ANTHROPIC_API_KEY=sk-ant-...
OPENAI_API_KEY=sk-...

Step 2: Define Agent Prompts

RESEARCHER_PROMPT = """You are a research specialist. Given a topic, produce:
1. 5-8 key facts with specific numbers
2. 3-5 recent trends or developments (2024-2026)
3. Common questions people ask about this topic
4. 2-3 contrarian or surprising angles

Output as structured JSON with keys: facts, trends, questions, angles."""

WRITER_PROMPT = """You are a technical blog writer. Given research data, write a blog post that:
1. Opens with a specific, surprising fact or number
2. Uses H2 and H3 headings for structure
3. Includes code examples or data tables where relevant
4. Ends with a clear summary and next steps
5. Targets 1,500-2,000 words

Write in a direct, technical style. No filler."""

REVIEWER_PROMPT = """You are an editorial reviewer. Given a blog post:
1. Check for factual errors or unsupported claims
2. Rate clarity, structure, and completeness (1-10)
3. Fix grammar and style issues
4. Add any missing key points
5. Return the improved post with a quality score

Output as JSON: {post: string, score: number, issues: string[]}"""

## Step 3: Build the Pipeline

```python
import json
import openai
import anthropic

def run_researcher(topic: str) -> dict:
    client = openai.OpenAI()
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": RESEARCHER_PROMPT},
            {"role": "user", "content": f"Research this topic: {topic}"}
        ],
        response_format={"type": "json_object"}
    )
    return json.loads(response.choices[0].message.content)

def run_writer(research: dict) -> str:
    client = anthropic.Anthropic()
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4000,
        system=WRITER_PROMPT,
        messages=[{
            "role": "user",
            "content": f"Write a blog post based on this research:\n{json.dumps(research, indent=2)}"
        }]
    )
    return response.content[0].text

def run_reviewer(draft: str) -> dict:
    client = anthropic.Anthropic()
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=4000,
        system=REVIEWER_PROMPT,
        messages=[{
            "role": "user",
            "content": f"Review and improve this blog post:\n{draft}"
        }]
    )
    return json.loads(response.content[0].text)

def run_pipeline(topic: str) -> dict:
    research = run_researcher(topic)
    draft = run_writer(research)
    result = run_reviewer(draft)
    return {
        "topic": topic,
        "research": research,
        "final_post": result["post"],
        "quality_score": result["score"],
        "issues_fixed": result["issues"]
    }

Step 4: Run the Pipeline

result = run_pipeline("How AI agent pipelines reduce content production costs by 80%")
print(f"Quality Score: {result['quality_score']}/10")
print(f"Issues Fixed: {len(result['issues_fixed'])}")
print(f"Final Post Length: {len(result['final_post'])} characters")

Expected output:

Quality Score: 8.5/10
Issues Fixed: 3
Final Post Length: 8420 characters

Cost Breakdown

At $0.15 per post, running this pipeline 100 times costs $15. Compare that to $49/month for Jasper or $20/month for ChatGPT Plus with rate limits.

For a detailed cost analysis across different models, see our AI Agent Cost Benchmark Report and use our AI Cost Calculator to estimate your exact spend.

3 Real Pipeline Examples

Pipeline 1: Content Marketing

Topic → Researcher → SEO Optimizer → Writer → Reviewer → Published Post
Cost: $0.12-$0.20 | Time: 45 seconds | Quality: 8.5/10

Pipeline 2: Code Review

PR Diff → Security Checker → Style Reviewer → Test Writer → Review Summary
Cost: $0.05-$0.15 | Time: 20 seconds | Quality: 9/10

Pipeline 3: Competitor Analysis

Competitor URL → Data Extractor → Analyst → Report Writer → Formatted Report
Cost: $0.08-$0.25 | Time: 35 seconds | Quality: 8/10

No-Code Alternative: Ivern AI

If you don't want to write Python code, Ivern AI provides a no-code agent pipeline builder:

1. Sign up at ivern.ai/signup (free, no credit card)
2. Connect your API keys (BYOK -- zero markup)
3. Select a pipeline template (Content, Code Review, Research)
4. Describe your task
5. Agents execute the pipeline and you get the finished output

Ivern handles the agent coordination, error recovery, and output formatting. You manage work through a task board. The free tier includes 15 pipeline runs.

Related: How to Create an AI Agent Pipeline Step by Step · AI Agent Pipeline Architecture · Build AI Agent Teams Guide · AI Agent Cost Calculator · Best BYOK AI Platforms

FAQ

What is an AI agent pipeline?

An AI agent pipeline is a sequence of AI agents where each agent handles one step of a task. The output of one agent feeds into the next. For example: a Researcher gathers data → a Writer drafts content → a Reviewer polishes it. Each agent specializes in its role, producing higher-quality output than a single general-purpose agent.

How much does an AI agent pipeline cost?

A 3-agent pipeline using GPT-4o and Claude Sonnet costs $0.07-$0.30 per run depending on output length. At 100 runs per month, that is $7-$30. With BYOK (Bring Your Own Key) pricing from Ivern AI, you pay direct API costs with zero markup.

Can I build an AI agent pipeline without coding?

Yes. Platforms like Ivern AI provide no-code pipeline builders where you select agent roles, describe your task, and the platform coordinates the agents. No Python or API integration required.

What is the difference between an AI agent pipeline and a chatbot?

A chatbot responds to one message at a time with a single model. An agent pipeline chains multiple specialized agents together, each handling a different step. Pipelines produce higher-quality output because each agent focuses on one task instead of doing everything at once. See our AI Agents vs Chatbots comparison for the full breakdown.

How do I add more agents to a pipeline?

Add a new step between existing agents. For example, insert a "Fact Checker" agent between the Writer and Reviewer. Define its system prompt, specify input/output format, and connect it in the pipeline sequence. Each additional agent adds $0.02-$0.10 per run.

Next Steps

• Try the code: Copy the pipeline code above and run it with your API keys
• Try no-code: Sign up for Ivern AI and use pre-built pipeline templates
• No-code guide: Build AI Agents Without Code if you prefer visual tools
• Learn more: AI Agent Pipeline Architecture for production patterns
• Compare tools: Best BYOK AI Platforms 2026 for pricing across all options