Agentic π Day

A Little Background...

No slides. No scripts. No fluff. That was the plan.

I posted on LinkedIn on March 10th around noon, announcing a live, unscripted session:

The only thing scripted? The start time. 3:14 PM. Because... π.

Then...

110+ people signed up. (and counting, as of 24 hours before the event)

Agenda

What We're Building

SupportBot: AI Customer Support Agent

Strands SDK Amazon Bedrock MCP AgentCore OpenTelemetry

What is Agentic AI?

AI systems that can autonomously perceive, reason, act, and learn

The Agentic Loop

flowchart TD
    A["User Prompt"] --> B["🧠 REASON\nLLM thinks about the task"]
    B --> C{"DECIDE"}
    C -->|"Done"| D["✅ RESPOND\nReturn final answer"]
    C -->|"Need more info"| E["🔧 ACT\nCall a tool"]
    E --> F["👁️ OBSERVE\nSee tool results"]
    F --> B
          

This Reason → Act → Observe loop is the foundation of all agents

Core Components of an Agent

Strands Agents SDK

Open-source, model-driven agent framework from AWS

from strands import Agent, tool

@tool
def lookup_order(order_id: str) -> dict:
    """Look up a customer order by ID."""
    return database.get_order(order_id)

agent = Agent(
    system_prompt="You are SupportBot...",
    tools=[lookup_order],
)

response = agent("What's the status of order ORD-10001?")

Used in production by Amazon Q Developer, AWS Glue, and more

Agent Architecture Patterns

Multi-Agent Patterns

flowchart TD
    T["🎯 Triage"] --> B["💰 Billing"]
    T --> Tech["🔧 Technical"]
    T --> R["📦 Returns"]
            

flowchart TD
    A["Agent A"] -->|handoff| B["Agent B"]
    B -->|handoff| C["Agent C"]
    C -->|handoff| A
            

flowchart TD
    A --> B & C --> D
            

Today: Agents-as-Tools, where a triage agent delegates to specialist agents

Model Context Protocol (MCP)

Open standard for agent ↔ tool communication

from fastmcp import FastMCP

mcp = FastMCP(name="Product Catalog")

@mcp.tool()
def get_product(sku: str) -> dict:
    """Get product details by SKU."""
    return products[sku]

Transport: stdio (local) | HTTP (remote) | SSE (streaming)

Hierarchical Context Management

flowchart LR
    subgraph L1["🟢 L1: Always Loaded"]
        A1["System Prompt"] ~~~ A2["Tool Defs"] ~~~ A3["Conversation"]
    end
    subgraph L2["🟡 L2: On-Demand"]
        B1["FAQ"] ~~~ B2["Memory"] ~~~ B3["Policies"]
    end
    subgraph L3["🔵 L3: External APIs"]
        C1["Catalog"] ~~~ C2["Orders"] ~~~ C3["Tickets"]
    end
    L1 --> L2 --> L3
          

Agent Evaluations

Agents are non-deterministic: same input, different (valid) outputs

Best practice: Automated evals (CI) + LLM-as-Judge (periodic) + Human review (calibration)

Observability with OpenTelemetry

gantt
    title Agent Request Trace (1.2s total)
    dateFormat X
    axisFormat %L ms
    section Model
    model_inference (150 tokens)    :0, 400
    model_inference (200 tokens)    :410, 800
    section Tools
    tool_call lookup_order          :400, 410
    section Response
    streaming response              :800, 1200
          

Strands emits OTEL-compliant spans → CloudWatch, Datadog, Jaeger

Amazon Bedrock AgentCore

Managed platform for deploying AI agents at scale

agentcore configure -e app.py
agentcore launch
agentcore invoke '{"prompt": "Help me with my order"}'

SupportBot Architecture

flowchart LR
    User["👤 User"] --> Triage["🎯 Triage Agent"]
    Triage --> Billing["💰 Billing"]
    Triage --> Technical["🔧 Technical"]
    Triage --> Returns["📦 Returns"]
    subgraph Tools["Shared Tools"]
        T1["Order Lookup"] ~~~ T2["KB Search"] ~~~ T3["Tickets"] ~~~ T4["MCP Catalog"]
    end
    Billing --> Tools
    Technical --> Tools
    Returns --> Tools
          

Let's Build! 🚀

Open the workshop docs for step-by-step instructions

Each module builds on the previous one, and by the end, you'll have a production-ready multi-agent system.

Custom Tools & MCP

Extending agents with tools and the Model Context Protocol

@tool
def lookup_order(order_id: str) -> dict:
    """Look up a customer order."""
    return ORDERS.get(order_id)

Tools turn agents from "answering" to "doing"

Memory & Context

Making agents remember and managing the context window

• Conversation memory: current session (built-in)
• Persistent memory: across sessions (custom store)
• Hierarchical context: L1/L2/L3 loading
• Skills.md pattern: modular, on-demand context

Multi-Agent Patterns

Triage agent routing to specialist agents

@tool
def route_to_billing(query: str) -> str:
    """Route to Billing Specialist."""
    response = billing_agent(query)
    return response.message.content[0]["text"]

triage_agent = Agent(
    tools=[route_to_billing, route_to_technical, route_to_returns]
)

Evals, Safety & Observability

Testing, protecting, and monitoring your agents

# Run evaluation suite
python module_05_evals/eval_suite.py --eval

# Chat with guardrails
python module_05_evals/eval_suite.py --chat

# Enable OpenTelemetry tracing
python module_05_evals/eval_suite.py --chat --otel

Deploy to AWS AgentCore

Production deployment on Amazon Bedrock AgentCore

# Configure deployment
agentcore configure -e module_06_deploy/app.py

# Launch on AgentCore Runtime
agentcore launch

# Invoke the deployed agent
agentcore invoke '{"prompt": "What is your return policy?"}'

What You Built Today

• ✅ Single agent with system prompt (Module 1)
• ✅ Custom tools + MCP server (Module 2)
• ✅ Persistent memory + context management (Module 3)
• ✅ Multi-agent triage system (Module 4)
• ✅ Evaluation suite + safety guardrails (Module 5)
• ✅ Deployed agent on AWS AgentCore (Module 6)

Next Steps

• 📚 Explore Strands Agents docs
• 🔬 Try more examples
• 🏗️ Build with AgentCore services
• 🤝 Join the community
• 📖 Read about agent evals best practices

Thank You! 🎉

Workshop materials available at the docs site