Agentic Content Calendars: Automating the Pitch, Outline, Draft, and Edit Flow

The Problem I Was Trying to Solve§

I was managing three content calendars across different domains: tech, marketing, and AI. Each required a distinct voice and depth of research. The manual cycle—pitching ideas, outlining, drafting, and editing—took roughly four hours per piece. To scale to 10+ pieces per week without hiring, I needed to offload the repetitive cognitive work: deciding what to write, structuring arguments, and polishing prose. The bottleneck wasn't writing ability; it was the constant context switching and decision fatigue.

My existing workflow was: scan Twitter and RSS for trends → brainstorm 10 angles → write a detailed outline → draft 1500 words → self-edit → publish. Each step required me to hold the entire narrative in my head. I wanted a system where I could define a domain and let agents propose, outline, draft, and edit—with me acting as the final editor. This would free up time for deeper research and personal engagement with readers.

Tools and Setup§

I settled on a multi-agent architecture using Claude (Sonnet 3.5) for drafting and editing, DeepSeek for research and pitch generation, Cursor for code snippets, and Perplexity for real-time trend analysis. The orchestration layer was a Python script using asyncio to call APIs concurrently. Each agent had a system prompt that defined its role: Researcher, Outliner, Writer, or Editor.

The shared state was a JSON file that tracked the calendar week, domain, current step, and all generated artifacts (pitches, outlines, drafts). I used a simple state machine: PITCH → OUTLINE → DRAFT → EDIT → REVIEW. Human intervention happened at the REVIEW step, after the editor agent had made its suggestions.

For API keys, I used environment variables. Cost was about $0.50 per piece across all models. I set rate limits conservatively to avoid throttling. The entire setup took two weekends to iterate to a stable flow.

Step-by-Step: What I Actually Did§

Step 1: Trend Scraping I scheduled a nightly Perplexity call for each domain. The query was: "List the top 3 emerging trends in [domain] this week with 2-3 sentence explanations." Perplexity returned structured responses that I parsed into a list of trend objects.

Step 2: Pitch Generation DeepSeek received the trends plus a style document containing my tone preferences (e.g., direct, data-driven, first-person anecdotes). The prompt asked for 5 pitches per trend, each with a title, a one-sentence hook, and a rationale. I kept the 2-3 strongest pitches per week.

Step 3: Outline Creation Claude (Outliner role) took the selected pitch and expanded it into a full outline. The output included H2, H3, key arguments, examples needed, and questions to research. This step reduced my outline time from 45 minutes to 5 minutes.

Step 4: First Draft The Writer agent (Claude) received the outline and my style document. It produced a 1500-word draft in one pass. I added a few guardrails: minimum 3 data points, at least one code example if technical, and a concluding takeaway section.

Step 5: Editing The Editor agent (Claude) reviewed the draft for clarity, flow, tone consistency, grammar, and redundancy. It output a list of suggested changes (not rewritten text). I accepted or rejected each suggestion manually. This step caught errors I would have missed and improved readability.

Code Samples / Prompts Used§

Here is the exact prompt used for pitch generation with DeepSeek:

You are a content strategist for a technology blog. Given the following trends and my writing style, generate 5 blog post pitches. Each pitch must include:
- Title (catchy but accurate)
- One-sentence hook
- Rationale (why this matters now)

Trends:
{trends}

Writing Style:
- Direct and authoritative
- Use first-person anecdotes from practical experience
- Prefer data over opinions
- Keep paragraphs short (2-4 sentences)

Output as JSON array with keys: title, hook, rationale.

And the Python orchestrator core loop:

import asyncio
from agents import Researcher, Outliner, Writer, Editor

async def run_content_pipeline(domain: str, week: str):
    state = load_state(domain, week)
    
    if state.step == "PITCH":
        trends = await Researcher.get_trends(domain)
        pitches = await Researcher.generate_pitches(trends)
        state.pitches = pitches
        state.step = "OUTLINE"
    
    if state.step == "OUTLINE":
        top_pitch = select_top_pitch(state.pitches)
        outline = await Outliner.create_outline(top_pitch)
        state.outline = outline
        state.step = "DRAFT"
    
    if state.step == "DRAFT":
        draft = await Writer.write_draft(state.outline)
        state.draft = draft
        state.step = "EDIT"
    
    if state.step == "EDIT":
        edits = await Editor.suggest_edits(state.draft)
        state.edits = edits
        state.step = "REVIEW"
    
    save_state(state)
    return state

What Worked Well§

Pitch generation was surprisingly good—DeepSeek caught nuances in trends that I would have missed. For instance, it suggested a piece on "Embedding Drift in RAG Pipelines" based on a subtle shift in retrieval augmentation papers. The outlines were detailed enough to cut first-draft time by 60%. I no longer stared at a blank page.

The edit pass consistently caught tone inconsistencies. For example, it flagged a paragraph that slipped into second-person generalities, which violated my first-person rule. It also found redundant phrases like "in order to" that I unconsciously overuse. The suggested changes were accurate 85% of the time.

Another win: the system forced me to think about style upfront. Defining a style document improved all downstream outputs. I spent two hours crafting that document, and it paid off every week.

What Failed and Why§

My first attempts omitted a tone profile. The drafts were generic—sounding like a textbook. I fixed this by adding a 200-word style guide in the system prompt for both Writer and Outliner agents. Also, the Editor agent initially rewrote entire paragraphs, removing personality. I switched it to "suggest only" mode, where it lists issues without rewriting.

DeepSeek's researcher sometimes hallucinated sources—citing papers that didn't exist. I added a verification step: after the draft, the Editor checks each claim against Perplexity. If a source is unverifiable, it flags it. This added 10 minutes per piece but prevented embarrassment.

Another failure: the system didn't handle long-running tasks well. Timeouts occurred when the Writer agent exceeded the 2-minute limit. I reduced the max token output for the draft to 2000 tokens and added retry logic.

Results and Takeaways§

Throughput increased from 5 pieces per week to 15 pieces per week with the same editorial quality. Time per piece dropped from 4 hours to 1.5 hours (including human oversight for edits and verification). The agent flow handled 70% of the cognitive load—pitching, outlining, and mechanical drafting.

I observed that the best pieces still required my personal touch: adding an anecdote, tweaking a metaphor, or challenging an assumption. But the routine work was automated. The system also worked cross-domain: I added two new domains (bioinformatics and indie hacking) by just providing a style document and trend sources.

Try It Yourself§

Here's a minimal setup to replicate this:

1. Install Python 3.10+ and pip install openai deepseek-api requests httpx.
2. Get API keys for DeepSeek, Claude (Anthropic), and Perplexity. Store them in .env.
3. Clone my starter repo: git clone github.com/yourname/agentic-calendar (replace with actual path).
4. Edit style_doc.txt with your tone preferences.
5. Run python run_pipeline.py --domain tech --week 2025-04-15.

The script outputs a state.json with pitches, outline, draft, and edits. Use any text editor to review and publish.

Tweak the prompts: experiment with different models for different roles. I found DeepSeek better for research, Claude for writing. Share your results—I'd love to see how others remix this flow.