Building Agent Templates: Pre-Configured Starting Points for Common Use Cases

Why Templates Accelerate Agent Adoption

Most users who want an AI agent for customer support do not want to write prompt engineering from scratch. They want to select "Customer Support Agent," fill in their company details, connect their knowledge base, and deploy. Templates provide this experience by packaging proven agent configurations as customizable starting points.

A good template system sits between fully custom development and rigid out-of-the-box agents. Users get 80% of the value immediately and can customize the remaining 20% without writing code.

Template Data Model

Each template defines a complete agent configuration with clearly marked customization points:

from dataclasses import dataclass, field
from typing import Any, Optional
from enum import Enum


class FieldType(Enum):
    TEXT = "text"
    TEXTAREA = "textarea"
    SELECT = "select"
    BOOLEAN = "boolean"
    FILE_UPLOAD = "file_upload"
    CONNECTION = "connection"


@dataclass
class CustomizationField:
    key: str
    label: str
    field_type: FieldType
    description: str = ""
    default_value: Any = None
    required: bool = False
    options: list[str] = field(default_factory=list)
    validation_regex: str = ""
    placeholder: str = ""


@dataclass
class AgentTemplate:
    id: str
    name: str
    description: str
    category: str
    icon: str = ""
    preview_image: str = ""
    base_system_prompt: str = ""
    recommended_model: str = "gpt-4o-mini"
    tools: list[str] = field(default_factory=list)
    customization_fields: list[CustomizationField] = field(
        default_factory=list
    )
    example_conversations: list[dict] = field(
        default_factory=list
    )
    estimated_setup_time: str = "5 minutes"

Here is a concrete customer support template:

customer_support_template = AgentTemplate(
    id="customer-support-v2",
    name="Customer Support Agent",
    description=(
        "Handle customer inquiries, look up orders, "
        "process returns, and escalate complex issues."
    ),
    category="Support",
    base_system_prompt=(
        "You are a customer support agent for "
        "{company_name}. Your role is to help customers "
        "with their questions about {product_types}.\n\n"
        "TONE: {tone}\n\n"
        "ESCALATION: If a customer is upset or you cannot "
        "resolve the issue, transfer to a human agent.\n\n"
        "KNOWLEDGE BASE: Use the search_knowledge tool to "
        "find answers before responding.\n\n"
        "{additional_instructions}"
    ),
    recommended_model="gpt-4o",
    tools=[
        "search_knowledge",
        "lookup_order",
        "create_ticket",
        "transfer_to_human",
    ],
    customization_fields=[
        CustomizationField(
            key="company_name",
            label="Company Name",
            field_type=FieldType.TEXT,
            required=True,
            placeholder="Acme Corp",
        ),
        CustomizationField(
            key="product_types",
            label="What do you sell?",
            field_type=FieldType.TEXT,
            required=True,
            placeholder="SaaS project management tools",
        ),
        CustomizationField(
            key="tone",
            label="Communication Style",
            field_type=FieldType.SELECT,
            options=[
                "Professional and formal",
                "Friendly and casual",
                "Technical and precise",
            ],
            default_value="Friendly and casual",
        ),
        CustomizationField(
            key="knowledge_base_file",
            label="Knowledge Base (FAQ document)",
            field_type=FieldType.FILE_UPLOAD,
            description="Upload a PDF or text file with FAQs",
        ),
        CustomizationField(
            key="additional_instructions",
            label="Additional Instructions",
            field_type=FieldType.TEXTAREA,
            placeholder="Any special policies or rules...",
            default_value="",
        ),
    ],
    estimated_setup_time="10 minutes",
)

Template Instantiation Engine

When a user fills in the customization fields, the engine resolves the template into a deployable agent configuration:

import re
from copy import deepcopy


class TemplateEngine:
    def __init__(self, template_store, file_processor):
        self.templates = template_store
        self.file_processor = file_processor

    async def instantiate(
        self, template_id: str, values: dict,
        tenant_id: str,
    ) -> dict:
        template = await self.templates.get(template_id)
        if not template:
            raise ValueError(f"Template not found: {template_id}")

        # Validate required fields
        self._validate_fields(template, values)

        # Process file uploads
        processed_values = dict(values)
        for cf in template.customization_fields:
            if (
                cf.field_type == FieldType.FILE_UPLOAD
                and cf.key in values
            ):
                processed_values[cf.key] = (
                    await self.file_processor.process(
                        values[cf.key], tenant_id
                    )
                )

        # Apply defaults for missing optional fields
        for cf in template.customization_fields:
            if cf.key not in processed_values:
                processed_values[cf.key] = (
                    cf.default_value or ""
                )

        # Resolve the system prompt
        system_prompt = template.base_system_prompt.format(
            **processed_values
        )

        return {
            "tenant_id": tenant_id,
            "template_id": template_id,
            "template_version": template.id,
            "name": f"{template.name} - {values.get('company_name', tenant_id)}",
            "system_prompt": system_prompt,
            "model": template.recommended_model,
            "tools": template.tools,
            "config": processed_values,
        }

    def _validate_fields(
        self, template: AgentTemplate, values: dict
    ):
        errors = []
        for cf in template.customization_fields:
            if cf.required and cf.key not in values:
                errors.append(
                    f"Missing required field: {cf.label}"
                )
            if (
                cf.validation_regex
                and cf.key in values
                and not re.match(
                    cf.validation_regex, str(values[cf.key])
                )
            ):
                errors.append(
                    f"Invalid format for {cf.label}"
                )
        if errors:
            raise ValueError(
                f"Validation errors: {'; '.join(errors)}"
            )

Template Gallery API

Users browse templates through a gallery API that supports filtering and previewing:

from fastapi import APIRouter, Query

router = APIRouter(prefix="/api/templates")


@router.get("/")
async def list_templates(
    category: str | None = Query(None),
    search: str | None = Query(None),
    template_store=Depends(get_template_store),
):
    templates = await template_store.list_all()

    if category:
        templates = [
            t for t in templates if t.category == category
        ]

    if search:
        search_lower = search.lower()
        templates = [
            t for t in templates
            if search_lower in t.name.lower()
            or search_lower in t.description.lower()
        ]

    return {
        "templates": [
            {
                "id": t.id,
                "name": t.name,
                "description": t.description,
                "category": t.category,
                "icon": t.icon,
                "estimated_setup_time": t.estimated_setup_time,
                "customization_fields_count": len(
                    t.customization_fields
                ),
            }
            for t in templates
        ]
    }


@router.get("/{template_id}")
async def get_template(
    template_id: str,
    template_store=Depends(get_template_store),
):
    template = await template_store.get(template_id)
    if not template:
        raise HTTPException(status_code=404)
    return template


@router.post("/{template_id}/deploy")
async def deploy_from_template(
    template_id: str,
    values: dict,
    engine=Depends(get_template_engine),
    deployer=Depends(get_deployer),
    tenant_id: str = Depends(get_current_tenant),
):
    config = await engine.instantiate(
        template_id, values, tenant_id
    )
    deployment = await deployer.deploy(config)
    return {
        "agent_id": deployment.agent_id,
        "status": "deployed",
        "endpoint": deployment.endpoint,
    }

FAQ

How many customization fields should a template have?

Keep it under ten. Research on form completion rates shows that each additional field reduces conversion. Focus on fields that meaningfully change agent behavior: company identity, tone, and knowledge base. Hide advanced options behind an "Advanced Settings" toggle.

How do you maintain templates as the underlying platform evolves?

Version templates independently from the platform. When the platform adds new tools or changes APIs, update templates to use the new capabilities and publish new template versions. Keep old versions functional for existing deployments but guide new users toward the latest version.

Should templates include sample data for testing?

Yes. Every template should include example conversations that demonstrate correct behavior. When a user deploys from a template, let them test with these examples before going live. This builds confidence and catches configuration mistakes before they reach real customers.

---

#AgentTemplates #NoCode #AgentDeployment #Customization #AgenticAI #LearnAI #AIEngineering