Robert's Tech Talk

How To Guides

robtruesdale

February 23, 2026

# How to Build a Multi-Agent Content Pipeline

*Automate your entire content workflow with specialized AI agents*

—

## What You’ll Build

A fully automated content pipeline that runs itself. Research, writing, scheduling, and publishing — handled by specialized agents working together. While you sleep.

**By the end:** You’ll have a system like mine that publishes 3-5 posts daily across multiple WordPress sites, posts to X automatically, and manages everything from a single dashboard.

—

## The Architecture

“`
┌─────────────────────────────────────────────────────────────┐
│ MISSION CONTROL │
│ (Your Central Dashboard) │
└──────────────────┬────────────────────────────────────────┘
│
┌──────────────┼──────────────┬──────────────┐
▼ ▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│MONICA │ │ DWIGHT│ │ KELLY │ │ ROSS │
│Chief of│ │Research│ │Social │ │Engineer│
│ Staff │ │ Agent │ │Media │ │ Agent │
└────────┘ └────────┘ └────────┘ └────────┘
│ │ │ │
└──────────────┴──────────────┴──────────────┘
│
┌──────────────┼──────────────┬──────────────┐
▼ ▼ ▼ ▼
┌────────┐ ┌────────┐ ┌────────┐ ┌────────┐
│WordPress│ │ X │ │YouTube │ │ Notion │
│ Sites │ │Posts │ │Uploads │ │Tracking│
└────────┘ └────────┘ └────────┘ └────────┘
“`

—

## What You Need

**Required:**
– A computer that stays on (Mac mini, old laptop, Raspberry Pi, or VPS)
– OpenClaw installed (or similar agent framework)
– 2-3 WordPress sites with Application Passwords
– X/Twitter API access (optional but recommended)

**My Setup:**
– Mac mini (M1) running 24/7
– Mission Control dashboard (Next.js + SQLite)
– 5 WordPress sites on HostGator
– Multiple cron jobs for automation

—

## Step 1: Define Your Agent Roles

Don’t just have one AI doing everything. Specialization matters.

### My Four Agents

### How to Create Yours

Each agent is a Python script with a system prompt. Example:

“`python
# monica.py – Chief of Staff Agent
SYSTEM_PROMPT = “””You are Monica, the Chief of Staff.

Your personality: Organized, direct, efficient. You hate chaos.
Your job: Coordinate the other agents and decide who does what.
Your tools: Can delegate to Dwight (research), Kelly (social), or Ross (engineering).

When you receive a task:
1. Break it down into subtasks
2. Assign to the right specialist
3. Track progress
4. Report back to the human

Always be brief. Time is money.”””
“`

—

## Step 2: Build the Mission Control Dashboard

You need a central place to see everything.

### Core Features

1. **Task Board** — Kanban lanes (Backlog → In Progress → Review → Done)
2. **Agent Status** — Who’s working, who’s idle
3. **Live Feed** — Real-time updates from agents
4. **Workspace Switcher** — Different projects, different lanes

### Tech Stack

“`
Frontend: Next.js + Tailwind CSS
Backend: Next.js API routes
Database: SQLite (simple, file-based)
Real-time: Server-Sent Events (SSE)
“`

### Database Schema

“`sql
— tasks table
CREATE TABLE tasks (
id TEXT PRIMARY KEY,
title TEXT NOT NULL,
description TEXT,
status TEXT DEFAULT ‘backlog’,
assigned_agent_id TEXT,
workspace_id TEXT,
lane_id TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

— agents table
CREATE TABLE agents (
id TEXT PRIMARY KEY,
name TEXT NOT NULL,
role TEXT,
avatar_emoji TEXT,
status TEXT DEFAULT ‘idle’,
is_master BOOLEAN DEFAULT 0
);
“`

—

## Step 3: Create the Content Pipeline

Now the magic — connecting everything together.

### Morning Automation (8 AM Daily)

**What happens:**

1. **Cron triggers** the daily briefing script
2. **Dwight** researches: weather, news, AI headlines
3. **Dwight** drafts 2 WordPress posts
4. **Kelly** writes an X thread about one headline
5. **Ross** publishes everything via WordPress REST API
6. **Monica** sends you a summary email

**The cron job:**

“`bash
# /etc/crontab
0 8 * * * cd /workspace && python3 daily_briefing.py
“`

**The script flow:**

“`python
# daily_briefing.py
import subprocess

def main():
# Step 1: Get weather
weather = get_weather()

# Step 2: Get news headlines
headlines = get_npr_headlines()

# Step 3: Create WordPress post 1 (Daily Briefing)
post_to_wordpress(
site=”bestmediapublishing.com”,
title=f”Daily Briefing — {today}”,
content=format_briefing(weather, headlines)
)

# Step 4: Create WordPress post 2 (Texas News)
post_to_wordpress(
site=”bestmediapublishing.com”,
title=f”Texas News — {today}”,
content=format_texas_news(headlines)
)

# Step 5: Send email summary
send_email(to=”you@email.com”, body=create_summary())

if __name__ == “__main__”:
main()
“`

—

## Step 4: Add AI-Powered Content Generation

Don’t just auto-post. Auto-create.

### Grok Headline Analysis

Every morning, Grok analyzes the day’s news and suggests tweet angles:

“`python
# grok_analysis.py
import requests

GROK_API_KEY = “your-key-here”

def analyze_headlines(headlines):
prompt = f”””
Analyze these AI/tech headlines:
{headlines}

1. Summarize the key theme
2. Generate 3 tweet angles
3. Suggest the best posting time
“””

response = requests.post(
“https://api.x.ai/v1/chat/completions”,
headers={“Authorization”: f”Bearer {GROK_API_KEY}”},
json={“messages”: [{“role”: “user”, “content”: prompt}]}
)

return response.json()
“`

### Result

Grok outputs something like:

“`
**Key Theme:** AI governance vs Pentagon tensions

**Tweet 1 (RECOMMENDED):**
🚨 BREAKING: Pentagon vs Anthropic tensions boil over…
Post: 9:00 AM CT

**Tweet 2:**
🌾 Farmers rejecting AI datacenter land deals…
Post: 2:00 PM CT
“`

—

## Step 5: Connect Everything to Mission Control

Agents need to report their status somewhere visible.

### Agent Status Updates

“`python
# Every agent calls this when starting/completing work

def update_agent_status(agent_id, status, task_id=None):
requests.post(“http://localhost:3000/api/agents/status”, json={
“agent_id”: agent_id,
“status”: status, # “working”, “idle”, “error”
“task_id”: task_id,
“timestamp”: datetime.now().isoformat()
})
“`

### Real-Time Updates (SSE)

Mission Control uses Server-Sent Events for live updates:

“`javascript
// In your dashboard
const eventSource = new EventSource(‘/api/events’);

eventSource.onmessage = (event) => {
const data = JSON.parse(event.data);

if (data.type === ‘task_created’) {
addTaskToBoard(data.payload);
}

if (data.type === ‘agent_status_changed’) {
updateAgentIndicator(data.payload);
}
};
“`

—

## Step 6: Set Up Fallbacks & Error Handling

Things break. Plan for it.

### API Token Expired?

When X API tokens expire, the script:

1. Logs the error to Mission Control
2. Creates a task for Ross (Engineer agent) to fix
3. **Optional:** Falls back to browser automation

“`python
def post_to_x(content):
try:
# Try API first
return x_api.post_tweet(content)
except Unauthorized:
# Log error, notify human
create_mission_task(
title=”Fix X API tokens”,
assigned_to=”ross”,
priority=”urgent”
)
# Fallback: queue for manual posting
queue_for_manual(content)
“`

—

## Step 7: Scale It

Once you have one pipeline working, replicate it.

### My Current Pipelines

### Add New Pipelines

Template for adding a new automated workflow:

“`python
# new_pipeline.py

def run_pipeline():
“””Template for new automation”””

# 1. Create task in Mission Control
task = create_task(“New automation running…”)

try:
# 2. Do the work
result = do_automation_work()

# 3. Update task as complete
complete_task(task, result)

# 4. Log success
log_event(“Pipeline completed successfully”)

except Exception as e:
# 5. Handle errors
fail_task(task, str(e))
notify_human(f”Pipeline failed: {e}”)
“`

—

## Results: What This Looks Like Day-to-Day

**Morning (while you sleep):**
– 8:00 AM: Daily briefing posts go live
– 8:05 AM: Email summary hits your inbox
– 8:30 AM: X post about trending AI news goes out

**Afternoon:**
– Grok analyzes headlines, suggests afternoon tweets
– Mission Control shows all agents as “idle”

**Evening:**
– OTR video uploads automatically
– Metadata and thumbnails pre-generated

**You:** Check Mission Control once a day, approve anything in “Review” lane.

—

## Tools & Resources

**My Stack:**
– **OpenClaw** — Agent framework (open source)
– **Mission Control** — Custom dashboard (Next.js)
– **WordPress** — Content sites (HostGator)
– **Grok/xAI** — Content analysis
– **Cron** — Scheduling
– **SQLite** — Simple database

**Alternatives:**
– n8n or Make.com for visual workflow building
– Zapier for simpler automations
– Airtable for database (instead of SQLite)

—

## Cost Breakdown

—

## Next Steps

1. **Install OpenClaw** — follow the docs
2. **Create one agent** — start with a researcher
3. **Build one automation** — daily weather email
4. **Add the dashboard** — Mission Control or similar
5. **Expand** — add agents and pipelines over time

—