Package & Deploy a Client-Ready Agent

In this capstone lab, you'll build a complete, client-ready content creation agent system from scratch. This is the final project that ties together everything you've learned throughout the course: agent configuration, workflow design, custom skills, security hardening, deployment practices, and client-facing documentation.

System Overview

You are building a Daily Content Engine — an agent system that:

1. Wakes up every morning on a schedule
2. Fetches content from RSS feeds and news sources
3. Summarizes key stories using an LLM
4. Generates social media carousels from blog posts
5. Delivers a formatted morning briefing via a messaging channel

┌──────────────────────────────────────────────────┐
│              Daily Content Engine                 │
│                                                   │
│  ┌────────────┐   ┌──────────────┐               │
│  │ Heartbeat  │──→│  RSS Fetch   │               │
│  │ (cron)     │   │  & Ingest    │               │
│  └────────────┘   └──────┬───────┘               │
│                          ↓                        │
│                   ┌──────────────┐               │
│                   │  LLM Summary │               │
│                   │  & Analysis  │               │
│                   └──────┬───────┘               │
│                          ↓                        │
│            ┌─────────────┴─────────────┐         │
│            ↓                           ↓         │
│  ┌──────────────┐          ┌──────────────┐     │
│  │   Morning    │          │   Carousel   │     │
│  │   Briefing   │          │   Generator  │     │
│  └──────┬───────┘          └──────┬───────┘     │
│         ↓                         ↓              │
│  ┌──────────────┐          ┌──────────────┐     │
│  │   Messaging  │          │   Platform   │     │
│  │   Channel    │          │   Export     │     │
│  └──────────────┘          └──────────────┘     │
│                                                   │
│  ┌────────────────────────────────────────────┐  │
│  │  Security Layer: trust, allow-lists, audit │  │
│  └────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────┘

Step 1: Agent Configuration (agent-config.yaml) — FILE 1

Create a complete YAML configuration file for the Daily Content Engine agent. This is the central file that defines how the agent behaves, what models it uses, and how it operates.

Your configuration must include these sections:

Agent Identity:

• Agent name, version, and description
• Author and contact information

Model Configuration:

• Define at least 3 model assignments for different task types:
  • summarization — a fast, cost-efficient model for summarizing articles
  • analysis — a capable model for deeper content analysis
  • creative — a strong model for generating carousel text and creative content
• For each, specify: model name, temperature, max tokens, and a brief rationale comment

Communication Channels:

• Configure at least 2 channels (e.g., Slack and email)
• For each channel: type, destination/webhook placeholder, format preference, and enabled flag

Memory Settings:

• Context window size and conversation history limit
• Knowledge base path for storing processed articles
• Cache TTL for fetched content

Heartbeat Schedule:

• Cron expression for the morning briefing (e.g., weekdays at 7 AM)
• Timezone setting
• A secondary schedule for weekly summary (e.g., Fridays at 5 PM)

Security Rules:

• Reference to the security hardening file
• Maximum actions per run
• Allowed external domains for RSS fetching
• Data retention policy

Step 2: Content Workflow (content-workflow.py) — FILE 2

Create a Python script that implements the morning briefing workflow. Use pseudocode-style structure with clear function signatures, docstrings, and data flow. Do NOT use real API calls — use structured placeholders that show exactly what would happen.

Your workflow must implement:

fetch_rss_feeds(feed_urls: list) -> list

• Accept a list of RSS feed URLs
• Return a list of article dictionaries with: title, link, published date, and summary
• Include error handling for unreachable feeds
• Add a placeholder comment showing where a real RSS parser (like feedparser) would be used

summarize_articles(articles: list, model: str, max_length: int) -> list

• Take the fetched articles and produce concise summaries
• Each summary should include: headline, 2-3 sentence summary, relevance score (1-10), and source attribution
• Include a placeholder for the LLM API call with the exact prompt template you would use
• Handle the case where the article list is empty

format_morning_briefing(summaries: list, date: str) -> str

• Format the summaries into a clean, readable morning briefing
• Include: greeting with date, top stories section (sorted by relevance), quick links section, and a sign-off
• Use Markdown formatting

send_briefing(briefing: str, channel_config: dict) -> bool

• Send the formatted briefing via the configured channel
• Support at least Slack (webhook) and email (SMTP) as channel types
• Return success/failure status
• Include placeholder for actual HTTP/SMTP calls

run_morning_workflow(config: dict) -> dict

• The main orchestrator function that ties everything together
• Load configuration, fetch feeds, summarize, format, and send
• Return a status report with: articles processed, briefing sent status, duration, and any errors
• Include logging at each step

Step 3: Social Media Carousel Skill (skills/social-media-carousel.yaml) — FILE 3

Create a custom skill definition in YAML format for generating social media carousel content from blog posts. This skill should follow a procedure-based pattern.

Your skill definition must include:

Skill Metadata:

• Name, description, version, and author
• Category (e.g., content-creation)
• Input and output type declarations

Procedure Steps (at least 5):

1. Extract — Take a blog post URL (or text), extract the main content, title, and key themes
2. Analyze — Identify 5-8 key points that would make compelling carousel slides
3. Generate — Write slide text for each key point (headline + supporting text, 40 words max per slide)
4. Hook — Create an attention-grabbing first slide and a call-to-action final slide
5. Format — Structure the output for multiple platforms (LinkedIn, Instagram, Twitter/X) with platform-specific character limits and hashtag strategies

Configuration Options:

• Number of slides (default: 8, range: 5-12)
• Tone (professional, casual, educational)
• Target platforms list
• Include emoji toggle
• Hashtag count per platform

Example Input/Output:

• Include a sample input (blog post topic) and the expected output format showing all carousel slides

Step 4: Client Proposal (client-proposal.md) — FILE 4

Write a professional client proposal document in Markdown. Imagine you are pitching the Daily Content Engine to a marketing agency that wants to automate their content workflow.

Your proposal must include:

Executive Summary (2-3 paragraphs)

• The client's problem: manual content curation is slow and inconsistent
• Your proposed solution: an AI-powered content engine
• Key benefit: 10+ hours saved per week with higher quality output

Problem Statement

• Detail 3-4 specific pain points the client faces
• Include estimated time/cost of the current manual process

Proposed Solution

• Architecture overview (reference the agent-config.yaml structure)
• How each component addresses a specific pain point
• Technology stack summary

Deliverables

• List each deliverable with description and timeline
• Include: agent system, custom skills, documentation, training session

Timeline

• Phase 1: Setup and configuration (Week 1)
• Phase 2: Workflow development and testing (Week 2-3)
• Phase 3: Deployment and training (Week 4)

Pricing Model

• Use value-based pricing with clear rationale
• Show the ROI calculation: time saved * hourly rate = value delivered
• Offer tiered pricing (Basic, Professional, Enterprise)
• Each tier should have different feature sets

Terms and Next Steps

• Payment schedule, support terms, and how to get started

Step 5: Deployment Guide (deployment-guide.md) — FILE 5

Write deployment documentation that a technical team member could follow to set up the agent system from scratch.

Your guide must include:

Prerequisites

• Required software and versions (Python, etc.)
• Required accounts and API keys (list each with purpose)
• System requirements (OS, memory, disk)

Installation Steps

• Step-by-step commands (use bash code blocks)
• Environment variable setup
• Configuration file placement

Configuration

• How to customize the agent-config.yaml for the client's needs
• How to add new RSS feeds
• How to configure messaging channels

Monitoring Setup

• How to check agent health
• Log file locations and rotation
• Key metrics to watch (articles processed, delivery success rate, LLM token usage)

Troubleshooting

• At least 5 common issues with solutions (e.g., feed timeout, LLM rate limit, channel auth failure)
• Each issue should have: symptom, cause, and fix

Maintenance Schedule

• Daily, weekly, and monthly maintenance tasks
• How to update feed sources
• How to upgrade the agent

Step 6: Security Hardening (security-hardening.yaml) — FILE 6

Create a security configuration file that locks down the agent system for production use.

Your security config must include:

Trust Levels:

• Define at least 3 trust levels (e.g., restricted, standard, elevated)
• For each level: what actions are allowed, token limits, and which users/roles get this level

Messaging Allow Lists:

• Approved sender domains/addresses
• Approved recipient domains/addresses
• Blocked patterns (e.g., personal email domains for a business system)

Credential Management:

• How API keys are stored (environment variables, not hardcoded)
• Key rotation schedule
• Which credentials are needed and their permission scopes

Action Approval Rules:

• Actions that require human approval before execution
• Auto-approved actions with conditions
• Maximum cost per action (token budget)
• Rate limits per action type

Monitoring and Alerting:

• Security events to log (failed auth, unusual patterns, rate limit hits)
• Alert thresholds and notification channels
• Audit log retention period

---

What to Submit

Your submission should contain 6 file sections in the editor:

• FILE 1: agent-config.yaml — Complete agent configuration
• FILE 2: content-workflow.py — Morning briefing workflow implementation
• FILE 3: skills/social-media-carousel.yaml — Carousel generation skill
• FILE 4: client-proposal.md — Professional client proposal
• FILE 5: deployment-guide.md — Deployment documentation
• FILE 6: security-hardening.yaml — Security configuration