Building My Autonomous Blog Agent
I built an AI agent that writes, optimizes, and publishes my BMX blog posts. Here's how you can do the same:
What You're Building
- 8 Skills: Research, Writing, SEO Optimization, Image Creation, Publishing to WordPress, Social Media Sharing, Performance Tracking
- Result: 3 high-quality posts per week fully automated
Prerequisites
- Python 3.10+
- WordPress blog (REST API enabled)
- OpenAI API key
- SEO tool like Ahrefs or SEMrush
- Social media API access (optional)
Build Time: 4-6 hours
Ongoing Cost: $50-100/month
Step 1: Set Up the Agent Foundation
blog-agent/
├── agent.py # Main agent
├── skills/ # Agent skills
│ ├── __init__.py
│ ├── research.py
│ ├── writing.py
│ ├── seo.py
│ └── publishing.py
├── config.py # Configuration
├── voice_profile.txt # Your writing style
└── requirements.txt
Install dependencies:
pip install openai requests beautifulsoup4 python-dotenv langchain duckduckgo-search pillow
Set up configuration:
import os
from dotenv import load_dotenv
load_dotenv()
class Config:
OPENAI_API_KEY = os.getenv('OPENAI_API_KEY')
WP_URL = os.getenv('WORDPRESS_URL')
WP_USER = os.getenv('WORDPRESS_USER')
WP_APP_PASSWORD = os.getenv('WORDPRESS_APP_PASSWORD')
AHREFS_API_KEY = os.getenv('AHREFS_API_KEY')
TWITTER_API_KEY = os.getenv('TWITTER_API_KEY')
POSTS_PER_WEEK = 3
Step 2: Build Research Skill
Find trending topics:
from duckduckgo_search import DDGS
import requests
import openai
from config import Config
class ResearchSkill:
def __init__(self):
self.config = Config()
def find_trending_topics(self, niche):
print(f"🔍 Researching trending topics in {niche}...")
# Search Reddit and Twitter for trending discussions
with DDGS() as ddgs:
reddit_results = list(ddgs.text(f"site:reddit.com {niche}", max_results=20))
twitter_results = list(ddgs.text(f"site:twitter.com {niche}", max_results=20))
# Get keyword opportunities from Ahrefs
url = "https://api.ahrefs.com/v3/keywords-explorer"
headers = {'Authorization': f'Bearer {self.config.AHREFS_API_KEY}'}
params = {'query': niche, 'country': 'us', 'limit': 50, 'order_by': 'keyword_difficulty:asc'}
response = requests.get(url, headers=headers, params=params)
keywords = response.json()
# Filter by difficulty
easy_keywords = [
k for k in keywords['keywords']
if k['difficulty'] <= self.config.TARGET_KEYWORD_DIFFICULTY and k['volume'] >= 500
]
return reddit_results + twitter_results, easy_keywords
def validate_topic(self, topic):
# Check if already covered or has enough volume
pass
Step 3: Build Writing Skill
Write posts in your voice:
import openai
from config import Config
class WritingSkill:
def __init__(self):
self.config = Config()
self.voice_profile = self.load_voice_profile()
def load_voice_profile(self):
with open(self.config.VOICE_PROFILE_PATH, 'r') as f:
return f.read()
def write_blog_post(self, topic, keyword, research_data):
print(f"✍️ Writing blog post: {topic}")
# Generate outline and full post
pass
Step 4: Build SEO Skill
Optimize posts:
import openai
from config import Config
class SEOSkill:
def __init__(self):
self.config = Config()
def optimize_post(self, post, keyword):
print(f"🎯 Optimizing for: {keyword}")
# Optimize content and add meta tags
pass
Step 5: Build Publishing Skill
Publish to WordPress:
import requests
from config import Config
class PublishingSkill:
def __init__(self):
self.config = Config()
self.wp_api_url = f"{self.config.WP_URL}/wp-json/wp/v2"
def publish_post(self, post, status='publish'):
print(f"🚀 Publishing: {post['title']}")
# Upload featured image and create post
pass
Step 6: Assemble the Complete Agent
from skills.research import ResearchSkill
from skills.writing import WritingSkill
from skills.seo import SEOSkill
from skills.publishing import PublishingSkill
from config import Config
class BlogPublishingAgent:
def __init__(self):
self.config = Config()
self.research = ResearchSkill()
self.writing = WritingSkill()
self.seo = SEOSkill()
self.publishing = PublishingSkill()
def run_weekly(self, niche):
print("🤖 Blog Agent starting weekly run...")
topics = self.research.find_trending_topics(niche=niche)
for topic_data in topics:
validation = self.research.validate_topic(topic_data['topic'])
if not validation['valid']:
continue
post = self.writing.write_blog_post(
topic=topic_data['topic'],
keyword=topic_data['keyword'],
research_data=topic_data
)
post = self.seo.optimize_post(post, topic_data['keyword'])
result = self.publishing.publish_post(post)
if result['success']:
print(f"✅ Successfully published: {result['url']}")
else:
print(f"❌ Failed to publish: {topic_data['topic']}")
Automate Weekly Execution
Set up a cron job or GitHub Actions for weekly runs:
Cron Job (Linux/Mac):
0 6 * * 0 cd /path/to/blog-agent && python agent.py
GitHub Actions:
name: Blog Publishing Agent
on:
schedule:
- cron: '0 6 * * 0'
jobs:
publish:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-python@v4
with:
python-version: '3.10'
- name: Install dependencies
run: pip install -r requirements.txt
- name: Run agent
env:
OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
WORDPRESS_URL: ${{ secrets.WORDPRESS_URL }}
WORDPRESS_USER: ${{ secrets.WORDPRESS_USER }}
WORDPRESS_APP_PASSWORD: ${{ secrets.WORDPRESS_APP_PASSWORD }}
run: python agent.py
Real Results
- Before: 1 post/week, manual work
- After: 3 posts/week, fully automated
Tools & Costs
Required:
- OpenAI API: $20-40/month
- WordPress hosting: $5-25/month
- SEO tool (Ahrefs): $99/month
Optional:
- Image generation: Free
- Social media APIs: Free
Total: $124-194/month
Getting Started This Weekend
Start building this weekend.
Autonomous blog in 2 weeks.
Call To Action
Check out my real AI tools at axon.nepa-ai.com.