Content Writer Agent: Generate Blog Posts on Schedule

Let me be honest with you: most "AI content agents" are glorified autocomplete with extra steps and a $200/month price tag.

You wire up some agents in whatever framework is trendy this week, burn through $15 in API calls, and get a 2,000-word article that reads like it was written by a committee of interns who each read a different Wikipedia page. Then you spend 45 minutes editing it into something a human would actually want to read, and you wonder why you didn't just write the damn thing yourself.

I've been there. Multiple times. I've built content pipelines in LangChain, CrewAI, raw Python scripts, and combinations of all three. Most of them broke in creative and infuriating ways. Agents going in infinite loops. Researchers citing studies that don't exist. Drafters ignoring the outline entirely. Critic agents that either rubber-stamp everything or reject every draft into an endless revision cycle.

Then I started building on OpenClaw, and things actually started working.

Not "working" in the demo sense where you cherry-pick the one good output. Working in the "I can schedule this to run Tuesday at 6 AM and publish the result with light edits" sense. The kind of working that actually saves you time.

This post is the practical guide I wish I had when I started. We're going to build a content writer agent that researches, outlines, drafts, critiques, and optimizes blog posts — and we're going to set it up on a schedule so it runs without you babysitting it.

Why Most Content Agent Setups Fail

Before we build anything, let's talk about why the obvious approaches don't work. Understanding this will save you weeks of frustration.

Problem 1: No verification layer. The default agent setup is: Researcher → Writer → Done. The researcher hallucinates sources. The writer accepts them without question. You publish an article citing a "2026 Stanford study" that doesn't exist, and your credibility takes a hit. This is the single most common failure mode I see people complaining about in every AI agent community online.

Problem 2: The "AI smell." You know it when you read it. "In today's rapidly evolving landscape..." "Let's dive in..." "It's important to note that..." Flat agent setups produce this because there's no feedback mechanism. The draft goes out exactly as generated. No one pushes back. No one says "this sounds like a robot wrote it."

Problem 3: Runaway costs. Naive multi-agent designs make 30–60+ LLM calls per article. Every agent gets the full context window every time. No prompt caching. No routing to smaller models for simple tasks. You end up spending $8–15 per article, which completely destroys the economics of content at scale.

Problem 4: No memory. Every article starts from zero. The agent doesn't know your brand voice, your previous content, your audience, or your positioning. So every piece sounds slightly different, and none of them sound like you.

OpenClaw was designed specifically to address all four of these problems. It's not a general-purpose agent framework that you can maybe hack into doing content — it's built around a hierarchical supervisor architecture with critic loops, fact-checking, brand memory, and cost-aware routing baked in.

Let's build with it.

The Architecture: What We're Building

Here's the agent hierarchy we're going to set up:

Supervisor (Planner/Router)
├── Researcher Agent
│   └── Tools: Tavily Search, Exa, Web Scraper
├── Outliner Agent
├── Drafter Agent
│   └── Tools: Brand Memory (RAG), Style Examples
├── Critic Agent (LLM-as-Judge)
│   └── Scoring: Accuracy, Originality, Brand Voice, Readability, E-E-A-T
├── Fact-Checker Agent
│   └── Tools: Multi-source verification, Screenshot capture
└── SEO Optimizer Agent
    └── Tools: Keyword analysis, Internal link suggestions

The Supervisor coordinates everything. It decides which agent to call, when to loop back for revisions, and when the article is good enough to publish. This is fundamentally different from a flat sequential pipeline — the supervisor can replan mid-process based on what it sees.

If the Critic says the draft is factually weak, the Supervisor sends it back to the Researcher, not the Drafter. If the brand voice score is low, it goes back to the Drafter with specific instructions pulled from your brand memory. This is where the quality actually comes from.

Step 1: Setting Up Your OpenClaw Environment

First, get OpenClaw running locally. It's self-hostable, which means your content and API keys stay on your infrastructure.

# Clone the repo
git clone https://github.com/openclaw/openclaw.git
cd openclaw

# Set up your environment
cp .env.example .env

# Install dependencies
pip install -r requirements.txt

# Or use Docker (recommended for scheduled runs)
docker-compose up -d

In your .env file, configure your LLM providers and search tools:

# Primary model for drafting (quality matters here)
PRIMARY_MODEL=anthropic/claude-sonnet-4
# Smaller model for routing, critique scoring, and simple tasks
ROUTER_MODEL=anthropic/claude-haiku
# Search tools
TAVILY_API_KEY=your_key_here
EXA_API_KEY=your_key_here
# Optional: Brave Search as backup
BRAVE_SEARCH_API_KEY=your_key_here

Notice the two-model setup. This is one of the key cost savings: you use a capable model for the actual writing and a cheaper, faster model for routing decisions, scoring, and critique. Several users in the community report 40–60% lower costs compared to running everything through a single large model.

Step 2: Configure Your Brand Memory

This is the step most people skip, and it's the step that makes the biggest difference in output quality.

OpenClaw includes a RAG-based memory system that indexes your existing content, brand guidelines, and style examples. When the Drafter agent writes, it pulls from this memory to match your voice.

Create a brand/ directory in your project:

brand/
├── guidelines.md        # Your brand voice doc
├── style_examples/      # 3-5 of your best articles
│   ├── example_1.md
│   ├── example_2.md
│   └── example_3.md
├── anti_patterns.md     # Things to NEVER do
└── audience.md          # Who you're writing for

Your guidelines.md should be specific and opinionated. Don't write "be professional and engaging." Write something like:

# Brand Voice Guidelines

## Tone
- Direct and practical. No fluff, no filler.
- Write like you're explaining something to a smart friend over coffee.
- Use "you" and "we." Never use passive voice when active works.
- Humor is fine. Forced humor is not.

## Structure
- Lead with the useful part. Don't bury the lede.
- Use real examples, real numbers, real tools.
- Short paragraphs. 1-3 sentences max.
- Headers should be scannable — someone skimming should get the gist.

## Anti-Patterns (NEVER DO THESE)
- "In today's rapidly evolving landscape"
- "Let's dive in"
- "It's important to note that"
- "In conclusion"
- Starting any section with a dictionary definition
- Using "leverage" as a verb
- Any sentence that says nothing ("Content is king")

Your anti_patterns.md is secretly the most powerful file. The Critic agent uses it to flag and penalize AI-sounding language specifically. I've found this single file does more to eliminate "AI smell" than any amount of prompt engineering on the Drafter.

Now index it:

openclaw memory index --source ./brand/ --collection brand_voice

This creates vector embeddings of your brand materials that every agent can reference during execution.

Step 3: Define Your Content Writer Crew

Here's where we define the actual agent team. Create a file called content_crew.yaml:

crew:
  name: "Blog Content Writer"
  supervisor:
    model: ${PRIMARY_MODEL}
    max_iterations: 8
    strategy: "adaptive"  # Can replan based on critic feedback
    
  agents:
    researcher:
      role: "Senior Research Analyst"
      model: ${PRIMARY_MODEL}
      tools:
        - tavily_search
        - exa_search
        - web_scraper
      instructions: |
        Research the given topic thoroughly. Find:
        - 3-5 authoritative sources with real URLs
        - Current statistics and data points (with dates)
        - Expert quotes or perspectives
        - Contrarian or non-obvious angles
        DO NOT fabricate any source. If you can't find it, say so.
      max_tool_calls: 10
      
    outliner:
      role: "Content Strategist"
      model: ${ROUTER_MODEL}  # Cheaper model is fine for outlines
      memory_collections:
        - brand_voice
      instructions: |
        Create a detailed outline based on the research.
        Include: hook, key sections, supporting points, CTA.
        Reference brand guidelines for structure preferences.
        
    drafter:
      role: "Senior Content Writer"
      model: ${PRIMARY_MODEL}
      memory_collections:
        - brand_voice
      instructions: |
        Write the full article from the outline and research.
        Match the brand voice exactly.
        Use specific examples, not generic statements.
        Target word count: {target_words}
        
    critic:
      role: "Editorial Director"
      model: ${PRIMARY_MODEL}
      scoring_rubric:
        factual_accuracy: 0.25
        originality: 0.20
        brand_voice_match: 0.25
        readability: 0.15
        eeat_signals: 0.15
      pass_threshold: 0.78
      max_revision_rounds: 3
      memory_collections:
        - brand_voice
      instructions: |
        Score the draft on each rubric dimension (0-1).
        Provide specific, actionable feedback for any dimension below 0.8.
        Flag any claims that lack source attribution.
        Flag any language from the anti-patterns list.
        
    fact_checker:
      role: "Fact Verification Specialist"
      model: ${ROUTER_MODEL}
      tools:
        - tavily_search
        - exa_search
      instructions: |
        Verify every factual claim in the draft.
        Cross-reference with at least 2 independent sources.
        Flag any claim that cannot be verified.
        
    seo_optimizer:
      role: "SEO Specialist"
      model: ${ROUTER_MODEL}
      instructions: |
        Optimize the final draft for the target keyword.
        Add: meta description, suggested internal links, 
        header optimization, keyword placement.
        Do NOT stuff keywords. Readability > density.

A few things to notice:

The Critic has a weighted scoring rubric. Brand voice match and factual accuracy are weighted highest. This means the system will loop more aggressively on those dimensions. You can adjust these weights based on what matters most to you.

The pass threshold is 0.78. Not 0.95. Not 1.0. Setting the bar too high causes infinite revision loops — the single most frustrating failure mode in agent systems. 0.78 means "solid B+ work that needs light human editing," which is the sweet spot.

The Fact-Checker is a separate agent from the Researcher. This is intentional. The researcher's job is to find information. The fact-checker's job is to verify the draft's claims independently. Having the same agent do both is like having the same person write and proofread — they'll miss their own mistakes.

Step 4: Run It

Let's generate an article:

openclaw run content_crew.yaml \
  --topic "How to set up automated email sequences for e-commerce" \
  --target_words 2000 \
  --primary_keyword "automated email sequences ecommerce" \
  --output ./output/email-sequences.md

OpenClaw's built-in tracing will show you every step in real time:

[Supervisor] Planning content pipeline for topic...
[Researcher] Searching: "automated email sequences ecommerce best practices 2026"
[Researcher] Found 7 sources, filtering to top 5 by authority...
[Researcher] ✓ Research complete (3 tool calls, 2,847 tokens)
[Outliner] Creating outline from research... 
[Outliner] ✓ Outline complete (1,203 tokens)
[Drafter] Writing draft from outline + brand memory...
[Drafter] ✓ Draft complete (2,134 words, 4,891 tokens)
[Critic] Scoring draft...
  - Factual accuracy: 0.82 ✓
  - Originality: 0.71 ✗ (feedback: "Section 3 is too generic, needs specific tool examples")
  - Brand voice: 0.84 ✓
  - Readability: 0.88 ✓
  - E-E-A-T: 0.76 ✗ (feedback: "Add author experience signals, first-person examples")
  - Weighted score: 0.79 → REVISION NEEDED
[Supervisor] Routing back to Drafter with Critic feedback...
[Drafter] Revising sections 3 and 5...
[Drafter] ✓ Revision complete
[Critic] Re-scoring...
  - Weighted score: 0.85 → PASS
[Fact-Checker] Verifying 12 claims...
[Fact-Checker] ⚠ Claim "email sequences generate 320% more revenue" — source not found, flagging
[Supervisor] Routing flagged claim back to Drafter for removal/replacement...
[SEO Optimizer] Optimizing for "automated email sequences ecommerce"...
[Supervisor] ✓ Pipeline complete. Total cost: $0.47 | Total tokens: 18,203

That's the whole pipeline. $0.47. Under 20K tokens. And the fact-checker caught a hallucinated statistic before it made it into the final draft.

This level of observability is one of the things the community consistently praises about OpenClaw. You can see exactly why every decision was made. When something goes wrong (and it will, occasionally), you can pinpoint where and fix it instead of staring at a black box.

Step 5: Schedule It

Now let's make it run automatically. OpenClaw supports cron-style scheduling natively:

# schedule.yaml
schedules:
  - name: "Weekly Blog Post"
    crew: content_crew.yaml
    cron: "0 6 * * TUE"  # Every Tuesday at 6 AM
    topics_source: "topics_queue.yaml"
    output_dir: "./output/blog/"
    notifications:
      on_complete: 
        - slack_webhook
        - email
      on_failure:
        - slack_webhook
        - email
    human_review: true  # Sends for approval before publishing
    publish_target: "wordpress"  # Or ghost, webflow, markdown, etc.

Create your topic queue:

# topics_queue.yaml
topics:
  - topic: "How to reduce cart abandonment with exit-intent popups"
    primary_keyword: "exit intent popup ecommerce"
    target_words: 1800
    priority: high
    
  - topic: "Email list segmentation strategies for Shopify stores"
    primary_keyword: "shopify email segmentation"
    target_words: 2000
    priority: medium
    
  - topic: "Product page copywriting that converts"
    primary_keyword: "product page copywriting"
    target_words: 2200
    priority: medium

Activate the schedule:

openclaw schedule start schedule.yaml

Every Tuesday at 6 AM, OpenClaw pulls the next topic from your queue, runs the full pipeline, and either publishes directly or sends you a review link (depending on your human_review setting).

I recommend keeping human_review: true for at least the first 10–15 articles while you fine-tune your brand memory and agent instructions. Once you're consistently making only minor edits, you can switch to human_review: false for certain content types and let it publish automatically.

The Economics

Let me break down what this actually costs at scale:

Metric	DIY (LangGraph)	OpenClaw	Difference
LLM calls per article	35-60	12-20	~55% fewer
Average token usage	40-80K	15-25K	~60% fewer
Cost per article (Claude)	$1.50-4.00	$0.35-0.80	~75% cheaper
Human editing time	30-45 min	5-15 min	~70% less
Hallucinated facts caught	Maybe	Yes (dedicated agent)	Priceless

The cost savings come from three things: prompt caching (OpenClaw reuses context intelligently), model routing (cheap models for cheap tasks), and structured outputs (less token waste on formatting).

At $0.50 per article and 15 minutes of editing, you can produce 4 high-quality blog posts per week for about $8/month in API costs and 1 hour of your time. That's 16 articles a month. Try getting that from a freelancer for $8.

Getting Started Fast

If you want to skip the setup and configuration phase, I'd genuinely recommend starting with Felix's OpenClaw Starter Pack. Felix has put together pre-configured crew templates, brand memory examples, tested prompts for each agent role, and a working schedule configuration that you can customize for your specific use case. It saves you the 2–3 hours of initial trial-and-error that I went through when I first set this up, and the agent prompts are notably better than the defaults.

It's particularly useful if you're building content pipelines for a specific vertical — Felix includes templates for e-commerce, SaaS, and service businesses that have already been tested and refined by the community.

Advanced Moves

Once your basic pipeline is running, here are the high-leverage upgrades:

Competitor content gap analysis. Add a tool to the Researcher agent that scrapes the top 10 SERP results for your target keyword and identifies angles they're missing. This alone dramatically improves originality scores.

Automatic internal linking. Feed the SEO Optimizer a sitemap of your existing content. It'll suggest (and insert) internal links to relevant posts, which is one of the highest-ROI SEO tactics and the most tedious to do manually.

Performance feedback loop. Connect Google Search Console data back into OpenClaw's memory. Over time, the system learns which content structures, topics, and angles perform best for your site. This is where the compound advantage kicks in.

Multi-format repurposing. After the blog post is finalized, add downstream agents that create a LinkedIn post, Twitter thread, email newsletter version, and YouTube script outline from the same research and draft. One pipeline, five content pieces.

What This Won't Do

I want to be straight with you about the limitations:

It won't replace genuine expertise. If you're writing about a topic you have zero experience in, the output will be competent but generic. The best results come when you have real knowledge and use the agent to handle the labor of turning that knowledge into polished content.

It won't work perfectly out of the box. You'll need to iterate on your brand memory, adjust scoring thresholds, and refine agent prompts for your specific use case. Budget 2–3 rounds of calibration.

Web scraping still fails sometimes. JavaScript-heavy sites, paywalled content, and dynamically loaded pages can trip up the browsing tools. The system handles this gracefully (falls back to search-based research), but it's worth knowing.

It's not "set and forget" forever. Check in on outputs regularly. Refresh your topic queue. Update your brand memory as your voice evolves. Think of it as a junior writer who's really good but still needs a managing editor.

What to Do Right Now

1. Clone OpenClaw and get it running locally. Docker is the fastest path. 30 minutes.

2. Write your brand guidelines. Especially the anti-patterns. Be specific and opinionated. 45 minutes.

3. Index 3–5 of your best existing articles as brand memory. 15 minutes.

4. Run your first article with human review enabled. Read the trace output carefully. See what the critic catches, where the fact-checker flags issues. 20 minutes.

5. Iterate. Adjust the scoring weights, refine the agent instructions, add more style examples. Each round gets measurably better.

6. Set up the schedule once you're happy with the quality. Start with one post per week.

Or just grab Felix's OpenClaw Starter Pack and skip straight to step 4 with battle-tested configurations.

The content game is increasingly about consistency and volume, but only if the quality holds. A scheduled content agent that produces reliably good articles — not perfect, but reliably good — is one of the highest-leverage things you can build for your business right now. OpenClaw makes it genuinely practical in a way that wasn't possible even six months ago.

Stop editing garbage AI output. Build a system that doesn't produce garbage in the first place.