Product Description Generation Crew

Writing compelling product descriptions at scale is one of e-commerce's biggest challenges. A single product might need descriptions for Amazon, Shopify, social media, and email marketing - each with different requirements.

Let's build a Product Description Crew that automates this entire workflow.

The Product Description Challenge

Crew Architecture

Our Product Description Crew has four specialized agents working in sequence:

┌─────────────────────────────────────────────────────────────────┐
│                  PRODUCT DESCRIPTION CREW                       │
│                                                                 │
│  ┌──────────┐    ┌──────────┐    ┌──────────┐    ┌──────────┐  │
│  │ Product  │───▶│   SEO    │───▶│  Copy-   │───▶│  Quality │  │
│  │Researcher│    │ Analyst  │    │  writer  │    │ Reviewer │  │
│  └──────────┘    └──────────┘    └──────────┘    └──────────┘  │
│       │               │               │               │         │
│       ▼               ▼               ▼               ▼         │
│   Market &        Keyword        Product         Final QA       │
│   Audience        Research       Listing         & Approval     │
│   Insights        + Strategy     Creation                       │
└─────────────────────────────────────────────────────────────────┘

Complete Implementation

Step 1: Define Custom Tools

from crewai import Agent, Task, Crew, Process
from crewai.tools import tool
from typing import Optional
import json

# Tool: Product Database Lookup
@tool("Product Database")
def get_product_details(product_id: str) -> str:
    """
    Retrieves complete product information from the database.

    Args:
        product_id: Unique product identifier (e.g., "PROD-12345")

    Returns:
        JSON with product name, features, specifications, price, and images.
    """
    # In production, connect to your actual product database
    products = {
        "PROD-12345": {
            "name": "CloudWalk Pro Running Shoes",
            "brand": "AthleteEdge",
            "price": 129.99,
            "category": "Footwear > Running",
            "features": [
                "CloudFoam cushioning technology",
                "Breathable mesh upper",
                "Reflective details for night running",
                "Lightweight at just 8.5 oz",
                "10mm heel-to-toe drop"
            ],
            "materials": ["Engineered mesh", "EVA foam", "Rubber outsole"],
            "available_colors": ["Midnight Black", "Ocean Blue", "Solar Red"],
            "sizes": "6-14 (US Men's)",
            "rating": 4.6,
            "reviews_count": 2847
        }
    }

    product = products.get(product_id)
    if product:
        return json.dumps(product, indent=2)
    return f"Product {product_id} not found"


# Tool: Competitor Analysis
@tool("Competitor Analyzer")
def analyze_competitors(product_category: str, price_point: float) -> str:
    """
    Analyzes competitor products in the same category and price range.

    Args:
        product_category: Product category (e.g., "Running Shoes")
        price_point: Target price for comparison

    Returns:
        JSON with competitor products, their positioning, and gaps.
    """
    competitor_data = {
        "competitors": [
            {
                "brand": "Nike",
                "product": "Air Zoom Pegasus",
                "price": 139.99,
                "positioning": "Performance-focused, marathon training",
                "key_features": ["Zoom Air units", "Flywire cables"]
            },
            {
                "brand": "Adidas",
                "product": "Ultraboost Light",
                "price": 189.99,
                "positioning": "Premium comfort, lifestyle crossover",
                "key_features": ["Boost midsole", "Primeknit upper"]
            },
            {
                "brand": "Brooks",
                "product": "Ghost 15",
                "price": 139.95,
                "positioning": "Neutral cushioning, everyday runner",
                "key_features": ["DNA LOFT cushioning", "Segmented crash pad"]
            }
        ],
        "market_gaps": [
            "Few options combine lightweight with maximum cushion",
            "Reflective features underemphasized by competitors",
            "Price point $120-130 has limited premium options"
        ],
        "positioning_opportunity": "Lightweight cushioned shoe for safety-conscious evening runners"
    }

    return json.dumps(competitor_data, indent=2)


# Tool: SEO Keyword Research
@tool("SEO Keyword Research")
def research_seo_keywords(product_type: str, target_audience: str) -> str:
    """
    Researches SEO keywords for product listings.

    Args:
        product_type: Type of product (e.g., "running shoes")
        target_audience: Target customer segment (e.g., "casual runners")

    Returns:
        JSON with primary keywords, long-tail phrases, and search volumes.
    """
    keyword_data = {
        "primary_keywords": [
            {"term": "running shoes", "monthly_searches": 823000, "competition": "high"},
            {"term": "cushioned running shoes", "monthly_searches": 74000, "competition": "medium"},
            {"term": "lightweight running shoes", "monthly_searches": 49000, "competition": "medium"}
        ],
        "long_tail_keywords": [
            {"term": "best running shoes for beginners", "monthly_searches": 18000, "competition": "low"},
            {"term": "running shoes for night running", "monthly_searches": 4400, "competition": "low"},
            {"term": "comfortable running shoes for long distance", "monthly_searches": 12000, "competition": "medium"}
        ],
        "buyer_intent_keywords": [
            "buy running shoes online",
            "running shoes free shipping",
            "running shoes sale"
        ],
        "recommended_tags": [
            "running shoes",
            "mens running shoes",
            "cushioned",
            "lightweight",
            "reflective",
            "night running"
        ]
    }

    return json.dumps(keyword_data, indent=2)


# Tool: Brand Guidelines
@tool("Brand Guidelines")
def get_brand_guidelines(brand_name: str) -> str:
    """
    Retrieves brand voice and style guidelines.

    Args:
        brand_name: Name of the brand

    Returns:
        JSON with brand voice, tone, and writing guidelines.
    """
    guidelines = {
        "brand_name": "AthleteEdge",
        "brand_voice": "Confident, encouraging, performance-driven",
        "tone": "Energetic but not aggressive, expert but accessible",
        "writing_principles": [
            "Lead with benefits, support with features",
            "Use action verbs",
            "Speak directly to the customer (you/your)",
            "Avoid jargon unless it adds credibility",
            "Keep sentences punchy - max 20 words"
        ],
        "words_to_use": ["performance", "engineered", "precision", "elevate", "unleash"],
        "words_to_avoid": ["cheap", "basic", "just", "only", "simple"],
        "formatting": {
            "title_max_chars": 80,
            "bullets_count": 5,
            "description_words": "150-200"
        }
    }

    return json.dumps(guidelines, indent=2)

Step 2: Define Specialized Agents

# Agent 1: Product Research Analyst
product_researcher = Agent(
    role="Product Research Analyst",

    goal="Gather comprehensive product data, competitive insights, and "
         "target audience information to inform compelling product copy",

    backstory="""You are a senior product analyst with 8 years of experience
    in e-commerce research. You've analyzed products for Nike, Lululemon,
    and Allbirds.

    Your superpower is identifying the unique value proposition that
    makes a product stand out. You dig deep into features to understand
    WHY they matter to customers, not just WHAT they are.

    You always consider:
    - Who is the ideal customer?
    - What problem does this product solve?
    - How is it different from competitors?
    - What emotional benefit does it provide?""",

    tools=[get_product_details, analyze_competitors],
    verbose=True
)


# Agent 2: SEO Content Strategist
seo_strategist = Agent(
    role="E-commerce SEO Specialist",

    goal="Identify high-value keywords and develop a strategy that "
         "maximizes organic search visibility without sacrificing readability",

    backstory="""You are an SEO expert who has optimized product listings
    generating over $50M in organic revenue. You understand that SEO is
    not about keyword stuffing - it's about matching search intent.

    Your approach:
    - Primary keyword in title and first paragraph
    - Long-tail keywords in bullet points naturally
    - Semantic variations throughout
    - Never sacrifice readability for keywords

    You know that a well-optimized listing ranks AND converts.""",

    tools=[research_seo_keywords],
    verbose=True
)


# Agent 3: Product Copywriter
product_copywriter = Agent(
    role="Senior E-commerce Copywriter",

    goal="Transform product research and SEO strategy into compelling, "
         "conversion-focused product listings that drive sales",

    backstory="""You are an award-winning e-commerce copywriter with
    experience writing for top DTC brands. Your listings have achieved
    15%+ conversion rates consistently.

    Your writing philosophy:
    - Features tell, benefits sell
    - Lead with the transformation, not the product
    - Every bullet point should answer "so what?"
    - The headline is 80% of the battle
    - Emotion drives the click, logic justifies the purchase

    You write in a way that makes customers feel understood.""",

    tools=[get_brand_guidelines],
    verbose=True
)


# Agent 4: Quality Assurance Editor
quality_reviewer = Agent(
    role="Content Quality Assurance Editor",

    goal="Ensure product listings meet brand standards, are factually "
         "accurate, and optimized for maximum conversion potential",

    backstory="""You are a meticulous editor who has reviewed over 10,000
    product listings. You catch what others miss.

    Your review checklist:
    - Accuracy: Do claims match product specs?
    - Brand voice: Is tone consistent with guidelines?
    - SEO: Are keywords naturally integrated?
    - Conversion: Is there a clear value proposition?
    - Formatting: Headlines, bullets, spacing correct?

    You believe great copy is rewritten, not written.""",

    tools=[get_brand_guidelines, get_product_details],
    verbose=True
)

Step 3: Define the Task Workflow

# Task 1: Product Research
research_task = Task(
    description="""
    Conduct comprehensive research for product: {product_id}

    Your deliverables:
    1. Complete product specifications and features
    2. Target audience profile (demographics, psychographics, pain points)
    3. Competitive analysis (3-5 competitors, positioning gaps)
    4. Unique value proposition (what makes this product special)
    5. Key selling points ranked by customer importance

    Focus on insights that will help write compelling copy.
    Don't just list features - explain why they matter.
    """,

    expected_output="""
    A comprehensive product brief containing:
    - Product overview with all specifications
    - Target customer avatar with pain points
    - Competitive landscape and positioning opportunity
    - 5 ranked selling points with customer benefits
    - Recommended emotional angle for copywriting
    """,

    agent=product_researcher
)


# Task 2: SEO Strategy
seo_task = Task(
    description="""
    Develop an SEO strategy for the product listing based on the research.

    Your deliverables:
    1. Primary keyword (must appear in title)
    2. Secondary keywords (for bullet points)
    3. Long-tail keywords (for description body)
    4. Semantic variations to avoid repetition
    5. Recommended product tags

    Remember: Keywords should enhance, not hurt readability.
    Match search intent with the customer persona from research.
    """,

    expected_output="""
    SEO keyword strategy containing:
    - 1 primary keyword with placement recommendation
    - 5 secondary keywords with usage suggestions
    - 3 long-tail phrases for natural integration
    - List of semantic variations
    - 10 recommended product tags
    """,

    agent=seo_strategist,
    context=[research_task]
)


# Task 3: Copywriting
copywriting_task = Task(
    description="""
    Write the complete product listing using the research and SEO strategy.

    Create:
    1. HEADLINE: Compelling, keyword-optimized (max 80 characters)
    2. BULLET POINTS: 5 benefit-focused points with keywords
    3. MAIN DESCRIPTION: 150-200 words, emotionally engaging
    4. CALL-TO-ACTION: Compelling reason to buy now

    Writing guidelines:
    - Lead with the biggest benefit
    - Use second person (you/your)
    - Include sensory language
    - Address objections preemptively
    - Create urgency without being pushy

    Make the customer feel this product was made for them.
    """,

    expected_output="""
    Complete product listing:
    - SEO-optimized headline (under 80 chars)
    - 5 benefit-focused bullet points
    - 150-200 word main description
    - Clear call-to-action
    - All formatted and ready for upload
    """,

    agent=product_copywriter,
    context=[research_task, seo_task]
)


# Task 4: Quality Review
review_task = Task(
    description="""
    Review the product listing for quality and accuracy.

    Check for:
    1. ACCURACY: All claims match product specifications
    2. BRAND VOICE: Tone matches brand guidelines
    3. SEO: Keywords integrated naturally, not stuffed
    4. CONVERSION: Clear value proposition and CTA
    5. FORMATTING: Correct headline length, bullet count
    6. GRAMMAR: No errors, consistent style

    If you find issues, provide the corrected version.
    If approved, confirm the listing is ready for publication.
    """,

    expected_output="""
    Quality review report:
    - Pass/Fail status
    - Issues found (if any) with corrections
    - Final approved listing (if passing)
    - Confidence score (1-10) for conversion potential
    """,

    agent=quality_reviewer,
    context=[research_task, copywriting_task]
)

Step 4: Assemble and Run the Crew

# Create the Product Description Crew
product_description_crew = Crew(
    agents=[product_researcher, seo_strategist, product_copywriter, quality_reviewer],
    tasks=[research_task, seo_task, copywriting_task, review_task],
    process=Process.sequential,  # Tasks run in order
    verbose=True
)


def generate_product_listing(product_id: str) -> str:
    """Generate a complete product listing for the given product ID."""
    result = product_description_crew.kickoff(
        inputs={"product_id": product_id}
    )
    return result


# Run the crew
if __name__ == "__main__":
    listing = generate_product_listing("PROD-12345")
    print("\n" + "="*60)
    print("FINAL PRODUCT LISTING")
    print("="*60)
    print(listing)

Sample Output

When you run this crew, you'll get output like:

Scaling to Multiple Products

Process many products efficiently with batch processing:

import asyncio
from typing import List, Dict

async def generate_listings_batch(product_ids: List[str]) -> Dict[str, str]:
    """Generate listings for multiple products."""
    results = {}

    for product_id in product_ids:
        print(f"Processing {product_id}...")
        result = product_description_crew.kickoff(
            inputs={"product_id": product_id}
        )
        results[product_id] = result

    return results


# Process a batch of products
product_ids = ["PROD-12345", "PROD-12346", "PROD-12347", "PROD-12348"]
listings = asyncio.run(generate_listings_batch(product_ids))

# Save to database or export
for product_id, listing in listings.items():
    print(f"Completed: {product_id}")
    # save_to_database(product_id, listing)

Key Takeaways

Next up: Dynamic Pricing Agent Crew - Build agents that optimize prices based on competition and demand.