Practical Agent Workflows: From Research to Publication

Learn how to orchestrate AI agents for end-to-end content creation. This practical workflow shows how to use agents for ideation, research, drafting, editing, and publishing — while keeping you in control.

The Content Creation Workflow

Modern content creation involves multiple stages:

  1. Ideation – Finding good topics
  2. Research – Gathering and verifying information
  3. Writing – Creating the first draft
  4. Editing – Improving clarity, structure, and accuracy
  5. Publishing – Formatting, SEO, and distribution

AI agents can help at every stage. Here’s how to build a workflow that leverages agents effectively.

Stage 1: Ideation with the Topic Exchange

Instead of staring at a blank page, use the topic exchange to find validated, high-potential topics.

# Step 1: Browse open topics
import requests

response = requests.get(
    "https://topic-exchange.donotmerge.com/api/topics/open",
    params={"site_id": "health-guides", "limit": 10}
)
topics = response.json()

# Step 2: Choose a topic that interests you
selected_topic = topics[0]  # Or use your own criteria

# Step 3: Claim it (optional, but prevents duplicates)
claim_response = requests.post(
    f"https://topic-exchange.donotmerge.com/api/topics/{selected_topic['id']}/claim",
    json={"claimed_by": "session:your-workflow-123"}
)

Why this works:

  • Topics are pre-vetted by the community (via voting/signals)
  • You see what others find valuable
  • Reduces ideation time from hours to minutes
  • The commitment hash system lets you prove you worked on it without revealing identity

Pro tip: Use the /api/signals endpoint to see what topics are gaining traction.

Stage 2: Research with a Specialized Agent

Deploy a research agent to gather sources and extract key points.

class ResearchWorkflow:
    def __init__(self, topic_id: str):
        self.topic_id = topic_id
        self.agent = ResearchAgent()
    
    async def run(self) -> ResearchBundle:
        # Get topic details
        topic = await self.get_topic_details(self.topic_id)
        
        # Run research agent
        research_spec = await self.agent.clarify_question(topic.description)
        sources = await self.agent.gather_sources(research_spec)
        analyses = await self.agent.analyze_sources(sources)
        synthesis = await self.agent.synthesize(analyses)
        
        return ResearchBundle(
            topic=topic,
            sources=sources,
            analyses=analyses,
            synthesis=synthesis
        )

The research agent does:

  • Parallel searches across multiple sources
  • Source quality filtering (peer-reviewed, authoritative)
  • Claim extraction and evidence grading
  • Conflict detection and consensus building
  • Automatic citation generation

Output: A structured research bundle with:

  • 15-30 high-quality sources
  • Extracted claims with evidence ratings
  • Synthesis of agreements/disagreements
  • Identified research gaps
  • Ready-to-use citations

Stage 3: Writing with a Writing Agent

Use a writing agent to create a first draft from your research.

class WritingWorkflow:
    def __init__(self, research_bundle: ResearchBundle):
        self.bundle = research_bundle
        self.writer = WritingAgent(style="informative-yet-engaging")
    
    async def run(self) -> ArticleDraft:
        # Prepare context for the writer
        context = self._build_writing_context(self.bundle)
        
        # Generate draft
        draft = await self.writer.write(
            title=self.bundle.topic.title,
            context=context,
            target_length=1200,  # words
            format="markdown"
        )
        
        return draft
    
    def _build_writing_context(self, bundle: ResearchBundle) -> str:
        return f"""
        Research Topic: {bundle.topic.title}
        
        Key Findings:
        {self._format_synthesis(bundle.synthesis)}
        
        Important Sources:
        {self._format_top_sources(bundle.sources, limit=5)}
        
        Research Gaps to Mention:
        {self._format_gaps(bundle.synthesis.gaps)}
        
        Writing Guidelines:
        - Target audience: Informed non-specialists
        - Tone: Authoritative yet accessible
        - Include: Practical takeaways, concrete examples
        - Avoid: Jargon without explanation, unsupported claims
        - Cite: All factual claims with inline references
        """

The writing agent produces:

  • A complete first draft (900-1500 words)
  • Proper structure (hook, thesis, body, counterpoint, takeaway)
  • Inline citations where appropriate
  • Engaging prose that matches the target style
  • A clear narrative flow

You still provide: The unique angle, personal examples, and final voice.

Stage 4: Editing with an Editor Agent

Use an editor agent to refine the draft before human review.

class EditingWorkflow:
    def __init__(self, draft: ArticleDraft):
        self.draft = draft
        self.editor = EditingAgent()
    
    async def run(self) -> EditedDraft:
        # Run multiple editing passes
        draft_after_structure = await self.editor.edit_for_structure(self.draft)
        draft_after_clarity = await self.editor.edit_for_clarity(draft_after_structure)
        draft_after_factcheck = await self.editor.fact_check(draft_after_clarity, self.bundle.sources)
        final_draft = await self.editor.optimize_for_reading(draft_after_factcheck)
        
        return final_draft

The editor agent checks:

  • Structure: Logical flow, proper transitions, section balance
  • Clarity: Jargon elimination, sentence variety, readability
  • Fact-checking: Verifies claims against research bundle
  • Engagement: Hook strength, pacing, conclusion impact
  • SEO: Heading structure, keyword natural placement, meta description

Output: A polished draft that’s ready for final human review.

Stage 5: Publishing Preparation

Use agents to prepare for publishing.

class PublishingWorkflow:
    def __init__(self, edited_draft: EditedDraft):
        self.draft = edited_draft
    
    async def run(self) -> PublishingPackage:
        # Generate SEO metadata
        seo = await self.generate_seo_metadata(self.draft)
        
        # Create social snippets
        social = await self.create_social_snippets(self.draft)
        
        # Suggest internal links
        links = await self.suggest_internal_links(self.draft)
        
        # Generate excerpt
        excerpt = await self.generate_excerpt(self.draft, length=160)
        
        return PublishingPackage(
            markdown=self.draft.content,
            seo=seo,
            social=social,
            internal_links=links,
            excerpt=excerpt
        )

Agents help with:

  • SEO: Title optimization, meta description, heading structure
  • Social: Twitter/X threads, LinkedIn posts, Reddit-friendly summaries
  • Linking: Suggesting relevant internal links to other site content
  • Accessibility: Alt text suggestions, reading level analysis
  • Formatting: Converting to site-specific markdown frontmatter

The Human-in-the-Loop Checklist

Agents augment, not replace. Here’s where you add value:

✅ After Ideation:

  • Choose topics that genuinely interest you (not just what’s popular)
  • Add your unique perspective or angle to the topic
  • Verify the topic aligns with your site’s goals and audience

✅ After Research:

  • Review the source list for bias or missing perspectives
  • Add any domain-specific knowledge you have
  • Mark any claims that need special attention or skepticism

✅ After Writing:

  • Inject your voice, personal examples, and style
  • Ensure the tone matches your brand/site
  • Add any specialized knowledge or experience
  • Check that the argument flows logically with your unique insights

✅ After Editing:

  • Review the editor’s changes — accept, reject, or modify
  • Ensure no important nuance was lost in clarification
  • Verify the piece still says what you want it to say
  • Add final touches that make it distinctly yours

✅ After Publishing:

  • Monitor engagement and feedback
  • Use comments/questions to inform future topics
  • Track what resonates with your audience

Tools You Need

To implement this workflow, you’ll need:

1. Topic Exchange Client

  • For ideation and claiming topics
  • Available as REST API or MCP server
  • Python/JS clients available

2. Research Agent

  • Can be built using:
    • Base LLM + web search + web extract tools
    • Or use a pre-built research agent framework
  • Key capabilities: search, extract, analyze, synthesize

3. Writing Agent

  • Configured for long-form content
  • Style controls (academic, journalistic, conversational, etc.)
  • Length and structure guidance

4. Editing Agent

  • Multiple passes: structure, clarity, fact-check, polish
  • Configurable for different content types
  • Integrates with your research for fact-checking

5. Publishing Helpers

  • SEO metadata generator
  • Social snippet creator
  • Internal link suggester
  • Excerpt/abstract generator

Example Workflow Run

Let’s walk through a real example:

Day 1: Ideation

  • 9:00 AM: Check topic exchange for health-guides site
  • 9:05 AM: Find topic “Zone 2 Training: The Cardio Protocol That Builds Mitochondria Without Burnout”
  • 9:07 AM: Claim topic with session:workflow-456
  • 9:10 AM: Review topic description and suggested sources

Day 1: Research

  • 9:15 AM: Launch research agent
  • 9:30 AM: Agent returns with 22 sources (6 RCTs, 8 reviews, 4 mechanistic studies, 4 expert opinions)
  • 9:45 AM: Review synthesis: consensus on mitochondrial benefits, optimal zone (60-70% max HR), minimum effective dose (30 min, 3x/week)
  • 10:00 AM: Add note to check latest meta-analysis from 2026

Day 1: Writing

  • 10:15 AM: Launch writing agent with research bundle
  • 10:45 AM: Receive first draft (1180 words)
  • 11:00 AM: Read draft, note where to add personal experience with zone 2 training
  • 11:15 AM: Add two personal anecdotes and adjust tone to be more encouraging

Day 2: Editing

  • 9:00 AM: Launch editing agent
  • 9:30 AM: Receive edited draft
  • 9:45 AM: Review changes:
    • Improved flow in mechanisms section
    • Clarified heart rate calculation explanation
    • Added citation to recent meta-analysis I missed
    • Suggested stronger closing call-to-action
  • 10:00 AM: Accept most edits, modify one for tone, finalize draft

Day 2: Publishing

  • 10:30 AM: Run publishing workflow
  • 10:45 AM: Receive SEO title, meta description, social snippets
  • 11:00 AM: Add frontmatter, verify links, schedule for publishing
  • 11:15 AM: Schedule post for next Tuesday at 8:00 AM
  • 11:20 AM: Share snippet on social media for promotion

Total active time: ~3 hours (vs. 8+ hours for manual process) Quality: Equal or better due to systematic research and editing Your contribution: Unique angle, personal voice, final judgment

The Takeaway

The best agent workflows treat agents as skilled assistants, not autonomous replacements.

You remain the:

  • Visionary – choosing what’s worth creating
  • Curator – selecting and interpreting information
  • Editor – ensuring quality and voice
  • Publisher – deciding when and how to share

Agents handle the:

  • Legwork – searching, extracting, organizing
  • Drafting – producing coherent first passes
  • Editing – catching errors and improving clarity
  • Preparation – optimizing for distribution

This workflow scales. Once you’ve built your agent toolkit, you can:

  • Produce more content with the same effort
  • Tackle more complex topics with better research
  • Maintain higher quality through systematic checks
  • Spend your time on what only you can do: judgment, creativity, and connection

Start small: Use agents for just one stage (e.g., research) in your next piece. Then gradually expand. Soon you’ll wonder how you ever created content without your agent team.

“The goal isn’t to eliminate human effort. It’s to redirect it from tedious tasks to the work that only humans can do well: having ideas, making judgments, and creating meaning.”