Researcher Agent → Analyzer Agent → Writer Agent → Publisher

Coordinator Agent
├── Researcher Agent (if research needed)
├── Coder Agent (if coding needed)
└── Design Agent (if UI/UX needed)

Agent A ←→ Agent B ←→ Agent C
(Agents debate, reach consensus)

import asyncio
from anthropic import Anthropic

client = Anthropic()

# Agent 1: Researcher
async def research_agent(topic: str):
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1500,
        system="You are a research expert. Provide detailed research on topics.",
        messages=[{"role": "user", "content": f"Research: {topic}"}]
    )
    return response.content[0].text

# Agent 2: Analyzer
async def analyzer_agent(research: str):
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1500,
        system="You are an analyst. Extract key insights from research.",
        messages=[{"role": "user", "content": f"Analyze this research: {research}"}]
    )
    return response.content[0].text

# Agent 3: Writer
async def writer_agent(analysis: str):
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=2000,
        system="You are a professional writer. Write compelling articles.",
        messages=[{"role": "user", "content": f"Write article based on analysis: {analysis}"}]
    )
    return response.content[0].text

# Orchestrator
async def orchestrate(topic: str):
    print(f"Researching: {topic}")
    research = await research_agent(topic)

    print("Analyzing...")
    analysis = await analyzer_agent(research)

    print("Writing...")
    article = await writer_agent(analysis)

    return article

# Run
if __name__ == "__main__":
    article = asyncio.run(orchestrate("AI in Pakistan"))
    print(article)

Topic List (100 keywords)
    ↓
Keyword Agent (pick best keyword, target audience)
    ↓
Outline Agent (create 2,000-word outline)
    ↓
Draft Agent (write full article)
    ↓
Editor Agent (improve grammar, flow, Pakistan context)
    ↓
SEO Agent (optimize for keywords, add links)
    ↓
Publish Agent (schedule to WordPress, social)

class AgentContext:
    def __init__(self):
        self.memory = {}

    def set(self, key, value):
        self.memory[key] = value

    def get(self, key):
        return self.memory.get(key)

# Shared context
context = AgentContext()

async def research_agent(topic):
    # Store findings in context
    research = "... findings ..."
    context.set("research_findings", research)
    return research

async def analyzer_agent(topic):
    # Access research from context (no need to pass)
    research = context.get("research_findings")
    analysis = f"Analyzing: {research}"
    context.set("analysis", analysis)
    return analysis

async def agent_with_retry(agent_func, *args, retries=3):
    for attempt in range(retries):
        try:
            return await agent_func(*args)
        except Exception as e:
            if attempt < retries - 1:
                wait_time = 2 ** attempt  # Exponential backoff
                print(f"Attempt {attempt + 1} failed. Retrying in {wait_time}s...")
                await asyncio.sleep(wait_time)
            else:
                raise

# Usage
result = await agent_with_retry(researcher_agent, "AI in Pakistan")

import time
import logging

logging.basicConfig(level=logging.INFO)

async def monitored_agent(agent_name, agent_func, *args):
    start = time.time()
    try:
        result = await agent_func(*args)
        duration = time.time() - start
        logging.info(f"✓ {agent_name}: {duration:.2f}s")
        return result
    except Exception as e:
        logging.error(f"✗ {agent_name}: {e}")
        raise

# Usage
result = await monitored_agent("Researcher", research_agent, "AI Pakistan")