Building Content & Productivity Agents

You have learned how to design agent architectures, wire up tools, and orchestrate multi-step workflows. Now it is time to build something people actually use every day. Content creation and personal productivity are where agents deliver the most immediate, tangible value — because the tasks are repetitive, time-consuming, and follow predictable patterns.

In this lesson, we walk through four practical builds that you can adapt and deploy.

Build 1: Morning Briefing Agent

Every professional spends time each morning catching up — scanning emails, reading news, checking social mentions. An agent can do this in seconds and deliver a single, structured briefing.

Architecture:

┌─────────────────────────────────────┐
│         Morning Briefing Agent       │
├─────────────────────────────────────┤
│  Triggers: Cron schedule (6:00 AM)  │
├──────────┬──────────┬───────────────┤
│ RSS Tool │ Email    │ Social Media  │
│ (feedparser)│ Tool  │ Tool (API)   │
│          │ (IMAP)  │               │
├──────────┴──────────┴───────────────┤
│  LLM Summarization Layer           │
├─────────────────────────────────────┤
│  Output: Formatted briefing        │
│  (Email / Telegram / Slack)        │
└─────────────────────────────────────┘

Tools needed:

• RSS parser (Python feedparser or similar)
• Email client (IMAP access to your inbox)
• Social media API (Twitter/X API, LinkedIn API)
• LLM for summarization and prioritization

Workflow:

1. Agent triggers on a cron schedule each morning
2. Pulls latest items from configured RSS feeds
3. Scans email inbox for unread messages, extracts subject lines and senders
4. Checks social media mentions and relevant hashtags
5. Sends all raw data to the LLM with a prompt: "Prioritize these items, highlight anything urgent, and summarize everything in under 300 words"
6. Delivers the briefing via your preferred channel

# Morning briefing agent - core workflow
import feedparser
from datetime import datetime, timedelta

def gather_rss_updates(feed_urls: list[str], since_hours: int = 24) -> list[dict]:
    """Collect recent RSS entries from configured feeds."""
    cutoff = datetime.now() - timedelta(hours=since_hours)
    entries = []
    for url in feed_urls:
        feed = feedparser.parse(url)
        for entry in feed.entries:
            published = datetime(*entry.published_parsed[:6])
            if published > cutoff:
                entries.append({
                    "title": entry.title,
                    "link": entry.link,
                    "source": feed.feed.title,
                    "summary": entry.get("summary", "")[:200]
                })
    return entries

def build_briefing_prompt(rss_items, emails, mentions) -> str:
    """Construct the LLM prompt for summarization."""
    return f"""You are a personal briefing assistant.
Summarize the following updates in under 300 words.
Prioritize urgent items first.

## News ({len(rss_items)} items)
{format_items(rss_items)}

## Emails ({len(emails)} unread)
{format_items(emails)}

## Social Mentions ({len(mentions)} mentions)
{format_items(mentions)}
"""

What the agent handles vs. what you review: The agent gathers, filters, and summarizes. You read a two-minute briefing instead of spending thirty minutes across multiple apps. You decide what needs a response.

Build 2: Script-to-Slides Workflow

You write a talk script or blog outline. The agent turns it into presentation slides with key points extracted and speaker notes prepared.

Tools needed:

• Text parser (to split the script into logical sections)
• LLM (to extract key points and generate speaker notes)
• Slide generation library (Python python-pptx or Google Slides API)
• Image search API (optional — for relevant visuals)

Workflow:

1. You provide a script or outline as input
2. The agent splits the content into logical sections (one per slide)
3. For each section, the LLM extracts the key point (headline), supporting bullets, and speaker notes
4. The slide generator creates the presentation with consistent styling
5. The agent outputs a downloadable file or a link to a Google Slides document

# Script-to-slides - section extraction
def split_into_slides(script: str, max_slides: int = 15) -> list[dict]:
    """Break a script into slide-sized sections."""
    sections = script.split("\n\n")  # Split on double newline
    slides = []
    for section in sections[:max_slides]:
        slide = llm.generate(
            prompt=f"""Extract from this section:
            1. A headline (max 8 words)
            2. 3-4 bullet points
            3. Speaker notes (2-3 sentences)

            Section: {section}""",
            response_format="json"
        )
        slides.append(slide)
    return slides

What the agent handles: Structure, formatting, and the tedious slide-by-slide creation. What you review: The narrative flow, visual choices, and final polish.

Build 3: Social Media Carousel Generator

You have a blog post or video transcript. The agent converts it into a series of carousel images for Instagram or LinkedIn — each image containing one key takeaway.

Tools needed:

• Content parser (extract key points from long text)
• LLM (to rewrite points as short, punchy carousel text)
• Image generation library (Pillow, or a design API like Canva's)
• Template system (consistent branding across slides)

Workflow:

1. Feed the agent your blog post or transcript
2. The LLM identifies the top takeaways (typically 5-8 for a carousel)
3. Each takeaway is rewritten as a short, visually friendly statement
4. The image generator places each statement onto a branded template
5. Output: a set of images ready to upload

What the agent handles: Reading comprehension, copywriting for visual format, image generation. What you review: Brand consistency and whether the key points actually represent your content.

Build 4: Motion Graphics with Remotion

Remotion is a React framework for creating videos programmatically. Instead of editing video by hand, you write React components that render as video frames. An agent can generate these components from a script.

Tools needed:

• Remotion (React framework for video — remotion.dev)
• LLM (to translate a script into scene descriptions)
• Asset library (stock images, icons, brand assets)
• Rendering pipeline (Remotion's built-in renderer)

Workflow:

1. You provide a script with scene descriptions
2. The agent generates a Remotion composition — each scene becomes a React component
3. Text animations, transitions, and timing are handled programmatically
4. The agent triggers a render and outputs an MP4 file

// Remotion scene component - generated by the agent
import { AbsoluteFill, useCurrentFrame, interpolate } from "remotion";

export const TitleScene: React.FC<{ text: string }> = ({ text }) => {
  const frame = useCurrentFrame();
  const opacity = interpolate(frame, [0, 30], [0, 1], {
    extrapolateRight: "clamp",
  });

  return (
    <AbsoluteFill style={{ backgroundColor: "#0a0a0a", justifyContent: "center", alignItems: "center" }}>
      <h1 style={{ color: "#fff", fontSize: 64, opacity }}>{text}</h1>
    </AbsoluteFill>
  );
};

The power here is that video creation becomes code — and code is something agents are excellent at generating and iterating on.

Key takeaway: Content and productivity agents succeed because they automate predictable, repetitive workflows. The agent handles the tedious steps; you maintain creative control over the final output.

Next: Building agents for operations and community management — automating the work that keeps businesses running. :::