From 499e5daa43730c79cac30d218a133cb544ea4dc3 Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Fri, 5 Sep 2025 11:50:23 -0700
Subject: [PATCH 01/13] Add initial training docs

---
 .../developers/01-introduction-to-agents.mdx  |  554 ++++++++
 .../developers/02-anatomy-of-an-agent.mdx     |  981 ++++++++++++++
 .../Training/developers/03-agent-memory.mdx   | 1186 +++++++++++++++++
 content/Training/developers/index.mdx         |   55 +
 content/Training/index.mdx                    |   21 +
 content/meta.json                             |    1 +
 6 files changed, 2798 insertions(+)
 create mode 100644 content/Training/developers/01-introduction-to-agents.mdx
 create mode 100644 content/Training/developers/02-anatomy-of-an-agent.mdx
 create mode 100644 content/Training/developers/03-agent-memory.mdx
 create mode 100644 content/Training/developers/index.mdx
 create mode 100644 content/Training/index.mdx

diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
new file mode 100644
index 00000000..d017417c
--- /dev/null
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -0,0 +1,554 @@
+---
+title: Introduction to Agents
+description: Understanding AI agents and the $47B opportunity
+---
+
+# Module 1: Introduction to Agents
+
+Welcome to the age of AI agents - autonomous systems that are fundamentally transforming how we build and think about software.
+
+## The $47B Agent Opportunity
+
+The AI agents market is exploding - projected to grow from [$5.1B in 2024 to $47.1B by 2030](https://www.marketsandmarkets.com/Market-Reports/ai-agents-market-15761548.html) at a staggering 44.8% CAGR. According to [IBM's latest research](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality), many developers are already exploring or building AI agents. 
+
+But here's the problem: most developers are trying to build autonomous systems on infrastructure designed for websites, not agents.
+
+As [Goldman Sachs' infrastructure analysis](https://www.goldmansachs.com/insights/articles/a-generational-infrastructure-buildout-might-hinge-on-ai-agents) points out:
+
+> "We're trying to run autonomous systems on infrastructure built for click-and-response websites. It's like trying to run a Tesla on roads designed for horses."
+
+Traditional cloud platforms (AWS Lambda, Google Cloud Functions, Azure Functions) were optimized for:
+- **5ms response times** (agents need minutes or hours to think)
+- **Stateless execution** (agents need persistent memory)
+- **Edge distribution** (agents need GPU proximity)
+- **Request-response patterns** (agents need continuous reasoning loops)
+
+## What Exactly Is an AI Agent?
+
+<Callout type="info">
+For a comprehensive overview of agents and how they differ from traditional software, see our [What is an Agent?](/Guides/what-is-an-agent) guide.
+</Callout>
+
+An AI agent is not just another chatbot or API wrapper around an LLM. It's a fundamentally different type of software that combines:
+
+### The Agent Formula
+```
+Agent = LLM + Memory + Tools + Reasoning Loop
+```
+
+Let's break this down:
+
+1. **LLM (Large Language Model)**: The "brain" that understands intent and generates responses
+2. **Memory**: Both short-term (conversation context) and long-term (persistent knowledge)
+3. **Tools**: Capabilities to interact with external systems, APIs, and data sources
+4. **Reasoning Loop**: The ability to plan, execute, observe results, and adapt
+
+### Agents vs. Everything Else
+
+| Traditional API | Chatbot | AI Agent |
+|----------------|---------|----------|
+| Waits for commands | Responds to messages | Acts autonomously |
+| Returns exactly what you ask | Follows scripted patterns | Figures out how to achieve goals |
+| Stateless between calls | Maintains conversation context | Remembers everything, learns over time |
+| Deterministic output | Limited variation | Adapts based on context |
+| Single request-response | Turn-based conversation | Continuous reasoning and action |
+
+Think of it this way:
+- **APIs** are like vending machines - push button, get result
+- **Chatbots** are like scripted receptionists - they can talk, but only follow a script
+- **Agents** are like smart assistants - they understand goals and figure out how to achieve them
+
+## The Paradigm Shift: From Deterministic to Non-Deterministic
+
+<Callout type="info">
+For deeper insights on this shift, read our [Agent Engineering](/Guides/agent-engineering) guide that covers thinking like an agent builder.
+</Callout>
+
+Traditional software engineering is built on determinism - given the same input, you always get the same output. We write explicit logic for every scenario:
+
+```python
+# Traditional deterministic approach
+def process_customer_request(request_type, data):
+    if request_type == "refund":
+        if data["amount"] < 100:
+            return process_refund(data)
+        else:
+            return escalate_to_manager(data)
+    elif request_type == "complaint":
+        return create_ticket(data)
+    # ... hundreds more conditions
+```
+
+Agent engineering embraces non-determinism - the agent interprets intent and figures out the best approach:
+
+```python
+# Agent-based approach
+async def handle_customer_request(request, context):
+    # Agent interprets the request
+    intent = await analyze_intent(request)
+    
+    # Agent decides on approach
+    plan = await create_action_plan(intent, context.customer_history)
+    
+    # Agent executes with available tools
+    result = await execute_plan(plan, context.available_tools)
+    
+    # Agent learns from outcome
+    await update_knowledge(result, context.memory)
+    
+    return result
+```
+
+This shift requires a new mindset:
+- **Design for intent**, not implementation
+- **Embrace variability** as a feature, not a bug
+- **Think in capabilities**, not functions
+- **Trust but verify** - use guardrails and observability
+
+## Why Agents Need Agent-Native Infrastructure
+
+[Microsoft's analysis](https://blogs.microsoft.com/blog/2025/05/19/microsoft-build-2025-the-age-of-ai-agents-and-building-the-open-agentic-web/) confirms that "most organizations aren't agent-ready" because their infrastructure wasn't built for autonomous systems.
+
+### The Infrastructure Mismatch
+
+Traditional cloud platforms face fundamental limitations when running agents:
+
+| Traditional Cloud | What Agents Need | The Gap |
+|-------------------|------------------|---------|
+| 15-second timeouts | Long-running processes | Agents timeout mid-thought |
+| Stateless by default | Persistent memory | Agents forget everything |
+| Distributed to edge | GPU proximity | High latency to AI models |
+| Pay per request | Continuous operation | Costs explode unexpectedly |
+| Human-centric monitoring | Agent observability | Can't debug agent decisions |
+
+Major cloud providers are scrambling to adapt:
+- **AWS** launched Bedrock AgentCore (still in preview)
+- **Google** released their Agent Development Kit (ADK)
+- **Microsoft** is retrofitting Azure with agent capabilities
+
+But retrofitting existing infrastructure is like turning a highway into an airport - technically possible, but not optimal.
+
+## Enter Agentuity: The Agent-Native Cloud
+
+<Callout type="info">
+Learn more about the Agent-Native Cloud paradigm in our [Agent-Native Cloud](/Guides/agent-native-cloud) guide.
+</Callout>
+
+While others retrofit, Agentuity was built from day one specifically for agents. This isn't just marketing - it's a fundamental architectural difference.
+
+### Purpose-Built for Agents
+
+Agentuity provides what agents actually need:
+
+- **Long-running processes**: Agents can think for hours, not seconds
+- **Persistent memory**: Built-in [key-value](/Guides/key-value), [vector](/Guides/vector-db), and [object storage](/Guides/object-storage)
+- **Agent-to-agent communication**: Secure, encrypted [channels between agents](/Guides/agent-communication)
+- **Native observability**: Track agent decisions with [built-in tracing](/Guides/agent-tracing)
+- **Automatic scaling**: Based on agent workload, not request count
+- **Framework agnostic**: Run LangChain, CrewAI, or custom agents side by side
+
+### The Agentuity Difference
+
+Instead of asking "How do we make Lambda work for agents?", we asked "What would infrastructure look like if agents were the only thing that mattered?"
+
+The result is a platform where:
+- Agents are first-class citizens, not adapted workloads
+- Memory and state are built-in, not bolted on
+- Long-running is the default, not an exception
+- Agent communication is native, not a hack
+
+## Your First Agent: Hello, Autonomous World
+
+Enough theory - let's build something. We'll create an agent that doesn't just respond to "hello" but actually thinks about how to greet you.
+
+### Prerequisites
+
+<Callout type="info">
+For detailed setup instructions, see our [Getting Started Guide](/Introduction/getting-started) and [CLI Installation Guide](/CLI/installation).
+</Callout>
+
+Before we start, make sure you have:
+- Python 3.9+ or Node.js 18+
+- Basic command line knowledge
+- An Agentuity account (free tier is fine)
+
+### Quick Setup
+
+```bash
+# Install the Agentuity CLI (see full installation guide for other OS)
+brew tap agentuity/tap && brew install agentuity
+
+# Verify installation
+agentuity --version
+
+# Login to your account
+agentuity auth login
+```
+
+### Creating Your First Agent Project
+
+Let's create a simple agent that demonstrates the key concepts we've learned:
+
+```bash
+# Create a new agent project
+agentuity create hello-agent --template python-starter
+# or for TypeScript:
+# agentuity create hello-agent --template typescript-starter
+
+# Navigate to the project
+cd hello-agent
+
+# Install dependencies (Python)
+pip install -r requirements.txt
+# or for TypeScript:
+# npm install
+```
+
+### Understanding the Agent Structure
+
+Here's a simple "Hello Agent" that demonstrates the core concepts:
+
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    """A simple agent that demonstrates basic concepts."""
+    
+    # Get the request data
+    data = await request.data.json()
+    name = data.get("name", "World")
+    
+    # Log the request (built-in observability)
+    context.logger.info(f"Received greeting request for {name}")
+    
+    # Check if we've seen this user before (persistent memory)
+    visits_key = f"visits_{name}"
+    result = await context.kv.get("user-data", visits_key)
+    
+    if result.exists:
+        # Returning visitor
+        visit_count = await result.data.json()
+        visit_count["count"] += 1
+        greeting = f"Welcome back, {name}! This is visit #{visit_count['count']}"
+        
+        # Update the visit count
+        await context.kv.set("user-data", visits_key, visit_count)
+    else:
+        # First-time visitor
+        greeting = f"Hello, {name}! Welcome to Agentuity."
+        
+        # Store first visit
+        await context.kv.set("user-data", visits_key, {
+            "count": 1,
+            "first_seen": datetime.now().isoformat()
+        })
+    
+    # Return the response
+    return response.json({
+        "message": greeting,
+        "timestamp": datetime.now().isoformat(),
+        "agent_info": "Running on Agentuity's agent-native infrastructure"
+    })`} js={`import { AgentHandler } from '@agentuity/sdk';
+
+const handler: AgentHandler = async (request, response, context) => {
+  // Get the request data
+  const data = await request.data.json();
+  const name = data.name || 'World';
+  
+  // Log the request (built-in observability)
+  context.logger.info(\`Received greeting request for \${name}\`);
+  
+  // Check if we've seen this user before (persistent memory)
+  const visitsKey = \`visits_\${name}\`;
+  const result = await context.kv.get('user-data', visitsKey);
+  
+  let greeting: string;
+  
+  if (result.exists) {
+    // Returning visitor
+    const visitCount = await result.data.json();
+    visitCount.count++;
+    greeting = \`Welcome back, \${name}! This is visit #\${visitCount.count}\`;
+    
+    // Update the visit count
+    await context.kv.set('user-data', visitsKey, JSON.stringify(visitCount));
+  } else {
+    // First-time visitor
+    greeting = \`Hello, \${name}! Welcome to Agentuity.\`;
+    
+    // Store first visit
+    await context.kv.set('user-data', visitsKey, JSON.stringify({
+      count: 1,
+      first_seen: new Date().toISOString()
+    }));
+  }
+  
+  // Return the response
+  return response.json({
+    message: greeting,
+    timestamp: new Date().toISOString(),
+    agent_info: "Running on Agentuity's agent-native infrastructure"
+  });
+};
+
+export default handler;`} />
+
+This simple agent demonstrates key concepts:
+- **Memory**: Uses key-value storage to remember visitors
+- **Logging**: Built-in observability with context.logger
+- **State Management**: Tracks visit counts persistently
+- **Request/Response**: Handles JSON input and output
+
+### Testing Your Agent with DevMode
+
+<Callout type="info">
+DevMode is Agentuity's local development environment that provides instant feedback, complete observability, and a user-friendly web interface for testing agents.
+</Callout>
+
+Test your agent using Agentuity's DevMode:
+
+```bash
+# Start DevMode - your agent will be available with a web interface
+agentuity dev
+
+# DevMode will start and show:
+# 🚀 DevMode ready
+# 🌐 Local: http://localhost:3500
+# 🔗 Public: https://[unique-id].agentuity.dev (for external access)
+```
+
+Once DevMode is running:
+1. Open the provided URL in your browser
+2. Select your agent from the dropdown
+3. Use the pre-configured prompts or write your own test scenarios
+4. Click "Run" to execute tests instantly
+5. View real-time logs, costs, and performance metrics in the interface
+
+#### Making Testing Easier with the Welcome Function
+
+Add a `welcome()` function to your agent to create clickable test scenarios in DevMode:
+
+<CodeExample py={`def welcome():
+    """Configure test scenarios for DevMode."""
+    return {
+        "welcome": "Welcome to my Hello Agent! Try these examples:",
+        "prompts": [
+            {
+                "data": {"name": "Sarah"},
+                "contentType": "application/json"
+            },
+            {
+                "data": {"name": "DevMode Tester"},
+                "contentType": "application/json"
+            },
+            {
+                "data": {"name": ""},  # Test missing name
+                "contentType": "application/json"
+            }
+        ]
+    }
+
+async def run(request, response, context):
+    # Your existing agent code...`} js={`export const welcome = () => {
+    return {
+        welcome: "Welcome to my Hello Agent! Try these examples:",
+        prompts: [
+            {
+                data: JSON.stringify({ name: "Sarah" }),
+                contentType: "application/json"
+            },
+            {
+                data: JSON.stringify({ name: "DevMode Tester" }),
+                contentType: "application/json"
+            },
+            {
+                data: JSON.stringify({ name: "" }), // Test missing name
+                contentType: "application/json"
+            }
+        ]
+    };
+};
+
+const handler: AgentHandler = async (request, response, context) => {
+    // Your existing agent code...`} />
+
+These prompts appear as clickable buttons in the DevMode interface. Try calling the agent multiple times with the same name - it will remember you, and you can see the memory operations in the real-time logs!
+
+### Deploying to the Agentuity Cloud
+
+Now let's deploy this agent to production:
+
+```bash
+# Deploy to Agentuity's agent-native infrastructure
+agentuity deploy
+
+# Your agent is now running at:
+# https://your-project.agentuity.com/agents/hello
+```
+
+That's it! Your agent is now:
+- Running in long-running infrastructure (no timeout worries)
+- Storing memory persistently (survives restarts)
+- Fully observable (check logs and traces in the dashboard)
+- Auto-scaling based on load
+
+## Lab: Extending Your Agent
+
+Now that you have a working agent, let's enhance it with more capabilities. Use DevMode to test each enhancement as you build it.
+
+### Challenge 1: Add Time-Based Context
+Modify your agent to greet differently based on the time of day:
+
+<CodeExample py={`from datetime import datetime
+
+async def run(request, response, context):
+    data = await request.data.json()
+    name = data.get("name", "World")
+    
+    hour = datetime.now().hour
+    
+    if hour < 12:
+        time_greeting = "Good morning"
+    elif hour < 17:
+        time_greeting = "Good afternoon"
+    else:
+        time_greeting = "Good evening"
+    
+    return response.json({
+        "message": f"{time_greeting}, {name}!",
+        "local_time": datetime.now().isoformat()
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  const name = data.name || 'World';
+  
+  const hour = new Date().getHours();
+  let timeGreeting: string;
+  
+  if (hour < 12) {
+    timeGreeting = 'Good morning';
+  } else if (hour < 17) {
+    timeGreeting = 'Good afternoon';
+  } else {
+    timeGreeting = 'Good evening';
+  }
+  
+  return response.json({
+    message: \`\${timeGreeting}, \${name}!\`,
+    local_time: new Date().toISOString()
+  });
+};`} />
+
+### Challenge 2: Track User Preferences
+Store and retrieve user preferences using key-value storage:
+
+<CodeExample py={`async def run(request, response, context):
+    data = await request.data.json()
+    user_id = data.get("userId")
+    action = data.get("action")
+    
+    if action == "set_preference":
+        preference = data.get("preference")
+        await context.kv.set("preferences", user_id, preference)
+        return response.json({"message": "Preference saved"})
+    
+    elif action == "get_preference":
+        result = await context.kv.get("preferences", user_id)
+        if result.exists:
+            pref = await result.data.json()
+            return response.json({"preference": pref})
+        return response.json({"message": "No preference found"})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  const userId = data.userId;
+  const action = data.action;
+  
+  if (action === 'set_preference') {
+    const preference = data.preference;
+    await context.kv.set('preferences', userId, JSON.stringify(preference));
+    return response.json({ message: 'Preference saved' });
+  
+  } else if (action === 'get_preference') {
+    const result = await context.kv.get('preferences', userId);
+    if (result.exists) {
+      const pref = await result.data.json();
+      return response.json({ preference: pref });
+    }
+    return response.json({ message: 'No preference found' });
+  }
+};`} />
+
+### Challenge 3: Add Logging and Error Handling
+Implement proper error handling and logging:
+
+<CodeExample py={`async def run(request, response, context):
+    try:
+        data = await request.data.json()
+        name = data.get("name")
+        
+        if not name:
+            context.logger.warn("No name provided in request")
+            return response.json({"error": "Name is required"})
+        
+        context.logger.info(f"Processing request for {name}")
+        
+        # Your agent logic here
+        return response.json({"message": f"Hello, {name}!"})
+        
+    except Exception as e:
+        context.logger.error(f"Error processing request: {str(e)}")
+        return response.json({"error": "Internal server error"})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  try {
+    const data = await request.data.json();
+    const name = data.name;
+    
+    if (!name) {
+      context.logger.warn('No name provided in request');
+      return response.json({ error: 'Name is required' });
+    }
+    
+    context.logger.info(\`Processing request for \${name}\`);
+    
+    // Your agent logic here
+    return response.json({ message: \`Hello, \${name}!\` });
+    
+  } catch (error) {
+    context.logger.error(\`Error processing request: \${error}\`);
+    return response.json({ error: 'Internal server error' });
+  }
+};`} />
+
+### Testing Your Enhancements
+
+After implementing each challenge:
+1. Update your `welcome()` function with relevant test scenarios
+2. Run `agentuity dev` to start DevMode
+3. Use the DevMode interface to test your changes
+4. Monitor the logs to verify your agent behaves correctly
+5. Check the Sessions tab to track performance and costs
+
+<Callout type="info">
+For more examples, check our [Templates](/Introduction/templates) and [Examples](/Examples) sections.
+</Callout>
+
+## Key Takeaways
+
+- **Agents are different**: They're autonomous systems, not just API wrappers around LLMs
+- **The market is massive**: $47B by 2030, with many developers already building agents
+- **Infrastructure matters**: Traditional cloud wasn't built for agents' unique needs
+- **Non-determinism is a feature**: Agents adapt and reason, they don't just execute
+- **Agentuity is agent-native**: Purpose-built infrastructure for agents, not retrofitted
+
+## What's Next?
+
+You've just built and deployed your first agent on infrastructure designed specifically for agents. In the next module, we'll dive deeper into the anatomy of an agent - understanding planning, reasoning loops, tool invocation, and how agents really work under the hood.
+
+But first, take a moment to experiment with your agent. Try:
+- Calling it with different names and at different times
+- Checking the logs in the Agentuity dashboard
+- Modifying the personality and responses
+- Adding more sophisticated memory patterns
+
+Remember: aside from just learning a new framework, you're learning a fundamentally new way to build software. Welcome to the age of agents!
+
+---
+
+**Ready for Module 2?** [The Anatomy of an Agent](./02-anatomy-of-an-agent)
\ No newline at end of file
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
new file mode 100644
index 00000000..0df46db8
--- /dev/null
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -0,0 +1,981 @@
+---
+title: The Anatomy of an Agent
+description: Understanding how agents work - planning, reasoning, tools, and memory
+---
+
+# Module 2: The Anatomy of an Agent
+
+Now that you've built your first agent, let's dive deeper to understand what makes agents tick. We'll explore the core components that transform a simple script into an autonomous, intelligent system.
+
+## The Agent Lifecycle
+
+Every agent interaction follows a predictable lifecycle, from receiving a trigger to returning a response. Understanding this flow is crucial for building effective agents.
+
+```mermaid
+graph TD
+    A[Trigger Event] --> B[Request Handler]
+    B --> C[Context Initialization]
+    C --> D[Planning Phase]
+    D --> E[Reasoning Loop]
+    E --> F[Tool Invocation]
+    F --> G[Memory Update]
+    G --> H[Response Generation]
+    H --> I[Return Response]
+    E --> E[Continue Loop]
+```
+
+Let's explore each phase:
+
+### 1. Trigger Events
+
+Agents spring into action when triggered. Agentuity supports multiple trigger types:
+
+| Trigger Type | Description | Use Case |
+|-------------|-------------|----------|
+| **webhook** | HTTP endpoint call | REST APIs, external integrations |
+| **cron** | Scheduled execution | Batch processing, periodic tasks |
+| **manual** | Console/CLI invocation | Testing, one-off tasks |
+| **agent** | Called by another agent | Multi-agent workflows |
+| **sms** | SMS message received | Text-based interactions |
+| **email** | Email received | Email automation |
+| **queue** | Message queue event | Async processing |
+
+Each trigger provides different metadata and context:
+
+<CodeExample py={`async def run(request, response, context):
+    # Identify the trigger type
+    trigger = request.trigger
+    
+    if trigger == "webhook":
+        # Handle HTTP request
+        data = await request.data.json()
+        context.logger.info(f"Webhook triggered with data: {data}")
+    
+    elif trigger == "cron":
+        # Handle scheduled execution
+        context.logger.info(f"Cron job running at {datetime.now()}")
+        # No input data for cron triggers
+    
+    elif trigger == "agent":
+        # Handle agent-to-agent call
+        calling_agent = request.metadata.get("source_agent")
+        context.logger.info(f"Called by agent: {calling_agent}")
+    
+    return response.json({
+        "trigger_type": trigger,
+        "processed_at": datetime.now().isoformat()
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Identify the trigger type
+  const trigger = request.trigger;
+  
+  if (trigger === 'webhook') {
+    // Handle HTTP request
+    const data = await request.data.json();
+    context.logger.info(\`Webhook triggered with data: \${JSON.stringify(data)}\`);
+  
+  } else if (trigger === 'cron') {
+    // Handle scheduled execution
+    context.logger.info(\`Cron job running at \${new Date().toISOString()}\`);
+    // No input data for cron triggers
+  
+  } else if (trigger === 'agent') {
+    // Handle agent-to-agent call
+    const callingAgent = request.metadata.get('source_agent');
+    context.logger.info(\`Called by agent: \${callingAgent}\`);
+  }
+  
+  return response.json({
+    trigger_type: trigger,
+    processed_at: new Date().toISOString()
+  });
+};`} />
+
+### 2. Request and Response Handling
+
+Every agent receives a request and must return a response. The request contains the trigger data and metadata, while the response can be in various formats:
+
+<CodeExample py={`async def run(request, response, context):
+    # Access request data in different formats
+    
+    # JSON data (most common)
+    json_data = await request.data.json()
+    
+    # Plain text
+    text_data = await request.data.text()
+    
+    # Binary data
+    binary_data = await request.data.binary()
+    
+    # Base64 encoded
+    base64_data = await request.data.base64()
+    
+    # Response options
+    
+    # JSON response (most common)
+    return response.json({"result": "success"})
+    
+    # Text response
+    # return response.text("Hello, World!")
+    
+    # HTML response
+    # return response.html("<h1>Hello</h1>")
+    
+    # Binary response (for files)
+    # return response.binary(file_bytes)
+    
+    # Redirect to another agent
+    # return response.handoff({"name": "other-agent"}, data, metadata={})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Access request data in different formats
+  
+  // JSON data (most common)
+  const jsonData = await request.data.json();
+  
+  // Plain text
+  const textData = await request.data.text();
+  
+  // Binary data
+  const binaryData = await request.data.binary();
+  
+  // Base64 encoded
+  const base64Data = await request.data.base64();
+  
+  // Response options
+  
+  // JSON response (most common)
+  return response.json({ result: 'success' });
+  
+  // Text response
+  // return response.text('Hello, World!');
+  
+  // HTML response
+  // return response.html('<h1>Hello</h1>');
+  
+  // Binary response (for files)
+  // return response.binary(fileBytes);
+  
+  // Redirect to another agent
+  // return response.handoff({ name: 'other-agent' }, { data: jsonData, contentType: 'application/json' });
+};`} />
+
+### 3. The Agent Context
+
+The context object is your agent's gateway to Agentuity's services. It provides access to storage, logging, tracing, and more:
+
+<CodeExample py={`async def run(request, response, context):
+    # Logging at different levels
+    context.logger.debug("Debug information")
+    context.logger.info("General information")
+    context.logger.warn("Warning message")
+    context.logger.error("Error occurred")
+    
+    # Access metadata
+    agent_id = context.agent.id
+    agent_name = context.agent.name
+    project_id = context.projectId
+    run_id = context.runId
+    
+    # Key-Value storage
+    await context.kv.set("cache", "key", {"data": "value"})
+    result = await context.kv.get("cache", "key")
+    
+    # Vector storage for semantic search
+    await context.vector.upsert("docs", {
+        "key": "doc1",
+        "document": "AI agents are autonomous systems",
+        "metadata": {"category": "intro"}
+    })
+    
+    # Object storage for files
+    await context.objectstore.put("files", "report.pdf", pdf_bytes)
+    
+    return response.json({
+        "agent": agent_name,
+        "run": run_id
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Logging at different levels
+  context.logger.debug('Debug information');
+  context.logger.info('General information');
+  context.logger.warn('Warning message');
+  context.logger.error('Error occurred');
+  
+  // Access metadata
+  const agentId = context.agent.id;
+  const agentName = context.agent.name;
+  const projectId = context.projectId;
+  const runId = context.runId;
+  
+  // Key-Value storage
+  await context.kv.set('cache', 'key', JSON.stringify({ data: 'value' }));
+  const result = await context.kv.get('cache', 'key');
+  
+  // Vector storage for semantic search
+  await context.vector.upsert('docs', {
+    key: 'doc1',
+    document: 'AI agents are autonomous systems',
+    metadata: { category: 'intro' }
+  });
+  
+  // Object storage for files
+  await context.objectstore.put('files', 'report.pdf', pdfBytes);
+  
+  return response.json({
+    agent: agentName,
+    run: runId
+  });
+};`} />
+
+## Planning and Reasoning: The Agent's Brain
+
+What separates agents from simple scripts is their ability to plan and reason. While Agentuity provides the infrastructure, you implement the intelligence.
+
+### The Planning Phase
+
+Planning involves breaking down a complex request into manageable steps:
+
+<CodeExample py={`async def create_plan(request_data, context):
+    """Create an execution plan based on the request."""
+    
+    # Analyze what the user wants
+    intent = analyze_intent(request_data)
+    
+    # Break down into steps
+    steps = []
+    
+    if intent == "research":
+        steps.append({"action": "search", "params": request_data["query"]})
+        steps.append({"action": "summarize", "params": "search_results"})
+        steps.append({"action": "format", "params": "summary"})
+    
+    elif intent == "process_data":
+        steps.append({"action": "validate", "params": request_data["data"]})
+        steps.append({"action": "transform", "params": "validated_data"})
+        steps.append({"action": "store", "params": "transformed_data"})
+    
+    context.logger.info(f"Created plan with {len(steps)} steps")
+    return steps
+
+async def run(request, response, context):
+    data = await request.data.json()
+    
+    # Create a plan
+    plan = await create_plan(data, context)
+    
+    # Execute the plan
+    results = []
+    for step in plan:
+        context.logger.info(f"Executing: {step['action']}")
+        result = await execute_step(step, context)
+        results.append(result)
+    
+    return response.json({"plan": plan, "results": results})`} js={`async function createPlan(requestData: any, context: any) {
+  // Analyze what the user wants
+  const intent = analyzeIntent(requestData);
+  
+  // Break down into steps
+  const steps = [];
+  
+  if (intent === 'research') {
+    steps.push({ action: 'search', params: requestData.query });
+    steps.push({ action: 'summarize', params: 'search_results' });
+    steps.push({ action: 'format', params: 'summary' });
+  
+  } else if (intent === 'process_data') {
+    steps.push({ action: 'validate', params: requestData.data });
+    steps.push({ action: 'transform', params: 'validated_data' });
+    steps.push({ action: 'store', params: 'transformed_data' });
+  }
+  
+  context.logger.info(\`Created plan with \${steps.length} steps\`);
+  return steps;
+}
+
+const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  
+  // Create a plan
+  const plan = await createPlan(data, context);
+  
+  // Execute the plan
+  const results = [];
+  for (const step of plan) {
+    context.logger.info(\`Executing: \${step.action}\`);
+    const result = await executeStep(step, context);
+    results.push(result);
+  }
+  
+  return response.json({ plan, results });
+};`} />
+
+### The Reasoning Loop
+
+The reasoning loop is where agents adapt based on results:
+
+<CodeExample py={`async def reasoning_loop(goal, context, max_iterations=5):
+    """Execute a reasoning loop until the goal is achieved."""
+    
+    iteration = 0
+    achieved = False
+    history = []
+    
+    while iteration < max_iterations and not achieved:
+        context.logger.info(f"Reasoning iteration {iteration + 1}")
+        
+        # Plan the next action
+        action = await plan_next_action(goal, history, context)
+        
+        # Execute the action
+        result = await execute_action(action, context)
+        
+        # Observe the result
+        observation = await observe_result(result, goal, context)
+        
+        # Store in history
+        history.append({
+            "action": action,
+            "result": result,
+            "observation": observation
+        })
+        
+        # Check if goal is achieved
+        achieved = observation.get("goal_achieved", False)
+        
+        # Adapt if needed
+        if not achieved and observation.get("needs_adjustment"):
+            goal = await adjust_goal(goal, observation, context)
+        
+        iteration += 1
+    
+    return {
+        "achieved": achieved,
+        "iterations": iteration,
+        "history": history
+    }`} js={`async function reasoningLoop(goal: any, context: any, maxIterations = 5) {
+  let iteration = 0;
+  let achieved = false;
+  const history = [];
+  
+  while (iteration < maxIterations && !achieved) {
+    context.logger.info(\`Reasoning iteration \${iteration + 1}\`);
+    
+    // Plan the next action
+    const action = await planNextAction(goal, history, context);
+    
+    // Execute the action
+    const result = await executeAction(action, context);
+    
+    // Observe the result
+    const observation = await observeResult(result, goal, context);
+    
+    // Store in history
+    history.push({
+      action,
+      result,
+      observation
+    });
+    
+    // Check if goal is achieved
+    achieved = observation.goal_achieved || false;
+    
+    // Adapt if needed
+    if (!achieved && observation.needs_adjustment) {
+      goal = await adjustGoal(goal, observation, context);
+    }
+    
+    iteration++;
+  }
+  
+  return {
+    achieved,
+    iterations: iteration,
+    history
+  };
+}`} />
+
+## Tool Invocation: Extending Agent Capabilities
+
+Agents become powerful when they can use tools. Tools can be APIs, databases, or even other agents:
+
+<CodeExample py={`import httpx
+from typing import Dict, Any
+
+class AgentTools:
+    """Collection of tools available to the agent."""
+    
+    @staticmethod
+    async def web_search(query: str) -> Dict[str, Any]:
+        """Search the web for information."""
+        async with httpx.AsyncClient() as client:
+            response = await client.get(
+                "https://api.search.com/v1/search",
+                params={"q": query}
+            )
+            return response.json()
+    
+    @staticmethod
+    async def calculate(expression: str) -> float:
+        """Perform mathematical calculations."""
+        # Safe evaluation of math expressions
+        import ast
+        import operator as op
+        
+        ops = {
+            ast.Add: op.add,
+            ast.Sub: op.sub,
+            ast.Mult: op.mul,
+            ast.Div: op.truediv,
+        }
+        
+        def eval_expr(expr):
+            return eval(compile(ast.parse(expr, mode='eval'), '', 'eval'))
+        
+        return eval_expr(expression)
+    
+    @staticmethod
+    async def send_email(to: str, subject: str, body: str) -> bool:
+        """Send an email."""
+        # Email sending logic
+        return True
+
+async def run(request, response, context):
+    data = await request.data.json()
+    action = data.get("action")
+    
+    tools = AgentTools()
+    
+    if action == "research":
+        # Use web search tool
+        results = await tools.web_search(data["query"])
+        return response.json({"search_results": results})
+    
+    elif action == "calculate":
+        # Use calculator tool
+        result = await tools.calculate(data["expression"])
+        return response.json({"result": result})
+    
+    elif action == "notify":
+        # Use email tool
+        sent = await tools.send_email(
+            data["email"],
+            data["subject"],
+            data["message"]
+        )
+        return response.json({"sent": sent})`} js={`import axios from 'axios';
+
+class AgentTools {
+  static async webSearch(query: string) {
+    const response = await axios.get('https://api.search.com/v1/search', {
+      params: { q: query }
+    });
+    return response.data;
+  }
+  
+  static async calculate(expression: string): Promise<number> {
+    // Use a safe math evaluation library
+    // This is a simplified example
+    return eval(expression); // In production, use a safe math parser
+  }
+  
+  static async sendEmail(to: string, subject: string, body: string): Promise<boolean> {
+    // Email sending logic
+    return true;
+  }
+}
+
+const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  const action = data.action;
+  
+  if (action === 'research') {
+    // Use web search tool
+    const results = await AgentTools.webSearch(data.query);
+    return response.json({ search_results: results });
+  
+  } else if (action === 'calculate') {
+    // Use calculator tool
+    const result = await AgentTools.calculate(data.expression);
+    return response.json({ result });
+  
+  } else if (action === 'notify') {
+    // Use email tool
+    const sent = await AgentTools.sendEmail(
+      data.email,
+      data.subject,
+      data.message
+    );
+    return response.json({ sent });
+  }
+};`} />
+
+## Memory Updates: Learning and Persistence
+
+Memory is what allows agents to learn and improve over time. Agentuity provides three types of memory storage:
+
+### Short-term Memory (Key-Value)
+For session data, cache, and temporary state:
+
+<CodeExample py={`async def run(request, response, context):
+    session_id = request.metadata.get("session_id")
+    
+    # Store conversation context
+    await context.kv.set(
+        "sessions",
+        session_id,
+        {
+            "messages": [],
+            "context": {},
+            "timestamp": datetime.now().isoformat()
+        },
+        {"ttl": 3600}  # Expires in 1 hour
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const sessionId = request.metadata.get('session_id');
+  
+  // Store conversation context
+  await context.kv.set(
+    'sessions',
+    sessionId,
+    JSON.stringify({
+      messages: [],
+      context: {},
+      timestamp: new Date().toISOString()
+    }),
+    { ttl: 3600 } // Expires in 1 hour
+  );
+};`} />
+
+### Long-term Memory (Vector Storage)
+For knowledge base and semantic search:
+
+<CodeExample py={`async def run(request, response, context):
+    # Store learned information
+    await context.vector.upsert("knowledge", {
+        "key": "fact_001",
+        "document": "Users prefer concise responses",
+        "metadata": {
+            "learned_from": "user_feedback",
+            "confidence": 0.85
+        }
+    })
+    
+    # Retrieve relevant knowledge
+    results = await context.vector.search(
+        "knowledge",
+        "How should I format responses?",
+        limit=5,
+        similarity=0.7
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Store learned information
+  await context.vector.upsert('knowledge', {
+    key: 'fact_001',
+    document: 'Users prefer concise responses',
+    metadata: {
+      learned_from: 'user_feedback',
+      confidence: 0.85
+    }
+  });
+  
+  // Retrieve relevant knowledge
+  const results = await context.vector.search('knowledge', {
+    query: 'How should I format responses?',
+    limit: 5
+  });
+};`} />
+
+## Framework Awareness: Choosing the Right Tool
+
+<Callout type="info">
+Agentuity is framework-agnostic. You can use any AI framework or build custom agents from scratch.
+</Callout>
+
+### Popular Agent Frameworks
+
+Different frameworks excel at different tasks. Here's when to use each:
+
+| Framework | Best For | Agentuity Integration |
+|-----------|----------|----------------------|
+| **LangChain** | Complex chains, RAG applications | Native SDK support |
+| **CrewAI** | Multi-agent teams, role-based systems | Deploy via container |
+| **AutoGen** | Research, experimentation | Direct deployment |
+| **Custom** | Specific requirements, full control | Full platform features |
+
+### Framework Comparison Example
+
+Here's the same agent built with different approaches:
+
+<CodeExample py={`# Vanilla Python Agent
+async def run(request, response, context):
+    data = await request.data.json()
+    # Direct implementation
+    result = process_data(data)
+    return response.json(result)
+
+# LangChain Agent
+from langchain.agents import initialize_agent
+from langchain.llms import OpenAI
+
+async def run(request, response, context):
+    llm = OpenAI()
+    agent = initialize_agent(tools, llm, agent="zero-shot")
+    result = agent.run(await request.data.text())
+    return response.text(result)
+
+# CrewAI Agent
+from crewai import Agent, Task, Crew
+
+async def run(request, response, context):
+    researcher = Agent(role="Researcher", goal="Find information")
+    writer = Agent(role="Writer", goal="Create content")
+    
+    crew = Crew(agents=[researcher, writer])
+    result = crew.kickoff(await request.data.json())
+    return response.json(result)`} js={`// Vanilla TypeScript Agent
+const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  // Direct implementation
+  const result = processData(data);
+  return response.json(result);
+};
+
+// LangChain Agent
+import { initializeAgentExecutor } from 'langchain/agents';
+import { OpenAI } from 'langchain/llms/openai';
+
+const handler: AgentHandler = async (request, response, context) => {
+  const llm = new OpenAI();
+  const agent = await initializeAgentExecutor(tools, llm, 'zero-shot');
+  const result = await agent.call({ input: await request.data.text() });
+  return response.text(result.output);
+};
+
+// Custom Multi-Agent System
+const handler: AgentHandler = async (request, response, context) => {
+  const researcher = new Agent('Researcher', 'Find information');
+  const writer = new Agent('Writer', 'Create content');
+  
+  const researchResult = await researcher.execute(data);
+  const writeResult = await writer.execute(researchResult);
+  return response.json(writeResult);
+};`} />
+
+### When to Use Which Framework
+
+- **Use LangChain** when you need:
+  - Complex reasoning chains
+  - RAG (Retrieval Augmented Generation)
+  - Extensive tool integration
+  - Well-documented patterns
+
+- **Use CrewAI** when you need:
+  - Multiple specialized agents
+  - Role-based collaboration
+  - Hierarchical task delegation
+
+- **Use Custom** when you need:
+  - Maximum performance
+  - Specific business logic
+  - Full control over behavior
+  - Minimal dependencies
+
+## Lab: Building a Multi-Trigger Agent
+
+Let's put it all together by building an agent that responds to multiple triggers. We'll test it using DevMode's web interface:
+
+<CodeExample py={`from datetime import datetime
+import json
+
+async def run(request, response, context):
+    """An agent that handles multiple trigger types."""
+    
+    trigger = request.trigger
+    context.logger.info(f"Agent triggered via: {trigger}")
+    
+    if trigger == "webhook":
+        # Handle API requests
+        data = await request.data.json()
+        
+        # Process based on action
+        action = data.get("action")
+        if action == "store":
+            # Store data in KV
+            await context.kv.set("data", data["key"], data["value"])
+            return response.json({"status": "stored", "key": data["key"]})
+        
+        elif action == "retrieve":
+            # Get from KV
+            result = await context.kv.get("data", data["key"])
+            if result.exists:
+                value = await result.data.json()
+                return response.json({"found": True, "value": value})
+    elif trigger == "cron":
+        # Scheduled cleanup task
+        context.logger.info("Running scheduled cleanup")
+        
+        # Clean old sessions (in production, iterate through keys)
+        await context.kv.delete("sessions", "old_session")
+        
+        # Generate report
+        report = {
+            "task": "cleanup",
+            "timestamp": datetime.now().isoformat(),
+            "status": "completed"
+        }
+        
+        # Store report
+        await context.kv.set("reports", "latest_cleanup", report)
+        return response.json(report)
+    
+    elif trigger == "agent":
+        # Handle agent-to-agent communication
+        data = await request.data.json()
+        
+        # Process request from another agent
+        result = f"Processed request from agent: {data}"
+        
+        return response.json({"result": result})
+    
+    else:
+        return response.json({
+            "error": f"Unknown trigger type: {trigger}"
+        })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const trigger = request.trigger;
+  context.logger.info(\`Agent triggered via: \${trigger}\`);
+  
+  if (trigger === 'webhook') {
+    // Handle API requests
+    const data = await request.data.json();
+    
+    // Process based on action
+    const action = data.action;
+    if (action === 'store') {
+      // Store data in KV
+      await context.kv.set('data', data.key, JSON.stringify(data.value));
+      return response.json({ status: 'stored', key: data.key });
+    
+    } else if (action === 'retrieve') {
+      // Get from KV
+      const result = await context.kv.get('data', data.key);
+      if (result.exists) {
+        const value = await result.data.json();
+        return response.json({ found: true, value });
+      }
+      return response.json({ found: false });
+    }
+    
+    // Handle DevMode simulation of cron for testing
+    if (data._simulate_cron) {
+      context.logger.info('Simulating cron trigger in DevMode');
+      // Run the same cleanup logic
+      const report = {
+        task: 'cleanup (simulated)',
+        timestamp: new Date().toISOString(),
+        status: 'completed'
+      };
+      return response.json(report);
+    }
+  
+  } else if (trigger === 'cron') {
+    // Scheduled cleanup task
+    context.logger.info('Running scheduled cleanup');
+    
+    // Clean old sessions
+    await context.kv.delete('sessions', 'old_session');
+    
+    // Generate report
+    const report = {
+      task: 'cleanup',
+      timestamp: new Date().toISOString(),
+      status: 'completed'
+    };
+    
+    // Store report
+    await context.kv.set('reports', 'latest_cleanup', JSON.stringify(report));
+    return response.json(report);
+  
+  } else if (trigger === 'agent') {
+    // Handle agent-to-agent communication
+    const data = await request.data.json();
+    
+    // Process request from another agent
+    const result = \`Processed request from agent: \${JSON.stringify(data)}\`;
+    
+    return response.json({ result });
+  
+  } else {
+    return response.json({
+      error: \`Unknown trigger type: \${trigger}\`
+    });
+  }
+};
+
+export default handler;`} />
+
+### Testing Your Multi-Trigger Agent
+
+<Callout type="info">
+DevMode makes it easy to test webhook triggers locally. For cron triggers, you can simulate them in DevMode or configure real schedules through the Agentuity Console.
+</Callout>
+
+#### Setting Up Test Scenarios
+
+First, enhance your agent with a `welcome()` function to create test scenarios:
+
+<CodeExample py={`def welcome():
+    """Configure test scenarios for different trigger types."""
+    return {
+        "welcome": "Multi-Trigger Agent Test Suite",
+        "prompts": [
+            # Webhook trigger tests
+            {
+                "data": {"action": "store", "key": "test", "value": "data"},
+                "contentType": "application/json"
+            },
+            {
+                "data": {"action": "retrieve", "key": "test"},
+                "contentType": "application/json"
+            },
+            # Simulate what a cron trigger would do
+            {
+                "data": {"_simulate_cron": True},
+                "contentType": "application/json"
+            },
+            # Simulate agent-to-agent communication
+            {
+                "data": {"message": "Hello from another agent", "source_agent": "agent_123"},
+                "contentType": "application/json"
+            }
+        ]
+    }`} js={`export const welcome = () => {
+    return {
+        welcome: "Multi-Trigger Agent Test Suite",
+        prompts: [
+            // Webhook trigger tests
+            {
+                data: JSON.stringify({ action: "store", key: "test", value: "data" }),
+                contentType: "application/json"
+            },
+            {
+                data: JSON.stringify({ action: "retrieve", key: "test" }),
+                contentType: "application/json"
+            },
+            // Simulate what a cron trigger would do
+            {
+                data: JSON.stringify({ _simulate_cron: true }),
+                contentType: "application/json"
+            },
+            // Simulate agent-to-agent communication
+            {
+                data: JSON.stringify({ message: "Hello from another agent", source_agent: "agent_123" }),
+                contentType: "application/json"
+            }
+        ]
+    };
+};`} />
+
+#### Testing in DevMode
+
+1. **Start DevMode:**
+```bash
+agentuity dev
+```
+
+2. **Open the DevMode interface** and click the pre-configured prompts to test different scenarios
+
+3. **Monitor the execution** in the Logs and Sessions tabs
+
+#### Configuring Cron Triggers for Production
+
+For actual scheduled execution, configure cron triggers through the [Agentuity Console](https://app.agentuity.com):
+
+1. Navigate to your agent in the Console
+2. Click on **"Add Trigger"** and select **"Cron Job"**
+3. Configure the schedule using cron syntax (e.g., `0 * * * *` for hourly)
+4. Set the Content Type and optional Payload
+5. Enable the trigger and save
+
+<Callout type="info">
+Learn more about configuring triggers in the [Agent Configuration Guide](/Cloud/agents).
+</Callout>
+
+## Performance Considerations
+
+Building efficient agents requires thinking about performance from the start:
+
+### Cost Optimization
+
+Effective cost optimization strategies include:
+
+- **Cache frequently used data** in KV storage to reduce repeated processing
+- **Batch operations** when possible to minimize API calls
+- **Use appropriate LLM models** - not everything needs GPT-4
+- **Implement early exits** in reasoning loops to avoid unnecessary iterations
+
+### Latency vs. Capability Trade-offs
+
+| Approach | Latency | Capability | Use Case |
+|----------|---------|------------|----------|
+| Simple rules | &lt;100ms | Low | Basic routing |
+| Small LLM | 200-500ms | Medium | Classification |
+| Large LLM | 1-3s | High | Complex reasoning |
+| Multi-agent | 3-10s | Very High | Research tasks |
+
+<CodeExample py={`async def run(request, response, context):
+    data = await request.data.json()
+    complexity = assess_complexity(data)
+    
+    if complexity == "simple":
+        # Use rules-based approach
+        result = apply_rules(data)
+        return response.json(result)
+    
+    elif complexity == "medium":
+        # Use small, fast model
+        result = await small_model_process(data)
+        return response.json(result)
+    
+    else:
+        # Use full agent capabilities
+        result = await full_agent_process(data, context)
+        return response.json(result)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  const complexity = assessComplexity(data);
+  
+  if (complexity === 'simple') {
+    // Use rules-based approach
+    const result = applyRules(data);
+    return response.json(result);
+  
+  } else if (complexity === 'medium') {
+    // Use small, fast model
+    const result = await smallModelProcess(data);
+    return response.json(result);
+  
+  } else {
+    // Use full agent capabilities
+    const result = await fullAgentProcess(data, context);
+    return response.json(result);
+  }
+};`} />
+
+## Key Takeaways
+
+- **Agents follow a lifecycle**: Trigger → Plan → Reason → Execute → Remember → Respond
+- **Multiple trigger types**: Choose the right trigger for your use case
+- **Context is powerful**: It provides access to all Agentuity services
+- **Frameworks are tools**: Pick the right one for your needs, or go custom
+- **Memory enables learning**: Use KV for short-term, Vector for long-term
+- **Performance matters**: Balance capability with cost and latency
+
+## What's Next?
+
+You now understand the core components that make agents work. In the next module, we'll dive deep into memory systems - how agents remember, learn, and improve over time.
+
+But first, experiment with the multi-trigger agent:
+- Add a new trigger type (email or SMS)
+- Implement a simple reasoning loop
+- Try different response formats
+- Connect two agents together
+
+Remember: The anatomy you've learned here is the foundation. The intelligence you add on top is what makes your agents unique.
+
+---
+
+**Ready for Module 3?** [Agent Memory](./03-agent-memory)
\ No newline at end of file
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
new file mode 100644
index 00000000..246ec9e3
--- /dev/null
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -0,0 +1,1186 @@
+---
+title: Agent Memory
+description: How agents remember, learn, and build context over time
+---
+
+# Module 3: Agent Memory
+
+Without memory, an agent is just a stateless function. With memory, it becomes a system that learns, adapts, and builds relationships over time.
+
+## The Memory Challenge
+
+According to [IBM's research on AI agent memory](https://www.ibm.com/think/topics/ai-agent-memory), the biggest limitation of current LLMs is their inability to retain information between sessions. Every conversation starts from scratch, every user must re-explain their context, and every task begins without learning from the past.
+
+As highlighted in recent [memory management research](https://medium.com/@nomannayeem/building-ai-agents-that-actually-remember-a-developers-guide-to-memory-management-in-2025-062fd0be80a1):
+
+> "The difference between a chatbot and an agent is memory. A chatbot responds to the current message. An agent remembers your entire relationship."
+
+This creates fundamental challenges:
+- **Context Loss**: Users repeatedly explain their situation
+- **No Learning**: Agents can't improve from past interactions
+- **Limited Personalization**: Every user gets the same generic experience
+- **Inefficient Operations**: Recomputing information that should be cached
+
+## Understanding Agent Memory Types
+
+<Callout type="info">
+For implementation details on Agentuity's storage systems, see our guides on [Key-Value Storage](/Guides/key-value), [Vector Database](/Guides/vector-db), and [Object Storage](/Guides/object-storage).
+</Callout>
+
+### The Memory Hierarchy
+
+Just like human memory, agent memory operates at different levels:
+
+```mermaid
+graph TD
+    A[Working Memory] --> B[Short-term Memory]
+    B --> C[Long-term Memory]
+    C --> D[Collective Memory]
+    
+    A1[Current Request Context] --> A
+    B1[Session State / Cache] --> B
+    C1[User History / Knowledge Base] --> C
+    D1[Shared Agent Knowledge] --> D
+```
+
+Let's explore each level:
+
+### 1. Working Memory (Request Context)
+**Lifetime**: Single request
+**Purpose**: Process current task
+**Storage**: In-memory variables
+
+```python
+# Working memory exists only during request processing
+async def run(request, response, context):
+    # These variables are working memory
+    user_intent = analyze_request(request)
+    current_plan = create_plan(user_intent)
+    execution_result = execute(current_plan)
+```
+
+### 2. Short-term Memory (Session State)
+**Lifetime**: Minutes to hours
+**Purpose**: Maintain conversation context
+**Storage**: Key-Value with TTL
+
+```python
+# Short-term memory for session continuity
+async def run(request, response, context):
+    session_id = request.metadata.get("session_id")
+    
+    # Retrieve session context
+    session_data = await context.kv.get("sessions", session_id)
+    
+    if session_data.exists:
+        conversation = await session_data.data.json()
+        conversation["messages"].append(user_message)
+    else:
+        conversation = {"messages": [user_message], "started": datetime.now()}
+    
+    # Update with TTL for automatic cleanup
+    await context.kv.set("sessions", session_id, conversation, {"ttl": 3600})
+```
+
+### 3. Long-term Memory (Persistent Knowledge)
+**Lifetime**: Permanent until deleted
+**Purpose**: Build user relationships and domain knowledge
+**Storage**: Vector database for semantic search
+
+```python
+# Long-term memory for learning and relationships
+async def run(request, response, context):
+    user_id = request.metadata.get("user_id")
+    
+    # Store learned preferences
+    await context.vector.upsert("user_knowledge", {
+        "key": f"pref_{user_id}_{datetime.now()}",
+        "document": "User prefers technical explanations with code examples",
+        "metadata": {
+            "user_id": user_id,
+            "confidence": 0.9,
+            "learned_from": "conversation_analysis"
+        }
+    })
+    
+    # Retrieve relevant memories
+    memories = await context.vector.search(
+        "user_knowledge",
+        f"What do I know about user {user_id}?",
+        limit=5,
+        similarity=0.7
+    )
+```
+
+### 4. Collective Memory (Shared Knowledge)
+**Lifetime**: Permanent, shared across agents
+**Purpose**: Organizational knowledge base
+**Storage**: Vector database with access controls
+
+## Structured vs. Unstructured Memory
+
+Different types of information require different storage approaches:
+
+### Structured Memory (Key-Value Storage)
+Best for discrete, queryable data:
+- User preferences
+- Session state
+- Configuration settings
+- Counters and metrics
+
+<CodeExample py={`async def run(request, response, context):
+    user_id = request.metadata.get("user_id")
+    
+    # Store structured user profile
+    profile = {
+        "name": "Alice Smith",
+        "preferences": {
+            "language": "python",
+            "timezone": "America/New_York",
+            "communication_style": "formal"
+        },
+        "metrics": {
+            "total_interactions": 42,
+            "last_seen": datetime.now().isoformat()
+        }
+    }
+    
+    await context.kv.set("users", user_id, profile)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const userId = request.metadata.get('user_id');
+  
+  // Store structured user profile
+  const profile = {
+    name: 'Alice Smith',
+    preferences: {
+      language: 'typescript',
+      timezone: 'America/New_York',
+      communication_style: 'formal'
+    },
+    metrics: {
+      total_interactions: 42,
+      last_seen: new Date().toISOString()
+    }
+  };
+  
+  await context.kv.set('users', userId, JSON.stringify(profile));
+};`} />
+
+### Unstructured Memory (Vector Storage)
+Best for semantic information:
+- Conversation history
+- Domain knowledge
+- User feedback
+- Document content
+
+<CodeExample py={`async def run(request, response, context):
+    # Store conversation for semantic retrieval
+    await context.vector.upsert("conversations", {
+        "key": f"conv_{datetime.now().isoformat()}",
+        "document": "User asked about deploying agents in production. " +
+                   "They're concerned about costs and scaling. " +
+                   "Recommended starting with dev environment.",
+        "metadata": {
+            "user_id": user_id,
+            "topic": "deployment",
+            "sentiment": "cautious",
+            "timestamp": datetime.now().isoformat()
+        }
+    })
+    
+    # Later, retrieve relevant context
+    similar_convos = await context.vector.search(
+        "conversations",
+        "deployment and scaling concerns",
+        limit=3
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Store conversation for semantic retrieval
+  await context.vector.upsert('conversations', {
+    key: \`conv_\${new Date().toISOString()}\`,
+    document: "User asked about deploying agents in production. " +
+              "They're concerned about costs and scaling. " +
+              "Recommended starting with dev environment.",
+    metadata: {
+      user_id: userId,
+      topic: 'deployment',
+      sentiment: 'cautious',
+      timestamp: new Date().toISOString()
+    }
+  });
+  
+  // Later, retrieve relevant context
+  const similarConvos = await context.vector.search('conversations', {
+    query: 'deployment and scaling concerns',
+    limit: 3
+  });
+};`} />
+
+### Binary Memory (Object Storage)
+Best for files and large data:
+- Generated reports
+- User uploads
+- Media files
+- Model outputs
+
+<CodeExample py={`async def run(request, response, context):
+    # Store generated report
+    report_data = generate_pdf_report(analysis_results)
+    report_key = f"reports/{user_id}/{datetime.now().strftime('%Y%m%d')}_analysis.pdf"
+    
+    await context.objectstore.put(
+        "documents",
+        report_key,
+        report_data,
+        {"contentType": "application/pdf"}
+    )
+    
+    # Create public URL for sharing (expires in 1 hour)
+    share_url = await context.objectstore.createPublicURL(
+        "documents",
+        report_key,
+        3600000  # milliseconds
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Store generated report
+  const reportData = generatePdfReport(analysisResults);
+  const reportKey = \`reports/\${userId}/\${new Date().toISOString().split('T')[0]}_analysis.pdf\`;
+  
+  await context.objectstore.put(
+    'documents',
+    reportKey,
+    reportData,
+    { contentType: 'application/pdf' }
+  );
+  
+  // Create public URL for sharing (expires in 1 hour)
+  const shareUrl = await context.objectstore.createPublicURL(
+    'documents',
+    reportKey,
+    3600000  // milliseconds
+  );
+};`} />
+
+## Memory Patterns and Best Practices
+
+### Pattern 1: Conversation Memory with Sliding Window
+
+Keep recent conversation context while managing memory size:
+
+<CodeExample py={`async def run(request, response, context):
+    session_id = request.metadata.get("session_id")
+    max_messages = 20  # Keep last 20 messages
+    
+    # Get existing conversation
+    result = await context.kv.get("conversations", session_id)
+    
+    if result.exists:
+        convo = await result.data.json()
+        messages = convo["messages"]
+    else:
+        messages = []
+    
+    # Add new message
+    messages.append({
+        "role": "user",
+        "content": await request.data.text(),
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    # Sliding window - keep only recent messages
+    if len(messages) > max_messages:
+        # Before removing, summarize older messages
+        summary = await summarize_messages(messages[:10])
+        await context.vector.upsert("summaries", {
+            "key": f"{session_id}_summary_{datetime.now()}",
+            "document": summary,
+            "metadata": {"session_id": session_id}
+        })
+        messages = messages[-max_messages:]
+    
+    # Process with context
+    agent_response = await process_with_context(messages)
+    
+    # Add agent response
+    messages.append({
+        "role": "agent",
+        "content": agent_response,
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    # Save updated conversation
+    await context.kv.set("conversations", session_id, {
+        "messages": messages,
+        "updated": datetime.now().isoformat()
+    }, {"ttl": 7200})  # 2 hour TTL
+    
+    return response.json({"message": agent_response})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const sessionId = request.metadata.get('session_id');
+  const maxMessages = 20; // Keep last 20 messages
+  
+  // Get existing conversation
+  const result = await context.kv.get('conversations', sessionId);
+  
+  let messages = [];
+  if (result.exists) {
+    const convo = await result.data.json();
+    messages = convo.messages;
+  }
+  
+  // Add new message
+  messages.push({
+    role: 'user',
+    content: await request.data.text(),
+    timestamp: new Date().toISOString()
+  });
+  
+  // Sliding window - keep only recent messages
+  if (messages.length > maxMessages) {
+    // Before removing, summarize older messages
+    const summary = await summarizeMessages(messages.slice(0, 10));
+    await context.vector.upsert('summaries', {
+      key: \`\${sessionId}_summary_\${new Date().toISOString()}\`,
+      document: summary,
+      metadata: { session_id: sessionId }
+    });
+    messages = messages.slice(-maxMessages);
+  }
+  
+  // Process with context
+  const agentResponse = await processWithContext(messages);
+  
+  // Add agent response
+  messages.push({
+    role: 'agent',
+    content: agentResponse,
+    timestamp: new Date().toISOString()
+  });
+  
+  // Save updated conversation
+  await context.kv.set('conversations', sessionId, JSON.stringify({
+    messages,
+    updated: new Date().toISOString()
+  }), { ttl: 7200 }); // 2 hour TTL
+  
+  return response.json({ message: agentResponse });
+};`} />
+
+### Pattern 2: Personalization Through Learning
+
+Build user profiles over time:
+
+<Callout type="info">
+**Metadata Filtering in Vector Search**: The `metadata` parameter in vector search is used to filter results, not just for returning metadata. When you specify `metadata={"user_id": user_id}` in Python or `metadata: { user_id: userId }` in JavaScript, the search will only return vectors that match those metadata criteria. This is useful for isolating user-specific memories or filtering by any other metadata field you've stored.
+</Callout>
+
+<CodeExample py={`async def run(request, response, context):
+    user_id = request.metadata.get("user_id")
+    user_input = await request.data.text()
+    
+    # Retrieve user profile
+    profile_result = await context.kv.get("profiles", user_id)
+    
+    if profile_result.exists:
+        profile = await profile_result.data.json()
+    else:
+        profile = {
+            "interaction_count": 0,
+            "topics": {},
+            "preferences": {},
+            "created": datetime.now().isoformat()
+        }
+    
+    # Update interaction count
+    profile["interaction_count"] += 1
+    
+    # Analyze input for topics and preferences
+    analysis = await analyze_user_input(user_input)
+    
+    # Update topic frequencies
+    for topic in analysis["topics"]:
+        profile["topics"][topic] = profile["topics"].get(topic, 0) + 1
+    
+    # Store notable preferences as vectors for semantic search
+    if analysis["preferences"]:
+        for pref in analysis["preferences"]:
+            await context.vector.upsert("user_preferences", {
+                "key": f"{user_id}_{hash(pref)}",
+                "document": pref,
+                "metadata": {
+                    "user_id": user_id,
+                    "confidence": analysis["confidence"],
+                    "learned_at": datetime.now().isoformat()
+                }
+            })
+    
+    # Get relevant memories for this conversation
+    memories = await context.vector.search(
+        "user_preferences",
+        user_input,
+        limit=3,
+        metadata={"user_id": user_id}
+    )
+    
+    # Generate personalized response
+    response_text = await generate_response(
+        user_input,
+        profile,
+        memories
+    )
+    
+    # Save updated profile
+    await context.kv.set("profiles", user_id, profile)
+    
+    return response.json({
+        "message": response_text,
+        "personalized": True,
+        "interaction_number": profile["interaction_count"]
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const userId = request.metadata.get('user_id');
+  const userInput = await request.data.text();
+  
+  // Retrieve user profile
+  const profileResult = await context.kv.get('profiles', userId);
+  
+  let profile;
+  if (profileResult.exists) {
+    profile = await profileResult.data.json();
+  } else {
+    profile = {
+      interaction_count: 0,
+      topics: {},
+      preferences: {},
+      created: new Date().toISOString()
+    };
+  }
+  
+  // Update interaction count
+  profile.interaction_count++;
+  
+  // Analyze input for topics and preferences
+  const analysis = await analyzeUserInput(userInput);
+  
+  // Update topic frequencies
+  for (const topic of analysis.topics) {
+    profile.topics[topic] = (profile.topics[topic] || 0) + 1;
+  }
+  
+  // Store notable preferences as vectors for semantic search
+  if (analysis.preferences) {
+    for (const pref of analysis.preferences) {
+      await context.vector.upsert('user_preferences', {
+        key: \`\${userId}_\${hashString(pref)}\`,
+        document: pref,
+        metadata: {
+          user_id: userId,
+          confidence: analysis.confidence,
+          learned_at: new Date().toISOString()
+        }
+      });
+    }
+  }
+  
+  // Get relevant memories for this conversation
+  const memories = await context.vector.search('user_preferences', {
+    query: userInput,
+    limit: 3,
+    metadata: { user_id: userId }
+  });
+  
+  // Generate personalized response
+  const responseText = await generateResponse(
+    userInput,
+    profile,
+    memories
+  );
+  
+  // Save updated profile
+  await context.kv.set('profiles', userId, JSON.stringify(profile));
+  
+  return response.json({
+    message: responseText,
+    personalized: true,
+    interaction_number: profile.interaction_count
+  });
+};`} />
+
+### Pattern 3: Semantic Knowledge Base
+
+Build a searchable knowledge base from interactions:
+
+<CodeExample py={`async def run(request, response, context):
+    action = (await request.data.json()).get("action")
+    
+    if action == "learn":
+        # Extract and store knowledge
+        knowledge = await request.data.json()
+        
+        await context.vector.upsert("knowledge_base", {
+            "key": f"fact_{datetime.now().timestamp()}",
+            "document": knowledge["fact"],
+            "metadata": {
+                "category": knowledge.get("category", "general"),
+                "source": knowledge.get("source", "user_provided"),
+                "confidence": knowledge.get("confidence", 0.8),
+                "tags": knowledge.get("tags", []),
+                "created": datetime.now().isoformat()
+            }
+        })
+        
+        return response.json({"status": "learned", "fact": knowledge["fact"]})
+    
+    elif action == "query":
+        # Search the knowledge base
+        query = (await request.data.json())["query"]
+        
+        # Semantic search
+        results = await context.vector.search(
+            "knowledge_base",
+            query,
+            limit=10,
+            similarity=0.6
+        )
+        
+        # Format results with relevance scores
+        formatted_results = []
+        for result in results:
+            formatted_results.append({
+                "fact": result.document,
+                "relevance": result.similarity,
+                "metadata": result.metadata
+            })
+        
+        return response.json({
+            "query": query,
+            "results": formatted_results,
+            "count": len(formatted_results)
+        })
+    
+    elif action == "analyze":
+        # Analyze knowledge base patterns
+        topic = (await request.data.json()).get("topic")
+        
+        # Get all related facts
+        facts = await context.vector.search(
+            "knowledge_base",
+            topic,
+            limit=50,
+            similarity=0.5
+        )
+        
+        # Analyze patterns
+        analysis = {
+            "topic": topic,
+            "fact_count": len(facts),
+            "categories": {},
+            "confidence_avg": 0,
+            "sources": {}
+        }
+        
+        for fact in facts:
+            category = fact.metadata.get("category", "unknown")
+            analysis["categories"][category] = \
+                analysis["categories"].get(category, 0) + 1
+            
+            source = fact.metadata.get("source", "unknown")
+            analysis["sources"][source] = \
+                analysis["sources"].get(source, 0) + 1
+            
+            analysis["confidence_avg"] += fact.metadata.get("confidence", 0)
+        
+        if facts:
+            analysis["confidence_avg"] /= len(facts)
+        
+        return response.json(analysis)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const { action } = await request.data.json();
+  
+  if (action === 'learn') {
+    // Extract and store knowledge
+    const knowledge = await request.data.json();
+    
+    await context.vector.upsert('knowledge_base', {
+      key: \`fact_\${Date.now()}\`,
+      document: knowledge.fact,
+      metadata: {
+        category: knowledge.category || 'general',
+        source: knowledge.source || 'user_provided',
+        confidence: knowledge.confidence || 0.8,
+        tags: knowledge.tags || [],
+        created: new Date().toISOString()
+      }
+    });
+    
+    return response.json({ status: 'learned', fact: knowledge.fact });
+  
+  } else if (action === 'query') {
+    // Search the knowledge base
+    const { query } = await request.data.json();
+    
+    // Semantic search
+    const results = await context.vector.search('knowledge_base', {
+      query,
+      limit: 10,
+      similarity: 0.6
+    });
+    
+    // Format results with relevance scores
+    const formattedResults = results.map(result => ({
+      fact: result.document,
+      relevance: result.similarity,
+      metadata: result.metadata
+    }));
+    
+    return response.json({
+      query,
+      results: formattedResults,
+      count: formattedResults.length
+    });
+  
+  } else if (action === 'analyze') {
+    // Analyze knowledge base patterns
+    const { topic } = await request.data.json();
+    
+    // Get all related facts
+    const facts = await context.vector.search('knowledge_base', {
+      query: topic,
+      limit: 50,
+      similarity: 0.5
+    });
+    
+    // Analyze patterns
+    const analysis = {
+      topic,
+      fact_count: facts.length,
+      categories: {},
+      confidence_avg: 0,
+      sources: {}
+    };
+    
+    for (const fact of facts) {
+      const category = fact.metadata?.category || 'unknown';
+      analysis.categories[category] = (analysis.categories[category] || 0) + 1;
+      
+      const source = fact.metadata?.source || 'unknown';
+      analysis.sources[source] = (analysis.sources[source] || 0) + 1;
+      
+      analysis.confidence_avg += fact.metadata?.confidence || 0;
+    }
+    
+    if (facts.length > 0) {
+      analysis.confidence_avg /= facts.length;
+    }
+    
+    return response.json(analysis);
+  }
+};`} />
+
+## Memory Management Strategies
+
+### TTL (Time To Live) Strategies
+
+Different memory types require different retention policies:
+
+| Memory Type | Recommended TTL | Use Case |
+|------------|-----------------|----------|
+| Session state | 1-2 hours | Active conversations |
+| Daily cache | 24 hours | Frequently accessed data |
+| User preferences | No TTL | Permanent personalization |
+| Temporary results | 5-15 minutes | Computation cache |
+| Audit logs | 30-90 days | Compliance requirements |
+
+### Memory Sizing Guidelines
+
+Plan your memory usage based on agent patterns:
+
+```python
+# Calculate memory requirements
+def estimate_memory_needs(users, interactions_per_day):
+    # Key-Value Storage
+    profile_size = 2  # KB per user profile
+    session_size = 10  # KB per active session
+    kv_total = (users * profile_size) + (users * 0.1 * session_size)
+    
+    # Vector Storage
+    vectors_per_user = interactions_per_day * 30  # 30 days retention
+    vector_size = 0.5  # KB per vector
+    vector_total = users * vectors_per_user * vector_size
+    
+    # Object Storage
+    reports_per_user = 10  # Average files per user
+    avg_file_size = 500  # KB per file
+    object_total = users * reports_per_user * avg_file_size
+    
+    return {
+        "kv_storage_gb": kv_total / 1024 / 1024,
+        "vector_storage_gb": vector_total / 1024 / 1024,
+        "object_storage_gb": object_total / 1024 / 1024
+    }
+```
+
+### Memory Cleanup Patterns
+
+Implement automated cleanup to manage costs:
+
+<CodeExample py={`async def run(request, response, context):
+    # Scheduled cleanup agent (triggered by cron)
+    if request.trigger == "cron":
+        context.logger.info("Running memory cleanup")
+        
+        # Clean expired sessions
+        # Note: KV items with TTL auto-expire, but we can proactively clean
+        
+        # Archive old conversations to object storage
+        cutoff_date = datetime.now() - timedelta(days=30)
+        
+        # In production, you'd iterate through keys with a pattern
+        # This is a simplified example
+        old_sessions = await get_old_sessions(cutoff_date)
+        
+        for session_id in old_sessions:
+            # Get conversation
+            result = await context.kv.get("conversations", session_id)
+            if result.exists:
+                convo = await result.data.json()
+                
+                # Archive to object storage
+                archive_key = f"archives/{session_id}/{cutoff_date.isoformat()}.json"
+                await context.objectstore.put(
+                    "archives",
+                    archive_key,
+                    json.dumps(convo),
+                    {"contentType": "application/json"}
+                )
+                
+                # Delete from KV
+                await context.kv.delete("conversations", session_id)
+                
+                context.logger.info(f"Archived session {session_id}")
+        
+        return response.json({
+            "task": "cleanup",
+            "archived_sessions": len(old_sessions),
+            "timestamp": datetime.now().isoformat()
+        })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Scheduled cleanup agent (triggered by cron)
+  if (request.trigger === 'cron') {
+    context.logger.info('Running memory cleanup');
+    
+    // Archive old conversations to object storage
+    const cutoffDate = new Date();
+    cutoffDate.setDate(cutoffDate.getDate() - 30);
+    
+    // In production, you'd iterate through keys with a pattern
+    // This is a simplified example
+    const oldSessions = await getOldSessions(cutoffDate);
+    
+    for (const sessionId of oldSessions) {
+      // Get conversation
+      const result = await context.kv.get('conversations', sessionId);
+      if (result.exists) {
+        const convo = await result.data.json();
+        
+        // Archive to object storage
+        const archiveKey = \`archives/\${sessionId}/\${cutoffDate.toISOString()}.json\`;
+        await context.objectstore.put(
+          'archives',
+          archiveKey,
+          JSON.stringify(convo),
+          { contentType: 'application/json' }
+        );
+        
+        // Delete from KV
+        await context.kv.delete('conversations', sessionId);
+        
+        context.logger.info(\`Archived session \${sessionId}\`);
+      }
+    }
+    
+    return response.json({
+      task: 'cleanup',
+      archived_sessions: oldSessions.length,
+      timestamp: new Date().toISOString()
+    });
+  }
+};`} />
+
+## Lab: Building a Memory-Powered Customer Service Agent
+
+Let's build an agent that remembers customer interactions and provides increasingly personalized support:
+
+<CodeExample py={`from datetime import datetime, timedelta
+import json
+
+def welcome():
+    """Test scenarios for our customer service agent."""
+    return {
+        "welcome": "Customer Service Agent - I remember you!",
+        "prompts": [
+            {
+                "data": {
+                    "action": "support",
+                    "user_id": "customer_123", 
+                    "message": "My order hasn't arrived yet",
+                    "order_id": "ORD-789"
+                },
+                "contentType": "application/json"
+            },
+            {
+                "data": {
+                    "action": "support",
+                    "user_id": "customer_123",
+                    "message": "Still waiting for my order"
+                },
+                "contentType": "application/json"
+            },
+            {
+                "data": {
+                    "action": "get_history",
+                    "user_id": "customer_123"
+                },
+                "contentType": "application/json"
+            }
+        ]
+    }
+
+async def run(request, response, context):
+    """Customer service agent with memory."""
+    data = await request.data.json()
+    action = data.get("action")
+    user_id = data.get("user_id")
+    
+    if action == "support":
+        message = data.get("message")
+        
+        # Get customer profile
+        profile_result = await context.kv.get("customers", user_id)
+        if profile_result.exists:
+            profile = await profile_result.data.json()
+            profile["interaction_count"] = profile.get("interaction_count", 0) + 1
+        else:
+            profile = {
+                "user_id": user_id,
+                "first_contact": datetime.now().isoformat(),
+                "interaction_count": 1,
+                "issues": []
+            }
+        
+        # Search for similar past issues
+        past_issues = await context.vector.search(
+            "support_history",
+            message,
+            limit=3,
+            metadata={"user_id": user_id}
+        )
+        
+        # Determine if this is a recurring issue
+        is_recurring = False
+        for issue in past_issues:
+            if issue.similarity > 0.8:
+                is_recurring = True
+                break
+        
+        # Store this interaction
+        interaction_key = f"{user_id}_{datetime.now().timestamp()}"
+        await context.vector.upsert("support_history", {
+            "key": interaction_key,
+            "document": message,
+            "metadata": {
+                "user_id": user_id,
+                "timestamp": datetime.now().isoformat(),
+                "order_id": data.get("order_id"),
+                "resolved": False
+            }
+        })
+        
+        # Add to profile issues
+        profile["issues"].append({
+            "message": message,
+            "timestamp": datetime.now().isoformat(),
+            "recurring": is_recurring
+        })
+        
+        # Generate response based on history
+        if is_recurring:
+            response_text = (
+                f"I see you've contacted us about this before. "
+                f"Let me escalate this to our senior support team immediately. "
+                f"Your case has been prioritized."
+            )
+            priority = "high"
+        elif profile["interaction_count"] > 5:
+            response_text = (
+                f"Thank you for being a valued customer. "
+                f"I'm looking into your issue right away."
+            )
+            priority = "medium"
+        else:
+            response_text = (
+                f"Thank you for contacting support. "
+                f"I'll help you with your issue."
+            )
+            priority = "normal"
+        
+        # Save updated profile
+        await context.kv.set("customers", user_id, profile)
+        
+        # Log for analytics
+        context.logger.info(f"Support request from {user_id}: {priority} priority")
+        
+        return response.json({
+            "response": response_text,
+            "is_recurring": is_recurring,
+            "interaction_number": profile["interaction_count"],
+            "priority": priority,
+            "similar_issues_found": len(past_issues)
+        })
+    
+    elif action == "get_history":
+        # Retrieve customer history
+        profile_result = await context.kv.get("customers", user_id)
+        
+        if not profile_result.exists:
+            return response.json({
+                "error": "No history found for this customer"
+            })
+        
+        profile = await profile_result.data.json()
+        
+        # Get recent issues from vector storage
+        recent_issues = await context.vector.search(
+            "support_history",
+            f"all issues for user {user_id}",
+            limit=10,
+            metadata={"user_id": user_id}
+        )
+        
+        return response.json({
+            "customer_profile": profile,
+            "recent_issues": [
+                {
+                    "message": issue.document,
+                    "metadata": issue.metadata
+                }
+                for issue in recent_issues
+            ]
+        })
+    
+    return response.json({
+        "error": "Unknown action"
+    })`} js={`const welcome = () => {
+    return {
+        welcome: "Customer Service Agent - I remember you!",
+        prompts: [
+            {
+                data: JSON.stringify({
+                    action: "support",
+                    user_id: "customer_123",
+                    message: "My order hasn't arrived yet",
+                    order_id: "ORD-789"
+                }),
+                contentType: "application/json"
+            },
+            {
+                data: JSON.stringify({
+                    action: "support",
+                    user_id: "customer_123",
+                    message: "Still waiting for my order"
+                }),
+                contentType: "application/json"
+            },
+            {
+                data: JSON.stringify({
+                    action: "get_history",
+                    user_id: "customer_123"
+                }),
+                contentType: "application/json"
+            }
+        ]
+    };
+};
+
+const handler: AgentHandler = async (request, response, context) => {
+  const data = await request.data.json();
+  const { action, user_id } = data;
+  
+  if (action === 'support') {
+    const { message } = data;
+    
+    // Get customer profile
+    const profileResult = await context.kv.get('customers', user_id);
+    let profile;
+    
+    if (profileResult.exists) {
+      profile = await profileResult.data.json();
+      profile.interaction_count = (profile.interaction_count || 0) + 1;
+    } else {
+      profile = {
+        user_id,
+        first_contact: new Date().toISOString(),
+        interaction_count: 1,
+        issues: []
+      };
+    }
+    
+    // Search for similar past issues
+    const pastIssues = await context.vector.search('support_history', {
+      query: message,
+      limit: 3,
+      metadata: { user_id }
+    });
+    
+    // Determine if this is a recurring issue
+    let isRecurring = false;
+    for (const issue of pastIssues) {
+      if (issue.similarity > 0.8) {
+        isRecurring = true;
+        break;
+      }
+    }
+    
+    // Store this interaction
+    const interactionKey = \`\${user_id}_\${Date.now()}\`;
+    await context.vector.upsert('support_history', {
+      key: interactionKey,
+      document: message,
+      metadata: {
+        user_id,
+        timestamp: new Date().toISOString(),
+        order_id: data.order_id,
+        resolved: false
+      }
+    });
+    
+    // Add to profile issues
+    profile.issues.push({
+      message,
+      timestamp: new Date().toISOString(),
+      recurring: isRecurring
+    });
+    
+    // Generate response based on history
+    let responseText, priority;
+    
+    if (isRecurring) {
+      responseText = 
+        "I see you've contacted us about this before. " +
+        "Let me escalate this to our senior support team immediately. " +
+        "Your case has been prioritized.";
+      priority = 'high';
+    } else if (profile.interaction_count > 5) {
+      responseText = 
+        "Thank you for being a valued customer. " +
+        "I'm looking into your issue right away.";
+      priority = 'medium';
+    } else {
+      responseText = 
+        "Thank you for contacting support. " +
+        "I'll help you with your issue.";
+      priority = 'normal';
+    }
+    
+    // Save updated profile
+    await context.kv.set('customers', user_id, JSON.stringify(profile));
+    
+    // Log for analytics
+    context.logger.info(\`Support request from \${user_id}: \${priority} priority\`);
+    
+    return response.json({
+      response: responseText,
+      is_recurring: isRecurring,
+      interaction_number: profile.interaction_count,
+      priority,
+      similar_issues_found: pastIssues.length
+    });
+  
+  } else if (action === 'get_history') {
+    // Retrieve customer history
+    const profileResult = await context.kv.get('customers', user_id);
+    
+    if (!profileResult.exists) {
+      return response.json({
+        error: 'No history found for this customer'
+      });
+    }
+    
+    const profile = await profileResult.data.json();
+    
+    // Get recent issues from vector storage
+    const recentIssues = await context.vector.search('support_history', {
+      query: \`all issues for user \${user_id}\`,
+      limit: 10,
+      metadata: { user_id }
+    });
+    
+    return response.json({
+      customer_profile: profile,
+      recent_issues: recentIssues.map(issue => ({
+        message: issue.document,
+        metadata: issue.metadata
+      }))
+    });
+  }
+  
+  return response.json({
+    error: 'Unknown action'
+  });
+};
+
+export default handler;
+export { welcome };`} />
+
+### Testing Your Memory Agent
+
+1. **Start DevMode:**
+```bash
+agentuity dev
+```
+
+2. **Test the scenarios:**
+   - First support request - notice the standard response
+   - Second similar request - see how it recognizes the recurring issue
+   - Check history - view all stored interactions
+
+3. **Observe the memory in action:**
+   - Watch the logs to see KV and vector operations
+   - Try different user IDs to see isolated memory
+   - Test with various message similarities
+
+## Memory at Scale
+
+As your agents grow, consider these scaling strategies:
+
+### Hybrid Memory Architecture
+- **Hot data** in KV storage (recent interactions)
+- **Warm data** in vector storage (searchable history)
+- **Cold data** in object storage (archives)
+
+### Memory Sharding
+- Partition by user ID or tenant
+- Distribute across namespaces
+- Implement consistent hashing for even distribution
+
+### Caching Strategies
+- Cache frequent queries in KV with short TTL
+- Pre-compute common aggregations
+- Use edge caching for read-heavy workloads
+
+## Key Takeaways
+
+- **Memory transforms agents** from stateless functions to learning systems
+- **Choose the right storage**: KV for structure, Vector for semantic, Object for files
+- **Implement retention policies**: Not all memory should be permanent
+- **Design for scale**: Plan your memory architecture for growth
+- **Privacy matters**: Always consider data retention regulations
+
+## What's Next?
+
+Now that your agents can remember, it's time to help them collaborate. In the next module, we'll explore agent-to-agent communication - how multiple specialized agents can work together to solve complex problems.
+
+But first, experiment with memory patterns:
+- Build an agent that learns user preferences over time
+- Implement a knowledge base that grows from conversations
+- Create memory cleanup strategies
+- Test different TTL strategies for various use cases
+
+Remember: Memory is what transforms an agent from a tool into a partner.
+
+---
+
+**Ready for Module 4?** [Agent-to-Agent Collaboration](./04-agent-collaboration)
\ No newline at end of file
diff --git a/content/Training/developers/index.mdx b/content/Training/developers/index.mdx
new file mode 100644
index 00000000..12e34cc6
--- /dev/null
+++ b/content/Training/developers/index.mdx
@@ -0,0 +1,55 @@
+---
+title: Developer Training
+description: Building with Agentuity - Developer Learning Path
+---
+
+## Why AI Agents, Why Now?
+
+The AI industry is racing toward a [$47B agent economy by 2030](https://www.marketsandmarkets.com/Market-Reports/ai-agents-market-15761548.html), but [many developers](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality) are trying to build autonomous systems on infrastructure designed for websites. 
+
+Agents are autonomous systems that remember context, reason through problems, act independently, and collaborate with other agents. This course teaches you **agent engineering fundamentals** while leveraging Agentuity's purpose-built infrastructure.
+
+## What You'll Build
+
+By the end of this course, you'll have deployed:
+- Production agents with persistent memory (stateful, long-running)
+- Multi-agent workflows with seamless agent-to-agent communication
+- Framework-agnostic agents (LangChain, CrewAI, or custom)
+- Fully observable systems with OpenTelemetry tracing
+- Complete dev → staging → production deployment pipelines
+
+## Time Investment
+- **Full course:** ~20 hours (all modules + capstone project)
+- **Fast track:** ~8 hours (Modules 1, 3, 6 + mini-project)
+- **Framework migration:** ~4 hours (Modules 2 + 6 for developers with existing agent projects)
+
+## Before You Start
+
+**Required:**
+- Proficiency in Python or JavaScript
+- Basic understanding of APIs and cloud deployment
+- Command line familiarity
+
+## Choose Your Path
+
+### New to AI Agents?
+Start with [Module 1: Introduction to Agents](./01-introduction-to-agents) to understand how agents differ from traditional software and why they need specialized infrastructure.
+
+### Built Agents Before?  
+Jump to [Module 3: Agent Memory](./03-agent-memory) to see how Agentuity handles state differently, or [Module 4: Agent-to-Agent Collaboration](./04-agent-collaboration) for orchestration patterns.
+
+### Need Production Deployment?
+Go straight to [Module 6: Deployment Environments](./06-deployment-environments) to understand Agentuity's dev/staging/prod environments and scaling approach.
+
+### Migrating from Another Platform?
+Check our Framework Migration Guide for specifics on moving from AWS Bedrock, Google ADK, or Azure AI.
+
+## What Makes This Different
+
+Unlike generic AI courses, this curriculum:
+- Focuses on **production deployment**, not just demos
+- Addresses real challenges like memory management, cost optimization, and non-determinism
+- Uses actual industry examples (both successes and cautionary tales)
+- Teaches **platform-agnostic concepts** alongside Agentuity-specific implementation
+
+Ready to dive into the world of AI agents? Let's get started with [Module 1: Introduction to Agents](./01-introduction-to-agents).
\ No newline at end of file
diff --git a/content/Training/index.mdx b/content/Training/index.mdx
new file mode 100644
index 00000000..fcbdf7ba
--- /dev/null
+++ b/content/Training/index.mdx
@@ -0,0 +1,21 @@
+---
+title: Training
+description: Learn how to build production-ready AI agents with Agentuity
+---
+
+## Available Training
+
+### For Developers
+Comprehensive hands-on course covering agent fundamentals through production deployment.
+
+- 7 modules from basics to advanced
+- ~20 hours of content
+- Hands-on labs and capstone project
+
+[Start Developer Training →](./developers)
+
+## Coming Soon
+
+**For Executives** - Strategic overview of the agent economy
+
+**For Tech Leads** - Architecture patterns and integration strategies
\ No newline at end of file
diff --git a/content/meta.json b/content/meta.json
index 77852ca1..2d80002e 100644
--- a/content/meta.json
+++ b/content/meta.json
@@ -3,6 +3,7 @@
 	"pages": [
 		"Introduction",
 		"Guides",
+		"Training",
 		"Cloud",
 		"CLI",
 		"SDKs",

From d1fe88c19ea0f2f8940991a5295c073ffbd375a5 Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Mon, 8 Sep 2025 18:33:29 -0700
Subject: [PATCH 02/13] Update training docs, add modules 4-7

---
 .../developers/01-introduction-to-agents.mdx  |    4 +-
 .../developers/02-anatomy-of-an-agent.mdx     |   35 +-
 .../Training/developers/03-agent-memory.mdx   |   42 +-
 .../developers/04-agent-collaboration.mdx     |  849 ++++++++++++++
 .../05-guardrails-evals-observability.mdx     | 1006 +++++++++++++++++
 .../developers/06-deployment-environments.mdx |  247 ++++
 .../developers/07-sandbox-capstone.mdx        |  389 +++++++
 7 files changed, 2527 insertions(+), 45 deletions(-)
 create mode 100644 content/Training/developers/04-agent-collaboration.mdx
 create mode 100644 content/Training/developers/05-guardrails-evals-observability.mdx
 create mode 100644 content/Training/developers/06-deployment-environments.mdx
 create mode 100644 content/Training/developers/07-sandbox-capstone.mdx

diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
index d017417c..3d197edb 100644
--- a/content/Training/developers/01-introduction-to-agents.mdx
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -1,10 +1,8 @@
 ---
-title: Introduction to Agents
+title: "Module 1: Introduction to Agents"
 description: Understanding AI agents and the $47B opportunity
 ---
 
-# Module 1: Introduction to Agents
-
 Welcome to the age of AI agents - autonomous systems that are fundamentally transforming how we build and think about software.
 
 ## The $47B Agent Opportunity
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index 0df46db8..99704d74 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -1,28 +1,23 @@
 ---
-title: The Anatomy of an Agent
+title: "Module 2: The Anatomy of an Agent"
 description: Understanding how agents work - planning, reasoning, tools, and memory
 ---
 
-# Module 2: The Anatomy of an Agent
-
 Now that you've built your first agent, let's dive deeper to understand what makes agents tick. We'll explore the core components that transform a simple script into an autonomous, intelligent system.
 
 ## The Agent Lifecycle
 
 Every agent interaction follows a predictable lifecycle, from receiving a trigger to returning a response. Understanding this flow is crucial for building effective agents.
 
-```mermaid
+<Mermaid chart="
 graph TD
-    A[Trigger Event] --> B[Request Handler]
-    B --> C[Context Initialization]
-    C --> D[Planning Phase]
-    D --> E[Reasoning Loop]
-    E --> F[Tool Invocation]
-    F --> G[Memory Update]
-    G --> H[Response Generation]
-    H --> I[Return Response]
-    E --> E[Continue Loop]
-```
+    Trigger[Trigger Event] --> Request[Request Object]
+    Request --> Handler[Agent Handler]
+    Handler --> Context[Context & Storage]
+    Handler --> Process[Process Logic]
+    Process --> Response[Response Object]
+    Response --> Output[Return to Caller]
+" />
 
 Let's explore each phase:
 
@@ -172,25 +167,25 @@ The context object is your agent's gateway to Agentuity's services. It provides
     agent_id = context.agent.id
     agent_name = context.agent.name
     project_id = context.projectId
-    run_id = context.runId
+    session_id = context.sessionId
     
     # Key-Value storage
     await context.kv.set("cache", "key", {"data": "value"})
     result = await context.kv.get("cache", "key")
     
     # Vector storage for semantic search
-    await context.vector.upsert("docs", {
+    await context.vector.upsert("docs", [{
         "key": "doc1",
         "document": "AI agents are autonomous systems",
         "metadata": {"category": "intro"}
-    })
+    }])
     
     # Object storage for files
     await context.objectstore.put("files", "report.pdf", pdf_bytes)
     
     return response.json({
         "agent": agent_name,
-        "run": run_id
+        "session": session_id
     })`} js={`const handler: AgentHandler = async (request, response, context) => {
   // Logging at different levels
   context.logger.debug('Debug information');
@@ -202,7 +197,7 @@ The context object is your agent's gateway to Agentuity's services. It provides
   const agentId = context.agent.id;
   const agentName = context.agent.name;
   const projectId = context.projectId;
-  const runId = context.runId;
+  const sessionId = context.sessionId;
   
   // Key-Value storage
   await context.kv.set('cache', 'key', JSON.stringify({ data: 'value' }));
@@ -220,7 +215,7 @@ The context object is your agent's gateway to Agentuity's services. It provides
   
   return response.json({
     agent: agentName,
-    run: runId
+    session: sessionId
   });
 };`} />
 
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
index 246ec9e3..e6d275e5 100644
--- a/content/Training/developers/03-agent-memory.mdx
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -1,10 +1,8 @@
 ---
-title: Agent Memory
+title: "Module 3: Agent Memory"
 description: How agents remember, learn, and build context over time
 ---
 
-# Module 3: Agent Memory
-
 Without memory, an agent is just a stateless function. With memory, it becomes a system that learns, adapts, and builds relationships over time.
 
 ## The Memory Challenge
@@ -31,7 +29,7 @@ For implementation details on Agentuity's storage systems, see our guides on [Ke
 
 Just like human memory, agent memory operates at different levels:
 
-```mermaid
+<Mermaid chart="
 graph TD
     A[Working Memory] --> B[Short-term Memory]
     B --> C[Long-term Memory]
@@ -41,7 +39,7 @@ graph TD
     B1[Session State / Cache] --> B
     C1[User History / Knowledge Base] --> C
     D1[Shared Agent Knowledge] --> D
-```
+" />
 
 Let's explore each level:
 
@@ -93,7 +91,7 @@ async def run(request, response, context):
     user_id = request.metadata.get("user_id")
     
     # Store learned preferences
-    await context.vector.upsert("user_knowledge", {
+    await context.vector.upsert("user_knowledge", [{
         "key": f"pref_{user_id}_{datetime.now()}",
         "document": "User prefers technical explanations with code examples",
         "metadata": {
@@ -101,7 +99,7 @@ async def run(request, response, context):
             "confidence": 0.9,
             "learned_from": "conversation_analysis"
         }
-    })
+    }])
     
     # Retrieve relevant memories
     memories = await context.vector.search(
@@ -174,7 +172,7 @@ Best for semantic information:
 
 <CodeExample py={`async def run(request, response, context):
     # Store conversation for semantic retrieval
-    await context.vector.upsert("conversations", {
+    await context.vector.upsert("conversations", [{
         "key": f"conv_{datetime.now().isoformat()}",
         "document": "User asked about deploying agents in production. " +
                    "They're concerned about costs and scaling. " +
@@ -185,7 +183,7 @@ Best for semantic information:
             "sentiment": "cautious",
             "timestamp": datetime.now().isoformat()
         }
-    })
+    }])
     
     # Later, retrieve relevant context
     similar_convos = await context.vector.search(
@@ -226,12 +224,13 @@ Best for files and large data:
     report_data = generate_pdf_report(analysis_results)
     report_key = f"reports/{user_id}/{datetime.now().strftime('%Y%m%d')}_analysis.pdf"
     
+    # Auto-detects content type from file extension and data
     await context.objectstore.put(
         "documents",
         report_key,
-        report_data,
-        {"contentType": "application/pdf"}
+        report_data
     )
+    # Note: For explicit content type, use ObjectStorePutParams class (see API reference)
     
     # Create public URL for sharing (expires in 1 hour)
     share_url = await context.objectstore.createPublicURL(
@@ -288,11 +287,11 @@ Keep recent conversation context while managing memory size:
     if len(messages) > max_messages:
         # Before removing, summarize older messages
         summary = await summarize_messages(messages[:10])
-        await context.vector.upsert("summaries", {
+        await context.vector.upsert("summaries", [{
             "key": f"{session_id}_summary_{datetime.now()}",
             "document": summary,
             "metadata": {"session_id": session_id}
-        })
+        }])
         messages = messages[-max_messages:]
     
     # Process with context
@@ -400,7 +399,7 @@ Build user profiles over time:
     # Store notable preferences as vectors for semantic search
     if analysis["preferences"]:
         for pref in analysis["preferences"]:
-            await context.vector.upsert("user_preferences", {
+            await context.vector.upsert("user_preferences", [{
                 "key": f"{user_id}_{hash(pref)}",
                 "document": pref,
                 "metadata": {
@@ -408,7 +407,7 @@ Build user profiles over time:
                     "confidence": analysis["confidence"],
                     "learned_at": datetime.now().isoformat()
                 }
-            })
+            }])
     
     # Get relevant memories for this conversation
     memories = await context.vector.search(
@@ -512,7 +511,7 @@ Build a searchable knowledge base from interactions:
         # Extract and store knowledge
         knowledge = await request.data.json()
         
-        await context.vector.upsert("knowledge_base", {
+        await context.vector.upsert("knowledge_base", [{
             "key": f"fact_{datetime.now().timestamp()}",
             "document": knowledge["fact"],
             "metadata": {
@@ -522,7 +521,7 @@ Build a searchable knowledge base from interactions:
                 "tags": knowledge.get("tags", []),
                 "created": datetime.now().isoformat()
             }
-        })
+        }])
         
         return response.json({"status": "learned", "fact": knowledge["fact"]})
     
@@ -739,13 +738,12 @@ Implement automated cleanup to manage costs:
             if result.exists:
                 convo = await result.data.json()
                 
-                # Archive to object storage
+                # Archive to object storage (auto-detects JSON content type)
                 archive_key = f"archives/{session_id}/{cutoff_date.isoformat()}.json"
                 await context.objectstore.put(
                     "archives",
                     archive_key,
-                    json.dumps(convo),
-                    {"contentType": "application/json"}
+                    json.dumps(convo)
                 )
                 
                 # Delete from KV
@@ -878,7 +876,7 @@ async def run(request, response, context):
         
         # Store this interaction
         interaction_key = f"{user_id}_{datetime.now().timestamp()}"
-        await context.vector.upsert("support_history", {
+        await context.vector.upsert("support_history", [{
             "key": interaction_key,
             "document": message,
             "metadata": {
@@ -887,7 +885,7 @@ async def run(request, response, context):
                 "order_id": data.get("order_id"),
                 "resolved": False
             }
-        })
+        }])
         
         # Add to profile issues
         profile["issues"].append({
diff --git a/content/Training/developers/04-agent-collaboration.mdx b/content/Training/developers/04-agent-collaboration.mdx
new file mode 100644
index 00000000..1a677179
--- /dev/null
+++ b/content/Training/developers/04-agent-collaboration.mdx
@@ -0,0 +1,849 @@
+---
+title: "Module 4: Agent-to-Agent Collaboration"
+description: Building multi-agent systems that work together
+---
+
+So far, we've built single agents that can reason, act, and remember. But what if one agent can't do everything? What if you need specialized expertise, parallel processing, or simply want to break down complex problems into manageable pieces?
+
+Welcome to the world of multi-agent systems.
+
+## Why Multi-Agent Systems?
+
+According to industry research, multi-agent architectures are becoming the standard for production AI systems. As [Microsoft's Build 2025 announcement](https://blogs.microsoft.com/blog/2025/05/19/microsoft-build-2025-the-age-of-ai-agents-and-building-the-open-agentic-web/) highlighted, the future is about agents working together in an "open agentic web."
+
+Think about how human organizations work:
+- **Specialization**: Different people excel at different tasks
+- **Scalability**: Teams can handle more work than individuals
+- **Reliability**: If one person is unavailable, others can step in
+- **Modularity**: Easy to add new team members with specific skills
+
+The same principles apply to agent systems.
+
+## Core Concepts of Agent Collaboration
+
+### 1. Agent Communication Patterns
+
+There are three primary ways agents can work together:
+
+#### Sequential (Chain)
+One agent completes its task and passes the result to the next:
+```
+User → Research Agent → Summarizer Agent → Response
+```
+
+#### Parallel (Fan-out/Fan-in)
+Multiple agents work simultaneously on different parts:
+```
+           ┌→ Web Search Agent →┐
+User → Coordinator →→ Database Agent →→ Aggregator → Response
+           └→ File Agent →┘
+```
+
+#### Conditional (Router)
+Agents are selected based on the task:
+```
+User → Router → [Math Agent | Language Agent | Code Agent] → Response
+```
+
+### 2. The Handoff Mechanism
+
+In Agentuity, agents communicate using the `handoff` method. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
+
+<CodeExample py={`async def run(request, response, context):
+    # Receive a research request
+    task = await request.data.json()
+    
+    # Decide we need help from the web search agent
+    if task.get("type") == "web_research":
+        # Hand off to the web search specialist
+        return response.handoff(
+            {"name": "web-search"},  # Target agent
+            {"query": task.get("query")},  # Data to pass
+            {"original_task": task}  # Metadata
+        )
+    
+    # Handle other task types...
+    return response.json({"result": "Task completed"})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Receive a research request
+  const task = await request.data.json();
+  
+  // Decide we need help from the web search agent
+  if (task.type === 'web_research') {
+    // Hand off to the web search specialist
+    return response.handoff(
+      { name: 'web-search' }, // Target agent
+      {
+        data: JSON.stringify({ query: task.query }), // Data as string/buffer
+        contentType: 'application/json',
+        metadata: { original_task: task } // Metadata object
+      }
+    );
+  }
+  
+  // Handle other task types...
+  return response.json({ result: 'Task completed' });
+};`} />
+
+### 3. Agent Resolution
+
+Agents can find each other using either:
+- **Name**: Human-readable identifier (e.g., "web-search")
+- **ID**: Unique system identifier (e.g., "agent_abc123")
+
+The context object knows about all agents in your project:
+
+<CodeExample py={`async def run(request, response, context):
+    # List all available agents
+    available_agents = context.agents
+    context.logger.info(f"Available agents: {[a.name for a in available_agents]}")
+    
+    # Check if a specific agent exists
+    if any(agent.name == "summarizer" for agent in context.agents):
+        # Agent exists, we can safely hand off
+        return response.handoff(
+            {"name": "summarizer"},
+            {"text": "Long article to summarize..."}  # Data to pass
+        )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // List all available agents
+  const availableAgents = context.agents;
+  context.logger.info(\`Available agents: \${availableAgents.map(a => a.name)}\`);
+  
+  // Check if a specific agent exists
+  if (availableAgents.some(agent => agent.name === 'summarizer')) {
+    // Agent exists, we can safely hand off
+    return response.handoff(
+      { name: 'summarizer' },
+      {
+        data: JSON.stringify({ text: 'Long article to summarize...' }),
+        contentType: 'application/json'
+      }
+    );
+  }
+};`} />
+
+## Building a Research Team
+
+Let's build a simple research system with three specialized agents working together.
+
+### The Coordinator Agent
+
+This agent receives research requests and delegates to specialists:
+
+<CodeExample py={`async def run(request, response, context):
+    """Research coordinator that delegates to specialist agents."""
+    
+    research_request = await request.data.json()
+    query = research_request.get("query", "")
+    
+    context.logger.info(f"Coordinating research for: {query}")
+    
+    # Step 1: Gather information from web search
+    search_result = await response.handoff(
+        {"name": "web-search"},
+        {"query": query, "max_results": 3}  # Data to pass
+    )
+    
+    # Note: In reality, the handoff returns immediately.
+    # For this example, imagine we're showing the flow.
+    # The web-search agent's response will go back to the user.
+    
+    # For a complete flow, you'd need to structure it differently:
+    # Option 1: Have web-search call summarizer
+    # Option 2: Use a workflow orchestrator
+    # Option 3: Have the client make sequential calls
+    
+    return search_result`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Research coordinator that delegates to specialist agents
+  
+  const researchRequest = await request.data.json();
+  const query = researchRequest.query || '';
+  
+  context.logger.info(\`Coordinating research for: \${query}\`);
+  
+  // Step 1: Gather information from web search
+  const searchResult = await response.handoff(
+    { name: 'web-search' },
+    {
+      data: JSON.stringify({ query, max_results: 3 }),
+      contentType: 'application/json'
+    }
+  );
+  
+  // Note: In reality, the handoff returns immediately.
+  // For this example, imagine we're showing the flow.
+  // The web-search agent's response will go back to the user.
+  
+  return searchResult;
+};`} />
+
+### The Web Search Agent
+
+A specialist that searches the web and returns results:
+
+<CodeExample py={`async def run(request, response, context):
+    """Specialist agent for web searches."""
+    
+    search_params = await request.data.json()
+    query = search_params.get("query")
+    max_results = search_params.get("max_results", 5)
+    
+    context.logger.info(f"Searching web for: {query}")
+    
+    # Simulate web search (in production, use actual search API)
+    search_results = [
+        {
+            "title": f"Result {i+1} for {query}",
+            "snippet": f"This is a relevant snippet about {query}...",
+            "url": f"https://example.com/{i+1}"
+        }
+        for i in range(max_results)
+    ]
+    
+    # Now hand off to summarizer to create a coherent summary
+    return response.handoff(
+        {"name": "summarizer"},
+        {
+            "content": search_results,
+            "original_query": query
+        },  # Data to pass
+        {"source": "web-search"}  # Metadata
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Specialist agent for web searches
+  
+  const searchParams = await request.data.json();
+  const query = searchParams.query;
+  const maxResults = searchParams.max_results || 5;
+  
+  context.logger.info(\`Searching web for: \${query}\`);
+  
+  // Simulate web search (in production, use actual search API)
+  const searchResults = Array.from({ length: maxResults }, (_, i) => ({
+    title: \`Result \${i + 1} for \${query}\`,
+    snippet: \`This is a relevant snippet about \${query}....\`,
+    url: \`https://example.com/\${i + 1}\`
+  }));
+  
+  // Now hand off to summarizer to create a coherent summary
+  return response.handoff(
+    { name: 'summarizer' },
+    {
+      data: JSON.stringify({
+        content: searchResults,
+        original_query: query
+      }),
+      contentType: 'application/json',
+      metadata: { source: 'web-search' }
+    }
+  );
+};`} />
+
+### The Summarizer Agent
+
+Takes search results and creates a concise summary:
+
+<CodeExample py={`async def run(request, response, context):
+    """Specialist agent for summarizing content."""
+    
+    summary_request = await request.data.json()
+    content = summary_request.get("content", [])
+    original_query = summary_request.get("original_query", "")
+    
+    context.logger.info(f"Summarizing {len(content)} items")
+    
+    # Create a summary from the search results
+    summary_parts = []
+    for item in content:
+        if isinstance(item, dict):
+            title = item.get("title", "")
+            snippet = item.get("snippet", "")
+            summary_parts.append(f"• {title}: {snippet}")
+    
+    final_summary = {
+        "query": original_query,
+        "summary": f"Here's what I found about '{original_query}':\\n\\n" + 
+                   "\\n".join(summary_parts),
+        "source_count": len(content),
+        "timestamp": datetime.now().isoformat()
+    }
+    
+    # Return the final summary to the user
+    return response.json(final_summary)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Specialist agent for summarizing content
+  
+  const summaryRequest = await request.data.json();
+  const content = summaryRequest.content || [];
+  const originalQuery = summaryRequest.original_query || '';
+  
+  context.logger.info(\`Summarizing \${content.length} items\`);
+  
+  // Create a summary from the search results
+  const summaryParts = content.map(item => {
+    if (typeof item === 'object') {
+      const title = item.title || '';
+      const snippet = item.snippet || '';
+      return \`• \${title}: \${snippet}\`;
+    }
+    return '';
+  }).filter(Boolean);
+  
+  const finalSummary = {
+    query: originalQuery,
+    summary: \`Here's what I found about '\${originalQuery}':\\n\\n\${summaryParts.join('\\n')}\`,
+    source_count: content.length,
+    timestamp: new Date().toISOString()
+  };
+  
+  // Return the final summary to the user
+  return response.json(finalSummary);
+};`} />
+
+## Orchestration Patterns: Industry vs. Agentuity
+
+### The Industry Challenge
+
+According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring LangGraph or custom orchestrators.
+
+### Agentuity's Approach: Simple Handoffs
+
+While other platforms build complex orchestration layers, Agentuity takes a different approach: **the handoff mechanism**. It's simpler, but with clear trade-offs:
+
+- **What it does**: Transfers control from one agent to another (like call forwarding)
+- **What it doesn't do**: Parallel execution, getting responses back, complex coordination
+- **Why it works**: Most real-world agent workflows are actually sequential or conditional
+
+## Patterns That Work with Agentuity's Handoff
+
+### 1. Sequential Chain Pattern
+
+Perfect for pipelines where each agent completes its work and passes to the next:
+
+<CodeExample py={`async def run(request, response, context):
+    """Pipeline pattern: Each agent enriches the data."""
+    
+    data = await request.data.json()
+    step = data.get("step", 1)
+    
+    if step == 1:
+        # First agent: Clean the data
+        data["cleaned"] = True
+        data["step"] = 2
+        return response.handoff({"name": "processor"}, data)
+    
+    elif step == 2:
+        # Second agent: Enrich the data
+        data["enriched"] = True
+        data["step"] = 3
+        return response.handoff({"name": "validator"}, data)
+    
+    elif step == 3:
+        # Final agent: Validate and return
+        data["validated"] = True
+        return response.json(data)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Pipeline pattern: Each agent enriches the data
+  
+  const data = await request.data.json();
+  const step = data.step || 1;
+  
+  if (step === 1) {
+    // First agent: Clean the data
+    data.cleaned = true;
+    data.step = 2;
+    return response.handoff({ name: 'processor' }, { data: JSON.stringify(data), contentType: 'application/json' });
+  
+  } else if (step === 2) {
+    // Second agent: Enrich the data
+    data.enriched = true;
+    data.step = 3;
+    return response.handoff({ name: 'validator' }, { data: JSON.stringify(data), contentType: 'application/json' });
+  
+  } else if (step === 3) {
+    // Final agent: Validate and return
+    data.validated = true;
+    return response.json(data);
+  }
+};`} />
+
+### 2. Conditional Routing Pattern
+
+Route to different agents based on the request type - ideal for dispatcher/router agents:
+
+<CodeExample py={`async def run(request, response, context):
+    """Router pattern: Direct to appropriate specialist."""
+    
+    task = await request.data.json()
+    task_type = task.get("type", "").lower()
+    
+    # Route based on task type
+    agent_map = {
+        "math": "calculator-agent",
+        "translation": "translator-agent",
+        "search": "web-search",
+        "summary": "summarizer"
+    }
+    
+    target_agent = agent_map.get(task_type)
+    
+    if target_agent:
+        context.logger.info(f"Routing {task_type} task to {target_agent}")
+        return response.handoff(
+            {"name": target_agent},
+            task.get("payload", {})  # Pass payload directly as data
+        )
+    
+    # Unknown task type
+    return response.json({
+        "error": f"Unknown task type: {task_type}",
+        "available_types": list(agent_map.keys())
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Router pattern: Direct to appropriate specialist
+  
+  const task = await request.data.json();
+  const taskType = (task.type || '').toLowerCase();
+  
+  // Route based on task type
+  const agentMap = {
+    math: 'calculator-agent',
+    translation: 'translator-agent',
+    search: 'web-search',
+    summary: 'summarizer'
+  };
+  
+  const targetAgent = agentMap[taskType];
+  
+  if (targetAgent) {
+    context.logger.info(\`Routing \${taskType} task to \${targetAgent}\`);
+    return response.handoff(
+      { name: targetAgent },
+      { 
+        data: JSON.stringify(task.payload || {}),
+        contentType: 'application/json'
+      }
+    );
+  }
+  
+  // Unknown task type
+  return response.json({
+    error: \`Unknown task type: \${taskType}\`,
+    available_types: Object.keys(agentMap)
+  });
+};`} />
+
+### 3. Delegation Pattern (Agentuity-Specific)
+
+A main agent handles most work but delegates specialized tasks. Remember: the delegated agent's response goes to the client, not back to the delegator:
+
+<CodeExample py={`async def run(request, response, context):
+    """Main agent that delegates when needed."""
+    
+    task = await request.data.json()
+    
+    # Handle most tasks directly
+    if task.get("type") in ["simple", "standard"]:
+        result = process_locally(task)
+        return response.json(result)
+    
+    # Delegate complex tasks
+    if task.get("type") == "complex":
+        # Note: We won't get the response back
+        # The specialist will respond directly to client
+        return response.handoff(
+            {"name": "specialist-agent"},
+            task
+        )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Main agent that delegates when needed
+  
+  const task = await request.data.json();
+  
+  // Handle most tasks directly
+  if (['simple', 'standard'].includes(task.type)) {
+    const result = processLocally(task);
+    return response.json(result);
+  }
+  
+  // Delegate complex tasks
+  if (task.type === 'complex') {
+    // Note: We won't get the response back
+    // The specialist will respond directly to client
+    return response.handoff(
+      { name: 'specialist-agent' },
+      { 
+        data: JSON.stringify(task),
+        contentType: 'application/json'
+      }
+    );
+  }
+};`} />
+
+### 4. Request-Response Pattern  
+
+Understanding that handoff is a one-way transfer is crucial. The final agent in the chain responds to the original client:
+
+```
+Client Request → Agent A → (handoff) → Agent B → Response to Client
+                    ↓
+                 (exits)
+```
+
+This is different from traditional RPC where Agent A would wait for Agent B's response.
+
+## Agentuity-Specific Best Practices
+
+### 1. Working with Agent Resolution
+
+Agentuity provides built-in agent discovery within your project:
+
+<CodeExample py={`async def run(request, response, context):
+    # List all agents in your project
+    available_agents = context.agents
+    agent_names = [agent.name for agent in available_agents]
+    context.logger.info(f"Available agents: {agent_names}")
+    
+    # Check if an agent exists before handoff
+    target_name = "specialist-agent"
+    if any(agent.name == target_name for agent in context.agents):
+        return response.handoff({"name": target_name}, data)
+    else:
+        return response.json({
+            "error": f"Agent '{target_name}' not found",
+            "available": agent_names
+        })
+    
+    # You can also use agent IDs for more precise targeting
+    # return response.handoff({"id": "agent_abc123"}, data)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // List all agents in your project
+  const availableAgents = context.agents;
+  const agentNames = availableAgents.map(a => a.name);
+  context.logger.info(\`Available agents: \${agentNames}\`);
+  
+  // Check if an agent exists before handoff
+  const targetName = 'specialist-agent';
+  if (availableAgents.some(agent => agent.name === targetName)) {
+    return response.handoff(
+      { name: targetName },
+      { data: JSON.stringify(data), contentType: 'application/json' }
+    );
+  } else {
+    return response.json({
+      error: \`Agent '\${targetName}' not found\`,
+      available: agentNames
+    });
+  }
+  
+  // You can also use agent IDs for more precise targeting
+  // return response.handoff({ id: 'agent_abc123' }, args);
+};`} />
+
+### 2. Understanding Handoff Limitations
+
+Agentuity's handoff has built-in safety features and constraints:
+
+<CodeExample py={`async def run(request, response, context):
+    # CONSTRAINT 1: Can't handoff to yourself (loop detection)
+    # This will raise an error:
+    # return response.handoff({"name": context.agent.name}, data)
+    
+    # CONSTRAINT 2: Handoff is one-way (no response back)
+    # Wrong expectation:
+    # result = await response.handoff({"name": "helper"}, data)  # NO!
+    # Right approach:
+    return response.handoff({"name": "helper"}, data)  # Helper responds to client
+    
+    # CONSTRAINT 3: Only see agents in your project
+    # Agents are isolated by project for security
+    
+    # FEATURE: Metadata persists through handoffs
+    metadata = request.metadata or {}
+    metadata["chain"] = metadata.get("chain", []) + [context.agent.name]
+    return response.handoff(
+        {"name": "next-agent"},
+        data,
+        metadata  # Pass context forward
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // CONSTRAINT 1: Can't handoff to yourself (loop detection)
+  // This will raise an error:
+  // return response.handoff({ name: context.agent.name }, args);
+  
+  // CONSTRAINT 2: Handoff is one-way (no response back)
+  // Wrong expectation:
+  // const result = await response.handoff({ name: 'helper' }, args); // NO!
+  // Right approach:
+  return response.handoff({ name: 'helper' }, args); // Helper responds to client
+  
+  // CONSTRAINT 3: Only see agents in your project
+  // Agents are isolated by project for security
+  
+  // FEATURE: Metadata persists through handoffs
+  const metadata = request.metadata || {};
+  metadata.chain = (metadata.chain || []).concat(context.agent.name);
+  return response.handoff(
+    { name: 'next-agent' },
+    { 
+      data: JSON.stringify(data),
+      contentType: 'application/json',
+      metadata  // Pass context forward
+    }
+  );
+};`} />
+
+### 3. Leveraging Agentuity's Built-in Features
+
+Agentuity provides powerful built-in features for multi-agent systems:
+
+<CodeExample py={`async def run(request, response, context):
+    # Use context.sessionId for automatic request tracking
+    context.logger.info(f"Processing request {context.sessionId} in {context.agent.name}")
+    
+    # Built-in OpenTelemetry tracing (automatic spans)
+    # Each handoff creates a new span in the trace
+    
+    # Use agent metadata for debugging
+    context.logger.debug(f"Agent ID: {context.agent.id}")
+    context.logger.debug(f"Project ID: {context.projectId}")
+    
+    # Track the chain of agents
+    metadata = request.metadata or {}
+    agent_chain = metadata.get("agent_chain", [])
+    agent_chain.append(context.agent.name)
+    
+    # Log the full chain for debugging
+    context.logger.info(f"Agent chain: {' -> '.join(agent_chain)}")
+    
+    return response.handoff(
+        {"name": "next-agent"},
+        processed_data,
+        {"agent_chain": agent_chain, "original_session_id": context.sessionId}
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Use context.sessionId for automatic request tracking
+  context.logger.info(\`Processing request \${context.sessionId} in \${context.agent.name}\`);
+  
+  // Built-in OpenTelemetry tracing (automatic spans)
+  // Each handoff creates a new span in the trace
+  
+  // Use agent metadata for debugging
+  context.logger.debug(\`Agent ID: \${context.agent.id}\`);
+  context.logger.debug(\`Project ID: \${context.projectId}\`);
+  
+  // Track the chain of agents
+  const metadata = request.metadata || {};
+  const agentChain = metadata.agent_chain || [];
+  agentChain.push(context.agent.name);
+  
+  // Log the full chain for debugging
+  context.logger.info(\`Agent chain: \${agentChain.join(' -> ')}\`);
+  
+  return response.handoff(
+    { name: 'next-agent' },
+    {
+      data: JSON.stringify(processedData),
+      contentType: 'application/json',
+      metadata: { agent_chain: agentChain, original_session_id: context.sessionId }
+    }
+  );
+};`} />
+
+## Lab: Build a Document Processing Pipeline
+
+Create a three-agent system that processes documents:
+
+1. **intake-agent**: Receives documents and validates format
+2. **analyzer-agent**: Extracts key information
+3. **storage-agent**: Stores processed results
+
+<CodeExample py={`# Intake Agent
+async def run(request, response, context):
+    """Validate and route incoming documents."""
+    
+    document = await request.data.json()
+    
+    # Validate document format
+    if not document.get("content"):
+        return response.json({"error": "Missing document content"})
+    
+    if not document.get("type") in ["pdf", "text", "html"]:
+        return response.json({"error": "Unsupported document type"})
+    
+    # Add processing metadata
+    document["received_at"] = datetime.now().isoformat()
+    document["intake_agent"] = context.agent.name
+    
+    # Pass to analyzer
+    return response.handoff(
+        {"name": "analyzer-agent"},
+        document  # Pass document as data
+    )
+
+# Analyzer Agent  
+async def run(request, response, context):
+    """Extract key information from documents."""
+    
+    document = await request.data.json()
+    content = document.get("content", "")
+    
+    # Simple analysis (in production, use NLP/LLM)
+    analysis = {
+        "word_count": len(content.split()),
+        "char_count": len(content),
+        "has_numbers": any(c.isdigit() for c in content),
+        "document_type": document.get("type"),
+        "analyzed_at": datetime.now().isoformat()
+    }
+    
+    # Combine with original document
+    document["analysis"] = analysis
+    
+    # Pass to storage
+    return response.handoff(
+        {"name": "storage-agent"},
+        document  # Pass document as data
+    )
+
+# Storage Agent
+async def run(request, response, context):
+    """Store processed documents."""
+    
+    document = await request.data.json()
+    
+    # Generate unique ID
+    doc_id = f"doc_{context.sessionId}"
+    
+    # Store in KV
+    await context.kv.set(
+        "processed_documents",
+        doc_id,
+        document
+    )
+    
+    # Return confirmation
+    return response.json({
+        "status": "success",
+        "document_id": doc_id,
+        "processed_by": [
+            document.get("intake_agent"),
+            "analyzer-agent",
+            "storage-agent"
+        ],
+        "stored_at": datetime.now().isoformat()
+    })`} js={`// Intake Agent
+const intakeHandler: AgentHandler = async (request, response, context) => {
+  // Validate and route incoming documents
+  
+  const document = await request.data.json();
+  
+  // Validate document format
+  if (!document.content) {
+    return response.json({ error: 'Missing document content' });
+  }
+  
+  if (!['pdf', 'text', 'html'].includes(document.type)) {
+    return response.json({ error: 'Unsupported document type' });
+  }
+  
+  // Add processing metadata
+  document.received_at = new Date().toISOString();
+  document.intake_agent = context.agent.name;
+  
+  // Pass to analyzer
+  return response.handoff(
+    { name: 'analyzer-agent' },
+    { 
+      data: JSON.stringify(document),
+      contentType: 'application/json'
+    }
+  );
+};
+
+// Analyzer Agent
+const analyzerHandler: AgentHandler = async (request, response, context) => {
+  // Extract key information from documents
+  
+  const document = await request.data.json();
+  const content = document.content || '';
+  
+  // Simple analysis (in production, use NLP/LLM)
+  const analysis = {
+    word_count: content.split(' ').length,
+    char_count: content.length,
+    has_numbers: /\d/.test(content),
+    document_type: document.type,
+    analyzed_at: new Date().toISOString()
+  };
+  
+  // Combine with original document
+  document.analysis = analysis;
+  
+  // Pass to storage
+  return response.handoff(
+    { name: 'storage-agent' },
+    { 
+      data: JSON.stringify(document),
+      contentType: 'application/json'
+    }
+  );
+};
+
+// Storage Agent
+const storageHandler: AgentHandler = async (request, response, context) => {
+  // Store processed documents
+  
+  const document = await request.data.json();
+  
+  // Generate unique ID
+  const docId = \`doc_\${context.sessionId}\`;
+  
+  // Store in KV
+  await context.kv.set(
+    'processed_documents',
+    docId,
+    JSON.stringify(document)
+  );
+  
+  // Return confirmation
+  return response.json({
+    status: 'success',
+    document_id: docId,
+    processed_by: [
+      document.intake_agent,
+      'analyzer-agent',
+      'storage-agent'
+    ],
+    stored_at: new Date().toISOString()
+  });
+};`} />
+
+## Testing Your Multi-Agent System
+
+Test the document processing pipeline:
+
+```bash
+# Test with a sample document
+curl -X POST https://your-project.agentuity.com/intake-agent \
+  -H "Content-Type: application/json" \
+  -d '{
+    "type": "text",
+    "content": "This is a test document with some numbers 12345."
+  }'
+```
+
+Expected flow:
+1. `intake-agent` validates and adds metadata
+2. `analyzer-agent` extracts information
+3. `storage-agent` saves and returns confirmation
+
+## Key Takeaways
+
+- **Multi-agent systems** enable specialization, scalability, and modularity
+- **Handoff mechanism** allows agents to delegate tasks to other agents
+- **Orchestration patterns** include sequential, parallel, and conditional routing
+- **Best practices** include loop prevention, error handling, and request tracing
+- **Agentuity makes it simple** with built-in agent resolution and communication
+
+## What's Next?
+
+Now that you can build multi-agent systems, Module 5 will cover **Guardrails & Observability** - how to ensure your agent teams behave safely and predictably in production.
+
+Questions to consider:
+- How do you prevent agents from taking harmful actions?
+- How do you track what decisions agents are making?
+- How do you ensure compliance and audit requirements?
+
+Continue to [Module 5: Guardrails & Observability →](./05-guardrails-observability)
\ No newline at end of file
diff --git a/content/Training/developers/05-guardrails-evals-observability.mdx b/content/Training/developers/05-guardrails-evals-observability.mdx
new file mode 100644
index 00000000..78e55b69
--- /dev/null
+++ b/content/Training/developers/05-guardrails-evals-observability.mdx
@@ -0,0 +1,1006 @@
+---
+title: "Module 5: Guardrails, Evals & Observability"
+description: Making agents reliable, safe, and production-ready
+---
+
+You've built agents that can think, remember, and collaborate. Now it's time to make them production-ready.
+
+## The Reality of Production Agents
+
+Research from NeurIPS 2024 reveals that most AI agents succeed only [30-40% of the time on complex tasks](https://neurips.cc/virtual/2024/panel/agent-systems). When [Salesforce automated 50% of their support cases](https://www.sfchronicle.com/tech/article/salesforce-ai-job-cuts-benioff-21025920.php), the implementation challenges led to significant organizational restructuring. The gap between demo and production? Proper guardrails, systematic evaluation, and comprehensive observability.
+
+According to [NIST's Generative AI Risk Management framework](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.1270e2025.pdf), the primary operational risks in AI systems include:
+- **Hallucination**: Agents generating plausible but incorrect information
+- **Prompt Injection**: Adversarial inputs manipulating agent behavior
+- **Resource Consumption**: Uncontrolled usage leading to excessive costs
+- **Compliance Drift**: Agents violating domain-specific regulations
+
+## The Three Pillars of Production Agents
+
+<Callout type="info">
+Agentuity provides built-in OpenTelemetry integration with automatic instrumentation through Traceloop SDK, giving you comprehensive observability out of the box.
+</Callout>
+
+### 1. Guardrails: Setting Boundaries
+
+Guardrails prevent agents from harmful actions while preserving autonomy:
+
+- **Input Validation**: Schema enforcement, content filtering, size limits
+- **Rate Limiting**: Prevent abuse and control costs per user/session  
+- **Security**: Prompt injection defense ([WASP](https://arxiv.org/abs/2407.01593)), tool permissions
+- **Domain Rules**: Compliance checks, output validation, custom constraints
+
+### 2. Evaluation: Measuring Success
+
+Systematic evaluation is critical for non-deterministic agents:
+
+- **Industry Benchmarks**: [SWE-Bench](https://www.swebench.com/) (~20% success), [BrowserGym](https://browsergym.ai), [AgentHarm](https://arxiv.org/abs/2407.01564)
+- **Automated Testing**: Unit tests, integration tests, golden datasets
+- **Production Metrics**: Success rates, latency, cost per request
+- **A/B Testing**: Shadow deployments, gradual rollouts
+
+### 3. Observability: Seeing Everything
+
+Agentuity provides automatic OpenTelemetry integration with Traceloop SDK:
+
+- **What's Tracked**: LLM calls, tool invocations, storage operations, API calls
+- **Three Pillars**: Logs (events), Metrics (measurements), Traces (request flow)
+- **Console View**: Timeline visualization with color-coded spans
+
+## Implementing Guardrails
+
+Let's implement essential guardrails for a financial advisor agent:
+
+### 1. Schema Validation with Zod & Pydantic
+
+Runtime validation is critical for agents. TypeScript and Python types only exist at development time - at runtime, your data needs validation.
+
+For detailed API references, see the [Zod](https://zod.dev) and [Pydantic](https://docs.pydantic.dev/latest/) documentation.
+
+<CodeExample py={`from pydantic import BaseModel, Field, ValidationError, field_validator
+from typing import Optional
+
+class UserQuery(BaseModel):
+    query: str = Field(min_length=1, max_length=1000)
+    user_id: str  
+    portfolio_value: Optional[float] = Field(None, gt=0)
+
+async def run(request, response, context):
+    # 1. Validate structure
+    try:
+        raw_data = await request.data.json()
+        validated = UserQuery(**raw_data)
+    except ValidationError as e:
+        return response.json({
+            'error': 'Invalid request',
+            'details': e.errors()
+        })
+    
+    # 2. Apply domain rules separately
+    prohibited = ['insider', 'guaranteed']
+    if any(term in validated.query.lower() for term in prohibited):
+        return response.json({'error': 'Prohibited terms detected'})
+    
+    # 3. Process validated data
+    return await process_query(validated.query, validated.user_id)`} js={`import { z } from 'zod';
+
+// Define clean schema for structure
+const UserQuerySchema = z.object({
+  query: z.string().min(1).max(1000),
+  userId: z.string(),
+  portfolioValue: z.number().positive().optional()
+});
+
+// TypeScript type from schema
+type UserQuery = z.infer<typeof UserQuerySchema>;
+
+const handler = async (request, response, context) => {
+  // 1. Validate structure
+  const result = UserQuerySchema.safeParse(await request.data.json());
+  
+  if (!result.success) {
+    return response.json({
+      error: 'Invalid request',
+      details: result.error.issues
+    });
+  }
+  
+  // 2. Apply domain rules separately  
+  const prohibited = ['insider', 'guaranteed'];
+  if (prohibited.some(term => result.data.query.toLowerCase().includes(term))) {
+    return response.json({ error: 'Prohibited terms detected' });
+  }
+  
+  // 3. Process validated data
+  const { query, userId } = result.data;
+  return await processQuery(query, userId);
+};`} />
+
+<Callout type="info">
+**Key Pattern**: Separate validation from domain rules. Schemas validate structure, your specific rules come after.
+</Callout>
+
+#### Real-World Example: Validating External API Responses
+
+Here's how the AI News Digest agent validates Hacker News API responses:
+
+<CodeExample py={`from pydantic import BaseModel, ValidationError
+from typing import Optional, List
+
+# Schema for Hacker News story
+class HNStory(BaseModel):
+    id: int                      # Required by HN API
+    title: str                   # What we display
+    url: Optional[str] = None    # Available if needed
+
+# Schema for our digest data
+class DigestData(BaseModel):
+    summary: str
+    sources: List[str]
+    article_count: int
+    timestamp: str
+    source: str
+
+async def fetch_top_stories(ctx, count=5):
+    stories = []
+    story_ids = await fetch_story_ids()  # Get from HN API
+    
+    for story_id in story_ids[:count]:
+        raw_data = await fetch_story_data(story_id)
+        
+        # Validate with Pydantic
+        try:
+            story = HNStory(**raw_data)
+            stories.append(story.title)
+        except ValidationError as e:
+            ctx.logger.warn(f"Invalid story data for ID {story_id}: {e}")
+            continue  # Skip invalid stories
+    
+    return stories
+
+async def run(request, response, context):
+    # Fetch and validate stories
+    articles = await fetch_top_stories(context, 5)
+    
+    # Generate AI summary
+    summary = await generate_summary(articles)
+    
+    # Create and validate digest
+    try:
+        digest = DigestData(
+            summary=summary,
+            sources=articles,
+            article_count=len(articles),
+            timestamp=datetime.now().isoformat(),
+            source="Hacker News API"
+        )
+    except ValidationError as e:
+        context.logger.error(f"Digest validation failed: {e}")
+        return response.json({"error": "Failed to create digest"})
+    
+    # Store validated digest
+    await context.kv.set("digest", "latest", digest.model_dump())
+    
+    return response.json(digest.model_dump())`} js={`import { z } from 'zod';
+
+// Zod schemas for type-safe API responses
+const HNStorySchema = z.object({
+  id: z.number(),             // Required by HN API
+  title: z.string(),          // What we display
+  url: z.string().optional(), // Available if needed
+});
+
+const DigestDataSchema = z.object({
+  summary: z.string(),
+  sources: z.array(z.string()),
+  articleCount: z.number(),
+  timestamp: z.string(),
+  source: z.string(),
+});
+
+async function fetchTopStories(ctx, count = 5) {
+  const stories = [];
+  const storyIds = await fetchStoryIds(); // Get from HN API
+  
+  for (const id of storyIds.slice(0, count)) {
+    const rawData = await fetchStoryData(id);
+    
+    // Validate with Zod
+    const parseResult = HNStorySchema.safeParse(rawData);
+    if (parseResult.success) {
+      stories.push(parseResult.data.title);
+    } else {
+      ctx.logger.warn('Invalid story data for ID ' + id);
+      continue; // Skip invalid stories
+    }
+  }
+  
+  return stories;
+}
+
+const handler = async (request, response, context) => {
+  // Fetch and validate stories
+  const articles = await fetchTopStories(context, 5);
+  
+  // Generate AI summary
+  const summary = await generateSummary(articles);
+  
+  // Create and validate digest with Zod
+  const digestResult = DigestDataSchema.safeParse({
+    summary,
+    sources: articles,
+    articleCount: articles.length,
+    timestamp: new Date().toISOString(),
+    source: 'Hacker News API'
+  });
+  
+  if (!digestResult.success) {
+    context.logger.error('Digest validation failed', digestResult.error);
+    return response.json({ error: 'Failed to create digest' });
+  }
+  
+  // Store validated digest
+  await context.kv.set('digest', 'latest', digestResult.data);
+  
+  return response.json(digestResult.data);
+};`} />
+
+#### Using Schemas with AI-Generated Output
+
+Schemas ensure structured output from AI models:
+
+<CodeExample py={`from pydantic import BaseModel
+from typing import Literal
+from ai import generate_object
+from anthropic import anthropic
+
+class AgentIntent(BaseModel):
+    agent_type: Literal['support', 'sales', 'technical']
+    confidence: float  # 0.0 to 1.0
+
+async def run(request, response, context):
+    user_message = await request.data.text()
+    
+    # AI generates structured, validated output
+    intent = await generate_object(
+        model=anthropic("claude-3-7-sonnet"),
+        schema=AgentIntent,  # Pydantic ensures structure
+        prompt=user_message
+    )
+    
+    # intent.object is validated and typed
+    if intent.object.confidence > 0.8:
+        agent = await context.get_agent(name=intent.object.agent_type)
+        return await agent.run(request)`} js={`import { z } from 'zod';
+import { generateObject } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
+
+const IntentSchema = z.object({
+  agentType: z.enum(['support', 'sales', 'technical']),
+  confidence: z.number().min(0).max(1)
+});
+
+const handler = async (request, response, context) => {
+  const userMessage = await request.data.text();
+  
+  // AI generates structured, validated output
+  const intent = await generateObject({
+    model: anthropic('claude-3-7-sonnet'),
+    schema: IntentSchema,  // Zod ensures structure
+    prompt: userMessage
+  });
+  
+  // intent.object is validated and typed
+  if (intent.object.confidence > 0.8) {
+    const agent = await context.getAgent({ name: intent.object.agentType });
+    return await agent.run(request);
+  }
+};`} />
+
+<Callout type="info">
+See the complete [Conference Concierge implementation](https://github.com/agentuity/agent-AIEWF2025-concierge-template) for a production example of multi-agent routing with schema validation.
+</Callout>
+
+### 2. Rate Limiting
+
+Prevent abuse and control costs:
+
+<CodeExample py={`async def run(request, response, context):
+    user_id = request.metadata.get("user_id")
+    hour_key = f"rate_{user_id}_{datetime.now().hour}"
+    
+    # Check current usage
+    usage = await context.kv.get("rate_limits", hour_key)
+    count = await usage.data.json() if usage.exists else 0
+    
+    if count >= 100:  # 100 requests per hour
+        return response.json({
+            "error": "Rate limit exceeded",
+            "retry_after": 3600
+        })
+    
+    # Increment counter with TTL
+    await context.kv.set("rate_limits", hour_key, count + 1, {"ttl": 3600})
+    
+    # Process request
+    return await handle_request(request)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const userId = request.metadata.get('user_id');
+  const hourKey = 'rate_' + userId + '_' + new Date().getHours();
+  
+  // Check current usage
+  const usage = await context.kv.get('rate_limits', hourKey);
+  const count = usage.exists ? await usage.data.json() : 0;
+  
+  if (count >= 100) {  // 100 requests per hour
+    return response.json({
+      error: 'Rate limit exceeded',
+      retry_after: 3600
+    });
+  }
+  
+  // Increment counter with TTL
+  await context.kv.set('rate_limits', hourKey, count + 1, { ttl: 3600 });
+  
+  // Process request
+  return await handleRequest(request);
+};`} />
+
+### 3. Domain-Specific Rules
+
+Enforce rules specific to your use case:
+
+<CodeExample py={`async def run(request, response, context):
+    query = (await request.data.json()).get("query", "")
+    
+    # Prohibited terms check
+    prohibited = ["guaranteed returns", "risk-free", "insider"]
+    for term in prohibited:
+        if term in query.lower():
+            return response.json({
+                "error": "Cannot provide advice on prohibited topics",
+                "reason": f"Term '{term}' is not allowed"
+            })
+    
+    # Generate advice with mandatory disclaimer
+    advice = await generate_advice(query)
+    
+    return response.json({
+        "advice": advice,
+        "disclaimer": "This is not personalized financial advice."
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const { query } = await request.data.json();
+  
+  // Prohibited terms check
+  const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
+  for (const term of prohibited) {
+    if (query.toLowerCase().includes(term)) {
+      return response.json({
+        error: 'Cannot provide advice on prohibited topics',
+        reason: 'Term \'' + term + '\' is not allowed'
+      });
+    }
+  }
+  
+  // Generate advice with mandatory disclaimer
+  const advice = await generateAdvice(query);
+  
+  return response.json({
+    advice,
+    disclaimer: 'This is not personalized financial advice.'
+  });
+};`} />
+
+## Evaluation Strategies
+
+### Define Success Metrics
+
+Choose metrics that matter for your domain:
+
+| Metric | Example | How to Measure |
+|--------|---------|----------------|
+| **Accuracy** | Correct advice | Compare against test cases |
+| **Compliance** | No prohibited terms | Check output validation |
+| **Performance** | < 5s response | Track in telemetry |
+| **Cost** | < $0.10/request | Monitor token usage |
+
+### Build a Golden Dataset
+
+Create test cases that cover your critical scenarios:
+
+<CodeExample py={`# Golden dataset for testing
+test_cases = [
+    {
+        "id": "basic_401k",
+        "input": {"query": "What is a 401k?"},
+        "expected": {
+            "contains": ["retirement", "employer", "tax"],
+            "excludes": ["guaranteed returns"],
+            "has_disclaimer": True
+        }
+    },
+    {
+        "id": "prohibited_terms",
+        "input": {"query": "Give me guaranteed returns"},
+        "expected": {
+            "error": "Cannot advise on 'guaranteed returns'"
+        }
+    },
+    {
+        "id": "complex_question",
+        "input": {"query": "Should I max out my 401k or pay off debt?"},
+        "expected": {
+            "contains": ["consider", "interest rate", "match"],
+            "has_disclaimer": True
+        }
+    }
+]
+
+async def evaluate_agent(agent_handler, test_cases):
+    """Run evaluation suite and track success rate."""
+    results = []
+    
+    for test in test_cases:
+        # Run the agent
+        response = await agent_handler(test["input"])
+        
+        # Check expectations
+        passed = True
+        if "error" in test["expected"]:
+            passed = response.get("error") == test["expected"]["error"]
+        else:
+            content = response.get("advice", "").lower()
+            
+            # Check required terms
+            for term in test["expected"].get("contains", []):
+                if term not in content:
+                    passed = False
+                    break
+            
+            # Check prohibited terms
+            for term in test["expected"].get("excludes", []):
+                if term in content:
+                    passed = False
+                    break
+        
+        results.append({
+            "test_id": test["id"],
+            "passed": passed,
+            "response": response
+        })
+    
+    # Calculate success rate
+    success_rate = sum(1 for r in results if r["passed"]) / len(results)
+    return {"success_rate": success_rate, "results": results}`} js={`// Golden dataset for testing
+const testCases = [
+  {
+    id: 'basic_401k',
+    input: { query: 'What is a 401k?' },
+    expected: {
+      contains: ['retirement', 'employer', 'tax'],
+      excludes: ['guaranteed returns'],
+      hasDisclaimer: true
+    }
+  },
+  {
+    id: 'prohibited_terms',
+    input: { query: 'Give me guaranteed returns' },
+    expected: {
+      error: 'Cannot advise on guaranteed returns'
+    }
+  },
+  {
+    id: 'complex_question',
+    input: { query: 'Should I max out my 401k or pay off debt?' },
+    expected: {
+      contains: ['consider', 'interest rate', 'match'],
+      hasDisclaimer: true
+    }
+  }
+];
+
+async function evaluateAgent(agentHandler, testCases) {
+  const results = [];
+  
+  for (const test of testCases) {
+    // Run the agent
+    const response = await agentHandler(test.input);
+    
+    // Check expectations
+    let passed = true;
+    if (test.expected.error) {
+      passed = response.error === test.expected.error;
+    } else {
+      const content = (response.advice || '').toLowerCase();
+      
+      // Check required terms
+      for (const term of test.expected.contains || []) {
+        if (!content.includes(term)) {
+          passed = false;
+          break;
+        }
+      }
+      
+      // Check prohibited terms
+      for (const term of test.expected.excludes || []) {
+        if (content.includes(term)) {
+          passed = false;
+          break;
+        }
+      }
+    }
+    
+    results.push({
+      testId: test.id,
+      passed,
+      response
+    });
+  }
+  
+  // Calculate success rate
+  const successRate = results.filter(r => r.passed).length / results.length;
+  return { successRate, results };
+}`} />
+
+## Observability with OpenTelemetry
+
+Agentuity automatically tracks everything through OpenTelemetry:
+
+### What's Tracked (No Code Required)
+- **Agent executions**: Full request/response lifecycle
+- **LLM calls**: Prompts, completions, token usage, latency
+- **Storage operations**: KV gets/sets, vector searches
+- **API calls**: External HTTP requests
+
+View in the Agentuity console Sessions tab with color-coded timeline visualization.
+
+### Using the Logger
+
+<CodeExample py={`async def run(request, response, context):
+    # Logs appear in Sessions view with trace context
+    context.logger.info("Processing", {"user_id": user_id})
+    
+    try:
+        result = await process(data)
+        context.logger.info("Success", {"count": len(result)})
+    except Exception as e:
+        context.logger.error("Failed", {"error": str(e)})
+        raise`} js={`const handler = async (request, response, context) => {
+  // Logs appear in Sessions view with trace context
+  context.logger.info('Processing', { userId });
+  
+  try {
+    const result = await process(data);
+    context.logger.info('Success', { count: result.length });
+  } catch (error) {
+    context.logger.error('Failed', { error: error.message });
+    throw error;
+  }
+};`} />
+
+### Custom Spans for Your Own Operations
+
+Track important operations with custom spans to understand performance and debug issues:
+
+<CodeExample py={`from opentelemetry.trace import Status, StatusCode
+
+async def run(request, response, context):
+    # Create a span for the entire validation flow
+    async with context.tracer.start_as_current_span("validate-financial-query") as span:
+        # Add context about this operation
+        span.set_attribute("user.tier", "premium")
+        span.set_attribute("query.type", "retirement")
+        span.set_attribute("query.length", len(query))
+        
+        try:
+            # Track validation steps
+            span.add_event("validation-started")
+            
+            if has_prohibited_terms(query):
+                span.add_event("validation-failed", {"reason": "prohibited-terms"})
+                span.set_status(Status(StatusCode.ERROR, "Prohibited terms detected"))
+                return response.json({"error": "Invalid query"})
+            
+            span.add_event("validation-passed")
+            
+            # Track LLM call separately
+            async with context.tracer.start_as_current_span("generate-advice") as llm_span:
+                llm_span.set_attribute("model", "gpt-4")
+                advice = await generate_advice(query)
+                llm_span.set_attribute("response.tokens", count_tokens(advice))
+            
+            span.set_status(Status(StatusCode.OK))
+            return response.json({"advice": advice})
+            
+        except Exception as e:
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            raise`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+
+const handler = async (request, response, context) => {
+  // Create a span for the entire validation flow
+  return context.tracer.startActiveSpan('validate-financial-query', async (span) => {
+    // Add context about this operation
+    span.setAttribute('user.tier', 'premium');
+    span.setAttribute('query.type', 'retirement');
+    span.setAttribute('query.length', query.length);
+    
+    try {
+      // Track validation steps
+      span.addEvent('validation-started');
+      
+      if (hasProhibitedTerms(query)) {
+        span.addEvent('validation-failed', { reason: 'prohibited-terms' });
+        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited terms detected' });
+        return response.json({ error: 'Invalid query' });
+      }
+      
+      span.addEvent('validation-passed');
+      
+      // Track LLM call separately
+      const advice = await context.tracer.startActiveSpan('generate-advice', async (llmSpan) => {
+        llmSpan.setAttribute('model', 'gpt-4');
+        const result = await generateAdvice(query);
+        llmSpan.setAttribute('response.tokens', countTokens(result));
+        llmSpan.end();
+        return result;
+      });
+      
+      span.setStatus({ code: SpanStatusCode.OK });
+      return response.json({ advice });
+      
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+      throw error;
+    } finally {
+      span.end();
+    }
+  });
+};`} />
+
+### Performance Best Practices
+
+Follow these optimization patterns to ensure your agents run efficiently in production:
+
+| Strategy | Implementation |
+|----------|---------------|
+| **Cache expensive operations** | Store LLM responses in KV with TTL to avoid repeated calls |
+| **Use parallel operations** | `Promise.all()` (JS) or `asyncio.gather()` (Python) for concurrent tasks |
+| **Fail fast** | Validate inputs early to avoid unnecessary processing |
+| **Track token usage** | Add token counts as span attributes to monitor costs |
+| **Set meaningful attributes** | Include user tier, request type, and other context for filtering |
+
+### What You Get Out of the Box
+
+<Callout type="info">
+**Built-in Observability**: Agentuity provides automatic OpenTelemetry instrumentation with zero configuration required.
+</Callout>
+
+Everything is tracked automatically:
+- **LLM calls**: Model, tokens, latency, and responses
+- **Storage operations**: Every KV get/set, vector search, object store operation
+- **API calls**: External service interactions and latencies
+- **Custom spans**: Your business logic with meaningful attributes
+- **Visual debugging**: Color-coded timeline in the console shows execution flow
+
+<Callout type="info">
+See the [Agent Telemetry Guide](/Guides/agent-telemetry) for advanced tracing and custom spans.
+</Callout>
+
+## Lab: Production-Ready Financial Advisor
+
+Let's build a financial advisor progressively, adding production features step by step:
+
+### Step 1: Basic Validation
+
+<CodeExample py={`from pydantic import BaseModel, Field, ValidationError
+from typing import Optional
+
+# Simple schema for financial queries
+class FinancialQuery(BaseModel):
+    query: str = Field(min_length=1, max_length=500)
+    portfolio_value: Optional[float] = Field(None, gt=0)
+
+def welcome():
+    return {
+        "welcome": "Financial Advisor Agent",
+        "prompts": [
+            {"data": {"query": "What is a Roth IRA?"}, "contentType": "application/json"},
+            {"data": {"query": "How do I invest $50000?"}, "contentType": "application/json"}
+        ]
+    }
+
+async def run(request, response, context):
+    # Step 1: Validate input structure
+    try:
+        data = await request.data.json()
+        validated = FinancialQuery(**data)
+    except ValidationError as e:
+        context.logger.error("Invalid input", {"errors": e.errors()})
+        return response.json({"error": "Invalid request", "details": e.errors()})
+    
+    # Step 2: Apply domain rules
+    prohibited = ['guaranteed returns', 'risk-free', 'insider']
+    for term in prohibited:
+        if term in validated.query.lower():
+            context.logger.warning("Prohibited term", {"term": term})
+            return response.json({"error": f"Cannot advise on '{term}'"})
+    
+    # Step 3: Generate response
+    advice = await generate_financial_advice(validated.query, context)
+    
+    return response.json({
+        "advice": advice,
+        "disclaimer": "Not personalized financial advice."
+    })
+
+async def generate_financial_advice(query: str, context) -> str:
+    """Generate financial advice - mock implementation for demo."""
+    context.logger.info("Generating advice", {"query_preview": query[:50]})
+    
+    # Simple mock responses
+    advice_map = {
+        "roth ira": "A Roth IRA is a retirement account with tax-free withdrawals.",
+        "401k": "A 401(k) offers pre-tax contributions and employer matching.",
+        "invest": "Start with your risk tolerance and time horizon."
+    }
+    
+    query_lower = query.lower()
+    for key, advice in advice_map.items():
+        if key in query_lower:
+            return advice
+    
+    return "I can help with retirement accounts and investment strategies."`} js={`import { z } from 'zod';
+
+// Simple schema for financial queries
+const FinancialQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  portfolioValue: z.number().positive().optional()
+});
+
+const welcome = () => ({
+  welcome: 'Financial Advisor Agent',
+  prompts: [
+    { data: JSON.stringify({ query: 'What is a Roth IRA?' }), contentType: 'application/json' },
+    { data: JSON.stringify({ query: 'How do I invest $50000?' }), contentType: 'application/json' }
+  ]
+});
+
+const handler = async (request, response, context) => {
+  // Step 1: Validate input structure
+  const result = FinancialQuerySchema.safeParse(await request.data.json());
+  if (!result.success) {
+    context.logger.error('Invalid input', { errors: result.error.issues });
+    return response.json({ error: 'Invalid request', details: result.error.issues });
+  }
+  
+  const validated = result.data;
+  
+  // Step 2: Apply domain rules
+  const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
+  for (const term of prohibited) {
+    if (validated.query.toLowerCase().includes(term)) {
+      context.logger.warning('Prohibited term', { term });
+      return response.json({ error: 'Cannot advise on ' + term });
+    }
+  }
+  
+  // Step 3: Generate response
+  const advice = await generateFinancialAdvice(validated.query, context);
+  
+  return response.json({
+    advice,
+    disclaimer: 'Not personalized financial advice.'
+  });
+};
+
+async function generateFinancialAdvice(query, context) {
+  // Generate financial advice - mock implementation for demo
+  context.logger.info('Generating advice', { queryPreview: query.substring(0, 50) });
+  
+  // Simple mock responses
+  const adviceMap = {
+    'roth ira': 'A Roth IRA is a retirement account with tax-free withdrawals.',
+    '401k': 'A 401(k) offers pre-tax contributions and employer matching.',
+    'invest': 'Start with your risk tolerance and time horizon.'
+  };
+  
+  const queryLower = query.toLowerCase();
+  for (const [key, advice] of Object.entries(adviceMap)) {
+    if (queryLower.includes(key)) {
+      return advice;
+    }
+  }
+  
+  return 'I can help with retirement accounts and investment strategies.';
+}
+
+export default handler;
+export { welcome };`} />
+
+### Step 2: Add Rate Limiting
+
+Now enhance with rate limiting to prevent abuse:
+
+<CodeExample py={`# Add to the run function after validation:
+
+# Check rate limit
+user_id = request.metadata.get("user_id", "anonymous")
+hour_key = f"rate_{user_id}_{datetime.now().hour}"
+usage = await context.kv.get("rate_limits", hour_key)
+count = await usage.data.json() if usage.exists else 0
+
+if count >= 100:  # 100 requests per hour
+    return response.json({
+        "error": "Rate limit exceeded",
+        "retry_after": 3600
+    })
+
+await context.kv.set("rate_limits", hour_key, count + 1, {"ttl": 3600})`} js={`// Add to the handler after validation:
+
+// Check rate limit
+const userId = request.metadata.get('user_id') || 'anonymous';
+const hourKey = 'rate_' + userId + '_' + new Date().getHours();
+const usage = await context.kv.get('rate_limits', hourKey);
+const count = usage.exists ? await usage.data.json() : 0;
+
+if (count >= 100) {  // 100 requests per hour
+  return response.json({
+    error: 'Rate limit exceeded',
+    retry_after: 3600
+  });
+}
+
+await context.kv.set('rate_limits', hourKey, count + 1, { ttl: 3600 });`} />
+
+### Step 3: Add Observability
+
+Finally, add custom spans to track and debug your agent's performance:
+
+<CodeExample py={`from opentelemetry.trace import Status, StatusCode
+
+async def run(request, response, context):
+    # Create a span for the entire request
+    async with context.tracer.start_as_current_span("financial-advisor-request") as span:
+        user_id = request.metadata.get("user_id", "anonymous")
+        span.set_attribute("user.id", user_id)
+        span.set_attribute("request.type", "financial-advice")
+        
+        # Validation with span tracking
+        span.add_event("validation-started")
+        try:
+            data = await request.data.json()
+            validated = FinancialQuery(**data)
+            span.set_attribute("query.length", len(validated.query))
+        except ValidationError as e:
+            span.add_event("validation-failed", {"errors": str(e.errors())})
+            span.set_status(Status(StatusCode.ERROR, "Invalid input"))
+            context.logger.error("Invalid input", {"errors": e.errors()})
+            return response.json({"error": "Invalid request", "details": e.errors()})
+        
+        span.add_event("validation-passed")
+        
+        # Domain rules check with tracking
+        prohibited = ['guaranteed returns', 'risk-free', 'insider']
+        for term in prohibited:
+            if term in validated.query.lower():
+                span.add_event("compliance-violation", {"term": term})
+                span.set_status(Status(StatusCode.ERROR, f"Prohibited term: {term}"))
+                return response.json({"error": f"Cannot advise on '{term}'"})
+        
+        # Generate advice with nested span
+        async with context.tracer.start_as_current_span("generate-advice") as advice_span:
+            advice_span.set_attribute("query.type", detect_query_type(validated.query))
+            advice = await generate_financial_advice(validated.query, context)
+            advice_span.set_attribute("response.length", len(advice))
+        
+        span.add_event("response-generated")
+        span.set_status(Status(StatusCode.OK))
+        
+        return response.json({
+            "advice": advice,
+            "disclaimer": "Not personalized financial advice."
+        })`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+
+const handler = async (request, response, context) => {
+  // Create a span for the entire request
+  return context.tracer.startActiveSpan('financial-advisor-request', async (span) => {
+    const userId = request.metadata.get('user_id') || 'anonymous';
+    span.setAttribute('user.id', userId);
+    span.setAttribute('request.type', 'financial-advice');
+    
+    // Validation with span tracking
+    span.addEvent('validation-started');
+    const result = FinancialQuerySchema.safeParse(await request.data.json());
+    if (!result.success) {
+      span.addEvent('validation-failed', { errors: JSON.stringify(result.error.issues) });
+      span.setStatus({ code: SpanStatusCode.ERROR, message: 'Invalid input' });
+      context.logger.error('Invalid input', { errors: result.error.issues });
+      span.end();
+      return response.json({ error: 'Invalid request', details: result.error.issues });
+    }
+    
+    span.addEvent('validation-passed');
+    span.setAttribute('query.length', result.data.query.length);
+    
+    const validated = result.data;
+    
+    // Domain rules check with tracking
+    const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
+    for (const term of prohibited) {
+      if (validated.query.toLowerCase().includes(term)) {
+        span.addEvent('compliance-violation', { term });
+        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited term: ' + term });
+        span.end();
+        return response.json({ error: 'Cannot advise on ' + term });
+      }
+    }
+    
+    // Generate advice with nested span
+    const advice = await context.tracer.startActiveSpan('generate-advice', async (adviceSpan) => {
+      adviceSpan.setAttribute('query.type', detectQueryType(validated.query));
+      const result = await generateFinancialAdvice(validated.query, context);
+      adviceSpan.setAttribute('response.length', result.length);
+      adviceSpan.end();
+      return result;
+    });
+    
+    span.addEvent('response-generated');
+    span.setStatus({ code: SpanStatusCode.OK });
+    span.end();
+    
+    return response.json({
+      advice,
+      disclaimer: 'Not personalized financial advice.'
+    });
+  });
+};`} />
+
+### Common Validation Pitfalls
+
+Avoid these common mistakes when implementing validation:
+
+| Pitfall | Best Practice |
+|---------|--------------|
+| **Using deprecated validators** | Pydantic v2: Use `@field_validator`, not `@validator` |
+| **Throwing on invalid input** | Zod: Use `safeParse` by default, `parse` only when you want to throw |
+| **Mixing concerns** | Keep schemas for structure, domain rules separate |
+| **I/O in validators** | Never make API calls or database queries inside validators |
+| **Poor error messages** | Format validation errors in user-friendly ways before returning |
+
+### Testing Your Production Agent
+
+1. **Start DevMode:**
+```bash
+agentuity dev
+```
+
+2. **Test guardrails:**
+   - Try prompt injection attacks
+   - Exceed rate limits
+   - Request prohibited advice
+
+3. **Monitor observability:**
+   - Watch traces in real-time
+   - Track custom metrics
+   - Review logs for issues
+
+- **Guardrails prevent failures** - Input validation, rate limiting, and domain rules protect your agents
+- **Evaluation proves reliability** - Systematic testing with metrics that matter for your domain  
+- **Observability is automatic** - Agentuity provides OpenTelemetry integration with Traceloop for comprehensive monitoring
+- **The console shows everything** - Sessions view with color-coded timeline visualization
+- **Production readiness** requires all three pillars working together
+
+## What's Next?
+
+Now that your agents are production-ready, it's time to deploy them. In the next module, we'll explore Agentuity's deployment environments - from local development through staging to production.
+
+But first, experiment with the lab agent:
+- Test different guardrail scenarios
+- View the telemetry in the console
+- Try modifying the evaluation criteria
+- Add your own custom spans
+
+---
+
+**Ready for Module 6?** [Deployment Environments](./06-deployment-environments)
\ No newline at end of file
diff --git a/content/Training/developers/06-deployment-environments.mdx b/content/Training/developers/06-deployment-environments.mdx
new file mode 100644
index 00000000..cdd023ef
--- /dev/null
+++ b/content/Training/developers/06-deployment-environments.mdx
@@ -0,0 +1,247 @@
+---
+title: "Module 6: Deployment Environments"
+description: From local development to global production
+---
+
+You've built agents with memory, collaboration, and production-grade guardrails. Now let's deploy them properly.
+
+## The Reality of Enterprise Agent Deployment
+
+Research shows that [most organizations aren't "agent-ready"](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality) - they lack the infrastructure, processes, and understanding needed for production agents. When [Salesforce automated 50% of their support cases](https://www.sfchronicle.com/tech/article/salesforce-ai-job-cuts-benioff-21025920.php), it required massive organizational change alongside the technology.
+
+The challenge isn't just technical - it's operational:
+- How do you test non-deterministic agents?
+- How do you safely roll out changes that affect customer interactions?
+- How do you monitor agents that make autonomous decisions?
+- How do you handle failures gracefully when agents are unpredictable?
+
+## The Agentuity Environment Model
+
+Agentuity provides three distinct environments, each with specific purposes:
+
+### Development Environment
+**Where ideas become agents**
+
+Your local machine running DevMode:
+- Instant feedback with hot reload
+- Full debugging capabilities
+- Mock external services
+- Unlimited iterations
+- Direct file system access
+
+```bash
+# Start local development
+agentuity dev
+
+# Test with real-time changes
+# Edit → Save → Test immediately
+```
+
+### Staging Environment
+**Where agents prove themselves**
+
+<Callout type="info">
+**Coming Soon**: Dedicated staging environments with production-like infrastructure but isolated from real users.
+</Callout>
+
+Cloud deployment with test data:
+- Production infrastructure
+- Synthetic test data
+- Full observability
+- Performance testing
+- Integration testing
+
+```bash
+# Deploy to staging (coming soon)
+```
+
+### Production Environment
+**Where agents serve users**
+
+Full-scale deployment:
+- Auto-scaling infrastructure
+- Real user traffic
+- Complete monitoring
+- High availability
+- Disaster recovery
+
+```bash
+# Deploy to production
+agentuity deploy
+```
+
+## Environment Progression
+
+### Moving Through Environments
+
+Each environment serves as a gate to the next:
+
+| Stage | Purpose | Key Validation | Duration |
+|-------|---------|----------------|----------|
+| **Local Dev** | Build & iterate | Basic functionality | Hours to days |
+| **Staging** | Validate at scale | Performance, integration | Days to weeks |
+| **Production** | Serve users | Monitoring, optimization | Ongoing |
+
+### Environment Testing Matrix
+
+Each environment requires different testing focus:
+
+| Testing Aspect | Development | Staging | Production |
+|----------------|------------|---------|------------|
+| **Core Functionality** | Basic input/output validation | Load testing with concurrent users | Success rate metrics |
+| **Memory & State** | Memory operations work correctly | Memory cleanup under load | Response time percentiles |
+| **Error Handling** | Validation catches bad inputs | Rate limiting works correctly | Error rate trends |
+| **Observability** | Logs provide debugging info | Meaningful telemetry spans | Cost per request tracking |
+| **Integration** | Error messages are helpful | External service integration | User satisfaction signals |
+| **Resilience** | Basic error recovery | Failover and recovery testing | Incident response time |
+
+## Enterprise Deployment Options
+
+<Callout type="info">
+**Coming Soon**: Advanced deployment options for enterprise customers with specific compliance and security requirements.
+</Callout>
+
+### Private Cloud Deployments
+Deploy Agentuity infrastructure in your own cloud account. More information coming soon.
+
+### On-Premise Installations
+Run Agentuity entirely within your data center. More information coming soon.
+
+## Configuration Management
+
+### Environment-Specific Settings
+
+Different environments need different configurations:
+
+<CodeExample py={`# config.py
+import os
+
+class Config:
+    """Environment-specific configuration"""
+    
+    def __init__(self):
+        self.env = os.getenv("AGENTUITY_ENVIRONMENT", "development")
+        
+        # Environment-specific settings
+        if self.env == "development":
+            self.log_level = "DEBUG"
+            self.rate_limit = 1000  # Generous for testing
+            self.cache_ttl = 60  # Short for quick iterations
+        elif self.env == "staging":
+            self.log_level = "INFO"
+            self.rate_limit = 100
+            self.cache_ttl = 300
+        else:  # production
+            self.log_level = "WARNING"
+            self.rate_limit = 50
+            self.cache_ttl = 3600
+            
+        # Feature flags
+        self.enable_experimental = self.env != "production"
+        self.verbose_errors = self.env == "development"`} js={`// config.js
+class Config {
+  constructor() {
+    this.env = process.env.AGENTUITY_ENVIRONMENT || 'development';
+    
+    // Environment-specific settings
+    switch(this.env) {
+      case 'development':
+        this.logLevel = 'DEBUG';
+        this.rateLimit = 1000;  // Generous for testing
+        this.cacheTTL = 60;  // Short for quick iterations
+        break;
+      case 'staging':
+        this.logLevel = 'INFO';
+        this.rateLimit = 100;
+        this.cacheTTL = 300;
+        break;
+      default:  // production
+        this.logLevel = 'WARNING';
+        this.rateLimit = 50;
+        this.cacheTTL = 3600;
+    }
+    
+    // Feature flags
+    this.enableExperimental = this.env !== 'production';
+    this.verboseErrors = this.env === 'development';
+  }
+}
+
+export default new Config();`} />
+
+## Real-World Deployment Lessons
+
+### Enterprise Scale: Salesforce's Journey
+
+When Salesforce deployed agents to handle 50% of support cases, they learned:
+- **Gradual rollout is essential**: Started with 1% of tickets
+- **Human oversight needed initially**: Agents flagged uncertain responses
+- **Continuous improvement**: Daily model updates based on outcomes
+- **Organizational change**: Required retraining support staff
+
+### Financial Services: 100+ GenAI Applications
+
+[CB Insights reports over 100 GenAI applications in financial services](https://www.cbinsights.com/research/report/generative-ai-financial-services-applications-2025/). Banks deploying agents discovered:
+- **Compliance first**: Every response needs audit trails
+- **Failover critical**: Instant human handoff when needed
+- **Cost management**: Token limits per customer interaction
+- **Security paramount**: No customer data in prompts
+
+## Lab: Deploy Your Financial Advisor
+
+Let's deploy the financial advisor from Module 5:
+
+### Step 1: Prepare for Deployment
+
+```bash
+# Ensure all tests pass
+npm test  # or python -m pytest
+
+# Check environment variables
+agentuity config verify
+
+# Build for production
+agentuity build
+```
+
+### Step 2: Deploy to Production
+
+```bash
+# Deploy with confirmation
+agentuity deploy --confirm
+
+# Monitor deployment
+agentuity logs --follow
+
+# Check health
+agentuity status
+```
+
+### Step 3: Monitor in Production
+
+View your deployment in the Agentuity console:
+- Real-time metrics
+- Session traces
+- Error tracking
+- Cost analysis
+
+## What's Next?
+
+You now understand the deployment journey from local development to production. But how do you build complete, production-ready systems that combine everything you've learned?
+
+In the next module, we'll tackle the capstone project - building a full agent system that uses:
+- Memory and state management
+- Multi-agent collaboration
+- Production guardrails
+- Comprehensive observability
+- Proper deployment practices
+
+But first, experiment with deployment:
+- Deploy your agents to production
+- Monitor their performance
+- Try different configurations
+- Practice rollback procedures
+
+---
+
+**Ready for the Capstone?** [Module 7: Sandbox & Capstone Project](./07-sandbox-capstone)
\ No newline at end of file
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
new file mode 100644
index 00000000..619f0747
--- /dev/null
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -0,0 +1,389 @@
+---
+title: "Module 7: Sandbox & Capstone Project"
+description: Bringing it all together in a complete production system
+---
+
+Time to combine everything you've learned into a complete, production-ready agent system.
+
+## Coming Soon: Agentic Sandbox
+
+<Callout type="info">
+**Coming Q2 2025**: The Agentic Sandbox - an interactive environment where you can experiment with agents risk-free, test complex scenarios, and learn through hands-on exploration.
+</Callout>
+
+### What is the Agentic Sandbox?
+
+A safe, isolated environment for agent experimentation:
+- **Pre-configured scenarios**: Common agent patterns ready to explore
+- **Interactive debugging**: Step through agent decisions
+- **Instant reset**: Break things and start fresh
+- **Guided challenges**: Progressive exercises with hints
+
+### Sandbox Features (Coming Soon)
+
+- Mock data sources and APIs
+- Simulated user interactions
+- Time travel debugging
+- Performance profiling
+- Collaborative sessions
+
+## Coming Soon: Training Agent
+
+<Callout type="info">
+**Coming Q2 2025**: Your AI-powered learning companion that adapts to your progress, answers questions, and provides personalized guidance through the Agentuity platform.
+</Callout>
+
+### Your Personal Agent Instructor
+
+An intelligent assistant that helps you learn:
+- **Contextual help**: Understands what you're building
+- **Debugging assistance**: Helps identify and fix issues
+- **Learning paths**: Customized based on your experience
+- **Best practices**: Recommends patterns for your use case
+
+## Capstone Project: Customer Support System
+
+Let's build a complete customer support system that demonstrates mastery of all previous modules.
+
+### Project Overview
+
+**Goal**: Build a multi-agent customer support system that can:
+- Handle customer inquiries autonomously
+- Escalate complex issues appropriately
+- Learn from interactions
+- Maintain conversation context
+- Ensure compliance and safety
+
+### System Architecture
+
+<Mermaid chart="
+graph TD
+    User[Customer] --> Triage[Triage Agent]
+    Triage -->|FAQ/Tech/Billing| Specialist[Specialist Agent]
+    Triage -->|Urgent/Low Confidence| Human[Human Escalation]
+    Specialist --> User
+    Human --> User
+    Memory[(Memory)] -.-> Triage
+    Memory -.-> Specialist
+" />
+
+### Skills in Practice
+
+Building this multi-agent system demonstrates the key concepts covered in this training:
+
+| Module | Key Skills Applied |
+|--------|-------------------|
+| **Agent Basics** | Request/response handling, error management, welcome messages, trigger configuration |
+| **Agent Anatomy** | Lifecycle management, comprehensive logging, context usage, tool integration |
+| **Memory Management** | Conversation history, user preferences, session management, cleanup strategies |
+| **Multi-Agent Collaboration** | Routing logic, context sharing, smooth handoffs, information preservation |
+| **Production Readiness** | Input validation (Zod/Pydantic), rate limiting, observability spans, compliance rules |
+| **Deployment** | Environment configuration, production deployment, monitoring setup |
+
+### Phase 1: Triage Agent
+
+The entry point for all customer interactions:
+
+<CodeExample py={`from pydantic import BaseModel
+from typing import Literal
+from ai import generate_object
+from anthropic import anthropic
+
+class CustomerIntent(BaseModel):
+    category: Literal['faq', 'technical', 'billing', 'urgent']
+    confidence: float
+    summary: str
+    
+async def run(request, response, context):
+    # Track the conversation
+    async with context.tracer.start_as_current_span("triage-request") as span:
+        session_id = request.metadata.get("session_id")
+        span.set_attribute("session.id", session_id)
+        
+        # Get conversation history
+        history = await context.kv.get("conversations", session_id)
+        messages = history.data.json() if history.exists else []
+        
+        # Analyze customer intent
+        customer_message = await request.data.text()
+        messages.append({"role": "user", "content": customer_message})
+        
+        intent = await generate_object(
+            model=anthropic("claude-3-7-sonnet"),
+            schema=CustomerIntent,
+            prompt=f"""
+            Analyze this customer support request:
+            Message: {customer_message}
+            History: {messages[-5:]}  # Last 5 messages for context
+            
+            Categorize as: faq, technical, billing, or urgent
+            """
+        )
+        
+        span.set_attribute("intent.category", intent.object.category)
+        span.set_attribute("intent.confidence", intent.object.confidence)
+        
+        # Route to appropriate agent
+        if intent.object.confidence < 0.7 or intent.object.category == "urgent":
+            # Low confidence or urgent = human escalation
+            span.add_event("escalating-to-human")
+            return response.json({
+                "action": "escalate",
+                "message": "Connecting you with a human agent...",
+                "reason": intent.object.summary
+            })
+        
+        # Hand off to specialist agent
+        return response.handoff(
+            {"name": f"{intent.object.category}-agent"},
+            customer_message,  # Pass message as data
+            {
+                "session_id": session_id,
+                "intent": intent.object.model_dump(),
+                "conversation_history": messages[-5:]  # Include recent context
+            }
+        )`} js={`import { z } from 'zod';
+import { generateObject } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
+
+const CustomerIntentSchema = z.object({
+  category: z.enum(['faq', 'technical', 'billing', 'urgent']),
+  confidence: z.number().min(0).max(1),
+  summary: z.string()
+});
+
+const handler = async (request, response, context) => {
+  // Track the conversation
+  return context.tracer.startActiveSpan('triage-request', async (span) => {
+    const sessionId = request.metadata.get('session_id');
+    span.setAttribute('session.id', sessionId);
+    
+    // Get conversation history
+    const history = await context.kv.get('conversations', sessionId);
+    const messages = history.exists ? await history.data.json() : [];
+    
+    // Analyze customer intent
+    const customerMessage = await request.data.text();
+    messages.push({ role: 'user', content: customerMessage });
+    
+    const intent = await generateObject({
+      model: anthropic('claude-3-7-sonnet'),
+      schema: CustomerIntentSchema,
+      prompt: \`
+        Analyze this customer support request:
+        Message: \${customerMessage}
+        History: \${JSON.stringify(messages.slice(-5))}
+        
+        Categorize as: faq, technical, billing, or urgent
+      \`
+    });
+    
+    span.setAttribute('intent.category', intent.object.category);
+    span.setAttribute('intent.confidence', intent.object.confidence);
+    
+    // Route to appropriate agent
+    if (intent.object.confidence < 0.7 || intent.object.category === 'urgent') {
+      // Low confidence or urgent = human escalation
+      span.addEvent('escalating-to-human');
+      span.end();
+      return response.json({
+        action: 'escalate',
+        message: 'Connecting you with a human agent...',
+        reason: intent.object.summary
+      });
+    }
+    
+    // Hand off to specialist agent
+    span.end();
+    return response.handoff(
+      { name: intent.object.category + '-agent' },
+      {
+        data: customerMessage,
+        contentType: 'text/plain',
+        metadata: {
+          session_id: sessionId,
+          intent: intent.object,
+          conversation_history: messages.slice(-5)  // Include recent context
+        }
+      }
+    );
+  });
+};`} />
+
+### Phase 2: Specialist Agents
+
+Create specialized agents for each category:
+
+#### FAQ Agent
+- Answers common questions
+- Uses vector search for knowledge base
+- Tracks which questions are most frequent
+
+#### Technical Support Agent
+- Troubleshoots technical issues
+- Guides through diagnostic steps
+- Creates tickets for engineering
+
+#### Billing Agent
+- Handles payment questions
+- Looks up account information (mock)
+- Processes refund requests
+
+### Phase 3: Memory & Learning
+
+Implement sophisticated memory:
+
+```python
+# Store interaction outcomes
+await context.kv.set(
+    "outcomes",
+    f"{session_id}_{timestamp}",
+    {
+        "category": intent.category,
+        "resolved": was_resolved,
+        "escalated": was_escalated,
+        "satisfaction": customer_rating,
+        "agent_actions": actions_taken
+    },
+    {"ttl": 30 * 24 * 3600}  # Keep for 30 days
+)
+
+# Learn from patterns
+outcomes = await context.kv.list("outcomes", prefix=f"{user_id}_")
+if frequent_escalations(outcomes):
+    # Adjust confidence thresholds
+    # Flag for human review
+    pass
+```
+
+### Phase 4: Production Hardening
+
+Add all production features:
+
+#### Guardrails
+- PII detection and redaction
+- Compliance with support policies
+- Rate limiting per customer
+- Response length limits
+
+#### Observability
+- Custom spans for each decision point
+- Track resolution rates
+- Monitor escalation patterns
+- Cost per interaction
+
+#### Testing Suite
+```python
+# test_support_system.py
+test_cases = [
+    {
+        "input": "How do I reset my password?",
+        "expected_category": "faq",
+        "should_escalate": False
+    },
+    {
+        "input": "The app crashes when I click submit",
+        "expected_category": "technical",
+        "should_escalate": False
+    },
+    {
+        "input": "I was charged twice!!!",
+        "expected_category": "billing",
+        "confidence_threshold": 0.9  # Higher for financial
+    },
+    {
+        "input": "This is unacceptable! I demand a manager!",
+        "expected_category": "urgent",
+        "should_escalate": True
+    }
+]
+```
+
+### Phase 5: Deployment
+
+Deploy your complete system:
+
+```bash
+# Test locally
+agentuity dev
+
+# Run test suite
+npm test
+
+# Deploy to production
+agentuity deploy
+
+# Monitor performance
+agentuity logs --follow
+```
+
+## Alternative Capstone Projects
+
+Not interested in customer support? Choose an alternative:
+
+### Option 2: Research Assistant Team
+
+Build a multi-agent research system:
+- **Research Agent**: Finds relevant papers and articles
+- **Summarizer Agent**: Creates concise summaries
+- **Fact Checker**: Validates claims against sources
+- **Report Generator**: Produces final documents
+
+Key challenges:
+- Citation tracking
+- Source credibility scoring
+- Handling conflicting information
+- Long-form content generation
+
+### Option 3: DevOps Assistant
+
+Build an operations helper:
+- **Monitor Agent**: Watches system metrics
+- **Diagnostics Agent**: Analyzes problems
+- **Remediation Agent**: Suggests or implements fixes
+- **Reporting Agent**: Creates incident reports
+
+Key challenges:
+- Real-time data processing
+- Safe remediation actions
+- Alert fatigue prevention
+- Root cause analysis
+
+## Getting Help
+
+As you build your capstone:
+
+1. **Review previous modules** - Each contains pieces you'll need
+2. **Start simple** - Get basic flow working first
+3. **Iterate** - Add features incrementally
+4. **Test thoroughly** - Each agent independently, then together
+5. **Monitor everything** - You can't fix what you can't see
+
+<Callout type="info">
+Pro Tip: Build your capstone iteratively. Start with two agents (triage + one specialist), get that working perfectly, then add more complexity.
+</Callout>
+
+## Congratulations!
+
+By completing this capstone, you've demonstrated mastery of:
+- Agent architecture and design
+- Memory and state management
+- Multi-agent orchestration
+- Production deployment
+- Real-world problem solving
+
+You're now ready to build production agent systems with Agentuity!
+
+## What's Next?
+
+- Deploy your capstone to production
+- Share your implementation with the community
+- Explore advanced patterns
+- Build agents for your own use cases
+- Contribute to the Agentuity ecosystem
+
+Welcome to the future of agent development! 🚀
+
+---
+
+**Need help?** Join our [Discord community](https://discord.gg/agentuity) or check the [documentation](https://docs.agentuity.com)
\ No newline at end of file

From e13f57a6c692247978c4e8ba97b738fa93ca4f37 Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Tue, 16 Sep 2025 07:41:42 -0700
Subject: [PATCH 03/13] Update training content

---
 .../developers/01-introduction-to-agents.mdx  | 367 ++++---
 .../developers/02-anatomy-of-an-agent.mdx     | 825 ++++++++--------
 .../Training/developers/03-agent-memory.mdx   | 101 +-
 .../developers/04-agent-collaboration.mdx     | 917 ++++++++----------
 .../05-guardrails-evals-observability.mdx     | 114 ++-
 .../developers/06-deployment-environments.mdx | 121 +--
 .../developers/07-sandbox-capstone.mdx        |  89 +-
 7 files changed, 1212 insertions(+), 1322 deletions(-)

diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
index 3d197edb..43118e66 100644
--- a/content/Training/developers/01-introduction-to-agents.mdx
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -19,7 +19,6 @@ Traditional cloud platforms (AWS Lambda, Google Cloud Functions, Azure Functions
 - **5ms response times** (agents need minutes or hours to think)
 - **Stateless execution** (agents need persistent memory)
 - **Edge distribution** (agents need GPU proximity)
-- **Request-response patterns** (agents need continuous reasoning loops)
 
 ## What Exactly Is an AI Agent?
 
@@ -27,7 +26,7 @@ Traditional cloud platforms (AWS Lambda, Google Cloud Functions, Azure Functions
 For a comprehensive overview of agents and how they differ from traditional software, see our [What is an Agent?](/Guides/what-is-an-agent) guide.
 </Callout>
 
-An AI agent is not just another chatbot or API wrapper around an LLM. It's a fundamentally different type of software that combines:
+An AI agent is not just another chatbot or API wrapper around an LLM. It's a fundamentally different type of software that combines a LLM with **memory, tools, and a reasoning loop**.
 
 ### The Agent Formula
 ```
@@ -64,8 +63,7 @@ For deeper insights on this shift, read our [Agent Engineering](/Guides/agent-en
 
 Traditional software engineering is built on determinism - given the same input, you always get the same output. We write explicit logic for every scenario:
 
-```python
-# Traditional deterministic approach
+<CodeExample py={`# Traditional deterministic approach
 def process_customer_request(request_type, data):
     if request_type == "refund":
         if data["amount"] < 100:
@@ -74,28 +72,52 @@ def process_customer_request(request_type, data):
             return escalate_to_manager(data)
     elif request_type == "complaint":
         return create_ticket(data)
-    # ... hundreds more conditions
-```
+    # ... hundreds more conditions`} js={`// Traditional deterministic approach
+function processCustomerRequest(requestType, data) {
+  if (requestType === 'refund') {
+    if (data.amount < 100) {
+      return processRefund(data);
+    } else {
+      return escalateToManager(data);
+    }
+  } else if (requestType === 'complaint') {
+    return createTicket(data);
+  }
+  // ... hundreds more conditions
+}`} />
 
 Agent engineering embraces non-determinism - the agent interprets intent and figures out the best approach:
 
-```python
-# Agent-based approach
+<CodeExample py={`# Agent-based approach
 async def handle_customer_request(request, context):
     # Agent interprets the request
     intent = await analyze_intent(request)
-    
+
     # Agent decides on approach
     plan = await create_action_plan(intent, context.customer_history)
-    
+
     # Agent executes with available tools
     result = await execute_plan(plan, context.available_tools)
-    
+
     # Agent learns from outcome
     await update_knowledge(result, context.memory)
-    
-    return result
-```
+
+    return result`} js={`// Agent-based approach
+const handleCustomerRequest = async (request, context) => {
+  // Agent interprets the request
+  const intent = await analyzeIntent(request);
+
+  // Agent decides on approach
+  const plan = await createActionPlan(intent, context.customerHistory);
+
+  // Agent executes with available tools
+  const result = await executePlan(plan, context.availableTools);
+
+  // Agent learns from outcome
+  await updateKnowledge(result, context.memory);
+
+  return result;
+};`} />
 
 This shift requires a new mindset:
 - **Design for intent**, not implementation
@@ -119,7 +141,7 @@ Traditional cloud platforms face fundamental limitations when running agents:
 | Pay per request | Continuous operation | Costs explode unexpectedly |
 | Human-centric monitoring | Agent observability | Can't debug agent decisions |
 
-Major cloud providers are scrambling to adapt:
+Major cloud providers are pushing to adapt to the needs of agents:
 - **AWS** launched Bedrock AgentCore (still in preview)
 - **Google** released their Agent Development Kit (ADK)
 - **Microsoft** is retrofitting Azure with agent capabilities
@@ -132,7 +154,7 @@ But retrofitting existing infrastructure is like turning a highway into an airpo
 Learn more about the Agent-Native Cloud paradigm in our [Agent-Native Cloud](/Guides/agent-native-cloud) guide.
 </Callout>
 
-While others retrofit, Agentuity was built from day one specifically for agents. This isn't just marketing - it's a fundamental architectural difference.
+While others retrofit, Agentuity was built from day one specifically for agents. Our agent-native platform puts AI agents at the center of everything we do.
 
 ### Purpose-Built for Agents
 
@@ -140,7 +162,7 @@ Agentuity provides what agents actually need:
 
 - **Long-running processes**: Agents can think for hours, not seconds
 - **Persistent memory**: Built-in [key-value](/Guides/key-value), [vector](/Guides/vector-db), and [object storage](/Guides/object-storage)
-- **Agent-to-agent communication**: Secure, encrypted [channels between agents](/Guides/agent-communication)
+- **Agent-to-agent communication**: Seamless and secure [channels between agents](/Guides/agent-communication)
 - **Native observability**: Track agent decisions with [built-in tracing](/Guides/agent-tracing)
 - **Automatic scaling**: Based on agent workload, not request count
 - **Framework agnostic**: Run LangChain, CrewAI, or custom agents side by side
@@ -157,7 +179,7 @@ The result is a platform where:
 
 ## Your First Agent: Hello, Autonomous World
 
-Enough theory - let's build something. We'll create an agent that doesn't just respond to "hello" but actually thinks about how to greet you.
+Now that you have an understanding of what agents are and why they need specialized infrastructure, let's build your first agent.
 
 ### Prerequisites
 
@@ -206,96 +228,99 @@ pip install -r requirements.txt
 
 Here's a simple "Hello Agent" that demonstrates the core concepts:
 
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
-from datetime import datetime
+<CodeExample py={`async def run(request, response, context):
+    # Get the name from request data
+    data = await request.data.json()
+    name = data.get("name", "World")
+
+    # Return a simple greeting
+    return response.json({"message": f"Hello, {name}!"})`} js={`const handler = async (request, response, context) => {
+  // Get the name from request data
+  const data = await request.data.json();
+  const name = data.name || 'World';
+
+  // Return a simple greeting
+  return response.json({ message: \`Hello, \${name}!\` });
+};
+
+export default handler;`} />
+
+This simple agent demonstrates:
+- **Request handling**: Accepts JSON input with a `name` field
+- **Response generation**: Returns a personalized greeting
+- **Agentuity patterns**: Uses the standard request/response structure
+- **Agent-native infrastructure**: Runs on infrastructure built for agents
+
+### Adding Observability and State
+
+Let's enhance our agent with logging and a simple state counter:
+
+<CodeExample py={`from datetime import datetime
+
+async def run(request, response, context):
+    # Log the incoming request (built-in observability)
+    context.logger.info("Hello agent received a request")
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    """A simple agent that demonstrates basic concepts."""
-    
-    # Get the request data
+    # Get the name from request data
     data = await request.data.json()
     name = data.get("name", "World")
-    
-    # Log the request (built-in observability)
-    context.logger.info(f"Received greeting request for {name}")
-    
-    # Check if we've seen this user before (persistent memory)
-    visits_key = f"visits_{name}"
-    result = await context.kv.get("user-data", visits_key)
-    
-    if result.exists:
-        # Returning visitor
-        visit_count = await result.data.json()
-        visit_count["count"] += 1
-        greeting = f"Welcome back, {name}! This is visit #{visit_count['count']}"
-        
-        # Update the visit count
-        await context.kv.set("user-data", visits_key, visit_count)
+
+    # Simple counter using KV storage
+    counter_result = await context.kv.get("stats", "greeting_count")
+    if counter_result.exists:
+        count = await counter_result.data.json()
+        count += 1
     else:
-        # First-time visitor
-        greeting = f"Hello, {name}! Welcome to Agentuity."
-        
-        # Store first visit
-        await context.kv.set("user-data", visits_key, {
-            "count": 1,
-            "first_seen": datetime.now().isoformat()
-        })
-    
-    # Return the response
-    return response.json({
-        "message": greeting,
-        "timestamp": datetime.now().isoformat(),
-        "agent_info": "Running on Agentuity's agent-native infrastructure"
-    })`} js={`import { AgentHandler } from '@agentuity/sdk';
+        count = 1
 
-const handler: AgentHandler = async (request, response, context) => {
-  // Get the request data
+    # Update the counter
+    await context.kv.set("stats", "greeting_count", count)
+
+    context.logger.info(f"Greeting #{count} for {name}")
+
+    # Return a greeting with some stats
+    return response.json({
+        "message": f"Hello, {name}!",
+        "greeting_number": count,
+        "timestamp": datetime.now().isoformat()
+    })`} js={`const handler = async (request, response, context) => {
+  // Log the incoming request (built-in observability)
+  context.logger.info('Hello agent received a request');
+
+  // Get the name from request data
   const data = await request.data.json();
   const name = data.name || 'World';
-  
-  // Log the request (built-in observability)
-  context.logger.info(\`Received greeting request for \${name}\`);
-  
-  // Check if we've seen this user before (persistent memory)
-  const visitsKey = \`visits_\${name}\`;
-  const result = await context.kv.get('user-data', visitsKey);
-  
-  let greeting: string;
-  
-  if (result.exists) {
-    // Returning visitor
-    const visitCount = await result.data.json();
-    visitCount.count++;
-    greeting = \`Welcome back, \${name}! This is visit #\${visitCount.count}\`;
-    
-    // Update the visit count
-    await context.kv.set('user-data', visitsKey, JSON.stringify(visitCount));
+
+  // Simple counter using KV storage
+  const counterResult = await context.kv.get('stats', 'greeting_count');
+  let count;
+  if (counterResult.exists) {
+    count = await counterResult.data.json();
+    count++;
   } else {
-    // First-time visitor
-    greeting = \`Hello, \${name}! Welcome to Agentuity.\`;
-    
-    // Store first visit
-    await context.kv.set('user-data', visitsKey, JSON.stringify({
-      count: 1,
-      first_seen: new Date().toISOString()
-    }));
+    count = 1;
   }
-  
-  // Return the response
+
+  // Update the counter
+  await context.kv.set('stats', 'greeting_count', count);
+
+  context.logger.info(\`Greeting #\${count} for \${name}\`);
+
+  // Return a greeting with some stats
   return response.json({
-    message: greeting,
-    timestamp: new Date().toISOString(),
-    agent_info: "Running on Agentuity's agent-native infrastructure"
+    message: \`Hello, \${name}!\`,
+    greeting_number: count,
+    timestamp: new Date().toISOString()
   });
 };
 
 export default handler;`} />
 
-This simple agent demonstrates key concepts:
-- **Memory**: Uses key-value storage to remember visitors
-- **Logging**: Built-in observability with context.logger
-- **State Management**: Tracks visit counts persistently
-- **Request/Response**: Handles JSON input and output
+This enhanced agent demonstrates:
+- **Observability**: Built-in logging with context.logger
+- **State Management**: Simple counter using key-value storage
+- **Agent Memory**: One storage type (KV) without complexity
+- **Request/Response**: JSON input and structured output
 
 ### Testing Your Agent with DevMode
 
@@ -380,8 +405,10 @@ Now let's deploy this agent to production:
 # Deploy to Agentuity's agent-native infrastructure
 agentuity deploy
 
-# Your agent is now running at:
-# https://your-project.agentuity.com/agents/hello
+# Your deployment will show:
+# Deployment successful
+# Agent URL: https://[unique-id].agentuity.com
+# Dashboard: https://console.agentuity.com/projects/[project-id]
 ```
 
 That's it! Your agent is now:
@@ -394,34 +421,75 @@ That's it! Your agent is now:
 
 Now that you have a working agent, let's enhance it with more capabilities. Use DevMode to test each enhancement as you build it.
 
-### Challenge 1: Add Time-Based Context
-Modify your agent to greet differently based on the time of day:
+### Challenge 1: Add Error Handling
+Enhance your agent with proper error handling and validation:
+
+<CodeExample py={`async def run(request, response, context):
+    try:
+        data = await request.data.json()
+        name = data.get("name")
+
+        if not name:
+            context.logger.warn("No name provided in request")
+            return response.json({"error": "Name is required"})
+
+        context.logger.info(f"Processing request for {name}")
+
+        # Your agent logic here
+        return response.json({"message": f"Hello, {name}!"})
+
+    except Exception as e:
+        context.logger.error(f"Error processing request: {str(e)}")
+        return response.json({"error": "Internal server error"})`} js={`const handler = async (request, response, context) => {
+  try {
+    const data = await request.data.json();
+    const name = data.name;
+
+    if (!name) {
+      context.logger.warn('No name provided in request');
+      return response.json({ error: 'Name is required' });
+    }
+
+    context.logger.info(\`Processing request for \${name}\`);
+
+    // Your agent logic here
+    return response.json({ message: \`Hello, \${name}!\` });
+
+  } catch (error) {
+    context.logger.error(\`Error processing request: \${error}\`);
+    return response.json({ error: 'Internal server error' });
+  }
+};`} />
+
+### Challenge 2: Add Time-Based Context
+Enhance your agent to greet differently based on the time of day:
 
 <CodeExample py={`from datetime import datetime
 
 async def run(request, response, context):
     data = await request.data.json()
     name = data.get("name", "World")
-    
+
+    # Time-based greeting
     hour = datetime.now().hour
-    
     if hour < 12:
         time_greeting = "Good morning"
     elif hour < 17:
         time_greeting = "Good afternoon"
     else:
         time_greeting = "Good evening"
-    
+
+    # Include your existing counter logic here
     return response.json({
         "message": f"{time_greeting}, {name}!",
         "local_time": datetime.now().isoformat()
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+    })`} js={`const handler = async (request, response, context) => {
   const data = await request.data.json();
   const name = data.name || 'World';
-  
+
+  // Time-based greeting
   const hour = new Date().getHours();
-  let timeGreeting: string;
-  
+  let timeGreeting;
   if (hour < 12) {
     timeGreeting = 'Good morning';
   } else if (hour < 17) {
@@ -429,90 +497,16 @@ async def run(request, response, context):
   } else {
     timeGreeting = 'Good evening';
   }
-  
+
+  // Include your existing counter logic here
   return response.json({
     message: \`\${timeGreeting}, \${name}!\`,
     local_time: new Date().toISOString()
   });
 };`} />
 
-### Challenge 2: Track User Preferences
-Store and retrieve user preferences using key-value storage:
-
-<CodeExample py={`async def run(request, response, context):
-    data = await request.data.json()
-    user_id = data.get("userId")
-    action = data.get("action")
-    
-    if action == "set_preference":
-        preference = data.get("preference")
-        await context.kv.set("preferences", user_id, preference)
-        return response.json({"message": "Preference saved"})
-    
-    elif action == "get_preference":
-        result = await context.kv.get("preferences", user_id)
-        if result.exists:
-            pref = await result.data.json()
-            return response.json({"preference": pref})
-        return response.json({"message": "No preference found"})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const data = await request.data.json();
-  const userId = data.userId;
-  const action = data.action;
-  
-  if (action === 'set_preference') {
-    const preference = data.preference;
-    await context.kv.set('preferences', userId, JSON.stringify(preference));
-    return response.json({ message: 'Preference saved' });
-  
-  } else if (action === 'get_preference') {
-    const result = await context.kv.get('preferences', userId);
-    if (result.exists) {
-      const pref = await result.data.json();
-      return response.json({ preference: pref });
-    }
-    return response.json({ message: 'No preference found' });
-  }
-};`} />
-
-### Challenge 3: Add Logging and Error Handling
-Implement proper error handling and logging:
-
-<CodeExample py={`async def run(request, response, context):
-    try:
-        data = await request.data.json()
-        name = data.get("name")
-        
-        if not name:
-            context.logger.warn("No name provided in request")
-            return response.json({"error": "Name is required"})
-        
-        context.logger.info(f"Processing request for {name}")
-        
-        # Your agent logic here
-        return response.json({"message": f"Hello, {name}!"})
-        
-    except Exception as e:
-        context.logger.error(f"Error processing request: {str(e)}")
-        return response.json({"error": "Internal server error"})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  try {
-    const data = await request.data.json();
-    const name = data.name;
-    
-    if (!name) {
-      context.logger.warn('No name provided in request');
-      return response.json({ error: 'Name is required' });
-    }
-    
-    context.logger.info(\`Processing request for \${name}\`);
-    
-    // Your agent logic here
-    return response.json({ message: \`Hello, \${name}!\` });
-    
-  } catch (error) {
-    context.logger.error(\`Error processing request: \${error}\`);
-    return response.json({ error: 'Internal server error' });
-  }
-};`} />
+### Challenge 3: Combine Features
+Combine error handling, time-based greetings, and your counter into one robust agent.
 
 ### Testing Your Enhancements
 
@@ -541,11 +535,12 @@ You've just built and deployed your first agent on infrastructure designed speci
 
 But first, take a moment to experiment with your agent. Try:
 - Calling it with different names and at different times
-- Checking the logs in the Agentuity dashboard
-- Modifying the personality and responses
-- Adding more sophisticated memory patterns
+- Checking the logs in the DevMode interface
+- Calling it multiple times to see the counter increment
+- Testing error cases like missing names
+- Monitoring the key-value storage in the dashboard
 
-Remember: aside from just learning a new framework, you're learning a fundamentally new way to build software. Welcome to the age of agents!
+Remember: you're not just learning a new framework, you're learning a fundamentally new way to build software. Welcome to the age of agents!
 
 ---
 
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index 99704d74..d5aa0a49 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -11,12 +11,12 @@ Every agent interaction follows a predictable lifecycle, from receiving a trigge
 
 <Mermaid chart="
 graph TD
-    Trigger[Trigger Event] --> Request[Request Object]
-    Request --> Handler[Agent Handler]
-    Handler --> Context[Context & Storage]
-    Handler --> Process[Process Logic]
-    Process --> Response[Response Object]
-    Response --> Output[Return to Caller]
+    A[Trigger Event<br/>HTTP, Cron, Email, etc.] --> B[Parse Request<br/>Extract data and metadata]
+    B --> C[Agent Handler<br/>Your agent/run function executes]
+    C --> D[Process Logic<br/>Business logic and decisions]
+    D --> E[Access Storage<br/>KV, Vector, Object store]
+    E --> F[Generate Response<br/>JSON, text, binary, etc. or handoff to another agent]
+    F --> G[Return to Caller<br/>Client receives result]
 " />
 
 Let's explore each phase:
@@ -225,306 +225,159 @@ What separates agents from simple scripts is their ability to plan and reason. W
 
 ### The Planning Phase
 
-Planning involves breaking down a complex request into manageable steps:
+Planning is how agents break down complex requests into actionable steps. According to [OpenAI's practical guide to building agents](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf), providing smaller, clearer steps from dense resources helps minimize ambiguity and helps the model better follow instructions. Effective agent planning involves:
 
-<CodeExample py={`async def create_plan(request_data, context):
-    """Create an execution plan based on the request."""
-    
-    # Analyze what the user wants
-    intent = analyze_intent(request_data)
-    
-    # Break down into steps
-    steps = []
-    
-    if intent == "research":
-        steps.append({"action": "search", "params": request_data["query"]})
-        steps.append({"action": "summarize", "params": "search_results"})
-        steps.append({"action": "format", "params": "summary"})
-    
-    elif intent == "process_data":
-        steps.append({"action": "validate", "params": request_data["data"]})
-        steps.append({"action": "transform", "params": "validated_data"})
-        steps.append({"action": "store", "params": "transformed_data"})
-    
-    context.logger.info(f"Created plan with {len(steps)} steps")
-    return steps
+1. **Intent Recognition**: Understanding what the user actually wants
+2. **Task Decomposition**: Breaking complex requests into smaller steps
+3. **Resource Assessment**: Determining what tools and data are needed
+4. **Execution Strategy**: Deciding the order and approach for each step
 
-async def run(request, response, context):
-    data = await request.data.json()
-    
-    # Create a plan
-    plan = await create_plan(data, context)
-    
-    # Execute the plan
-    results = []
-    for step in plan:
-        context.logger.info(f"Executing: {step['action']}")
-        result = await execute_step(step, context)
-        results.append(result)
-    
-    return response.json({"plan": plan, "results": results})`} js={`async function createPlan(requestData: any, context: any) {
-  // Analyze what the user wants
-  const intent = analyzeIntent(requestData);
-  
-  // Break down into steps
-  const steps = [];
-  
-  if (intent === 'research') {
-    steps.push({ action: 'search', params: requestData.query });
-    steps.push({ action: 'summarize', params: 'search_results' });
-    steps.push({ action: 'format', params: 'summary' });
-  
-  } else if (intent === 'process_data') {
-    steps.push({ action: 'validate', params: requestData.data });
-    steps.push({ action: 'transform', params: 'validated_data' });
-    steps.push({ action: 'store', params: 'transformed_data' });
-  }
-  
-  context.logger.info(\`Created plan with \${steps.length} steps\`);
-  return steps;
-}
-
-const handler: AgentHandler = async (request, response, context) => {
-  const data = await request.data.json();
-  
-  // Create a plan
-  const plan = await createPlan(data, context);
-  
-  // Execute the plan
-  const results = [];
-  for (const step of plan) {
-    context.logger.info(\`Executing: \${step.action}\`);
-    const result = await executeStep(step, context);
-    results.push(result);
-  }
-  
-  return response.json({ plan, results });
-};`} />
+Modern agents use LLMs for dynamic planning rather than hard-coded decision trees, allowing them to adapt their approach based on context and available resources.
 
 ### The Reasoning Loop
 
-The reasoning loop is where agents adapt based on results:
+The reasoning loop is where agents continuously evaluate and adapt their approach. [Stanford's research on ReAct agents](https://arxiv.org/abs/2210.03629) shows that combining reasoning and acting in iterative loops significantly improves agent performance.
 
-<CodeExample py={`async def reasoning_loop(goal, context, max_iterations=5):
-    """Execute a reasoning loop until the goal is achieved."""
-    
-    iteration = 0
-    achieved = False
-    history = []
-    
-    while iteration < max_iterations and not achieved:
-        context.logger.info(f"Reasoning iteration {iteration + 1}")
-        
-        # Plan the next action
-        action = await plan_next_action(goal, history, context)
-        
-        # Execute the action
-        result = await execute_action(action, context)
-        
-        # Observe the result
-        observation = await observe_result(result, goal, context)
-        
-        # Store in history
-        history.append({
-            "action": action,
-            "result": result,
-            "observation": observation
-        })
-        
-        # Check if goal is achieved
-        achieved = observation.get("goal_achieved", False)
-        
-        # Adapt if needed
-        if not achieved and observation.get("needs_adjustment"):
-            goal = await adjust_goal(goal, observation, context)
-        
-        iteration += 1
-    
-    return {
-        "achieved": achieved,
-        "iterations": iteration,
-        "history": history
-    }`} js={`async function reasoningLoop(goal: any, context: any, maxIterations = 5) {
-  let iteration = 0;
-  let achieved = false;
-  const history = [];
-  
-  while (iteration < maxIterations && !achieved) {
-    context.logger.info(\`Reasoning iteration \${iteration + 1}\`);
-    
-    // Plan the next action
-    const action = await planNextAction(goal, history, context);
-    
-    // Execute the action
-    const result = await executeAction(action, context);
-    
-    // Observe the result
-    const observation = await observeResult(result, goal, context);
-    
-    // Store in history
-    history.push({
-      action,
-      result,
-      observation
-    });
-    
-    // Check if goal is achieved
-    achieved = observation.goal_achieved || false;
-    
-    // Adapt if needed
-    if (!achieved && observation.needs_adjustment) {
-      goal = await adjustGoal(goal, observation, context);
-    }
-    
-    iteration++;
-  }
-  
-  return {
-    achieved,
-    iterations: iteration,
-    history
-  };
-}`} />
+The basic pattern follows:
+1. **Observe**: Analyze current state and available information
+2. **Think**: Reason about the best next action
+3. **Act**: Execute the chosen action
+4. **Reflect**: Evaluate the results and learn
+5. **Repeat**: Continue until goal is achieved or constraints are met
+
+This iterative approach allows agents to handle uncertainty and recover from errors - key capabilities that distinguish agents from simple scripts.
 
 ## Tool Invocation: Extending Agent Capabilities
 
-Agents become powerful when they can use tools. Tools can be APIs, databases, or even other agents:
+Agents become powerful when they can use external tools and services:
 
 <CodeExample py={`import httpx
+import os
 from typing import Dict, Any
 
-class AgentTools:
-    """Collection of tools available to the agent."""
-    
-    @staticmethod
-    async def web_search(query: str) -> Dict[str, Any]:
-        """Search the web for information."""
+async def use_web_search(query: str, context) -> Dict[str, Any]:
+    """Search the web using a real API."""
+    try:
+        # Example using a hypothetical search API
+        api_key = os.getenv("SEARCH_API_KEY")
+        if not api_key:
+            context.logger.warn("No search API key found")
+            return {"error": "Search not available"}
+
         async with httpx.AsyncClient() as client:
             response = await client.get(
-                "https://api.search.com/v1/search",
-                params={"q": query}
+                "https://api.searxng.org/search",
+                params={"q": query, "format": "json"}
             )
             return response.json()
-    
-    @staticmethod
-    async def calculate(expression: str) -> float:
-        """Perform mathematical calculations."""
-        # Safe evaluation of math expressions
-        import ast
-        import operator as op
-        
-        ops = {
-            ast.Add: op.add,
-            ast.Sub: op.sub,
-            ast.Mult: op.mul,
-            ast.Div: op.truediv,
-        }
-        
-        def eval_expr(expr):
-            return eval(compile(ast.parse(expr, mode='eval'), '', 'eval'))
-        
-        return eval_expr(expression)
-    
-    @staticmethod
-    async def send_email(to: str, subject: str, body: str) -> bool:
-        """Send an email."""
-        # Email sending logic
-        return True
+    except Exception as e:
+        context.logger.error(f"Search failed: {str(e)}")
+        return {"error": "Search failed"}
+
+async def call_another_agent(agent_name: str, data: dict, context) -> Dict[str, Any]:
+    """Call another agent within the same project."""
+    try:
+        agent = await context.getAgent({"name": agent_name})
+        result = await agent.run({
+            "data": data,
+            "contentType": "application/json"
+        })
+        return await result.data.json()
+    except Exception as e:
+        context.logger.error(f"Agent call failed: {str(e)}")
+        return {"error": "Agent call failed"}
 
 async def run(request, response, context):
     data = await request.data.json()
-    action = data.get("action")
-    
-    tools = AgentTools()
-    
-    if action == "research":
-        # Use web search tool
-        results = await tools.web_search(data["query"])
-        return response.json({"search_results": results})
-    
-    elif action == "calculate":
-        # Use calculator tool
-        result = await tools.calculate(data["expression"])
-        return response.json({"result": result})
-    
-    elif action == "notify":
-        # Use email tool
-        sent = await tools.send_email(
-            data["email"],
-            data["subject"],
-            data["message"]
-        )
-        return response.json({"sent": sent})`} js={`import axios from 'axios';
-
-class AgentTools {
-  static async webSearch(query: string) {
-    const response = await axios.get('https://api.search.com/v1/search', {
-      params: { q: query }
-    });
-    return response.data;
-  }
-  
-  static async calculate(expression: string): Promise<number> {
-    // Use a safe math evaluation library
-    // This is a simplified example
-    return eval(expression); // In production, use a safe math parser
+    tool = data.get("tool")
+
+    if tool == "search":
+        result = await use_web_search(data["query"], context)
+    elif tool == "delegate":
+        result = await call_another_agent(data["agent"], data["task"], context)
+    else:
+        result = {"error": "Unknown tool"}
+
+    return response.json(result)`} js={`async function useWebSearch(query: string, context: any): Promise<any> {
+  try {
+    // Example using a hypothetical search API
+    const apiKey = process.env.SEARCH_API_KEY;
+    if (!apiKey) {
+      context.logger.warn('No search API key found');
+      return { error: 'Search not available' };
+    }
+
+    const response = await fetch('https://api.searxng.org/search?' +
+      new URLSearchParams({ q: query, format: 'json' }));
+    return await response.json();
+  } catch (error) {
+    context.logger.error(\`Search failed: \${error}\`);
+    return { error: 'Search failed' };
   }
-  
-  static async sendEmail(to: string, subject: string, body: string): Promise<boolean> {
-    // Email sending logic
-    return true;
+}
+
+async function callAnotherAgent(agentName: string, data: any, context: any): Promise<any> {
+  try {
+    const agent = await context.getAgent({ name: agentName });
+    const result = await agent.run({
+      data,
+      contentType: 'application/json'
+    });
+    return await result.data.json();
+  } catch (error) {
+    context.logger.error(\`Agent call failed: \${error}\`);
+    return { error: 'Agent call failed' };
   }
 }
 
 const handler: AgentHandler = async (request, response, context) => {
   const data = await request.data.json();
-  const action = data.action;
-  
-  if (action === 'research') {
-    // Use web search tool
-    const results = await AgentTools.webSearch(data.query);
-    return response.json({ search_results: results });
-  
-  } else if (action === 'calculate') {
-    // Use calculator tool
-    const result = await AgentTools.calculate(data.expression);
-    return response.json({ result });
-  
-  } else if (action === 'notify') {
-    // Use email tool
-    const sent = await AgentTools.sendEmail(
-      data.email,
-      data.subject,
-      data.message
-    );
-    return response.json({ sent });
+  const tool = data.tool;
+
+  let result;
+  if (tool === 'search') {
+    result = await useWebSearch(data.query, context);
+  } else if (tool === 'delegate') {
+    result = await callAnotherAgent(data.agent, data.task, context);
+  } else {
+    result = { error: 'Unknown tool' };
   }
+
+  return response.json(result);
 };`} />
 
-## Memory Updates: Learning and Persistence
+## Memory Patterns: How Agents Remember
 
-Memory is what allows agents to learn and improve over time. Agentuity provides three types of memory storage:
+Memory enables agents to learn and maintain state across interactions. The duration and type of memory depends on your use case and TTL settings.
 
-### Short-term Memory (Key-Value)
-For session data, cache, and temporary state:
+### Session Memory
+For temporary data that should expire:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from datetime import datetime
+
+async def run(request, response, context):
     session_id = request.metadata.get("session_id")
-    
-    # Store conversation context
+
+    # Store temporary session data with TTL
     await context.kv.set(
         "sessions",
         session_id,
         {
             "messages": [],
-            "context": {},
-            "timestamp": datetime.now().isoformat()
+            "user_preferences": {},
+            "started_at": datetime.now().isoformat()
         },
         {"ttl": 3600}  # Expires in 1 hour
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+    )
+
+    # Retrieve session data
+    session_data = await context.kv.get("sessions", session_id)
+    if session_data.exists:
+        data = await session_data.data.json()
+        context.logger.info(f"Session active for {len(data['messages'])} messages")`} js={`const handler: AgentHandler = async (request, response, context) => {
   const sessionId = request.metadata.get('session_id');
-  
-  // Store conversation context
+
+  // Store temporary session data with TTL
   await context.kv.set(
     'sessions',
     sessionId,
@@ -537,42 +390,104 @@ For session data, cache, and temporary state:
   );
 };`} />
 
-### Long-term Memory (Vector Storage)
-For knowledge base and semantic search:
+### Persistent Memory
+For data that should survive restarts:
 
 <CodeExample py={`async def run(request, response, context):
-    # Store learned information
-    await context.vector.upsert("knowledge", {
-        "key": "fact_001",
-        "document": "Users prefer concise responses",
+    user_id = request.metadata.get("user_id")
+
+    # Store user preferences permanently (no TTL)
+    await context.kv.set(
+        "user_profiles",
+        user_id,
+        {
+            "name": "Alice",
+            "preferences": {"format": "concise"},
+            "created_at": datetime.now().isoformat()
+        }
+        # No TTL = permanent storage
+    )
+
+    # Store large files in object storage
+    await context.objectstore.put(
+        "user_documents",
+        f"{user_id}/resume.pdf",
+        pdf_bytes
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  const userId = request.metadata.get('user_id');
+
+  // Store user preferences permanently (no TTL)
+  await context.kv.set(
+    'user_profiles',
+    userId,
+    {
+      name: 'Alice',
+      preferences: { format: 'concise' },
+      created_at: new Date().toISOString()
+    }
+    // No TTL = permanent storage
+  );
+
+  // Store large files in object storage
+  await context.objectstore.put(
+    'user_documents',
+    \`\${userId}/resume.pdf\`,
+    pdfBytes
+  );
+};`} />
+
+### Searchable Memory
+For semantic search and knowledge retrieval:
+
+<CodeExample py={`async def run(request, response, context):
+    # Store searchable knowledge
+    await context.vector.upsert("knowledge", [{
+        "key": "user_feedback_001",
+        "document": "Users prefer concise responses with examples",
         "metadata": {
             "learned_from": "user_feedback",
-            "confidence": 0.85
+            "confidence": 0.85,
+            "category": "response_style"
         }
-    })
-    
-    # Retrieve relevant knowledge
+    }])
+
+    # Search for relevant knowledge
     results = await context.vector.search(
         "knowledge",
-        "How should I format responses?",
-        limit=5,
-        similarity=0.7
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Store learned information
-  await context.vector.upsert('knowledge', {
-    key: 'fact_001',
-    document: 'Users prefer concise responses',
+        "How should I format my responses?",
+        limit=5
+    )
+
+    # Use the knowledge to improve responses
+    if results:
+        context.logger.info(f"Found {len(results)} relevant insights")
+        for result in results:
+            context.logger.info(f"Insight: {result.document}")`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Store searchable knowledge
+  await context.vector.upsert('knowledge', [{
+    key: 'user_feedback_001',
+    document: 'Users prefer concise responses with examples',
     metadata: {
       learned_from: 'user_feedback',
-      confidence: 0.85
+      confidence: 0.85,
+      category: 'response_style'
     }
-  });
-  
-  // Retrieve relevant knowledge
-  const results = await context.vector.search('knowledge', {
-    query: 'How should I format responses?',
-    limit: 5
-  });
+  }]);
+
+  // Search for relevant knowledge
+  const results = await context.vector.search(
+    'knowledge',
+    'How should I format my responses?',
+    { limit: 5 }
+  );
+
+  // Use the knowledge to improve responses
+  if (results.length > 0) {
+    context.logger.info(\`Found \${results.length} relevant insights\`);
+    results.forEach(result => {
+      context.logger.info(\`Insight: \${result.document}\`);
+    });
+  }
 };`} />
 
 ## Framework Awareness: Choosing the Right Tool
@@ -585,12 +500,12 @@ Agentuity is framework-agnostic. You can use any AI framework or build custom ag
 
 Different frameworks excel at different tasks. Here's when to use each:
 
-| Framework | Best For | Agentuity Integration |
-|-----------|----------|----------------------|
-| **LangChain** | Complex chains, RAG applications | Native SDK support |
-| **CrewAI** | Multi-agent teams, role-based systems | Deploy via container |
-| **AutoGen** | Research, experimentation | Direct deployment |
-| **Custom** | Specific requirements, full control | Full platform features |
+| Framework | Best For | Language Support | Agentuity Integration |
+|-----------|----------|------------------|----------------------|
+| **LangChain** | Complex chains, RAG applications | Python, TypeScript | Native SDK support |
+| **CrewAI** | Multi-agent teams, role-based systems | Python | Container deployment |
+| **AutoGen** | Research, conversational AI | Python | Direct deployment |
+| **Custom** | Specific requirements, full control | Python, TypeScript, Bun | Full platform features |
 
 ### Framework Comparison Example
 
@@ -653,165 +568,202 @@ const handler: AgentHandler = async (request, response, context) => {
 
 ### When to Use Which Framework
 
-- **Use LangChain** when you need:
-  - Complex reasoning chains
-  - RAG (Retrieval Augmented Generation)
-  - Extensive tool integration
-  - Well-documented patterns
-
-- **Use CrewAI** when you need:
-  - Multiple specialized agents
-  - Role-based collaboration
-  - Hierarchical task delegation
+| Framework | Use When You Need | Avoid When You Need |
+|-----------|-------------------|-------------------|
+| **LangChain** | Complex reasoning chains, RAG applications, extensive data integrations | Simple agents, minimal dependencies, lightweight solutions |
+| **CrewAI** | Multi-agent teams, role-based collaboration, specialized workflows | Single-agent tasks, simple request-response patterns |
+| **AutoGen** | Conversational AI, research applications, experimental workflows | Production deployments, strict performance requirements |
+| **Custom** | Full control, specific requirements, optimized performance | Rapid prototyping, standard use cases, extensive tooling needs |
 
-- **Use Custom** when you need:
-  - Maximum performance
-  - Specific business logic
-  - Full control over behavior
-  - Minimal dependencies
+## Lab: Building a Weather Agent with Multiple Triggers
 
-## Lab: Building a Multi-Trigger Agent
-
-Let's put it all together by building an agent that responds to multiple triggers. We'll test it using DevMode's web interface:
+Let's build an agent that demonstrates different behaviors based on how it's triggered. This weather agent will show you how the same code can serve different purposes:
 
 <CodeExample py={`from datetime import datetime
-import json
 
 async def run(request, response, context):
-    """An agent that handles multiple trigger types."""
-    
+    """Weather agent with different trigger behaviors."""
+
     trigger = request.trigger
-    context.logger.info(f"Agent triggered via: {trigger}")
-    
+    context.logger.info(f"Weather agent triggered via: {trigger}")
+
     if trigger == "webhook":
-        # Handle API requests
-        data = await request.data.json()
-        
-        # Process based on action
-        action = data.get("action")
-        if action == "store":
-            # Store data in KV
-            await context.kv.set("data", data["key"], data["value"])
-            return response.json({"status": "stored", "key": data["key"]})
-        
-        elif action == "retrieve":
-            # Get from KV
-            result = await context.kv.get("data", data["key"])
-            if result.exists:
-                value = await result.data.json()
-                return response.json({"found": True, "value": value})
-    elif trigger == "cron":
-        # Scheduled cleanup task
-        context.logger.info("Running scheduled cleanup")
-        
-        # Clean old sessions (in production, iterate through keys)
-        await context.kv.delete("sessions", "old_session")
-        
-        # Generate report
-        report = {
-            "task": "cleanup",
-            "timestamp": datetime.now().isoformat(),
-            "status": "completed"
+        # Manual requests for specific cities
+        try:
+            data = await request.data.json()
+            city = data.get("city", "London")
+        except:
+            city = await request.data.text() or "London"
+
+        context.logger.info(f"Manual weather request for: {city}")
+
+        # Check cache first (10 minutes TTL)
+        cache_key = f"weather_{city.lower()}"
+        cached = await context.kv.get("weather_cache", cache_key)
+
+        if cached.exists:
+            weather = await cached.data.json()
+            context.logger.info(f"Returning cached weather for {city}")
+            return response.json({
+                **weather,
+                "cached": True,
+                "cache_age_minutes": 5  # Mock age
+            })
+
+        # Mock weather data (in production, call real API)
+        weather = {
+            "city": city,
+            "temperature": 22,
+            "description": "partly cloudy",
+            "humidity": 65,
+            "timestamp": datetime.now().isoformat()
         }
-        
-        # Store report
-        await context.kv.set("reports", "latest_cleanup", report)
-        return response.json(report)
-    
-    elif trigger == "agent":
-        # Handle agent-to-agent communication
-        data = await request.data.json()
-        
-        # Process request from another agent
-        result = f"Processed request from agent: {data}"
-        
-        return response.json({"result": result})
-    
+
+        # Cache for 10 minutes
+        await context.kv.set("weather_cache", cache_key, weather, {"ttl": 600})
+
+        return response.json({**weather, "cached": False})
+
+    elif trigger == "cron":
+        # Batch update for major cities
+        cities = ["London", "New York", "Tokyo", "Sydney"]
+        context.logger.info(f"Cron job: Updating weather for {len(cities)} cities")
+
+        weather_data = {}
+        for city in cities:
+            # Mock weather data
+            weather_data[city] = {
+                "temperature": 20 + hash(city) % 15,  # Mock variation
+                "description": "sunny",
+                "updated": datetime.now().isoformat()
+            }
+
+        # Store daily weather report
+        await context.kv.set("weather_reports", "daily", weather_data, {"ttl": 86400})
+
+        return response.json({
+            "task": "weather_update",
+            "cities_updated": len(cities),
+            "timestamp": datetime.now().isoformat()
+        })
+
+    elif trigger == "manual":
+        # DevMode testing - show available commands
+        return response.json({
+            "message": "Weather Agent DevMode",
+            "commands": [
+                "Test webhook: POST {\"city\": \"Paris\"}",
+                "Test cron: Use simulate button in DevMode"
+            ],
+            "current_time": datetime.now().isoformat()
+        })
+
     else:
         return response.json({
-            "error": f"Unknown trigger type: {trigger}"
+            "error": f"Unsupported trigger: {trigger}",
+            "supported": ["webhook", "cron", "manual"]
         })`} js={`const handler: AgentHandler = async (request, response, context) => {
   const trigger = request.trigger;
-  context.logger.info(\`Agent triggered via: \${trigger}\`);
-  
+  context.logger.info(\`Weather agent triggered via: \${trigger}\`);
+
   if (trigger === 'webhook') {
-    // Handle API requests
-    const data = await request.data.json();
-    
-    // Process based on action
-    const action = data.action;
-    if (action === 'store') {
-      // Store data in KV
-      await context.kv.set('data', data.key, JSON.stringify(data.value));
-      return response.json({ status: 'stored', key: data.key });
-    
-    } else if (action === 'retrieve') {
-      // Get from KV
-      const result = await context.kv.get('data', data.key);
-      if (result.exists) {
-        const value = await result.data.json();
-        return response.json({ found: true, value });
-      }
-      return response.json({ found: false });
+    // Manual requests for specific cities
+    let city = 'London';
+    try {
+      const data = await request.data.json();
+      city = data.city || 'London';
+    } catch {
+      city = await request.data.text() || 'London';
     }
-    
-    // Handle DevMode simulation of cron for testing
-    if (data._simulate_cron) {
-      context.logger.info('Simulating cron trigger in DevMode');
-      // Run the same cleanup logic
-      const report = {
-        task: 'cleanup (simulated)',
-        timestamp: new Date().toISOString(),
-        status: 'completed'
-      };
-      return response.json(report);
+
+    context.logger.info(\`Manual weather request for: \${city}\`);
+
+    // Check cache first (10 minutes TTL)
+    const cacheKey = \`weather_\${city.toLowerCase()}\`;
+    const cached = await context.kv.get('weather_cache', cacheKey);
+
+    if (cached.exists) {
+      const weather = await cached.data.json();
+      context.logger.info(\`Returning cached weather for \${city}\`);
+      return response.json({
+        ...weather,
+        cached: true,
+        cache_age_minutes: 5  // Mock age
+      });
     }
-  
-  } else if (trigger === 'cron') {
-    // Scheduled cleanup task
-    context.logger.info('Running scheduled cleanup');
-    
-    // Clean old sessions
-    await context.kv.delete('sessions', 'old_session');
-    
-    // Generate report
-    const report = {
-      task: 'cleanup',
-      timestamp: new Date().toISOString(),
-      status: 'completed'
+
+    // Mock weather data (in production, call real API)
+    const weather = {
+      city,
+      temperature: 22,
+      description: 'partly cloudy',
+      humidity: 65,
+      timestamp: new Date().toISOString()
     };
-    
-    // Store report
-    await context.kv.set('reports', 'latest_cleanup', JSON.stringify(report));
-    return response.json(report);
-  
-  } else if (trigger === 'agent') {
-    // Handle agent-to-agent communication
-    const data = await request.data.json();
-    
-    // Process request from another agent
-    const result = \`Processed request from agent: \${JSON.stringify(data)}\`;
-    
-    return response.json({ result });
-  
+
+    // Cache for 10 minutes
+    await context.kv.set('weather_cache', cacheKey, weather, { ttl: 600 });
+
+    return response.json({ ...weather, cached: false });
+
+  } else if (trigger === 'cron') {
+    // Batch update for major cities
+    const cities = ['London', 'New York', 'Tokyo', 'Sydney'];
+    context.logger.info(\`Cron job: Updating weather for \${cities.length} cities\`);
+
+    const weatherData: Record<string, any> = {};
+    cities.forEach(city => {
+      // Mock weather data with variation
+      weatherData[city] = {
+        temperature: 20 + (city.length % 15),  // Mock variation
+        description: 'sunny',
+        updated: new Date().toISOString()
+      };
+    });
+
+    // Store daily weather report
+    await context.kv.set('weather_reports', 'daily', weatherData, { ttl: 86400 });
+
+    return response.json({
+      task: 'weather_update',
+      cities_updated: cities.length,
+      timestamp: new Date().toISOString()
+    });
+
+  } else if (trigger === 'manual') {
+    // DevMode testing - show available commands
+    return response.json({
+      message: 'Weather Agent DevMode',
+      commands: [
+        'Test webhook: POST {"city": "Paris"}',
+        'Test cron: Use simulate button in DevMode'
+      ],
+      current_time: new Date().toISOString()
+    });
+
   } else {
     return response.json({
-      error: \`Unknown trigger type: \${trigger}\`
+      error: \`Unsupported trigger: \${trigger}\`,
+      supported: ['webhook', 'cron', 'manual']
     });
   }
-};
-
-export default handler;`} />
+};`} />
 
-### Testing Your Multi-Trigger Agent
+### Testing Your Weather Agent
 
 <Callout type="info">
-DevMode makes it easy to test webhook triggers locally. For cron triggers, you can simulate them in DevMode or configure real schedules through the Agentuity Console.
+DevMode makes it easy to test all trigger types. You can simulate webhooks, test manual triggers, and even simulate cron jobs through the interface.
 </Callout>
 
-#### Setting Up Test Scenarios
+#### What This Agent Demonstrates
+
+- **Webhook trigger**: Handles real-time weather requests with caching
+- **Cron trigger**: Batch updates for multiple cities
+- **Manual trigger**: DevMode testing and debugging interface
+- **Caching strategy**: Uses TTL to balance freshness and performance
+- **Error handling**: Graceful fallbacks for different input types
 
-First, enhance your agent with a `welcome()` function to create test scenarios:
+Try calling this agent with different cities and watch how it caches responses for efficiency!
 
 <CodeExample py={`def welcome():
     """Configure test scenarios for different trigger types."""
@@ -900,7 +852,8 @@ Effective cost optimization strategies include:
 
 - **Cache frequently used data** in KV storage to reduce repeated processing
 - **Batch operations** when possible to minimize API calls
-- **Use appropriate LLM models** - not everything needs GPT-4
+- **Use appropriate LLM models** - use reasoning models (like GPT-4) only when you need complex reasoning
+- **Consider fast inference providers** - Groq offers high-speed inference for many models
 - **Implement early exits** in reasoning loops to avoid unnecessary iterations
 
 ### Latency vs. Capability Trade-offs
@@ -956,18 +909,18 @@ Effective cost optimization strategies include:
 - **Multiple trigger types**: Choose the right trigger for your use case
 - **Context is powerful**: It provides access to all Agentuity services
 - **Frameworks are tools**: Pick the right one for your needs, or go custom
-- **Memory enables learning**: Use KV for short-term, Vector for long-term
+- **Memory patterns matter**: Session data (TTL), persistent data (no TTL), searchable knowledge (Vector)
 - **Performance matters**: Balance capability with cost and latency
 
 ## What's Next?
 
 You now understand the core components that make agents work. In the next module, we'll dive deep into memory systems - how agents remember, learn, and improve over time.
 
-But first, experiment with the multi-trigger agent:
-- Add a new trigger type (email or SMS)
-- Implement a simple reasoning loop
-- Try different response formats
-- Connect two agents together
+But first, experiment with the weather agent:
+- Test it with different cities
+- Try the caching behavior with repeated requests
+- Add new cities to the cron batch update
+- Modify the cache TTL and observe the difference
 
 Remember: The anatomy you've learned here is the foundation. The intelligence you add on top is what makes your agents unique.
 
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
index e6d275e5..1a446855 100644
--- a/content/Training/developers/03-agent-memory.mdx
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -9,7 +9,7 @@ Without memory, an agent is just a stateless function. With memory, it becomes a
 
 According to [IBM's research on AI agent memory](https://www.ibm.com/think/topics/ai-agent-memory), the biggest limitation of current LLMs is their inability to retain information between sessions. Every conversation starts from scratch, every user must re-explain their context, and every task begins without learning from the past.
 
-As highlighted in recent [memory management research](https://medium.com/@nomannayeem/building-ai-agents-that-actually-remember-a-developers-guide-to-memory-management-in-2025-062fd0be80a1):
+As highlighted in a recent [memory management blog post](https://medium.com/@nomannayeem/building-ai-agents-that-actually-remember-a-developers-guide-to-memory-management-in-2025-062fd0be80a1):
 
 > "The difference between a chatbot and an agent is memory. A chatbot responds to the current message. An agent remembers your entire relationship."
 
@@ -25,21 +25,16 @@ This creates fundamental challenges:
 For implementation details on Agentuity's storage systems, see our guides on [Key-Value Storage](/Guides/key-value), [Vector Database](/Guides/vector-db), and [Object Storage](/Guides/object-storage).
 </Callout>
 
-### The Memory Hierarchy
+### Memory Types Overview
 
-Just like human memory, agent memory operates at different levels:
+Agent memory serves different purposes based on how long data needs to persist:
 
-<Mermaid chart="
-graph TD
-    A[Working Memory] --> B[Short-term Memory]
-    B --> C[Long-term Memory]
-    C --> D[Collective Memory]
-    
-    A1[Current Request Context] --> A
-    B1[Session State / Cache] --> B
-    C1[User History / Knowledge Base] --> C
-    D1[Shared Agent Knowledge] --> D
-" />
+| Memory Type | Duration | Storage | Purpose |
+|-------------|----------|---------|----------|
+| **Working Memory** | Single request | In-memory variables | Process current task |
+| **Session Memory** | Minutes to hours | KV with TTL | Maintain conversation context |
+| **Persistent Memory** | Until deleted | KV without TTL | Store user preferences, profiles |
+| **Searchable Memory** | Until deleted | Vector storage | Semantic search and retrieval |
 
 Let's explore each level:
 
@@ -163,12 +158,12 @@ Best for discrete, queryable data:
   await context.kv.set('users', userId, JSON.stringify(profile));
 };`} />
 
-### Unstructured Memory (Vector Storage)
-Best for semantic information:
-- Conversation history
-- Domain knowledge
-- User feedback
-- Document content
+### Searchable Memory (Vector Storage)
+Best for semantic search and knowledge retrieval:
+- Conversation history you want to search through
+- Domain knowledge and learned information
+- User feedback and insights
+- Document content that needs to be findable
 
 <CodeExample py={`async def run(request, response, context):
     # Store conversation for semantic retrieval
@@ -684,34 +679,20 @@ Different memory types require different retention policies:
 | Temporary results | 5-15 minutes | Computation cache |
 | Audit logs | 30-90 days | Compliance requirements |
 
-### Memory Sizing Guidelines
+### Memory Strategy Guidelines
 
-Plan your memory usage based on agent patterns:
+Start with simple patterns and scale based on actual usage:
 
-```python
-# Calculate memory requirements
-def estimate_memory_needs(users, interactions_per_day):
-    # Key-Value Storage
-    profile_size = 2  # KB per user profile
-    session_size = 10  # KB per active session
-    kv_total = (users * profile_size) + (users * 0.1 * session_size)
-    
-    # Vector Storage
-    vectors_per_user = interactions_per_day * 30  # 30 days retention
-    vector_size = 0.5  # KB per vector
-    vector_total = users * vectors_per_user * vector_size
-    
-    # Object Storage
-    reports_per_user = 10  # Average files per user
-    avg_file_size = 500  # KB per file
-    object_total = users * reports_per_user * avg_file_size
-    
-    return {
-        "kv_storage_gb": kv_total / 1024 / 1024,
-        "vector_storage_gb": vector_total / 1024 / 1024,
-        "object_storage_gb": object_total / 1024 / 1024
-    }
-```
+- **Start small**: Begin with essential data only
+- **Monitor usage**: Track storage costs and access patterns
+- **Use appropriate TTL**: Match expiration to business needs
+- **Scale gradually**: Add memory features as you understand usage patterns
+
+Common TTL patterns:
+- Chat sessions: 1-4 hours
+- Daily summaries: 24-48 hours
+- User preferences: No TTL (permanent)
+- Temporary calculations: 5-15 minutes
 
 ### Memory Cleanup Patterns
 
@@ -1144,28 +1125,24 @@ agentuity dev
 
 As your agents grow, consider these scaling strategies:
 
-### Hybrid Memory Architecture
-- **Hot data** in KV storage (recent interactions)
-- **Warm data** in vector storage (searchable history)
-- **Cold data** in object storage (archives)
+### Memory Access Patterns
+- **Frequently accessed data**: KV storage (recent interactions, user profiles)
+- **Searchable data**: Vector storage (conversation history, knowledge base)
+- **Archived data**: Object storage (old files, backups)
+
+### Organizing Memory at Scale
 
-### Memory Sharding
-- Partition by user ID or tenant
-- Distribute across namespaces
-- Implement consistent hashing for even distribution
+**Data Partitioning**: Use user IDs or tenant IDs to organize data in separate namespaces, keeping user data isolated.
 
-### Caching Strategies
-- Cache frequent queries in KV with short TTL
-- Pre-compute common aggregations
-- Use edge caching for read-heavy workloads
+**Smart Caching**: Use KV storage with short TTL (5-15 minutes) for expensive computations that might be repeated.
 
 ## Key Takeaways
 
 - **Memory transforms agents** from stateless functions to learning systems
-- **Choose the right storage**: KV for structure, Vector for semantic, Object for files
-- **Implement retention policies**: Not all memory should be permanent
-- **Design for scale**: Plan your memory architecture for growth
-- **Privacy matters**: Always consider data retention regulations
+- **Choose the right storage**: KV for data, Vector for search, Object for files
+- **TTL is key**: Use appropriate expiration times for different data types
+- **Start simple**: Begin with basic patterns, add complexity as needed
+- **Organize by user**: Keep data properly partitioned and isolated
 
 ## What's Next?
 
diff --git a/content/Training/developers/04-agent-collaboration.mdx b/content/Training/developers/04-agent-collaboration.mdx
index 1a677179..ada674f1 100644
--- a/content/Training/developers/04-agent-collaboration.mdx
+++ b/content/Training/developers/04-agent-collaboration.mdx
@@ -19,40 +19,50 @@ Think about how human organizations work:
 
 The same principles apply to agent systems.
 
-## Core Concepts of Agent Collaboration
+## Industry Multi-Agent Patterns
 
-### 1. Agent Communication Patterns
+Most production multi-agent systems follow one of two patterns:
 
-There are three primary ways agents can work together:
-
-#### Sequential (Chain)
-One agent completes its task and passes the result to the next:
+### Direct Handoff (Sequential)
+Agents pass control directly to each other, like a relay race:
 ```
-User → Research Agent → Summarizer Agent → Response
+Data Fetcher → Analyzer → Report Writer → User
 ```
 
-#### Parallel (Fan-out/Fan-in)
-Multiple agents work simultaneously on different parts:
-```
-           ┌→ Web Search Agent →┐
-User → Coordinator →→ Database Agent →→ Aggregator → Response
-           └→ File Agent →┘
-```
+**Best for:** Linear workflows where each step depends on the previous one.
 
-#### Conditional (Router)
-Agents are selected based on the task:
+### Orchestrator Pattern (Hub-and-Spoke)
+A central orchestrator manages and routes to specialized agents:
 ```
-User → Router → [Math Agent | Language Agent | Code Agent] → Response
+           ┌→ Technical Agent
+User → Orchestrator →→ Sales Agent
+           └→ Support Agent
 ```
 
-### 2. The Handoff Mechanism
+**Best for:** Complex systems with multiple specialized agents.
+
+## Industry Challenges vs. Agentuity's Approach
+
+According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring LangGraph or custom orchestrators.
+
+### Agentuity's Approach: Simple Handoffs
+
+While other platforms build complex orchestration layers, Agentuity takes a different approach: **the handoff mechanism**. It's simpler, but with clear trade-offs:
+
+- **What it does**: Transfers control from one agent to another (like call forwarding)
+- **What it doesn't do**: Parallel execution, getting responses back, complex coordination
+- **Why it works**: Most real-world agent workflows are actually sequential or conditional
+
+## The Handoff Mechanism
 
 In Agentuity, agents communicate using the `handoff` method. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
 
 <CodeExample py={`async def run(request, response, context):
+    """Basic handoff example."""
+
     # Receive a research request
     task = await request.data.json()
-    
+
     # Decide we need help from the web search agent
     if task.get("type") == "web_research":
         # Hand off to the web search specialist
@@ -61,30 +71,31 @@ In Agentuity, agents communicate using the `handoff` method. This is like forwar
             {"query": task.get("query")},  # Data to pass
             {"original_task": task}  # Metadata
         )
-    
+
     # Handle other task types...
     return response.json({"result": "Task completed"})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Receive a research request
+  // Basic handoff example
+
   const task = await request.data.json();
-  
+
   // Decide we need help from the web search agent
   if (task.type === 'web_research') {
     // Hand off to the web search specialist
     return response.handoff(
       { name: 'web-search' }, // Target agent
       {
-        data: JSON.stringify({ query: task.query }), // Data as string/buffer
+        data: JSON.stringify({ query: task.query }), // Data as string
         contentType: 'application/json',
         metadata: { original_task: task } // Metadata object
       }
     );
   }
-  
+
   // Handle other task types...
   return response.json({ result: 'Task completed' });
 };`} />
 
-### 3. Agent Resolution
+## Agent Resolution
 
 Agents can find each other using either:
 - **Name**: Human-readable identifier (e.g., "web-search")
@@ -96,7 +107,7 @@ The context object knows about all agents in your project:
     # List all available agents
     available_agents = context.agents
     context.logger.info(f"Available agents: {[a.name for a in available_agents]}")
-    
+
     # Check if a specific agent exists
     if any(agent.name == "summarizer" for agent in context.agents):
         # Agent exists, we can safely hand off
@@ -107,7 +118,7 @@ The context object knows about all agents in your project:
   // List all available agents
   const availableAgents = context.agents;
   context.logger.info(\`Available agents: \${availableAgents.map(a => a.name)}\`);
-  
+
   // Check if a specific agent exists
   if (availableAgents.some(agent => agent.name === 'summarizer')) {
     // Agent exists, we can safely hand off
@@ -121,196 +132,6 @@ The context object knows about all agents in your project:
   }
 };`} />
 
-## Building a Research Team
-
-Let's build a simple research system with three specialized agents working together.
-
-### The Coordinator Agent
-
-This agent receives research requests and delegates to specialists:
-
-<CodeExample py={`async def run(request, response, context):
-    """Research coordinator that delegates to specialist agents."""
-    
-    research_request = await request.data.json()
-    query = research_request.get("query", "")
-    
-    context.logger.info(f"Coordinating research for: {query}")
-    
-    # Step 1: Gather information from web search
-    search_result = await response.handoff(
-        {"name": "web-search"},
-        {"query": query, "max_results": 3}  # Data to pass
-    )
-    
-    # Note: In reality, the handoff returns immediately.
-    # For this example, imagine we're showing the flow.
-    # The web-search agent's response will go back to the user.
-    
-    # For a complete flow, you'd need to structure it differently:
-    # Option 1: Have web-search call summarizer
-    # Option 2: Use a workflow orchestrator
-    # Option 3: Have the client make sequential calls
-    
-    return search_result`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Research coordinator that delegates to specialist agents
-  
-  const researchRequest = await request.data.json();
-  const query = researchRequest.query || '';
-  
-  context.logger.info(\`Coordinating research for: \${query}\`);
-  
-  // Step 1: Gather information from web search
-  const searchResult = await response.handoff(
-    { name: 'web-search' },
-    {
-      data: JSON.stringify({ query, max_results: 3 }),
-      contentType: 'application/json'
-    }
-  );
-  
-  // Note: In reality, the handoff returns immediately.
-  // For this example, imagine we're showing the flow.
-  // The web-search agent's response will go back to the user.
-  
-  return searchResult;
-};`} />
-
-### The Web Search Agent
-
-A specialist that searches the web and returns results:
-
-<CodeExample py={`async def run(request, response, context):
-    """Specialist agent for web searches."""
-    
-    search_params = await request.data.json()
-    query = search_params.get("query")
-    max_results = search_params.get("max_results", 5)
-    
-    context.logger.info(f"Searching web for: {query}")
-    
-    # Simulate web search (in production, use actual search API)
-    search_results = [
-        {
-            "title": f"Result {i+1} for {query}",
-            "snippet": f"This is a relevant snippet about {query}...",
-            "url": f"https://example.com/{i+1}"
-        }
-        for i in range(max_results)
-    ]
-    
-    # Now hand off to summarizer to create a coherent summary
-    return response.handoff(
-        {"name": "summarizer"},
-        {
-            "content": search_results,
-            "original_query": query
-        },  # Data to pass
-        {"source": "web-search"}  # Metadata
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Specialist agent for web searches
-  
-  const searchParams = await request.data.json();
-  const query = searchParams.query;
-  const maxResults = searchParams.max_results || 5;
-  
-  context.logger.info(\`Searching web for: \${query}\`);
-  
-  // Simulate web search (in production, use actual search API)
-  const searchResults = Array.from({ length: maxResults }, (_, i) => ({
-    title: \`Result \${i + 1} for \${query}\`,
-    snippet: \`This is a relevant snippet about \${query}....\`,
-    url: \`https://example.com/\${i + 1}\`
-  }));
-  
-  // Now hand off to summarizer to create a coherent summary
-  return response.handoff(
-    { name: 'summarizer' },
-    {
-      data: JSON.stringify({
-        content: searchResults,
-        original_query: query
-      }),
-      contentType: 'application/json',
-      metadata: { source: 'web-search' }
-    }
-  );
-};`} />
-
-### The Summarizer Agent
-
-Takes search results and creates a concise summary:
-
-<CodeExample py={`async def run(request, response, context):
-    """Specialist agent for summarizing content."""
-    
-    summary_request = await request.data.json()
-    content = summary_request.get("content", [])
-    original_query = summary_request.get("original_query", "")
-    
-    context.logger.info(f"Summarizing {len(content)} items")
-    
-    # Create a summary from the search results
-    summary_parts = []
-    for item in content:
-        if isinstance(item, dict):
-            title = item.get("title", "")
-            snippet = item.get("snippet", "")
-            summary_parts.append(f"• {title}: {snippet}")
-    
-    final_summary = {
-        "query": original_query,
-        "summary": f"Here's what I found about '{original_query}':\\n\\n" + 
-                   "\\n".join(summary_parts),
-        "source_count": len(content),
-        "timestamp": datetime.now().isoformat()
-    }
-    
-    # Return the final summary to the user
-    return response.json(final_summary)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Specialist agent for summarizing content
-  
-  const summaryRequest = await request.data.json();
-  const content = summaryRequest.content || [];
-  const originalQuery = summaryRequest.original_query || '';
-  
-  context.logger.info(\`Summarizing \${content.length} items\`);
-  
-  // Create a summary from the search results
-  const summaryParts = content.map(item => {
-    if (typeof item === 'object') {
-      const title = item.title || '';
-      const snippet = item.snippet || '';
-      return \`• \${title}: \${snippet}\`;
-    }
-    return '';
-  }).filter(Boolean);
-  
-  const finalSummary = {
-    query: originalQuery,
-    summary: \`Here's what I found about '\${originalQuery}':\\n\\n\${summaryParts.join('\\n')}\`,
-    source_count: content.length,
-    timestamp: new Date().toISOString()
-  };
-  
-  // Return the final summary to the user
-  return response.json(finalSummary);
-};`} />
-
-## Orchestration Patterns: Industry vs. Agentuity
-
-### The Industry Challenge
-
-According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring LangGraph or custom orchestrators.
-
-### Agentuity's Approach: Simple Handoffs
-
-While other platforms build complex orchestration layers, Agentuity takes a different approach: **the handoff mechanism**. It's simpler, but with clear trade-offs:
-
-- **What it does**: Transfers control from one agent to another (like call forwarding)
-- **What it doesn't do**: Parallel execution, getting responses back, complex coordination
-- **Why it works**: Most real-world agent workflows are actually sequential or conditional
-
 ## Patterns That Work with Agentuity's Handoff
 
 ### 1. Sequential Chain Pattern
@@ -319,43 +140,43 @@ Perfect for pipelines where each agent completes its work and passes to the next
 
 <CodeExample py={`async def run(request, response, context):
     """Pipeline pattern: Each agent enriches the data."""
-    
+
     data = await request.data.json()
     step = data.get("step", 1)
-    
+
     if step == 1:
         # First agent: Clean the data
         data["cleaned"] = True
         data["step"] = 2
         return response.handoff({"name": "processor"}, data)
-    
+
     elif step == 2:
         # Second agent: Enrich the data
         data["enriched"] = True
         data["step"] = 3
         return response.handoff({"name": "validator"}, data)
-    
+
     elif step == 3:
         # Final agent: Validate and return
         data["validated"] = True
         return response.json(data)`} js={`const handler: AgentHandler = async (request, response, context) => {
   // Pipeline pattern: Each agent enriches the data
-  
+
   const data = await request.data.json();
   const step = data.step || 1;
-  
+
   if (step === 1) {
     // First agent: Clean the data
     data.cleaned = true;
     data.step = 2;
     return response.handoff({ name: 'processor' }, { data: JSON.stringify(data), contentType: 'application/json' });
-  
+
   } else if (step === 2) {
     // Second agent: Enrich the data
     data.enriched = true;
     data.step = 3;
     return response.handoff({ name: 'validator' }, { data: JSON.stringify(data), contentType: 'application/json' });
-  
+
   } else if (step === 3) {
     // Final agent: Validate and return
     data.validated = true;
@@ -369,10 +190,10 @@ Route to different agents based on the request type - ideal for dispatcher/route
 
 <CodeExample py={`async def run(request, response, context):
     """Router pattern: Direct to appropriate specialist."""
-    
+
     task = await request.data.json()
     task_type = task.get("type", "").lower()
-    
+
     # Route based on task type
     agent_map = {
         "math": "calculator-agent",
@@ -380,26 +201,26 @@ Route to different agents based on the request type - ideal for dispatcher/route
         "search": "web-search",
         "summary": "summarizer"
     }
-    
+
     target_agent = agent_map.get(task_type)
-    
+
     if target_agent:
         context.logger.info(f"Routing {task_type} task to {target_agent}")
         return response.handoff(
             {"name": target_agent},
             task.get("payload", {})  # Pass payload directly as data
         )
-    
+
     # Unknown task type
     return response.json({
         "error": f"Unknown task type: {task_type}",
         "available_types": list(agent_map.keys())
     })`} js={`const handler: AgentHandler = async (request, response, context) => {
   // Router pattern: Direct to appropriate specialist
-  
+
   const task = await request.data.json();
   const taskType = (task.type || '').toLowerCase();
-  
+
   // Route based on task type
   const agentMap = {
     math: 'calculator-agent',
@@ -407,20 +228,20 @@ Route to different agents based on the request type - ideal for dispatcher/route
     search: 'web-search',
     summary: 'summarizer'
   };
-  
+
   const targetAgent = agentMap[taskType];
-  
+
   if (targetAgent) {
     context.logger.info(\`Routing \${taskType} task to \${targetAgent}\`);
     return response.handoff(
       { name: targetAgent },
-      { 
+      {
         data: JSON.stringify(task.payload || {}),
         contentType: 'application/json'
       }
     );
   }
-  
+
   // Unknown task type
   return response.json({
     error: \`Unknown task type: \${taskType}\`,
@@ -428,53 +249,68 @@ Route to different agents based on the request type - ideal for dispatcher/route
   });
 };`} />
 
-### 3. Delegation Pattern (Agentuity-Specific)
+### 3. Orchestrator Pattern (Smart Routing)
 
-A main agent handles most work but delegates specialized tasks. Remember: the delegated agent's response goes to the client, not back to the delegator:
+A central agent analyzes requests and routes to appropriate specialists:
 
 <CodeExample py={`async def run(request, response, context):
-    """Main agent that delegates when needed."""
-    
-    task = await request.data.json()
-    
-    # Handle most tasks directly
-    if task.get("type") in ["simple", "standard"]:
-        result = process_locally(task)
-        return response.json(result)
-    
-    # Delegate complex tasks
-    if task.get("type") == "complex":
-        # Note: We won't get the response back
-        # The specialist will respond directly to client
+    """Smart orchestrator that analyzes intent before routing."""
+
+    user_prompt = await request.data.text()
+
+    # Simple intent analysis (in production, use LLM)
+    if "technical" in user_prompt.lower() or "code" in user_prompt.lower():
         return response.handoff(
-            {"name": "specialist-agent"},
-            task
-        )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Main agent that delegates when needed
-  
-  const task = await request.data.json();
-  
-  // Handle most tasks directly
-  if (['simple', 'standard'].includes(task.type)) {
-    const result = processLocally(task);
-    return response.json(result);
-  }
-  
-  // Delegate complex tasks
-  if (task.type === 'complex') {
-    // Note: We won't get the response back
-    // The specialist will respond directly to client
+            {"name": "technical-expert"},
+            {"query": user_prompt, "type": "technical"}
+        )
+    elif "price" in user_prompt.lower() or "cost" in user_prompt.lower():
+        return response.handoff(
+            {"name": "sales-expert"},
+            {"query": user_prompt, "type": "sales"}
+        )
+    elif "help" in user_prompt.lower() or "problem" in user_prompt.lower():
+        return response.handoff(
+            {"name": "support-expert"},
+            {"query": user_prompt, "type": "support"}
+        )
+    else:
+        return response.text("I can help with technical, sales, or support questions. How can I assist you?")`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Smart orchestrator that analyzes intent before routing
+
+  const userPrompt = await request.data.text();
+
+  // Simple intent analysis (in production, use LLM)
+  if (userPrompt.toLowerCase().includes('technical') || userPrompt.toLowerCase().includes('code')) {
+    return response.handoff(
+      { name: 'technical-expert' },
+      {
+        data: JSON.stringify({ query: userPrompt, type: 'technical' }),
+        contentType: 'application/json'
+      }
+    );
+  } else if (userPrompt.toLowerCase().includes('price') || userPrompt.toLowerCase().includes('cost')) {
+    return response.handoff(
+      { name: 'sales-expert' },
+      {
+        data: JSON.stringify({ query: userPrompt, type: 'sales' }),
+        contentType: 'application/json'
+      }
+    );
+  } else if (userPrompt.toLowerCase().includes('help') || userPrompt.toLowerCase().includes('problem')) {
     return response.handoff(
-      { name: 'specialist-agent' },
-      { 
-        data: JSON.stringify(task),
+      { name: 'support-expert' },
+      {
+        data: JSON.stringify({ query: userPrompt, type: 'support' }),
         contentType: 'application/json'
       }
     );
+  } else {
+    return response.text('I can help with technical, sales, or support questions. How can I assist you?');
   }
 };`} />
 
-### 4. Request-Response Pattern  
+### 4. Understanding Handoff Flow
 
 Understanding that handoff is a one-way transfer is crucial. The final agent in the chain responds to the original client:
 
@@ -486,71 +322,24 @@ Client Request → Agent A → (handoff) → Agent B → Response to Client
 
 This is different from traditional RPC where Agent A would wait for Agent B's response.
 
-## Agentuity-Specific Best Practices
-
-### 1. Working with Agent Resolution
+## Understanding Handoff Constraints
 
-Agentuity provides built-in agent discovery within your project:
-
-<CodeExample py={`async def run(request, response, context):
-    # List all agents in your project
-    available_agents = context.agents
-    agent_names = [agent.name for agent in available_agents]
-    context.logger.info(f"Available agents: {agent_names}")
-    
-    # Check if an agent exists before handoff
-    target_name = "specialist-agent"
-    if any(agent.name == target_name for agent in context.agents):
-        return response.handoff({"name": target_name}, data)
-    else:
-        return response.json({
-            "error": f"Agent '{target_name}' not found",
-            "available": agent_names
-        })
-    
-    # You can also use agent IDs for more precise targeting
-    # return response.handoff({"id": "agent_abc123"}, data)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // List all agents in your project
-  const availableAgents = context.agents;
-  const agentNames = availableAgents.map(a => a.name);
-  context.logger.info(\`Available agents: \${agentNames}\`);
-  
-  // Check if an agent exists before handoff
-  const targetName = 'specialist-agent';
-  if (availableAgents.some(agent => agent.name === targetName)) {
-    return response.handoff(
-      { name: targetName },
-      { data: JSON.stringify(data), contentType: 'application/json' }
-    );
-  } else {
-    return response.json({
-      error: \`Agent '\${targetName}' not found\`,
-      available: agentNames
-    });
-  }
-  
-  // You can also use agent IDs for more precise targeting
-  // return response.handoff({ id: 'agent_abc123' }, args);
-};`} />
-
-### 2. Understanding Handoff Limitations
-
-Agentuity's handoff has built-in safety features and constraints:
+Agentuity's handoff has built-in safety features and important constraints to understand:
 
 <CodeExample py={`async def run(request, response, context):
     # CONSTRAINT 1: Can't handoff to yourself (loop detection)
     # This will raise an error:
     # return response.handoff({"name": context.agent.name}, data)
-    
+
     # CONSTRAINT 2: Handoff is one-way (no response back)
     # Wrong expectation:
     # result = await response.handoff({"name": "helper"}, data)  # NO!
     # Right approach:
     return response.handoff({"name": "helper"}, data)  # Helper responds to client
-    
+
     # CONSTRAINT 3: Only see agents in your project
     # Agents are isolated by project for security
-    
+
     # FEATURE: Metadata persists through handoffs
     metadata = request.metadata or {}
     metadata["chain"] = metadata.get("chain", []) + [context.agent.name]
@@ -562,22 +351,25 @@ Agentuity's handoff has built-in safety features and constraints:
   // CONSTRAINT 1: Can't handoff to yourself (loop detection)
   // This will raise an error:
   // return response.handoff({ name: context.agent.name }, args);
-  
+
   // CONSTRAINT 2: Handoff is one-way (no response back)
   // Wrong expectation:
   // const result = await response.handoff({ name: 'helper' }, args); // NO!
   // Right approach:
-  return response.handoff({ name: 'helper' }, args); // Helper responds to client
-  
+  return response.handoff({ name: 'helper' }, {
+    data: JSON.stringify(data),
+    contentType: 'application/json'
+  }); // Helper responds to client
+
   // CONSTRAINT 3: Only see agents in your project
   // Agents are isolated by project for security
-  
+
   // FEATURE: Metadata persists through handoffs
   const metadata = request.metadata || {};
   metadata.chain = (metadata.chain || []).concat(context.agent.name);
   return response.handoff(
     { name: 'next-agent' },
-    { 
+    {
       data: JSON.stringify(data),
       contentType: 'application/json',
       metadata  // Pass context forward
@@ -585,29 +377,29 @@ Agentuity's handoff has built-in safety features and constraints:
   );
 };`} />
 
-### 3. Leveraging Agentuity's Built-in Features
+## Agentuity's Built-in Features
 
 Agentuity provides powerful built-in features for multi-agent systems:
 
 <CodeExample py={`async def run(request, response, context):
     # Use context.sessionId for automatic request tracking
     context.logger.info(f"Processing request {context.sessionId} in {context.agent.name}")
-    
+
     # Built-in OpenTelemetry tracing (automatic spans)
     # Each handoff creates a new span in the trace
-    
+
     # Use agent metadata for debugging
     context.logger.debug(f"Agent ID: {context.agent.id}")
     context.logger.debug(f"Project ID: {context.projectId}")
-    
+
     # Track the chain of agents
     metadata = request.metadata or {}
     agent_chain = metadata.get("agent_chain", [])
     agent_chain.append(context.agent.name)
-    
+
     # Log the full chain for debugging
     context.logger.info(f"Agent chain: {' -> '.join(agent_chain)}")
-    
+
     return response.handoff(
         {"name": "next-agent"},
         processed_data,
@@ -615,22 +407,22 @@ Agentuity provides powerful built-in features for multi-agent systems:
     )`} js={`const handler: AgentHandler = async (request, response, context) => {
   // Use context.sessionId for automatic request tracking
   context.logger.info(\`Processing request \${context.sessionId} in \${context.agent.name}\`);
-  
+
   // Built-in OpenTelemetry tracing (automatic spans)
   // Each handoff creates a new span in the trace
-  
+
   // Use agent metadata for debugging
   context.logger.debug(\`Agent ID: \${context.agent.id}\`);
   context.logger.debug(\`Project ID: \${context.projectId}\`);
-  
+
   // Track the chain of agents
   const metadata = request.metadata || {};
   const agentChain = metadata.agent_chain || [];
   agentChain.push(context.agent.name);
-  
+
   // Log the full chain for debugging
   context.logger.info(\`Agent chain: \${agentChain.join(' -> ')}\`);
-  
+
   return response.handoff(
     { name: 'next-agent' },
     {
@@ -641,201 +433,294 @@ Agentuity provides powerful built-in features for multi-agent systems:
   );
 };`} />
 
-## Lab: Build a Document Processing Pipeline
-
-Create a three-agent system that processes documents:
-
-1. **intake-agent**: Receives documents and validates format
-2. **analyzer-agent**: Extracts key information
-3. **storage-agent**: Stores processed results
-
-<CodeExample py={`# Intake Agent
-async def run(request, response, context):
-    """Validate and route incoming documents."""
-    
-    document = await request.data.json()
-    
-    # Validate document format
-    if not document.get("content"):
-        return response.json({"error": "Missing document content"})
-    
-    if not document.get("type") in ["pdf", "text", "html"]:
-        return response.json({"error": "Unsupported document type"})
-    
-    # Add processing metadata
-    document["received_at"] = datetime.now().isoformat()
-    document["intake_agent"] = context.agent.name
-    
-    # Pass to analyzer
+## Lab: Build a Research Orchestrator System
+
+Create a three-agent system using the orchestrator pattern with specialized agents:
+
+1. **orchestrator**: Receives research requests and routes to specialists
+2. **web-search**: Searches the web and passes results to summarizer
+3. **summarizer**: Creates final research summary
+
+### The Orchestrator Agent
+
+This agent analyzes requests and delegates to appropriate specialists:
+
+<CodeExample py={`async def run(request, response, context):
+    """Research orchestrator that routes to specialist agents."""
+
+    research_request = await request.data.json()
+    query = research_request.get("query", "")
+    research_type = research_request.get("type", "general")
+
+    context.logger.info(f"Orchestrating research for: {query}")
+
+    # Route based on research type
+    if research_type == "web" or "search" in query.lower():
+        # Route to web search specialist
+        return response.handoff(
+            {"name": "web-search"},
+            {"query": query, "max_results": 5},
+            {"orchestrator": "research-orchestrator", "original_type": research_type}
+        )
+    elif research_type == "summary" or "summarize" in query.lower():
+        # Route directly to summarizer if we have content
+        content = research_request.get("content", "")
+        if content:
+            return response.handoff(
+                {"name": "summarizer"},
+                {"content": content, "query": query},
+                {"orchestrator": "research-orchestrator"}
+            )
+
+    # Default: explain what we can do
+    return response.json({
+        "message": "I can help with web research or summarization.",
+        "examples": [
+            {"type": "web", "query": "latest AI developments"},
+            {"type": "summary", "content": "text to summarize", "query": "key points"}
+        ]
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Research orchestrator that routes to specialist agents
+
+  const researchRequest = await request.data.json();
+  const query = researchRequest.query || '';
+  const researchType = researchRequest.type || 'general';
+
+  context.logger.info(\`Orchestrating research for: \${query}\`);
+
+  // Route based on research type
+  if (researchType === 'web' || query.toLowerCase().includes('search')) {
+    // Route to web search specialist
     return response.handoff(
-        {"name": "analyzer-agent"},
-        document  # Pass document as data
-    )
-
-# Analyzer Agent  
-async def run(request, response, context):
-    """Extract key information from documents."""
-    
-    document = await request.data.json()
-    content = document.get("content", "")
-    
-    # Simple analysis (in production, use NLP/LLM)
-    analysis = {
-        "word_count": len(content.split()),
-        "char_count": len(content),
-        "has_numbers": any(c.isdigit() for c in content),
-        "document_type": document.get("type"),
-        "analyzed_at": datetime.now().isoformat()
+      { name: 'web-search' },
+      {
+        data: JSON.stringify({ query, max_results: 5 }),
+        contentType: 'application/json',
+        metadata: { orchestrator: 'research-orchestrator', original_type: researchType }
+      }
+    );
+  } else if (researchType === 'summary' || query.toLowerCase().includes('summarize')) {
+    // Route directly to summarizer if we have content
+    const content = researchRequest.content || '';
+    if (content) {
+      return response.handoff(
+        { name: 'summarizer' },
+        {
+          data: JSON.stringify({ content, query }),
+          contentType: 'application/json',
+          metadata: { orchestrator: 'research-orchestrator' }
+        }
+      );
     }
-    
-    # Combine with original document
-    document["analysis"] = analysis
-    
-    # Pass to storage
-    return response.handoff(
-        {"name": "storage-agent"},
-        document  # Pass document as data
-    )
-
-# Storage Agent
-async def run(request, response, context):
-    """Store processed documents."""
-    
-    document = await request.data.json()
-    
-    # Generate unique ID
-    doc_id = f"doc_{context.sessionId}"
-    
-    # Store in KV
-    await context.kv.set(
-        "processed_documents",
-        doc_id,
-        document
-    )
-    
-    # Return confirmation
-    return response.json({
-        "status": "success",
-        "document_id": doc_id,
-        "processed_by": [
-            document.get("intake_agent"),
-            "analyzer-agent",
-            "storage-agent"
-        ],
-        "stored_at": datetime.now().isoformat()
-    })`} js={`// Intake Agent
-const intakeHandler: AgentHandler = async (request, response, context) => {
-  // Validate and route incoming documents
-  
-  const document = await request.data.json();
-  
-  // Validate document format
-  if (!document.content) {
-    return response.json({ error: 'Missing document content' });
   }
-  
-  if (!['pdf', 'text', 'html'].includes(document.type)) {
-    return response.json({ error: 'Unsupported document type' });
-  }
-  
-  // Add processing metadata
-  document.received_at = new Date().toISOString();
-  document.intake_agent = context.agent.name;
-  
-  // Pass to analyzer
-  return response.handoff(
-    { name: 'analyzer-agent' },
-    { 
-      data: JSON.stringify(document),
-      contentType: 'application/json'
-    }
-  );
-};
-
-// Analyzer Agent
-const analyzerHandler: AgentHandler = async (request, response, context) => {
-  // Extract key information from documents
-  
-  const document = await request.data.json();
-  const content = document.content || '';
-  
-  // Simple analysis (in production, use NLP/LLM)
-  const analysis = {
-    word_count: content.split(' ').length,
-    char_count: content.length,
-    has_numbers: /\d/.test(content),
-    document_type: document.type,
-    analyzed_at: new Date().toISOString()
-  };
-  
-  // Combine with original document
-  document.analysis = analysis;
-  
-  // Pass to storage
+
+  // Default: explain what we can do
+  return response.json({
+    message: 'I can help with web research or summarization.',
+    examples: [
+      { type: 'web', query: 'latest AI developments' },
+      { type: 'summary', content: 'text to summarize', query: 'key points' }
+    ]
+  });
+};`} />
+
+### The Web Search Agent
+
+A specialist that searches the web and automatically forwards to summarizer:
+
+<CodeExample py={`async def run(request, response, context):
+    """Specialist agent for web searches."""
+
+    search_params = await request.data.json()
+    query = search_params.get("query")
+    max_results = search_params.get("max_results", 5)
+
+    context.logger.info(f"Searching web for: {query}")
+
+    # Simulate web search (in production, use actual search API)
+    search_results = [
+        {
+            "title": f"Result {i+1} for {query}",
+            "snippet": f"This is a relevant snippet about {query} with detailed information...",
+            "url": f"https://example.com/article-{i+1}",
+            "relevance_score": 0.9 - (i * 0.1)
+        }
+        for i in range(max_results)
+    ]
+
+    # Automatically hand off to summarizer for final processing
+    return response.handoff(
+        {"name": "summarizer"},
+        {
+            "content": search_results,
+            "original_query": query,
+            "source": "web_search"
+        },
+        {"previous_agent": "web-search", "search_count": len(search_results)}
+    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Specialist agent for web searches
+
+  const searchParams = await request.data.json();
+  const query = searchParams.query;
+  const maxResults = searchParams.max_results || 5;
+
+  context.logger.info(\`Searching web for: \${query}\`);
+
+  // Simulate web search (in production, use actual search API)
+  const searchResults = Array.from({ length: maxResults }, (_, i) => ({
+    title: \`Result \${i + 1} for \${query}\`,
+    snippet: \`This is a relevant snippet about \${query} with detailed information...\`,
+    url: \`https://example.com/article-\${i + 1}\`,
+    relevance_score: 0.9 - (i * 0.1)
+  }));
+
+  // Automatically hand off to summarizer for final processing
   return response.handoff(
-    { name: 'storage-agent' },
-    { 
-      data: JSON.stringify(document),
-      contentType: 'application/json'
+    { name: 'summarizer' },
+    {
+      data: JSON.stringify({
+        content: searchResults,
+        original_query: query,
+        source: 'web_search'
+      }),
+      contentType: 'application/json',
+      metadata: { previous_agent: 'web-search', search_count: searchResults.length }
     }
   );
-};
-
-// Storage Agent
-const storageHandler: AgentHandler = async (request, response, context) => {
-  // Store processed documents
-  
-  const document = await request.data.json();
-  
-  // Generate unique ID
-  const docId = \`doc_\${context.sessionId}\`;
-  
-  // Store in KV
-  await context.kv.set(
-    'processed_documents',
-    docId,
-    JSON.stringify(document)
-  );
-  
-  // Return confirmation
-  return response.json({
-    status: 'success',
-    document_id: docId,
-    processed_by: [
-      document.intake_agent,
-      'analyzer-agent',
-      'storage-agent'
-    ],
-    stored_at: new Date().toISOString()
-  });
 };`} />
 
-## Testing Your Multi-Agent System
+### The Summarizer Agent
+
+Takes search results and creates a final research summary:
 
-Test the document processing pipeline:
+<CodeExample py={`async def run(request, response, context):
+    """Specialist agent for summarizing research content."""
+
+    summary_request = await request.data.json()
+    content = summary_request.get("content", [])
+    original_query = summary_request.get("original_query", "")
+    source = summary_request.get("source", "unknown")
+
+    context.logger.info(f"Summarizing {len(content)} items for query: {original_query}")
+
+    # Process different content types
+    if source == "web_search" and isinstance(content, list):
+        # Handle web search results
+        summary_parts = []
+        for i, item in enumerate(content[:3]):  # Top 3 results
+            if isinstance(item, dict):
+                title = item.get("title", "")
+                snippet = item.get("snippet", "")
+                url = item.get("url", "")
+                relevance = item.get("relevance_score", 0)
+                summary_parts.append({
+                    "rank": i + 1,
+                    "title": title,
+                    "summary": snippet,
+                    "source_url": url,
+                    "relevance": relevance
+                })
+
+        final_summary = {
+            "query": original_query,
+            "summary": f"Research Summary for '{original_query}'",
+            "key_findings": summary_parts,
+            "total_sources": len(content),
+            "research_completed_at": datetime.now().isoformat(),
+            "agent_chain": ["orchestrator", "web-search", "summarizer"]
+        }
+    else:
+        # Handle direct text content
+        final_summary = {
+            "query": original_query,
+            "summary": f"Summary of content for '{original_query}'",
+            "content_length": len(str(content)),
+            "processed_at": datetime.now().isoformat(),
+            "agent_chain": ["orchestrator", "summarizer"]
+        }
+
+    # Return the final research summary to the user
+    return response.json(final_summary)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Specialist agent for summarizing research content
+
+  const summaryRequest = await request.data.json();
+  const content = summaryRequest.content || [];
+  const originalQuery = summaryRequest.original_query || '';
+  const source = summaryRequest.source || 'unknown';
+
+  context.logger.info(\`Summarizing \${Array.isArray(content) ? content.length : 1} items for query: \${originalQuery}\`);
+
+  // Process different content types
+  let finalSummary;
+
+  if (source === 'web_search' && Array.isArray(content)) {
+    // Handle web search results
+    const summaryParts = content.slice(0, 3).map((item, i) => ({
+      rank: i + 1,
+      title: item.title || '',
+      summary: item.snippet || '',
+      source_url: item.url || '',
+      relevance: item.relevance_score || 0
+    }));
+
+    finalSummary = {
+      query: originalQuery,
+      summary: \`Research Summary for '\${originalQuery}'\`,
+      key_findings: summaryParts,
+      total_sources: content.length,
+      research_completed_at: new Date().toISOString(),
+      agent_chain: ['orchestrator', 'web-search', 'summarizer']
+    };
+  } else {
+    // Handle direct text content
+    finalSummary = {
+      query: originalQuery,
+      summary: \`Summary of content for '\${originalQuery}'\`,
+      content_length: String(content).length,
+      processed_at: new Date().toISOString(),
+      agent_chain: ['orchestrator', 'summarizer']
+    };
+  }
+
+  // Return the final research summary to the user
+  return response.json(finalSummary);
+};`} />
+
+## Testing Your Research Orchestrator
+
+Test the research orchestrator system:
 
 ```bash
-# Test with a sample document
-curl -X POST https://your-project.agentuity.com/intake-agent \
+# Test web research routing
+curl -X POST https://your-project.agentuity.com/agents/orchestrator \
+  -H "Content-Type: application/json" \
+  -d '{
+    "type": "web",
+    "query": "latest developments in AI agents"
+  }'
+
+# Test direct summarization routing
+curl -X POST https://your-project.agentuity.com/agents/orchestrator \
   -H "Content-Type: application/json" \
   -d '{
-    "type": "text",
-    "content": "This is a test document with some numbers 12345."
+    "type": "summary",
+    "query": "key points",
+    "content": "Long text content to be summarized..."
   }'
 ```
 
-Expected flow:
-1. `intake-agent` validates and adds metadata
-2. `analyzer-agent` extracts information
-3. `storage-agent` saves and returns confirmation
+Expected flow for web research:
+1. `orchestrator` analyzes request and routes to web-search
+2. `web-search` finds results and forwards to summarizer
+3. `summarizer` creates final research summary and responds to client
 
 ## Key Takeaways
 
 - **Multi-agent systems** enable specialization, scalability, and modularity
-- **Handoff mechanism** allows agents to delegate tasks to other agents
-- **Orchestration patterns** include sequential, parallel, and conditional routing
-- **Best practices** include loop prevention, error handling, and request tracing
-- **Agentuity makes it simple** with built-in agent resolution and communication
+- **Handoff mechanism** allows agents to delegate tasks in a simple, sequential manner
+- **Orchestration patterns** include sequential chains, conditional routing, and smart orchestration
+- **Constraints matter**: Handoffs are one-way, agents can't call themselves, and responses go directly to clients
+- **Agentuity simplifies** multi-agent coordination with built-in agent resolution and communication
 
 ## What's Next?
 
@@ -846,4 +731,4 @@ Questions to consider:
 - How do you track what decisions agents are making?
 - How do you ensure compliance and audit requirements?
 
-Continue to [Module 5: Guardrails & Observability →](./05-guardrails-observability)
\ No newline at end of file
+Continue to [Module 5: Guardrails & Observability →](./05-guardrails-evals-observability)
\ No newline at end of file
diff --git a/content/Training/developers/05-guardrails-evals-observability.mdx b/content/Training/developers/05-guardrails-evals-observability.mdx
index 78e55b69..56654feb 100644
--- a/content/Training/developers/05-guardrails-evals-observability.mdx
+++ b/content/Training/developers/05-guardrails-evals-observability.mdx
@@ -7,9 +7,9 @@ You've built agents that can think, remember, and collaborate. Now it's time to
 
 ## The Reality of Production Agents
 
-Research from NeurIPS 2024 reveals that most AI agents succeed only [30-40% of the time on complex tasks](https://neurips.cc/virtual/2024/panel/agent-systems). When [Salesforce automated 50% of their support cases](https://www.sfchronicle.com/tech/article/salesforce-ai-job-cuts-benioff-21025920.php), the implementation challenges led to significant organizational restructuring. The gap between demo and production? Proper guardrails, systematic evaluation, and comprehensive observability.
+When [Salesforce deployed their Agentforce AI agents](https://www.hr-brew.com/stories/2025/03/04/salesforce-ai-agents-reskilling), they discovered that success required more than just technology - it demanded a comprehensive reskilling strategy for their 72,000+ employees. As their EVP of talent growth noted: "This rise of digital labor powered by AI agents is truly reshaping the way our businesses operate." The gap between demo and production? Proper guardrails, systematic evaluation, and comprehensive observability.
 
-According to [NIST's Generative AI Risk Management framework](https://nvlpubs.nist.gov/nistpubs/SpecialPublications/NIST.SP.1270e2025.pdf), the primary operational risks in AI systems include:
+According to [NIST's AI Risk Management framework](https://www.nist.gov/itl/ai-risk-management-framework), the primary operational risks in AI systems include:
 - **Hallucination**: Agents generating plausible but incorrect information
 - **Prompt Injection**: Adversarial inputs manipulating agent behavior
 - **Resource Consumption**: Uncontrolled usage leading to excessive costs
@@ -34,7 +34,7 @@ Guardrails prevent agents from harmful actions while preserving autonomy:
 
 Systematic evaluation is critical for non-deterministic agents:
 
-- **Industry Benchmarks**: [SWE-Bench](https://www.swebench.com/) (~20% success), [BrowserGym](https://browsergym.ai), [AgentHarm](https://arxiv.org/abs/2407.01564)
+- **Industry Benchmarks**: [SWE-Bench](https://www.swebench.com/) (success rate on software engineering tasks)
 - **Automated Testing**: Unit tests, integration tests, golden datasets
 - **Production Metrics**: Success rates, latency, cost per request
 - **A/B Testing**: Shadow deployments, gradual rollouts
@@ -297,6 +297,114 @@ const handler = async (request, response, context) => {
   }
 };`} />
 
+### Orchestrators as Natural Guardrails
+
+Remember the orchestrator pattern from Module 4? Orchestrators are your first line of defense:
+
+<CodeExample py={`from pydantic import BaseModel
+from typing import Literal
+
+class ValidatedIntent(BaseModel):
+    category: Literal['technical', 'sales', 'support']
+    confidence: float
+    sensitive: bool = False
+    
+async def orchestrator_with_guardrails(request, response, context):
+    user_prompt = await request.data.text()
+    
+    # 1. Input validation
+    if len(user_prompt) > 1000:
+        return response.json({"error": "Request too long"})
+    
+    # 2. Analyze intent with validation
+    intent = await analyze_intent(user_prompt, schema=ValidatedIntent)
+    
+    # 3. Apply routing rules
+    if intent.sensitive:
+        # Route sensitive requests to specialized agent
+        return response.handoff(
+            {"name": "compliance-agent"},
+            {"query": user_prompt, "flagged": True}
+        )
+    
+    if intent.confidence < 0.7:
+        # Low confidence = fallback to human
+        return response.json({
+            "message": "I'll connect you with a specialist",
+            "transfer": "human"
+        })
+    
+    # 4. Route to appropriate agent
+    agent_map = {
+        "technical": "tech-expert",
+        "sales": "sales-agent",
+        "support": "support-agent"
+    }
+    
+    return response.handoff(
+        {"name": agent_map[intent.category]},
+        {"query": user_prompt}
+    )`} js={`import { z } from 'zod';
+
+const ValidatedIntentSchema = z.object({
+  category: z.enum(['technical', 'sales', 'support']),
+  confidence: z.number(),
+  sensitive: z.boolean().default(false)
+});
+
+const orchestratorWithGuardrails = async (request, response, context) => {
+  const userPrompt = await request.data.text();
+  
+  // 1. Input validation
+  if (userPrompt.length > 1000) {
+    return response.json({ error: 'Request too long' });
+  }
+  
+  // 2. Analyze intent with validation
+  const { object: intent } = await analyzeIntent(userPrompt, {
+    schema: ValidatedIntentSchema
+  });
+  
+  // 3. Apply routing rules
+  if (intent.sensitive) {
+    // Route sensitive requests to specialized agent
+    return response.handoff(
+      { name: 'compliance-agent' },
+      { 
+        data: JSON.stringify({ query: userPrompt, flagged: true }),
+        contentType: 'application/json'
+      }
+    );
+  }
+  
+  if (intent.confidence < 0.7) {
+    // Low confidence = fallback to human
+    return response.json({
+      message: "I'll connect you with a specialist",
+      transfer: 'human'
+    });
+  }
+  
+  // 4. Route to appropriate agent
+  const agentMap = {
+    technical: 'tech-expert',
+    sales: 'sales-agent',
+    support: 'support-agent'
+  };
+  
+  return response.handoff(
+    { name: agentMap[intent.category] },
+    { data: userPrompt, contentType: 'text/plain' }
+  );
+};`} />
+
+**Why Orchestrators Make Great Guardrails:**
+1. **Single validation point** - Check all inputs before routing
+2. **Access control** - Decide who can access which agents
+3. **Fallback handling** - Gracefully handle edge cases
+4. **Audit trail** - Log all routing decisions
+5. **Rate limiting** - Apply per-user limits before delegation
+
 <Callout type="info">
 See the complete [Conference Concierge implementation](https://github.com/agentuity/agent-AIEWF2025-concierge-template) for a production example of multi-agent routing with schema validation.
 </Callout>
diff --git a/content/Training/developers/06-deployment-environments.mdx b/content/Training/developers/06-deployment-environments.mdx
index cdd023ef..c9e53f4d 100644
--- a/content/Training/developers/06-deployment-environments.mdx
+++ b/content/Training/developers/06-deployment-environments.mdx
@@ -7,9 +7,9 @@ You've built agents with memory, collaboration, and production-grade guardrails.
 
 ## The Reality of Enterprise Agent Deployment
 
-Research shows that [most organizations aren't "agent-ready"](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality) - they lack the infrastructure, processes, and understanding needed for production agents. When [Salesforce automated 50% of their support cases](https://www.sfchronicle.com/tech/article/salesforce-ai-job-cuts-benioff-21025920.php), it required massive organizational change alongside the technology.
+Research shows that [most organizations aren't "agent-ready"](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality) - they lack the infrastructure, processes, and understanding needed for production agents. When [Salesforce deployed their Agentforce AI agents](https://www.hr-brew.com/stories/2025/03/04/salesforce-ai-agents-reskilling), it required massive organizational change alongside the technology.
 
-The challenge isn't just technical - it's operational:
+The challenge involves both technical and operational considerations:
 - How do you test non-deterministic agents?
 - How do you safely roll out changes that affect customer interactions?
 - How do you monitor agents that make autonomous decisions?
@@ -25,9 +25,8 @@ Agentuity provides three distinct environments, each with specific purposes:
 Your local machine running DevMode:
 - Instant feedback with hot reload
 - Full debugging capabilities
-- Mock external services
-- Unlimited iterations
-- Direct file system access
+- Observability provided by Traceloop (OpenTelemetry integration)
+- Access to Agentuity API features (memory, etc)
 
 ```bash
 # Start local development
@@ -45,11 +44,9 @@ agentuity dev
 </Callout>
 
 Cloud deployment with test data:
-- Production infrastructure
-- Synthetic test data
 - Full observability
-- Performance testing
-- Integration testing
+- Options for different deployment configurations
+- Ability to use different keys and environment variables
 
 ```bash
 # Deploy to staging (coming soon)
@@ -60,10 +57,7 @@ Cloud deployment with test data:
 
 Full-scale deployment:
 - Auto-scaling infrastructure
-- Real user traffic
-- Complete monitoring
-- High availability
-- Disaster recovery
+- Complete monitoring, with the exact same experience as local development
 
 ```bash
 # Deploy to production
@@ -74,26 +68,26 @@ agentuity deploy
 
 ### Moving Through Environments
 
-Each environment serves as a gate to the next:
+The typical flow moves from local development to production with clear validation at each stage:
 
-| Stage | Purpose | Key Validation | Duration |
-|-------|---------|----------------|----------|
-| **Local Dev** | Build & iterate | Basic functionality | Hours to days |
-| **Staging** | Validate at scale | Performance, integration | Days to weeks |
-| **Production** | Serve users | Monitoring, optimization | Ongoing |
+| Stage | Purpose | Key Focus | Typical Timeline |
+|-------|---------|-----------|------------------|
+| **Local Dev** | Build & iterate rapidly | Feature development | Hours to days |
+| **Staging** | Validate production readiness | Performance & integration testing | Days to weeks |
+| **Production** | Serve real users | Monitoring & optimization | Ongoing |
 
-### Environment Testing Matrix
+### Environment Validation Focus
 
-Each environment requires different testing focus:
+Each environment emphasizes different aspects of your agent's readiness:
 
-| Testing Aspect | Development | Staging | Production |
-|----------------|------------|---------|------------|
-| **Core Functionality** | Basic input/output validation | Load testing with concurrent users | Success rate metrics |
-| **Memory & State** | Memory operations work correctly | Memory cleanup under load | Response time percentiles |
-| **Error Handling** | Validation catches bad inputs | Rate limiting works correctly | Error rate trends |
-| **Observability** | Logs provide debugging info | Meaningful telemetry spans | Cost per request tracking |
-| **Integration** | Error messages are helpful | External service integration | User satisfaction signals |
-| **Resilience** | Basic error recovery | Failover and recovery testing | Incident response time |
+| Focus Area | Development | Staging | Production |
+|------------|------------|---------|------------|
+| **Functionality** | Core features work | Load & stress testing | Success metrics |
+| **Memory & State** | Memory operations function | Memory performance under load | Response time tracking |
+| **Error Handling** | Validation works | Rate limiting effective | Error rate monitoring |
+| **Observability** | Debug information available | Telemetry accuracy | Performance insights |
+| **Integration** | Error messages helpful | External service testing | User experience metrics |
+| **Resilience** | Basic error recovery | Failover mechanisms | Incident response |
 
 ## Enterprise Deployment Options
 
@@ -102,10 +96,10 @@ Each environment requires different testing focus:
 </Callout>
 
 ### Private Cloud Deployments
-Deploy Agentuity infrastructure in your own cloud account. More information coming soon.
+Deploy Agentuity infrastructure in your own cloud account. More information coming soon!
 
 ### On-Premise Installations
-Run Agentuity entirely within your data center. More information coming soon.
+Run Agentuity entirely within your data center. More information coming soon!
 
 ## Configuration Management
 
@@ -113,61 +107,16 @@ Run Agentuity entirely within your data center. More information coming soon.
 
 Different environments need different configurations:
 
-<CodeExample py={`# config.py
-import os
-
-class Config:
-    """Environment-specific configuration"""
-    
-    def __init__(self):
-        self.env = os.getenv("AGENTUITY_ENVIRONMENT", "development")
-        
-        # Environment-specific settings
-        if self.env == "development":
-            self.log_level = "DEBUG"
-            self.rate_limit = 1000  # Generous for testing
-            self.cache_ttl = 60  # Short for quick iterations
-        elif self.env == "staging":
-            self.log_level = "INFO"
-            self.rate_limit = 100
-            self.cache_ttl = 300
-        else:  # production
-            self.log_level = "WARNING"
-            self.rate_limit = 50
-            self.cache_ttl = 3600
-            
-        # Feature flags
-        self.enable_experimental = self.env != "production"
-        self.verbose_errors = self.env == "development"`} js={`// config.js
-class Config {
-  constructor() {
-    this.env = process.env.AGENTUITY_ENVIRONMENT || 'development';
-    
-    // Environment-specific settings
-    switch(this.env) {
-      case 'development':
-        this.logLevel = 'DEBUG';
-        this.rateLimit = 1000;  // Generous for testing
-        this.cacheTTL = 60;  // Short for quick iterations
-        break;
-      case 'staging':
-        this.logLevel = 'INFO';
-        this.rateLimit = 100;
-        this.cacheTTL = 300;
-        break;
-      default:  // production
-        this.logLevel = 'WARNING';
-        this.rateLimit = 50;
-        this.cacheTTL = 3600;
-    }
-    
-    // Feature flags
-    this.enableExperimental = this.env !== 'production';
-    this.verboseErrors = this.env === 'development';
-  }
-}
-
-export default new Config();`} />
+{/* Environment-specific settings are typically configured through the Agentuity web console.
+Screenshots showing the web UI for environment configuration will be added here.
+
+The web console allows you to set:
+- Environment variables per deployment
+- Rate limiting and caching settings
+- Feature flags and deployment options
+- Observability and monitoring configuration */}
+
+*Environment-specific settings are managed through the Agentuity web console. Screenshots of the configuration interface will be provided here.*
 
 ## Real-World Deployment Lessons
 
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index 619f0747..fa28933a 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -5,6 +5,20 @@ description: Bringing it all together in a complete production system
 
 Time to combine everything you've learned into a complete, production-ready agent system.
 
+## Building Your Capstone
+
+As you work on your capstone project:
+
+1. **Review previous modules** - Each contains pieces you'll need
+2. **Start simple** - Get basic flow working first
+3. **Iterate** - Add features incrementally
+4. **Test thoroughly** - Each agent independently, then together
+5. **Monitor everything** - You can't fix what you can't see
+
+<Callout type="info">
+Pro Tip: Build your capstone iteratively. Start with two agents (triage + one specialist), get that working perfectly, then add more complexity.
+</Callout>
+
 ## Coming Soon: Agentic Sandbox
 
 <Callout type="info">
@@ -321,47 +335,56 @@ agentuity logs --follow
 
 Not interested in customer support? Choose an alternative:
 
-### Option 2: Research Assistant Team
+### Option 2: Deep Research System
 
-Build a multi-agent research system:
-- **Research Agent**: Finds relevant papers and articles
-- **Summarizer Agent**: Creates concise summaries
-- **Fact Checker**: Validates claims against sources
-- **Report Generator**: Produces final documents
+Build a comprehensive research and analysis system:
+- **Research Coordinator**: Routes queries to appropriate researchers
+- **Web Research Agent**: Searches and gathers online sources
+- **Academic Research Agent**: Finds scholarly articles and papers
+- **Analysis Agent**: Synthesizes information across sources
+- **Report Generator**: Creates structured research reports
+- **Fact Verification Agent**: Cross-checks claims and citations
 
 Key challenges:
-- Citation tracking
-- Source credibility scoring
-- Handling conflicting information
-- Long-form content generation
+- Multi-source information synthesis
+- Citation accuracy and tracking
+- Handling conflicting or outdated information
+- Maintaining research quality standards
+- Long-form document generation
 
-### Option 3: DevOps Assistant
+### Option 3: Financial Analysis System
 
-Build an operations helper:
-- **Monitor Agent**: Watches system metrics
-- **Diagnostics Agent**: Analyzes problems
-- **Remediation Agent**: Suggests or implements fixes
-- **Reporting Agent**: Creates incident reports
+Build a financial research and advisory system:
+- **Market Research Agent**: Gathers financial data and news
+- **Risk Assessment Agent**: Analyzes investment risks
+- **Portfolio Advisor**: Provides investment recommendations
+- **Compliance Agent**: Ensures regulatory adherence
+- **Report Generator**: Creates financial summaries
 
 Key challenges:
-- Real-time data processing
-- Safe remediation actions
-- Alert fatigue prevention
-- Root cause analysis
+- Real-time financial data processing
+- Risk calculation and modeling
+- Regulatory compliance requirements
+- Investment strategy optimization
+- Market sentiment analysis
+
+### Option 4: Content Creation Pipeline
+
+Build a multi-agent content production system:
+- **Content Planner**: Develops content strategies and schedules
+- **Research Agent**: Gathers information and sources
+- **Writer Agent**: Creates draft content
+- **Editor Agent**: Reviews and improves content quality
+- **SEO Optimizer**: Optimizes for search and engagement
+- **Publisher Agent**: Handles final formatting and distribution
 
-## Getting Help
-
-As you build your capstone:
-
-1. **Review previous modules** - Each contains pieces you'll need
-2. **Start simple** - Get basic flow working first
-3. **Iterate** - Add features incrementally
-4. **Test thoroughly** - Each agent independently, then together
-5. **Monitor everything** - You can't fix what you can't see
+Key challenges:
+- Content quality consistency
+- Brand voice maintenance
+- Multi-format content adaptation
+- Publishing workflow coordination
+- Performance analytics integration
 
-<Callout type="info">
-Pro Tip: Build your capstone iteratively. Start with two agents (triage + one specialist), get that working perfectly, then add more complexity.
-</Callout>
 
 ## Congratulations!
 
@@ -386,4 +409,4 @@ Welcome to the future of agent development! 🚀
 
 ---
 
-**Need help?** Join our [Discord community](https://discord.gg/agentuity) or check the [documentation](https://docs.agentuity.com)
\ No newline at end of file
+**Ready to dive deeper?** Check the [documentation](https://docs.agentuity.com) for advanced patterns and deployment guides.
\ No newline at end of file

From e209008366931805219bcd679dd08bad62ea8762 Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Wed, 24 Sep 2025 13:13:41 -0700
Subject: [PATCH 04/13] Update code examples & content

---
 .../developers/01-introduction-to-agents.mdx  |  261 ++--
 .../developers/02-anatomy-of-an-agent.mdx     |  625 +++++----
 .../Training/developers/03-agent-memory.mdx   |  570 ++++----
 .../developers/04-agent-collaboration.mdx     | 1149 ++++++++++-------
 ... => 05-observability-guardrails-evals.mdx} | 1085 ++++++++--------
 .../developers/06-deployment-environments.mdx |  184 +--
 .../developers/07-sandbox-capstone.mdx        |  511 +++-----
 content/Training/developers/index.mdx         |   24 +-
 content/Training/index.mdx                    |    4 +-
 9 files changed, 2188 insertions(+), 2225 deletions(-)
 rename content/Training/developers/{05-guardrails-evals-observability.mdx => 05-observability-guardrails-evals.mdx} (57%)

diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
index 43118e66..c4c39984 100644
--- a/content/Training/developers/01-introduction-to-agents.mdx
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -20,6 +20,11 @@ Traditional cloud platforms (AWS Lambda, Google Cloud Functions, Azure Functions
 - **Stateless execution** (agents need persistent memory)
 - **Edge distribution** (agents need GPU proximity)
 
+This makes them poorly suited for:
+- **Long-running reasoning** processes that require extended compute time
+- **Persistent state management** across multiple interactions
+- **Complex agent workflows** that span multiple reasoning cycles
+
 ## What Exactly Is an AI Agent?
 
 <Callout type="info">
@@ -141,10 +146,7 @@ Traditional cloud platforms face fundamental limitations when running agents:
 | Pay per request | Continuous operation | Costs explode unexpectedly |
 | Human-centric monitoring | Agent observability | Can't debug agent decisions |
 
-Major cloud providers are pushing to adapt to the needs of agents:
-- **AWS** launched Bedrock AgentCore (still in preview)
-- **Google** released their Agent Development Kit (ADK)
-- **Microsoft** is retrofitting Azure with agent capabilities
+Major cloud providers like AWS, Google, and Microsoft are working to adapt their platforms for agents.
 
 But retrofitting existing infrastructure is like turning a highway into an airport - technically possible, but not optimal.
 
@@ -154,9 +156,11 @@ But retrofitting existing infrastructure is like turning a highway into an airpo
 Learn more about the Agent-Native Cloud paradigm in our [Agent-Native Cloud](/Guides/agent-native-cloud) guide.
 </Callout>
 
-While others retrofit, Agentuity was built from day one specifically for agents. Our agent-native platform puts AI agents at the center of everything we do.
+While others retrofit, Agentuity was built from day one specifically for agents. Agentuity's agent-native platform puts AI agents at the center of everything.
+
+### The Agentuity Difference: Purpose-Built for Agents
 
-### Purpose-Built for Agents
+Instead of asking "How do we make Lambda work for agents?", we asked "What would infrastructure look like if agents were the only thing that mattered?"
 
 Agentuity provides what agents actually need:
 
@@ -165,17 +169,9 @@ Agentuity provides what agents actually need:
 - **Agent-to-agent communication**: Seamless and secure [channels between agents](/Guides/agent-communication)
 - **Native observability**: Track agent decisions with [built-in tracing](/Guides/agent-tracing)
 - **Automatic scaling**: Based on agent workload, not request count
-- **Framework agnostic**: Run LangChain, CrewAI, or custom agents side by side
+- **Framework agnostic**: Run LangChain, CrewAI, or custom agents side by side - and easily integrate with popular tools like the Vercel AI SDK for streamlined AI development
 
-### The Agentuity Difference
-
-Instead of asking "How do we make Lambda work for agents?", we asked "What would infrastructure look like if agents were the only thing that mattered?"
-
-The result is a platform where:
-- Agents are first-class citizens, not adapted workloads
-- Memory and state are built-in, not bolted on
-- Long-running is the default, not an exception
-- Agent communication is native, not a hack
+The result is a platform where agents are first-class citizens, not adapted workloads; memory and state are built-in, not bolted on; long-running is the default, not an exception; and agent communication is native, not a hack.
 
 ## Your First Agent: Hello, Autonomous World
 
@@ -195,9 +191,24 @@ Before we start, make sure you have:
 ### Quick Setup
 
 ```bash
-# Install the Agentuity CLI (see full installation guide for other OS)
+# Install the Agentuity CLI
+
+# NPM (if you have Node.js)
+npm install -g @agentuity/cli
+
+# Bun (if you have Bun)
+bun install -g @agentuity/cli
+
+# macOS (Homebrew)
 brew tap agentuity/tap && brew install agentuity
 
+# Universal installer (Windows/Linux/macOS)
+curl -fsS https://agentuity.sh | sh
+# Note: Verify the checksum from https://agentuity.com/install for security
+
+# Direct download from releases
+# Visit https://github.com/agentuity/cli/releases for your platform
+
 # Verify installation
 agentuity --version
 
@@ -211,39 +222,41 @@ Let's create a simple agent that demonstrates the key concepts we've learned:
 
 ```bash
 # Create a new agent project
-agentuity create hello-agent --template python-starter
-# or for TypeScript:
-# agentuity create hello-agent --template typescript-starter
+agentuity create hello-agent --template typescript-starter
+# or for Python:
+# agentuity create hello-agent --template python-starter
 
 # Navigate to the project
 cd hello-agent
 
-# Install dependencies (Python)
-pip install -r requirements.txt
-# or for TypeScript:
-# npm install
+# Install dependencies (TypeScript)
+npm install
+# or for Python:
+# pip install -r requirements.txt
 ```
 
 ### Understanding the Agent Structure
 
 Here's a simple "Hello Agent" that demonstrates the core concepts:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Get the name from request data
     data = await request.data.json()
     name = data.get("name", "World")
 
     # Return a simple greeting
-    return response.json({"message": f"Hello, {name}!"})`} js={`const handler = async (request, response, context) => {
+    return response.json({"message": f"Hello, {name}!"})`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Get the name from request data
   const data = await request.data.json();
   const name = data.name || 'World';
 
   // Return a simple greeting
   return response.json({ message: \`Hello, \${name}!\` });
-};
-
-export default handler;`} />
+}`} />
 
 This simple agent demonstrates:
 - **Request handling**: Accepts JSON input with a `name` field
@@ -256,8 +269,9 @@ This simple agent demonstrates:
 Let's enhance our agent with logging and a simple state counter:
 
 <CodeExample py={`from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Log the incoming request (built-in observability)
     context.logger.info("Hello agent received a request")
 
@@ -283,7 +297,9 @@ async def run(request, response, context):
         "message": f"Hello, {name}!",
         "greeting_number": count,
         "timestamp": datetime.now().isoformat()
-    })`} js={`const handler = async (request, response, context) => {
+    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Log the incoming request (built-in observability)
   context.logger.info('Hello agent received a request');
 
@@ -312,12 +328,10 @@ async def run(request, response, context):
     greeting_number: count,
     timestamp: new Date().toISOString()
   });
-};
-
-export default handler;`} />
+}`} />
 
 This enhanced agent demonstrates:
-- **Observability**: Built-in logging with context.logger
+- **Comprehensive Observability**: Built-in logging with context.logger plus automatic OpenTelemetry tracing that captures all operations (storage calls, external requests) as structured spans without any additional code
 - **State Management**: Simple counter using key-value storage
 - **Agent Memory**: One storage type (KV) without complexity
 - **Request/Response**: JSON input and structured output
@@ -351,7 +365,9 @@ Once DevMode is running:
 
 Add a `welcome()` function to your agent to create clickable test scenarios in DevMode:
 
-<CodeExample py={`def welcome():
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+
+def welcome():
     """Configure test scenarios for DevMode."""
     return {
         "welcome": "Welcome to my Hello Agent! Try these examples:",
@@ -371,8 +387,10 @@ Add a `welcome()` function to your agent to create clickable test scenarios in D
         ]
     }
 
-async def run(request, response, context):
-    # Your existing agent code...`} js={`export const welcome = () => {
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Your existing agent code...`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export const welcome = () => {
     return {
         welcome: "Welcome to my Hello Agent! Try these examples:",
         prompts: [
@@ -392,7 +410,7 @@ async def run(request, response, context):
     };
 };
 
-const handler: AgentHandler = async (request, response, context) => {
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
     // Your existing agent code...`} />
 
 These prompts appear as clickable buttons in the DevMode interface. Try calling the agent multiple times with the same name - it will remember you, and you can see the memory operations in the real-time logs!
@@ -424,101 +442,98 @@ Now that you have a working agent, let's enhance it with more capabilities. Use
 ### Challenge 1: Add Error Handling
 Enhance your agent with proper error handling and validation:
 
-<CodeExample py={`async def run(request, response, context):
-    try:
-        data = await request.data.json()
-        name = data.get("name")
-
-        if not name:
-            context.logger.warn("No name provided in request")
-            return response.json({"error": "Name is required"})
-
-        context.logger.info(f"Processing request for {name}")
-
-        # Your agent logic here
-        return response.json({"message": f"Hello, {name}!"})
-
-    except Exception as e:
-        context.logger.error(f"Error processing request: {str(e)}")
-        return response.json({"error": "Internal server error"})`} js={`const handler = async (request, response, context) => {
-  try {
-    const data = await request.data.json();
-    const name = data.name;
-
-    if (!name) {
-      context.logger.warn('No name provided in request');
-      return response.json({ error: 'Name is required' });
-    }
-
-    context.logger.info(\`Processing request for \${name}\`);
-
-    // Your agent logic here
-    return response.json({ message: \`Hello, \${name}!\` });
-
-  } catch (error) {
-    context.logger.error(\`Error processing request: \${error}\`);
-    return response.json({ error: 'Internal server error' });
-  }
-};`} />
-
-### Challenge 2: Add Time-Based Context
-Enhance your agent to greet differently based on the time of day:
-
-<CodeExample py={`from datetime import datetime
-
-async def run(request, response, context):
+<CodeExample py={`# Key pattern: Defensive error handling
+try:
     data = await request.data.json()
-    name = data.get("name", "World")
+    name = data.get("name")
 
-    # Time-based greeting
-    hour = datetime.now().hour
-    if hour < 12:
-        time_greeting = "Good morning"
-    elif hour < 17:
-        time_greeting = "Good afternoon"
-    else:
-        time_greeting = "Good evening"
+    if not name:
+        context.logger.warn("No name provided in request")
+        return response.json({"error": "Name is required"})
 
-    # Include your existing counter logic here
-    return response.json({
-        "message": f"{time_greeting}, {name}!",
-        "local_time": datetime.now().isoformat()
-    })`} js={`const handler = async (request, response, context) => {
+    # Your agent logic here...`} js={`// Key pattern: Defensive error handling
+try {
   const data = await request.data.json();
-  const name = data.name || 'World';
+  const name = data.name;
 
-  // Time-based greeting
-  const hour = new Date().getHours();
-  let timeGreeting;
-  if (hour < 12) {
-    timeGreeting = 'Good morning';
-  } else if (hour < 17) {
-    timeGreeting = 'Good afternoon';
-  } else {
-    timeGreeting = 'Good evening';
+  if (!name) {
+    context.logger.warn('No name provided in request');
+    return response.json({ error: 'Name is required' });
   }
 
-  // Include your existing counter logic here
-  return response.json({
-    message: \`\${timeGreeting}, \${name}!\`,
-    local_time: new Date().toISOString()
-  });
-};`} />
+  // Your agent logic here...`} />
 
-### Challenge 3: Combine Features
-Combine error handling, time-based greetings, and your counter into one robust agent.
+### Challenge 2: Handle Multiple Input Types
+Enhance your agent to handle both JSON and text inputs gracefully:
 
-### Testing Your Enhancements
+<CodeExample py={`# Key pattern: Flexible input handling
+try:
+    if request.data.contentType == "application/json":
+        data = await request.data.json()
+        name = data.get("name", "World")
+    elif request.data.contentType == "text/plain":
+        name = await request.data.text() or "World"
+    else:
+        name = "World"
+except Exception as e:
+    context.logger.error(f"Error parsing request: {e}")
+    name = "World"  # Graceful fallback`} js={`// Key pattern: Flexible input handling
+let name = 'World';
+try {
+  if (request.data.contentType === 'application/json') {
+    const data = await request.data.json();
+    name = data.name || 'World';
+  } else if (request.data.contentType === 'text/plain') {
+    name = await request.data.text() || 'World';
+  }
+} catch (error) {
+  context.logger.error(\`Error parsing request: \${error}\`);
+  // Graceful fallback to default
+}`} />
 
-After implementing each challenge:
-1. Update your `welcome()` function with relevant test scenarios
-2. Run `agentuity dev` to start DevMode
-3. Use the DevMode interface to test your changes
-4. Monitor the logs to verify your agent behaves correctly
-5. Check the Sessions tab to track performance and costs
+### Challenge 3: Complete Production Implementation
+
+Now let's combine all features (and add some simple storage provided by Agentuity) into a fully-functional agent.
+
+This complete implementation demonstrates:
+- **Error handling** with try/catch
+- **Multiple content types** (JSON and text input support)
+- **Statistics tracking** (personal greeting counts)
+- **Memory management** (stores only last 5 names)
+- **TTL storage** (24-hour expiration on stats)
+- **DevMode integration** with clickable test scenarios via `welcome()`
+- **Logging** for debugging and monitoring
+
+### Build This Agent Yourself
+
+Ready to implement this agent? Follow our complete examples:
+
+<div className="flex flex-wrap gap-3 mb-6">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/01-hello-world-ts" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    TypeScript
+  </a>
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/01_hello_world_py" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    Python
+  </a>
+</div>
+
+## Testing Your Complete Agent
+
+After implementing this complete version:
+1. Run `agentuity dev` to start DevMode
+2. Use the clickable prompts from the `welcome()` function
+3. Test with both JSON and text inputs
+4. Call the agent multiple times with the same name to see statistics
+5. Monitor the logs to see detailed operation tracking
+6. Check the key-value storage to see the personal greeting counts
+7. Check the Sessions tab for performance metrics
 
 <Callout type="info">
-For more examples, check our [Templates](/Introduction/templates) and [Examples](/Examples) sections.
+This complete implementation shows production patterns you'll use throughout the training modules. Notice how we handle errors gracefully, store data efficiently, and provide rich observability.
 </Callout>
 
 ## Key Takeaways
@@ -544,4 +559,4 @@ Remember: you're not just learning a new framework, you're learning a fundamenta
 
 ---
 
-**Ready for Module 2?** [The Anatomy of an Agent](./02-anatomy-of-an-agent)
\ No newline at end of file
+**Ready for Module 2?** [The Anatomy of an Agent](./02-anatomy-of-an-agent)
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index d5aa0a49..49d35b3c 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -37,187 +37,202 @@ Agents spring into action when triggered. Agentuity supports multiple trigger ty
 
 Each trigger provides different metadata and context:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Identify the trigger type
     trigger = request.trigger
-    
+
     if trigger == "webhook":
         # Handle HTTP request
         data = await request.data.json()
         context.logger.info(f"Webhook triggered with data: {data}")
-    
+
     elif trigger == "cron":
         # Handle scheduled execution
         context.logger.info(f"Cron job running at {datetime.now()}")
         # No input data for cron triggers
-    
+
     elif trigger == "agent":
         # Handle agent-to-agent call
         calling_agent = request.metadata.get("source_agent")
         context.logger.info(f"Called by agent: {calling_agent}")
-    
+
     return response.json({
         "trigger_type": trigger,
         "processed_at": datetime.now().isoformat()
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Identify the trigger type
   const trigger = request.trigger;
-  
+
   if (trigger === 'webhook') {
     // Handle HTTP request
     const data = await request.data.json();
     context.logger.info(\`Webhook triggered with data: \${JSON.stringify(data)}\`);
-  
+
   } else if (trigger === 'cron') {
     // Handle scheduled execution
     context.logger.info(\`Cron job running at \${new Date().toISOString()}\`);
     // No input data for cron triggers
-  
+
   } else if (trigger === 'agent') {
     // Handle agent-to-agent call
     const callingAgent = request.metadata.get('source_agent');
     context.logger.info(\`Called by agent: \${callingAgent}\`);
   }
-  
+
   return response.json({
     trigger_type: trigger,
     processed_at: new Date().toISOString()
   });
-};`} />
+}`} />
 
 ### 2. Request and Response Handling
 
 Every agent receives a request and must return a response. The request contains the trigger data and metadata, while the response can be in various formats:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Access request data in different formats
-    
+
     # JSON data (most common)
     json_data = await request.data.json()
-    
+
     # Plain text
     text_data = await request.data.text()
-    
+
     # Binary data
     binary_data = await request.data.binary()
-    
-    # Base64 encoded
-    base64_data = await request.data.base64()
-    
+
     # Response options
-    
+
     # JSON response (most common)
     return response.json({"result": "success"})
-    
+
     # Text response
     # return response.text("Hello, World!")
-    
+
     # HTML response
     # return response.html("<h1>Hello</h1>")
-    
+
     # Binary response (for files)
     # return response.binary(file_bytes)
-    
+
     # Redirect to another agent
-    # return response.handoff({"name": "other-agent"}, data, metadata={})`} js={`const handler: AgentHandler = async (request, response, context) => {
+    # return response.handoff({"name": "other-agent"}, data, metadata={})`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Access request data in different formats
-  
+
   // JSON data (most common)
   const jsonData = await request.data.json();
-  
+
   // Plain text
   const textData = await request.data.text();
-  
+
   // Binary data
   const binaryData = await request.data.binary();
-  
-  // Base64 encoded
-  const base64Data = await request.data.base64();
-  
+
   // Response options
-  
+
   // JSON response (most common)
   return response.json({ result: 'success' });
-  
+
   // Text response
   // return response.text('Hello, World!');
-  
+
   // HTML response
   // return response.html('<h1>Hello</h1>');
-  
+
   // Binary response (for files)
   // return response.binary(fileBytes);
-  
+
   // Redirect to another agent
   // return response.handoff({ name: 'other-agent' }, { data: jsonData, contentType: 'application/json' });
-};`} />
+}`} />
 
 ### 3. The Agent Context
 
-The context object is your agent's gateway to Agentuity's services. It provides access to storage, logging, tracing, and more:
+The context object is your agent's gateway to Agentuity's services. It provides access to storage, logging, tracing, agent communication, and more:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Logging at different levels
     context.logger.debug("Debug information")
     context.logger.info("General information")
     context.logger.warn("Warning message")
     context.logger.error("Error occurred")
-    
+
     # Access metadata
     agent_id = context.agent.id
     agent_name = context.agent.name
     project_id = context.projectId
     session_id = context.sessionId
-    
+
     # Key-Value storage
     await context.kv.set("cache", "key", {"data": "value"})
     result = await context.kv.get("cache", "key")
-    
+
     # Vector storage for semantic search
     await context.vector.upsert("docs", [{
         "key": "doc1",
         "document": "AI agents are autonomous systems",
         "metadata": {"category": "intro"}
     }])
-    
+
     # Object storage for files
     await context.objectstore.put("files", "report.pdf", pdf_bytes)
-    
+
+    # Get reference to another agent for inter-agent communication
+    other_agent = context.get_agent("specialist-agent")
+    # agent_response = await other_agent.run({"data": "Hello from triage agent"})
+
     return response.json({
         "agent": agent_name,
         "session": session_id
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Logging at different levels
   context.logger.debug('Debug information');
   context.logger.info('General information');
   context.logger.warn('Warning message');
   context.logger.error('Error occurred');
-  
+
   // Access metadata
   const agentId = context.agent.id;
   const agentName = context.agent.name;
   const projectId = context.projectId;
   const sessionId = context.sessionId;
-  
+
   // Key-Value storage
-  await context.kv.set('cache', 'key', JSON.stringify({ data: 'value' }));
+  await context.kv.set('cache', 'key', { data: 'value' });
   const result = await context.kv.get('cache', 'key');
-  
+
   // Vector storage for semantic search
-  await context.vector.upsert('docs', {
+  await context.vector.upsert('docs', [{
     key: 'doc1',
     document: 'AI agents are autonomous systems',
     metadata: { category: 'intro' }
-  });
-  
+  }]);
+
   // Object storage for files
   await context.objectstore.put('files', 'report.pdf', pdfBytes);
-  
+
+  // Get reference to another agent for inter-agent communication
+  const otherAgent = context.getAgent({ name: 'specialist-agent' });
+  // const agentResponse = await otherAgent.run({ data: 'Hello from triage agent' });
+
   return response.json({
     agent: agentName,
     session: sessionId
   });
-};`} />
+}`} />
 
 ## Planning and Reasoning: The Agent's Brain
 
@@ -254,8 +269,9 @@ Agents become powerful when they can use external tools and services:
 <CodeExample py={`import httpx
 import os
 from typing import Dict, Any
+from agentuity import AgentRequest, AgentResponse, AgentContext
 
-async def use_web_search(query: str, context) -> Dict[str, Any]:
+async def use_web_search(query: str, context: AgentContext) -> Dict[str, Any]:
     """Search the web using a real API."""
     try:
         # Example using a hypothetical search API
@@ -274,10 +290,10 @@ async def use_web_search(query: str, context) -> Dict[str, Any]:
         context.logger.error(f"Search failed: {str(e)}")
         return {"error": "Search failed"}
 
-async def call_another_agent(agent_name: str, data: dict, context) -> Dict[str, Any]:
+async def call_another_agent(agent_name: str, data: dict, context: AgentContext) -> Dict[str, Any]:
     """Call another agent within the same project."""
     try:
-        agent = await context.getAgent({"name": agent_name})
+        agent = context.get_agent(agent_name)
         result = await agent.run({
             "data": data,
             "contentType": "application/json"
@@ -287,7 +303,7 @@ async def call_another_agent(agent_name: str, data: dict, context) -> Dict[str,
         context.logger.error(f"Agent call failed: {str(e)}")
         return {"error": "Agent call failed"}
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     data = await request.data.json()
     tool = data.get("tool")
 
@@ -298,7 +314,9 @@ async def run(request, response, context):
     else:
         result = {"error": "Unknown tool"}
 
-    return response.json(result)`} js={`async function useWebSearch(query: string, context: any): Promise<any> {
+    return response.json(result)`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+async function useWebSearch(query: string, context: AgentContext): Promise<any> {
   try {
     // Example using a hypothetical search API
     const apiKey = process.env.SEARCH_API_KEY;
@@ -316,9 +334,9 @@ async def run(request, response, context):
   }
 }
 
-async function callAnotherAgent(agentName: string, data: any, context: any): Promise<any> {
+async function callAnotherAgent(agentName: string, data: any, context: AgentContext): Promise<any> {
   try {
-    const agent = await context.getAgent({ name: agentName });
+    const agent = context.getAgent({ name: agentName });
     const result = await agent.run({
       data,
       contentType: 'application/json'
@@ -330,7 +348,7 @@ async function callAnotherAgent(agentName: string, data: any, context: any): Pro
   }
 }
 
-const handler: AgentHandler = async (request, response, context) => {
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const data = await request.data.json();
   const tool = data.tool;
 
@@ -344,7 +362,7 @@ const handler: AgentHandler = async (request, response, context) => {
   }
 
   return response.json(result);
-};`} />
+}`} />
 
 ## Memory Patterns: How Agents Remember
 
@@ -354,8 +372,9 @@ Memory enables agents to learn and maintain state across interactions. The durat
 For temporary data that should expire:
 
 <CodeExample py={`from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     session_id = request.metadata.get("session_id")
 
     # Store temporary session data with TTL
@@ -374,26 +393,31 @@ async def run(request, response, context):
     session_data = await context.kv.get("sessions", session_id)
     if session_data.exists:
         data = await session_data.data.json()
-        context.logger.info(f"Session active for {len(data['messages'])} messages")`} js={`const handler: AgentHandler = async (request, response, context) => {
+        context.logger.info(f"Session active for {len(data['messages'])} messages")`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const sessionId = request.metadata.get('session_id');
 
   // Store temporary session data with TTL
   await context.kv.set(
     'sessions',
     sessionId,
-    JSON.stringify({
+    {
       messages: [],
-      context: {},
+      user_preferences: {},
       timestamp: new Date().toISOString()
-    }),
+    },
     { ttl: 3600 } // Expires in 1 hour
   );
-};`} />
+}`} />
 
 ### Persistent Memory
 For data that should survive restarts:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     user_id = request.metadata.get("user_id")
 
     # Store user preferences permanently (no TTL)
@@ -413,7 +437,9 @@ For data that should survive restarts:
         "user_documents",
         f"{user_id}/resume.pdf",
         pdf_bytes
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
+    )`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const userId = request.metadata.get('user_id');
 
   // Store user preferences permanently (no TTL)
@@ -434,12 +460,14 @@ For data that should survive restarts:
     \`\${userId}/resume.pdf\`,
     pdfBytes
   );
-};`} />
+}`} />
 
 ### Searchable Memory
 For semantic search and knowledge retrieval:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Store searchable knowledge
     await context.vector.upsert("knowledge", [{
         "key": "user_feedback_001",
@@ -462,7 +490,9 @@ For semantic search and knowledge retrieval:
     if results:
         context.logger.info(f"Found {len(results)} relevant insights")
         for result in results:
-            context.logger.info(f"Insight: {result.document}")`} js={`const handler: AgentHandler = async (request, response, context) => {
+            context.logger.info(f"Insight: {result.document}")`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Store searchable knowledge
   await context.vector.upsert('knowledge', [{
     key: 'user_feedback_001',
@@ -488,7 +518,7 @@ For semantic search and knowledge retrieval:
       context.logger.info(\`Insight: \${result.document}\`);
     });
   }
-};`} />
+}`} />
 
 ## Framework Awareness: Choosing the Right Tool
 
@@ -505,6 +535,8 @@ Different frameworks excel at different tasks. Here's when to use each:
 | **LangChain** | Complex chains, RAG applications | Python, TypeScript | Native SDK support |
 | **CrewAI** | Multi-agent teams, role-based systems | Python | Container deployment |
 | **AutoGen** | Research, conversational AI | Python | Direct deployment |
+| **Mastra** | TypeScript agents, workflows, modern DX | TypeScript | Full compatibility |
+| **Vercel AI SDK** | UI-integrated agents, streaming, web apps | TypeScript | Direct integration |
 | **Custom** | Specific requirements, full control | Python, TypeScript, Bun | Full platform features |
 
 ### Framework Comparison Example
@@ -512,7 +544,9 @@ Different frameworks excel at different tasks. Here's when to use each:
 Here's the same agent built with different approaches:
 
 <CodeExample py={`# Vanilla Python Agent
-async def run(request, response, context):
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     data = await request.data.json()
     # Direct implementation
     result = process_data(data)
@@ -521,8 +555,9 @@ async def run(request, response, context):
 # LangChain Agent
 from langchain.agents import initialize_agent
 from langchain.llms import OpenAI
+from agentuity import AgentRequest, AgentResponse, AgentContext
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     llm = OpenAI()
     agent = initialize_agent(tools, llm, agent="zero-shot")
     result = agent.run(await request.data.text())
@@ -530,41 +565,47 @@ async def run(request, response, context):
 
 # CrewAI Agent
 from crewai import Agent, Task, Crew
+from agentuity import AgentRequest, AgentResponse, AgentContext
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     researcher = Agent(role="Researcher", goal="Find information")
     writer = Agent(role="Writer", goal="Create content")
-    
+
     crew = Crew(agents=[researcher, writer])
     result = crew.kickoff(await request.data.json())
     return response.json(result)`} js={`// Vanilla TypeScript Agent
-const handler: AgentHandler = async (request, response, context) => {
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const data = await request.data.json();
   // Direct implementation
   const result = processData(data);
   return response.json(result);
-};
+}
 
 // LangChain Agent
 import { initializeAgentExecutor } from 'langchain/agents';
 import { OpenAI } from 'langchain/llms/openai';
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
 
-const handler: AgentHandler = async (request, response, context) => {
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const llm = new OpenAI();
   const agent = await initializeAgentExecutor(tools, llm, 'zero-shot');
   const result = await agent.call({ input: await request.data.text() });
   return response.text(result.output);
-};
+}
 
 // Custom Multi-Agent System
-const handler: AgentHandler = async (request, response, context) => {
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const researcher = new Agent('Researcher', 'Find information');
   const writer = new Agent('Writer', 'Create content');
-  
+
   const researchResult = await researcher.execute(data);
   const writeResult = await writer.execute(researchResult);
   return response.json(writeResult);
-};`} />
+}`} />
 
 ### When to Use Which Framework
 
@@ -577,258 +618,198 @@ const handler: AgentHandler = async (request, response, context) => {
 
 ## Lab: Building a Weather Agent with Multiple Triggers
 
-Let's build an agent that demonstrates different behaviors based on how it's triggered. This weather agent will show you how the same code can serve different purposes:
+Let's build an agent that demonstrates different behaviors based on how it's triggered - the same agent code serves different purposes depending on the trigger type.
 
-<CodeExample py={`from datetime import datetime
+### Key Implementation: Trigger-Based Routing
 
-async def run(request, response, context):
-    """Weather agent with different trigger behaviors."""
+The core pattern shows how agents can behave differently based on their trigger:
 
-    trigger = request.trigger
-    context.logger.info(f"Weather agent triggered via: {trigger}")
+<CodeExample py={`# Key pattern: Different behavior based on trigger type
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    if request.trigger == "cron":
+        # Bulk monitoring mode
+        context.logger.info("Running scheduled weather monitoring")
+        return await monitor_multiple_cities(context)
+    else:
+        # On-demand single query
+        data = await request.data.json()
+        location = data.get("location", "San Francisco, CA")
+        return await get_single_weather(location, context)`} js={`// Key pattern: Different behavior based on trigger type
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
+  if (request.trigger === 'cron') {
+    // Bulk monitoring mode
+    context.logger.info('Running scheduled weather monitoring');
+    return await monitorMultipleCities(context);
+  } else {
+    // On-demand single query
+    const data = await request.data.json();
+    const location = data.location || 'San Francisco, CA';
+    return await getSingleWeather(location, context);
+  }
+}`} />
 
-    if trigger == "webhook":
-        # Manual requests for specific cities
-        try:
-            data = await request.data.json()
-            city = data.get("city", "London")
-        except:
-            city = await request.data.text() or "London"
-
-        context.logger.info(f"Manual weather request for: {city}")
-
-        # Check cache first (10 minutes TTL)
-        cache_key = f"weather_{city.lower()}"
-        cached = await context.kv.get("weather_cache", cache_key)
-
-        if cached.exists:
-            weather = await cached.data.json()
-            context.logger.info(f"Returning cached weather for {city}")
-            return response.json({
-                **weather,
-                "cached": True,
-                "cache_age_minutes": 5  # Mock age
-            })
-
-        # Mock weather data (in production, call real API)
-        weather = {
-            "city": city,
-            "temperature": 22,
-            "description": "partly cloudy",
-            "humidity": 65,
-            "timestamp": datetime.now().isoformat()
-        }
+### Key Implementation: External API Integration
+
+Real-world agents integrate with external services using proper error handling:
 
-        # Cache for 10 minutes
-        await context.kv.set("weather_cache", cache_key, weather, {"ttl": 600})
+<CodeExample py={`# Key pattern: NWS API two-step process with proper error handling
+async def fetch_nws_weather(lat: float, lon: float, location_name: str, context: AgentContext):
+    try:
+        # Step 1: Get grid coordinates from lat/lon
+        points_url = f"https://api.weather.gov/points/{lat},{lon}"
 
-        return response.json({**weather, "cached": False})
+        async with aiohttp.ClientSession() as session:
+            async with session.get(points_url, headers={"User-Agent": USER_AGENT},
+                                 timeout=aiohttp.ClientTimeout(total=10)) as points_response:
+                if points_response.status != 200:
+                    raise Exception(f"NWS points API error: {points_response.status}")
 
-    elif trigger == "cron":
-        # Batch update for major cities
-        cities = ["London", "New York", "Tokyo", "Sydney"]
-        context.logger.info(f"Cron job: Updating weather for {len(cities)} cities")
-
-        weather_data = {}
-        for city in cities:
-            # Mock weather data
-            weather_data[city] = {
-                "temperature": 20 + hash(city) % 15,  # Mock variation
-                "description": "sunny",
-                "updated": datetime.now().isoformat()
-            }
-
-        # Store daily weather report
-        await context.kv.set("weather_reports", "daily", weather_data, {"ttl": 86400})
-
-        return response.json({
-            "task": "weather_update",
-            "cities_updated": len(cities),
-            "timestamp": datetime.now().isoformat()
-        })
+                points_data = await points_response.json()
+                grid_props = points_data.get("properties", {})
 
-    elif trigger == "manual":
-        # DevMode testing - show available commands
-        return response.json({
-            "message": "Weather Agent DevMode",
-            "commands": [
-                "Test webhook: POST {\"city\": \"Paris\"}",
-                "Test cron: Use simulate button in DevMode"
-            ],
-            "current_time": datetime.now().isoformat()
-        })
+                # Extract and validate grid data
+                grid_id = grid_props.get("gridId")
+                grid_x = grid_props.get("gridX")
+                grid_y = grid_props.get("gridY")
 
-    else:
-        return response.json({
-            "error": f"Unsupported trigger: {trigger}",
-            "supported": ["webhook", "cron", "manual"]
-        })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const trigger = request.trigger;
-  context.logger.info(\`Weather agent triggered via: \${trigger}\`);
+                if not all([grid_id, grid_x, grid_y]):
+                    raise Exception("Invalid grid data from NWS points API")
 
-  if (trigger === 'webhook') {
-    // Manual requests for specific cities
-    let city = 'London';
-    try {
-      const data = await request.data.json();
-      city = data.city || 'London';
-    } catch {
-      city = await request.data.text() || 'London';
-    }
+            # Step 2: Get forecast using grid coordinates
+            forecast_url = f"https://api.weather.gov/gridpoints/{grid_id}/{grid_x},{grid_y}/forecast"
+            # ... fetch and process forecast data
 
-    context.logger.info(\`Manual weather request for: \${city}\`);
+    except Exception as e:
+        context.logger.error(f"Weather API failed for {location_name}: {e}")
+        raise`} js={`// Key pattern: NWS API two-step process with proper error handling
+async function fetchNWSWeather(lat: number, lon: number, locationName: string, context: AgentContext): Promise<WeatherResult | null> {
+  try {
+    // Step 1: Get grid coordinates from lat/lon
+    const pointsUrl = \`https://api.weather.gov/points/\${lat},\${lon}\`;
 
-    // Check cache first (10 minutes TTL)
-    const cacheKey = \`weather_\${city.toLowerCase()}\`;
-    const cached = await context.kv.get('weather_cache', cacheKey);
+    const pointsResponse = await fetch(pointsUrl, {
+      headers: { 'User-Agent': USER_AGENT },
+      signal: AbortSignal.timeout(10000)  // 10 second timeout
+    });
 
-    if (cached.exists) {
-      const weather = await cached.data.json();
-      context.logger.info(\`Returning cached weather for \${city}\`);
-      return response.json({
-        ...weather,
-        cached: true,
-        cache_age_minutes: 5  // Mock age
-      });
+    if (!pointsResponse.ok) {
+      throw new Error(\`NWS points API failed: \${pointsResponse.status} \${pointsResponse.statusText}\`);
     }
 
-    // Mock weather data (in production, call real API)
-    const weather = {
-      city,
-      temperature: 22,
-      description: 'partly cloudy',
-      humidity: 65,
-      timestamp: new Date().toISOString()
-    };
-
-    // Cache for 10 minutes
-    await context.kv.set('weather_cache', cacheKey, weather, { ttl: 600 });
+    const pointsData = await pointsResponse.json() as NWSPointsResponse;
+    const gridProps = pointsData.properties;
 
-    return response.json({ ...weather, cached: false });
+    // Validate and extract grid properties
+    if (!gridProps || gridProps.gridId === undefined || gridProps.gridX === undefined || gridProps.gridY === undefined) {
+      throw new Error('Could not extract grid information from NWS points API response.');
+    }
 
-  } else if (trigger === 'cron') {
-    // Batch update for major cities
-    const cities = ['London', 'New York', 'Tokyo', 'Sydney'];
-    context.logger.info(\`Cron job: Updating weather for \${cities.length} cities\`);
-
-    const weatherData: Record<string, any> = {};
-    cities.forEach(city => {
-      // Mock weather data with variation
-      weatherData[city] = {
-        temperature: 20 + (city.length % 15),  // Mock variation
-        description: 'sunny',
-        updated: new Date().toISOString()
-      };
-    });
+    // Step 2: Get forecast using grid coordinates
+    const forecastUrl = \`https://api.weather.gov/gridpoints/\${gridProps.gridId}/\${gridProps.gridX},\${gridProps.gridY}/forecast\`;
+    // ... fetch and process forecast data
 
-    // Store daily weather report
-    await context.kv.set('weather_reports', 'daily', weatherData, { ttl: 86400 });
+  } catch (error) {
+    context.logger.error(\`Weather API failed for \${locationName}: \${error}\`);
+    throw new Error(\`Weather service unavailable: \${error instanceof Error ? error.message : 'Unknown error'}\`);
+  }
+}`} />
+
+### Key Implementation: Smart Caching Strategies
+
+Different caching approaches based on use case and trigger:
+
+<CodeExample py={`# Key pattern: Trigger-based caching with different TTL strategies
+async def handle_manual_trigger(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Parse location and create cache key
+    location_query = await request.data.text() or "San Francisco"
+    cache_key = f"city_{location_query.lower().replace(' ', '_')}"
+
+    # Check cache first (5 minutes for manual requests)
+    cached = await context.kv.get("weather", cache_key)
+    if cached.exists:
+        cached_weather = await cached.data.json()
+        context.logger.info(f"Returning cached weather for {location_query}")
+        return response.json(cached_weather)
+
+    # Fetch fresh data and cache with shorter TTL
+    weather = await fetch_nws_weather(coordinates["lat"], coordinates["lon"], location_query, context)
+    await context.kv.set("weather", cache_key, weather, {"ttl": 300})  # 5 minutes
+
+    return response.json(weather)
+
+async def handle_cron_trigger(response: AgentResponse, context: AgentContext):
+    # Bulk processing with longer cache (1 hour for monitoring)
+    for city in MONITORED_CITIES:
+        weather = await fetch_nws_weather(city["lat"], city["lon"], city["name"], context)
+        await context.kv.set("weather", f"city_{city['name'].lower()}", weather, {"ttl": 3600})
+        context.logger.info(f"Cached weather for {city['name']}: {weather['temperature']}°F")`} js={`// Key pattern: Trigger-based caching with different TTL strategies
+async function handleManualTrigger(request: AgentRequest, response: AgentResponse, context: AgentContext) {
+  // Parse location and create cache key
+  const locationQuery = await request.data.text() || 'San Francisco';
+  const cacheKey = \`city_\${locationQuery.toLowerCase().replace(/\\s+/g, '_')}\`;
+
+  // Check cache first (5 minutes for manual requests)
+  const cached = await context.kv.get('weather', cacheKey);
+  if (cached.exists) {
+    const cachedWeather = await cached.data.json() as WeatherResult;
+    context.logger.info(\`Returning cached weather for \${locationQuery}\`);
+    return response.json(cachedWeather);
+  }
 
-    return response.json({
-      task: 'weather_update',
-      cities_updated: cities.length,
-      timestamp: new Date().toISOString()
-    });
+  // Fetch fresh data and cache with shorter TTL
+  const weather = await fetchNWSWeather(coordinates.lat, coordinates.lon, locationQuery, context);
+  await context.kv.set('weather', cacheKey, weather, { ttl: 300 }); // 5 minutes
 
-  } else if (trigger === 'manual') {
-    // DevMode testing - show available commands
-    return response.json({
-      message: 'Weather Agent DevMode',
-      commands: [
-        'Test webhook: POST {"city": "Paris"}',
-        'Test cron: Use simulate button in DevMode'
-      ],
-      current_time: new Date().toISOString()
-    });
+  return response.json(weather);
+}
 
-  } else {
-    return response.json({
-      error: \`Unsupported trigger: \${trigger}\`,
-      supported: ['webhook', 'cron', 'manual']
-    });
+async function handleCronTrigger(response: AgentResponse, context: AgentContext) {
+  // Bulk processing with longer cache (1 hour for monitoring)
+  for (const city of MONITORED_CITIES) {
+    const weather = await fetchNWSWeather(city.lat, city.lon, city.name, context);
+    await context.kv.set('weather', \`city_\${city.name.toLowerCase()}\`, weather, { ttl: 3600 });
+    context.logger.info(\`Cached weather for \${city.name}: \${weather.temperature}°F\`);
   }
-};`} />
+}`} />
 
-### Testing Your Weather Agent
+### Build This Agent Yourself
 
-<Callout type="info">
-DevMode makes it easy to test all trigger types. You can simulate webhooks, test manual triggers, and even simulate cron jobs through the interface.
-</Callout>
+Ready to implement this agent? Follow our complete examples:
+
+<div className="flex flex-wrap gap-3 mb-6">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/02-weather-agent-ts" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    TypeScript
+  </a>
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/02_weather_agent_py" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    Python
+  </a>
+</div>
+
+### What This Agent Demonstrates
+
+- **Trigger-based behavior**: Same agent code behaves differently based on trigger type
+- **External API integration**: Real National Weather Service API calls with proper error handling
+- **Smart caching strategies**: Different TTL based on use case (cron vs manual)
+- **Production patterns**: Timeouts, defensive typing, comprehensive logging
+- **AI enhancement**: Vercel AI SDK for weather interpretation
 
-#### What This Agent Demonstrates
-
-- **Webhook trigger**: Handles real-time weather requests with caching
-- **Cron trigger**: Batch updates for multiple cities
-- **Manual trigger**: DevMode testing and debugging interface
-- **Caching strategy**: Uses TTL to balance freshness and performance
-- **Error handling**: Graceful fallbacks for different input types
-
-Try calling this agent with different cities and watch how it caches responses for efficiency!
-
-<CodeExample py={`def welcome():
-    """Configure test scenarios for different trigger types."""
-    return {
-        "welcome": "Multi-Trigger Agent Test Suite",
-        "prompts": [
-            # Webhook trigger tests
-            {
-                "data": {"action": "store", "key": "test", "value": "data"},
-                "contentType": "application/json"
-            },
-            {
-                "data": {"action": "retrieve", "key": "test"},
-                "contentType": "application/json"
-            },
-            # Simulate what a cron trigger would do
-            {
-                "data": {"_simulate_cron": True},
-                "contentType": "application/json"
-            },
-            # Simulate agent-to-agent communication
-            {
-                "data": {"message": "Hello from another agent", "source_agent": "agent_123"},
-                "contentType": "application/json"
-            }
-        ]
-    }`} js={`export const welcome = () => {
-    return {
-        welcome: "Multi-Trigger Agent Test Suite",
-        prompts: [
-            // Webhook trigger tests
-            {
-                data: JSON.stringify({ action: "store", key: "test", value: "data" }),
-                contentType: "application/json"
-            },
-            {
-                data: JSON.stringify({ action: "retrieve", key: "test" }),
-                contentType: "application/json"
-            },
-            // Simulate what a cron trigger would do
-            {
-                data: JSON.stringify({ _simulate_cron: true }),
-                contentType: "application/json"
-            },
-            // Simulate agent-to-agent communication
-            {
-                data: JSON.stringify({ message: "Hello from another agent", source_agent: "agent_123" }),
-                contentType: "application/json"
-            }
-        ]
-    };
-};`} />
-
-#### Testing in DevMode
+The complete examples show you how to build real agents that integrate external APIs and use multiple triggers with caching and error handling.
+
+## Testing Your Weather Agent
 
 1. **Start DevMode:**
 ```bash
 agentuity dev
 ```
 
-2. **Open the DevMode interface** and click the pre-configured prompts to test different scenarios
-
-3. **Monitor the execution** in the Logs and Sessions tabs
+2. **Test the weather agent** with different city names and trigger types
+3. **Monitor the execution** in the Logs and Sessions tabs to see caching behavior
 
-#### Configuring Cron Triggers for Production
+### Configuring Cron Triggers for Production
 
 For actual scheduled execution, configure cron triggers through the [Agentuity Console](https://app.agentuity.com):
 
@@ -852,20 +833,24 @@ Effective cost optimization strategies include:
 
 - **Cache frequently used data** in KV storage to reduce repeated processing
 - **Batch operations** when possible to minimize API calls
-- **Use appropriate LLM models** - use reasoning models (like GPT-4) only when you need complex reasoning
+- **Use appropriate LLM models** - use reasoning models only when you need complex reasoning
 - **Consider fast inference providers** - Groq offers high-speed inference for many models
 - **Implement early exits** in reasoning loops to avoid unnecessary iterations
 
 ### Latency vs. Capability Trade-offs
 
+Different approaches offer varying trade-offs between speed and intelligence:
+
 | Approach | Latency | Capability | Use Case |
 |----------|---------|------------|----------|
-| Simple rules | &lt;100ms | Low | Basic routing |
-| Small LLM | 200-500ms | Medium | Classification |
-| Large LLM | 1-3s | High | Complex reasoning |
-| Multi-agent | 3-10s | Very High | Research tasks |
+| Simple rules | Fastest | Low | Basic routing, simple classification |
+| Small LLM | Fast | Medium | Text classification, simple reasoning |
+| Large LLM | Moderate | High | Complex reasoning, nuanced understanding |
+| Multi-agent | Slowest | Very High | Research, complex workflows |
+
+<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
 
-<CodeExample py={`async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     data = await request.data.json()
     complexity = assess_complexity(data)
     
@@ -882,26 +867,28 @@ Effective cost optimization strategies include:
     else:
         # Use full agent capabilities
         result = await full_agent_process(data, context)
-        return response.json(result)`} js={`const handler: AgentHandler = async (request, response, context) => {
+        return response.json(result)`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const data = await request.data.json();
   const complexity = assessComplexity(data);
-  
+
   if (complexity === 'simple') {
     // Use rules-based approach
     const result = applyRules(data);
     return response.json(result);
-  
+
   } else if (complexity === 'medium') {
     // Use small, fast model
     const result = await smallModelProcess(data);
     return response.json(result);
-  
+
   } else {
     // Use full agent capabilities
     const result = await fullAgentProcess(data, context);
     return response.json(result);
   }
-};`} />
+}`} />
 
 ## Key Takeaways
 
@@ -926,4 +913,4 @@ Remember: The anatomy you've learned here is the foundation. The intelligence yo
 
 ---
 
-**Ready for Module 3?** [Agent Memory](./03-agent-memory)
\ No newline at end of file
+**Ready for Module 3?** [Agent Memory](./03-agent-memory)
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
index 1a446855..b9b99844 100644
--- a/content/Training/developers/03-agent-memory.mdx
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -60,7 +60,7 @@ async def run(request, response, context):
 ```python
 # Short-term memory for session continuity
 async def run(request, response, context):
-    session_id = request.metadata.get("session_id")
+    session_id = context.sessionId
     
     # Retrieve session context
     session_data = await context.kv.get("sessions", session_id)
@@ -81,10 +81,12 @@ async def run(request, response, context):
 **Storage**: Vector database for semantic search
 
 ```python
+from datetime import datetime
+
 # Long-term memory for learning and relationships
 async def run(request, response, context):
     user_id = request.metadata.get("user_id")
-    
+
     # Store learned preferences
     await context.vector.upsert("user_knowledge", [{
         "key": f"pref_{user_id}_{datetime.now()}",
@@ -95,7 +97,7 @@ async def run(request, response, context):
             "learned_from": "conversation_analysis"
         }
     }])
-    
+
     # Retrieve relevant memories
     memories = await context.vector.search(
         "user_knowledge",
@@ -155,7 +157,7 @@ Best for discrete, queryable data:
     }
   };
   
-  await context.kv.set('users', userId, JSON.stringify(profile));
+  await context.kv.set('users', userId, profile);
 };`} />
 
 ### Searchable Memory (Vector Storage)
@@ -203,7 +205,8 @@ Best for semantic search and knowledge retrieval:
   // Later, retrieve relevant context
   const similarConvos = await context.vector.search('conversations', {
     query: 'deployment and scaling concerns',
-    limit: 3
+    limit: 3,
+    similarity: 0.7
   });
 };`} />
 
@@ -214,11 +217,18 @@ Best for files and large data:
 - Media files
 - Model outputs
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`from datetime import datetime
+import json
+
+async def run(request, response, context):
+    # Assume analysis_results and user_id are defined above
+    analysis_results = {"data": "sample analysis"}  # placeholder
+    user_id = request.metadata.get("user_id")
+
     # Store generated report
     report_data = generate_pdf_report(analysis_results)
     report_key = f"reports/{user_id}/{datetime.now().strftime('%Y%m%d')}_analysis.pdf"
-    
+
     # Auto-detects content type from file extension and data
     await context.objectstore.put(
         "documents",
@@ -226,13 +236,17 @@ Best for files and large data:
         report_data
     )
     # Note: For explicit content type, use ObjectStorePutParams class (see API reference)
-    
+
     # Create public URL for sharing (expires in 1 hour)
     share_url = await context.objectstore.createPublicURL(
         "documents",
         report_key,
         3600000  # milliseconds
     )`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Assume analysisResults and userId are defined above
+  const analysisResults = { data: 'sample analysis' }; // placeholder
+  const userId = request.metadata.get('user_id');
+
   // Store generated report
   const reportData = generatePdfReport(analysisResults);
   const reportKey = \`reports/\${userId}/\${new Date().toISOString().split('T')[0]}_analysis.pdf\`;
@@ -259,7 +273,7 @@ Best for files and large data:
 Keep recent conversation context while managing memory size:
 
 <CodeExample py={`async def run(request, response, context):
-    session_id = request.metadata.get("session_id")
+    session_id = context.sessionId
     max_messages = 20  # Keep last 20 messages
     
     # Get existing conversation
@@ -306,7 +320,7 @@ Keep recent conversation context while managing memory size:
     }, {"ttl": 7200})  # 2 hour TTL
     
     return response.json({"message": agent_response})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const sessionId = request.metadata.get('session_id');
+  const sessionId = context.sessionId;
   const maxMessages = 20; // Keep last 20 messages
   
   // Get existing conversation
@@ -348,10 +362,10 @@ Keep recent conversation context while managing memory size:
   });
   
   // Save updated conversation
-  await context.kv.set('conversations', sessionId, JSON.stringify({
+  await context.kv.set('conversations', sessionId, {
     messages,
     updated: new Date().toISOString()
-  }), { ttl: 7200 }); // 2 hour TTL
+  }, { ttl: 7200 }); // 2 hour TTL
   
   return response.json({ message: agentResponse });
 };`} />
@@ -475,6 +489,7 @@ Build user profiles over time:
   const memories = await context.vector.search('user_preferences', {
     query: userInput,
     limit: 3,
+    similarity: 0.7,
     metadata: { user_id: userId }
   });
   
@@ -486,7 +501,7 @@ Build user profiles over time:
   );
   
   // Save updated profile
-  await context.kv.set('profiles', userId, JSON.stringify(profile));
+  await context.kv.set('profiles', userId, profile);
   
   return response.json({
     message: responseText,
@@ -779,347 +794,242 @@ Implement automated cleanup to manage costs:
   }
 };`} />
 
-## Lab: Building a Memory-Powered Customer Service Agent
+## Lab: Building a Docs Q&A Agent with Memory
 
-Let's build an agent that remembers customer interactions and provides increasingly personalized support:
+Let's build an agent that helps users find documentation using semantic search and learns from user interactions to provide better responses over time.
 
-<CodeExample py={`from datetime import datetime, timedelta
-import json
+### Key Implementation: Upload & Index Pattern
 
-def welcome():
-    """Test scenarios for our customer service agent."""
-    return {
-        "welcome": "Customer Service Agent - I remember you!",
-        "prompts": [
-            {
-                "data": {
-                    "action": "support",
-                    "user_id": "customer_123", 
-                    "message": "My order hasn't arrived yet",
-                    "order_id": "ORD-789"
-                },
-                "contentType": "application/json"
-            },
-            {
-                "data": {
-                    "action": "support",
-                    "user_id": "customer_123",
-                    "message": "Still waiting for my order"
-                },
-                "contentType": "application/json"
-            },
-            {
-                "data": {
-                    "action": "get_history",
-                    "user_id": "customer_123"
-                },
-                "contentType": "application/json"
-            }
-        ]
-    }
+The core pattern shows how agents use all storage types together in a cohesive workflow:
 
-async def run(request, response, context):
-    """Customer service agent with memory."""
-    data = await request.data.json()
-    action = data.get("action")
-    user_id = data.get("user_id")
-    
-    if action == "support":
-        message = data.get("message")
-        
-        # Get customer profile
-        profile_result = await context.kv.get("customers", user_id)
-        if profile_result.exists:
-            profile = await profile_result.data.json()
-            profile["interaction_count"] = profile.get("interaction_count", 0) + 1
-        else:
-            profile = {
-                "user_id": user_id,
-                "first_contact": datetime.now().isoformat(),
-                "interaction_count": 1,
-                "issues": []
-            }
-        
-        # Search for similar past issues
-        past_issues = await context.vector.search(
-            "support_history",
-            message,
-            limit=3,
-            metadata={"user_id": user_id}
-        )
-        
-        # Determine if this is a recurring issue
-        is_recurring = False
-        for issue in past_issues:
-            if issue.similarity > 0.8:
-                is_recurring = True
-                break
-        
-        # Store this interaction
-        interaction_key = f"{user_id}_{datetime.now().timestamp()}"
-        await context.vector.upsert("support_history", [{
-            "key": interaction_key,
-            "document": message,
+<CodeExample py={`# Key pattern: Upload, store, and index documents
+async def handle_upload(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    file_content = await request.data.text()
+    file_name = request.metadata.get("filename", "document.txt")
+
+    # 1. Store in object storage with proper UTF-8 encoding
+    binary_data = file_content.encode('utf-8')
+    await context.objectstore.put(OBJECT_STORAGE_BUCKET, file_name, binary_data)
+
+    # 2. Chunk and embed for search
+    chunks = chunk_document(file_content, chunk_size=500)
+
+    for i, chunk in enumerate(chunks):
+        chunk_id = f"{file_name}_chunk_{i}"
+        # Python vector storage uses array format
+        await context.vector.upsert(VECTOR_STORAGE_NAME, [{
+            "key": chunk_id,
+            "document": chunk,
             "metadata": {
-                "user_id": user_id,
-                "timestamp": datetime.now().isoformat(),
-                "order_id": data.get("order_id"),
-                "resolved": False
+                "source_file": file_name,
+                "chunk_index": i,
+                "uploaded_at": datetime.now().isoformat()
             }
         }])
-        
-        # Add to profile issues
-        profile["issues"].append({
-            "message": message,
-            "timestamp": datetime.now().isoformat(),
-            "recurring": is_recurring
-        })
-        
-        # Generate response based on history
-        if is_recurring:
-            response_text = (
-                f"I see you've contacted us about this before. "
-                f"Let me escalate this to our senior support team immediately. "
-                f"Your case has been prioritized."
-            )
-            priority = "high"
-        elif profile["interaction_count"] > 5:
-            response_text = (
-                f"Thank you for being a valued customer. "
-                f"I'm looking into your issue right away."
-            )
-            priority = "medium"
-        else:
-            response_text = (
-                f"Thank you for contacting support. "
-                f"I'll help you with your issue."
-            )
-            priority = "normal"
-        
-        # Save updated profile
-        await context.kv.set("customers", user_id, profile)
-        
-        # Log for analytics
-        context.logger.info(f"Support request from {user_id}: {priority} priority")
-        
-        return response.json({
-            "response": response_text,
-            "is_recurring": is_recurring,
-            "interaction_number": profile["interaction_count"],
-            "priority": priority,
-            "similar_issues_found": len(past_issues)
-        })
-    
-    elif action == "get_history":
-        # Retrieve customer history
-        profile_result = await context.kv.get("customers", user_id)
-        
-        if not profile_result.exists:
-            return response.json({
-                "error": "No history found for this customer"
-            })
-        
-        profile = await profile_result.data.json()
-        
-        # Get recent issues from vector storage
-        recent_issues = await context.vector.search(
-            "support_history",
-            f"all issues for user {user_id}",
-            limit=10,
-            metadata={"user_id": user_id}
-        )
-        
-        return response.json({
-            "customer_profile": profile,
-            "recent_issues": [
-                {
-                    "message": issue.document,
-                    "metadata": issue.metadata
-                }
-                for issue in recent_issues
-            ]
-        })
-    
+
     return response.json({
-        "error": "Unknown action"
-    })`} js={`const welcome = () => {
-    return {
-        welcome: "Customer Service Agent - I remember you!",
-        prompts: [
-            {
-                data: JSON.stringify({
-                    action: "support",
-                    user_id: "customer_123",
-                    message: "My order hasn't arrived yet",
-                    order_id: "ORD-789"
-                }),
-                contentType: "application/json"
-            },
+        "status": "indexed",
+        "chunks": len(chunks),
+        "file": file_name
+    })`} js={`// Key pattern: Upload, store, and index documents
+async function handleUpload(request: AgentRequest, response: AgentResponse, context: AgentContext) {
+  const fileContent = await request.data.text();
+  const fileName = request.metadata.get('filename') || 'document.txt';
+
+  // 1. Store in object storage with proper UTF-8 encoding
+  const binaryData = new TextEncoder().encode(fileContent);
+  await context.objectstore.put(OBJECT_STORAGE_BUCKET, fileName, binaryData);
+
+  // 2. Chunk and embed for search
+  const chunks = chunkDocument(fileContent, 500);
+
+  for (let i = 0; i < chunks.length; i++) {
+    const chunkId = \`\${fileName}_chunk_\${i}\`;
+    // TypeScript vector storage uses single object format
+    await context.vector.upsert(VECTOR_STORAGE_NAME, {
+      key: chunkId,
+      document: chunks[i],
+      metadata: {
+        sourceFile: fileName,
+        chunkIndex: i,
+        uploadedAt: new Date().toISOString()
+      }
+    });
+  }
+
+  return response.json({
+    status: 'indexed',
+    chunks: chunks.length,
+    file: fileName
+  });
+}`} />
+
+### Key Implementation: Semantic Search with Context
+
+Agents combine search results with user history for intelligent responses:
+
+<CodeExample py={`# Key pattern: Semantic search with context and intelligent file detection
+async def search_documents(query: str, context: AgentContext, limit: int = 5):
+    # Detect if this is a file upload (llms.txt pattern)
+    is_file_upload = (query.startswith('# Agentuity') and
+                     ('## Features' in query or '## Product Features' in query) and
+                     '## About' in query)
+
+    if is_file_upload:
+        # Handle structured file indexing
+        return await handle_file_upload(query, context)
+
+    # 1. Vector search for relevant chunks
+    search_results = await context.vector.search(
+        VECTOR_STORAGE_NAME,
+        query,
+        limit=limit,
+        similarity=0.5  # Minimum similarity threshold
+    )
+
+    # 2. Track query history for learning
+    query_history = await context.kv.get(KV_STORAGE_NAME, "recent_queries")
+    if query_history.exists:
+        recent = await query_history.data.json()
+        recent.append({"query": query, "timestamp": datetime.now().isoformat()})
+    else:
+        recent = [{"query": query, "timestamp": datetime.now().isoformat()}]
+
+    # Store updated query history (keep last 10)
+    await context.kv.set(KV_STORAGE_NAME, "recent_queries", recent[-10:])
+
+    return search_results`} js={`// Key pattern: Semantic search with context and intelligent file detection
+async function searchDocuments(query: string, context: AgentContext, limit: number = 5) {
+  // Detect if this is a file upload (llms.txt pattern)
+  const isFileUpload = query.startsWith('# Agentuity') &&
+                      (query.includes('## Features') || query.includes('## Product Features')) &&
+                      query.includes('## About');
+
+  if (isFileUpload) {
+    // Handle structured file indexing
+    return await handleFileUpload(query, context);
+  }
+
+  // 1. Vector search for relevant chunks
+  const searchResults = await context.vector.search(VECTOR_STORAGE_NAME, {
+    query,
+    limit,
+    similarity: 0.5  // Minimum similarity threshold
+  });
+
+  // 2. Track query history for learning
+  const queryHistory = await context.kv.get(KV_STORAGE_NAME, 'recent_queries');
+  let recent;
+  if (queryHistory.exists) {
+    recent = await queryHistory.data.json();
+    recent.push({ query, timestamp: new Date().toISOString() });
+  } else {
+    recent = [{ query, timestamp: new Date().toISOString() }];
+  }
+
+  // Store updated query history (keep last 10)
+  await context.kv.set(KV_STORAGE_NAME, 'recent_queries', recent.slice(-10));
+
+  return searchResults;
+}`} />
+
+### Key Implementation: AI-Powered Documentation Q&A
+
+Combining search results with AI for intelligent documentation responses:
+
+<CodeExample py={`# Key pattern: AI-powered documentation Q&A with context building
+async def build_smart_response(query: str, search_results: list, context: AgentContext):
+    # Build context from top search results (metadata contains full content)
+    doc_context = '\n\n'.join([
+        result.metadata.get('content', '')
+        for result in search_results[:2]  # Use top 2 results
+        if result.metadata.get('content')
+    ])
+
+    # Generate AI response using OpenAI
+    response = await client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[
             {
-                data: JSON.stringify({
-                    action: "support",
-                    user_id: "customer_123",
-                    message: "Still waiting for my order"
-                }),
-                contentType: "application/json"
+                "role": "system",
+                "content": "Answer questions about Agentuity based on the documentation provided. Be helpful and concise."
             },
             {
-                data: JSON.stringify({
-                    action: "get_history",
-                    user_id: "customer_123"
-                }),
-                contentType: "application/json"
+                "role": "user",
+                "content": f"Documentation context:\n{doc_context or 'No relevant documentation found.'}\n\nQuestion: {query}\n\nProvide a helpful answer in 2-3 sentences."
             }
         ]
-    };
-};
+    )
 
-const handler: AgentHandler = async (request, response, context) => {
-  const data = await request.data.json();
-  const { action, user_id } = data;
-  
-  if (action === 'support') {
-    const { message } = data;
-    
-    // Get customer profile
-    const profileResult = await context.kv.get('customers', user_id);
-    let profile;
-    
-    if (profileResult.exists) {
-      profile = await profileResult.data.json();
-      profile.interaction_count = (profile.interaction_count || 0) + 1;
-    } else {
-      profile = {
-        user_id,
-        first_contact: new Date().toISOString(),
-        interaction_count: 1,
-        issues: []
-      };
-    }
-    
-    // Search for similar past issues
-    const pastIssues = await context.vector.search('support_history', {
-      query: message,
-      limit: 3,
-      metadata: { user_id }
-    });
-    
-    // Determine if this is a recurring issue
-    let isRecurring = false;
-    for (const issue of pastIssues) {
-      if (issue.similarity > 0.8) {
-        isRecurring = true;
-        break;
-      }
-    }
-    
-    // Store this interaction
-    const interactionKey = \`\${user_id}_\${Date.now()}\`;
-    await context.vector.upsert('support_history', {
-      key: interactionKey,
-      document: message,
-      metadata: {
-        user_id,
-        timestamp: new Date().toISOString(),
-        order_id: data.order_id,
-        resolved: false
-      }
-    });
-    
-    // Add to profile issues
-    profile.issues.push({
-      message,
-      timestamp: new Date().toISOString(),
-      recurring: isRecurring
-    });
-    
-    // Generate response based on history
-    let responseText, priority;
-    
-    if (isRecurring) {
-      responseText = 
-        "I see you've contacted us about this before. " +
-        "Let me escalate this to our senior support team immediately. " +
-        "Your case has been prioritized.";
-      priority = 'high';
-    } else if (profile.interaction_count > 5) {
-      responseText = 
-        "Thank you for being a valued customer. " +
-        "I'm looking into your issue right away.";
-      priority = 'medium';
-    } else {
-      responseText = 
-        "Thank you for contacting support. " +
-        "I'll help you with your issue.";
-      priority = 'normal';
-    }
-    
-    // Save updated profile
-    await context.kv.set('customers', user_id, JSON.stringify(profile));
-    
-    // Log for analytics
-    context.logger.info(\`Support request from \${user_id}: \${priority} priority\`);
-    
-    return response.json({
-      response: responseText,
-      is_recurring: isRecurring,
-      interaction_number: profile.interaction_count,
-      priority,
-      similar_issues_found: pastIssues.length
-    });
-  
-  } else if (action === 'get_history') {
-    // Retrieve customer history
-    const profileResult = await context.kv.get('customers', user_id);
-    
-    if (!profileResult.exists) {
-      return response.json({
-        error: 'No history found for this customer'
-      });
-    }
-    
-    const profile = await profileResult.data.json();
-    
-    // Get recent issues from vector storage
-    const recentIssues = await context.vector.search('support_history', {
-      query: \`all issues for user \${user_id}\`,
-      limit: 10,
-      metadata: { user_id }
-    });
-    
-    return response.json({
-      customer_profile: profile,
-      recent_issues: recentIssues.map(issue => ({
-        message: issue.document,
-        metadata: issue.metadata
-      }))
-    });
-  }
-  
-  return response.json({
-    error: 'Unknown action'
+    return response.choices[0].message.content.strip()`} js={`// Key pattern: AI-powered documentation Q&A with context building
+async function buildSmartResponse(query: string, searchResults: any[], context: AgentContext) {
+  // Build context from top search results (metadata contains full content)
+  const docContext = searchResults
+    .slice(0, 2)  // Use top 2 results for context
+    .map(result => result.metadata?.content || '')
+    .filter(content => content)  // Remove any empty results
+    .join('\\n\\n');
+
+  // Generate AI response using Vercel AI SDK
+  const { text: aiAnswer } = await generateText({
+    model: openai('gpt-4o-mini'),
+    prompt: \`Answer this question about Agentuity based on the documentation provided.
+
+Documentation context:
+\${docContext || 'No relevant documentation found.'}
+
+Question: \${query}
+
+Provide a helpful, concise answer in 2-3 sentences. If no context is available, politely indicate that.\`
   });
-};
 
-export default handler;
-export { welcome };`} />
+  return aiAnswer;
+}`} />
+
+### Build This Agent Yourself
+
+Ready to implement this agent? Follow our complete examples:
+
+<div className="flex flex-wrap gap-3 mb-6">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/03-docs-qa-agent-ts" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    TypeScript
+  </a>
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/03_docs_qa_agent_py" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    Python
+  </a>
+</div>
+
+### What This Agent Demonstrates
+
+- **Semantic search**: Vector similarity for finding relevant documentation
+- **User learning**: Tracking search patterns and feedback to improve responses
+- **Context building**: Combining search results with conversation history
+- **Feedback loops**: Learning from user interactions to boost helpful content
+- **Personalization**: Adapting responses based on user's experience level
+
+The complete examples show you how to build intelligent documentation agents that get smarter over time through user interaction.
+
 
-### Testing Your Memory Agent
+## Testing Your Docs Q&A Agent
 
 1. **Start DevMode:**
 ```bash
 agentuity dev
 ```
 
-2. **Test the scenarios:**
-   - First support request - notice the standard response
-   - Second similar request - see how it recognizes the recurring issue
-   - Check history - view all stored interactions
+2. **Test the documentation search:**
+   - Ask questions about different documentation topics
+   - Notice how semantic search finds relevant content
+   - Test similar queries to see cached vs fresh results
 
 3. **Observe the memory in action:**
-   - Watch the logs to see KV and vector operations
-   - Try different user IDs to see isolated memory
-   - Test with various message similarities
+   - Watch the logs to see vector search operations
+   - Try different user patterns to see personalized responses
+   - Test feedback loops by rating search results
 
 ## Memory at Scale
 
@@ -1158,4 +1068,4 @@ Remember: Memory is what transforms an agent from a tool into a partner.
 
 ---
 
-**Ready for Module 4?** [Agent-to-Agent Collaboration](./04-agent-collaboration)
\ No newline at end of file
+**Ready for Module 4?** [Agent-to-Agent Collaboration](./04-agent-collaboration)
diff --git a/content/Training/developers/04-agent-collaboration.mdx b/content/Training/developers/04-agent-collaboration.mdx
index ada674f1..a67e1d24 100644
--- a/content/Training/developers/04-agent-collaboration.mdx
+++ b/content/Training/developers/04-agent-collaboration.mdx
@@ -43,50 +43,56 @@ User → Orchestrator →→ Sales Agent
 
 ## Industry Challenges vs. Agentuity's Approach
 
-According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring LangGraph or custom orchestrators.
+According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring custom orchestrators and complex coordination mechanisms.
 
-### Agentuity's Approach: Simple Handoffs
+### Agentuity's Approach: Multiple Communication Methods
 
-While other platforms build complex orchestration layers, Agentuity takes a different approach: **the handoff mechanism**. It's simpler, but with clear trade-offs:
+While other platforms build complex orchestration layers, Agentuity provides flexible agent communication options:
 
+**The handoff mechanism** is one approach that's simpler but focused:
 - **What it does**: Transfers control from one agent to another (like call forwarding)
 - **What it doesn't do**: Parallel execution, getting responses back, complex coordination
 - **Why it works**: Most real-world agent workflows are actually sequential or conditional
 
-## The Handoff Mechanism
+Agentuity also supports other communication patterns including parallel execution through `ctx.getAgent()` for more complex coordination when needed.
 
-In Agentuity, agents communicate using the `handoff` method. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
+## Agent Communication Methods
+
+Agentuity provides two primary ways for agents to communicate with each other, each suited for different scenarios:
+
+### 1. Delegation with `response.handoff()`
+
+Use handoff when you want to delegate control to another agent and exit. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
 
 <CodeExample py={`async def run(request, response, context):
-    """Basic handoff example."""
+    """Delegation example: route to specialist and exit."""
 
-    # Receive a research request
     task = await request.data.json()
 
-    # Decide we need help from the web search agent
+    # Decide we need help from a specialist
     if task.get("type") == "web_research":
-        # Hand off to the web search specialist
+        # Delegate to web search specialist (we exit, they respond to client)
         return response.handoff(
             {"name": "web-search"},  # Target agent
-            {"query": task.get("query")},  # Data to pass
-            {"original_task": task}  # Metadata
+            task.get("query"),  # Data to pass
+            metadata={"original_task": task}  # Metadata
         )
 
     # Handle other task types...
     return response.json({"result": "Task completed"})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Basic handoff example
+  // Delegation example: route to specialist and exit
 
   const task = await request.data.json();
 
-  // Decide we need help from the web search agent
+  // Decide we need help from a specialist
   if (task.type === 'web_research') {
-    // Hand off to the web search specialist
+    // Delegate to web search specialist (we exit, they respond to client)
     return response.handoff(
       { name: 'web-search' }, // Target agent
       {
-        data: JSON.stringify({ query: task.query }), // Data as string
+        data: JSON.stringify({ query: task.query }),
         contentType: 'application/json',
-        metadata: { original_task: task } // Metadata object
+        metadata: { original_task: task }
       }
     );
   }
@@ -95,286 +101,137 @@ In Agentuity, agents communicate using the `handoff` method. This is like forwar
   return response.json({ result: 'Task completed' });
 };`} />
 
-## Agent Resolution
-
-Agents can find each other using either:
-- **Name**: Human-readable identifier (e.g., "web-search")
-- **ID**: Unique system identifier (e.g., "agent_abc123")
-
-The context object knows about all agents in your project:
-
-<CodeExample py={`async def run(request, response, context):
-    # List all available agents
-    available_agents = context.agents
-    context.logger.info(f"Available agents: {[a.name for a in available_agents]}")
-
-    # Check if a specific agent exists
-    if any(agent.name == "summarizer" for agent in context.agents):
-        # Agent exists, we can safely hand off
-        return response.handoff(
-            {"name": "summarizer"},
-            {"text": "Long article to summarize..."}  # Data to pass
-        )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // List all available agents
-  const availableAgents = context.agents;
-  context.logger.info(\`Available agents: \${availableAgents.map(a => a.name)}\`);
-
-  // Check if a specific agent exists
-  if (availableAgents.some(agent => agent.name === 'summarizer')) {
-    // Agent exists, we can safely hand off
-    return response.handoff(
-      { name: 'summarizer' },
-      {
-        data: JSON.stringify({ text: 'Long article to summarize...' }),
-        contentType: 'application/json'
-      }
-    );
-  }
-};`} />
-
-## Patterns That Work with Agentuity's Handoff
-
-### 1. Sequential Chain Pattern
-
-Perfect for pipelines where each agent completes its work and passes to the next:
-
-<CodeExample py={`async def run(request, response, context):
-    """Pipeline pattern: Each agent enriches the data."""
+### 2. Request-Response with `ctx.getAgent()`
 
-    data = await request.data.json()
-    step = data.get("step", 1)
-
-    if step == 1:
-        # First agent: Clean the data
-        data["cleaned"] = True
-        data["step"] = 2
-        return response.handoff({"name": "processor"}, data)
-
-    elif step == 2:
-        # Second agent: Enrich the data
-        data["enriched"] = True
-        data["step"] = 3
-        return response.handoff({"name": "validator"}, data)
-
-    elif step == 3:
-        # Final agent: Validate and return
-        data["validated"] = True
-        return response.json(data)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Pipeline pattern: Each agent enriches the data
+Use getAgent when you need to stay in control and process responses from other agents. This enables parallel execution, conditional logic, and result aggregation.
 
-  const data = await request.data.json();
-  const step = data.step || 1;
-
-  if (step === 1) {
-    // First agent: Clean the data
-    data.cleaned = true;
-    data.step = 2;
-    return response.handoff({ name: 'processor' }, { data: JSON.stringify(data), contentType: 'application/json' });
-
-  } else if (step === 2) {
-    // Second agent: Enrich the data
-    data.enriched = true;
-    data.step = 3;
-    return response.handoff({ name: 'validator' }, { data: JSON.stringify(data), contentType: 'application/json' });
-
-  } else if (step === 3) {
-    // Final agent: Validate and return
-    data.validated = true;
-    return response.json(data);
-  }
-};`} />
+<CodeExample py={`import asyncio
 
-### 2. Conditional Routing Pattern
+async def run(request, response, context):
+    """Request-response example: coordinate multiple agents."""
 
-Route to different agents based on the request type - ideal for dispatcher/router agents:
+    query = (await request.data.json()).get("query", "")
 
-<CodeExample py={`async def run(request, response, context):
-    """Router pattern: Direct to appropriate specialist."""
+    # Get references to specialist agents
+    web_agent = context.get_agent("web-search")
+    news_agent = context.get_agent("news-search")
 
-    task = await request.data.json()
-    task_type = task.get("type", "").lower()
+    # Execute searches in parallel and process responses
+    results = await asyncio.gather(
+        web_agent.run({"query": query, "source": "web"}),
+        news_agent.run({"query": query, "source": "news"}),
+        return_exceptions=True
+    )
 
-    # Route based on task type
-    agent_map = {
-        "math": "calculator-agent",
-        "translation": "translator-agent",
-        "search": "web-search",
-        "summary": "summarizer"
-    }
+    # Process and combine results (we stay in control)
+    combined_results = []
+    for i, result in enumerate(results):
+        if not isinstance(result, Exception):
+            data = await result.data.json()
+            combined_results.append({
+                "source": ["web", "news"][i],
+                "results": data
+            })
 
-    target_agent = agent_map.get(task_type)
-
-    if target_agent:
-        context.logger.info(f"Routing {task_type} task to {target_agent}")
-        return response.handoff(
-            {"name": target_agent},
-            task.get("payload", {})  # Pass payload directly as data
-        )
-
-    # Unknown task type
+    # We respond to client with aggregated results
     return response.json({
-        "error": f"Unknown task type: {task_type}",
-        "available_types": list(agent_map.keys())
+        "query": query,
+        "combined_results": combined_results,
+        "total_sources": len(combined_results)
     })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Router pattern: Direct to appropriate specialist
-
-  const task = await request.data.json();
-  const taskType = (task.type || '').toLowerCase();
-
-  // Route based on task type
-  const agentMap = {
-    math: 'calculator-agent',
-    translation: 'translator-agent',
-    search: 'web-search',
-    summary: 'summarizer'
-  };
-
-  const targetAgent = agentMap[taskType];
-
-  if (targetAgent) {
-    context.logger.info(\`Routing \${taskType} task to \${targetAgent}\`);
-    return response.handoff(
-      { name: targetAgent },
-      {
-        data: JSON.stringify(task.payload || {}),
-        contentType: 'application/json'
-      }
-    );
+  // Request-response example: coordinate multiple agents
+
+  const { query } = await request.data.json();
+
+  // Get references to specialist agents
+  const webAgent = await context.getAgent({ name: 'web-search' });
+  const newsAgent = await context.getAgent({ name: 'news-search' });
+
+  // Execute searches in parallel and process responses
+  const results = await Promise.allSettled([
+    webAgent.run({ data: JSON.stringify({ query, source: 'web' }), contentType: 'application/json' }),
+    newsAgent.run({ data: JSON.stringify({ query, source: 'news' }), contentType: 'application/json' })
+  ]);
+
+  // Process and combine results (we stay in control)
+  const combinedResults = [];
+  const sources = ['web', 'news'];
+
+  for (let i = 0; i < results.length; i++) {
+    if (results[i].status === 'fulfilled') {
+      const data = await results[i].value.data.json();
+      combinedResults.push({
+        source: sources[i],
+        results: data
+      });
+    }
   }
 
-  // Unknown task type
+  // We respond to client with aggregated results
   return response.json({
-    error: \`Unknown task type: \${taskType}\`,
-    available_types: Object.keys(agentMap)
+    query,
+    combined_results: combinedResults,
+    total_sources: combinedResults.length
   });
 };`} />
 
-### 3. Orchestrator Pattern (Smart Routing)
+### When to Use Each Method
+
+| Method | Use When | Control Flow | Response Handling | Constraints |
+|--------|----------|--------------|-------------------|-------------|
+| **`handoff`** | Sequential workflows, simple routing, delegation | One-way, exit current agent | Target agent responds to client | No response back, can't handoff to self, project isolation |
+| **`getAgent`** | Parallel execution, conditional logic, result aggregation | Stay in control | You process responses, then respond | More complex, manual coordination required |
 
-A central agent analyzes requests and routes to appropriate specialists:
+### Agent Discovery
+
+Agents can find each other using either name or ID. The context object knows about all agents in your project:
 
 <CodeExample py={`async def run(request, response, context):
-    """Smart orchestrator that analyzes intent before routing."""
+    # List all available agents
+    available_agents = context.agents
+    context.logger.info(f"Available agents: {[a.name for a in available_agents]}")
 
-    user_prompt = await request.data.text()
+    # Check if a specific agent exists before communicating
+    if any(agent.name == "summarizer" for agent in context.agents):
+        # Agent exists, safe to use either method
 
-    # Simple intent analysis (in production, use LLM)
-    if "technical" in user_prompt.lower() or "code" in user_prompt.lower():
-        return response.handoff(
-            {"name": "technical-expert"},
-            {"query": user_prompt, "type": "technical"}
-        )
-    elif "price" in user_prompt.lower() or "cost" in user_prompt.lower():
-        return response.handoff(
-            {"name": "sales-expert"},
-            {"query": user_prompt, "type": "sales"}
-        )
-    elif "help" in user_prompt.lower() or "problem" in user_prompt.lower():
+        # Option 1: Delegate and exit
         return response.handoff(
-            {"name": "support-expert"},
-            {"query": user_prompt, "type": "support"}
+            {"name": "summarizer"},
+            "Long article to summarize..."
         )
-    else:
-        return response.text("I can help with technical, sales, or support questions. How can I assist you?")`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Smart orchestrator that analyzes intent before routing
 
-  const userPrompt = await request.data.text();
+        # Option 2: Get response and stay in control
+        # summarizer = context.get_agent("summarizer")
+        # result = await summarizer.run({"text": "Long article..."})
+        # summary = await result.data.json()
+        # return response.json({"processed_summary": summary})`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // List all available agents
+  const availableAgents = context.agents;
+  context.logger.info(\`Available agents: \${availableAgents.map(a => a.name)}\`);
 
-  // Simple intent analysis (in production, use LLM)
-  if (userPrompt.toLowerCase().includes('technical') || userPrompt.toLowerCase().includes('code')) {
-    return response.handoff(
-      { name: 'technical-expert' },
-      {
-        data: JSON.stringify({ query: userPrompt, type: 'technical' }),
-        contentType: 'application/json'
-      }
-    );
-  } else if (userPrompt.toLowerCase().includes('price') || userPrompt.toLowerCase().includes('cost')) {
-    return response.handoff(
-      { name: 'sales-expert' },
-      {
-        data: JSON.stringify({ query: userPrompt, type: 'sales' }),
-        contentType: 'application/json'
-      }
-    );
-  } else if (userPrompt.toLowerCase().includes('help') || userPrompt.toLowerCase().includes('problem')) {
+  // Check if a specific agent exists before communicating
+  if (availableAgents.some(agent => agent.name === 'summarizer')) {
+    // Agent exists, safe to use either method
+
+    // Option 1: Delegate and exit
     return response.handoff(
-      { name: 'support-expert' },
+      { name: 'summarizer' },
       {
-        data: JSON.stringify({ query: userPrompt, type: 'support' }),
+        data: JSON.stringify({ text: 'Long article to summarize...' }),
         contentType: 'application/json'
       }
     );
-  } else {
-    return response.text('I can help with technical, sales, or support questions. How can I assist you?');
-  }
-};`} />
-
-### 4. Understanding Handoff Flow
-
-Understanding that handoff is a one-way transfer is crucial. The final agent in the chain responds to the original client:
-
-```
-Client Request → Agent A → (handoff) → Agent B → Response to Client
-                    ↓
-                 (exits)
-```
-
-This is different from traditional RPC where Agent A would wait for Agent B's response.
-
-## Understanding Handoff Constraints
-
-Agentuity's handoff has built-in safety features and important constraints to understand:
-
-<CodeExample py={`async def run(request, response, context):
-    # CONSTRAINT 1: Can't handoff to yourself (loop detection)
-    # This will raise an error:
-    # return response.handoff({"name": context.agent.name}, data)
 
-    # CONSTRAINT 2: Handoff is one-way (no response back)
-    # Wrong expectation:
-    # result = await response.handoff({"name": "helper"}, data)  # NO!
-    # Right approach:
-    return response.handoff({"name": "helper"}, data)  # Helper responds to client
-
-    # CONSTRAINT 3: Only see agents in your project
-    # Agents are isolated by project for security
-
-    # FEATURE: Metadata persists through handoffs
-    metadata = request.metadata or {}
-    metadata["chain"] = metadata.get("chain", []) + [context.agent.name]
-    return response.handoff(
-        {"name": "next-agent"},
-        data,
-        metadata  # Pass context forward
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // CONSTRAINT 1: Can't handoff to yourself (loop detection)
-  // This will raise an error:
-  // return response.handoff({ name: context.agent.name }, args);
-
-  // CONSTRAINT 2: Handoff is one-way (no response back)
-  // Wrong expectation:
-  // const result = await response.handoff({ name: 'helper' }, args); // NO!
-  // Right approach:
-  return response.handoff({ name: 'helper' }, {
-    data: JSON.stringify(data),
-    contentType: 'application/json'
-  }); // Helper responds to client
-
-  // CONSTRAINT 3: Only see agents in your project
-  // Agents are isolated by project for security
-
-  // FEATURE: Metadata persists through handoffs
-  const metadata = request.metadata || {};
-  metadata.chain = (metadata.chain || []).concat(context.agent.name);
-  return response.handoff(
-    { name: 'next-agent' },
-    {
-      data: JSON.stringify(data),
-      contentType: 'application/json',
-      metadata  // Pass context forward
-    }
-  );
+    // Option 2: Get response and stay in control
+    // const summarizer = await context.getAgent({ name: 'summarizer' });
+    // const result = await summarizer.run({
+    //   data: JSON.stringify({ text: 'Long article...' }),
+    //   contentType: 'application/json'
+    // });
+    // const summary = await result.data.json();
+    // return response.json({ processed_summary: summary });
+  }
 };`} />
 
 ## Agentuity's Built-in Features
@@ -433,286 +290,580 @@ Agentuity provides powerful built-in features for multi-agent systems:
   );
 };`} />
 
-## Lab: Build a Research Orchestrator System
+## Common Communication Patterns
+
+### 1. Sequential Chain Pattern
+
+Perfect for pipelines where each agent completes its work and passes to the next. **Best approach: `handoff`** - Natural fit for one-way delegation through a pipeline.
+
+**Cleaner Agent** - processes raw data:
+<CodeExample py={`async def run(request, response, context):
+    """Data cleaner agent - first in the pipeline."""
+
+    data = await request.data.json()
+    context.logger.info("Cleaning incoming data")
+
+    # Clean and validate the data
+    cleaned_data = {
+        "original": data,
+        "cleaned": True,
+        "processed_by": context.agent.name,
+        "timestamp": datetime.now().isoformat()
+    }
+
+    # Pass to processor agent
+    return response.handoff({"name": "processor"}, cleaned_data)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Data cleaner agent - first in the pipeline
+
+  const data = await request.data.json();
+  context.logger.info('Cleaning incoming data');
+
+  // Clean and validate the data
+  const cleanedData = {
+    original: data,
+    cleaned: true,
+    processed_by: context.agent.name,
+    timestamp: new Date().toISOString()
+  };
+
+  // Pass to processor agent
+  return response.handoff({ name: 'processor' }, {
+    data: JSON.stringify(cleanedData),
+    contentType: 'application/json'
+  });
+};`} />
+
+**Processor Agent** - enriches cleaned data:
+<CodeExample py={`async def run(request, response, context):
+    """Data processor agent - enriches cleaned data."""
 
-Create a three-agent system using the orchestrator pattern with specialized agents:
+    data = await request.data.json()
+    context.logger.info("Processing cleaned data")
+
+    # Add enrichments
+    enriched_data = {
+        **data,
+        "enriched": True,
+        "enrichments": ["validation", "normalization", "metadata"],
+        "processed_by": context.agent.name
+    }
 
-1. **orchestrator**: Receives research requests and routes to specialists
-2. **web-search**: Searches the web and passes results to summarizer
-3. **summarizer**: Creates final research summary
+    # Pass to final validator
+    return response.handoff({"name": "validator"}, enriched_data)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Data processor agent - enriches cleaned data
 
-### The Orchestrator Agent
+  const data = await request.data.json();
+  context.logger.info('Processing cleaned data');
+
+  // Add enrichments
+  const enrichedData = {
+    ...data,
+    enriched: true,
+    enrichments: ['validation', 'normalization', 'metadata'],
+    processed_by: context.agent.name
+  };
 
-This agent analyzes requests and delegates to appropriate specialists:
+  // Pass to final validator
+  return response.handoff({ name: 'validator' }, {
+    data: JSON.stringify(enrichedData),
+    contentType: 'application/json'
+  });
+};`} />
 
+**Validator Agent** - final validation and response:
 <CodeExample py={`async def run(request, response, context):
-    """Research orchestrator that routes to specialist agents."""
+    """Validator agent - final step, responds to client."""
 
-    research_request = await request.data.json()
-    query = research_request.get("query", "")
-    research_type = research_request.get("type", "general")
+    data = await request.data.json()
+    context.logger.info("Final validation")
+
+    # Final validation and response to client
+    final_result = {
+        **data,
+        "validated": True,
+        "pipeline_complete": True,
+        "final_processor": context.agent.name,
+        "pipeline_chain": ["cleaner", "processor", "validator"]
+    }
+
+    # Respond directly to client (no further handoff)
+    return response.json(final_result)`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Validator agent - final step, responds to client
+
+  const data = await request.data.json();
+  context.logger.info('Final validation');
+
+  // Final validation and response to client
+  const finalResult = {
+    ...data,
+    validated: true,
+    pipeline_complete: true,
+    final_processor: context.agent.name,
+    pipeline_chain: ['cleaner', 'processor', 'validator']
+  };
+
+  // Respond directly to client (no further handoff)
+  return response.json(finalResult);
+};`} />
+
+### 2. Conditional Routing Pattern
+
+Route to different agents based on the request type - ideal for dispatcher/router agents. **Best approach: `handoff`** - Simple delegation based on input analysis.
+
+<CodeExample py={`async def run(request, response, context):
+    """Router pattern: Direct to appropriate specialist."""
+
+    task = await request.data.json()
+    task_type = task.get("type", "").lower()
+
+    # Route based on task type
+    agent_map = {
+        "math": "calculator-agent",
+        "translation": "translator-agent",
+        "search": "web-search",
+        "summary": "summarizer"
+    }
 
-    context.logger.info(f"Orchestrating research for: {query}")
+    target_agent = agent_map.get(task_type)
 
-    # Route based on research type
-    if research_type == "web" or "search" in query.lower():
-        # Route to web search specialist
+    if target_agent:
+        context.logger.info(f"Routing {task_type} task to {target_agent}")
         return response.handoff(
-            {"name": "web-search"},
-            {"query": query, "max_results": 5},
-            {"orchestrator": "research-orchestrator", "original_type": research_type}
+            {"name": target_agent},
+            task.get("payload", {})  # Pass payload directly as data
         )
-    elif research_type == "summary" or "summarize" in query.lower():
-        # Route directly to summarizer if we have content
-        content = research_request.get("content", "")
-        if content:
-            return response.handoff(
-                {"name": "summarizer"},
-                {"content": content, "query": query},
-                {"orchestrator": "research-orchestrator"}
-            )
-
-    # Default: explain what we can do
+
+    # Unknown task type
     return response.json({
-        "message": "I can help with web research or summarization.",
-        "examples": [
-            {"type": "web", "query": "latest AI developments"},
-            {"type": "summary", "content": "text to summarize", "query": "key points"}
-        ]
+        "error": f"Unknown task type: {task_type}",
+        "available_types": list(agent_map.keys())
     })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Research orchestrator that routes to specialist agents
+  // Router pattern: Direct to appropriate specialist
 
-  const researchRequest = await request.data.json();
-  const query = researchRequest.query || '';
-  const researchType = researchRequest.type || 'general';
+  const task = await request.data.json();
+  const taskType = (task.type || '').toLowerCase();
 
-  context.logger.info(\`Orchestrating research for: \${query}\`);
+  // Route based on task type
+  const agentMap = {
+    math: 'calculator-agent',
+    translation: 'translator-agent',
+    search: 'web-search',
+    summary: 'summarizer'
+  };
+
+  const targetAgent = agentMap[taskType];
 
-  // Route based on research type
-  if (researchType === 'web' || query.toLowerCase().includes('search')) {
-    // Route to web search specialist
+  if (targetAgent) {
+    context.logger.info(\`Routing \${taskType} task to \${targetAgent}\`);
     return response.handoff(
-      { name: 'web-search' },
+      { name: targetAgent },
       {
-        data: JSON.stringify({ query, max_results: 5 }),
-        contentType: 'application/json',
-        metadata: { orchestrator: 'research-orchestrator', original_type: researchType }
+        data: JSON.stringify(task.payload || {}),
+        contentType: 'application/json'
       }
     );
-  } else if (researchType === 'summary' || query.toLowerCase().includes('summarize')) {
-    // Route directly to summarizer if we have content
-    const content = researchRequest.content || '';
-    if (content) {
-      return response.handoff(
-        { name: 'summarizer' },
-        {
-          data: JSON.stringify({ content, query }),
-          contentType: 'application/json',
-          metadata: { orchestrator: 'research-orchestrator' }
-        }
-      );
-    }
   }
 
-  // Default: explain what we can do
+  // Unknown task type
   return response.json({
-    message: 'I can help with web research or summarization.',
-    examples: [
-      { type: 'web', query: 'latest AI developments' },
-      { type: 'summary', content: 'text to summarize', query: 'key points' }
-    ]
+    error: \`Unknown task type: \${taskType}\`,
+    available_types: Object.keys(agentMap)
   });
 };`} />
 
-### The Web Search Agent
+### 3. Parallel Execution Pattern
 
-A specialist that searches the web and automatically forwards to summarizer:
+Execute multiple agents simultaneously and aggregate results. **Best approach: `getAgent`** - Requires collecting and processing responses from multiple agents.
 
-<CodeExample py={`async def run(request, response, context):
-    """Specialist agent for web searches."""
-
-    search_params = await request.data.json()
-    query = search_params.get("query")
-    max_results = search_params.get("max_results", 5)
-
-    context.logger.info(f"Searching web for: {query}")
-
-    # Simulate web search (in production, use actual search API)
-    search_results = [
-        {
-            "title": f"Result {i+1} for {query}",
-            "snippet": f"This is a relevant snippet about {query} with detailed information...",
-            "url": f"https://example.com/article-{i+1}",
-            "relevance_score": 0.9 - (i * 0.1)
-        }
-        for i in range(max_results)
-    ]
-
-    # Automatically hand off to summarizer for final processing
-    return response.handoff(
-        {"name": "summarizer"},
-        {
-            "content": search_results,
-            "original_query": query,
-            "source": "web_search"
-        },
-        {"previous_agent": "web-search", "search_count": len(search_results)}
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Specialist agent for web searches
+<CodeExample py={`import asyncio
 
-  const searchParams = await request.data.json();
-  const query = searchParams.query;
-  const maxResults = searchParams.max_results || 5;
+async def run(request, response, context):
+    """Parallel execution example: comprehensive research."""
 
-  context.logger.info(\`Searching web for: \${query}\`);
+    query = (await request.data.json()).get("query", "")
 
-  // Simulate web search (in production, use actual search API)
-  const searchResults = Array.from({ length: maxResults }, (_, i) => ({
-    title: \`Result \${i + 1} for \${query}\`,
-    snippet: \`This is a relevant snippet about \${query} with detailed information...\`,
-    url: \`https://example.com/article-\${i + 1}\`,
-    relevance_score: 0.9 - (i * 0.1)
-  }));
+    # Get multiple specialist agents
+    web_agent = context.get_agent("web-search")
+    academic_agent = context.get_agent("academic-search")
+    news_agent = context.get_agent("news-search")
 
-  // Automatically hand off to summarizer for final processing
-  return response.handoff(
-    { name: 'summarizer' },
-    {
-      data: JSON.stringify({
-        content: searchResults,
-        original_query: query,
-        source: 'web_search'
-      }),
-      contentType: 'application/json',
-      metadata: { previous_agent: 'web-search', search_count: searchResults.length }
+    # Execute all searches in parallel
+    results = await asyncio.gather(
+        web_agent.run({"query": query, "source": "web"}),
+        academic_agent.run({"query": query, "source": "academic"}),
+        news_agent.run({"query": query, "source": "news"}),
+        return_exceptions=True
+    )
+
+    # Process and combine results
+    combined_results = []
+    sources = ["web", "academic", "news"]
+
+    for i, result in enumerate(results):
+        if not isinstance(result, Exception):
+            data = await result.data.json()
+            combined_results.append({
+                "source": sources[i],
+                "results": data.get("results", []),
+                "count": len(data.get("results", []))
+            })
+
+    # Return aggregated results
+    return response.json({
+        "query": query,
+        "research_results": combined_results,
+        "total_sources": len(combined_results),
+        "execution_pattern": "parallel"
+    })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Parallel execution example: comprehensive research
+
+  const { query } = await request.data.json();
+
+  // Get multiple specialist agents
+  const webAgent = await context.getAgent({ name: 'web-search' });
+  const academicAgent = await context.getAgent({ name: 'academic-search' });
+  const newsAgent = await context.getAgent({ name: 'news-search' });
+
+  // Execute all searches in parallel
+  const results = await Promise.allSettled([
+    webAgent.run({ data: JSON.stringify({ query, source: 'web' }), contentType: 'application/json' }),
+    academicAgent.run({ data: JSON.stringify({ query, source: 'academic' }), contentType: 'application/json' }),
+    newsAgent.run({ data: JSON.stringify({ query, source: 'news' }), contentType: 'application/json' })
+  ]);
+
+  // Process and combine results
+  const combinedResults = [];
+  const sources = ['web', 'academic', 'news'];
+
+  for (let i = 0; i < results.length; i++) {
+    if (results[i].status === 'fulfilled') {
+      const data = await results[i].value.data.json();
+      combinedResults.push({
+        source: sources[i],
+        results: data.results || [],
+        count: (data.results || []).length
+      });
     }
-  );
+  }
+
+  // Return aggregated results
+  return response.json({
+    query,
+    research_results: combinedResults,
+    total_sources: combinedResults.length,
+    execution_pattern: 'parallel'
+  });
 };`} />
 
-### The Summarizer Agent
+### 4. Smart Orchestration Pattern
 
-Takes search results and creates a final research summary:
+A central agent analyzes requests, makes decisions based on responses, and orchestrates complex workflows. **Best approach: `getAgent`** - Requires response processing for intelligent decision-making.
 
 <CodeExample py={`async def run(request, response, context):
-    """Specialist agent for summarizing research content."""
-
-    summary_request = await request.data.json()
-    content = summary_request.get("content", [])
-    original_query = summary_request.get("original_query", "")
-    source = summary_request.get("source", "unknown")
-
-    context.logger.info(f"Summarizing {len(content)} items for query: {original_query}")
-
-    # Process different content types
-    if source == "web_search" and isinstance(content, list):
-        # Handle web search results
-        summary_parts = []
-        for i, item in enumerate(content[:3]):  # Top 3 results
-            if isinstance(item, dict):
-                title = item.get("title", "")
-                snippet = item.get("snippet", "")
-                url = item.get("url", "")
-                relevance = item.get("relevance_score", 0)
-                summary_parts.append({
-                    "rank": i + 1,
-                    "title": title,
-                    "summary": snippet,
-                    "source_url": url,
-                    "relevance": relevance
-                })
-
-        final_summary = {
-            "query": original_query,
-            "summary": f"Research Summary for '{original_query}'",
-            "key_findings": summary_parts,
-            "total_sources": len(content),
-            "research_completed_at": datetime.now().isoformat(),
-            "agent_chain": ["orchestrator", "web-search", "summarizer"]
-        }
+    """Smart orchestration with decision-making."""
+
+    user_request = await request.data.json()
+    query = user_request.get("query", "")
+
+    # First, analyze the request complexity
+    analyzer = context.get_agent("complexity-analyzer")
+    analysis = await analyzer.run({"query": query})
+    analysis_data = await analysis.data.json()
+
+    # Make routing decisions based on analysis
+    if analysis_data.get("complexity") == "high":
+        # High complexity: get multiple perspectives
+        research_agent = context.get_agent("research-specialist")
+        expert_agent = context.get_agent("domain-expert")
+
+        research_result = await research_agent.run({"query": query})
+        expert_result = await expert_agent.run({"query": query})
+
+        # Combine insights for comprehensive response
+        return response.json({
+            "approach": "comprehensive",
+            "research": await research_result.data.json(),
+            "expert_opinion": await expert_result.data.json(),
+            "confidence": "high"
+        })
+
+    elif analysis_data.get("complexity") == "medium":
+        # Medium complexity: single specialist
+        specialist = context.get_agent("general-specialist")
+        result = await specialist.run({"query": query})
+
+        return response.json({
+            "approach": "specialist",
+            "result": await result.data.json(),
+            "confidence": "medium"
+        })
+
     else:
-        # Handle direct text content
-        final_summary = {
-            "query": original_query,
-            "summary": f"Summary of content for '{original_query}'",
-            "content_length": len(str(content)),
-            "processed_at": datetime.now().isoformat(),
-            "agent_chain": ["orchestrator", "summarizer"]
-        }
-
-    # Return the final research summary to the user
-    return response.json(final_summary)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Specialist agent for summarizing research content
-
-  const summaryRequest = await request.data.json();
-  const content = summaryRequest.content || [];
-  const originalQuery = summaryRequest.original_query || '';
-  const source = summaryRequest.source || 'unknown';
-
-  context.logger.info(\`Summarizing \${Array.isArray(content) ? content.length : 1} items for query: \${originalQuery}\`);
-
-  // Process different content types
-  let finalSummary;
-
-  if (source === 'web_search' && Array.isArray(content)) {
-    // Handle web search results
-    const summaryParts = content.slice(0, 3).map((item, i) => ({
-      rank: i + 1,
-      title: item.title || '',
-      summary: item.snippet || '',
-      source_url: item.url || '',
-      relevance: item.relevance_score || 0
-    }));
-
-    finalSummary = {
-      query: originalQuery,
-      summary: \`Research Summary for '\${originalQuery}'\`,
-      key_findings: summaryParts,
-      total_sources: content.length,
-      research_completed_at: new Date().toISOString(),
-      agent_chain: ['orchestrator', 'web-search', 'summarizer']
-    };
+        # Low complexity: handle directly
+        return response.json({
+            "approach": "direct",
+            "result": f"Simple answer for: {query}",
+            "confidence": "low"
+        })`} js={`const handler: AgentHandler = async (request, response, context) => {
+  // Smart orchestration with decision-making
+
+  const { query } = await request.data.json();
+
+  // First, analyze the request complexity
+  const analyzer = await context.getAgent({ name: 'complexity-analyzer' });
+  const analysis = await analyzer.run({
+    data: JSON.stringify({ query }),
+    contentType: 'application/json'
+  });
+  const analysisData = await analysis.data.json();
+
+  // Make routing decisions based on analysis
+  if (analysisData.complexity === 'high') {
+    // High complexity: get multiple perspectives
+    const researchAgent = await context.getAgent({ name: 'research-specialist' });
+    const expertAgent = await context.getAgent({ name: 'domain-expert' });
+
+    const researchResult = await researchAgent.run({
+      data: JSON.stringify({ query }),
+      contentType: 'application/json'
+    });
+    const expertResult = await expertAgent.run({
+      data: JSON.stringify({ query }),
+      contentType: 'application/json'
+    });
+
+    // Combine insights for comprehensive response
+    return response.json({
+      approach: 'comprehensive',
+      research: await researchResult.data.json(),
+      expert_opinion: await expertResult.data.json(),
+      confidence: 'high'
+    });
+
+  } else if (analysisData.complexity === 'medium') {
+    // Medium complexity: single specialist
+    const specialist = await context.getAgent({ name: 'general-specialist' });
+    const result = await specialist.run({
+      data: JSON.stringify({ query }),
+      contentType: 'application/json'
+    });
+
+    return response.json({
+      approach: 'specialist',
+      result: await result.data.json(),
+      confidence: 'medium'
+    });
+
   } else {
-    // Handle direct text content
-    finalSummary = {
-      query: originalQuery,
-      summary: \`Summary of content for '\${originalQuery}'\`,
-      content_length: String(content).length,
-      processed_at: new Date().toISOString(),
-      agent_chain: ['orchestrator', 'summarizer']
-    };
+    // Low complexity: handle directly
+    return response.json({
+      approach: 'direct',
+      result: \`Simple answer for: \${query}\`,
+      confidence: 'low'
+    });
   }
-
-  // Return the final research summary to the user
-  return response.json(finalSummary);
 };`} />
 
-## Testing Your Research Orchestrator
+## Lab: Build a Conference Concierge System
+
+Build a concierge system that routes user requests to different specialized agents using structured AI responses. This shows how agents can work together by analyzing user intent and routing to the right specialist.
 
-Test the research orchestrator system:
+### Key Implementation: Intent Analysis with Zod Validation
 
+The core pattern shows how agents use structured AI responses to decide where to route requests:
+
+<CodeExample py={`# Python - Intent analysis with structured output
+from pydantic import BaseModel
+from typing import Literal
+
+class UserIntent(BaseModel):
+    agent_type: Literal['sf_local_guide', 'conference_expert', 'dev_experience']
+    confidence: float
+
+# AI generates structured routing decision
+intent = await generate_structured_intent(user_message, schema=UserIntent)
+
+# Validated intent enables confident routing
+if intent.confidence < 0.8:
+    return response.json({
+        "message": "I'll connect you with a human specialist"
+    })
+
+# Route to appropriate domain specialist
+agent = await context.get_agent(name=intent.agent_type)
+return await agent.run(request)`} js={`// TypeScript - Intent analysis with Zod validation
+import { z } from 'zod';
+import { generateObject } from 'ai';
+
+const UserIntentSchema = z.object({
+  agentType: z.enum(['sf_local_guide', 'conference_expert', 'dev_experience']),
+  confidence: z.number().min(0).max(1)
+});
+
+// AI generates structured, validated routing decision
+const { object: userIntent } = await generateObject({
+  model: anthropic('claude-3-5-sonnet-20241022'),
+  schema: UserIntentSchema,
+  prompt: \`Analyze this user message and determine routing: "\${userMessage}"\`
+});
+
+// Validated intent enables confident routing
+if (userIntent.confidence < 0.8) {
+  return response.json({
+    message: "I'll connect you with a human specialist"
+  });
+}
+
+// Route to appropriate domain specialist
+const agent = await ctx.getAgent({ name: userIntent.agentType });
+return await agent.run({ data: userMessage, contentType: 'text/plain' });`} />
+
+### Key Implementation: Routing to Specialized Agents
+
+The concierge routes to different agents based on what the user needs:
+
+<CodeExample py={`# Python - Domain-specific routing with conversation memory
+from datetime import datetime
+
+# Analyze intent with structured output
+intent = await analyze_user_intent(user_message)
+
+# Store conversation context in KV storage
+session_id = request.sessionId
+await context.kv.set("conversations", session_id, {
+    "last_message": user_message,
+    "routed_to": intent.agent_type,
+    "timestamp": datetime.now().isoformat()
+}, {"ttl": 3600})  # 1 hour session memory
+
+# Route based on validated intent
+if intent.agent_type == "sf_local_guide":
+    agent = await context.get_agent(name="sf-local-guide")
+    return await agent.run(request)
+elif intent.agent_type == "conference_expert":
+    agent = await context.get_agent(name="conference-expert")
+    return await agent.run(request)
+else:
+    agent = await context.get_agent(name="dev-experience")
+    return await agent.run(request)`} js={`// TypeScript - Domain-specific routing with conversation memory
+
+// Analyze intent with structured output
+const intent = await analyzeUserIntent(userMessage);
+
+// Store conversation context in KV storage
+const sessionId = request.sessionId;
+await context.kv.set('conversations', sessionId, {
+  last_message: userMessage,
+  routed_to: intent.agentType,
+  timestamp: new Date().toISOString()
+}, { ttl: 3600 });  // 1 hour session memory
+
+// Route based on validated intent
+if (intent.agentType === 'sf_local_guide') {
+  const agent = await context.getAgent({ name: 'sf-local-guide' });
+  return await agent.run(request);
+} else if (intent.agentType === 'conference_expert') {
+  const agent = await context.getAgent({ name: 'conference-expert' });
+  return await agent.run(request);
+} else {
+  const agent = await context.getAgent({ name: 'dev-experience' });
+  return await agent.run(request);
+}`} />
+
+### Key Implementation: Conversation Memory and Context
+
+Sophisticated orchestrators maintain conversation state across agent interactions:
+
+<CodeExample py={`# Python - Session memory and context management
+from datetime import datetime
+
+# Retrieve existing conversation context
+existing_context = await ctx.kv.get('conversations', session_id)
+conversation_history = (
+    await existing_context.data.json() if existing_context.exists
+    else {'messages': [], 'preferences': {}}
+)
+
+# Update conversation record
+conversation_history['messages'].append({
+    'timestamp': datetime.now().isoformat(),
+    'intent': user_intent.agentType,
+    'confidence': user_intent.confidence
+})
+
+# Extract user preferences for better routing
+if user_intent.agentType == 'sf_local_guide':
+    conversation_history['preferences']['location_interests'] = (
+        conversation_history['preferences'].get('location_interests', 0) + 1
+    )
+
+# Store updated context with TTL
+await ctx.kv.set('conversations', session_id, conversation_history, {'ttl': 3600})`} js={`// TypeScript - Session memory and context management
+
+// Retrieve existing conversation context
+const existingContext = await ctx.kv.get('conversations', sessionId);
+const conversationHistory = existingContext.exists
+  ? await existingContext.data.json()
+  : { messages: [], preferences: {} };
+
+// Update conversation record
+conversationHistory.messages.push({
+  timestamp: new Date().toISOString(),
+  intent: userIntent.agentType,
+  confidence: userIntent.confidence,
+  context: userIntent.context
+});
+
+// Extract user preferences for better routing
+if (userIntent.agentType === 'sf_local_guide') {
+  conversationHistory.preferences.location_interests =
+    (conversationHistory.preferences.location_interests || 0) + 1;
+}
+
+// Store updated context with TTL
+await ctx.kv.set('conversations', sessionId, conversationHistory, { ttl: 3600 });`} />
+
+### Build This Project Yourself
+
+Ready to implement this project? Follow our complete examples:
+<div className="flex flex-wrap gap-3 mb-6">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/04-concierge-ts" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    TypeScript
+  </a>
+  <div className="inline-flex items-center gap-2 px-4 py-3 bg-gray-400 text-white rounded-lg no-underline text-sm font-medium cursor-not-allowed opacity-75">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    Python (Coming Soon)
+  </div>
+</div>
+
+### What This System Demonstrates
+
+- **Structured AI responses**: Zod and Pydantic schemas ensure reliable routing decisions
+- **Agent specialization**: Different agents handle SF questions, conference info, and developer support
+- **Conversation memory**: KV storage keeps track of context across agent interactions
+- **Practical patterns**: Confidence thresholds, fallback handling, and session management
+- **Intent-based routing**: AI analyzes user messages to figure out which agent can help
+
+The complete examples show how to build agent coordination systems that route users to the right specialists based on AI analysis.
+
+## Testing Your Conference Concierge
+
+1. **Start DevMode:**
 ```bash
-# Test web research routing
-curl -X POST https://your-project.agentuity.com/agents/orchestrator \
-  -H "Content-Type: application/json" \
-  -d '{
-    "type": "web",
-    "query": "latest developments in AI agents"
-  }'
-
-# Test direct summarization routing
-curl -X POST https://your-project.agentuity.com/agents/orchestrator \
-  -H "Content-Type: application/json" \
-  -d '{
-    "type": "summary",
-    "query": "key points",
-    "content": "Long text content to be summarized..."
-  }'
+agentuity dev
 ```
 
-Expected flow for web research:
-1. `orchestrator` analyzes request and routes to web-search
-2. `web-search` finds results and forwards to summarizer
-3. `summarizer` creates final research summary and responds to client
+2. **Test different intents:**
+   - **Local questions**: "Where's the best coffee near Moscone Center?"
+   - **Conference questions**: "What time does the keynote start?"
+   - **Developer questions**: "How do I implement agent handoffs?"
+
+3. **Watch the routing in action:**
+   - Check logs to see intent analysis and confidence scores
+   - See how conversation context helps routing get better over time
+   - Test edge cases where confidence is too low
 
 ## Key Takeaways
 
@@ -724,11 +875,11 @@ Expected flow for web research:
 
 ## What's Next?
 
-Now that you can build multi-agent systems, Module 5 will cover **Guardrails & Observability** - how to ensure your agent teams behave safely and predictably in production.
+Now that you can build multi-agent systems, Module 5 will cover **Observability, Guardrails, & Evals** - how to ensure your agent teams behave safely and predictably in production.
 
 Questions to consider:
 - How do you prevent agents from taking harmful actions?
 - How do you track what decisions agents are making?
 - How do you ensure compliance and audit requirements?
 
-Continue to [Module 5: Guardrails & Observability →](./05-guardrails-evals-observability)
\ No newline at end of file
+Continue to [Module 5: Observability, Guardrails, & Evals →](./05-observability-guardrails-evals)
diff --git a/content/Training/developers/05-guardrails-evals-observability.mdx b/content/Training/developers/05-observability-guardrails-evals.mdx
similarity index 57%
rename from content/Training/developers/05-guardrails-evals-observability.mdx
rename to content/Training/developers/05-observability-guardrails-evals.mdx
index 56654feb..c07e7408 100644
--- a/content/Training/developers/05-guardrails-evals-observability.mdx
+++ b/content/Training/developers/05-observability-guardrails-evals.mdx
@@ -1,5 +1,5 @@
 ---
-title: "Module 5: Guardrails, Evals & Observability"
+title: "Module 5: Observability, Guardrails, & Evals"
 description: Making agents reliable, safe, and production-ready
 ---
 
@@ -18,54 +18,210 @@ According to [NIST's AI Risk Management framework](https://www.nist.gov/itl/ai-r
 ## The Three Pillars of Production Agents
 
 <Callout type="info">
-Agentuity provides built-in OpenTelemetry integration with automatic instrumentation through Traceloop SDK, giving you comprehensive observability out of the box.
+Agentuity provides built-in OpenTelemetry integration with automatic instrumentation, giving you comprehensive observability out of the box.
 </Callout>
 
-### 1. Guardrails: Setting Boundaries
+### 1. Observability: Seeing Everything
 
-Guardrails prevent agents from harmful actions while preserving autonomy:
+Agentuity's key advantage is automatic OpenTelemetry integration with zero configuration:
+
+- **What's Tracked**: LLM calls, tool invocations, storage operations, API calls
+- **Observability Triad**: Logs (events), Metrics (measurements), Traces (request flow)
+- **Console View**: Timeline visualization with color-coded spans
+- **Zero Setup**: Works out of the box - no instrumentation code required
+
+### 2. Guardrails: Setting Boundaries
+
+Guardrails prevent agents from harmful actions while preserving autonomy and ensuring they stay in line with what they're supposed to do:
 
 - **Input Validation**: Schema enforcement, content filtering, size limits
-- **Rate Limiting**: Prevent abuse and control costs per user/session  
+- **Rate Limiting**: Prevent abuse and control costs per user/session
 - **Security**: Prompt injection defense ([WASP](https://arxiv.org/abs/2407.01593)), tool permissions
 - **Domain Rules**: Compliance checks, output validation, custom constraints
 
-### 2. Evaluation: Measuring Success
+### 3. Evaluation: Measuring Success
 
 Systematic evaluation is critical for non-deterministic agents:
 
-- **Industry Benchmarks**: [SWE-Bench](https://www.swebench.com/) (success rate on software engineering tasks)
-- **Automated Testing**: Unit tests, integration tests, golden datasets
-- **Production Metrics**: Success rates, latency, cost per request
-- **A/B Testing**: Shadow deployments, gradual rollouts
+- **Real-World Benchmarks**: [τ-Bench](https://sierra.ai/blog/benchmarking-ai-agents) (dynamic agent interactions), [TheAgentCompany](https://metadesignsolutions.com/benchmarking-ai-agents-in-2025-top-tools-metrics-performance-testing-strategies/) (multi-step professional tasks)
+- **Golden Datasets**: Domain-specific test cases with expected outcomes
+- **Production Metrics**: Success rates, latency, cost per request, goal completion rates
+- **A/B Testing**: Shadow deployments, gradual rollouts, real user feedback
 
-### 3. Observability: Seeing Everything
+## Observability with OpenTelemetry
 
-Agentuity provides automatic OpenTelemetry integration with Traceloop SDK:
+Agentuity automatically tracks everything through OpenTelemetry:
 
-- **What's Tracked**: LLM calls, tool invocations, storage operations, API calls
-- **Three Pillars**: Logs (events), Metrics (measurements), Traces (request flow)
-- **Console View**: Timeline visualization with color-coded spans
+### What's Tracked (No Code Required)
+- **Agent executions**: Full request/response lifecycle
+- **LLM calls**: Prompts, completions, token usage, latency
+- **Storage operations**: KV gets/sets, vector searches
+- **API calls**: External HTTP requests
+
+View in the Agentuity console Sessions tab with color-coded timeline visualization.
+
+### Using the Logger
+
+<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Logs appear in Sessions view with trace context
+    context.logger.info("Processing", {"user_id": user_id})
+
+    try:
+        result = await process(data)
+        context.logger.info("Success", {"count": len(result)})
+    except Exception as e:
+        context.logger.error("Failed", {"error": str(e)})
+        raise`} js={`const handler = async (request, response, context) => {
+  // Logs appear in Sessions view with trace context
+  context.logger.info('Processing', { userId });
+
+  try {
+    const result = await process(data);
+    context.logger.info('Success', { count: result.length });
+  } catch (error) {
+    context.logger.error('Failed', { error: error.message });
+    throw error;
+  }
+};`} />
+
+### Custom Spans for Your Own Operations
+
+Track important operations with custom spans to understand performance and debug issues:
+
+<CodeExample py={`from opentelemetry.trace import Status, StatusCode
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Create a span for the entire validation flow
+    async with context.tracer.start_as_current_span("validate-financial-query") as span:
+        # Add context about this operation
+        span.set_attribute("user.tier", "premium")
+        span.set_attribute("query.type", "retirement")
+        span.set_attribute("query.length", len(query))
+
+        try:
+            # Track validation steps
+            span.add_event("validation-started")
+
+            if has_prohibited_terms(query):
+                span.add_event("validation-failed", {"reason": "prohibited-terms"})
+                span.set_status(Status(StatusCode.ERROR, "Prohibited terms detected"))
+                return response.json({"error": "Invalid query"})
+
+            span.add_event("validation-passed")
+
+            # Track LLM call separately
+            async with context.tracer.start_as_current_span("generate-advice") as llm_span:
+                llm_span.set_attribute("model", "gpt-4")
+                advice = await generate_advice(query)
+                llm_span.set_attribute("response.tokens", count_tokens(advice))
+
+            span.set_status(Status(StatusCode.OK))
+            return response.json({"advice": advice})
+
+        except Exception as e:
+            span.record_exception(e)
+            span.set_status(Status(StatusCode.ERROR, str(e)))
+            raise`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+
+const handler = async (request, response, context) => {
+  // Create a span for the entire validation flow
+  return context.tracer.startActiveSpan('validate-financial-query', async (span) => {
+    // Add context about this operation
+    span.setAttribute('user.tier', 'premium');
+    span.setAttribute('query.type', 'retirement');
+    span.setAttribute('query.length', query.length);
+
+    try {
+      // Track validation steps
+      span.addEvent('validation-started');
+
+      if (hasProhibitedTerms(query)) {
+        span.addEvent('validation-failed', { reason: 'prohibited-terms' });
+        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited terms detected' });
+        return response.json({ error: 'Invalid query' });
+      }
+
+      span.addEvent('validation-passed');
+
+      // Track LLM call separately
+      const advice = await context.tracer.startActiveSpan('generate-advice', async (llmSpan) => {
+        llmSpan.setAttribute('model', 'gpt-4');
+        const result = await generateAdvice(query);
+        llmSpan.setAttribute('response.tokens', countTokens(result));
+        llmSpan.end();
+        return result;
+      });
+
+      span.setStatus({ code: SpanStatusCode.OK });
+      return response.json({ advice });
+
+    } catch (error) {
+      span.recordException(error);
+      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
+      throw error;
+    } finally {
+      span.end();
+    }
+  });
+};`} />
+
+### Performance Best Practices
+
+Follow these optimization patterns to ensure your agents run efficiently in production:
+
+| Strategy | Implementation |
+|----------|---------------|
+| **Cache expensive operations** | Store LLM responses in KV with TTL to avoid repeated calls |
+| **Use parallel operations** | `Promise.all()` (JS) or `asyncio.gather()` (Python) for concurrent tasks |
+| **Fail fast** | Validate inputs early to avoid unnecessary processing |
+| **Track token usage** | Add token counts as span attributes to monitor costs |
+| **Set meaningful attributes** | Include user tier, request type, and other context for filtering |
+
+### What You Get Out of the Box
+
+<Callout type="info">
+**Built-in Observability**: Agentuity provides automatic OpenTelemetry instrumentation with zero configuration required.
+</Callout>
+
+Everything is tracked automatically:
+- **LLM calls**: Model, tokens, latency, and responses
+- **Storage operations**: Every KV get/set, vector search, object store operation
+- **API calls**: External service interactions and latencies
+- **Custom spans**: Your business logic with meaningful attributes
+- **Visual debugging**: Color-coded timeline in the console shows execution flow
+
+<Callout type="info">
+See the [Agent Telemetry Guide](/Guides/agent-telemetry) for advanced tracing and custom spans.
+</Callout>
 
 ## Implementing Guardrails
 
-Let's implement essential guardrails for a financial advisor agent:
+Let's implement essential guardrails for production agent systems, using patterns from our Conference Concierge system:
 
 ### 1. Schema Validation with Zod & Pydantic
 
 Runtime validation is critical for agents. TypeScript and Python types only exist at development time - at runtime, your data needs validation.
 
+**Zod** (TypeScript) and **Pydantic** (Python) are popular validation libraries in their respective ecosystems. Zod provides TypeScript-first schema validation with static type inference, while Pydantic offers high-performance validation for Python with type hints integration. Both solve the same problem: ensuring runtime data matches your type expectations.
+
 For detailed API references, see the [Zod](https://zod.dev) and [Pydantic](https://docs.pydantic.dev/latest/) documentation.
 
-<CodeExample py={`from pydantic import BaseModel, Field, ValidationError, field_validator
-from typing import Optional
+<CodeExample py={`from datetime import datetime
+from pydantic import BaseModel, Field, ValidationError
+from typing import Optional, Literal
 
 class UserQuery(BaseModel):
     query: str = Field(min_length=1, max_length=1000)
-    user_id: str  
-    portfolio_value: Optional[float] = Field(None, gt=0)
+    user_id: str
+    portfolio_value: Optional[float] = Field(None, gt=0)  # Must be > 0 if provided
+
+class ContentEvaluation(BaseModel):
+    approved: bool
+    reason: str
+    category: Literal['safe', 'risky', 'prohibited']
+    confidence: float = Field(ge=0.0, le=1.0)
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # 1. Validate structure
     try:
         raw_data = await request.data.json()
@@ -76,55 +232,148 @@ async def run(request, response, context):
             'details': e.errors()
         })
     
-    # 2. Apply domain rules separately
-    prohibited = ['insider', 'guaranteed']
-    if any(term in validated.query.lower() for term in prohibited):
-        return response.json({'error': 'Prohibited terms detected'})
-    
-    # 3. Process validated data
-    return await process_query(validated.query, validated.user_id)`} js={`import { z } from 'zod';
+    # 2. Use LLM jury for content evaluation
+    evaluation = await evaluate_with_jury(validated.query, context)
+    if not evaluation.approved:
+        return response.json({
+            'error': 'Content policy violation',
+            'reason': evaluation.reason
+        })
+
+    # 3. Process validated and approved data
+    return await process_query(validated.query, validated.user_id)
+
+async def evaluate_with_jury(query: str, context) -> ContentEvaluation:
+    """Use LLM jury to evaluate content appropriateness."""
+    jury_prompt = f'''
+    Evaluate this financial query for compliance and safety:
+    "{query}"
+
+    Check for:
+    - Prohibited financial advice (guaranteed returns, insider trading)
+    - Inappropriate requests (illegal activities)
+    - Scam indicators or harmful content
+
+    Respond with your evaluation as structured data.
+    '''
+
+    # Use structured generation with Python anthropic SDK
+    from anthropic import Anthropic
+    import json
+
+    client = Anthropic()
+    response = await client.messages.create(
+        model="claude-3-haiku-20240307",
+        max_tokens=1000,
+        messages=[{"role": "user", "content": jury_prompt}]
+    )
+
+    # Parse response and validate with Pydantic
+    try:
+        response_data = json.loads(response.content[0].text)
+        evaluation = ContentEvaluation(**response_data)
+    except (json.JSONDecodeError, ValidationError) as e:
+        # Fallback to safe evaluation
+        evaluation = ContentEvaluation(
+            approved=False,
+            reason="Failed to parse AI evaluation",
+            category="prohibited",
+            confidence=0.0
+        )
+
+    context.logger.info("Jury evaluation", {
+        "approved": evaluation.approved,
+        "category": evaluation.category,
+        "confidence": evaluation.confidence
+    })
+
+    return evaluation`} js={`import { z } from 'zod';
+import { generateObject } from 'ai';
+import { anthropic } from '@ai-sdk/anthropic';
 
 // Define clean schema for structure
 const UserQuerySchema = z.object({
   query: z.string().min(1).max(1000),
   userId: z.string(),
-  portfolioValue: z.number().positive().optional()
+  portfolioValue: z.number().positive().optional()  // Must be > 0 if provided
+});
+
+// Content evaluation schema for LLM jury
+const ContentEvaluationSchema = z.object({
+  approved: z.boolean(),
+  reason: z.string(),
+  category: z.enum(['safe', 'risky', 'prohibited']),
+  confidence: z.number().min(0).max(1)
 });
 
-// TypeScript type from schema
+// TypeScript types from schemas
 type UserQuery = z.infer<typeof UserQuerySchema>;
+type ContentEvaluation = z.infer<typeof ContentEvaluationSchema>;
 
 const handler = async (request, response, context) => {
   // 1. Validate structure
   const result = UserQuerySchema.safeParse(await request.data.json());
-  
+
   if (!result.success) {
     return response.json({
       error: 'Invalid request',
       details: result.error.issues
     });
   }
-  
-  // 2. Apply domain rules separately  
-  const prohibited = ['insider', 'guaranteed'];
-  if (prohibited.some(term => result.data.query.toLowerCase().includes(term))) {
-    return response.json({ error: 'Prohibited terms detected' });
+
+  // 2. Use LLM jury for content evaluation
+  const evaluation = await evaluateWithJury(result.data.query, context);
+  if (!evaluation.approved) {
+    return response.json({
+      error: 'Content policy violation',
+      reason: evaluation.reason
+    });
   }
-  
-  // 3. Process validated data
+
+  // 3. Process validated and approved data
   const { query, userId } = result.data;
   return await processQuery(query, userId);
+};
+
+async function evaluateWithJury(query: string, context): Promise<ContentEvaluation> {
+  const juryPrompt = \`
+  Evaluate this financial query for compliance and safety:
+  "\${query}"
+
+  Check for:
+  - Prohibited financial advice (guaranteed returns, insider trading)
+  - Inappropriate requests (illegal activities)
+  - Scam indicators or harmful content
+
+  Respond with your evaluation as structured data.
+  \`;
+
+  const evaluation = await generateObject({
+    model: anthropic('claude-3-haiku'),
+    schema: ContentEvaluationSchema,
+    prompt: juryPrompt
+  });
+
+  context.logger.info('Jury evaluation', {
+    approved: evaluation.object.approved,
+    category: evaluation.object.category,
+    confidence: evaluation.object.confidence
+  });
+
+  return evaluation.object;
 };`} />
 
 <Callout type="info">
 **Key Pattern**: Separate validation from domain rules. Schemas validate structure, your specific rules come after.
 </Callout>
 
+
 #### Real-World Example: Validating External API Responses
 
 Here's how the AI News Digest agent validates Hacker News API responses:
 
-<CodeExample py={`from pydantic import BaseModel, ValidationError
+<CodeExample py={`from datetime import datetime
+from pydantic import BaseModel, ValidationError
 from typing import Optional, List
 
 # Schema for Hacker News story
@@ -158,7 +407,7 @@ async def fetch_top_stories(ctx, count=5):
     
     return stories
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Fetch and validate stories
     articles = await fetch_top_stories(context, 5)
     
@@ -258,7 +507,7 @@ class AgentIntent(BaseModel):
     agent_type: Literal['support', 'sales', 'technical']
     confidence: float  # 0.0 to 1.0
 
-async def run(request, response, context):
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     user_message = await request.data.text()
     
     # AI generates structured, validated output
@@ -297,7 +546,7 @@ const handler = async (request, response, context) => {
   }
 };`} />
 
-### Orchestrators as Natural Guardrails
+### 3. Orchestrators as Natural Guardrails
 
 Remember the orchestrator pattern from Module 4? Orchestrators are your first line of defense:
 
@@ -324,7 +573,8 @@ async def orchestrator_with_guardrails(request, response, context):
         # Route sensitive requests to specialized agent
         return response.handoff(
             {"name": "compliance-agent"},
-            {"query": user_prompt, "flagged": True}
+            user_prompt,
+            metadata={"flagged": True}
         )
     
     if intent.confidence < 0.7:
@@ -343,7 +593,7 @@ async def orchestrator_with_guardrails(request, response, context):
     
     return response.handoff(
         {"name": agent_map[intent.category]},
-        {"query": user_prompt}
+        user_prompt
     )`} js={`import { z } from 'zod';
 
 const ValidatedIntentSchema = z.object({
@@ -413,7 +663,9 @@ See the complete [Conference Concierge implementation](https://github.com/agentu
 
 Prevent abuse and control costs:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    from datetime import datetime
+
     user_id = request.metadata.get("user_id")
     hour_key = f"rate_{user_id}_{datetime.now().hour}"
     
@@ -453,61 +705,80 @@ Prevent abuse and control costs:
   return await handleRequest(request);
 };`} />
 
-### 3. Domain-Specific Rules
+### 4. Domain-Specific Rules
 
 Enforce rules specific to your use case:
 
-<CodeExample py={`async def run(request, response, context):
+<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     query = (await request.data.json()).get("query", "")
-    
-    # Prohibited terms check
-    prohibited = ["guaranteed returns", "risk-free", "insider"]
-    for term in prohibited:
+
+    # Domain-specific validation rules
+    inappropriate_requests = ["hack", "illegal", "private information"]
+    for term in inappropriate_requests:
         if term in query.lower():
             return response.json({
-                "error": "Cannot provide advice on prohibited topics",
-                "reason": f"Term '{term}' is not allowed"
+                "error": "Cannot assist with inappropriate requests",
+                "reason": f"Request contains prohibited content: '{term}'"
             })
-    
-    # Generate advice with mandatory disclaimer
-    advice = await generate_advice(query)
-    
+
+    # Length validation
+    if len(query) > 1000:
+        return response.json({
+            "error": "Query too long",
+            "max_length": 1000
+        })
+
+    # Process valid request
+    result = await process_query(query, context)
+
     return response.json({
-        "advice": advice,
-        "disclaimer": "This is not personalized financial advice."
+        "response": result,
+        "processed_by": context.agent.name
     })`} js={`const handler: AgentHandler = async (request, response, context) => {
   const { query } = await request.data.json();
-  
-  // Prohibited terms check
-  const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
-  for (const term of prohibited) {
+
+  // Domain-specific validation rules
+  const inappropriateRequests = ['hack', 'illegal', 'private information'];
+  for (const term of inappropriateRequests) {
     if (query.toLowerCase().includes(term)) {
       return response.json({
-        error: 'Cannot provide advice on prohibited topics',
-        reason: 'Term \'' + term + '\' is not allowed'
+        error: 'Cannot assist with inappropriate requests',
+        reason: \`Request contains prohibited content: '\${term}'\`
       });
     }
   }
-  
-  // Generate advice with mandatory disclaimer
-  const advice = await generateAdvice(query);
-  
+
+  // Length validation
+  if (query.length > 1000) {
+    return response.json({
+      error: 'Query too long',
+      maxLength: 1000
+    });
+  }
+
+  // Process valid request
+  const result = await processQuery(query, context);
+
   return response.json({
-    advice,
-    disclaimer: 'This is not personalized financial advice.'
+    response: result,
+    processedBy: context.agent.name
   });
 };`} />
 
 ## Evaluation Strategies
 
+<Callout type="info">
+**Coming Soon**: Agentuity's integrated prompt library and automated evaluation suite will provide built-in prompt management and continuous evaluation workflows.
+</Callout>
+
 ### Define Success Metrics
 
 Choose metrics that matter for your domain:
 
 | Metric | Example | How to Measure |
 |--------|---------|----------------|
-| **Accuracy** | Correct advice | Compare against test cases |
-| **Compliance** | No prohibited terms | Check output validation |
+| **Accuracy** | Correct routing | Compare against test cases |
+| **Compliance** | Appropriate responses | Check output validation |
 | **Performance** | < 5s response | Track in telemetry |
 | **Cost** | < $0.10/request | Monitor token usage |
 
@@ -515,30 +786,39 @@ Choose metrics that matter for your domain:
 
 Create test cases that cover your critical scenarios:
 
-<CodeExample py={`# Golden dataset for testing
+<CodeExample py={`# Golden dataset for concierge testing
 test_cases = [
     {
-        "id": "basic_401k",
-        "input": {"query": "What is a 401k?"},
+        "id": "sf_local_question",
+        "input": {"query": "Where's good coffee near Moscone Center?"},
         "expected": {
-            "contains": ["retirement", "employer", "tax"],
-            "excludes": ["guaranteed returns"],
-            "has_disclaimer": True
+            "routed_to": "sf_local_guide",
+            "contains": ["coffee", "moscone", "san francisco"],
+            "confidence": 0.8
         }
     },
     {
-        "id": "prohibited_terms",
-        "input": {"query": "Give me guaranteed returns"},
+        "id": "conference_question",
+        "input": {"query": "What time is the keynote session?"},
         "expected": {
-            "error": "Cannot advise on 'guaranteed returns'"
+            "routed_to": "conference_expert",
+            "contains": ["keynote", "session", "schedule"]
         }
     },
     {
-        "id": "complex_question",
-        "input": {"query": "Should I max out my 401k or pay off debt?"},
+        "id": "developer_question",
+        "input": {"query": "How do I implement agent handoffs?"},
         "expected": {
-            "contains": ["consider", "interest rate", "match"],
-            "has_disclaimer": True
+            "routed_to": "dev_experience",
+            "contains": ["handoff", "agent", "implementation"]
+        }
+    },
+    {
+        "id": "unclear_request",
+        "input": {"query": "Help me with stuff"},
+        "expected": {
+            "fallback": True,
+            "contains": ["clarify", "help with"]
         }
     }
 ]
@@ -553,22 +833,21 @@ async def evaluate_agent(agent_handler, test_cases):
         
         # Check expectations
         passed = True
-        if "error" in test["expected"]:
-            passed = response.get("error") == test["expected"]["error"]
-        else:
-            content = response.get("advice", "").lower()
-            
-            # Check required terms
+        if "fallback" in test["expected"]:
+            # Check for fallback response pattern
+            content = response.get("message", "").lower()
+            passed = any(term in content for term in test["expected"].get("contains", []))
+        elif "routed_to" in test["expected"]:
+            # Check correct routing decision
+            routed_agent = response.get("routed_to")
+            passed = routed_agent == test["expected"]["routed_to"]
+
+            # Also check response content
+            content = response.get("response", "").lower()
             for term in test["expected"].get("contains", []):
                 if term not in content:
                     passed = False
                     break
-            
-            # Check prohibited terms
-            for term in test["expected"].get("excludes", []):
-                if term in content:
-                    passed = False
-                    break
         
         results.append({
             "test_id": test["id"],
@@ -578,63 +857,69 @@ async def evaluate_agent(agent_handler, test_cases):
     
     # Calculate success rate
     success_rate = sum(1 for r in results if r["passed"]) / len(results)
-    return {"success_rate": success_rate, "results": results}`} js={`// Golden dataset for testing
+    return {"success_rate": success_rate, "results": results}`} js={`// Golden dataset for concierge testing
 const testCases = [
   {
-    id: 'basic_401k',
-    input: { query: 'What is a 401k?' },
+    id: 'sf_local_question',
+    input: { query: "Where's good coffee near Moscone Center?" },
     expected: {
-      contains: ['retirement', 'employer', 'tax'],
-      excludes: ['guaranteed returns'],
-      hasDisclaimer: true
+      routedTo: 'sf_local_guide',
+      contains: ['coffee', 'moscone', 'san francisco'],
+      confidence: 0.8
     }
   },
   {
-    id: 'prohibited_terms',
-    input: { query: 'Give me guaranteed returns' },
+    id: 'conference_question',
+    input: { query: 'What time is the keynote session?' },
     expected: {
-      error: 'Cannot advise on guaranteed returns'
+      routedTo: 'conference_expert',
+      contains: ['keynote', 'session', 'schedule']
     }
   },
   {
-    id: 'complex_question',
-    input: { query: 'Should I max out my 401k or pay off debt?' },
+    id: 'developer_question',
+    input: { query: 'How do I implement agent handoffs?' },
     expected: {
-      contains: ['consider', 'interest rate', 'match'],
-      hasDisclaimer: true
+      routedTo: 'dev_experience',
+      contains: ['handoff', 'agent', 'implementation']
+    }
+  },
+  {
+    id: 'unclear_request',
+    input: { query: 'Help me with stuff' },
+    expected: {
+      fallback: true,
+      contains: ['clarify', 'help with']
     }
   }
 ];
 
 async function evaluateAgent(agentHandler, testCases) {
   const results = [];
-  
+
   for (const test of testCases) {
     // Run the agent
     const response = await agentHandler(test.input);
-    
+
     // Check expectations
     let passed = true;
-    if (test.expected.error) {
-      passed = response.error === test.expected.error;
-    } else {
-      const content = (response.advice || '').toLowerCase();
-      
-      // Check required terms
+    if (test.expected.fallback) {
+      // Check for fallback response pattern
+      const content = (response.message || '').toLowerCase();
+      passed = test.expected.contains.some(term => content.includes(term));
+    } else if (test.expected.routedTo) {
+      // Check correct routing decision
+      const routedAgent = response.routedTo;
+      passed = routedAgent === test.expected.routedTo;
+
+      // Also check response content
+      const content = (response.response || '').toLowerCase();
       for (const term of test.expected.contains || []) {
         if (!content.includes(term)) {
           passed = false;
           break;
         }
       }
-      
-      // Check prohibited terms
-      for (const term of test.expected.excludes || []) {
-        if (content.includes(term)) {
-          passed = false;
-          break;
-        }
-      }
     }
     
     results.push({
@@ -649,466 +934,188 @@ async function evaluateAgent(agentHandler, testCases) {
   return { successRate, results };
 }`} />
 
-## Observability with OpenTelemetry
-
-Agentuity automatically tracks everything through OpenTelemetry:
-
-### What's Tracked (No Code Required)
-- **Agent executions**: Full request/response lifecycle
-- **LLM calls**: Prompts, completions, token usage, latency
-- **Storage operations**: KV gets/sets, vector searches
-- **API calls**: External HTTP requests
-
-View in the Agentuity console Sessions tab with color-coded timeline visualization.
-
-### Using the Logger
-
-<CodeExample py={`async def run(request, response, context):
-    # Logs appear in Sessions view with trace context
-    context.logger.info("Processing", {"user_id": user_id})
-    
-    try:
-        result = await process(data)
-        context.logger.info("Success", {"count": len(result)})
-    except Exception as e:
-        context.logger.error("Failed", {"error": str(e)})
-        raise`} js={`const handler = async (request, response, context) => {
-  // Logs appear in Sessions view with trace context
-  context.logger.info('Processing', { userId });
-  
-  try {
-    const result = await process(data);
-    context.logger.info('Success', { count: result.length });
-  } catch (error) {
-    context.logger.error('Failed', { error: error.message });
-    throw error;
-  }
-};`} />
-
-### Custom Spans for Your Own Operations
-
-Track important operations with custom spans to understand performance and debug issues:
-
-<CodeExample py={`from opentelemetry.trace import Status, StatusCode
 
-async def run(request, response, context):
-    # Create a span for the entire validation flow
-    async with context.tracer.start_as_current_span("validate-financial-query") as span:
-        # Add context about this operation
-        span.set_attribute("user.tier", "premium")
-        span.set_attribute("query.type", "retirement")
-        span.set_attribute("query.length", len(query))
-        
-        try:
-            # Track validation steps
-            span.add_event("validation-started")
-            
-            if has_prohibited_terms(query):
-                span.add_event("validation-failed", {"reason": "prohibited-terms"})
-                span.set_status(Status(StatusCode.ERROR, "Prohibited terms detected"))
-                return response.json({"error": "Invalid query"})
-            
-            span.add_event("validation-passed")
-            
-            # Track LLM call separately
-            async with context.tracer.start_as_current_span("generate-advice") as llm_span:
-                llm_span.set_attribute("model", "gpt-4")
-                advice = await generate_advice(query)
-                llm_span.set_attribute("response.tokens", count_tokens(advice))
-            
-            span.set_status(Status(StatusCode.OK))
-            return response.json({"advice": advice})
-            
-        except Exception as e:
-            span.record_exception(e)
-            span.set_status(Status(StatusCode.ERROR, str(e)))
-            raise`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+## Validation Patterns from Working Agent Systems
 
-const handler = async (request, response, context) => {
-  // Create a span for the entire validation flow
-  return context.tracer.startActiveSpan('validate-financial-query', async (span) => {
-    // Add context about this operation
-    span.setAttribute('user.tier', 'premium');
-    span.setAttribute('query.type', 'retirement');
-    span.setAttribute('query.length', query.length);
-    
-    try {
-      // Track validation steps
-      span.addEvent('validation-started');
-      
-      if (hasProhibitedTerms(query)) {
-        span.addEvent('validation-failed', { reason: 'prohibited-terms' });
-        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited terms detected' });
-        return response.json({ error: 'Invalid query' });
-      }
-      
-      span.addEvent('validation-passed');
-      
-      // Track LLM call separately
-      const advice = await context.tracer.startActiveSpan('generate-advice', async (llmSpan) => {
-        llmSpan.setAttribute('model', 'gpt-4');
-        const result = await generateAdvice(query);
-        llmSpan.setAttribute('response.tokens', countTokens(result));
-        llmSpan.end();
-        return result;
-      });
-      
-      span.setStatus({ code: SpanStatusCode.OK });
-      return response.json({ advice });
-      
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-};`} />
+Instead of building a new agent from scratch, let's learn validation patterns from Module 4's Conference Concierge - a working system that shows useful validation techniques.
 
-### Performance Best Practices
+### Key Pattern: Structured LLM Output Validation
 
-Follow these optimization patterns to ensure your agents run efficiently in production:
+The concierge uses validation schemas to ensure AI generates reliable routing decisions:
 
-| Strategy | Implementation |
-|----------|---------------|
-| **Cache expensive operations** | Store LLM responses in KV with TTL to avoid repeated calls |
-| **Use parallel operations** | `Promise.all()` (JS) or `asyncio.gather()` (Python) for concurrent tasks |
-| **Fail fast** | Validate inputs early to avoid unnecessary processing |
-| **Track token usage** | Add token counts as span attributes to monitor costs |
-| **Set meaningful attributes** | Include user tier, request type, and other context for filtering |
+<CodeExample py={`# Python - Pydantic validation for AI-generated routing decisions
+from pydantic import BaseModel, ValidationError
+from typing import Literal
 
-### What You Get Out of the Box
+class UserIntent(BaseModel):
+    agent_type: Literal['sf_local_guide', 'conference_expert', 'dev_experience']
+    confidence: float
 
-<Callout type="info">
-**Built-in Observability**: Agentuity provides automatic OpenTelemetry instrumentation with zero configuration required.
-</Callout>
+# Use AI to analyze intent with validation
+try:
+    ai_response = await generate_structured_intent(user_message)
+    intent = UserIntent(**ai_response)  # Pydantic validates structure
+except ValidationError:
+    # Safe fallback for invalid data
+    intent = UserIntent(agent_type='dev_experience', confidence=0.5)
 
-Everything is tracked automatically:
-- **LLM calls**: Model, tokens, latency, and responses
-- **Storage operations**: Every KV get/set, vector search, object store operation
-- **API calls**: External service interactions and latencies
-- **Custom spans**: Your business logic with meaningful attributes
-- **Visual debugging**: Color-coded timeline in the console shows execution flow
+# Validated data enables confident decision making
+if intent.confidence < 0.8:
+    return response.json({
+        "message": "I'll connect you with a human specialist"
+    })`} js={`// TypeScript - Zod validation for AI-generated routing decisions
+import { z } from 'zod';
+import { generateObject } from 'ai';
 
-<Callout type="info">
-See the [Agent Telemetry Guide](/Guides/agent-telemetry) for advanced tracing and custom spans.
-</Callout>
+const UserIntentSchema = z.object({
+  agentType: z.enum(['sf_local_guide', 'conference_expert', 'dev_experience']),
+  confidence: z.number().min(0).max(1)
+});
 
-## Lab: Production-Ready Financial Advisor
+// Validation ensures reliable AI output structure
+const { object: userIntent } = await generateObject({
+  model: anthropic('claude-3-5-sonnet-20241022'),
+  schema: UserIntentSchema,  // Zod prevents invalid structures
+  prompt: \`Analyze this user message and determine routing: "\${userMessage}"\`
+});
 
-Let's build a financial advisor progressively, adding production features step by step:
+// Validated data enables confident decision making
+if (userIntent.confidence < 0.8) {
+  return response.json({
+    message: "I'll connect you with a human specialist"
+  });
+}`} />
 
-### Step 1: Basic Validation
+### Key Pattern: Input Validation
 
-<CodeExample py={`from pydantic import BaseModel, Field, ValidationError
-from typing import Optional
+Agents should validate all inputs before processing:
 
-# Simple schema for financial queries
-class FinancialQuery(BaseModel):
-    query: str = Field(min_length=1, max_length=500)
-    portfolio_value: Optional[float] = Field(None, gt=0)
+```python
+# From Module 4: Pydantic validation patterns
+from pydantic import BaseModel, Field, ValidationError
+from typing import Literal
 
-def welcome():
-    return {
-        "welcome": "Financial Advisor Agent",
-        "prompts": [
-            {"data": {"query": "What is a Roth IRA?"}, "contentType": "application/json"},
-            {"data": {"query": "How do I invest $50000?"}, "contentType": "application/json"}
-        ]
-    }
+class ConversationRequest(BaseModel):
+    message: str = Field(min_length=1, max_length=1000)
+    session_id: str = Field(pattern=r'^[a-zA-Z0-9_-]+$')
+    user_preferences: dict = Field(default_factory=dict)
 
-async def run(request, response, context):
-    # Step 1: Validate input structure
+async def concierge_handler(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Validate input structure with clear error handling
     try:
         data = await request.data.json()
-        validated = FinancialQuery(**data)
+        validated = ConversationRequest(**data)
     except ValidationError as e:
-        context.logger.error("Invalid input", {"errors": e.errors()})
-        return response.json({"error": "Invalid request", "details": e.errors()})
-    
-    # Step 2: Apply domain rules
-    prohibited = ['guaranteed returns', 'risk-free', 'insider']
-    for term in prohibited:
-        if term in validated.query.lower():
-            context.logger.warning("Prohibited term", {"term": term})
-            return response.json({"error": f"Cannot advise on '{term}'"})
-    
-    # Step 3: Generate response
-    advice = await generate_financial_advice(validated.query, context)
-    
-    return response.json({
-        "advice": advice,
-        "disclaimer": "Not personalized financial advice."
-    })
-
-async def generate_financial_advice(query: str, context) -> str:
-    """Generate financial advice - mock implementation for demo."""
-    context.logger.info("Generating advice", {"query_preview": query[:50]})
-    
-    # Simple mock responses
-    advice_map = {
-        "roth ira": "A Roth IRA is a retirement account with tax-free withdrawals.",
-        "401k": "A 401(k) offers pre-tax contributions and employer matching.",
-        "invest": "Start with your risk tolerance and time horizon."
-    }
-    
-    query_lower = query.lower()
-    for key, advice in advice_map.items():
-        if key in query_lower:
-            return advice
-    
-    return "I can help with retirement accounts and investment strategies."`} js={`import { z } from 'zod';
-
-// Simple schema for financial queries
-const FinancialQuerySchema = z.object({
-  query: z.string().min(1).max(500),
-  portfolioValue: z.number().positive().optional()
-});
+        context.logger.warning("Invalid input structure", {"errors": e.errors()})
+        return response.json({
+            "error": "Invalid request format",
+            "details": [{"field": err["loc"][-1], "issue": err["msg"]} for err in e.errors()]
+        })
 
-const welcome = () => ({
-  welcome: 'Financial Advisor Agent',
-  prompts: [
-    { data: JSON.stringify({ query: 'What is a Roth IRA?' }), contentType: 'application/json' },
-    { data: JSON.stringify({ query: 'How do I invest $50000?' }), contentType: 'application/json' }
-  ]
-});
+    # Proceed with validated, type-safe data
+    return await process_conversation(validated, context)
+```
 
-const handler = async (request, response, context) => {
-  // Step 1: Validate input structure
-  const result = FinancialQuerySchema.safeParse(await request.data.json());
-  if (!result.success) {
-    context.logger.error('Invalid input', { errors: result.error.issues });
-    return response.json({ error: 'Invalid request', details: result.error.issues });
-  }
-  
-  const validated = result.data;
-  
-  // Step 2: Apply domain rules
-  const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
-  for (const term of prohibited) {
-    if (validated.query.toLowerCase().includes(term)) {
-      context.logger.warning('Prohibited term', { term });
-      return response.json({ error: 'Cannot advise on ' + term });
+### Key Pattern: Domain-Specific Guardrails
+
+The concierge applies context-aware validation rules:
+
+```typescript
+// Context-aware validation based on agent routing
+async function validateAgentRouting(
+  userIntent: UserIntent,
+  conversationHistory: ConversationRecord,
+  ctx: AgentContext
+) {
+  // Apply routing-specific validation rules
+  if (userIntent.agentType === 'dev_experience') {
+    // Technical questions require minimum context
+    if (userIntent.context.length < 10) {
+      ctx.logger.info('Insufficient context for technical routing');
+      return { valid: false, reason: 'Please provide more detail about your question' };
     }
   }
-  
-  // Step 3: Generate response
-  const advice = await generateFinancialAdvice(validated.query, context);
-  
-  return response.json({
-    advice,
-    disclaimer: 'Not personalized financial advice.'
-  });
-};
 
-async function generateFinancialAdvice(query, context) {
-  // Generate financial advice - mock implementation for demo
-  context.logger.info('Generating advice', { queryPreview: query.substring(0, 50) });
-  
-  // Simple mock responses
-  const adviceMap = {
-    'roth ira': 'A Roth IRA is a retirement account with tax-free withdrawals.',
-    '401k': 'A 401(k) offers pre-tax contributions and employer matching.',
-    'invest': 'Start with your risk tolerance and time horizon.'
-  };
-  
-  const queryLower = query.toLowerCase();
-  for (const [key, advice] of Object.entries(adviceMap)) {
-    if (queryLower.includes(key)) {
-      return advice;
+  // Location questions need geographic context
+  if (userIntent.agentType === 'sf_local_guide') {
+    const hasLocationContext = /\b(san francisco|sf|bay area|moscone)\b/i.test(userIntent.context);
+    if (!hasLocationContext) {
+      return { valid: false, reason: 'Please specify your San Francisco location or area of interest' };
     }
   }
-  
-  return 'I can help with retirement accounts and investment strategies.';
-}
-
-export default handler;
-export { welcome };`} />
-
-### Step 2: Add Rate Limiting
-
-Now enhance with rate limiting to prevent abuse:
-
-<CodeExample py={`# Add to the run function after validation:
-
-# Check rate limit
-user_id = request.metadata.get("user_id", "anonymous")
-hour_key = f"rate_{user_id}_{datetime.now().hour}"
-usage = await context.kv.get("rate_limits", hour_key)
-count = await usage.data.json() if usage.exists else 0
-
-if count >= 100:  # 100 requests per hour
-    return response.json({
-        "error": "Rate limit exceeded",
-        "retry_after": 3600
-    })
 
-await context.kv.set("rate_limits", hour_key, count + 1, {"ttl": 3600})`} js={`// Add to the handler after validation:
-
-// Check rate limit
-const userId = request.metadata.get('user_id') || 'anonymous';
-const hourKey = 'rate_' + userId + '_' + new Date().getHours();
-const usage = await context.kv.get('rate_limits', hourKey);
-const count = usage.exists ? await usage.data.json() : 0;
-
-if (count >= 100) {  // 100 requests per hour
-  return response.json({
-    error: 'Rate limit exceeded',
-    retry_after: 3600
-  });
+  return { valid: true };
 }
+```
 
-await context.kv.set('rate_limits', hourKey, count + 1, { ttl: 3600 });`} />
-
-### Step 3: Add Observability
+### Pattern: Error Recovery and Fallbacks
 
-Finally, add custom spans to track and debug your agent's performance:
+Good validation includes graceful error recovery:
 
-<CodeExample py={`from opentelemetry.trace import Status, StatusCode
+```python
+# Defensive validation with multiple fallback strategies
+async def validate_with_fallbacks(request_data: dict, context: AgentContext):
+    # Strategy 1: Full validation
+    try:
+        validated = ConversationRequest(**request_data)
+        return {"status": "validated", "data": validated}
+    except ValidationError as primary_error:
+        context.logger.info("Primary validation failed, trying fallbacks")
 
-async def run(request, response, context):
-    # Create a span for the entire request
-    async with context.tracer.start_as_current_span("financial-advisor-request") as span:
-        user_id = request.metadata.get("user_id", "anonymous")
-        span.set_attribute("user.id", user_id)
-        span.set_attribute("request.type", "financial-advice")
-        
-        # Validation with span tracking
-        span.add_event("validation-started")
-        try:
-            data = await request.data.json()
-            validated = FinancialQuery(**data)
-            span.set_attribute("query.length", len(validated.query))
-        except ValidationError as e:
-            span.add_event("validation-failed", {"errors": str(e.errors())})
-            span.set_status(Status(StatusCode.ERROR, "Invalid input"))
-            context.logger.error("Invalid input", {"errors": e.errors()})
-            return response.json({"error": "Invalid request", "details": e.errors()})
-        
-        span.add_event("validation-passed")
-        
-        # Domain rules check with tracking
-        prohibited = ['guaranteed returns', 'risk-free', 'insider']
-        for term in prohibited:
-            if term in validated.query.lower():
-                span.add_event("compliance-violation", {"term": term})
-                span.set_status(Status(StatusCode.ERROR, f"Prohibited term: {term}"))
-                return response.json({"error": f"Cannot advise on '{term}'"})
-        
-        # Generate advice with nested span
-        async with context.tracer.start_as_current_span("generate-advice") as advice_span:
-            advice_span.set_attribute("query.type", detect_query_type(validated.query))
-            advice = await generate_financial_advice(validated.query, context)
-            advice_span.set_attribute("response.length", len(advice))
-        
-        span.add_event("response-generated")
-        span.set_status(Status(StatusCode.OK))
-        
-        return response.json({
-            "advice": advice,
-            "disclaimer": "Not personalized financial advice."
-        })`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+    # Strategy 2: Essential fields only
+    try:
+        essential_fields = {
+            "message": request_data.get("message", ""),
+            "session_id": request_data.get("session_id", f"fallback_{uuid.uuid4()}")
+        }
+        minimal = ConversationRequest(**essential_fields)
+        context.logger.info("Using minimal validation fallback")
+        return {"status": "fallback", "data": minimal}
+    except ValidationError:
+        context.logger.warning("All validation strategies failed")
 
-const handler = async (request, response, context) => {
-  // Create a span for the entire request
-  return context.tracer.startActiveSpan('financial-advisor-request', async (span) => {
-    const userId = request.metadata.get('user_id') || 'anonymous';
-    span.setAttribute('user.id', userId);
-    span.setAttribute('request.type', 'financial-advice');
-    
-    // Validation with span tracking
-    span.addEvent('validation-started');
-    const result = FinancialQuerySchema.safeParse(await request.data.json());
-    if (!result.success) {
-      span.addEvent('validation-failed', { errors: JSON.stringify(result.error.issues) });
-      span.setStatus({ code: SpanStatusCode.ERROR, message: 'Invalid input' });
-      context.logger.error('Invalid input', { errors: result.error.issues });
-      span.end();
-      return response.json({ error: 'Invalid request', details: result.error.issues });
-    }
-    
-    span.addEvent('validation-passed');
-    span.setAttribute('query.length', result.data.query.length);
-    
-    const validated = result.data;
-    
-    // Domain rules check with tracking
-    const prohibited = ['guaranteed returns', 'risk-free', 'insider'];
-    for (const term of prohibited) {
-      if (validated.query.toLowerCase().includes(term)) {
-        span.addEvent('compliance-violation', { term });
-        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited term: ' + term });
-        span.end();
-        return response.json({ error: 'Cannot advise on ' + term });
-      }
+    # Strategy 3: Safe defaults
+    return {
+        "status": "default",
+        "data": ConversationRequest(
+            message="I need help",
+            session_id=f"emergency_{int(time.time())}"
+        )
     }
-    
-    // Generate advice with nested span
-    const advice = await context.tracer.startActiveSpan('generate-advice', async (adviceSpan) => {
-      adviceSpan.setAttribute('query.type', detectQueryType(validated.query));
-      const result = await generateFinancialAdvice(validated.query, context);
-      adviceSpan.setAttribute('response.length', result.length);
-      adviceSpan.end();
-      return result;
-    });
-    
-    span.addEvent('response-generated');
-    span.setStatus({ code: SpanStatusCode.OK });
-    span.end();
-    
-    return response.json({
-      advice,
-      disclaimer: 'Not personalized financial advice.'
-    });
-  });
-};`} />
+```
 
-### Common Validation Pitfalls
+## 🚀 Coming Soon: Integrated Prompts & Evaluations
 
-Avoid these common mistakes when implementing validation:
+Agentuity is working on prompt management and evaluation features:
 
-| Pitfall | Best Practice |
-|---------|--------------|
-| **Using deprecated validators** | Pydantic v2: Use `@field_validator`, not `@validator` |
-| **Throwing on invalid input** | Zod: Use `safeParse` by default, `parse` only when you want to throw |
-| **Mixing concerns** | Keep schemas for structure, domain rules separate |
-| **I/O in validators** | Never make API calls or database queries inside validators |
-| **Poor error messages** | Format validation errors in user-friendly ways before returning |
+### **Code-First Prompts**
+- Version-controlled prompts in your codebase alongside agent logic
+- Prompt templates with variable substitution
 
-### Testing Your Production Agent
+### **Automated Evaluations**
+- Evals that run automatically after every agent session (configurable)
+- Custom evaluation criteria specific to your domain and use cases
+- Integration with your existing CI/CD pipeline
 
-1. **Start DevMode:**
-```bash
-agentuity dev
-```
+### **Experimentation Mode**
+- Multi-model comparisons (e.g., GPT-5, Claude, Gemini) on identical prompts
 
-2. **Test guardrails:**
-   - Try prompt injection attacks
-   - Exceed rate limits
-   - Request prohibited advice
+<Callout type="info">
+These features will provide better visibility into agent behavior and systematic ways to improve agent performance over time.
+</Callout>
 
-3. **Monitor observability:**
-   - Watch traces in real-time
-   - Track custom metrics
-   - Review logs for issues
+## Key Takeaways
 
 - **Guardrails prevent failures** - Input validation, rate limiting, and domain rules protect your agents
-- **Evaluation proves reliability** - Systematic testing with metrics that matter for your domain  
-- **Observability is automatic** - Agentuity provides OpenTelemetry integration with Traceloop for comprehensive monitoring
+- **Evaluation proves reliability** - Systematic testing with metrics that matter for your domain
+- **Observability is automatic** - Agentuity provides OpenTelemetry integration for comprehensive monitoring
 - **The console shows everything** - Sessions view with color-coded timeline visualization
 - **Production readiness** requires all three pillars working together
 
 ## What's Next?
 
-Now that your agents are production-ready, it's time to deploy them. In the next module, we'll explore Agentuity's deployment environments - from local development through staging to production.
-
-But first, experiment with the lab agent:
-- Test different guardrail scenarios
-- View the telemetry in the console
-- Try modifying the evaluation criteria
-- Add your own custom spans
+Now that you understand the fundamentals of production-ready agents, it's time to explore deployment. In the next module, we'll cover Agentuity's deployment environments - from local development through staging to production.
 
 ---
 
-**Ready for Module 6?** [Deployment Environments](./06-deployment-environments)
\ No newline at end of file
+**Ready for Module 6?** [Deployment Environments](./06-deployment-environments)
diff --git a/content/Training/developers/06-deployment-environments.mdx b/content/Training/developers/06-deployment-environments.mdx
index c9e53f4d..c314763c 100644
--- a/content/Training/developers/06-deployment-environments.mdx
+++ b/content/Training/developers/06-deployment-environments.mdx
@@ -5,16 +5,6 @@ description: From local development to global production
 
 You've built agents with memory, collaboration, and production-grade guardrails. Now let's deploy them properly.
 
-## The Reality of Enterprise Agent Deployment
-
-Research shows that [most organizations aren't "agent-ready"](https://www.ibm.com/think/insights/ai-agents-2025-expectations-vs-reality) - they lack the infrastructure, processes, and understanding needed for production agents. When [Salesforce deployed their Agentforce AI agents](https://www.hr-brew.com/stories/2025/03/04/salesforce-ai-agents-reskilling), it required massive organizational change alongside the technology.
-
-The challenge involves both technical and operational considerations:
-- How do you test non-deterministic agents?
-- How do you safely roll out changes that affect customer interactions?
-- How do you monitor agents that make autonomous decisions?
-- How do you handle failures gracefully when agents are unpredictable?
-
 ## The Agentuity Environment Model
 
 Agentuity provides three distinct environments, each with specific purposes:
@@ -25,7 +15,7 @@ Agentuity provides three distinct environments, each with specific purposes:
 Your local machine running DevMode:
 - Instant feedback with hot reload
 - Full debugging capabilities
-- Observability provided by Traceloop (OpenTelemetry integration)
+- Observability provided by OpenTelemetry integration
 - Access to Agentuity API features (memory, etc)
 
 ```bash
@@ -48,12 +38,12 @@ Cloud deployment with test data:
 - Options for different deployment configurations
 - Ability to use different keys and environment variables
 
-```bash
-# Deploy to staging (coming soon)
-```
+<Callout type="info">
+Staging environment deployment is coming soon. For now, you can test locally with DevMode and deploy directly to production.
+</Callout>
 
 ### Production Environment
-**Where agents serve users**
+**Where agents live**
 
 Full-scale deployment:
 - Auto-scaling infrastructure
@@ -64,6 +54,47 @@ Full-scale deployment:
 agentuity deploy
 ```
 
+## Preview Deployments
+
+**Testing changes in the cloud before production**
+
+Preview deployments allow you to test agent modifications in a cloud environment automatically when you create pull requests, giving you confidence before merging to production.
+
+### How Preview Deployments Work
+
+1. **Enable in Console**: Turn on preview deployments for your repository
+2. **Create Pull Request**: Open a PR with your agent changes
+3. **Automatic Deployment**: Agentuity automatically deploys your changes to a preview environment
+4. **Test with Unique URLs**: Each preview gets unique URLs with git hash tagging
+5. **Merge with Confidence**: Test thoroughly before merging to production
+
+### Setting Up Preview Deployments
+
+Enable preview deployments in your repository settings through the Agentuity console with a simple toggle switch.
+
+### PR Integration
+
+When you create a pull request, Agentuity automatically comments with:
+- Direct links to your preview deployment
+- Curl examples for API testing
+- Deployment logs and monitoring links
+- Configuration details from your agentuity.yaml
+
+### Preview Environment Access
+
+Each preview deployment gets tagged URLs that include your git commit hash, allowing precise testing of specific changes.
+
+<Callout type="info">
+**Current Status**: Preview deployments share production resources for storage (KV, vector, object store). Full resource isolation is coming soon.
+</Callout>
+
+### Benefits for Development Teams
+
+- **Collaborative testing**: Share preview links with team members and stakeholders
+- **Integration validation**: Test with real external APIs in cloud environment
+- **Performance insights**: See how changes perform under cloud conditions
+- **Risk reduction**: Catch issues before they reach production users
+
 ## Environment Progression
 
 ### Moving Through Environments
@@ -73,6 +104,7 @@ The typical flow moves from local development to production with clear validatio
 | Stage | Purpose | Key Focus | Typical Timeline |
 |-------|---------|-----------|------------------|
 | **Local Dev** | Build & iterate rapidly | Feature development | Hours to days |
+| **Preview** | Test changes in cloud | PR validation & team collaboration | Minutes to hours |
 | **Staging** | Validate production readiness | Performance & integration testing | Days to weeks |
 | **Production** | Serve real users | Monitoring & optimization | Ongoing |
 
@@ -80,14 +112,14 @@ The typical flow moves from local development to production with clear validatio
 
 Each environment emphasizes different aspects of your agent's readiness:
 
-| Focus Area | Development | Staging | Production |
-|------------|------------|---------|------------|
-| **Functionality** | Core features work | Load & stress testing | Success metrics |
-| **Memory & State** | Memory operations function | Memory performance under load | Response time tracking |
-| **Error Handling** | Validation works | Rate limiting effective | Error rate monitoring |
-| **Observability** | Debug information available | Telemetry accuracy | Performance insights |
-| **Integration** | Error messages helpful | External service testing | User experience metrics |
-| **Resilience** | Basic error recovery | Failover mechanisms | Incident response |
+| Focus Area | Development | Preview | Staging | Production |
+|------------|------------|---------|---------|------------|
+| **Functionality** | Core features work | Change validation | Load & stress testing | Success metrics |
+| **Memory & State** | Memory operations function | Data integration testing | Memory performance under load | Response time tracking |
+| **Error Handling** | Validation works | Edge case testing | Rate limiting effective | Error rate monitoring |
+| **Observability** | Debug information available | Cloud behavior verification | Telemetry accuracy | Performance insights |
+| **Integration** | Error messages helpful | Real API testing | External service testing | User experience metrics |
+| **Resilience** | Basic error recovery | Team collaboration | Failover mechanisms | Incident response |
 
 ## Enterprise Deployment Options
 
@@ -96,10 +128,53 @@ Each environment emphasizes different aspects of your agent's readiness:
 </Callout>
 
 ### Private Cloud Deployments
-Deploy Agentuity infrastructure in your own cloud account. More information coming soon!
+
+**Complete infrastructure control via CLI**
+
+<Callout type="info">
+**Coming Soon**: Create and manage your own Agentuity clusters with full control over infrastructure, compliance, and data sovereignty.
+</Callout>
+
+#### Multi-Cloud Support
+Deploy Agentuity infrastructure on your preferred cloud provider with full region selection:
+- **Amazon Web Services (AWS)** - All AWS regions
+- **Microsoft Azure** - Global Azure regions
+- **Google Cloud Platform (GCP)** - Worldwide GCP regions
+- **VMware** - On-premise and private cloud deployments
+
+#### Flexible Cluster Sizing
+Choose the right cluster size for your workload:
+
+| Size | Use Case | Typical Workload |
+|------|----------|------------------|
+| **Dev** | Development & testing | Individual developers, proof of concepts |
+| **Small** | Team deployments | Small teams, departmental use |
+| **Medium** | Production workloads | Multiple teams, moderate scale |
+| **Large** | Enterprise scale | High-volume production, multiple business units |
+
+#### Complete Cluster Management
+Create and manage clusters through the command-line interface with full control over:
+
+- **Cluster Creation**: New cluster provisioning across supported providers
+- **Region Selection**: Choose optimal geographic deployment locations
+- **Machine Management**: List, remove, and monitor individual cluster machines
+- **Status Monitoring**: Real-time cluster health and performance visibility
+
+#### Deployment Options
+- **Automated Setup**: Streamlined cloud provider integration
+- **Manual Setup**: Step-by-step guidance for custom configurations
+- **Full Control**: Complete networking, security, and resource customization
+
+#### Enterprise Benefits
+- **Data Sovereignty**: Keep all data within your infrastructure boundaries
+- **Compliance Control**: Meet specific regulatory and security requirements
+- **Performance Optimization**: Deploy closer to your users and data sources
+- **Cost Management**: Direct control over resource allocation and scaling
 
 ### On-Premise Installations
-Run Agentuity entirely within your data center. More information coming soon!
+**VMware-based deployments for complete on-premise control**
+
+Run Agentuity entirely within your data center using VMware infrastructure. Perfect for organizations requiring complete air-gapped deployments or specific hardware control.
 
 ## Configuration Management
 
@@ -107,16 +182,9 @@ Run Agentuity entirely within your data center. More information coming soon!
 
 Different environments need different configurations:
 
-{/* Environment-specific settings are typically configured through the Agentuity web console.
-Screenshots showing the web UI for environment configuration will be added here.
-
-The web console allows you to set:
-- Environment variables per deployment
-- Rate limiting and caching settings
-- Feature flags and deployment options
-- Observability and monitoring configuration */}
-
-*Environment-specific settings are managed through the Agentuity web console. Screenshots of the configuration interface will be provided here.*
+<Callout type="info">
+Environment-specific settings are configured in the Agentuity web console. More information coming soon.
+</Callout>
 
 ## Real-World Deployment Lessons
 
@@ -136,44 +204,6 @@ When Salesforce deployed agents to handle 50% of support cases, they learned:
 - **Cost management**: Token limits per customer interaction
 - **Security paramount**: No customer data in prompts
 
-## Lab: Deploy Your Financial Advisor
-
-Let's deploy the financial advisor from Module 5:
-
-### Step 1: Prepare for Deployment
-
-```bash
-# Ensure all tests pass
-npm test  # or python -m pytest
-
-# Check environment variables
-agentuity config verify
-
-# Build for production
-agentuity build
-```
-
-### Step 2: Deploy to Production
-
-```bash
-# Deploy with confirmation
-agentuity deploy --confirm
-
-# Monitor deployment
-agentuity logs --follow
-
-# Check health
-agentuity status
-```
-
-### Step 3: Monitor in Production
-
-View your deployment in the Agentuity console:
-- Real-time metrics
-- Session traces
-- Error tracking
-- Cost analysis
-
 ## What's Next?
 
 You now understand the deployment journey from local development to production. But how do you build complete, production-ready systems that combine everything you've learned?
@@ -185,12 +215,6 @@ In the next module, we'll tackle the capstone project - building a full agent sy
 - Comprehensive observability
 - Proper deployment practices
 
-But first, experiment with deployment:
-- Deploy your agents to production
-- Monitor their performance
-- Try different configurations
-- Practice rollback procedures
-
 ---
 
-**Ready for the Capstone?** [Module 7: Sandbox & Capstone Project](./07-sandbox-capstone)
\ No newline at end of file
+**Ready for the Capstone?** [Module 7: Sandbox & Capstone Project](./07-sandbox-capstone)
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index fa28933a..d779acbc 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -1,9 +1,9 @@
 ---
-title: "Module 7: Sandbox & Capstone Project"
-description: Bringing it all together in a complete production system
+title: "Module 7: Advanced Multi-Agent Research System"
+description: Building sophisticated agent coordination with recursive research
 ---
 
-Time to combine everything you've learned into a complete, production-ready agent system.
+Time to build an advanced multi-agent research system that combines everything you've learned.
 
 ## Building Your Capstone
 
@@ -16,7 +16,7 @@ As you work on your capstone project:
 5. **Monitor everything** - You can't fix what you can't see
 
 <Callout type="info">
-Pro Tip: Build your capstone iteratively. Start with two agents (triage + one specialist), get that working perfectly, then add more complexity.
+Pro Tip: Build your research system iteratively. Start with orchestrator + web search agents, get that working perfectly, then add recursive research and report generation.
 </Callout>
 
 ## Coming Soon: Agentic Sandbox
@@ -55,358 +55,215 @@ An intelligent assistant that helps you learn:
 - **Learning paths**: Customized based on your experience
 - **Best practices**: Recommends patterns for your use case
 
-## Capstone Project: Customer Support System
+## Capstone Project: Deep Research System
 
-Let's build a complete customer support system that demonstrates mastery of all previous modules.
+Build an advanced multi-agent research system that demonstrates mastery of sophisticated agent coordination, recursive algorithms, and real-world API integration.
 
 ### Project Overview
 
-**Goal**: Build a multi-agent customer support system that can:
-- Handle customer inquiries autonomously
-- Escalate complex issues appropriately
-- Learn from interactions
-- Maintain conversation context
-- Ensure compliance and safety
+**Goal**: Create a research system that can:
+- Coordinate multiple specialized research agents
+- Conduct recursive deep-dive investigations
+- Accumulate knowledge across research iterations
+- Generate comprehensive structured reports
+- Handle complex multi-source information synthesis
 
 ### System Architecture
 
 <Mermaid chart="
 graph TD
-    User[Customer] --> Triage[Triage Agent]
-    Triage -->|FAQ/Tech/Billing| Specialist[Specialist Agent]
-    Triage -->|Urgent/Low Confidence| Human[Human Escalation]
-    Specialist --> User
-    Human --> User
-    Memory[(Memory)] -.-> Triage
-    Memory -.-> Specialist
+    User[Research Request] --> Orchestrator[Research Orchestrator]
+    Orchestrator --> Researcher[Deep Researcher]
+    Researcher -->|Recursive Calls| Researcher
+    Researcher --> WebSearch[Web Search Agent]
+    WebSearch --> Researcher
+    Researcher --> Author[Report Author]
+    Author --> User[Structured Report]
+    Memory[(Research State)] -.-> Orchestrator
+    Memory -.-> Researcher
+    Memory -.-> Author
 " />
 
-### Skills in Practice
-
-Building this multi-agent system demonstrates the key concepts covered in this training:
-
-| Module | Key Skills Applied |
-|--------|-------------------|
-| **Agent Basics** | Request/response handling, error management, welcome messages, trigger configuration |
-| **Agent Anatomy** | Lifecycle management, comprehensive logging, context usage, tool integration |
-| **Memory Management** | Conversation history, user preferences, session management, cleanup strategies |
-| **Multi-Agent Collaboration** | Routing logic, context sharing, smooth handoffs, information preservation |
-| **Production Readiness** | Input validation (Zod/Pydantic), rate limiting, observability spans, compliance rules |
-| **Deployment** | Environment configuration, production deployment, monitoring setup |
-
-### Phase 1: Triage Agent
-
-The entry point for all customer interactions:
-
-<CodeExample py={`from pydantic import BaseModel
-from typing import Literal
-from ai import generate_object
-from anthropic import anthropic
-
-class CustomerIntent(BaseModel):
-    category: Literal['faq', 'technical', 'billing', 'urgent']
-    confidence: float
-    summary: str
-    
-async def run(request, response, context):
-    # Track the conversation
-    async with context.tracer.start_as_current_span("triage-request") as span:
-        session_id = request.metadata.get("session_id")
-        span.set_attribute("session.id", session_id)
-        
-        # Get conversation history
-        history = await context.kv.get("conversations", session_id)
-        messages = history.data.json() if history.exists else []
-        
-        # Analyze customer intent
-        customer_message = await request.data.text()
-        messages.append({"role": "user", "content": customer_message})
-        
-        intent = await generate_object(
-            model=anthropic("claude-3-7-sonnet"),
-            schema=CustomerIntent,
-            prompt=f"""
-            Analyze this customer support request:
-            Message: {customer_message}
-            History: {messages[-5:]}  # Last 5 messages for context
-            
-            Categorize as: faq, technical, billing, or urgent
-            """
-        )
-        
-        span.set_attribute("intent.category", intent.object.category)
-        span.set_attribute("intent.confidence", intent.object.confidence)
-        
-        # Route to appropriate agent
-        if intent.object.confidence < 0.7 or intent.object.category == "urgent":
-            # Low confidence or urgent = human escalation
-            span.add_event("escalating-to-human")
-            return response.json({
-                "action": "escalate",
-                "message": "Connecting you with a human agent...",
-                "reason": intent.object.summary
-            })
-        
-        # Hand off to specialist agent
-        return response.handoff(
-            {"name": f"{intent.object.category}-agent"},
-            customer_message,  # Pass message as data
-            {
-                "session_id": session_id,
-                "intent": intent.object.model_dump(),
-                "conversation_history": messages[-5:]  # Include recent context
-            }
-        )`} js={`import { z } from 'zod';
-import { generateObject } from 'ai';
-import { anthropic } from '@ai-sdk/anthropic';
-
-const CustomerIntentSchema = z.object({
-  category: z.enum(['faq', 'technical', 'billing', 'urgent']),
-  confidence: z.number().min(0).max(1),
-  summary: z.string()
-});
-
-const handler = async (request, response, context) => {
-  // Track the conversation
-  return context.tracer.startActiveSpan('triage-request', async (span) => {
-    const sessionId = request.metadata.get('session_id');
-    span.setAttribute('session.id', sessionId);
-    
-    // Get conversation history
-    const history = await context.kv.get('conversations', sessionId);
-    const messages = history.exists ? await history.data.json() : [];
-    
-    // Analyze customer intent
-    const customerMessage = await request.data.text();
-    messages.push({ role: 'user', content: customerMessage });
-    
-    const intent = await generateObject({
-      model: anthropic('claude-3-7-sonnet'),
-      schema: CustomerIntentSchema,
-      prompt: \`
-        Analyze this customer support request:
-        Message: \${customerMessage}
-        History: \${JSON.stringify(messages.slice(-5))}
-        
-        Categorize as: faq, technical, billing, or urgent
-      \`
-    });
-    
-    span.setAttribute('intent.category', intent.object.category);
-    span.setAttribute('intent.confidence', intent.object.confidence);
-    
-    // Route to appropriate agent
-    if (intent.object.confidence < 0.7 || intent.object.category === 'urgent') {
-      // Low confidence or urgent = human escalation
-      span.addEvent('escalating-to-human');
-      span.end();
-      return response.json({
-        action: 'escalate',
-        message: 'Connecting you with a human agent...',
-        reason: intent.object.summary
-      });
-    }
-    
-    // Hand off to specialist agent
-    span.end();
-    return response.handoff(
-      { name: intent.object.category + '-agent' },
-      {
-        data: customerMessage,
-        contentType: 'text/plain',
-        metadata: {
-          session_id: sessionId,
-          intent: intent.object,
-          conversation_history: messages.slice(-5)  // Include recent context
-        }
-      }
-    );
-  });
-};`} />
-
-### Phase 2: Specialist Agents
-
-Create specialized agents for each category:
-
-#### FAQ Agent
-- Answers common questions
-- Uses vector search for knowledge base
-- Tracks which questions are most frequent
-
-#### Technical Support Agent
-- Troubleshoots technical issues
-- Guides through diagnostic steps
-- Creates tickets for engineering
-
-#### Billing Agent
-- Handles payment questions
-- Looks up account information (mock)
-- Processes refund requests
-
-### Phase 3: Memory & Learning
-
-Implement sophisticated memory:
-
-```python
-# Store interaction outcomes
-await context.kv.set(
-    "outcomes",
-    f"{session_id}_{timestamp}",
-    {
-        "category": intent.category,
-        "resolved": was_resolved,
-        "escalated": was_escalated,
-        "satisfaction": customer_rating,
-        "agent_actions": actions_taken
-    },
-    {"ttl": 30 * 24 * 3600}  # Keep for 30 days
-)
-
-# Learn from patterns
-outcomes = await context.kv.list("outcomes", prefix=f"{user_id}_")
-if frequent_escalations(outcomes):
-    # Adjust confidence thresholds
-    # Flag for human review
-    pass
-```
-
-### Phase 4: Production Hardening
-
-Add all production features:
-
-#### Guardrails
-- PII detection and redaction
-- Compliance with support policies
-- Rate limiting per customer
-- Response length limits
-
-#### Observability
-- Custom spans for each decision point
-- Track resolution rates
-- Monitor escalation patterns
-- Cost per interaction
-
-#### Testing Suite
-```python
-# test_support_system.py
-test_cases = [
-    {
-        "input": "How do I reset my password?",
-        "expected_category": "faq",
-        "should_escalate": False
-    },
-    {
-        "input": "The app crashes when I click submit",
-        "expected_category": "technical",
-        "should_escalate": False
-    },
-    {
-        "input": "I was charged twice!!!",
-        "expected_category": "billing",
-        "confidence_threshold": 0.9  # Higher for financial
-    },
-    {
-        "input": "This is unacceptable! I demand a manager!",
-        "expected_category": "urgent",
-        "should_escalate": True
-    }
-]
-```
-
-### Phase 5: Deployment
-
-Deploy your complete system:
-
-```bash
-# Test locally
-agentuity dev
-
-# Run test suite
-npm test
+### Skills Progression
 
-# Deploy to production
-agentuity deploy
-
-# Monitor performance
-agentuity logs --follow
-```
+This sophisticated system builds on concepts from every previous module:
 
-## Alternative Capstone Projects
+| Module | Skills Applied in Deep Research |
+|--------|--------------------------------|
+| **Module 1** | Request handling, error management → Complex orchestration |
+| **Module 2** | Trigger behaviors → Agent coordination patterns |
+| **Module 3** | Memory management → Research state accumulation |
+| **Module 4** | Multi-agent basics → Advanced orchestration |
+| **Module 5** | Validation → Research quality assurance |
+| **Module 6** | Deployment → Production research system |
 
-Not interested in customer support? Choose an alternative:
+### Key Implementation: Research Orchestration
 
-### Option 2: Deep Research System
+The orchestrator coordinates the entire research workflow:
 
-Build a comprehensive research and analysis system:
-- **Research Coordinator**: Routes queries to appropriate researchers
-- **Web Research Agent**: Searches and gathers online sources
-- **Academic Research Agent**: Finds scholarly articles and papers
-- **Analysis Agent**: Synthesizes information across sources
-- **Report Generator**: Creates structured research reports
-- **Fact Verification Agent**: Cross-checks claims and citations
+<CodeExample py={`# Python - Research orchestration with structured planning
+research_plan = await generate_research_plan(query)
 
-Key challenges:
-- Multi-source information synthesis
-- Citation accuracy and tracking
-- Handling conflicting or outdated information
-- Maintaining research quality standards
-- Long-form document generation
+# Coordinate multi-step research workflow
+researcher = await context.get_agent(name="deep-researcher")
+research_result = await researcher.run({
+    "query": query,
+    "plan": research_plan,
+    "max_depth": 3
+})
 
-### Option 3: Financial Analysis System
-
-Build a financial research and advisory system:
-- **Market Research Agent**: Gathers financial data and news
-- **Risk Assessment Agent**: Analyzes investment risks
-- **Portfolio Advisor**: Provides investment recommendations
-- **Compliance Agent**: Ensures regulatory adherence
-- **Report Generator**: Creates financial summaries
+return await research_result.data.json()`} js={`// TypeScript - Research orchestration with structured planning
+const researchPlan = await generateObject({
+  model: anthropic('claude-3-5-sonnet-20241022'),
+  schema: ResearchPlanSchema,
+  prompt: \`Create a research plan for: "\${query}"\`
+});
 
-Key challenges:
-- Real-time financial data processing
-- Risk calculation and modeling
-- Regulatory compliance requirements
-- Investment strategy optimization
-- Market sentiment analysis
+// Coordinate multi-step research workflow
+const researcher = await ctx.getAgent({ name: 'deep-researcher' });
+const researchResult = await researcher.run({
+  data: JSON.stringify({
+    query,
+    plan: researchPlan.object,
+    maxDepth: 3
+  }),
+  contentType: 'application/json'
+});`} />
+
+### Key Implementation: Recursive Research Pattern
+
+The researcher agent conducts deep, iterative research:
+
+<CodeExample py={`# Python - Recursive research with learning accumulation
+async def conduct_research(query: str, accumulated_knowledge: list, depth: int, context: AgentContext):
+    if depth >= MAX_DEPTH or sufficient_information(accumulated_knowledge):
+        return accumulated_knowledge
+
+    # Conduct research iteration
+    new_findings = await search_and_analyze(query, context)
+    accumulated_knowledge.extend(new_findings)
+
+    # Generate follow-up questions based on findings
+    follow_up_queries = await generate_follow_ups(accumulated_knowledge)
+
+    # Recursive calls for deeper research
+    for follow_up in follow_up_queries:
+        deeper_knowledge = await conduct_research(
+            follow_up, accumulated_knowledge, depth + 1, context
+        )
+        accumulated_knowledge.extend(deeper_knowledge)
+
+    return accumulated_knowledge`} js={`// TypeScript - Recursive research with learning accumulation
+const conductResearch = async (
+  query: string,
+  accumulatedKnowledge: ResearchFinding[],
+  depth: number,
+  context: AgentContext
+) => {
+  if (depth >= MAX_DEPTH || sufficientInformation(accumulatedKnowledge)) {
+    return accumulatedKnowledge;
+  }
+
+  // Conduct research iteration
+  const newFindings = await searchAndAnalyze(query, context);
+  accumulatedKnowledge.push(...newFindings);
+
+  // Generate follow-up questions based on findings
+  const followUpQueries = await generateFollowUps(accumulatedKnowledge);
+
+  // Recursive calls for deeper research
+  for (const followUp of followUpQueries) {
+    const deeperKnowledge = await conductResearch(
+      followUp, accumulatedKnowledge, depth + 1, context
+    );
+    accumulatedKnowledge.push(...deeperKnowledge);
+  }
 
-### Option 4: Content Creation Pipeline
+  return accumulatedKnowledge;
+};`} />
 
-Build a multi-agent content production system:
-- **Content Planner**: Develops content strategies and schedules
-- **Research Agent**: Gathers information and sources
-- **Writer Agent**: Creates draft content
-- **Editor Agent**: Reviews and improves content quality
-- **SEO Optimizer**: Optimizes for search and engagement
-- **Publisher Agent**: Handles final formatting and distribution
+### Key Implementation: Smart Caching Strategies
+
+Different caching approaches based on research depth and complexity:
+
+<CodeExample py={`# Python - Smart caching strategies for research data
+# Different TTL strategies based on research type
+if research_type == 'comprehensive':
+    # Complex research - longer cache (1 hour)
+    await context.kv.set('research', cache_key, results, {'ttl': 3600})
+else:
+    # Quick research - shorter cache (15 minutes) for responsiveness
+    await context.kv.set('research', cache_key, results, {'ttl': 900})`} js={`// TypeScript - Smart caching strategies for research data
+// Different TTL strategies based on research type
+if (researchType === 'comprehensive') {
+  // Complex research - longer cache (1 hour)
+  await context.kv.set('research', cacheKey, results, { ttl: 3600 });
+} else {
+  // Quick research - shorter cache (15 minutes) for responsiveness
+  await context.kv.set('research', cacheKey, results, { ttl: 900 });
+}`} />
+
+### Build This Project Yourself
+
+Ready to implement this project? Follow our complete examples:
+
+<div className="flex flex-wrap gap-3 mb-6">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/07-deep-research-ts" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    TypeScript
+  </a>
+  <div className="inline-flex items-center gap-2 px-4 py-3 bg-gray-400 text-white rounded-lg no-underline text-sm font-medium cursor-not-allowed opacity-75">
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    Python (Coming Soon)
+  </div>
+</div>
+
+### What This System Demonstrates
+
+- **Advanced multi-agent orchestration**: Coordinated workflow between specialized research agents
+- **Recursive algorithms**: Self-improving research with learning accumulation across iterations
+- **External API integration**: Real-world web search with intelligent filtering and relevance evaluation
+- **State accumulation**: Complex memory management and knowledge aggregation
+- **Production patterns**: Error handling, rate limiting, comprehensive observability
+
+The complete examples show how to build sophisticated research systems that demonstrate mastery of advanced agent concepts.
+
+## Testing Your Deep Research System
+
+1. **Start DevMode:**
+```bash
+agentuity dev
+```
 
-Key challenges:
-- Content quality consistency
-- Brand voice maintenance
-- Multi-format content adaptation
-- Publishing workflow coordination
-- Performance analytics integration
+2. **Test research requests:**
+   - **Simple topics**: "Benefits of renewable energy"
+   - **Complex topics**: "Impact of quantum computing on cryptography"
+   - **Technical subjects**: "Latest developments in machine learning architectures"
 
+3. **Monitor the orchestration:**
+   - Watch logs to see agent coordination and recursive research calls
+   - Observe how research accumulates across multiple iterations
+   - See report generation synthesis from accumulated findings
+## Key Takeaways
 
-## Congratulations!
+By building this deep research system, you've mastered:
 
-By completing this capstone, you've demonstrated mastery of:
-- Agent architecture and design
-- Memory and state management
-- Multi-agent orchestration
-- Production deployment
-- Real-world problem solving
+- **Multi-agent orchestration**: Coordinating specialized agents for complex workflows
+- **Recursive algorithms**: Self-improving systems with learning accumulation
+- **Production integration**: Real-world APIs with intelligent filtering and caching
+- **Advanced memory management**: State accumulation across multiple agent interactions
+- **Sophisticated observability**: Comprehensive tracking of complex agent workflows
 
-You're now ready to build production agent systems with Agentuity!
+You're now ready to build advanced production agent systems with Agentuity!
 
 ## What's Next?
 
-- Deploy your capstone to production
-- Share your implementation with the community
-- Explore advanced patterns
-- Build agents for your own use cases
-- Contribute to the Agentuity ecosystem
+- Deploy your research system to production
+- Experiment with different research domains
+- Build agents for your own complex use cases
+- Share your implementations with the community
 
-Welcome to the future of agent development! 🚀
+Welcome to advanced agent development! 🚀
 
 ---
-
-**Ready to dive deeper?** Check the [documentation](https://docs.agentuity.com) for advanced patterns and deployment guides.
\ No newline at end of file
diff --git a/content/Training/developers/index.mdx b/content/Training/developers/index.mdx
index 12e34cc6..c8e6bd6a 100644
--- a/content/Training/developers/index.mdx
+++ b/content/Training/developers/index.mdx
@@ -15,7 +15,7 @@ By the end of this course, you'll have deployed:
 - Production agents with persistent memory (stateful, long-running)
 - Multi-agent workflows with seamless agent-to-agent communication
 - Framework-agnostic agents (LangChain, CrewAI, or custom)
-- Fully observable systems with OpenTelemetry tracing
+- Fully observable systems with [OpenTelemetry](https://opentelemetry.io/) tracing
 - Complete dev → staging → production deployment pipelines
 
 ## Time Investment
@@ -33,16 +33,18 @@ By the end of this course, you'll have deployed:
 ## Choose Your Path
 
 ### New to AI Agents?
-Start with [Module 1: Introduction to Agents](./01-introduction-to-agents) to understand how agents differ from traditional software and why they need specialized infrastructure.
+Start with [Module 1: Introduction to Agents](./developers/01-introduction-to-agents) to understand how agents differ from traditional software and why they need specialized infrastructure.
 
 ### Built Agents Before?  
-Jump to [Module 3: Agent Memory](./03-agent-memory) to see how Agentuity handles state differently, or [Module 4: Agent-to-Agent Collaboration](./04-agent-collaboration) for orchestration patterns.
+Jump to [Module 3: Agent Memory](./developers/03-agent-memory) to see how Agentuity handles state differently, or [Module 4: Agent-to-Agent Collaboration](./developers/04-agent-collaboration) for orchestration patterns.
 
 ### Need Production Deployment?
-Go straight to [Module 6: Deployment Environments](./06-deployment-environments) to understand Agentuity's dev/staging/prod environments and scaling approach.
+Go straight to [Module 6: Deployment Environments](./developers/06-deployment-environments) to understand Agentuity's dev/staging/prod environments and scaling approach.
 
 ### Migrating from Another Platform?
-Check our Framework Migration Guide for specifics on moving from AWS Bedrock, Google ADK, or Azure AI.
+<Callout type="info">
+Framework Migration Guide coming soon for developers moving from AWS Bedrock, Google ADK, or Azure AI.
+</Callout>
 
 ## What Makes This Different
 
@@ -52,4 +54,14 @@ Unlike generic AI courses, this curriculum:
 - Uses actual industry examples (both successes and cautionary tales)
 - Teaches **platform-agnostic concepts** alongside Agentuity-specific implementation
 
-Ready to dive into the world of AI agents? Let's get started with [Module 1: Introduction to Agents](./01-introduction-to-agents).
\ No newline at end of file
+Ready to dive into the world of AI agents? Let's get started with [Module 1: Introduction to Agents](./developers/01-introduction-to-agents).
+
+## All Modules
+
+- [Module 1: Introduction to Agents](./developers/01-introduction-to-agents)
+- [Module 2: Anatomy of an Agent](./developers/02-anatomy-of-an-agent)
+- [Module 3: Agent Memory](./developers/03-agent-memory)
+- [Module 4: Agent Collaboration](./developers/04-agent-collaboration)
+- [Module 5: Observability, Guardrails, & Evals](./developers/05-observability-guardrails-evals)
+- [Module 6: Deployment Environments](./developers/06-deployment-environments)
+- [Module 7: Sandbox Capstone](./developers/07-sandbox-capstone)
diff --git a/content/Training/index.mdx b/content/Training/index.mdx
index fcbdf7ba..207ae796 100644
--- a/content/Training/index.mdx
+++ b/content/Training/index.mdx
@@ -12,10 +12,10 @@ Comprehensive hands-on course covering agent fundamentals through production dep
 - ~20 hours of content
 - Hands-on labs and capstone project
 
-[Start Developer Training →](./developers)
+[Start Developer Training →](Training/developers)
 
 ## Coming Soon
 
 **For Executives** - Strategic overview of the agent economy
 
-**For Tech Leads** - Architecture patterns and integration strategies
\ No newline at end of file
+**For Tech Leads** - Architecture patterns and integration strategies

From 7500edae430fe5f47cb874a628825abe3de3ebaa Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Wed, 24 Sep 2025 13:49:38 -0700
Subject: [PATCH 05/13] Tweaks

---
 .../developers/02-anatomy-of-an-agent.mdx       | 11 +++++++++++
 .../05-observability-guardrails-evals.mdx       | 17 +++++++++++++++--
 .../developers/06-deployment-environments.mdx   | 12 ++++++------
 .../Training/developers/07-sandbox-capstone.mdx |  2 +-
 4 files changed, 33 insertions(+), 9 deletions(-)

diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index 49d35b3c..c3a79084 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -731,6 +731,11 @@ async def handle_manual_trigger(request: AgentRequest, response: AgentResponse,
         context.logger.info(f"Returning cached weather for {location_query}")
         return response.json(cached_weather)
 
+    # Resolve location to coordinates (geocoding step)
+    coordinates = await geocode_location(location_query)
+    if not coordinates:
+        return response.json({"error": "Unable to find location coordinates"})
+
     # Fetch fresh data and cache with shorter TTL
     weather = await fetch_nws_weather(coordinates["lat"], coordinates["lon"], location_query, context)
     await context.kv.set("weather", cache_key, weather, {"ttl": 300})  # 5 minutes
@@ -756,6 +761,12 @@ async function handleManualTrigger(request: AgentRequest, response: AgentRespons
     return response.json(cachedWeather);
   }
 
+  // Resolve location to coordinates (geocoding step)
+  const coordinates = await geocodeLocation(locationQuery);
+  if (!coordinates) {
+    return response.json({ error: 'Unable to find location coordinates' });
+  }
+
   // Fetch fresh data and cache with shorter TTL
   const weather = await fetchNWSWeather(coordinates.lat, coordinates.lon, locationQuery, context);
   await context.kv.set('weather', cacheKey, weather, { ttl: 300 }); // 5 minutes
diff --git a/content/Training/developers/05-observability-guardrails-evals.mdx b/content/Training/developers/05-observability-guardrails-evals.mdx
index c07e7408..db1348cc 100644
--- a/content/Training/developers/05-observability-guardrails-evals.mdx
+++ b/content/Training/developers/05-observability-guardrails-evals.mdx
@@ -63,6 +63,10 @@ View in the Agentuity console Sessions tab with color-coded timeline visualizati
 ### Using the Logger
 
 <CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Extract data from request
+    data = await request.data.json()
+    user_id = request.metadata.get("user_id")
+
     # Logs appear in Sessions view with trace context
     context.logger.info("Processing", {"user_id": user_id})
 
@@ -72,6 +76,10 @@ View in the Agentuity console Sessions tab with color-coded timeline visualizati
     except Exception as e:
         context.logger.error("Failed", {"error": str(e)})
         raise`} js={`const handler = async (request, response, context) => {
+  // Extract data from request
+  const data = await request.data.json();
+  const userId = request.metadata.get('user_id');
+
   // Logs appear in Sessions view with trace context
   context.logger.info('Processing', { userId });
 
@@ -91,6 +99,9 @@ Track important operations with custom spans to understand performance and debug
 <CodeExample py={`from opentelemetry.trace import Status, StatusCode
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    payload = await request.data.json()
+    query = payload.get("query", "")
+
     # Create a span for the entire validation flow
     async with context.tracer.start_as_current_span("validate-financial-query") as span:
         # Add context about this operation
@@ -124,6 +135,8 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
             raise`} js={`import { SpanStatusCode } from '@opentelemetry/api';
 
 const handler = async (request, response, context) => {
+  const { query = '' } = await request.data.json();
+
   // Create a span for the entire validation flow
   return context.tracer.startActiveSpan('validate-financial-query', async (span) => {
     // Add context about this operation
@@ -258,10 +271,10 @@ async def evaluate_with_jury(query: str, context) -> ContentEvaluation:
     '''
 
     # Use structured generation with Python anthropic SDK
-    from anthropic import Anthropic
+    from anthropic import AsyncAnthropic
     import json
 
-    client = Anthropic()
+    client = AsyncAnthropic()
     response = await client.messages.create(
         model="claude-3-haiku-20240307",
         max_tokens=1000,
diff --git a/content/Training/developers/06-deployment-environments.mdx b/content/Training/developers/06-deployment-environments.mdx
index c314763c..cc6ca52c 100644
--- a/content/Training/developers/06-deployment-environments.mdx
+++ b/content/Training/developers/06-deployment-environments.mdx
@@ -29,8 +29,8 @@ agentuity dev
 ### Staging Environment
 **Where agents prove themselves**
 
-<Callout type="info">
-**Coming Soon**: Dedicated staging environments with production-like infrastructure but isolated from real users.
+<Callout type="success">
+**Now Available**: Staging environments are here! Test your agents with production-like infrastructure before going live.
 </Callout>
 
 Cloud deployment with test data:
@@ -38,10 +38,6 @@ Cloud deployment with test data:
 - Options for different deployment configurations
 - Ability to use different keys and environment variables
 
-<Callout type="info">
-Staging environment deployment is coming soon. For now, you can test locally with DevMode and deploy directly to production.
-</Callout>
-
 ### Production Environment
 **Where agents live**
 
@@ -58,6 +54,10 @@ agentuity deploy
 
 **Testing changes in the cloud before production**
 
+<Callout type="success">
+**Preview deployments are here!** Automatically test your PR changes in the cloud before merging.
+</Callout>
+
 Preview deployments allow you to test agent modifications in a cloud environment automatically when you create pull requests, giving you confidence before merging to production.
 
 ### How Preview Deployments Work
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index d779acbc..c05d39b7 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -120,7 +120,7 @@ const researchPlan = await generateObject({
 });
 
 // Coordinate multi-step research workflow
-const researcher = await ctx.getAgent({ name: 'deep-researcher' });
+const researcher = await context.getAgent({ name: 'deep-researcher' });
 const researchResult = await researcher.run({
   data: JSON.stringify({
     query,

From 4a8cf871aa1a28bc300eb5e27c2eff5b06426925 Mon Sep 17 00:00:00 2001
From: afterrburn <sun_rsh@outlook.com>
Date: Wed, 1 Oct 2025 07:24:09 -0600
Subject: [PATCH 06/13] updating tutorial api reader

---
 app/api/tutorials/[id]/route.ts               | 10 ++-
 .../[id]/steps/[stepNumber]/route.ts          | 21 ++++---
 app/api/tutorials/route.ts                    | 43 +++++--------
 content/tutorials.json                        | 61 +++++++++++++++++++
 lib/tutorial/index.ts                         | 40 ++++++++++++
 lib/tutorial/schemas.ts                       |  2 +-
 6 files changed, 139 insertions(+), 38 deletions(-)
 create mode 100644 content/tutorials.json

diff --git a/app/api/tutorials/[id]/route.ts b/app/api/tutorials/[id]/route.ts
index 434fa476..9b4245cd 100644
--- a/app/api/tutorials/[id]/route.ts
+++ b/app/api/tutorials/[id]/route.ts
@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { join } from 'path';
 import { parseTutorialMDXCached } from '@/lib/tutorial/mdx-parser';
 import { TutorialIdParamsSchema } from '@/lib/tutorial/schemas';
+import { getTutorialFilePath } from '@/lib/tutorial';
 
 interface RouteParams {
   params: Promise<{ id: string }>;
@@ -21,7 +21,13 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
     }
     
     const { id } = validationResult.data;
-    const filePath = join(process.cwd(), 'content', 'Tutorial', `${id}.mdx`);
+    const filePath = await getTutorialFilePath(id);
+    if (!filePath) {
+      return NextResponse.json(
+        { success: false, error: 'Tutorial not found' },
+        { status: 404 }
+      );
+    }
     
     const parsed = await parseTutorialMDXCached(filePath);
     
diff --git a/app/api/tutorials/[id]/steps/[stepNumber]/route.ts b/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
index d881bf75..53979777 100644
--- a/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
+++ b/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
@@ -1,7 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
-import { join } from 'path';
 import { parseTutorialMDXCached } from '@/lib/tutorial/mdx-parser';
 import { StepParamsSchema } from '@/lib/tutorial/schemas';
+import { getTutorialFilePath } from '@/lib/tutorial';
 
 interface RouteParams {
   params: Promise<{ id: string; stepNumber: string }>;
@@ -10,8 +10,7 @@ interface RouteParams {
 export async function GET(request: NextRequest, { params }: RouteParams) {
   try {
     const rawParams = await params;
-    
-    // Validate and transform parameters with Zod
+
     const validationResult = StepParamsSchema.safeParse(rawParams);
     if (!validationResult.success) {
       return NextResponse.json(
@@ -19,12 +18,18 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
         { status: 400 }
       );
     }
-    
+
     const { id, stepNumber: stepNum } = validationResult.data;
-    
-    const filePath = join(process.cwd(), 'content', 'Tutorial', `${id}.mdx`);
+
+    const filePath = await getTutorialFilePath(id);
+    if (!filePath) {
+      return NextResponse.json(
+        { success: false, error: 'Tutorial not found' },
+        { status: 404 }
+      );
+    }
     const parsed = await parseTutorialMDXCached(filePath);
-    
+
     const step = parsed.steps.find(s => s.stepNumber === stepNum);
     if (!step) {
       return NextResponse.json(
@@ -32,7 +37,7 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
         { status: 404 }
       );
     }
-    
+
     return NextResponse.json({
       success: true,
       data: {
diff --git a/app/api/tutorials/route.ts b/app/api/tutorials/route.ts
index 934f0891..15c7a2a5 100644
--- a/app/api/tutorials/route.ts
+++ b/app/api/tutorials/route.ts
@@ -1,57 +1,46 @@
 import { NextResponse } from 'next/server';
-import { readdir } from 'fs/promises';
 import { join } from 'path';
 import { parseTutorialMDXCached } from '@/lib/tutorial/mdx-parser';
 import { TutorialListItemSchema, type TutorialListItem } from '@/lib/tutorial/schemas';
+import { getTutorialsConfig } from '@/lib/tutorial';
 
 export async function GET() {
   try {
-    const tutorialsDir = join(process.cwd(), 'content', 'Tutorial');
-    
-    // Check if Tutorial directory exists, if not create it for future use
-    let entries: string[];
-    try {
-      entries = await readdir(tutorialsDir);
-    } catch (error) {
-      // Return empty array if Tutorial directory doesn't exist yet
-      return NextResponse.json([]);
-    }
-    
-    const mdxFiles = entries.filter(file => file.endsWith('.mdx'));
-    
+    const config = await getTutorialsConfig();
+
     const tutorials = await Promise.all(
-      mdxFiles.map(async (file): Promise<TutorialListItem | null> => {
+      config.tutorials.map(async (tutorialMeta): Promise<TutorialListItem | null> => {
         try {
-          const filePath = join(tutorialsDir, file);
+          const filePath = join(process.cwd(), 'content', tutorialMeta.path);
           const parsed = await parseTutorialMDXCached(filePath);
-          
+
           const tutorialItem = {
-            id: file.replace('.mdx', ''),
-            title: parsed.metadata.title,
-            description: parsed.metadata.description,
-            totalSteps: parsed.metadata.totalSteps,
-            difficulty: parsed.metadata.difficulty,
-            estimatedTime: parsed.metadata.estimatedTime,
+            id: tutorialMeta.id,
+            title: tutorialMeta.title,
+            description: tutorialMeta.description,
+            totalSteps: parsed.metadata.totalSteps || parsed.steps.length,
+            difficulty: tutorialMeta.difficulty,
+            estimatedTime: tutorialMeta.estimatedTime,
           };
 
           // Validate the tutorial list item
           const validationResult = TutorialListItemSchema.safeParse(tutorialItem);
           if (!validationResult.success) {
-            console.warn(`Invalid tutorial item ${file}:`, validationResult.error.message);
+            console.warn(`Invalid tutorial item ${tutorialMeta.id}:`, validationResult.error.message);
             return null;
           }
 
           return validationResult.data;
         } catch (error) {
-          console.warn(`Failed to parse tutorial ${file}:`, error);
+          console.warn(`Failed to parse tutorial ${tutorialMeta.id} at ${tutorialMeta.path}:`, error);
           return null;
         }
       })
     );
-    
+
     // Filter out failed tutorials
     const validTutorials = tutorials.filter(tutorial => tutorial !== null);
-    
+
     return NextResponse.json(validTutorials);
   } catch (error) {
     console.error('Failed to load tutorials:', error);
diff --git a/content/tutorials.json b/content/tutorials.json
new file mode 100644
index 00000000..ae2db185
--- /dev/null
+++ b/content/tutorials.json
@@ -0,0 +1,61 @@
+{
+    "_comment": "This file defines all available tutorials for the tutorial API endpoints. The tutorial API (/api/tutorials) reads from this file to determine which MDX files to process as tutorials, ensuring only intentionally marked files are included. Each tutorial entry must have a corresponding MDX file at the specified path.",
+    "tutorials": [
+        {
+            "id": "01-introduction-to-agents",
+            "title": "Module 1: Introduction to Agents",
+            "description": "Understanding AI agents and the $47B opportunity",
+            "path": "Training/developers/01-introduction-to-agents.mdx",
+            "difficulty": "beginner",
+            "estimatedTime": "15 minutes"
+        },
+        {
+            "id": "02-anatomy-of-an-agent",
+            "title": "Module 2: The Anatomy of an Agent",
+            "description": "Understanding how agents work - planning, reasoning, tools, and memory",
+            "path": "Training/developers/02-anatomy-of-an-agent.mdx",
+            "difficulty": "beginner",
+            "estimatedTime": "20 minutes"
+        },
+    {
+      "id": "03-agent-memory",
+      "title": "Module 3: Agent Memory", 
+      "description": "How agents remember, learn, and build context over time",
+      "path": "Training/developers/03-agent-memory.mdx",
+      "difficulty": "beginner",
+      "estimatedTime": "55 minutes"
+    },
+        {
+            "id": "04-agent-collaboration",
+            "title": "Module 4: Agent-to-Agent Collaboration",
+            "description": "Building multi-agent systems that work together",
+            "path": "Training/developers/04-agent-collaboration.mdx",
+            "difficulty": "intermediate",
+            "estimatedTime": "30 minutes"
+        },
+        {
+            "id": "05-observability-guardrails-evals",
+            "title": "Module 5: Observability, Guardrails, & Evals",
+            "description": "Making agents reliable, safe, and production-ready",
+            "path": "Training/developers/05-observability-guardrails-evals.mdx",
+            "difficulty": "intermediate",
+            "estimatedTime": "25 minutes"
+        },
+        {
+            "id": "06-deployment-environments",
+            "title": "Module 6: Deployment Environments",
+            "description": "From local development to global production",
+            "path": "Training/developers/06-deployment-environments.mdx",
+            "difficulty": "intermediate",
+            "estimatedTime": "20 minutes"
+        },
+        {
+            "id": "07-sandbox-capstone",
+            "title": "Module 7: Advanced Multi-Agent Research System",
+            "description": "Building sophisticated agent coordination with recursive research",
+            "path": "Training/developers/07-sandbox-capstone.mdx",
+            "difficulty": "advanced",
+            "estimatedTime": "45 minutes"
+        }
+    ]
+}
\ No newline at end of file
diff --git a/lib/tutorial/index.ts b/lib/tutorial/index.ts
index ff0ffffd..bc3ff7f9 100644
--- a/lib/tutorial/index.ts
+++ b/lib/tutorial/index.ts
@@ -1,3 +1,43 @@
 // Tutorial state management exports
 export * from './types';
 export * from './state-manager';
+
+// Tutorial configuration utilities
+import { join } from 'path';
+import { readFile } from 'fs/promises';
+
+interface TutorialMeta {
+  id: string;
+  title: string;
+  description: string;
+  path: string;
+  difficulty?: string;
+  estimatedTime?: string;
+}
+
+interface TutorialsConfig {
+  tutorials: TutorialMeta[];
+}
+
+/**
+ * Reads the tutorials.json configuration file
+ */
+export async function getTutorialsConfig(): Promise<TutorialsConfig> {
+  const configPath = join(process.cwd(), 'content', 'tutorials.json');
+  const configContent = await readFile(configPath, 'utf-8');
+  return JSON.parse(configContent);
+}
+
+/**
+ * Gets the full file path for a specific tutorial based on tutorials.json
+ */
+export async function getTutorialFilePath(tutorialId: string): Promise<string | null> {
+  const config = await getTutorialsConfig();
+  const tutorial = config.tutorials.find(t => t.id === tutorialId);
+  
+  if (!tutorial) {
+    return null;
+  }
+  
+  return join(process.cwd(), 'content', tutorial.path);
+}
diff --git a/lib/tutorial/schemas.ts b/lib/tutorial/schemas.ts
index 6f64921b..30716f2e 100644
--- a/lib/tutorial/schemas.ts
+++ b/lib/tutorial/schemas.ts
@@ -4,7 +4,7 @@ import { z } from 'zod';
 export const TutorialMetadataSchema = z.object({
   title: z.string().min(1, 'Title is required'),
   description: z.string().min(1, 'Description is required'),
-  totalSteps: z.number().positive('Total steps must be a positive number'),
+  totalSteps: z.number().positive('Total steps must be a positive number').optional(),
   difficulty: z.enum(['beginner', 'intermediate', 'advanced']).optional(),
   estimatedTime: z.string().optional()
 });

From cf514cbecf5306ef32b964aa23e552a93ea84807 Mon Sep 17 00:00:00 2001
From: afterrburn <sun_rsh@outlook.com>
Date: Wed, 1 Oct 2025 07:24:33 -0600
Subject: [PATCH 07/13] add .env.example to agent-docs

---
 agent-docs/.env.example | 4 ++++
 1 file changed, 4 insertions(+)
 create mode 100644 agent-docs/.env.example

diff --git a/agent-docs/.env.example b/agent-docs/.env.example
new file mode 100644
index 00000000..a8b9bfbb
--- /dev/null
+++ b/agent-docs/.env.example
@@ -0,0 +1,4 @@
+TUTORIAL_API_URL=http://localhost:3201
+VECTOR_STORE_NAME=docs
+# Run `agentuity auth` -- this will be populated in .env 
+AGENTUITY_SDK_KEY=
\ No newline at end of file

From 480fee898caf1a92b316d8d4d2bcf08b2a37ebd9 Mon Sep 17 00:00:00 2001
From: afterrburn <sun_rsh@outlook.com>
Date: Sat, 4 Oct 2025 15:05:28 -0600
Subject: [PATCH 08/13] safe-guarding file reading

---
 app/api/page-content/route.ts |  12 ++-
 app/api/tutorials/route.ts    |   9 +-
 components/CodeFromFiles.tsx  |  25 ++---
 lib/tutorial/index.ts         |  18 +++-
 lib/tutorial/mdx-parser.ts    |  22 ++---
 lib/utils/secure-path.ts      | 168 ++++++++++++++++++++++++++++++++++
 lib/validation/middleware.ts  |   6 +-
 7 files changed, 216 insertions(+), 44 deletions(-)
 create mode 100644 lib/utils/secure-path.ts

diff --git a/app/api/page-content/route.ts b/app/api/page-content/route.ts
index c91c3939..4187afa7 100644
--- a/app/api/page-content/route.ts
+++ b/app/api/page-content/route.ts
@@ -1,5 +1,6 @@
 import type { NextRequest } from 'next/server';
 import docsJson from '@/content/docs.json';
+import { validatePathString } from '@/lib/utils/secure-path';
 
 interface Doc {
 	file: string;
@@ -18,8 +19,15 @@ export async function GET(request: NextRequest) {
 			return new Response('Path parameter required', { status: 400 });
 		}
 
-		if (path.includes('..') || path.includes('\\') || path.startsWith('/')) {
-			return new Response('Invalid path parameter', { status: 400 });
+		// Validate path for security issues (but don't require leading slash for this API)
+		const validation = validatePathString(path);
+		if (!validation.valid) {
+			return new Response(`Invalid path parameter: ${validation.error}`, { status: 400 });
+		}
+
+		// Additional check: path shouldn't start with '/' for this specific API
+		if (path.startsWith('/')) {
+			return new Response('Invalid path parameter: path should not start with "/"', { status: 400 });
 		}
 
 		const doc = docs.find(
diff --git a/app/api/tutorials/route.ts b/app/api/tutorials/route.ts
index 15c7a2a5..aac96d44 100644
--- a/app/api/tutorials/route.ts
+++ b/app/api/tutorials/route.ts
@@ -1,8 +1,7 @@
 import { NextResponse } from 'next/server';
-import { join } from 'path';
 import { parseTutorialMDXCached } from '@/lib/tutorial/mdx-parser';
 import { TutorialListItemSchema, type TutorialListItem } from '@/lib/tutorial/schemas';
-import { getTutorialsConfig } from '@/lib/tutorial';
+import { getTutorialsConfig, getTutorialFilePath } from '@/lib/tutorial';
 
 export async function GET() {
   try {
@@ -11,7 +10,11 @@ export async function GET() {
     const tutorials = await Promise.all(
       config.tutorials.map(async (tutorialMeta): Promise<TutorialListItem | null> => {
         try {
-          const filePath = join(process.cwd(), 'content', tutorialMeta.path);
+          const filePath = await getTutorialFilePath(tutorialMeta.id);
+          if (!filePath) {
+            console.warn(`Tutorial file not found for ${tutorialMeta.id}`);
+            return null;
+          }
           const parsed = await parseTutorialMDXCached(filePath);
 
           const tutorialItem = {
diff --git a/components/CodeFromFiles.tsx b/components/CodeFromFiles.tsx
index a3f97467..ead65df5 100644
--- a/components/CodeFromFiles.tsx
+++ b/components/CodeFromFiles.tsx
@@ -1,8 +1,8 @@
 import React from 'react';
-import { readFile } from 'fs/promises';
 import path from 'path';
 import CodeBlock from '@/app/chat/components/CodeBlock';
 import { Tabs, Tab } from 'fumadocs-ui/components/tabs';
+import { readSecureFile } from '@/lib/utils/secure-path';
 
 export interface CodeFromFilesSnippet {
   path: string; // repo-root-relative, e.g. "/examples/poc-tutorial/src/agent.ts"
@@ -41,20 +41,15 @@ export default async function CodeFromFiles(props: CodeFromFilesProps) {
     return null;
   }
 
-  const repoRoot = process.cwd();
-
   const loaded = await Promise.all(
     snippets.map(async (s) => {
-      if (!s.path.startsWith('/')) {
-        throw new Error('CodeFromFiles: each snippet.path must start with "/" (repo-root-relative)');
-      }
-      const absolutePath = path.resolve(repoRoot, `.${s.path}`);
-      if (!absolutePath.startsWith(repoRoot)) {
-        throw new Error('CodeFromFiles: resolved path escapes repository root');
-      }
-      let fileContent = '';
+      let content = '';
       try {
-        fileContent = await readFile(absolutePath, 'utf-8');
+        content = await readSecureFile(s.path, {
+          from: s.from,
+          to: s.to,
+          requireLeadingSlash: true
+        });
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
         return {
@@ -63,14 +58,10 @@ export default async function CodeFromFiles(props: CodeFromFilesProps) {
           content: `// Failed to load ${s.path}: ${message}`,
         };
       }
-      const lines = fileContent.split(/\r?\n/);
-      const startIdx = Math.max(0, (s.from ? s.from - 1 : 0));
-      const endIdx = Math.min(lines.length, s.to ? s.to : lines.length);
-      const sliced = lines.slice(startIdx, endIdx).join('\n');
       return {
         label: s.title || path.basename(s.path) || s.lang || 'code',
         lang: s.lang || inferLanguageFromExtension(s.path) || 'text',
-        content: sliced,
+        content,
       };
     })
   );
diff --git a/lib/tutorial/index.ts b/lib/tutorial/index.ts
index bc3ff7f9..6ca11394 100644
--- a/lib/tutorial/index.ts
+++ b/lib/tutorial/index.ts
@@ -5,6 +5,7 @@ export * from './state-manager';
 // Tutorial configuration utilities
 import { join } from 'path';
 import { readFile } from 'fs/promises';
+import { resolveSecurePath } from '@/lib/utils/secure-path';
 
 interface TutorialMeta {
   id: string;
@@ -29,7 +30,8 @@ export async function getTutorialsConfig(): Promise<TutorialsConfig> {
 }
 
 /**
- * Gets the full file path for a specific tutorial based on tutorials.json
+ * Gets the full file path for a specific tutorial based on tutorials.json.
+ * Validates that the tutorial path doesn't escape the content directory.
  */
 export async function getTutorialFilePath(tutorialId: string): Promise<string | null> {
   const config = await getTutorialsConfig();
@@ -39,5 +41,17 @@ export async function getTutorialFilePath(tutorialId: string): Promise<string |
     return null;
   }
   
-  return join(process.cwd(), 'content', tutorial.path);
+  // Ensure the path is secure and doesn't escape the content directory
+  const contentDir = join(process.cwd(), 'content');
+  const tutorialPath = `/${tutorial.path}`;
+  
+  try {
+    return resolveSecurePath(tutorialPath, {
+      baseDir: contentDir,
+      requireLeadingSlash: true
+    });
+  } catch (error) {
+    console.error(`Security validation failed for tutorial ${tutorialId}:`, error);
+    return null;
+  }
 }
diff --git a/lib/tutorial/mdx-parser.ts b/lib/tutorial/mdx-parser.ts
index 1c378891..2239ff16 100644
--- a/lib/tutorial/mdx-parser.ts
+++ b/lib/tutorial/mdx-parser.ts
@@ -1,12 +1,12 @@
 import matter from 'gray-matter';
 import { readFile, stat } from 'fs/promises';
-import path from 'path';
 import {
   TutorialMetadataSchema,
   ParsedTutorialSchema,
   type TutorialStepData,
   type ParsedTutorial
 } from './schemas';
+import { readSecureFile } from '@/lib/utils/secure-path';
 
 export async function parseTutorialMDX(filePath: string): Promise<ParsedTutorial> {
   const fileContent = await readFile(filePath, 'utf-8');
@@ -218,21 +218,11 @@ function parseSnippetObject(objectString: string): {
 
 async function loadSnippetContent(snippet: { path: string; from?: number; to?: number }): Promise<string> {
   try {
-    const repoRoot = process.cwd();
-    const absolutePath = path.resolve(repoRoot, `.${snippet.path}`);
-
-    // Security check
-    if (!absolutePath.startsWith(repoRoot)) {
-      throw new Error('Path escapes repository root');
-    }
-
-    const fileContent = await readFile(absolutePath, 'utf-8');
-    const lines = fileContent.split(/\r?\n/);
-
-    const startIdx = Math.max(0, (snippet.from ? snippet.from - 1 : 0));
-    const endIdx = Math.min(lines.length, snippet.to ? snippet.to : lines.length);
-
-    return lines.slice(startIdx, endIdx).join('\n');
+    return await readSecureFile(snippet.path, {
+      from: snippet.from,
+      to: snippet.to,
+      requireLeadingSlash: true
+    });
   } catch (error) {
     return `// Failed to load ${snippet.path}: ${error}`;
   }
diff --git a/lib/utils/secure-path.ts b/lib/utils/secure-path.ts
new file mode 100644
index 00000000..eac9cf43
--- /dev/null
+++ b/lib/utils/secure-path.ts
@@ -0,0 +1,168 @@
+import path from 'path';
+import { readFile } from 'fs/promises';
+import { z } from 'zod';
+
+export class PathSecurityError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'PathSecurityError';
+  }
+}
+
+export interface SecurePathOptions {
+  /**
+   * Base directory to resolve paths against (defaults to process.cwd())
+   */
+  baseDir?: string;
+  /**
+   * Whether to require the path to start with '/' (repo-relative)
+   */
+  requireLeadingSlash?: boolean;
+}
+
+export interface ReadSecureFileOptions extends SecurePathOptions {
+  /**
+   * Starting line number (1-indexed, inclusive)
+   */
+  from?: number;
+  /**
+   * Ending line number (1-indexed, inclusive)
+   */
+  to?: number;
+}
+
+/**
+ * Validates a path string for security issues without resolving it.
+ * Checks for path traversal attempts and suspicious characters.
+ */
+export function validatePathString(pathStr: string): { valid: boolean; error?: string } {
+  if (!pathStr || pathStr.trim().length === 0) {
+    return { valid: false, error: 'Path cannot be empty' };
+  }
+
+  // Check for path traversal attempts
+  if (pathStr.includes('..')) {
+    return { valid: false, error: 'Path contains ".." (path traversal attempt)' };
+  }
+
+  // Check for backslashes (Windows-style paths can be problematic)
+  if (pathStr.includes('\\')) {
+    return { valid: false, error: 'Path contains backslashes' };
+  }
+
+  return { valid: true };
+}
+
+/**
+ * Resolves a path safely within a base directory.
+ * Ensures the resolved path doesn't escape the base directory.
+ * 
+ * @param inputPath - The path to resolve (should start with '/' for repo-relative paths)
+ * @param options - Configuration options
+ * @returns Absolute path that's guaranteed to be within the base directory
+ * @throws {PathSecurityError} If the path is invalid or escapes the base directory
+ */
+export function resolveSecurePath(inputPath: string, options: SecurePathOptions = {}): string {
+  const {
+    baseDir = process.cwd(),
+    requireLeadingSlash = true
+  } = options;
+
+  // Validate the path string
+  const validation = validatePathString(inputPath);
+  if (!validation.valid) {
+    throw new PathSecurityError(validation.error!);
+  }
+
+  // Check if path starts with '/' if required
+  if (requireLeadingSlash && !inputPath.startsWith('/')) {
+    throw new PathSecurityError(
+      'Path must start with "/" (repo-relative path expected)'
+    );
+  }
+
+  // Resolve the path
+  // If path starts with '/', treat it as repo-relative by prepending '.'
+  const pathToResolve = inputPath.startsWith('/') ? `.${inputPath}` : inputPath;
+  const absolutePath = path.resolve(baseDir, pathToResolve);
+
+  // Security check: ensure the resolved path is within the base directory
+  if (!absolutePath.startsWith(baseDir)) {
+    throw new PathSecurityError(
+      `Resolved path escapes base directory: ${path.relative(baseDir, absolutePath)}`
+    );
+  }
+
+  return absolutePath;
+}
+
+/**
+ * Reads a file securely with optional line range extraction.
+ * Combines path resolution, security checks, and file reading.
+ * 
+ * @param inputPath - The path to read (should start with '/' for repo-relative paths)
+ * @param options - Configuration options including line range
+ * @returns File content (optionally sliced to specified line range)
+ * @throws {PathSecurityError} If the path is invalid or escapes the base directory
+ * @throws {Error} If the file cannot be read
+ */
+export async function readSecureFile(
+  inputPath: string,
+  options: ReadSecureFileOptions = {}
+): Promise<string> {
+  const { from, to, ...pathOptions } = options;
+
+  // Resolve the path securely
+  const absolutePath = resolveSecurePath(inputPath, pathOptions);
+
+  // Read the file
+  const fileContent = await readFile(absolutePath, 'utf-8');
+
+  // If no line range specified, return full content
+  if (from === undefined && to === undefined) {
+    return fileContent;
+  }
+
+  // Extract line range
+  const lines = fileContent.split(/\r?\n/);
+  const startIdx = Math.max(0, (from ? from - 1 : 0));
+  const endIdx = Math.min(lines.length, to ? to : lines.length);
+
+  return lines.slice(startIdx, endIdx).join('\n');
+}
+
+/**
+ * Zod schema for validating path strings.
+ * Can be used in API route parameter validation.
+ */
+export const SecurePathStringSchema = z.string()
+  .min(1, 'Path cannot be empty')
+  .refine(
+    (p) => !p.includes('..'),
+    'Path contains ".." (path traversal attempt)'
+  )
+  .refine(
+    (p) => !p.includes('\\'),
+    'Path contains backslashes'
+  );
+
+/**
+ * Zod schema for validating repo-relative paths (must start with '/').
+ */
+export const RepoRelativePathSchema = SecurePathStringSchema
+  .refine(
+    (p) => p.startsWith('/'),
+    'Path must start with "/" (repo-relative path expected)'
+  );
+
+/**
+ * Zod schema for validating simple path identifiers (no slashes, no dots).
+ * Useful for validating tutorial IDs, page paths, etc.
+ */
+export const PathIdentifierSchema = z.string()
+  .min(1, 'Identifier cannot be empty')
+  .refine(
+    (id) => !id.includes('..') && !id.includes('/') && !id.includes('\\'),
+    'Identifier contains invalid characters (path traversal attempt)'
+  );
+
diff --git a/lib/validation/middleware.ts b/lib/validation/middleware.ts
index b04e3c7b..36ed8e7d 100644
--- a/lib/validation/middleware.ts
+++ b/lib/validation/middleware.ts
@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { z } from 'zod';
 import { MessageSchema } from '@/app/chat/types';
+import { PathIdentifierSchema } from '@/lib/utils/secure-path';
 
 export interface ValidationError {
   field: string;
@@ -101,10 +102,7 @@ export const StepNumberSchema = z.string().transform((val, ctx) => {
   return stepIndex;
 });
 
-export const TutorialIdSchema = z.string().min(1, 'must be a non-empty string').refine(
-  (id) => !id.includes('..') && !id.includes('/') && !id.includes('\\'),
-  'contains invalid characters (path traversal attempt)'
-);
+export const TutorialIdSchema = PathIdentifierSchema;
 
 export function validateStepNumber(stepNumber: string): ValidationResult<number> {
   const result = StepNumberSchema.safeParse(stepNumber);

From fea3010e18b6db5acbcb7edc190303231bedd49a Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Mon, 13 Oct 2025 11:35:12 -0700
Subject: [PATCH 09/13] Refine docs and update training agent

- Update module content to provide step-by-step guidance
- Add code step files (`examples/training`) for agent to use
- Set training steps to a minimum of 1 (no step 0 state)
- Use `dynamic-codeblock` in docs content and agent output
- Remove modules 6 and 7 from `tutorials.json` (no training steps)
- Update system prompts to use `askDocsAgentTool` more often
---
 .../src/agents/agent-pulse/context/builder.ts |   6 +-
 agent-docs/src/agents/agent-pulse/tools.ts    |  20 +-
 app/chat/components/CodeBlock.tsx             |  47 +-
 app/chat/types.ts                             |   7 +-
 components/CodeFromFiles.tsx                  |   4 +-
 .../developers/01-introduction-to-agents.mdx  | 395 +++----
 .../developers/02-anatomy-of-an-agent.mdx     | 874 +++++----------
 .../Training/developers/03-agent-memory.mdx   | 978 ++++-------------
 .../developers/04-agent-collaboration.mdx     | 991 +++++-------------
 .../05-observability-guardrails-evals.mdx     | 860 +++------------
 .../developers/07-sandbox-capstone.mdx        | 281 +++--
 content/Training/developers/index.mdx         |  11 +-
 content/tutorials.json                        |  16 -
 .../training/01-intro/step1-basic-agent.py    |   9 +
 .../training/01-intro/step1-basic-agent.ts    |  14 +
 .../training/01-intro/step2-with-logging.py   |  14 +
 .../training/01-intro/step2-with-logging.ts   |  19 +
 .../training/01-intro/step3-with-state.py     |  28 +
 .../training/01-intro/step3-with-state.ts     |  34 +
 .../training/01-intro/step4-with-errors.py    |  41 +
 .../training/01-intro/step4-with-errors.ts    |  53 +
 .../step1-understanding-triggers.py           |  29 +
 .../step1-understanding-triggers.ts           |  35 +
 .../training/02-anatomy/step2-request-data.py |  44 +
 .../training/02-anatomy/step2-request-data.ts |  50 +
 .../02-anatomy/step3-structured-logging.py    |  50 +
 .../02-anatomy/step3-structured-logging.ts    |  60 ++
 .../training/02-anatomy/step4-kv-caching.py   |  47 +
 .../training/02-anatomy/step4-kv-caching.ts   |  55 +
 .../02-anatomy/step5-response-formats.py      |  43 +
 .../02-anatomy/step5-response-formats.ts      |  48 +
 .../03-memory/step1-session-memory.py         |  49 +
 .../03-memory/step1-session-memory.ts         |  55 +
 .../03-memory/step2-persistent-preferences.py |  56 +
 .../03-memory/step2-persistent-preferences.ts |  63 ++
 .../training/03-memory/step3-vector-basics.py |  80 ++
 .../training/03-memory/step3-vector-basics.ts |  85 ++
 .../03-memory/step4-vector-filtering.py       |  88 ++
 .../03-memory/step4-vector-filtering.ts       |  92 ++
 .../03-memory/step5-object-storage.py         |  52 +
 .../03-memory/step5-object-storage.ts         |  57 +
 .../step1-basic-handoff.py                    |   8 +
 .../step1-basic-handoff.ts                    |  13 +
 .../step2-data-formats.py                     |  29 +
 .../step2-data-formats.ts                     |  34 +
 .../step3-run-and-wait.py                     |  26 +
 .../step3-run-and-wait.ts                     |  33 +
 .../step4-parallel-execution.py               |  33 +
 .../step4-parallel-execution.ts               |  36 +
 .../step5-structured-responses.py             |  68 ++
 .../step5-structured-responses.ts             |  54 +
 .../step1-child-loggers.py                    |  41 +
 .../step1-child-loggers.ts                    |  50 +
 .../step2-input-validation.py                 |  49 +
 .../step2-input-validation.ts                 |  57 +
 .../step3-ai-output-validation.py             |  66 ++
 .../step3-ai-output-validation.ts             |  55 +
 .../step4-custom-spans.py                     |  64 ++
 .../step4-custom-spans.ts                     |  71 ++
 lib/tutorial/mdx-parser.ts                    |   7 +-
 lib/tutorial/schemas.ts                       |  13 +-
 lib/validation/middleware.ts                  |   7 +-
 62 files changed, 3362 insertions(+), 3292 deletions(-)
 create mode 100644 examples/training/01-intro/step1-basic-agent.py
 create mode 100644 examples/training/01-intro/step1-basic-agent.ts
 create mode 100644 examples/training/01-intro/step2-with-logging.py
 create mode 100644 examples/training/01-intro/step2-with-logging.ts
 create mode 100644 examples/training/01-intro/step3-with-state.py
 create mode 100644 examples/training/01-intro/step3-with-state.ts
 create mode 100644 examples/training/01-intro/step4-with-errors.py
 create mode 100644 examples/training/01-intro/step4-with-errors.ts
 create mode 100644 examples/training/02-anatomy/step1-understanding-triggers.py
 create mode 100644 examples/training/02-anatomy/step1-understanding-triggers.ts
 create mode 100644 examples/training/02-anatomy/step2-request-data.py
 create mode 100644 examples/training/02-anatomy/step2-request-data.ts
 create mode 100644 examples/training/02-anatomy/step3-structured-logging.py
 create mode 100644 examples/training/02-anatomy/step3-structured-logging.ts
 create mode 100644 examples/training/02-anatomy/step4-kv-caching.py
 create mode 100644 examples/training/02-anatomy/step4-kv-caching.ts
 create mode 100644 examples/training/02-anatomy/step5-response-formats.py
 create mode 100644 examples/training/02-anatomy/step5-response-formats.ts
 create mode 100644 examples/training/03-memory/step1-session-memory.py
 create mode 100644 examples/training/03-memory/step1-session-memory.ts
 create mode 100644 examples/training/03-memory/step2-persistent-preferences.py
 create mode 100644 examples/training/03-memory/step2-persistent-preferences.ts
 create mode 100644 examples/training/03-memory/step3-vector-basics.py
 create mode 100644 examples/training/03-memory/step3-vector-basics.ts
 create mode 100644 examples/training/03-memory/step4-vector-filtering.py
 create mode 100644 examples/training/03-memory/step4-vector-filtering.ts
 create mode 100644 examples/training/03-memory/step5-object-storage.py
 create mode 100644 examples/training/03-memory/step5-object-storage.ts
 create mode 100644 examples/training/04-agent-communication/step1-basic-handoff.py
 create mode 100644 examples/training/04-agent-communication/step1-basic-handoff.ts
 create mode 100644 examples/training/04-agent-communication/step2-data-formats.py
 create mode 100644 examples/training/04-agent-communication/step2-data-formats.ts
 create mode 100644 examples/training/04-agent-communication/step3-run-and-wait.py
 create mode 100644 examples/training/04-agent-communication/step3-run-and-wait.ts
 create mode 100644 examples/training/04-agent-communication/step4-parallel-execution.py
 create mode 100644 examples/training/04-agent-communication/step4-parallel-execution.ts
 create mode 100644 examples/training/04-agent-communication/step5-structured-responses.py
 create mode 100644 examples/training/04-agent-communication/step5-structured-responses.ts
 create mode 100644 examples/training/05-observability-guardrails/step1-child-loggers.py
 create mode 100644 examples/training/05-observability-guardrails/step1-child-loggers.ts
 create mode 100644 examples/training/05-observability-guardrails/step2-input-validation.py
 create mode 100644 examples/training/05-observability-guardrails/step2-input-validation.ts
 create mode 100644 examples/training/05-observability-guardrails/step3-ai-output-validation.py
 create mode 100644 examples/training/05-observability-guardrails/step3-ai-output-validation.ts
 create mode 100644 examples/training/05-observability-guardrails/step4-custom-spans.py
 create mode 100644 examples/training/05-observability-guardrails/step4-custom-spans.ts

diff --git a/agent-docs/src/agents/agent-pulse/context/builder.ts b/agent-docs/src/agents/agent-pulse/context/builder.ts
index ca48a4f1..63a0221f 100644
--- a/agent-docs/src/agents/agent-pulse/context/builder.ts
+++ b/agent-docs/src/agents/agent-pulse/context/builder.ts
@@ -24,7 +24,11 @@ You have access to various tools you can use -- use when appropriate!
 
 === TOOL-USAGE RULES (must follow) ===
 - startTutorialById must only be used when user select a tutorial. If the user starts a new tutorial, the step number should be set to one. Valid step is between 1 and totalSteps of the specific tutorial.
-- Treat askDocsAgentTool as a search helper; ignore results you judge irrelevant.
+- **askDocsAgentTool usage:**
+  - ALWAYS use askDocsAgentTool for questions about the Agentuity SDK, platform features, APIs, or CLI commands.
+  - Examples: AgentContext, AgentRequest, AgentResponse, ctx.logger, ctx.vector, resp.json, deployment, authentication, agent configuration.
+  - For non-Agentuity questions (general programming concepts), you may answer directly without the tool.
+  - Treat doc results as authoritative. If docs don't cover it, inform the user.
 
 === RESPONSE STYLE (format guidelines) ===
 - Begin with a short answer, then elaborate if necessary.
diff --git a/agent-docs/src/agents/agent-pulse/tools.ts b/agent-docs/src/agents/agent-pulse/tools.ts
index 89f2e501..6ca21035 100644
--- a/agent-docs/src/agents/agent-pulse/tools.ts
+++ b/agent-docs/src/agents/agent-pulse/tools.ts
@@ -38,8 +38,15 @@ export async function createTools(context: ToolContext) {
 
             const data = tutorialResponse.data
             const totalSteps = tutorialResponse.data.totalSteps;
+
+            // Guard: reject invalid step numbers (steps are 1-indexed)
+            if (stepNumber < 1) {
+                return `Step number must be 1 or greater. You requested step ${stepNumber}.`;
+            }
+
+            // Guard: reject steps beyond tutorial length
             if (stepNumber > totalSteps) {
-                return `This tutorial only has ${totalSteps} steps. You either reached the end of the tutorial or selected an incorrect step number.`;
+                return `This tutorial only has ${totalSteps} step${totalSteps === 1 ? '' : 's'}. You requested step ${stepNumber}.`;
             }
             state.setAction({
                 type: ActionType.START_TUTORIAL_STEP,
@@ -57,7 +64,16 @@ export async function createTools(context: ToolContext) {
      * This tool doesn't use state - it returns data directly
      */
     const askDocsAgentTool = tool({
-        description: "Query the Agentuity Development Documentation agent using RAG (Retrieval Augmented Generation) to get relevant documentation and answers about the Agentuity platform, APIs, and development concepts",
+        description: `Query the Agentuity Development Documentation agent using RAG (Retrieval Augmented Generation).
+
+USE THIS TOOL when users ask about:
+- Agentuity SDK objects (AgentContext, AgentRequest, AgentResponse)
+- SDK methods (ctx.logger, ctx.vector, ctx.kv, resp.json, resp.stream, etc.)
+- Platform features (deployment, authentication, agent configuration, etc.)
+- CLI commands (agentuity agent create, deploy, etc.)
+- Agentuity APIs and development workflows (e.g. agent.run, agent.create, etc.)
+
+This tool provides authoritative, up-to-date documentation specific to the Agentuity platform.`,
         parameters: z.object({
             query: z.string().describe("The question or query to send to the query function"),
         }),
diff --git a/app/chat/components/CodeBlock.tsx b/app/chat/components/CodeBlock.tsx
index 8900cb92..4a236ccb 100644
--- a/app/chat/components/CodeBlock.tsx
+++ b/app/chat/components/CodeBlock.tsx
@@ -1,7 +1,6 @@
 'use client';
 
-import { useState, useEffect, useRef } from 'react';
-import { Copy, Check } from 'lucide-react';
+import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
 
 interface SimpleCodeBlockProps {
   content: string;
@@ -12,51 +11,17 @@ export default function CodeBlock({
   content,
   language
 }: SimpleCodeBlockProps) {
-  const [code, setCode] = useState(content);
-  const [copied, setCopied] = useState(false);
-  const textareaRef = useRef<HTMLTextAreaElement | null>(null);
-
-  useEffect(() => {
-    setCode(content);
-    // Auto-size the textarea to its content within max height
-    if (textareaRef.current) {
-      const el = textareaRef.current;
-      el.style.height = 'auto';
-      const maxPx = 500;
-      const newHeight = Math.min(el.scrollHeight, maxPx);
-      el.style.height = `${newHeight}px`;
-    }
-  }, [content]);
-
-  const copyToClipboard = () => {
-    navigator.clipboard.writeText(code);
-    setCopied(true);
-    setTimeout(() => setCopied(false), 2000);
-  };
-
   return (
     <div className="agentuity-card-elevated rounded-xl overflow-hidden">
-      {/* Header */}
+      {/* Custom header with language label */}
       <div className="flex items-center justify-between p-2 bg-black/5 dark:bg-black/20 border-b border-black/2 dark:border-white/8">
         <span className="text-sm text-gray-200">{language}</span>
-        <div className="flex gap-2">
-          <button
-            onClick={copyToClipboard}
-            className="group flex items-center gap-1 px-2 py-1 text-xs font-medium rounded-lg transition-all duration-200 agentuity-button-primary bg-gradient-to-r from-blue-500/20 to-cyan-500/20 hover:from-blue-500/30 hover:to-cyan-500/30 text-cyan-400 hover:scale-105 active:scale-95"
-          >
-            {copied ? <Check className="w-4 h-4" /> : <Copy className="w-4 h-4" />}
-          </button>
-        </div>
       </div>
 
-      <textarea
-        ref={textareaRef}
-        value={code}
-        readOnly={true}
-        className="w-full p-4 text-sm font-mono bg-white text-gray-900 dark:bg-transparent dark:text-gray-200 border-0 focus:outline-none focus:ring-0 overflow-x-auto overflow-y-auto leading-relaxed resize-none"
-        style={{ minHeight: '200px', maxHeight: '500px' }}
-        spellCheck={false}
-      />
+      {/* Syntax-highlighted code block with built-in copy button */}
+      <div className="[&>figure]:my-0 [&>figure]:rounded-none [&>figure]:border-0">
+        <DynamicCodeBlock code={content} lang={language || 'text'} />
+      </div>
     </div>
   );
 } 
\ No newline at end of file
diff --git a/app/chat/types.ts b/app/chat/types.ts
index cda91db4..c8f14308 100644
--- a/app/chat/types.ts
+++ b/app/chat/types.ts
@@ -11,10 +11,15 @@ export const TutorialSnippetSchema = z.object({
 
 export type TutorialSnippet = z.infer<typeof TutorialSnippetSchema>;
 
+/**
+ * Tutorial data schema for agent responses
+ * - Steps are 1-indexed (no step 0 concept)
+ * - Only tutorials with interactive steps are tracked
+ */
 export const TutorialDataSchema = z.object({
   tutorialId: z.string(),
   totalSteps: z.number().int().min(1),
-  currentStep: z.number().int().min(0),
+  currentStep: z.number().int().min(1),
   tutorialStep: z.object({
     title: z.string(),
     mdx: z.string(),
diff --git a/components/CodeFromFiles.tsx b/components/CodeFromFiles.tsx
index ead65df5..e26ffd6e 100644
--- a/components/CodeFromFiles.tsx
+++ b/components/CodeFromFiles.tsx
@@ -1,6 +1,6 @@
 import React from 'react';
 import path from 'path';
-import CodeBlock from '@/app/chat/components/CodeBlock';
+import { DynamicCodeBlock } from 'fumadocs-ui/components/dynamic-codeblock';
 import { Tabs, Tab } from 'fumadocs-ui/components/tabs';
 import { readSecureFile } from '@/lib/utils/secure-path';
 
@@ -72,7 +72,7 @@ export default async function CodeFromFiles(props: CodeFromFilesProps) {
       <Tabs items={loaded.map((x) => x.label)}>
         {loaded.map((x, idx) => (
           <Tab key={idx} value={x.label}>
-            <CodeBlock content={x.content} language={x.lang} />
+            <DynamicCodeBlock code={x.content} lang={x.lang} />
           </Tab>
         ))}
       </Tabs>
diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
index c4c39984..4d41f20e 100644
--- a/content/Training/developers/01-introduction-to-agents.mdx
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -169,30 +169,27 @@ Agentuity provides what agents actually need:
 - **Agent-to-agent communication**: Seamless and secure [channels between agents](/Guides/agent-communication)
 - **Native observability**: Track agent decisions with [built-in tracing](/Guides/agent-tracing)
 - **Automatic scaling**: Based on agent workload, not request count
-- **Framework agnostic**: Run LangChain, CrewAI, or custom agents side by side - and easily integrate with popular tools like the Vercel AI SDK for streamlined AI development
+- **Framework agnostic**: Run agents on any framework (LangChain, CrewAI, custom, etc.), and combine them in multi-agent projects
+- **Easily integrate with popular tools**: Including the Vercel AI SDK for streamlined AI development, a personal favorite of ours for TypeScript projects
 
 The result is a platform where agents are first-class citizens, not adapted workloads; memory and state are built-in, not bolted on; long-running is the default, not an exception; and agent communication is native, not a hack.
 
-## Your First Agent: Hello, Autonomous World
+## Your First Agent: From Zero to Production
 
-Now that you have an understanding of what agents are and why they need specialized infrastructure, let's build your first agent.
-
-### Prerequisites
+### Environment Setup
 
 <Callout type="info">
 For detailed setup instructions, see our [Getting Started Guide](/Introduction/getting-started) and [CLI Installation Guide](/CLI/installation).
 </Callout>
 
-Before we start, make sure you have:
+Before we start building, make sure you have:
 - Python 3.9+ or Node.js 18+
 - Basic command line knowledge
 - An Agentuity account (free tier is fine)
 
-### Quick Setup
+Install the Agentuity CLI:
 
 ```bash
-# Install the Agentuity CLI
-
 # NPM (if you have Node.js)
 npm install -g @agentuity/cli
 
@@ -204,10 +201,6 @@ brew tap agentuity/tap && brew install agentuity
 
 # Universal installer (Windows/Linux/macOS)
 curl -fsS https://agentuity.sh | sh
-# Note: Verify the checksum from https://agentuity.com/install for security
-
-# Direct download from releases
-# Visit https://github.com/agentuity/cli/releases for your platform
 
 # Verify installation
 agentuity --version
@@ -216,302 +209,140 @@ agentuity --version
 agentuity auth login
 ```
 
-### Creating Your First Agent Project
+### Local Development with DevMode
+
+<Callout type="info">
+DevMode is Agentuity's local development environment that provides instant feedback, complete observability, and a web interface for testing agents. Learn more in our [DevMode Guide](/Guides/devmode).
+</Callout>
 
-Let's create a simple agent that demonstrates the key concepts we've learned:
+Start DevMode to test your agents locally:
 
 ```bash
-# Create a new agent project
-agentuity create hello-agent --template typescript-starter
-# or for Python:
-# agentuity create hello-agent --template python-starter
-
-# Navigate to the project
-cd hello-agent
-
-# Install dependencies (TypeScript)
-npm install
-# or for Python:
-# pip install -r requirements.txt
+agentuity dev
+# Opens at http://localhost:3500 with a web interface
 ```
 
-### Understanding the Agent Structure
+You'll use DevMode throughout the tutorial below to test each step as you build your agent.
 
-Here's a simple "Hello Agent" that demonstrates the core concepts:
+### Build Your First Agent Step-by-Step
 
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+Work through these steps to build your first agent. Each step adds new capabilities - follow along by creating a project (`agentuity create`), or read through to understand the patterns.
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Get the name from request data
-    data = await request.data.json()
-    name = data.get("name", "World")
+### Step 1: Create a Basic Agent
 
-    # Return a simple greeting
-    return response.json({"message": f"Hello, {name}!"})`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+<TutorialStep number={1} title="Create a Basic Agent" estimatedTime="3 minutes">
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Get the name from request data
-  const data = await request.data.json();
-  const name = data.name || 'World';
+Let's start with the simplest possible agent - it accepts a name and returns a greeting:
 
-  // Return a simple greeting
-  return response.json({ message: \`Hello, \${name}!\` });
-}`} />
+<CodeFromFiles snippets={[
+  { path: "/examples/training/01-intro/step1-basic-agent.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/01-intro/step1-basic-agent.py", lang: "python", title: "Python" }
+]} />
 
-This simple agent demonstrates:
-- **Request handling**: Accepts JSON input with a `name` field
-- **Response generation**: Returns a personalized greeting
-- **Agentuity patterns**: Uses the standard request/response structure
-- **Agent-native infrastructure**: Runs on infrastructure built for agents
-
-### Adding Observability and State
-
-Let's enhance our agent with logging and a simple state counter:
-
-<CodeExample py={`from datetime import datetime
-from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Log the incoming request (built-in observability)
-    context.logger.info("Hello agent received a request")
-
-    # Get the name from request data
-    data = await request.data.json()
-    name = data.get("name", "World")
-
-    # Simple counter using KV storage
-    counter_result = await context.kv.get("stats", "greeting_count")
-    if counter_result.exists:
-        count = await counter_result.data.json()
-        count += 1
-    else:
-        count = 1
-
-    # Update the counter
-    await context.kv.set("stats", "greeting_count", count)
-
-    context.logger.info(f"Greeting #{count} for {name}")
-
-    # Return a greeting with some stats
-    return response.json({
-        "message": f"Hello, {name}!",
-        "greeting_number": count,
-        "timestamp": datetime.now().isoformat()
-    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Log the incoming request (built-in observability)
-  context.logger.info('Hello agent received a request');
-
-  // Get the name from request data
-  const data = await request.data.json();
-  const name = data.name || 'World';
-
-  // Simple counter using KV storage
-  const counterResult = await context.kv.get('stats', 'greeting_count');
-  let count;
-  if (counterResult.exists) {
-    count = await counterResult.data.json();
-    count++;
-  } else {
-    count = 1;
-  }
+**What this demonstrates:**
+- Basic request/response pattern
+- JSON input handling
+- Simple response generation
+- Core agent structure (AgentRequest, AgentResponse, AgentContext)
 
-  // Update the counter
-  await context.kv.set('stats', 'greeting_count', count);
+**Try it yourself:** Create a new project with `agentuity create`, replace the default agent code with the code above, and run `agentuity dev` to test it.
 
-  context.logger.info(\`Greeting #\${count} for \${name}\`);
+</TutorialStep>
 
-  // Return a greeting with some stats
-  return response.json({
-    message: \`Hello, \${name}!\`,
-    greeting_number: count,
-    timestamp: new Date().toISOString()
-  });
-}`} />
+### Step 2: Add Observability
 
-This enhanced agent demonstrates:
-- **Comprehensive Observability**: Built-in logging with context.logger plus automatic OpenTelemetry tracing that captures all operations (storage calls, external requests) as structured spans without any additional code
-- **State Management**: Simple counter using key-value storage
-- **Agent Memory**: One storage type (KV) without complexity
-- **Request/Response**: JSON input and structured output
+<TutorialStep number={2} title="Add Observability" estimatedTime="3 minutes">
 
-### Testing Your Agent with DevMode
+Now let's add logging so we can see what's happening inside our agent:
 
-<Callout type="info">
-DevMode is Agentuity's local development environment that provides instant feedback, complete observability, and a user-friendly web interface for testing agents.
-</Callout>
+<CodeFromFiles snippets={[
+  { path: "/examples/training/01-intro/step2-with-logging.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/01-intro/step2-with-logging.py", lang: "python", title: "Python" }
+]} />
 
-Test your agent using Agentuity's DevMode:
+**What changed:**
+- Added `context.logger.info()` calls to track agent behavior
+- Logs appear in DevMode and dashboard
+- Helps debug and monitor agent execution
 
-```bash
-# Start DevMode - your agent will be available with a web interface
-agentuity dev
+**Key insight:** In non-deterministic systems like agents, observability is critical. You need to see what the agent is doing and why.
 
-# DevMode will start and show:
-# 🚀 DevMode ready
-# 🌐 Local: http://localhost:3500
-# 🔗 Public: https://[unique-id].agentuity.dev (for external access)
-```
+**Try it:** Run this version in DevMode and watch the logs appear in real-time.
 
-Once DevMode is running:
-1. Open the provided URL in your browser
-2. Select your agent from the dropdown
-3. Use the pre-configured prompts or write your own test scenarios
-4. Click "Run" to execute tests instantly
-5. View real-time logs, costs, and performance metrics in the interface
-
-#### Making Testing Easier with the Welcome Function
-
-Add a `welcome()` function to your agent to create clickable test scenarios in DevMode:
-
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
-
-def welcome():
-    """Configure test scenarios for DevMode."""
-    return {
-        "welcome": "Welcome to my Hello Agent! Try these examples:",
-        "prompts": [
-            {
-                "data": {"name": "Sarah"},
-                "contentType": "application/json"
-            },
-            {
-                "data": {"name": "DevMode Tester"},
-                "contentType": "application/json"
-            },
-            {
-                "data": {"name": ""},  # Test missing name
-                "contentType": "application/json"
-            }
-        ]
-    }
+</TutorialStep>
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Your existing agent code...`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export const welcome = () => {
-    return {
-        welcome: "Welcome to my Hello Agent! Try these examples:",
-        prompts: [
-            {
-                data: JSON.stringify({ name: "Sarah" }),
-                contentType: "application/json"
-            },
-            {
-                data: JSON.stringify({ name: "DevMode Tester" }),
-                contentType: "application/json"
-            },
-            {
-                data: JSON.stringify({ name: "" }), // Test missing name
-                contentType: "application/json"
-            }
-        ]
-    };
-};
-
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-    // Your existing agent code...`} />
-
-These prompts appear as clickable buttons in the DevMode interface. Try calling the agent multiple times with the same name - it will remember you, and you can see the memory operations in the real-time logs!
-
-### Deploying to the Agentuity Cloud
-
-Now let's deploy this agent to production:
+### Step 3: Add State Management
 
-```bash
-# Deploy to Agentuity's agent-native infrastructure
-agentuity deploy
+<TutorialStep number={3} title="Add State Management" estimatedTime="5 minutes">
 
-# Your deployment will show:
-# Deployment successful
-# Agent URL: https://[unique-id].agentuity.com
-# Dashboard: https://console.agentuity.com/projects/[project-id]
-```
+Let's make the agent remember how many times it has greeted people using Agentuity's built-in key-value storage:
 
-That's it! Your agent is now:
-- Running in long-running infrastructure (no timeout worries)
-- Storing memory persistently (survives restarts)
-- Fully observable (check logs and traces in the dashboard)
-- Auto-scaling based on load
+<CodeFromFiles snippets={[
+  { path: "/examples/training/01-intro/step3-with-state.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/01-intro/step3-with-state.py", lang: "python", title: "Python" }
+]} />
+
+**What changed:**
+- Uses `context.kv.get()` to read state
+- Uses `context.kv.set()` to update state
+- Checks `result.exists` to handle first-time execution
+- State persists across invocations
 
-## Lab: Extending Your Agent
+**Key insight:** Agents need memory to be truly useful. Agentuity provides built-in key-value storage so you don't need external databases for simple state.
 
-Now that you have a working agent, let's enhance it with more capabilities. Use DevMode to test each enhancement as you build it.
+<Callout type="info">
+We cover all storage APIs later in [Module 3: Agent Memory](/Training/developers/03-agent-memory). You can also read more by checking out our guide on [Key-Value Storage](/Guides/key-value).
+</Callout>
 
-### Challenge 1: Add Error Handling
-Enhance your agent with proper error handling and validation:
+**Try it:** Call this agent multiple times. Watch the counter increment and persist across calls.
 
-<CodeExample py={`# Key pattern: Defensive error handling
-try:
-    data = await request.data.json()
-    name = data.get("name")
+</TutorialStep>
 
-    if not name:
-        context.logger.warn("No name provided in request")
-        return response.json({"error": "Name is required"})
+### Step 4: Add Error Handling
 
-    # Your agent logic here...`} js={`// Key pattern: Defensive error handling
-try {
-  const data = await request.data.json();
-  const name = data.name;
+<TutorialStep number={4} title="Add Error Handling" estimatedTime="5 minutes">
 
-  if (!name) {
-    context.logger.warn('No name provided in request');
-    return response.json({ error: 'Name is required' });
-  }
+Agents need defensive error handling to gracefully handle invalid inputs:
 
-  // Your agent logic here...`} />
-
-### Challenge 2: Handle Multiple Input Types
-Enhance your agent to handle both JSON and text inputs gracefully:
-
-<CodeExample py={`# Key pattern: Flexible input handling
-try:
-    if request.data.contentType == "application/json":
-        data = await request.data.json()
-        name = data.get("name", "World")
-    elif request.data.contentType == "text/plain":
-        name = await request.data.text() or "World"
-    else:
-        name = "World"
-except Exception as e:
-    context.logger.error(f"Error parsing request: {e}")
-    name = "World"  # Graceful fallback`} js={`// Key pattern: Flexible input handling
-let name = 'World';
-try {
-  if (request.data.contentType === 'application/json') {
-    const data = await request.data.json();
-    name = data.name || 'World';
-  } else if (request.data.contentType === 'text/plain') {
-    name = await request.data.text() || 'World';
-  }
-} catch (error) {
-  context.logger.error(\`Error parsing request: \${error}\`);
-  // Graceful fallback to default
-}`} />
+<CodeFromFiles snippets={[
+  { path: "/examples/training/01-intro/step4-with-errors.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/01-intro/step4-with-errors.py", lang: "python", title: "Python" }
+]} />
+
+**What changed:**
+- Try/catch blocks around JSON parsing
+- Input validation (checks for valid name)
+- Graceful error responses
+- Defensive storage handling (continues even if storage fails)
 
-### Challenge 3: Complete Production Implementation
+**Key insight:** Agents interact with unpredictable inputs and external systems. Error handling ensures they fail gracefully and provide useful feedback.
 
-Now let's combine all features (and add some simple storage provided by Agentuity) into a fully-functional agent.
+**Try it:** Send invalid JSON or missing data to see how the agent handles errors.
 
-This complete implementation demonstrates:
-- **Error handling** with try/catch
-- **Multiple content types** (JSON and text input support)
-- **Statistics tracking** (personal greeting counts)
-- **Memory management** (stores only last 5 names)
-- **TTL storage** (24-hour expiration on stats)
-- **DevMode integration** with clickable test scenarios via `welcome()`
-- **Logging** for debugging and monitoring
+</TutorialStep>
 
-### Build This Agent Yourself
+### Deploy Your Tutorial Agent
 
-Ready to implement this agent? Follow our complete examples:
+Now that you've built and tested your agent locally, deploy it to Agentuity's agent-native infrastructure:
+
+```bash
+agentuity deploy
+```
+
+Your agent will be:
+- Running in long-running infrastructure (no timeout worries)
+- Storing memory persistently (survives restarts)
+- Fully observable (logs and traces in the dashboard)
+- Auto-scaling based on load
+
+## Lab: Try It All Together
+
+Ready to see everything in action? Clone a complete example that combines all the concepts you've learned - error handling, state management, multiple input types, and more:
 
 <div className="flex flex-wrap gap-3 mb-6">
   <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/01-hello-world-ts" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
-    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.23 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
+    <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     TypeScript
   </a>
   <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/01_hello_world_py" target="_blank" rel="noopener noreferrer"
@@ -521,9 +352,15 @@ Ready to implement this agent? Follow our complete examples:
   </a>
 </div>
 
-## Testing Your Complete Agent
+This lab project includes:
+- Error handling and input validation
+- Multiple input types (JSON and text)
+- Personal statistics tracking per user
+- Memory management with TTL-based expiration
+- DevMode test scenarios via `welcome()` function
+- Complete `agentuity.yaml` configuration
 
-After implementing this complete version:
+After cloning the lab, try the following:
 1. Run `agentuity dev` to start DevMode
 2. Use the clickable prompts from the `welcome()` function
 3. Test with both JSON and text inputs
@@ -533,13 +370,31 @@ After implementing this complete version:
 7. Check the Sessions tab for performance metrics
 
 <Callout type="info">
-This complete implementation shows production patterns you'll use throughout the training modules. Notice how we handle errors gracefully, store data efficiently, and provide rich observability.
+This complete implementation shows patterns you'll use throughout the training modules. Notice how we handle errors gracefully, store data efficiently, and provide rich observability.
 </Callout>
 
+### Testing Your First Agent
+
+1. **Start DevMode:**
+```bash
+agentuity dev
+```
+
+2. **Test with the clickable prompts** from the `welcome()` function in the lab examples
+3. **Try different inputs:**
+   - Valid JSON: `{"name": "Alice"}`
+   - Plain text: `"Bob"`
+   - Invalid data to test error handling
+4. **Call multiple times** with the same name to see the greeting counter increment
+5. **Monitor observability:**
+   - Check the Logs tab to see structured logging
+   - View the Sessions tab for performance metrics
+   - Inspect key-value storage to see persisted counts
+
 ## Key Takeaways
 
 - **Agents are different**: They're autonomous systems, not just API wrappers around LLMs
-- **The market is massive**: $47B by 2030, with many developers already building agents
+- **The market is massive**: $47B by 2030, with many developers already building agents (you're now one of them!)
 - **Infrastructure matters**: Traditional cloud wasn't built for agents' unique needs
 - **Non-determinism is a feature**: Agents adapt and reason, they don't just execute
 - **Agentuity is agent-native**: Purpose-built infrastructure for agents, not retrofitted
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index c3a79084..0f7fa1a5 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -1,9 +1,9 @@
 ---
 title: "Module 2: The Anatomy of an Agent"
-description: Understanding how agents work - planning, reasoning, tools, and memory
+description: Understanding the core components that make agents work - triggers, requests, logging, and storage
 ---
 
-Now that you've built your first agent, let's dive deeper to understand what makes agents tick. We'll explore the core components that transform a simple script into an autonomous, intelligent system.
+Now that you've built your first agent, let's dive deeper to understand what makes agents tick. In this module, you'll learn the fundamental building blocks every agent shares, then see them combined in a real-world weather agent.
 
 ## The Agent Lifecycle
 
@@ -19,612 +19,305 @@ graph TD
     F --> G[Return to Caller<br/>Client receives result]
 " />
 
-Let's explore each phase:
+Agents follow this lifecycle regardless of complexity—from simple greeting agents to more complex multi-step (or multi-agent) solutions. Let's explore each phase to understand what makes this lifecycle powerful.
 
-### 1. Trigger Events
+## Planning and Reasoning: The Agent's Brain
 
-Agents spring into action when triggered. Agentuity supports multiple trigger types:
+What separates agents from simple scripts is their ability to plan and reason. While Agentuity provides the infrastructure (triggers, storage, logging), you implement the logic to make your agent(s) do something useful.
 
-| Trigger Type | Description | Use Case |
-|-------------|-------------|----------|
-| **webhook** | HTTP endpoint call | REST APIs, external integrations |
-| **cron** | Scheduled execution | Batch processing, periodic tasks |
-| **manual** | Console/CLI invocation | Testing, one-off tasks |
-| **agent** | Called by another agent | Multi-agent workflows |
-| **sms** | SMS message received | Text-based interactions |
-| **email** | Email received | Email automation |
-| **queue** | Message queue event | Async processing |
+### The Planning Phase
 
-Each trigger provides different metadata and context:
+Planning is how agents break down complex requests into actionable steps. According to [OpenAI's practical guide to building agents](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf), providing smaller, clearer steps from dense resources helps minimize ambiguity and helps the model better follow instructions.
 
-<CodeExample py={`from datetime import datetime
-from agentuity import AgentRequest, AgentResponse, AgentContext
+Effective agent planning involves:
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Identify the trigger type
-    trigger = request.trigger
+1. **Intent Recognition**: Understanding what the user actually wants
+2. **Task Decomposition**: Breaking complex requests into smaller steps
+3. **Resource Assessment**: Determining what tools and data are needed
+4. **Execution Strategy**: Deciding the order and approach for each step
 
-    if trigger == "webhook":
-        # Handle HTTP request
-        data = await request.data.json()
-        context.logger.info(f"Webhook triggered with data: {data}")
+As a result, agents use LLMs to adapt their approach based on context and available resources, rather than use hard-coded logic (i.e. decision trees).
 
-    elif trigger == "cron":
-        # Handle scheduled execution
-        context.logger.info(f"Cron job running at {datetime.now()}")
-        # No input data for cron triggers
+### The Reasoning Loop
 
-    elif trigger == "agent":
-        # Handle agent-to-agent call
-        calling_agent = request.metadata.get("source_agent")
-        context.logger.info(f"Called by agent: {calling_agent}")
+The reasoning loop is where agents continuously evaluate and adapt their approach. [Stanford's research on ReAct agents](https://arxiv.org/abs/2210.03629) shows that combining reasoning and acting in iterative loops significantly improves agent performance.
 
-    return response.json({
-        "trigger_type": trigger,
-        "processed_at": datetime.now().isoformat()
-    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+The basic pattern follows:
+1. **Observe** - Analyze current state and available information
+2. **Think** - Reason about the best next action
+3. **Act** - Execute the chosen action
+4. **Reflect** - Evaluate the results and learn
+5. **Repeat** - Continue until goal is achieved or constraints are met
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Identify the trigger type
-  const trigger = request.trigger;
+This iterative approach allows agents to handle uncertainty and recover from errors—key capabilities that distinguish agents from simple scripts.
 
-  if (trigger === 'webhook') {
-    // Handle HTTP request
-    const data = await request.data.json();
-    context.logger.info(\`Webhook triggered with data: \${JSON.stringify(data)}\`);
+You'll implement these patterns in a basic way, using the anatomy concepts you'll learn next: triggers to determine when to start, logging to track decisions, storage to maintain state, and responses to deliver results.
 
-  } else if (trigger === 'cron') {
-    // Handle scheduled execution
-    context.logger.info(\`Cron job running at \${new Date().toISOString()}\`);
-    // No input data for cron triggers
+## Core Components of Agent Anatomy
 
-  } else if (trigger === 'agent') {
-    // Handle agent-to-agent call
-    const callingAgent = request.metadata.get('source_agent');
-    context.logger.info(\`Called by agent: \${callingAgent}\`);
-  }
+Now that you understand the theory, let's dive into the practical components. Every agent is built from the same fundamental building blocks:
 
-  return response.json({
-    trigger_type: trigger,
-    processed_at: new Date().toISOString()
-  });
-}`} />
+### 1. Triggers
 
-### 2. Request and Response Handling
+Agents spring into action when triggered. Agentuity supports multiple trigger types:
 
-Every agent receives a request and must return a response. The request contains the trigger data and metadata, while the response can be in various formats:
+| Trigger Type | Description | Use Case |
+|-------------|-------------|----------|
+| **webhook** | HTTP endpoint call | REST APIs, external integrations |
+| **cron** | Scheduled execution | Batch processing, periodic tasks |
+| **manual** | DevMode/CLI invocation | Testing, one-off tasks |
+| **agent** | Called by another agent | Multi-agent workflows |
+| **sms** | SMS message received | Text-based interactions |
+| **email** | Email received | Email automation |
+| **queue** | Message queue event | Async processing |
 
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+But these triggers are not mutually exclusive. Agents on Agentuity can be triggered *by multiple triggers*, and can behave differently based on the trigger.
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Access request data in different formats
+For example, a weather agent might use the following triggers:
+- **Webhook**: Return weather for a user-requested location
+- **Cron**: Update cached weather data for monitoring dashboards
+- **Manual**: Test behavior (locally, via DevMode) during development
 
-    # JSON data (most common)
-    json_data = await request.data.json()
+### 2. Request and Response
 
-    # Plain text
-    text_data = await request.data.text()
+Every agent receives a **request** containing data and metadata, and must return a **response**.
 
-    # Binary data
-    binary_data = await request.data.binary()
+**Request Data Formats:**
+- `request.data.json()` - Parse JSON data
+- `request.data.text()` - Get plain text
+- `request.data.binary()` - Get binary data
+- `request.data.email()`, `request.data.pdf()`, etc. - Specialized formats
+- *(and many more...)*
 
-    # Response options
+**Request Metadata:**
+- `request.metadata` - Property returning the full metadata dict/object
+- `request.get(key, default)` - Convenience method for accessing metadata values
+- `request.trigger` - Property identifying how the agent was invoked
 
-    # JSON response (most common)
-    return response.json({"result": "success"})
+**Response Formats:**
+- `response.json(data)` - Most common, structured data
+- `response.text(data)` - Plain text
+- `response.html(data)` - HTML content
+- `response.empty()` - No content (useful for webhooks or to handle cases where no "actual" response is needed)
+- `response.binary(data)` - Binary data
+- Media-specific: `pdf()`, `png()`, `jpeg()`, `mp3()`, etc.
 
-    # Text response
-    # return response.text("Hello, World!")
+### 3. The Agent Context
 
-    # HTML response
-    # return response.html("<h1>Hello</h1>")
+The `context` object is your agent's way to access core Agentuity services, including:
 
-    # Binary response (for files)
-    # return response.binary(file_bytes)
+**Storage & Data:**
+- `context.kv` - Key-value storage for caching and state
+- `context.vector` - Vector storage for semantic search
+- `context.objectstore` - Object storage for files
 
-    # Redirect to another agent
-    # return response.handoff({"name": "other-agent"}, data, metadata={})`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+**Observability:**
+- `context.logger` - Structured logging with levels (info, warn, error, debug)
+- `context.tracer` - built-in OpenTelemetry tracing
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Access request data in different formats
+**Communication:**
+- `context.getAgent()` - Access other agents for multi-agent workflows
 
-  // JSON data (most common)
-  const jsonData = await request.data.json();
+**Metadata:**
+- `context.agent` - Current agent info (id, name)
+- `context.sessionId` - Current session identifier
+- `context.projectId` - Current project identifier
 
-  // Plain text
-  const textData = await request.data.text();
+<Callout type="info">
+See the [JavaScript SDK API Reference](/SDKs/javascript/api-reference) or [Python SDK API Reference](/SDKs/python/api-reference) for complete details.
+</Callout>
 
-  // Binary data
-  const binaryData = await request.data.binary();
+### 4. Storage for State and Memory
 
-  // Response options
+Agentuity provides three storage APIs that enable different memory patterns:
 
-  // JSON response (most common)
-  return response.json({ result: 'success' });
+- **Session memory (KV with TTL)** - Temporary data that expires (e.g., 5-minute cache)
+- **Persistent memory (KV without TTL)** - Data that survives restarts
+- **Searchable memory (Vector)** - Semantic search and knowledge retrieval
+- **File storage (Object)** - Binary files, documents, images, and media
 
-  // Text response
-  // return response.text('Hello, World!');
+We'll explore memory patterns in depth in **Module 3: Agent Memory**.
 
-  // HTML response
-  // return response.html('<h1>Hello</h1>');
+### 5. Framework Awareness
 
-  // Binary response (for files)
-  // return response.binary(fileBytes);
+<Callout type="info">
+Agentuity is framework-agnostic. Use any AI framework (LangChain, CrewAI, Vercel AI SDK, etc.) or build custom agents from scratch. The anatomy concepts work with all of them. See [Templates](/Introduction/templates) for starter examples.
+</Callout>
 
-  // Redirect to another agent
-  // return response.handoff({ name: 'other-agent' }, { data: jsonData, contentType: 'application/json' });
-}`} />
+Different frameworks excel at different tasks, but they all use the same Agentuity SDK anatomy:
+- All receive `request`, `response`, `context` parameters
+- All access triggers, data, logging, and storage the same way
+- All return responses in standard formats
 
-### 3. The Agent Context
+As a result, you can choose your framework *based on your use case*, not platform constraints. Plus, you can use multiple frameworks in the same project, or even run agents on different frameworks in the same project.
 
-The context object is your agent's gateway to Agentuity's services. It provides access to storage, logging, tracing, agent communication, and more:
+## Build Agent Anatomy Step-by-Step
 
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
+Now let's get hands-on. Each step below focuses on one core concept, with simple code you can run immediately in DevMode.
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Logging at different levels
-    context.logger.debug("Debug information")
-    context.logger.info("General information")
-    context.logger.warn("Warning message")
-    context.logger.error("Error occurred")
-
-    # Access metadata
-    agent_id = context.agent.id
-    agent_name = context.agent.name
-    project_id = context.projectId
-    session_id = context.sessionId
-
-    # Key-Value storage
-    await context.kv.set("cache", "key", {"data": "value"})
-    result = await context.kv.get("cache", "key")
-
-    # Vector storage for semantic search
-    await context.vector.upsert("docs", [{
-        "key": "doc1",
-        "document": "AI agents are autonomous systems",
-        "metadata": {"category": "intro"}
-    }])
-
-    # Object storage for files
-    await context.objectstore.put("files", "report.pdf", pdf_bytes)
-
-    # Get reference to another agent for inter-agent communication
-    other_agent = context.get_agent("specialist-agent")
-    # agent_response = await other_agent.run({"data": "Hello from triage agent"})
-
-    return response.json({
-        "agent": agent_name,
-        "session": session_id
-    })`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+### Step 1: Understanding Triggers
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Logging at different levels
-  context.logger.debug('Debug information');
-  context.logger.info('General information');
-  context.logger.warn('Warning message');
-  context.logger.error('Error occurred');
-
-  // Access metadata
-  const agentId = context.agent.id;
-  const agentName = context.agent.name;
-  const projectId = context.projectId;
-  const sessionId = context.sessionId;
-
-  // Key-Value storage
-  await context.kv.set('cache', 'key', { data: 'value' });
-  const result = await context.kv.get('cache', 'key');
-
-  // Vector storage for semantic search
-  await context.vector.upsert('docs', [{
-    key: 'doc1',
-    document: 'AI agents are autonomous systems',
-    metadata: { category: 'intro' }
-  }]);
-
-  // Object storage for files
-  await context.objectstore.put('files', 'report.pdf', pdfBytes);
-
-  // Get reference to another agent for inter-agent communication
-  const otherAgent = context.getAgent({ name: 'specialist-agent' });
-  // const agentResponse = await otherAgent.run({ data: 'Hello from triage agent' });
-
-  return response.json({
-    agent: agentName,
-    session: sessionId
-  });
-}`} />
+<TutorialStep number={1} title="Understanding Triggers" estimatedTime="3 min">
 
-## Planning and Reasoning: The Agent's Brain
+Every agent needs to know *how* it was triggered. The same agent code can behave differently based on whether it was called via HTTP, scheduled by cron, invoked manually, and more.
 
-What separates agents from simple scripts is their ability to plan and reason. While Agentuity provides the infrastructure, you implement the intelligence.
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step1-understanding-triggers.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step1-understanding-triggers.py", lang: "python", title: "Python" }
+]} />
 
-### The Planning Phase
+**What this demonstrates:**
+- Accessing the trigger type via `request.trigger`
+- Conditional logic based on trigger
+- Different responses for different trigger types
 
-Planning is how agents break down complex requests into actionable steps. According to [OpenAI's practical guide to building agents](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf), providing smaller, clearer steps from dense resources helps minimize ambiguity and helps the model better follow instructions. Effective agent planning involves:
+**Try it:**
+1. Run this agent in DevMode (creates a `manual` trigger)
+2. Send a webhook request to test `webhook` trigger
+3. Notice how `request.trigger` changes the response
 
-1. **Intent Recognition**: Understanding what the user actually wants
-2. **Task Decomposition**: Breaking complex requests into smaller steps
-3. **Resource Assessment**: Determining what tools and data are needed
-4. **Execution Strategy**: Deciding the order and approach for each step
+</TutorialStep>
 
-Modern agents use LLMs for dynamic planning rather than hard-coded decision trees, allowing them to adapt their approach based on context and available resources.
+### Step 2: Working with Request Data
 
-### The Reasoning Loop
+<TutorialStep number={2} title="Working with Request Data" estimatedTime="4 min">
 
-The reasoning loop is where agents continuously evaluate and adapt their approach. [Stanford's research on ReAct agents](https://arxiv.org/abs/2210.03629) shows that combining reasoning and acting in iterative loops significantly improves agent performance.
+Agents receive data in various formats—JSON, text, binary. The SDK provides methods to handle each format and access metadata about the request.
 
-The basic pattern follows:
-1. **Observe**: Analyze current state and available information
-2. **Think**: Reason about the best next action
-3. **Act**: Execute the chosen action
-4. **Reflect**: Evaluate the results and learn
-5. **Repeat**: Continue until goal is achieved or constraints are met
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step2-request-data.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step2-request-data.py", lang: "python", title: "Python" }
+]} />
 
-This iterative approach allows agents to handle uncertainty and recover from errors - key capabilities that distinguish agents from simple scripts.
+**What this demonstrates:**
+- Content type detection via `request.data.contentType` (TypeScript) or `request.data.content_type` (Python)
+- Parsing different data formats (JSON, text, binary)
+- Accessing metadata using multiple approaches:
+  - `request.get(key, default)` - SDK convenience method (recommended)
+  - `request.metadata` property - Returns the full metadata dict/object
+  - Direct property/dict access for specific use cases
 
-## Tool Invocation: Extending Agent Capabilities
+**Try it:**
+1. Send JSON data: `{"name": "Alice", "action": "greet"}`
+2. Send plain text: `"Hello, agent!"`
+3. Check the logs to see how content type detection works
+4. Notice the commented examples showing different ways to access metadata
 
-Agents become powerful when they can use external tools and services:
+</TutorialStep>
 
-<CodeExample py={`import httpx
-import os
-from typing import Dict, Any
-from agentuity import AgentRequest, AgentResponse, AgentContext
+### Step 3: Structured Logging
 
-async def use_web_search(query: str, context: AgentContext) -> Dict[str, Any]:
-    """Search the web using a real API."""
-    try:
-        # Example using a hypothetical search API
-        api_key = os.getenv("SEARCH_API_KEY")
-        if not api_key:
-            context.logger.warn("No search API key found")
-            return {"error": "Search not available"}
-
-        async with httpx.AsyncClient() as client:
-            response = await client.get(
-                "https://api.searxng.org/search",
-                params={"q": query, "format": "json"}
-            )
-            return response.json()
-    except Exception as e:
-        context.logger.error(f"Search failed: {str(e)}")
-        return {"error": "Search failed"}
+<TutorialStep number={3} title="Structured Logging" estimatedTime="4 min">
 
-async def call_another_agent(agent_name: str, data: dict, context: AgentContext) -> Dict[str, Any]:
-    """Call another agent within the same project."""
-    try:
-        agent = context.get_agent(agent_name)
-        result = await agent.run({
-            "data": data,
-            "contentType": "application/json"
-        })
-        return await result.data.json()
-    except Exception as e:
-        context.logger.error(f"Agent call failed: {str(e)}")
-        return {"error": "Agent call failed"}
+Effective logging is crucial for debugging and monitoring. Use appropriate log levels and structured data to make your logs searchable and actionable.
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    data = await request.data.json()
-    tool = data.get("tool")
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step3-structured-logging.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step3-structured-logging.py", lang: "python", title: "Python" }
+]} />
 
-    if tool == "search":
-        result = await use_web_search(data["query"], context)
-    elif tool == "delegate":
-        result = await call_another_agent(data["agent"], data["task"], context)
-    else:
-        result = {"error": "Unknown tool"}
+**What this demonstrates:**
+- Using different log levels (`info`, `warn`, `error`, `debug`)
+- Including structured context in logs
+- Conditional logging based on task type
 
-    return response.json(result)`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+**Try it:**
+1. Send `{"task": "normal"}` - see INFO logs
+2. Send `{"task": "risky"}` - see WARN logs
+3. Send `{"task": "error"}` - see ERROR logs
+4. Check the Console Logs tab to see structured data
 
-async function useWebSearch(query: string, context: AgentContext): Promise<any> {
-  try {
-    // Example using a hypothetical search API
-    const apiKey = process.env.SEARCH_API_KEY;
-    if (!apiKey) {
-      context.logger.warn('No search API key found');
-      return { error: 'Search not available' };
-    }
+**Best Practice:** Include context in every log (agent ID, session ID, request details) to help with debugging later.
 
-    const response = await fetch('https://api.searxng.org/search?' +
-      new URLSearchParams({ q: query, format: 'json' }));
-    return await response.json();
-  } catch (error) {
-    context.logger.error(\`Search failed: \${error}\`);
-    return { error: 'Search failed' };
-  }
-}
+</TutorialStep>
 
-async function callAnotherAgent(agentName: string, data: any, context: AgentContext): Promise<any> {
-  try {
-    const agent = context.getAgent({ name: agentName });
-    const result = await agent.run({
-      data,
-      contentType: 'application/json'
-    });
-    return await result.data.json();
-  } catch (error) {
-    context.logger.error(\`Agent call failed: \${error}\`);
-    return { error: 'Agent call failed' };
-  }
-}
+### Step 4: Introduction to KV Storage
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const data = await request.data.json();
-  const tool = data.tool;
-
-  let result;
-  if (tool === 'search') {
-    result = await useWebSearch(data.query, context);
-  } else if (tool === 'delegate') {
-    result = await callAnotherAgent(data.agent, data.task, context);
-  } else {
-    result = { error: 'Unknown tool' };
-  }
-
-  return response.json(result);
-}`} />
-
-## Memory Patterns: How Agents Remember
-
-Memory enables agents to learn and maintain state across interactions. The duration and type of memory depends on your use case and TTL settings.
-
-### Session Memory
-For temporary data that should expire:
-
-<CodeExample py={`from datetime import datetime
-from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    session_id = request.metadata.get("session_id")
-
-    # Store temporary session data with TTL
-    await context.kv.set(
-        "sessions",
-        session_id,
-        {
-            "messages": [],
-            "user_preferences": {},
-            "started_at": datetime.now().isoformat()
-        },
-        {"ttl": 3600}  # Expires in 1 hour
-    )
-
-    # Retrieve session data
-    session_data = await context.kv.get("sessions", session_id)
-    if session_data.exists:
-        data = await session_data.data.json()
-        context.logger.info(f"Session active for {len(data['messages'])} messages")`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+<TutorialStep number={4} title="Introduction to KV Storage" estimatedTime="5 min">
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const sessionId = request.metadata.get('session_id');
-
-  // Store temporary session data with TTL
-  await context.kv.set(
-    'sessions',
-    sessionId,
-    {
-      messages: [],
-      user_preferences: {},
-      timestamp: new Date().toISOString()
-    },
-    { ttl: 3600 } // Expires in 1 hour
-  );
-}`} />
+Key-value storage lets agents cache data, manage state, and avoid redundant work. This is a simple caching pattern—check cache first, compute if needed, then store with TTL.
 
-### Persistent Memory
-For data that should survive restarts:
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step4-kv-caching.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step4-kv-caching.py", lang: "python", title: "Python" }
+]} />
 
-<CodeExample py={`from datetime import datetime
-from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    user_id = request.metadata.get("user_id")
-
-    # Store user preferences permanently (no TTL)
-    await context.kv.set(
-        "user_profiles",
-        user_id,
-        {
-            "name": "Alice",
-            "preferences": {"format": "concise"},
-            "created_at": datetime.now().isoformat()
-        }
-        # No TTL = permanent storage
-    )
-
-    # Store large files in object storage
-    await context.objectstore.put(
-        "user_documents",
-        f"{user_id}/resume.pdf",
-        pdf_bytes
-    )`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const userId = request.metadata.get('user_id');
-
-  // Store user preferences permanently (no TTL)
-  await context.kv.set(
-    'user_profiles',
-    userId,
-    {
-      name: 'Alice',
-      preferences: { format: 'concise' },
-      created_at: new Date().toISOString()
-    }
-    // No TTL = permanent storage
-  );
-
-  // Store large files in object storage
-  await context.objectstore.put(
-    'user_documents',
-    \`\${userId}/resume.pdf\`,
-    pdfBytes
-  );
-}`} />
+**What this demonstrates:**
+- Checking cache with `context.kv.get()`
+- Cache hit vs. cache miss handling
+- Storing data with TTL using `context.kv.set()`
 
-### Searchable Memory
-For semantic search and knowledge retrieval:
+**Try it:**
+1. Send `{"query": "hello"}` - first request computes and caches
+2. Send `{"query": "hello"}` again - returns from cache
+3. Send `{"query": "world"}` - different key, fresh computation
+4. Wait 5 minutes and retry - cache expired, recomputes
 
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Store searchable knowledge
-    await context.vector.upsert("knowledge", [{
-        "key": "user_feedback_001",
-        "document": "Users prefer concise responses with examples",
-        "metadata": {
-            "learned_from": "user_feedback",
-            "confidence": 0.85,
-            "category": "response_style"
-        }
-    }])
-
-    # Search for relevant knowledge
-    results = await context.vector.search(
-        "knowledge",
-        "How should I format my responses?",
-        limit=5
-    )
-
-    # Use the knowledge to improve responses
-    if results:
-        context.logger.info(f"Found {len(results)} relevant insights")
-        for result in results:
-            context.logger.info(f"Insight: {result.document}")`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  // Store searchable knowledge
-  await context.vector.upsert('knowledge', [{
-    key: 'user_feedback_001',
-    document: 'Users prefer concise responses with examples',
-    metadata: {
-      learned_from: 'user_feedback',
-      confidence: 0.85,
-      category: 'response_style'
-    }
-  }]);
-
-  // Search for relevant knowledge
-  const results = await context.vector.search(
-    'knowledge',
-    'How should I format my responses?',
-    { limit: 5 }
-  );
-
-  // Use the knowledge to improve responses
-  if (results.length > 0) {
-    context.logger.info(\`Found \${results.length} relevant insights\`);
-    results.forEach(result => {
-      context.logger.info(\`Insight: \${result.document}\`);
-    });
-  }
-}`} />
-
-## Framework Awareness: Choosing the Right Tool
+**Key Concepts:**
+- **Bucket**: First parameter (`'demo-cache'`) - organizes related keys
+- **Key**: Second parameter (unique identifier for the data)
+- **TTL**: Time-to-live in seconds (data expires automatically)
+- **No TTL**: Omit TTL for permanent storage
 
 <Callout type="info">
-Agentuity is framework-agnostic. You can use any AI framework or build custom agents from scratch.
+We'll explore advanced memory patterns (session, persistent, vector) in [**Module 3: Agent Memory**](/Training/developers/03-agent-memory).
 </Callout>
 
-### Popular Agent Frameworks
-
-Different frameworks excel at different tasks. Here's when to use each:
-
-| Framework | Best For | Language Support | Agentuity Integration |
-|-----------|----------|------------------|----------------------|
-| **LangChain** | Complex chains, RAG applications | Python, TypeScript | Native SDK support |
-| **CrewAI** | Multi-agent teams, role-based systems | Python | Container deployment |
-| **AutoGen** | Research, conversational AI | Python | Direct deployment |
-| **Mastra** | TypeScript agents, workflows, modern DX | TypeScript | Full compatibility |
-| **Vercel AI SDK** | UI-integrated agents, streaming, web apps | TypeScript | Direct integration |
-| **Custom** | Specific requirements, full control | Python, TypeScript, Bun | Full platform features |
-
-### Framework Comparison Example
-
-Here's the same agent built with different approaches:
-
-<CodeExample py={`# Vanilla Python Agent
-from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    data = await request.data.json()
-    # Direct implementation
-    result = process_data(data)
-    return response.json(result)
-
-# LangChain Agent
-from langchain.agents import initialize_agent
-from langchain.llms import OpenAI
-from agentuity import AgentRequest, AgentResponse, AgentContext
+</TutorialStep>
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    llm = OpenAI()
-    agent = initialize_agent(tools, llm, agent="zero-shot")
-    result = agent.run(await request.data.text())
-    return response.text(result)
+### Step 5: Response Formats
 
-# CrewAI Agent
-from crewai import Agent, Task, Crew
-from agentuity import AgentRequest, AgentResponse, AgentContext
+<TutorialStep number={5} title="Response Formats" estimatedTime="3 min">
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    researcher = Agent(role="Researcher", goal="Find information")
-    writer = Agent(role="Writer", goal="Create content")
+Agents can return responses in various formats depending on who's calling them—JSON for APIs, HTML for browsers, text for simple integrations, or empty for webhooks.
 
-    crew = Crew(agents=[researcher, writer])
-    result = crew.kickoff(await request.data.json())
-    return response.json(result)`} js={`// Vanilla TypeScript Agent
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step5-response-formats.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step5-response-formats.py", lang: "python", title: "Python" }
+]} />
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const data = await request.data.json();
-  // Direct implementation
-  const result = processData(data);
-  return response.json(result);
-}
+**What this demonstrates:**
+- Returning JSON with `response.json()`
+- Returning text with `response.text()`
+- Returning HTML with `response.html()`
+- Returning empty response with `response.empty()`
 
-// LangChain Agent
-import { initializeAgentExecutor } from 'langchain/agents';
-import { OpenAI } from 'langchain/llms/openai';
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+**Try it:**
+1. Send `{"format": "json"}` - structured data response
+2. Send `{"format": "text"}` - plain text response
+3. Send `{"format": "html"}` - view in browser
+4. Send `{"format": "empty"}` - no response body (useful for webhooks or to handle cases where no "actual" response is needed)
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const llm = new OpenAI();
-  const agent = await initializeAgentExecutor(tools, llm, 'zero-shot');
-  const result = await agent.call({ input: await request.data.text() });
-  return response.text(result.output);
-}
-
-// Custom Multi-Agent System
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+</TutorialStep>
 
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const researcher = new Agent('Researcher', 'Find information');
-  const writer = new Agent('Writer', 'Create content');
+## Lab: Try It All Together
 
-  const researchResult = await researcher.execute(data);
-  const writeResult = await writer.execute(researchResult);
-  return response.json(writeResult);
-}`} />
+You've learned the core anatomy concepts through focused steps. Now let's see them combined in a real-world agent that uses:
+- **Multiple triggers** (cron, manual, webhook, etc.) with different behaviors
+- **External API integration** (National Weather Service)
+- **Smart caching strategies** (different TTL based on trigger)
+- **Structured logging** throughout
+- **Best practices for error handling**
 
-### When to Use Which Framework
+### What the Weather Agent Does
 
-| Framework | Use When You Need | Avoid When You Need |
-|-----------|-------------------|-------------------|
-| **LangChain** | Complex reasoning chains, RAG applications, extensive data integrations | Simple agents, minimal dependencies, lightweight solutions |
-| **CrewAI** | Multi-agent teams, role-based collaboration, specialized workflows | Single-agent tasks, simple request-response patterns |
-| **AutoGen** | Conversational AI, research applications, experimental workflows | Production deployments, strict performance requirements |
-| **Custom** | Full control, specific requirements, optimized performance | Rapid prototyping, standard use cases, extensive tooling needs |
+The weather agent demonstrates **trigger-based behavior**—the same agent code serves different purposes based on how it's triggered:
 
-## Lab: Building a Weather Agent with Multiple Triggers
+**Cron Trigger (Monitoring Mode):**
+- Runs automatically on schedule
+- Fetches weather for multiple cities
+- Caches data with 1-hour TTL
+- Returns bulk report with all cities
 
-Let's build an agent that demonstrates different behaviors based on how it's triggered - the same agent code serves different purposes depending on the trigger type.
+**Manual Trigger (On-Demand Mode):**
+- Responds to user requests
+- Fetches weather for specific location (based on user request)
+- Caches with 5-minute TTL (for quick repeat queries)
+- Returns single location result
 
 ### Key Implementation: Trigger-Based Routing
 
-The core pattern shows how agents can behave differently based on their trigger:
-
-<CodeExample py={`# Key pattern: Different behavior based on trigger type
+<CodeExample py={`# Different behavior based on trigger type
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     if request.trigger == "cron":
         # Bulk monitoring mode
@@ -634,7 +327,7 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
         # On-demand single query
         data = await request.data.json()
         location = data.get("location", "San Francisco, CA")
-        return await get_single_weather(location, context)`} js={`// Key pattern: Different behavior based on trigger type
+        return await get_single_weather(location, context)`} js={`// Different behavior based on trigger type
 export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   if (request.trigger === 'cron') {
     // Bulk monitoring mode
@@ -650,9 +343,7 @@ export default async function Agent(request: AgentRequest, response: AgentRespon
 
 ### Key Implementation: External API Integration
 
-Real-world agents integrate with external services using proper error handling:
-
-<CodeExample py={`# Key pattern: NWS API two-step process with proper error handling
+<CodeExample py={`# NWS API two-step process with proper error handling
 async def fetch_nws_weather(lat: float, lon: float, location_name: str, context: AgentContext):
     try:
         # Step 1: Get grid coordinates from lat/lon
@@ -681,8 +372,8 @@ async def fetch_nws_weather(lat: float, lon: float, location_name: str, context:
 
     except Exception as e:
         context.logger.error(f"Weather API failed for {location_name}: {e}")
-        raise`} js={`// Key pattern: NWS API two-step process with proper error handling
-async function fetchNWSWeather(lat: number, lon: number, locationName: string, context: AgentContext): Promise<WeatherResult | null> {
+        raise`} js={`// NWS API two-step process with proper error handling
+async function fetchNWSWeather(lat: number, lon: number, locationName: string, context: AgentContext): Promise<WeatherResult> {
   try {
     // Step 1: Get grid coordinates from lat/lon
     const pointsUrl = \`https://api.weather.gov/points/\${lat},\${lon}\`;
@@ -693,15 +384,15 @@ async function fetchNWSWeather(lat: number, lon: number, locationName: string, c
     });
 
     if (!pointsResponse.ok) {
-      throw new Error(\`NWS points API failed: \${pointsResponse.status} \${pointsResponse.statusText}\`);
+      throw new Error(\`NWS points API failed: \${pointsResponse.status}\`);
     }
 
     const pointsData = await pointsResponse.json() as NWSPointsResponse;
     const gridProps = pointsData.properties;
 
     // Validate and extract grid properties
-    if (!gridProps || gridProps.gridId === undefined || gridProps.gridX === undefined || gridProps.gridY === undefined) {
-      throw new Error('Could not extract grid information from NWS points API response.');
+    if (!gridProps || gridProps.gridId === undefined) {
+      throw new Error('Could not extract grid information from NWS API');
     }
 
     // Step 2: Get forecast using grid coordinates
@@ -716,9 +407,7 @@ async function fetchNWSWeather(lat: number, lon: number, locationName: string, c
 
 ### Key Implementation: Smart Caching Strategies
 
-Different caching approaches based on use case and trigger:
-
-<CodeExample py={`# Key pattern: Trigger-based caching with different TTL strategies
+<CodeExample py={`# Different caching strategies based on trigger
 async def handle_manual_trigger(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Parse location and create cache key
     location_query = await request.data.text() or "San Francisco"
@@ -731,11 +420,6 @@ async def handle_manual_trigger(request: AgentRequest, response: AgentResponse,
         context.logger.info(f"Returning cached weather for {location_query}")
         return response.json(cached_weather)
 
-    # Resolve location to coordinates (geocoding step)
-    coordinates = await geocode_location(location_query)
-    if not coordinates:
-        return response.json({"error": "Unable to find location coordinates"})
-
     # Fetch fresh data and cache with shorter TTL
     weather = await fetch_nws_weather(coordinates["lat"], coordinates["lon"], location_query, context)
     await context.kv.set("weather", cache_key, weather, {"ttl": 300})  # 5 minutes
@@ -747,7 +431,7 @@ async def handle_cron_trigger(response: AgentResponse, context: AgentContext):
     for city in MONITORED_CITIES:
         weather = await fetch_nws_weather(city["lat"], city["lon"], city["name"], context)
         await context.kv.set("weather", f"city_{city['name'].lower()}", weather, {"ttl": 3600})
-        context.logger.info(f"Cached weather for {city['name']}: {weather['temperature']}°F")`} js={`// Key pattern: Trigger-based caching with different TTL strategies
+        context.logger.info(f"Cached weather for {city['name']}: {weather['temperature']}°F")`} js={`// Different caching strategies based on trigger
 async function handleManualTrigger(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   // Parse location and create cache key
   const locationQuery = await request.data.text() || 'San Francisco';
@@ -761,12 +445,6 @@ async function handleManualTrigger(request: AgentRequest, response: AgentRespons
     return response.json(cachedWeather);
   }
 
-  // Resolve location to coordinates (geocoding step)
-  const coordinates = await geocodeLocation(locationQuery);
-  if (!coordinates) {
-    return response.json({ error: 'Unable to find location coordinates' });
-  }
-
   // Fetch fresh data and cache with shorter TTL
   const weather = await fetchNWSWeather(coordinates.lat, coordinates.lon, locationQuery, context);
   await context.kv.set('weather', cacheKey, weather, { ttl: 300 }); // 5 minutes
@@ -788,12 +466,12 @@ async function handleCronTrigger(response: AgentResponse, context: AgentContext)
 Ready to implement this agent? Follow our complete examples:
 
 <div className="flex flex-wrap gap-3 mb-6">
-  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/02-weather-agent-ts" target="_blank" rel="noopener noreferrer"
+  <a href="https://github.com/agentuity/examples/tree/main/training/02-weather-agent-ts" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     TypeScript
   </a>
-  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/02_weather_agent_py" target="_blank" rel="noopener noreferrer"
+  <a href="https://github.com/agentuity/examples/tree/main/training/02_weather_agent_py" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     Python
@@ -806,121 +484,55 @@ Ready to implement this agent? Follow our complete examples:
 - **External API integration**: Real National Weather Service API calls with proper error handling
 - **Smart caching strategies**: Different TTL based on use case (cron vs manual)
 - **Production patterns**: Timeouts, defensive typing, comprehensive logging
-- **AI enhancement**: Vercel AI SDK for weather interpretation
+- **AI enhancement**: Optional AI-powered weather interpretation
 
-The complete examples show you how to build real agents that integrate external APIs and use multiple triggers with caching and error handling.
+The complete examples show you how to build real agents that integrate external APIs and use multiple triggers with intelligent caching and error handling.
 
-## Testing Your Weather Agent
+### Testing Your Weather Agent
 
 1. **Start DevMode:**
 ```bash
 agentuity dev
 ```
 
-2. **Test the weather agent** with different city names and trigger types
-3. **Monitor the execution** in the Logs and Sessions tabs to see caching behavior
+2. **Test the weather agent** with different city names (San Francisco, New York, Los Angeles, Chicago)
+3. **Monitor the execution** in the *Logs* and *Sessions* tabs to see caching behavior
+4. **Try the same request twice** to see cache hits
 
-### Configuring Cron Triggers for Production
+#### Configuring Cron Triggers for Production
 
 For actual scheduled execution, configure cron triggers through the [Agentuity Console](https://app.agentuity.com):
 
 1. Navigate to your agent in the Console
 2. Click on **"Add Trigger"** and select **"Cron Job"**
 3. Configure the schedule using cron syntax (e.g., `0 * * * *` for hourly)
-4. Set the Content Type and optional Payload
+4. Set the *Content Type* and optional *Payload*
 5. Enable the trigger and save
 
 <Callout type="info">
 Learn more about configuring triggers in the [Agent Configuration Guide](/Cloud/agents).
 </Callout>
 
-## Performance Considerations
-
-Building efficient agents requires thinking about performance from the start:
-
-### Cost Optimization
-
-Effective cost optimization strategies include:
-
-- **Cache frequently used data** in KV storage to reduce repeated processing
-- **Batch operations** when possible to minimize API calls
-- **Use appropriate LLM models** - use reasoning models only when you need complex reasoning
-- **Consider fast inference providers** - Groq offers high-speed inference for many models
-- **Implement early exits** in reasoning loops to avoid unnecessary iterations
-
-### Latency vs. Capability Trade-offs
-
-Different approaches offer varying trade-offs between speed and intelligence:
-
-| Approach | Latency | Capability | Use Case |
-|----------|---------|------------|----------|
-| Simple rules | Fastest | Low | Basic routing, simple classification |
-| Small LLM | Fast | Medium | Text classification, simple reasoning |
-| Large LLM | Moderate | High | Complex reasoning, nuanced understanding |
-| Multi-agent | Slowest | Very High | Research, complex workflows |
-
-<CodeExample py={`from agentuity import AgentRequest, AgentResponse, AgentContext
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    data = await request.data.json()
-    complexity = assess_complexity(data)
-    
-    if complexity == "simple":
-        # Use rules-based approach
-        result = apply_rules(data)
-        return response.json(result)
-    
-    elif complexity == "medium":
-        # Use small, fast model
-        result = await small_model_process(data)
-        return response.json(result)
-    
-    else:
-        # Use full agent capabilities
-        result = await full_agent_process(data, context)
-        return response.json(result)`} js={`import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(request: AgentRequest, response: AgentResponse, context: AgentContext) {
-  const data = await request.data.json();
-  const complexity = assessComplexity(data);
-
-  if (complexity === 'simple') {
-    // Use rules-based approach
-    const result = applyRules(data);
-    return response.json(result);
-
-  } else if (complexity === 'medium') {
-    // Use small, fast model
-    const result = await smallModelProcess(data);
-    return response.json(result);
-
-  } else {
-    // Use full agent capabilities
-    const result = await fullAgentProcess(data, context);
-    return response.json(result);
-  }
-}`} />
-
 ## Key Takeaways
 
-- **Agents follow a lifecycle**: Trigger → Plan → Reason → Execute → Remember → Respond
-- **Multiple trigger types**: Choose the right trigger for your use case
-- **Context is powerful**: It provides access to all Agentuity services
-- **Frameworks are tools**: Pick the right one for your needs, or go custom
-- **Memory patterns matter**: Session data (TTL), persistent data (no TTL), searchable knowledge (Vector)
-- **Performance matters**: Balance capability with cost and latency
+- **Triggers determine behavior**: Same agent, different responses based on how it's called (webhook, cron, manual)
+- **Request handling is flexible**: SDK provides `json()`, `text()`, `binary()` methods for all formats
+- **Logging is essential**: Structured logs with appropriate levels help debugging and monitoring
+- **KV storage enables caching**: Simple `get/set` with TTL prevents redundant work
+- **Responses adapt to context**: `json()` for APIs, `html()` for browsers, `empty()` for webhooks
+- **The weather agent shows it all**: See these concepts combined in production code
 
 ## What's Next?
 
-You now understand the core components that make agents work. In the next module, we'll dive deep into memory systems - how agents remember, learn, and improve over time.
+You now understand agent anatomy—the building blocks every agent shares. In **Module 3: Agent Memory**, we'll dive deep into how agents remember, learn, and maintain state across interactions.
 
-But first, experiment with the weather agent:
-- Test it with different cities
-- Try the caching behavior with repeated requests
-- Add new cities to the cron batch update
-- Modify the cache TTL and observe the difference
+**Before moving on:**
+1. Complete all 5 tutorial steps
+2. Build and test the weather agent
+3. Experiment with different triggers and cache TTLs
+4. Review the logs to see patterns emerge
 
-Remember: The anatomy you've learned here is the foundation. The intelligence you add on top is what makes your agents unique.
+Remember: Anatomy is the foundation. The logic you add on top is what makes your agents unique.
 
 ---
 
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
index b9b99844..19889f2a 100644
--- a/content/Training/developers/03-agent-memory.mdx
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -3,11 +3,11 @@ title: "Module 3: Agent Memory"
 description: How agents remember, learn, and build context over time
 ---
 
-Without memory, an agent is just a stateless function. With memory, it becomes a system that learns, adapts, and builds relationships over time.
+Without memory, an agent is just a stateless function. With memory, it becomes a system that learns, adapts, and evolves over time.
 
 ## The Memory Challenge
 
-According to [IBM's research on AI agent memory](https://www.ibm.com/think/topics/ai-agent-memory), the biggest limitation of current LLMs is their inability to retain information between sessions. Every conversation starts from scratch, every user must re-explain their context, and every task begins without learning from the past.
+LLMs can't remember things on their own—the memory component must be added separately. [One of the biggest challenges](https://www.ibm.com/think/topics/ai-agent-memory) in AI memory design is optimizing retrieval efficiency, since storing too much data can slow down response times.
 
 As highlighted in a recent [memory management blog post](https://medium.com/@nomannayeem/building-ai-agents-that-actually-remember-a-developers-guide-to-memory-management-in-2025-062fd0be80a1):
 
@@ -27,776 +27,205 @@ For implementation details on Agentuity's storage systems, see our guides on [Ke
 
 ### Memory Types Overview
 
-Agent memory serves different purposes based on how long data needs to persist:
-
-| Memory Type | Duration | Storage | Purpose |
-|-------------|----------|---------|----------|
-| **Working Memory** | Single request | In-memory variables | Process current task |
-| **Session Memory** | Minutes to hours | KV with TTL | Maintain conversation context |
-| **Persistent Memory** | Until deleted | KV without TTL | Store user preferences, profiles |
-| **Searchable Memory** | Until deleted | Vector storage | Semantic search and retrieval |
-
-Let's explore each level:
-
-### 1. Working Memory (Request Context)
-**Lifetime**: Single request
-**Purpose**: Process current task
-**Storage**: In-memory variables
-
-```python
-# Working memory exists only during request processing
-async def run(request, response, context):
-    # These variables are working memory
-    user_intent = analyze_request(request)
-    current_plan = create_plan(user_intent)
-    execution_result = execute(current_plan)
-```
+Agent memory maps to three storage APIs, each serving different patterns:
 
-### 2. Short-term Memory (Session State)
-**Lifetime**: Minutes to hours
-**Purpose**: Maintain conversation context
-**Storage**: Key-Value with TTL
-
-```python
-# Short-term memory for session continuity
-async def run(request, response, context):
-    session_id = context.sessionId
-    
-    # Retrieve session context
-    session_data = await context.kv.get("sessions", session_id)
-    
-    if session_data.exists:
-        conversation = await session_data.data.json()
-        conversation["messages"].append(user_message)
-    else:
-        conversation = {"messages": [user_message], "started": datetime.now()}
-    
-    # Update with TTL for automatic cleanup
-    await context.kv.set("sessions", session_id, conversation, {"ttl": 3600})
-```
+| Memory Pattern | Storage API | Duration | Common Use Cases |
+|----------------|-------------|----------|------------------|
+| **Working Memory** | In-memory variables | Single request | Temporary calculations, request context |
+| **Session State** | KV with TTL | Minutes-hours | Conversation context, temporary cache |
+| **Persistent Data** | KV (no TTL) | Permanent | User profiles, preferences, settings |
+| **Knowledge Base** | Vector storage | Permanent | Semantic search, RAG, learned insights |
+| **File Storage** | Object storage | Permanent | Documents, images, media, backups |
 
-### 3. Long-term Memory (Persistent Knowledge)
-**Lifetime**: Permanent until deleted
-**Purpose**: Build user relationships and domain knowledge
-**Storage**: Vector database for semantic search
-
-```python
-from datetime import datetime
-
-# Long-term memory for learning and relationships
-async def run(request, response, context):
-    user_id = request.metadata.get("user_id")
-
-    # Store learned preferences
-    await context.vector.upsert("user_knowledge", [{
-        "key": f"pref_{user_id}_{datetime.now()}",
-        "document": "User prefers technical explanations with code examples",
-        "metadata": {
-            "user_id": user_id,
-            "confidence": 0.9,
-            "learned_from": "conversation_analysis"
-        }
-    }])
-
-    # Retrieve relevant memories
-    memories = await context.vector.search(
-        "user_knowledge",
-        f"What do I know about user {user_id}?",
-        limit=5,
-        similarity=0.7
-    )
-```
+### Storage API Quick Reference
 
-### 4. Collective Memory (Shared Knowledge)
-**Lifetime**: Permanent, shared across agents
-**Purpose**: Organizational knowledge base
-**Storage**: Vector database with access controls
-
-## Structured vs. Unstructured Memory
-
-Different types of information require different storage approaches:
-
-### Structured Memory (Key-Value Storage)
-Best for discrete, queryable data:
-- User preferences
-- Session state
-- Configuration settings
-- Counters and metrics
-
-<CodeExample py={`async def run(request, response, context):
-    user_id = request.metadata.get("user_id")
-    
-    # Store structured user profile
-    profile = {
-        "name": "Alice Smith",
-        "preferences": {
-            "language": "python",
-            "timezone": "America/New_York",
-            "communication_style": "formal"
-        },
-        "metrics": {
-            "total_interactions": 42,
-            "last_seen": datetime.now().isoformat()
-        }
-    }
-    
-    await context.kv.set("users", user_id, profile)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const userId = request.metadata.get('user_id');
-  
-  // Store structured user profile
-  const profile = {
-    name: 'Alice Smith',
-    preferences: {
-      language: 'typescript',
-      timezone: 'America/New_York',
-      communication_style: 'formal'
-    },
-    metrics: {
-      total_interactions: 42,
-      last_seen: new Date().toISOString()
-    }
-  };
-  
-  await context.kv.set('users', userId, profile);
-};`} />
-
-### Searchable Memory (Vector Storage)
-Best for semantic search and knowledge retrieval:
-- Conversation history you want to search through
-- Domain knowledge and learned information
-- User feedback and insights
-- Document content that needs to be findable
-
-<CodeExample py={`async def run(request, response, context):
-    # Store conversation for semantic retrieval
-    await context.vector.upsert("conversations", [{
-        "key": f"conv_{datetime.now().isoformat()}",
-        "document": "User asked about deploying agents in production. " +
-                   "They're concerned about costs and scaling. " +
-                   "Recommended starting with dev environment.",
-        "metadata": {
-            "user_id": user_id,
-            "topic": "deployment",
-            "sentiment": "cautious",
-            "timestamp": datetime.now().isoformat()
-        }
-    }])
-    
-    # Later, retrieve relevant context
-    similar_convos = await context.vector.search(
-        "conversations",
-        "deployment and scaling concerns",
-        limit=3
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Store conversation for semantic retrieval
-  await context.vector.upsert('conversations', {
-    key: \`conv_\${new Date().toISOString()}\`,
-    document: "User asked about deploying agents in production. " +
-              "They're concerned about costs and scaling. " +
-              "Recommended starting with dev environment.",
-    metadata: {
-      user_id: userId,
-      topic: 'deployment',
-      sentiment: 'cautious',
-      timestamp: new Date().toISOString()
-    }
-  });
-  
-  // Later, retrieve relevant context
-  const similarConvos = await context.vector.search('conversations', {
-    query: 'deployment and scaling concerns',
-    limit: 3,
-    similarity: 0.7
-  });
-};`} />
-
-### Binary Memory (Object Storage)
-Best for files and large data:
-- Generated reports
-- User uploads
-- Media files
-- Model outputs
-
-<CodeExample py={`from datetime import datetime
-import json
-
-async def run(request, response, context):
-    # Assume analysis_results and user_id are defined above
-    analysis_results = {"data": "sample analysis"}  # placeholder
-    user_id = request.metadata.get("user_id")
-
-    # Store generated report
-    report_data = generate_pdf_report(analysis_results)
-    report_key = f"reports/{user_id}/{datetime.now().strftime('%Y%m%d')}_analysis.pdf"
-
-    # Auto-detects content type from file extension and data
-    await context.objectstore.put(
-        "documents",
-        report_key,
-        report_data
-    )
-    # Note: For explicit content type, use ObjectStorePutParams class (see API reference)
-
-    # Create public URL for sharing (expires in 1 hour)
-    share_url = await context.objectstore.createPublicURL(
-        "documents",
-        report_key,
-        3600000  # milliseconds
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Assume analysisResults and userId are defined above
-  const analysisResults = { data: 'sample analysis' }; // placeholder
-  const userId = request.metadata.get('user_id');
-
-  // Store generated report
-  const reportData = generatePdfReport(analysisResults);
-  const reportKey = \`reports/\${userId}/\${new Date().toISOString().split('T')[0]}_analysis.pdf\`;
-  
-  await context.objectstore.put(
-    'documents',
-    reportKey,
-    reportData,
-    { contentType: 'application/pdf' }
-  );
-  
-  // Create public URL for sharing (expires in 1 hour)
-  const shareUrl = await context.objectstore.createPublicURL(
-    'documents',
-    reportKey,
-    3600000  // milliseconds
-  );
-};`} />
+Agentuity provides three storage APIs, each optimized for different data types:
 
-## Memory Patterns and Best Practices
+- **Key-Value (KV)**: Fast exact-match lookups. Use TTL for auto-expiring data (sessions), omit TTL for permanent storage (preferences)
+- **Vector Storage**: Semantic similarity search using embeddings. Perfect for "find relevant information" use cases
+- **Object Storage**: Binary file storage with public URL generation. For media, documents, and large files
 
-### Pattern 1: Conversation Memory with Sliding Window
+### Structured vs. Unstructured Memory
 
-Keep recent conversation context while managing memory size:
+Choose your storage API based on how you need to query and retrieve data:
 
-<CodeExample py={`async def run(request, response, context):
-    session_id = context.sessionId
-    max_messages = 20  # Keep last 20 messages
-    
-    # Get existing conversation
-    result = await context.kv.get("conversations", session_id)
-    
-    if result.exists:
-        convo = await result.data.json()
-        messages = convo["messages"]
-    else:
-        messages = []
-    
-    # Add new message
-    messages.append({
-        "role": "user",
-        "content": await request.data.text(),
-        "timestamp": datetime.now().isoformat()
-    })
-    
-    # Sliding window - keep only recent messages
-    if len(messages) > max_messages:
-        # Before removing, summarize older messages
-        summary = await summarize_messages(messages[:10])
-        await context.vector.upsert("summaries", [{
-            "key": f"{session_id}_summary_{datetime.now()}",
-            "document": summary,
-            "metadata": {"session_id": session_id}
-        }])
-        messages = messages[-max_messages:]
-    
-    # Process with context
-    agent_response = await process_with_context(messages)
-    
-    # Add agent response
-    messages.append({
-        "role": "agent",
-        "content": agent_response,
-        "timestamp": datetime.now().isoformat()
-    })
-    
-    # Save updated conversation
-    await context.kv.set("conversations", session_id, {
-        "messages": messages,
-        "updated": datetime.now().isoformat()
-    }, {"ttl": 7200})  # 2 hour TTL
-    
-    return response.json({"message": agent_response})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const sessionId = context.sessionId;
-  const maxMessages = 20; // Keep last 20 messages
-  
-  // Get existing conversation
-  const result = await context.kv.get('conversations', sessionId);
-  
-  let messages = [];
-  if (result.exists) {
-    const convo = await result.data.json();
-    messages = convo.messages;
-  }
-  
-  // Add new message
-  messages.push({
-    role: 'user',
-    content: await request.data.text(),
-    timestamp: new Date().toISOString()
-  });
-  
-  // Sliding window - keep only recent messages
-  if (messages.length > maxMessages) {
-    // Before removing, summarize older messages
-    const summary = await summarizeMessages(messages.slice(0, 10));
-    await context.vector.upsert('summaries', {
-      key: \`\${sessionId}_summary_\${new Date().toISOString()}\`,
-      document: summary,
-      metadata: { session_id: sessionId }
-    });
-    messages = messages.slice(-maxMessages);
-  }
-  
-  // Process with context
-  const agentResponse = await processWithContext(messages);
-  
-  // Add agent response
-  messages.push({
-    role: 'agent',
-    content: agentResponse,
-    timestamp: new Date().toISOString()
-  });
-  
-  // Save updated conversation
-  await context.kv.set('conversations', sessionId, {
-    messages,
-    updated: new Date().toISOString()
-  }, { ttl: 7200 }); // 2 hour TTL
-  
-  return response.json({ message: agentResponse });
-};`} />
+**Structured Memory (Key-Value Storage)**
+
+Use when you need exact-match lookups with known keys:
+- User preferences and profiles
+- Session state and temporary cache
+- Configuration settings and feature flags
+- Counters, metrics, and structured data
+
+**Unstructured Memory (Vector Storage)**
+
+Use when you need semantic search across text content:
+- Conversation history you want to search by meaning
+- Knowledge bases and documentation
+- User feedback and learned insights
+- Any content requiring "find similar" functionality
+
+**Binary Memory (Object Storage)**
+
+Use for files and large binary content:
+- User uploads and generated documents
+- Images, videos, and media files
+- Backups and archives
+- Large datasets and exports
+
+## Build Agent Memory Step-by-Step
+
+Now let's get hands-on with memory patterns. Each step below focuses on one core concept, with simple code you can run immediately in DevMode. These tutorial steps teach platform-specific SDK patterns. The lab at the end shows all three storage types working together in a real docs Q&A agent.
+
+### Step 1: Session Memory
+
+<TutorialStep number={1} title="Session Memory with KV + TTL" estimatedTime="5 min">
+
+Short-term conversation context needs automatic cleanup. Key-value storage with TTL (time-to-live) makes sessions expire automatically, preventing storage bloat.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/03-memory/step1-session-memory.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step1-session-memory.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- Using `context.sessionId` for consistent session tracking
+- Checking `result.exists` to handle new vs returning sessions
+- Setting TTL (3600 seconds = 1 hour) for automatic expiration
+- Building conversation history by appending messages
+
+**Try it:**
+1. Send a message - creates a new session
+2. Send another message - retrieves and appends to history
+3. Check back later - session data expires automatically (after 1 hour in this example; adjust as needed)
+4. Check DevMode logs to see session operations
+
+**Key insight:** TTL-based memory is perfect for temporary data like chat sessions, preventing manual cleanup and storage costs.
+
+</TutorialStep>
+
+### Step 2: Persistent Preferences
+
+<TutorialStep number={2} title="Persistent Preferences with KV" estimatedTime="4 min">
+
+User profiles and preferences should survive restarts. Omitting the TTL parameter makes data permanent until explicitly deleted.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/03-memory/step2-persistent-preferences.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step2-persistent-preferences.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- Permanent storage by omitting TTL parameter
+- Handling first-time users (create profile) vs returning users (update profile)
+- Tracking interaction counts and timestamps
+- Updating nested preference objects
+
+**Try it:**
+1. Send `{"theme": "dark", "language": "en"}` - creates profile
+2. Send `{"theme": "light"}` - updates theme, keeps language
+3. Restart DevMode - profile persists
+4. Check interaction count incrementing
+
+**Key insight:** No TTL means data persists forever, perfect for user profiles, settings, and application state.
+
+</TutorialStep>
+
+### Step 3: Basic Search
+
+<TutorialStep number={3} title="Vector Upsert & Basic Search" estimatedTime="6 min">
+
+Vector storage enables semantic search—finding information by meaning rather than keywords. Documents are converted to embeddings automatically.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/03-memory/step3-vector-basics.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step3-vector-basics.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- **TypeScript:** Upsert single object `{ key, document, metadata }`
+- **Python:** Upsert array of objects `[{ key, document, metadata }]`
+- Searching with query text, limit, and similarity threshold
+- Handling empty results gracefully
+- Similarity scores (0-1, where 1 = perfect match)
+- Cleanup by deleting demo vectors
+
+**Try it:**
+1. Run the agent with query "What is Agentuity?"
+2. See semantic matches (finds "agent-native cloud platform")
+3. Try "How does storage work?" - finds storage-related facts
+4. Notice similarity scores in results
 
-### Pattern 2: Personalization Through Learning
+**Key insight:** Vector search finds meaning, not keywords. "What is Agentuity?" matches "agent-native cloud platform" even without exact words.
 
-Build user profiles over time:
+</TutorialStep>
+
+### Step 4: Metadata Filtering
+
+<TutorialStep number={4} title="Vector Metadata Filtering" estimatedTime="5 min">
+
+Combine semantic similarity with structured filters to narrow results by category, user, status, or any metadata field.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/03-memory/step4-vector-filtering.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step4-vector-filtering.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- Adding metadata to vectors (category, price, inStock, etc.)
+- Filtering search results with `metadata` parameter
+- Metadata filters use AND logic (all conditions must match)
+- Lower similarity threshold (0.3) when using strict filters
+- Post-processing results for additional filtering
+
+**Try it:**
+1. Send `{"query": "office furniture", "category": "furniture", "inStock": true}`
+2. See only furniture items that are in stock
+3. Try `{"query": "desk accessories", "category": "electronics"}`
+4. Notice results filtered by both meaning AND category
+
+**Key insight:** Metadata filtering is exact-match, not fuzzy. Use it to combine semantic search with business rules.
 
 <Callout type="info">
 **Metadata Filtering in Vector Search**: The `metadata` parameter in vector search is used to filter results, not just for returning metadata. When you specify `metadata={"user_id": user_id}` in Python or `metadata: { user_id: userId }` in JavaScript, the search will only return vectors that match those metadata criteria. This is useful for isolating user-specific memories or filtering by any other metadata field you've stored.
 </Callout>
 
-<CodeExample py={`async def run(request, response, context):
-    user_id = request.metadata.get("user_id")
-    user_input = await request.data.text()
-    
-    # Retrieve user profile
-    profile_result = await context.kv.get("profiles", user_id)
-    
-    if profile_result.exists:
-        profile = await profile_result.data.json()
-    else:
-        profile = {
-            "interaction_count": 0,
-            "topics": {},
-            "preferences": {},
-            "created": datetime.now().isoformat()
-        }
-    
-    # Update interaction count
-    profile["interaction_count"] += 1
-    
-    # Analyze input for topics and preferences
-    analysis = await analyze_user_input(user_input)
-    
-    # Update topic frequencies
-    for topic in analysis["topics"]:
-        profile["topics"][topic] = profile["topics"].get(topic, 0) + 1
-    
-    # Store notable preferences as vectors for semantic search
-    if analysis["preferences"]:
-        for pref in analysis["preferences"]:
-            await context.vector.upsert("user_preferences", [{
-                "key": f"{user_id}_{hash(pref)}",
-                "document": pref,
-                "metadata": {
-                    "user_id": user_id,
-                    "confidence": analysis["confidence"],
-                    "learned_at": datetime.now().isoformat()
-                }
-            }])
-    
-    # Get relevant memories for this conversation
-    memories = await context.vector.search(
-        "user_preferences",
-        user_input,
-        limit=3,
-        metadata={"user_id": user_id}
-    )
-    
-    # Generate personalized response
-    response_text = await generate_response(
-        user_input,
-        profile,
-        memories
-    )
-    
-    # Save updated profile
-    await context.kv.set("profiles", user_id, profile)
-    
-    return response.json({
-        "message": response_text,
-        "personalized": True,
-        "interaction_number": profile["interaction_count"]
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const userId = request.metadata.get('user_id');
-  const userInput = await request.data.text();
-  
-  // Retrieve user profile
-  const profileResult = await context.kv.get('profiles', userId);
-  
-  let profile;
-  if (profileResult.exists) {
-    profile = await profileResult.data.json();
-  } else {
-    profile = {
-      interaction_count: 0,
-      topics: {},
-      preferences: {},
-      created: new Date().toISOString()
-    };
-  }
-  
-  // Update interaction count
-  profile.interaction_count++;
-  
-  // Analyze input for topics and preferences
-  const analysis = await analyzeUserInput(userInput);
-  
-  // Update topic frequencies
-  for (const topic of analysis.topics) {
-    profile.topics[topic] = (profile.topics[topic] || 0) + 1;
-  }
-  
-  // Store notable preferences as vectors for semantic search
-  if (analysis.preferences) {
-    for (const pref of analysis.preferences) {
-      await context.vector.upsert('user_preferences', {
-        key: \`\${userId}_\${hashString(pref)}\`,
-        document: pref,
-        metadata: {
-          user_id: userId,
-          confidence: analysis.confidence,
-          learned_at: new Date().toISOString()
-        }
-      });
-    }
-  }
-  
-  // Get relevant memories for this conversation
-  const memories = await context.vector.search('user_preferences', {
-    query: userInput,
-    limit: 3,
-    similarity: 0.7,
-    metadata: { user_id: userId }
-  });
-  
-  // Generate personalized response
-  const responseText = await generateResponse(
-    userInput,
-    profile,
-    memories
-  );
-  
-  // Save updated profile
-  await context.kv.set('profiles', userId, profile);
-  
-  return response.json({
-    message: responseText,
-    personalized: true,
-    interaction_number: profile.interaction_count
-  });
-};`} />
-
-### Pattern 3: Semantic Knowledge Base
-
-Build a searchable knowledge base from interactions:
-
-<CodeExample py={`async def run(request, response, context):
-    action = (await request.data.json()).get("action")
-    
-    if action == "learn":
-        # Extract and store knowledge
-        knowledge = await request.data.json()
-        
-        await context.vector.upsert("knowledge_base", [{
-            "key": f"fact_{datetime.now().timestamp()}",
-            "document": knowledge["fact"],
-            "metadata": {
-                "category": knowledge.get("category", "general"),
-                "source": knowledge.get("source", "user_provided"),
-                "confidence": knowledge.get("confidence", 0.8),
-                "tags": knowledge.get("tags", []),
-                "created": datetime.now().isoformat()
-            }
-        }])
-        
-        return response.json({"status": "learned", "fact": knowledge["fact"]})
-    
-    elif action == "query":
-        # Search the knowledge base
-        query = (await request.data.json())["query"]
-        
-        # Semantic search
-        results = await context.vector.search(
-            "knowledge_base",
-            query,
-            limit=10,
-            similarity=0.6
-        )
-        
-        # Format results with relevance scores
-        formatted_results = []
-        for result in results:
-            formatted_results.append({
-                "fact": result.document,
-                "relevance": result.similarity,
-                "metadata": result.metadata
-            })
-        
-        return response.json({
-            "query": query,
-            "results": formatted_results,
-            "count": len(formatted_results)
-        })
-    
-    elif action == "analyze":
-        # Analyze knowledge base patterns
-        topic = (await request.data.json()).get("topic")
-        
-        # Get all related facts
-        facts = await context.vector.search(
-            "knowledge_base",
-            topic,
-            limit=50,
-            similarity=0.5
-        )
-        
-        # Analyze patterns
-        analysis = {
-            "topic": topic,
-            "fact_count": len(facts),
-            "categories": {},
-            "confidence_avg": 0,
-            "sources": {}
-        }
-        
-        for fact in facts:
-            category = fact.metadata.get("category", "unknown")
-            analysis["categories"][category] = \
-                analysis["categories"].get(category, 0) + 1
-            
-            source = fact.metadata.get("source", "unknown")
-            analysis["sources"][source] = \
-                analysis["sources"].get(source, 0) + 1
-            
-            analysis["confidence_avg"] += fact.metadata.get("confidence", 0)
-        
-        if facts:
-            analysis["confidence_avg"] /= len(facts)
-        
-        return response.json(analysis)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const { action } = await request.data.json();
-  
-  if (action === 'learn') {
-    // Extract and store knowledge
-    const knowledge = await request.data.json();
-    
-    await context.vector.upsert('knowledge_base', {
-      key: \`fact_\${Date.now()}\`,
-      document: knowledge.fact,
-      metadata: {
-        category: knowledge.category || 'general',
-        source: knowledge.source || 'user_provided',
-        confidence: knowledge.confidence || 0.8,
-        tags: knowledge.tags || [],
-        created: new Date().toISOString()
-      }
-    });
-    
-    return response.json({ status: 'learned', fact: knowledge.fact });
-  
-  } else if (action === 'query') {
-    // Search the knowledge base
-    const { query } = await request.data.json();
-    
-    // Semantic search
-    const results = await context.vector.search('knowledge_base', {
-      query,
-      limit: 10,
-      similarity: 0.6
-    });
-    
-    // Format results with relevance scores
-    const formattedResults = results.map(result => ({
-      fact: result.document,
-      relevance: result.similarity,
-      metadata: result.metadata
-    }));
-    
-    return response.json({
-      query,
-      results: formattedResults,
-      count: formattedResults.length
-    });
-  
-  } else if (action === 'analyze') {
-    // Analyze knowledge base patterns
-    const { topic } = await request.data.json();
-    
-    // Get all related facts
-    const facts = await context.vector.search('knowledge_base', {
-      query: topic,
-      limit: 50,
-      similarity: 0.5
-    });
-    
-    // Analyze patterns
-    const analysis = {
-      topic,
-      fact_count: facts.length,
-      categories: {},
-      confidence_avg: 0,
-      sources: {}
-    };
-    
-    for (const fact of facts) {
-      const category = fact.metadata?.category || 'unknown';
-      analysis.categories[category] = (analysis.categories[category] || 0) + 1;
-      
-      const source = fact.metadata?.source || 'unknown';
-      analysis.sources[source] = (analysis.sources[source] || 0) + 1;
-      
-      analysis.confidence_avg += fact.metadata?.confidence || 0;
-    }
-    
-    if (facts.length > 0) {
-      analysis.confidence_avg /= facts.length;
-    }
-    
-    return response.json(analysis);
-  }
-};`} />
-
-## Memory Management Strategies
-
-### TTL (Time To Live) Strategies
-
-Different memory types require different retention policies:
-
-| Memory Type | Recommended TTL | Use Case |
-|------------|-----------------|----------|
-| Session state | 1-2 hours | Active conversations |
-| Daily cache | 24 hours | Frequently accessed data |
-| User preferences | No TTL | Permanent personalization |
-| Temporary results | 5-15 minutes | Computation cache |
-| Audit logs | 30-90 days | Compliance requirements |
-
-### Memory Strategy Guidelines
-
-Start with simple patterns and scale based on actual usage:
-
-- **Start small**: Begin with essential data only
-- **Monitor usage**: Track storage costs and access patterns
-- **Use appropriate TTL**: Match expiration to business needs
-- **Scale gradually**: Add memory features as you understand usage patterns
-
-Common TTL patterns:
-- Chat sessions: 1-4 hours
-- Daily summaries: 24-48 hours
-- User preferences: No TTL (permanent)
-- Temporary calculations: 5-15 minutes
-
-### Memory Cleanup Patterns
-
-Implement automated cleanup to manage costs:
-
-<CodeExample py={`async def run(request, response, context):
-    # Scheduled cleanup agent (triggered by cron)
-    if request.trigger == "cron":
-        context.logger.info("Running memory cleanup")
-        
-        # Clean expired sessions
-        # Note: KV items with TTL auto-expire, but we can proactively clean
-        
-        # Archive old conversations to object storage
-        cutoff_date = datetime.now() - timedelta(days=30)
-        
-        # In production, you'd iterate through keys with a pattern
-        # This is a simplified example
-        old_sessions = await get_old_sessions(cutoff_date)
-        
-        for session_id in old_sessions:
-            # Get conversation
-            result = await context.kv.get("conversations", session_id)
-            if result.exists:
-                convo = await result.data.json()
-                
-                # Archive to object storage (auto-detects JSON content type)
-                archive_key = f"archives/{session_id}/{cutoff_date.isoformat()}.json"
-                await context.objectstore.put(
-                    "archives",
-                    archive_key,
-                    json.dumps(convo)
-                )
-                
-                # Delete from KV
-                await context.kv.delete("conversations", session_id)
-                
-                context.logger.info(f"Archived session {session_id}")
-        
-        return response.json({
-            "task": "cleanup",
-            "archived_sessions": len(old_sessions),
-            "timestamp": datetime.now().isoformat()
-        })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Scheduled cleanup agent (triggered by cron)
-  if (request.trigger === 'cron') {
-    context.logger.info('Running memory cleanup');
-    
-    // Archive old conversations to object storage
-    const cutoffDate = new Date();
-    cutoffDate.setDate(cutoffDate.getDate() - 30);
-    
-    // In production, you'd iterate through keys with a pattern
-    // This is a simplified example
-    const oldSessions = await getOldSessions(cutoffDate);
-    
-    for (const sessionId of oldSessions) {
-      // Get conversation
-      const result = await context.kv.get('conversations', sessionId);
-      if (result.exists) {
-        const convo = await result.data.json();
-        
-        // Archive to object storage
-        const archiveKey = \`archives/\${sessionId}/\${cutoffDate.toISOString()}.json\`;
-        await context.objectstore.put(
-          'archives',
-          archiveKey,
-          JSON.stringify(convo),
-          { contentType: 'application/json' }
-        );
-        
-        // Delete from KV
-        await context.kv.delete('conversations', sessionId);
-        
-        context.logger.info(\`Archived session \${sessionId}\`);
-      }
-    }
-    
-    return response.json({
-      task: 'cleanup',
-      archived_sessions: oldSessions.length,
-      timestamp: new Date().toISOString()
-    });
-  }
-};`} />
+</TutorialStep>
+
+### Step 5: Object Storage Basics
+
+<TutorialStep number={5} title="Object Storage Basics" estimatedTime="5 min">
+
+Files and media need different storage than structured data. Object storage handles binary content and provides shareable public URLs.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/03-memory/step5-object-storage.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step5-object-storage.py", lang: "python", title: "Python" }
+]} />
 
-## Lab: Building a Docs Q&A Agent with Memory
+**What this demonstrates:**
+- Storing files with auto-detected content type (simplest approach)
+- Retrieving stored objects and checking `result.exists`
+- Creating temporary public URLs (expires in 1 hour)
+- Cleanup by deleting demo files
 
-Let's build an agent that helps users find documentation using semantic search and learns from user interactions to provide better responses over time.
+**Try it:**
+1. Send any text content
+2. See file stored, retrieved, and public URL created
+3. Access the URL in browser (works for 1 hour)
+4. Notice file is deleted after demo (cleanup pattern)
+
+**Key insight:** Public URLs expire automatically, perfect for temporary file sharing without permanent public access.
+
+</TutorialStep>
+
+## Lab: Try It All Together
+
+You've learned the core memory patterns through focused steps. Now let's see them combined in a real-world agent that uses **all three storage types together**:
+
+- **Vector storage** for semantic document search
+- **KV storage** for tracking query history and caching
+- **Object storage** for uploaded documentation files
 
 ### Key Implementation: Upload & Index Pattern
 
@@ -805,19 +234,20 @@ The core pattern shows how agents use all storage types together in a cohesive w
 <CodeExample py={`# Key pattern: Upload, store, and index documents
 async def handle_upload(request: AgentRequest, response: AgentResponse, context: AgentContext):
     file_content = await request.data.text()
-    file_name = request.metadata.get("filename", "document.txt")
+    file_name = request.get("filename", "document.txt")
 
     # 1. Store in object storage with proper UTF-8 encoding
     binary_data = file_content.encode('utf-8')
     await context.objectstore.put(OBJECT_STORAGE_BUCKET, file_name, binary_data)
 
-    # 2. Chunk and embed for search
+    # 2. Chunk and embed for search (batch upsert is more efficient)
     chunks = chunk_document(file_content, chunk_size=500)
 
+    # Build all chunk documents for batch upsert
+    chunk_docs = []
     for i, chunk in enumerate(chunks):
         chunk_id = f"{file_name}_chunk_{i}"
-        # Python vector storage uses array format
-        await context.vector.upsert(VECTOR_STORAGE_NAME, [{
+        chunk_docs.append({
             "key": chunk_id,
             "document": chunk,
             "metadata": {
@@ -825,7 +255,10 @@ async def handle_upload(request: AgentRequest, response: AgentResponse, context:
                 "chunk_index": i,
                 "uploaded_at": datetime.now().isoformat()
             }
-        }])
+        })
+
+    # Python vector storage uses array format - upsert all at once
+    await context.vector.upsert(VECTOR_STORAGE_NAME, chunk_docs)
 
     return response.json({
         "status": "indexed",
@@ -834,7 +267,7 @@ async def handle_upload(request: AgentRequest, response: AgentResponse, context:
     })`} js={`// Key pattern: Upload, store, and index documents
 async function handleUpload(request: AgentRequest, response: AgentResponse, context: AgentContext) {
   const fileContent = await request.data.text();
-  const fileName = request.metadata.get('filename') || 'document.txt';
+  const fileName = request.get('filename', 'document.txt');
 
   // 1. Store in object storage with proper UTF-8 encoding
   const binaryData = new TextEncoder().encode(fileContent);
@@ -843,19 +276,19 @@ async function handleUpload(request: AgentRequest, response: AgentResponse, cont
   // 2. Chunk and embed for search
   const chunks = chunkDocument(fileContent, 500);
 
-  for (let i = 0; i < chunks.length; i++) {
-    const chunkId = \`\${fileName}_chunk_\${i}\`;
-    // TypeScript vector storage uses single object format
-    await context.vector.upsert(VECTOR_STORAGE_NAME, {
-      key: chunkId,
-      document: chunks[i],
+  // TypeScript vector storage uses rest parameters - pass all objects at once
+  await context.vector.upsert(
+    VECTOR_STORAGE_NAME,
+    ...chunks.map((chunk, i) => ({
+      key: \`\${fileName}_chunk_\${i}\`,
+      document: chunk,
       metadata: {
         sourceFile: fileName,
         chunkIndex: i,
         uploadedAt: new Date().toISOString()
       }
-    });
-  }
+    }))
+  );
 
   return response.json({
     status: 'indexed',
@@ -1013,8 +446,7 @@ Ready to implement this agent? Follow our complete examples:
 
 The complete examples show you how to build intelligent documentation agents that get smarter over time through user interaction.
 
-
-## Testing Your Docs Q&A Agent
+### Testing Your Docs Q&A Agent
 
 1. **Start DevMode:**
 ```bash
@@ -1064,7 +496,7 @@ But first, experiment with memory patterns:
 - Create memory cleanup strategies
 - Test different TTL strategies for various use cases
 
-Remember: Memory is what transforms an agent from a tool into a partner.
+Remember: Memory is what transforms an agent from a simple tool into a useful, effective, and adaptive system.
 
 ---
 
diff --git a/content/Training/developers/04-agent-collaboration.mdx b/content/Training/developers/04-agent-collaboration.mdx
index a67e1d24..01c95458 100644
--- a/content/Training/developers/04-agent-collaboration.mdx
+++ b/content/Training/developers/04-agent-collaboration.mdx
@@ -1,5 +1,5 @@
 ---
-title: "Module 4: Agent-to-Agent Collaboration"
+title: "Module 4: Agent-to-Agent Communication"
 description: Building multi-agent systems that work together
 ---
 
@@ -19,813 +19,374 @@ Think about how human organizations work:
 
 The same principles apply to agent systems.
 
-## Industry Multi-Agent Patterns
+## Communication Methods
 
-Most production multi-agent systems follow one of two patterns:
+Agentuity provides two primary ways for agents to communicate, each suited for different scenarios:
 
-### Direct Handoff (Sequential)
-Agents pass control directly to each other, like a relay race:
-```
-Data Fetcher → Analyzer → Report Writer → User
-```
+### 1. Delegation with `response.handoff()`
 
-**Best for:** Linear workflows where each step depends on the previous one.
+Use handoff when you want to delegate control to another agent and exit. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
 
-### Orchestrator Pattern (Hub-and-Spoke)
-A central orchestrator manages and routes to specialized agents:
-```
-           ┌→ Technical Agent
-User → Orchestrator →→ Sales Agent
-           └→ Support Agent
-```
+<CodeExample js={`export default async function Agent(req, resp, ctx) {
+  // Delegate to another agent
+  return resp.handoff({ name: 'gateway-provider' });
+}`} py={`async def run(request, response, context):
+    # Delegate to another agent
+    return response.handoff({"name": "gateway-provider"})
+`} />
 
-**Best for:** Complex systems with multiple specialized agents.
+**Best for:** Sequential workflows, simple routing, task delegation
 
-## Industry Challenges vs. Agentuity's Approach
+### 2. Invocation with `context.getAgent()` and `agent.run()`
 
-According to [Microsoft's multi-agent orchestration announcements](https://www.microsoft.com/en-us/microsoft-copilot/blog/copilot-studio/multi-agent-orchestration-maker-controls-and-more-microsoft-copilot-studio-announcements-at-microsoft-build-2025/), most platforms require complex orchestration layers with state management, workflow engines, and coordination services. [AWS's multi-agent design patterns](https://aws.amazon.com/blogs/machine-learning/design-multi-agent-orchestration-with-reasoning-using-amazon-bedrock-and-open-source-frameworks/) show similar complexity, often requiring custom orchestrators and complex coordination mechanisms.
+When you need to call another agent and process its response, use a two-step pattern:
 
-### Agentuity's Approach: Multiple Communication Methods
+1. **Get the agent reference**: `await ctx.getAgent({name: 'other-agent'})`
+2. **Run and wait for response**: `await agent.run({data: 'your message'})`
 
-While other platforms build complex orchestration layers, Agentuity provides flexible agent communication options:
+<CodeExample js={`// Inside your agent's handler
+export default async function Agent(req, resp, ctx) {
+  const agent = await ctx.getAgent({ name: 'gateway-provider' });
+  const result = await agent.run({ data: 'Tell me a story' });
+  return resp.text(await result.data.text());
+}`} py={`# Inside your agent's handler
+async def run(request, response, context):
+    agent = await context.get_agent({"name": "gateway-provider"})
+    result = await agent.run("Tell me a story")
+    return response.text(await result.data.text())
+`} />
 
-**The handoff mechanism** is one approach that's simpler but focused:
-- **What it does**: Transfers control from one agent to another (like call forwarding)
-- **What it doesn't do**: Parallel execution, getting responses back, complex coordination
-- **Why it works**: Most real-world agent workflows are actually sequential or conditional
+**Best for:** Parallel execution, conditional logic, result aggregation, smart orchestration
 
-Agentuity also supports other communication patterns including parallel execution through `ctx.getAgent()` for more complex coordination when needed.
+### When to Use Each Method
 
-## Agent Communication Methods
+| Method | Use When | Control Flow | Response Handling |
+|--------|----------|--------------|-------------------|
+| **`handoff()`** | Sequential workflows, simple routing | One-way, exit current agent | Target agent responds to client |
+| **`getAgent()` + `run()`** | Parallel execution, result aggregation | Stay in control | You process responses, then respond |
 
-Agentuity provides two primary ways for agents to communicate with each other, each suited for different scenarios:
+## Build Multi-Agent Communication Step-by-Step
 
-### 1. Delegation with `response.handoff()`
+You'll learn the essential patterns for agent communication through five progressive steps.
 
-Use handoff when you want to delegate control to another agent and exit. This is like forwarding a phone call - the current agent passes control to another agent, along with any necessary data.
+### Step 1: Basic Handoff
 
-<CodeExample py={`async def run(request, response, context):
-    """Delegation example: route to specialist and exit."""
-
-    task = await request.data.json()
-
-    # Decide we need help from a specialist
-    if task.get("type") == "web_research":
-        # Delegate to web search specialist (we exit, they respond to client)
-        return response.handoff(
-            {"name": "web-search"},  # Target agent
-            task.get("query"),  # Data to pass
-            metadata={"original_task": task}  # Metadata
-        )
-
-    # Handle other task types...
-    return response.json({"result": "Task completed"})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Delegation example: route to specialist and exit
-
-  const task = await request.data.json();
-
-  // Decide we need help from a specialist
-  if (task.type === 'web_research') {
-    // Delegate to web search specialist (we exit, they respond to client)
-    return response.handoff(
-      { name: 'web-search' }, // Target agent
-      {
-        data: JSON.stringify({ query: task.query }),
-        contentType: 'application/json',
-        metadata: { original_task: task }
-      }
-    );
-  }
+<TutorialStep number={1} title="Basic Handoff" estimatedTime="3 minutes">
 
-  // Handle other task types...
-  return response.json({ result: 'Task completed' });
-};`} />
+This demonstrates the **delegation pattern** - passing control to a specialist agent when you need expertise you don't have.
 
-### 2. Request-Response with `ctx.getAgent()`
+<CodeFromFiles snippets={[
+  { path: "/examples/training/04-agent-communication/step1-basic-handoff.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/04-agent-communication/step1-basic-handoff.py", lang: "python", title: "Python" }
+]} />
 
-Use getAgent when you need to stay in control and process responses from other agents. This enables parallel execution, conditional logic, and result aggregation.
+**What this demonstrates:**
+- Using `response.handoff()` to delegate to another agent
+- Agent resolution by name
+- Clean separation of concerns (routing vs. specialist work)
 
-<CodeExample py={`import asyncio
+**Try it:**
+1. Start DevMode and trigger this agent
+2. Check the logs - notice the current agent exits after handoff
+3. The specialist agent responds directly to the client
 
-async def run(request, response, context):
-    """Request-response example: coordinate multiple agents."""
+**Key insight:** Handoff is one-way delegation. Once you hand off, your agent exits and the target agent owns the response.
 
-    query = (await request.data.json()).get("query", "")
+</TutorialStep>
 
-    # Get references to specialist agents
-    web_agent = context.get_agent("web-search")
-    news_agent = context.get_agent("news-search")
+### Step 2: Passing Data
 
-    # Execute searches in parallel and process responses
-    results = await asyncio.gather(
-        web_agent.run({"query": query, "source": "web"}),
-        news_agent.run({"query": query, "source": "news"}),
-        return_exceptions=True
-    )
+<TutorialStep number={2} title="Passing Data" estimatedTime="4 minutes">
 
-    # Process and combine results (we stay in control)
-    combined_results = []
-    for i, result in enumerate(results):
-        if not isinstance(result, Exception):
-            data = await result.data.json()
-            combined_results.append({
-                "source": ["web", "news"][i],
-                "results": data
-            })
-
-    # We respond to client with aggregated results
-    return response.json({
-        "query": query,
-        "combined_results": combined_results,
-        "total_sources": len(combined_results)
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Request-response example: coordinate multiple agents
-
-  const { query } = await request.data.json();
-
-  // Get references to specialist agents
-  const webAgent = await context.getAgent({ name: 'web-search' });
-  const newsAgent = await context.getAgent({ name: 'news-search' });
-
-  // Execute searches in parallel and process responses
-  const results = await Promise.allSettled([
-    webAgent.run({ data: JSON.stringify({ query, source: 'web' }), contentType: 'application/json' }),
-    newsAgent.run({ data: JSON.stringify({ query, source: 'news' }), contentType: 'application/json' })
-  ]);
-
-  // Process and combine results (we stay in control)
-  const combinedResults = [];
-  const sources = ['web', 'news'];
-
-  for (let i = 0; i < results.length; i++) {
-    if (results[i].status === 'fulfilled') {
-      const data = await results[i].value.data.json();
-      combinedResults.push({
-        source: sources[i],
-        results: data
-      });
-    }
-  }
+When handing off to another agent, you'll often need to pass data along. This step shows how to work with different data formats.
 
-  // We respond to client with aggregated results
-  return response.json({
-    query,
-    combined_results: combinedResults,
-    total_sources: combinedResults.length
-  });
-};`} />
+<CodeFromFiles snippets={[
+  { path: "/examples/training/04-agent-communication/step2-data-formats.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/04-agent-communication/step2-data-formats.py", lang: "python", title: "Python" }
+]} />
 
-### When to Use Each Method
+**What this demonstrates:**
+- Passing plain text with optional explicit content type
+- Passing JSON objects for structured data
+- Forwarding the original request as-is
+- Content type inference: string → text/plain, object/dict → application/json
 
-| Method | Use When | Control Flow | Response Handling | Constraints |
-|--------|----------|--------------|-------------------|-------------|
-| **`handoff`** | Sequential workflows, simple routing, delegation | One-way, exit current agent | Target agent responds to client | No response back, can't handoff to self, project isolation |
-| **`getAgent`** | Parallel execution, conditional logic, result aggregation | Stay in control | You process responses, then respond | More complex, manual coordination required |
-
-### Agent Discovery
-
-Agents can find each other using either name or ID. The context object knows about all agents in your project:
-
-<CodeExample py={`async def run(request, response, context):
-    # List all available agents
-    available_agents = context.agents
-    context.logger.info(f"Available agents: {[a.name for a in available_agents]}")
-
-    # Check if a specific agent exists before communicating
-    if any(agent.name == "summarizer" for agent in context.agents):
-        # Agent exists, safe to use either method
-
-        # Option 1: Delegate and exit
-        return response.handoff(
-            {"name": "summarizer"},
-            "Long article to summarize..."
-        )
-
-        # Option 2: Get response and stay in control
-        # summarizer = context.get_agent("summarizer")
-        # result = await summarizer.run({"text": "Long article..."})
-        # summary = await result.data.json()
-        # return response.json({"processed_summary": summary})`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // List all available agents
-  const availableAgents = context.agents;
-  context.logger.info(\`Available agents: \${availableAgents.map(a => a.name)}\`);
-
-  // Check if a specific agent exists before communicating
-  if (availableAgents.some(agent => agent.name === 'summarizer')) {
-    // Agent exists, safe to use either method
-
-    // Option 1: Delegate and exit
-    return response.handoff(
-      { name: 'summarizer' },
-      {
-        data: JSON.stringify({ text: 'Long article to summarize...' }),
-        contentType: 'application/json'
-      }
-    );
-
-    // Option 2: Get response and stay in control
-    // const summarizer = await context.getAgent({ name: 'summarizer' });
-    // const result = await summarizer.run({
-    //   data: JSON.stringify({ text: 'Long article...' }),
-    //   contentType: 'application/json'
-    // });
-    // const summary = await result.data.json();
-    // return response.json({ processed_summary: summary });
-  }
-};`} />
+**Try it:**
+1. Test each example by uncommenting different scenarios
+2. Send different data types and observe how target agents receive them
+3. Try with and without explicit `contentType` to see the inference in action
 
-## Agentuity's Built-in Features
+**Key insight:** The SDK infers content types from your data type, but you can override with explicit `contentType` when needed.
 
-Agentuity provides powerful built-in features for multi-agent systems:
+</TutorialStep>
 
-<CodeExample py={`async def run(request, response, context):
-    # Use context.sessionId for automatic request tracking
-    context.logger.info(f"Processing request {context.sessionId} in {context.agent.name}")
+### Step 3: Run and Wait
 
-    # Built-in OpenTelemetry tracing (automatic spans)
-    # Each handoff creates a new span in the trace
+<TutorialStep number={3} title="Run and Wait" estimatedTime="5 minutes">
 
-    # Use agent metadata for debugging
-    context.logger.debug(f"Agent ID: {context.agent.id}")
-    context.logger.debug(f"Project ID: {context.projectId}")
+This demonstrates the **coordinator pattern** - getting responses back from other agents so you can process results before responding.
 
-    # Track the chain of agents
-    metadata = request.metadata or {}
-    agent_chain = metadata.get("agent_chain", [])
-    agent_chain.append(context.agent.name)
+<CodeFromFiles snippets={[
+  { path: "/examples/training/04-agent-communication/step3-run-and-wait.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/04-agent-communication/step3-run-and-wait.py", lang: "python", title: "Python" }
+]} />
 
-    # Log the full chain for debugging
-    context.logger.info(f"Agent chain: {' -> '.join(agent_chain)}")
+**What this demonstrates:**
+- Using `context.getAgent()` to get a reference to another agent
+- Running the agent and waiting for its response with `agent.run()`
+- Processing the response before sending your own
+- Maintaining control throughout the invocation
 
-    return response.handoff(
-        {"name": "next-agent"},
-        processed_data,
-        {"agent_chain": agent_chain, "original_session_id": context.sessionId}
-    )`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Use context.sessionId for automatic request tracking
-  context.logger.info(\`Processing request \${context.sessionId} in \${context.agent.name}\`);
+**Try it:**
+1. Send a request with a message in the JSON body
+2. Watch the logs - you'll see both the coordinator and specialist working
+3. Notice how the coordinator processes the specialist's response before replying
 
-  // Built-in OpenTelemetry tracing (automatic spans)
-  // Each handoff creates a new span in the trace
+**Key insight:** Unlike handoff, `getAgent()` lets you stay in control, process responses, and coordinate multiple agents.
 
-  // Use agent metadata for debugging
-  context.logger.debug(\`Agent ID: \${context.agent.id}\`);
-  context.logger.debug(\`Project ID: \${context.projectId}\`);
+</TutorialStep>
 
-  // Track the chain of agents
-  const metadata = request.metadata || {};
-  const agentChain = metadata.agent_chain || [];
-  agentChain.push(context.agent.name);
+### Step 4: Parallel Execution
 
-  // Log the full chain for debugging
-  context.logger.info(\`Agent chain: \${agentChain.join(' -> ')}\`);
+<TutorialStep number={4} title="Parallel Execution" estimatedTime="5 minutes">
 
-  return response.handoff(
-    { name: 'next-agent' },
-    {
-      data: JSON.stringify(processedData),
-      contentType: 'application/json',
-      metadata: { agent_chain: agentChain, original_session_id: context.sessionId }
-    }
-  );
-};`} />
+This shows the **parallel execution pattern** - running multiple agents simultaneously and aggregating their results.
 
-## Common Communication Patterns
+<CodeFromFiles snippets={[
+  { path: "/examples/training/04-agent-communication/step4-parallel-execution.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/04-agent-communication/step4-parallel-execution.py", lang: "python", title: "Python" }
+]} />
 
-### 1. Sequential Chain Pattern
+**What this demonstrates:**
+- Getting references to multiple agents
+- Executing agents in parallel with `Promise.all` (TypeScript) or `asyncio.gather` (Python)
+- Aggregating results from multiple sources
+- Efficient coordination when agents don't depend on each other
 
-Perfect for pipelines where each agent completes its work and passes to the next. **Best approach: `handoff`** - Natural fit for one-way delegation through a pipeline.
+**Try it:**
+1. Send a search query in your request
+2. Watch the logs - both agents execute simultaneously
+3. Notice how much faster parallel execution is compared to sequential
 
-**Cleaner Agent** - processes raw data:
-<CodeExample py={`async def run(request, response, context):
-    """Data cleaner agent - first in the pipeline."""
+**Key insight:** When agents don't depend on each other's results, run them in parallel for better performance and user experience.
 
-    data = await request.data.json()
-    context.logger.info("Cleaning incoming data")
+</TutorialStep>
 
-    # Clean and validate the data
-    cleaned_data = {
-        "original": data,
-        "cleaned": True,
-        "processed_by": context.agent.name,
-        "timestamp": datetime.now().isoformat()
-    }
+### Step 5: Structured Responses for Routing
 
-    # Pass to processor agent
-    return response.handoff({"name": "processor"}, cleaned_data)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Data cleaner agent - first in the pipeline
+<TutorialStep number={5} title="Structured Responses for Routing" estimatedTime="6 minutes">
 
-  const data = await request.data.json();
-  context.logger.info('Cleaning incoming data');
+The patterns above work great when you know exactly which agent to call. But what if you need AI to decide which agent should handle a request? This requires **structured AI responses** - validated outputs that your orchestrator can trust for routing decisions.
 
-  // Clean and validate the data
-  const cleanedData = {
-    original: data,
-    cleaned: true,
-    processed_by: context.agent.name,
-    timestamp: new Date().toISOString()
-  };
+**The Challenge:**
 
-  // Pass to processor agent
-  return response.handoff({ name: 'processor' }, {
-    data: JSON.stringify(cleanedData),
-    contentType: 'application/json'
-  });
-};`} />
+Your orchestrator receives: "What's the best coffee near Moscone?"
 
-**Processor Agent** - enriches cleaned data:
-<CodeExample py={`async def run(request, response, context):
-    """Data processor agent - enriches cleaned data."""
-
-    data = await request.data.json()
-    context.logger.info("Processing cleaned data")
-
-    # Add enrichments
-    enriched_data = {
-        **data,
-        "enriched": True,
-        "enrichments": ["validation", "normalization", "metadata"],
-        "processed_by": context.agent.name
-    }
-
-    # Pass to final validator
-    return response.handoff({"name": "validator"}, enriched_data)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Data processor agent - enriches cleaned data
-
-  const data = await request.data.json();
-  context.logger.info('Processing cleaned data');
-
-  // Add enrichments
-  const enrichedData = {
-    ...data,
-    enriched: true,
-    enrichments: ['validation', 'normalization', 'metadata'],
-    processed_by: context.agent.name
-  };
-
-  // Pass to final validator
-  return response.handoff({ name: 'validator' }, {
-    data: JSON.stringify(enrichedData),
-    contentType: 'application/json'
-  });
-};`} />
+AI needs to determine: Should this go to the SF local guide or conference expert?
 
-**Validator Agent** - final validation and response:
-<CodeExample py={`async def run(request, response, context):
-    """Validator agent - final step, responds to client."""
-
-    data = await request.data.json()
-    context.logger.info("Final validation")
-
-    # Final validation and response to client
-    final_result = {
-        **data,
-        "validated": True,
-        "pipeline_complete": True,
-        "final_processor": context.agent.name,
-        "pipeline_chain": ["cleaner", "processor", "validator"]
-    }
-
-    # Respond directly to client (no further handoff)
-    return response.json(final_result)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Validator agent - final step, responds to client
-
-  const data = await request.data.json();
-  context.logger.info('Final validation');
-
-  // Final validation and response to client
-  const finalResult = {
-    ...data,
-    validated: true,
-    pipeline_complete: true,
-    final_processor: context.agent.name,
-    pipeline_chain: ['cleaner', 'processor', 'validator']
-  };
-
-  // Respond directly to client (no further handoff)
-  return response.json(finalResult);
-};`} />
+**The Solution:**
 
-### 2. Conditional Routing Pattern
-
-Route to different agents based on the request type - ideal for dispatcher/router agents. **Best approach: `handoff`** - Simple delegation based on input analysis.
-
-<CodeExample py={`async def run(request, response, context):
-    """Router pattern: Direct to appropriate specialist."""
-
-    task = await request.data.json()
-    task_type = task.get("type", "").lower()
-
-    # Route based on task type
-    agent_map = {
-        "math": "calculator-agent",
-        "translation": "translator-agent",
-        "search": "web-search",
-        "summary": "summarizer"
-    }
-
-    target_agent = agent_map.get(task_type)
-
-    if target_agent:
-        context.logger.info(f"Routing {task_type} task to {target_agent}")
-        return response.handoff(
-            {"name": target_agent},
-            task.get("payload", {})  # Pass payload directly as data
-        )
-
-    # Unknown task type
-    return response.json({
-        "error": f"Unknown task type: {task_type}",
-        "available_types": list(agent_map.keys())
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Router pattern: Direct to appropriate specialist
-
-  const task = await request.data.json();
-  const taskType = (task.type || '').toLowerCase();
-
-  // Route based on task type
-  const agentMap = {
-    math: 'calculator-agent',
-    translation: 'translator-agent',
-    search: 'web-search',
-    summary: 'summarizer'
-  };
-
-  const targetAgent = agentMap[taskType];
-
-  if (targetAgent) {
-    context.logger.info(\`Routing \${taskType} task to \${targetAgent}\`);
-    return response.handoff(
-      { name: targetAgent },
-      {
-        data: JSON.stringify(task.payload || {}),
-        contentType: 'application/json'
-      }
-    );
-  }
+Schema validation libraries ensure AI outputs match expected structures:
+- **TypeScript**: Zod schemas define and validate response structure
+- **Python**: Pydantic models provide type-safe validation
 
-  // Unknown task type
-  return response.json({
-    error: \`Unknown task type: \${taskType}\`,
-    available_types: Object.keys(agentMap)
-  });
-};`} />
+This transforms free-form AI responses into type-safe routing decisions. Instead of parsing unpredictable text, you get validated data structures that your code can reliably use.
 
-### 3. Parallel Execution Pattern
+<CodeFromFiles snippets={[
+  { path: "/examples/training/04-agent-communication/step5-structured-responses.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/04-agent-communication/step5-structured-responses.py", lang: "python", title: "Python" }
+]} />
 
-Execute multiple agents simultaneously and aggregate results. **Best approach: `getAgent`** - Requires collecting and processing responses from multiple agents.
+**What this demonstrates:**
+- Defining schemas with Zod (TypeScript) or Pydantic (Python)
+- Generating structured AI responses that match your schema
+- Validating responses to ensure type safety
+- Using confidence thresholds for smart fallback handling
+- Building reliable routing logic on validated decisions
 
-<CodeExample py={`import asyncio
+**Try it:**
+1. Send different types of requests (support questions, sales inquiries, technical issues)
+2. Watch the logs to see routing decisions with confidence scores
+3. Try ambiguous requests to see fallback handling when confidence is low
 
-async def run(request, response, context):
-    """Parallel execution example: comprehensive research."""
+**Key insight:** Structured responses transform unreliable AI outputs into type-safe data structures, essential for production multi-agent systems. This pattern is the foundation for smart orchestration.
 
-    query = (await request.data.json()).get("query", "")
+</TutorialStep>
 
-    # Get multiple specialist agents
-    web_agent = context.get_agent("web-search")
-    academic_agent = context.get_agent("academic-search")
-    news_agent = context.get_agent("news-search")
+## Lab: Conference Concierge System
 
-    # Execute all searches in parallel
-    results = await asyncio.gather(
-        web_agent.run({"query": query, "source": "web"}),
-        academic_agent.run({"query": query, "source": "academic"}),
-        news_agent.run({"query": query, "source": "news"}),
-        return_exceptions=True
-    )
+You've learned the core patterns for agent communication. Now let's see how they combine in a real-world system.
 
-    # Process and combine results
-    combined_results = []
-    sources = ["web", "academic", "news"]
-
-    for i, result in enumerate(results):
-        if not isinstance(result, Exception):
-            data = await result.data.json()
-            combined_results.append({
-                "source": sources[i],
-                "results": data.get("results", []),
-                "count": len(data.get("results", []))
-            })
-
-    # Return aggregated results
-    return response.json({
-        "query": query,
-        "research_results": combined_results,
-        "total_sources": len(combined_results),
-        "execution_pattern": "parallel"
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Parallel execution example: comprehensive research
-
-  const { query } = await request.data.json();
-
-  // Get multiple specialist agents
-  const webAgent = await context.getAgent({ name: 'web-search' });
-  const academicAgent = await context.getAgent({ name: 'academic-search' });
-  const newsAgent = await context.getAgent({ name: 'news-search' });
-
-  // Execute all searches in parallel
-  const results = await Promise.allSettled([
-    webAgent.run({ data: JSON.stringify({ query, source: 'web' }), contentType: 'application/json' }),
-    academicAgent.run({ data: JSON.stringify({ query, source: 'academic' }), contentType: 'application/json' }),
-    newsAgent.run({ data: JSON.stringify({ query, source: 'news' }), contentType: 'application/json' })
-  ]);
-
-  // Process and combine results
-  const combinedResults = [];
-  const sources = ['web', 'academic', 'news'];
-
-  for (let i = 0; i < results.length; i++) {
-    if (results[i].status === 'fulfilled') {
-      const data = await results[i].value.data.json();
-      combinedResults.push({
-        source: sources[i],
-        results: data.results || [],
-        count: (data.results || []).length
-      });
-    }
-  }
+Build a concierge system that routes user requests to different specialized agents based on AI-powered intent analysis. This demonstrates how the patterns you learned work together in production.
 
-  // Return aggregated results
-  return response.json({
-    query,
-    research_results: combinedResults,
-    total_sources: combinedResults.length,
-    execution_pattern: 'parallel'
-  });
-};`} />
+### Advanced Pattern: Smart Orchestration
+
+The tutorial steps covered handoff, data passing, run-and-wait, parallel execution, and structured responses. The Conference Concierge combines these into **smart orchestration** - dynamic decision-making that adapts based on AI analysis.
+
+Unlike simple conditional routing, smart orchestrators:
+- Analyze request complexity before routing
+- Make multi-step decisions based on intermediate results
+- Adapt routing based on confidence scores
+- Maintain conversation context across interactions
+
+Here's how it works:
+
+<CodeExample py={`# Smart orchestration example
+async def run(request, response, context):
+    user_message = await request.data.text()
+
+    # Step 1: Use AI to analyze intent with structured output
+    result = await client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        system="Analyze user intent and return structured routing decision...",
+        messages=[{"role": "user", "content": user_message}]
+    )
 
-### 4. Smart Orchestration Pattern
-
-A central agent analyzes requests, makes decisions based on responses, and orchestrates complex workflows. **Best approach: `getAgent`** - Requires response processing for intelligent decision-making.
-
-<CodeExample py={`async def run(request, response, context):
-    """Smart orchestration with decision-making."""
-
-    user_request = await request.data.json()
-    query = user_request.get("query", "")
-
-    # First, analyze the request complexity
-    analyzer = context.get_agent("complexity-analyzer")
-    analysis = await analyzer.run({"query": query})
-    analysis_data = await analysis.data.json()
-
-    # Make routing decisions based on analysis
-    if analysis_data.get("complexity") == "high":
-        # High complexity: get multiple perspectives
-        research_agent = context.get_agent("research-specialist")
-        expert_agent = context.get_agent("domain-expert")
-
-        research_result = await research_agent.run({"query": query})
-        expert_result = await expert_agent.run({"query": query})
-
-        # Combine insights for comprehensive response
-        return response.json({
-            "approach": "comprehensive",
-            "research": await research_result.data.json(),
-            "expert_opinion": await expert_result.data.json(),
-            "confidence": "high"
-        })
-
-    elif analysis_data.get("complexity") == "medium":
-        # Medium complexity: single specialist
-        specialist = context.get_agent("general-specialist")
-        result = await specialist.run({"query": query})
-
-        return response.json({
-            "approach": "specialist",
-            "result": await result.data.json(),
-            "confidence": "medium"
-        })
-
-    else:
-        # Low complexity: handle directly
-        return response.json({
-            "approach": "direct",
-            "result": f"Simple answer for: {query}",
-            "confidence": "low"
-        })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  // Smart orchestration with decision-making
-
-  const { query } = await request.data.json();
-
-  // First, analyze the request complexity
-  const analyzer = await context.getAgent({ name: 'complexity-analyzer' });
-  const analysis = await analyzer.run({
-    data: JSON.stringify({ query }),
-    contentType: 'application/json'
+    # Step 2: Validate the decision with Pydantic
+    decision_data = json.loads(result.content[0].text)
+    decision = RoutingDecision(**decision_data)
+
+    # Step 3: Make smart routing choices based on confidence
+    if decision.confidence < 0.7:
+        # Low confidence: fallback to human
+        return response.json({"message": "Let me connect you with a human..."})
+
+    # Step 4: Route to validated specialist
+    agent = await context.get_agent({"name": decision.agent_type})
+    return await agent.run(user_message)`} js={`// Smart orchestration example
+const handler = async (request, response, context) => {
+  const userMessage = await request.data.text();
+
+  // Step 1: Use AI to analyze intent with structured output
+  const { object: decision } = await generateObject({
+    model: anthropic('claude-3-5-sonnet-20241022'),
+    schema: RoutingDecisionSchema,
+    system: 'Analyze user intent and return structured routing decision...',
+    prompt: userMessage
   });
-  const analysisData = await analysis.data.json();
-
-  // Make routing decisions based on analysis
-  if (analysisData.complexity === 'high') {
-    // High complexity: get multiple perspectives
-    const researchAgent = await context.getAgent({ name: 'research-specialist' });
-    const expertAgent = await context.getAgent({ name: 'domain-expert' });
-
-    const researchResult = await researchAgent.run({
-      data: JSON.stringify({ query }),
-      contentType: 'application/json'
-    });
-    const expertResult = await expertAgent.run({
-      data: JSON.stringify({ query }),
-      contentType: 'application/json'
-    });
-
-    // Combine insights for comprehensive response
-    return response.json({
-      approach: 'comprehensive',
-      research: await researchResult.data.json(),
-      expert_opinion: await expertResult.data.json(),
-      confidence: 'high'
-    });
-
-  } else if (analysisData.complexity === 'medium') {
-    // Medium complexity: single specialist
-    const specialist = await context.getAgent({ name: 'general-specialist' });
-    const result = await specialist.run({
-      data: JSON.stringify({ query }),
-      contentType: 'application/json'
-    });
-
-    return response.json({
-      approach: 'specialist',
-      result: await result.data.json(),
-      confidence: 'medium'
-    });
-
-  } else {
-    // Low complexity: handle directly
-    return response.json({
-      approach: 'direct',
-      result: \`Simple answer for: \${query}\`,
-      confidence: 'low'
-    });
-  }
-};`} />
 
-## Lab: Build a Conference Concierge System
+  // Step 2: Decision is automatically validated by Zod
 
-Build a concierge system that routes user requests to different specialized agents using structured AI responses. This shows how agents can work together by analyzing user intent and routing to the right specialist.
+  // Step 3: Make smart routing choices based on confidence
+  if (decision.confidence < 0.7) {
+    // Low confidence: fallback to human
+    return response.json({ message: "Let me connect you with a human..." });
+  }
 
-### Key Implementation: Intent Analysis with Zod Validation
+  // Step 4: Route to validated specialist
+  const agent = await context.getAgent({ name: decision.agentType });
+  const result = await agent.run({ data: userMessage });
+  return response.text(await result.data.text());
+};`} />
 
-The core pattern shows how agents use structured AI responses to decide where to route requests:
+### Key Implementation: Intent Analysis with Validation
 
-<CodeExample py={`# Python - Intent analysis with structured output
-from pydantic import BaseModel
-from typing import Literal
+The concierge analyzes user messages to determine which specialist agent should handle them. This uses the structured response pattern from Step 5:
 
+<CodeExample py={`# Define routing schema with Pydantic
 class UserIntent(BaseModel):
     agent_type: Literal['sf_local_guide', 'conference_expert', 'dev_experience']
-    confidence: float
-
-# AI generates structured routing decision
-intent = await generate_structured_intent(user_message, schema=UserIntent)
-
-# Validated intent enables confident routing
-if intent.confidence < 0.8:
-    return response.json({
-        "message": "I'll connect you with a human specialist"
-    })
+    tags: List[str]
+    likely_intent: str
+    confidence: float = Field(ge=0.0, le=1.0)
+
+# Generate and validate routing decision
+result = await client.messages.create(
+    model="claude-3-5-sonnet-20241022",
+    system="Analyze user intent and route to appropriate agent...",
+    messages=[{"role": "user", "content": user_message}]
+)
 
-# Route to appropriate domain specialist
-agent = await context.get_agent(name=intent.agent_type)
-return await agent.run(request)`} js={`// TypeScript - Intent analysis with Zod validation
-import { z } from 'zod';
-import { generateObject } from 'ai';
+intent_data = json.loads(result.content[0].text)
+intent = UserIntent(**intent_data)  # Pydantic validates structure
 
+# Route based on validated intent
+if intent.agent_type == "sf_local_guide":
+    agent = await context.get_agent("sf-local-guide")
+    return await agent.run(user_message)`} js={`// Define routing schema with Zod
 const UserIntentSchema = z.object({
   agentType: z.enum(['sf_local_guide', 'conference_expert', 'dev_experience']),
+  tags: z.array(z.string()),
+  likelyIntent: z.string(),
   confidence: z.number().min(0).max(1)
 });
 
-// AI generates structured, validated routing decision
-const { object: userIntent } = await generateObject({
+// Generate validated routing decision
+const { object: intent } = await generateObject({
   model: anthropic('claude-3-5-sonnet-20241022'),
   schema: UserIntentSchema,
-  prompt: \`Analyze this user message and determine routing: "\${userMessage}"\`
+  system: 'Analyze user intent and route to appropriate agent...',
+  prompt: userMessage
 });
 
-// Validated intent enables confident routing
-if (userIntent.confidence < 0.8) {
-  return response.json({
-    message: "I'll connect you with a human specialist"
-  });
-}
-
-// Route to appropriate domain specialist
-const agent = await ctx.getAgent({ name: userIntent.agentType });
-return await agent.run({ data: userMessage, contentType: 'text/plain' });`} />
-
-### Key Implementation: Routing to Specialized Agents
-
-The concierge routes to different agents based on what the user needs:
-
-<CodeExample py={`# Python - Domain-specific routing with conversation memory
-from datetime import datetime
-
-# Analyze intent with structured output
-intent = await analyze_user_intent(user_message)
-
-# Store conversation context in KV storage
-session_id = request.sessionId
-await context.kv.set("conversations", session_id, {
-    "last_message": user_message,
-    "routed_to": intent.agent_type,
-    "timestamp": datetime.now().isoformat()
-}, {"ttl": 3600})  # 1 hour session memory
-
-# Route based on validated intent
-if intent.agent_type == "sf_local_guide":
-    agent = await context.get_agent(name="sf-local-guide")
-    return await agent.run(request)
-elif intent.agent_type == "conference_expert":
-    agent = await context.get_agent(name="conference-expert")
-    return await agent.run(request)
-else:
-    agent = await context.get_agent(name="dev-experience")
-    return await agent.run(request)`} js={`// TypeScript - Domain-specific routing with conversation memory
-
-// Analyze intent with structured output
-const intent = await analyzeUserIntent(userMessage);
-
-// Store conversation context in KV storage
-const sessionId = request.sessionId;
-await context.kv.set('conversations', sessionId, {
-  last_message: userMessage,
-  routed_to: intent.agentType,
-  timestamp: new Date().toISOString()
-}, { ttl: 3600 });  // 1 hour session memory
-
-// Route based on validated intent
+// Route based on validated intent (type-safe!)
 if (intent.agentType === 'sf_local_guide') {
   const agent = await context.getAgent({ name: 'sf-local-guide' });
-  return await agent.run(request);
-} else if (intent.agentType === 'conference_expert') {
-  const agent = await context.getAgent({ name: 'conference-expert' });
-  return await agent.run(request);
-} else {
-  const agent = await context.getAgent({ name: 'dev-experience' });
-  return await agent.run(request);
+  const result = await agent.run({ data: userMessage });
+  return response.text(await result.data.text());
 }`} />
 
 ### Key Implementation: Conversation Memory and Context
 
-Sophisticated orchestrators maintain conversation state across agent interactions:
-
-<CodeExample py={`# Python - Session memory and context management
-from datetime import datetime
+The concierge maintains conversation state across agent interactions using KV storage:
 
-# Retrieve existing conversation context
-existing_context = await ctx.kv.get('conversations', session_id)
+<CodeExample py={`# Retrieve existing conversation context
+existing_context = await context.kv.get('conversations', session_id)
 conversation_history = (
     await existing_context.data.json() if existing_context.exists
     else {'messages': [], 'preferences': {}}
 )
 
-# Update conversation record
+# Update conversation record with new intent
 conversation_history['messages'].append({
     'timestamp': datetime.now().isoformat(),
-    'intent': user_intent.agentType,
+    'intent': user_intent.agent_type,
     'confidence': user_intent.confidence
 })
 
-# Extract user preferences for better routing
-if user_intent.agentType == 'sf_local_guide':
+# Track user preferences for better routing
+if user_intent.agent_type == 'sf_local_guide':
     conversation_history['preferences']['location_interests'] = (
         conversation_history['preferences'].get('location_interests', 0) + 1
     )
 
-# Store updated context with TTL
-await ctx.kv.set('conversations', session_id, conversation_history, {'ttl': 3600})`} js={`// TypeScript - Session memory and context management
-
-// Retrieve existing conversation context
-const existingContext = await ctx.kv.get('conversations', sessionId);
+# Save updated context with TTL
+await context.kv.set('conversations', session_id, conversation_history, {'ttl': 3600})`} js={`// Retrieve existing conversation context
+const existingContext = await context.kv.get('conversations', sessionId);
 const conversationHistory = existingContext.exists
   ? await existingContext.data.json()
   : { messages: [], preferences: {} };
 
-// Update conversation record
+// Update conversation record with new intent
 conversationHistory.messages.push({
   timestamp: new Date().toISOString(),
   intent: userIntent.agentType,
-  confidence: userIntent.confidence,
-  context: userIntent.context
+  confidence: userIntent.confidence
 });
 
-// Extract user preferences for better routing
+// Track user preferences for better routing
 if (userIntent.agentType === 'sf_local_guide') {
   conversationHistory.preferences.location_interests =
     (conversationHistory.preferences.location_interests || 0) + 1;
 }
 
-// Store updated context with TTL
-await ctx.kv.set('conversations', sessionId, conversationHistory, { ttl: 3600 });`} />
+// Save updated context with TTL
+await context.kv.set('conversations', sessionId, conversationHistory, { ttl: 3600 });`} />
 
 ### Build This Project Yourself
 
-Ready to implement this project? Follow our complete examples:
+Ready to implement this project? You'll need multiple specialized agents for the concierge system.
+
+**Setting up your multi-agent project:**
+
+1. Create agents using the CLI:
+   ```bash
+   agentuity agent create
+   ```
+   Run this command once for each specialist agent (concierge, sf-local-guide, conference-expert, etc.).
+
+2. Follow the complete examples below:
+
 <div className="flex flex-wrap gap-3 mb-6">
   <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/04-concierge-ts" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
@@ -838,40 +399,62 @@ Ready to implement this project? Follow our complete examples:
   </div>
 </div>
 
+<Callout type="warning">
+Always use CLI commands to manage agents. Use `agentuity agent delete` to remove agents. Never manually edit agent directories to avoid potential issues.
+</Callout>
+
 ### What This System Demonstrates
 
 - **Structured AI responses**: Zod and Pydantic schemas ensure reliable routing decisions
 - **Agent specialization**: Different agents handle SF questions, conference info, and developer support
-- **Conversation memory**: KV storage keeps track of context across agent interactions
+- **Conversation memory**: KV storage maintains context across agent interactions
 - **Practical patterns**: Confidence thresholds, fallback handling, and session management
-- **Intent-based routing**: AI analyzes user messages to figure out which agent can help
+- **Intent-based routing**: AI analyzes user messages to determine which agent can help best
+
+The complete example shows how to build agent coordination systems that intelligently route users to the right specialists based on validated AI analysis.
 
-The complete examples show how to build agent coordination systems that route users to the right specialists based on AI analysis.
+### Testing Your Multi-Agent System
 
-## Testing Your Conference Concierge
+Testing multi-agent systems requires understanding the flow across multiple agents.
 
-1. **Start DevMode:**
+**Start DevMode:**
 ```bash
 agentuity dev
 ```
 
-2. **Test different intents:**
-   - **Local questions**: "Where's the best coffee near Moscone Center?"
-   - **Conference questions**: "What time does the keynote start?"
-   - **Developer questions**: "How do I implement agent handoffs?"
+**Key testing scenarios:**
+1. **Test handoff flow** - Verify the correct specialist handles requests
+2. **Test parallel execution** - Check that multiple agents run concurrently
+3. **Test error scenarios** - Reference non-existent agents or send malformed data
+
+**Monitoring agent communication:**
+- Filter logs by agent ID to track individual agents
+- Filter by environment (Local/Cloud/Both) to see where requests are processed
+- Follow trace spans to see the full request flow across agents
+
+<Callout type="info">
+For detailed logging capabilities and advanced filtering options, see the [Agent Logging Guide](/Guides/agent-logging).
+</Callout>
+
+### Deploy Your Multi-Agent System
+
+Once your multi-agent system is built, deploy it to production:
+
+```bash
+agentuity deploy
+```
 
-3. **Watch the routing in action:**
-   - Check logs to see intent analysis and confidence scores
-   - See how conversation context helps routing get better over time
-   - Test edge cases where confidence is too low
+The deploy process is identical to single-agent projects. All agents are deployed together and can immediately communicate with each other.
 
 ## Key Takeaways
 
-- **Multi-agent systems** enable specialization, scalability, and modularity
-- **Handoff mechanism** allows agents to delegate tasks in a simple, sequential manner
-- **Orchestration patterns** include sequential chains, conditional routing, and smart orchestration
-- **Constraints matter**: Handoffs are one-way, agents can't call themselves, and responses go directly to clients
-- **Agentuity simplifies** multi-agent coordination with built-in agent resolution and communication
+- **Multi-agent systems** enable specialization, scalability, and modularity through coordinated agents
+- **Handoff** (`response.handoff()`) delegates control for sequential workflows and simple routing
+- **Invocation** (`context.getAgent()` + `agent.run()`) lets you call agents and process their responses
+- **Parallel execution** runs multiple agent invocations concurrently for better performance
+- **Structured responses** transform unreliable AI outputs into type-safe routing decisions
+- **Smart orchestration** combines these patterns with AI analysis for dynamic, adaptive workflows
+- **Agentuity simplifies** multi-agent coordination with built-in agent resolution, communication, and tracing
 
 ## What's Next?
 
@@ -880,6 +463,6 @@ Now that you can build multi-agent systems, Module 5 will cover **Observability,
 Questions to consider:
 - How do you prevent agents from taking harmful actions?
 - How do you track what decisions agents are making?
-- How do you ensure compliance and audit requirements?
+- How do you ensure compliance and other (general) requirements?
 
 Continue to [Module 5: Observability, Guardrails, & Evals →](./05-observability-guardrails-evals)
diff --git a/content/Training/developers/05-observability-guardrails-evals.mdx b/content/Training/developers/05-observability-guardrails-evals.mdx
index db1348cc..68257e70 100644
--- a/content/Training/developers/05-observability-guardrails-evals.mdx
+++ b/content/Training/developers/05-observability-guardrails-evals.mdx
@@ -1,9 +1,9 @@
 ---
 title: "Module 5: Observability, Guardrails, & Evals"
-description: Making agents reliable, safe, and production-ready
+description: Making agents reliable, safe, and ready for real-world use
 ---
 
-You've built agents that can think, remember, and collaborate. Now it's time to make them production-ready.
+You've built agents that can think, remember, and collaborate. Now it's time to make them reliable and safe.
 
 ## The Reality of Production Agents
 
@@ -17,30 +17,27 @@ According to [NIST's AI Risk Management framework](https://www.nist.gov/itl/ai-r
 
 ## The Three Pillars of Production Agents
 
-<Callout type="info">
-Agentuity provides built-in OpenTelemetry integration with automatic instrumentation, giving you comprehensive observability out of the box.
-</Callout>
-
 ### 1. Observability: Seeing Everything
 
-Agentuity's key advantage is automatic OpenTelemetry integration with zero configuration:
-
-- **What's Tracked**: LLM calls, tool invocations, storage operations, API calls
-- **Observability Triad**: Logs (events), Metrics (measurements), Traces (request flow)
-- **Console View**: Timeline visualization with color-coded spans
-- **Zero Setup**: Works out of the box - no instrumentation code required
+<Callout type="info">
+**Automatic Observability**: Agentuity provides built-in OpenTelemetry integration with zero configuration. All agent executions, LLM calls, storage operations, and API calls are tracked automatically and appear in the Sessions tab with color-coded timeline visualization.
+</Callout>
 
 ### 2. Guardrails: Setting Boundaries
 
 Guardrails prevent agents from harmful actions while preserving autonomy and ensuring they stay in line with what they're supposed to do:
 
-- **Input Validation**: Schema enforcement, content filtering, size limits
+- **Input Validation**: Schema enforcement with Zod (TypeScript) and Pydantic (Python) for runtime validation
 - **Rate Limiting**: Prevent abuse and control costs per user/session
 - **Security**: Prompt injection defense ([WASP](https://arxiv.org/abs/2407.01593)), tool permissions
 - **Domain Rules**: Compliance checks, output validation, custom constraints
 
 ### 3. Evaluation: Measuring Success
 
+<Callout type="info">
+Agentuity's upcoming *prompts and evaluations suite* will provide built-in prompt management and evaluation workflows.
+</Callout>
+
 Systematic evaluation is critical for non-deterministic agents:
 
 - **Real-World Benchmarks**: [τ-Bench](https://sierra.ai/blog/benchmarking-ai-agents) (dynamic agent interactions), [TheAgentCompany](https://metadesignsolutions.com/benchmarking-ai-agents-in-2025-top-tools-metrics-performance-testing-strategies/) (multi-step professional tasks)
@@ -48,139 +45,112 @@ Systematic evaluation is critical for non-deterministic agents:
 - **Production Metrics**: Success rates, latency, cost per request, goal completion rates
 - **A/B Testing**: Shadow deployments, gradual rollouts, real user feedback
 
-## Observability with OpenTelemetry
+## Build A Safe and Reliable Agent Step-by-Step
 
-Agentuity automatically tracks everything through OpenTelemetry:
+Let's implement the essential observability and validation patterns that make agents reliable at scale.
 
-### What's Tracked (No Code Required)
-- **Agent executions**: Full request/response lifecycle
-- **LLM calls**: Prompts, completions, token usage, latency
-- **Storage operations**: KV gets/sets, vector searches
-- **API calls**: External HTTP requests
+<TutorialStep number={1} title="Child Loggers" estimatedTime="4 min">
 
-View in the Agentuity console Sessions tab with color-coded timeline visualization.
+When debugging agents, you need context in every log entry. Child loggers let you attach metadata once, then all subsequent logs automatically include that context.
 
-### Using the Logger
+<CodeFromFiles snippets={[
+  { path: "/examples/training/05-observability-guardrails/step1-child-loggers.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/05-observability-guardrails/step1-child-loggers.py", lang: "python", title: "Python" }
+]} />
 
-<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Extract data from request
-    data = await request.data.json()
-    user_id = request.metadata.get("user_id")
+**What this demonstrates:**
+- TypeScript: Creating child loggers with `context.logger.child({ key: value })`
+- Python: Manual context pattern (child() method coming soon)
+- How context appears in logs/metadata for easier debugging
+- Consistent tracking throughout request lifecycle
 
-    # Logs appear in Sessions view with trace context
-    context.logger.info("Processing", {"user_id": user_id})
+**Try it:**
+1. Send a request with `userId` and `query` fields
+2. Check logs in DevMode - notice how context appears in every log entry
+3. Python users: Observe the manual context pattern with structured logging
 
-    try:
-        result = await process(data)
-        context.logger.info("Success", {"count": len(result)})
-    except Exception as e:
-        context.logger.error("Failed", {"error": str(e)})
-        raise`} js={`const handler = async (request, response, context) => {
-  // Extract data from request
-  const data = await request.data.json();
-  const userId = request.metadata.get('user_id');
-
-  // Logs appear in Sessions view with trace context
-  context.logger.info('Processing', { userId });
-
-  try {
-    const result = await process(data);
-    context.logger.info('Success', { count: result.length });
-  } catch (error) {
-    context.logger.error('Failed', { error: error.message });
-    throw error;
-  }
-};`} />
+</TutorialStep>
 
-### Custom Spans for Your Own Operations
+<TutorialStep number={2} title="Input Validation" estimatedTime="5 min">
 
-Track important operations with custom spans to understand performance and debug issues:
+Runtime validation protects your agent from malformed requests. TypeScript types and Python type hints only exist at development time - at runtime, your data needs actual validation.
 
-<CodeExample py={`from opentelemetry.trace import Status, StatusCode
+<CodeFromFiles snippets={[
+  { path: "/examples/training/05-observability-guardrails/step2-input-validation.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/05-observability-guardrails/step2-input-validation.py", lang: "python", title: "Python" }
+]} />
 
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    payload = await request.data.json()
-    query = payload.get("query", "")
+**What this demonstrates:**
+- Why runtime validation matters (types alone aren't enough)
+- Zod's `safeParse()` pattern for safe validation (TypeScript)
+- Pydantic's try/except ValidationError pattern (Python)
+- Clear error messages for invalid input
+- Type-safe data access after validation
 
-    # Create a span for the entire validation flow
-    async with context.tracer.start_as_current_span("validate-financial-query") as span:
-        # Add context about this operation
-        span.set_attribute("user.tier", "premium")
-        span.set_attribute("query.type", "retirement")
-        span.set_attribute("query.length", len(query))
+**Try it:**
+1. Send valid request: `{"query": "test", "userId": "123"}`
+2. Send invalid data (missing field): `{"query": "test"}`
+3. Send wrong type: `{"query": 123, "userId": "123"}`
+4. Check logs to see validation failures tracked
 
-        try:
-            # Track validation steps
-            span.add_event("validation-started")
+</TutorialStep>
 
-            if has_prohibited_terms(query):
-                span.add_event("validation-failed", {"reason": "prohibited-terms"})
-                span.set_status(Status(StatusCode.ERROR, "Prohibited terms detected"))
-                return response.json({"error": "Invalid query"})
+<TutorialStep number={3} title="AI Output Validation" estimatedTime="5 min">
 
-            span.add_event("validation-passed")
+AI models are non-deterministic, but your downstream code needs reliable structure. Validation schemas ensure AI responses always match your expected format.
 
-            # Track LLM call separately
-            async with context.tracer.start_as_current_span("generate-advice") as llm_span:
-                llm_span.set_attribute("model", "gpt-4")
-                advice = await generate_advice(query)
-                llm_span.set_attribute("response.tokens", count_tokens(advice))
+<CodeFromFiles snippets={[
+  { path: "/examples/training/05-observability-guardrails/step3-ai-output-validation.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/05-observability-guardrails/step3-ai-output-validation.py", lang: "python", title: "Python" }
+]} />
 
-            span.set_status(Status(StatusCode.OK))
-            return response.json({"advice": advice})
+**What this demonstrates:**
+- Using schemas with `generateObject()` from Vercel AI SDK (TypeScript)
+- Using Pydantic with Anthropic structured output (Python)
+- Guaranteed type-safe AI responses
+- Graceful handling if AI returns invalid structure
+- Logging validated results
 
-        except Exception as e:
-            span.record_exception(e)
-            span.set_status(Status(StatusCode.ERROR, str(e)))
-            raise`} js={`import { SpanStatusCode } from '@opentelemetry/api';
+**Try it:**
+1. Send a query: `{"query": "This is amazing!"}`
+2. See structured sentiment analysis guaranteed to match schema
+3. Try different queries (positive, negative, neutral)
+4. Notice how validation prevents downstream errors
 
-const handler = async (request, response, context) => {
-  const { query = '' } = await request.data.json();
-
-  // Create a span for the entire validation flow
-  return context.tracer.startActiveSpan('validate-financial-query', async (span) => {
-    // Add context about this operation
-    span.setAttribute('user.tier', 'premium');
-    span.setAttribute('query.type', 'retirement');
-    span.setAttribute('query.length', query.length);
-
-    try {
-      // Track validation steps
-      span.addEvent('validation-started');
-
-      if (hasProhibitedTerms(query)) {
-        span.addEvent('validation-failed', { reason: 'prohibited-terms' });
-        span.setStatus({ code: SpanStatusCode.ERROR, message: 'Prohibited terms detected' });
-        return response.json({ error: 'Invalid query' });
-      }
-
-      span.addEvent('validation-passed');
-
-      // Track LLM call separately
-      const advice = await context.tracer.startActiveSpan('generate-advice', async (llmSpan) => {
-        llmSpan.setAttribute('model', 'gpt-4');
-        const result = await generateAdvice(query);
-        llmSpan.setAttribute('response.tokens', countTokens(result));
-        llmSpan.end();
-        return result;
-      });
-
-      span.setStatus({ code: SpanStatusCode.OK });
-      return response.json({ advice });
-
-    } catch (error) {
-      span.recordException(error);
-      span.setStatus({ code: SpanStatusCode.ERROR, message: error.message });
-      throw error;
-    } finally {
-      span.end();
-    }
-  });
-};`} />
+</TutorialStep>
+
+<TutorialStep number={4} title="Custom Spans for Performance" estimatedTime="6 min">
+
+Agentuity automatically traces LLM calls and storage operations, but you can also track your own business logic with custom spans. This helps identify performance bottlenecks and debug complex workflows.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/05-observability-guardrails/step4-custom-spans.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/05-observability-guardrails/step4-custom-spans.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- Creating spans for operations with `context.tracer`
+- Setting attributes for filtering and analysis
+- Adding events to mark milestones
+- Error handling with `recordException()` and `setStatus()`
+- Viewing execution flow in Sessions timeline
+
+**Try it:**
+1. Send plain text: `"Testing tracing"`
+2. Send JSON: `{"user": "alice", "action": "purchase"}`
+3. Open DevMode Sessions tab - see the span timeline
+4. Check span attributes and events
+5. Notice how different content types create different attributes
+
+</TutorialStep>
+
+## Advanced Patterns
+
+The tutorial steps covered the core observability and validation concepts. Here are some additional patterns for complex real-world scenarios.
 
 ### Performance Best Practices
 
-Follow these optimization patterns to ensure your agents run efficiently in production:
+Follow these optimization patterns to ensure your agents run efficiently:
 
 | Strategy | Implementation |
 |----------|---------------|
@@ -190,34 +160,11 @@ Follow these optimization patterns to ensure your agents run efficiently in prod
 | **Track token usage** | Add token counts as span attributes to monitor costs |
 | **Set meaningful attributes** | Include user tier, request type, and other context for filtering |
 
-### What You Get Out of the Box
-
-<Callout type="info">
-**Built-in Observability**: Agentuity provides automatic OpenTelemetry instrumentation with zero configuration required.
-</Callout>
-
-Everything is tracked automatically:
-- **LLM calls**: Model, tokens, latency, and responses
-- **Storage operations**: Every KV get/set, vector search, object store operation
-- **API calls**: External service interactions and latencies
-- **Custom spans**: Your business logic with meaningful attributes
-- **Visual debugging**: Color-coded timeline in the console shows execution flow
-
-<Callout type="info">
-See the [Agent Telemetry Guide](/Guides/agent-telemetry) for advanced tracing and custom spans.
-</Callout>
-
-## Implementing Guardrails
-
-Let's implement essential guardrails for production agent systems, using patterns from our Conference Concierge system:
-
-### 1. Schema Validation with Zod & Pydantic
-
-Runtime validation is critical for agents. TypeScript and Python types only exist at development time - at runtime, your data needs validation.
+### Combining Validation with Content Moderation
 
-**Zod** (TypeScript) and **Pydantic** (Python) are popular validation libraries in their respective ecosystems. Zod provides TypeScript-first schema validation with static type inference, while Pydantic offers high-performance validation for Python with type hints integration. Both solve the same problem: ensuring runtime data matches your type expectations.
+Sometimes you need both structural validation *and* content policy checks. This pattern combines schema validation (from Step 2) with an LLM-based content moderator - useful for applications like financial advisors, healthcare chatbots, or any domain with compliance requirements.
 
-For detailed API references, see the [Zod](https://zod.dev) and [Pydantic](https://docs.pydantic.dev/latest/) documentation.
+The key idea: validate structure first, then use an LLM to evaluate content appropriateness before processing:
 
 <CodeExample py={`from datetime import datetime
 from pydantic import BaseModel, Field, ValidationError
@@ -376,14 +323,11 @@ async function evaluateWithJury(query: string, context): Promise<ContentEvaluati
   return evaluation.object;
 };`} />
 
-<Callout type="info">
-**Key Pattern**: Separate validation from domain rules. Schemas validate structure, your specific rules come after.
-</Callout>
-
+### Validating External API Responses
 
-#### Real-World Example: Validating External API Responses
+When working with external APIs, defensive validation prevents downstream errors from malformed or unexpected data. This pattern is demonstrated in the [AI News Digest cron demo](https://github.com/agentuity/examples/tree/add-tutorials/tutorials/03-cron-demo) - a scheduled agent that fetches tech news every 5 minutes.
 
-Here's how the AI News Digest agent validates Hacker News API responses:
+Here's how it validates Hacker News API responses before processing:
 
 <CodeExample py={`from datetime import datetime
 from pydantic import BaseModel, ValidationError
@@ -415,7 +359,7 @@ async def fetch_top_stories(ctx, count=5):
             story = HNStory(**raw_data)
             stories.append(story.title)
         except ValidationError as e:
-            ctx.logger.warn(f"Invalid story data for ID {story_id}: {e}")
+            ctx.logger.warning(f"Invalid story data for ID {story_id}: {e}")
             continue  # Skip invalid stories
     
     return stories
@@ -507,282 +451,7 @@ const handler = async (request, response, context) => {
   return response.json(digestResult.data);
 };`} />
 
-#### Using Schemas with AI-Generated Output
-
-Schemas ensure structured output from AI models:
-
-<CodeExample py={`from pydantic import BaseModel
-from typing import Literal
-from ai import generate_object
-from anthropic import anthropic
-
-class AgentIntent(BaseModel):
-    agent_type: Literal['support', 'sales', 'technical']
-    confidence: float  # 0.0 to 1.0
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    user_message = await request.data.text()
-    
-    # AI generates structured, validated output
-    intent = await generate_object(
-        model=anthropic("claude-3-7-sonnet"),
-        schema=AgentIntent,  # Pydantic ensures structure
-        prompt=user_message
-    )
-    
-    # intent.object is validated and typed
-    if intent.object.confidence > 0.8:
-        agent = await context.get_agent(name=intent.object.agent_type)
-        return await agent.run(request)`} js={`import { z } from 'zod';
-import { generateObject } from 'ai';
-import { anthropic } from '@ai-sdk/anthropic';
-
-const IntentSchema = z.object({
-  agentType: z.enum(['support', 'sales', 'technical']),
-  confidence: z.number().min(0).max(1)
-});
-
-const handler = async (request, response, context) => {
-  const userMessage = await request.data.text();
-  
-  // AI generates structured, validated output
-  const intent = await generateObject({
-    model: anthropic('claude-3-7-sonnet'),
-    schema: IntentSchema,  // Zod ensures structure
-    prompt: userMessage
-  });
-  
-  // intent.object is validated and typed
-  if (intent.object.confidence > 0.8) {
-    const agent = await context.getAgent({ name: intent.object.agentType });
-    return await agent.run(request);
-  }
-};`} />
-
-### 3. Orchestrators as Natural Guardrails
-
-Remember the orchestrator pattern from Module 4? Orchestrators are your first line of defense:
-
-<CodeExample py={`from pydantic import BaseModel
-from typing import Literal
-
-class ValidatedIntent(BaseModel):
-    category: Literal['technical', 'sales', 'support']
-    confidence: float
-    sensitive: bool = False
-    
-async def orchestrator_with_guardrails(request, response, context):
-    user_prompt = await request.data.text()
-    
-    # 1. Input validation
-    if len(user_prompt) > 1000:
-        return response.json({"error": "Request too long"})
-    
-    # 2. Analyze intent with validation
-    intent = await analyze_intent(user_prompt, schema=ValidatedIntent)
-    
-    # 3. Apply routing rules
-    if intent.sensitive:
-        # Route sensitive requests to specialized agent
-        return response.handoff(
-            {"name": "compliance-agent"},
-            user_prompt,
-            metadata={"flagged": True}
-        )
-    
-    if intent.confidence < 0.7:
-        # Low confidence = fallback to human
-        return response.json({
-            "message": "I'll connect you with a specialist",
-            "transfer": "human"
-        })
-    
-    # 4. Route to appropriate agent
-    agent_map = {
-        "technical": "tech-expert",
-        "sales": "sales-agent",
-        "support": "support-agent"
-    }
-    
-    return response.handoff(
-        {"name": agent_map[intent.category]},
-        user_prompt
-    )`} js={`import { z } from 'zod';
-
-const ValidatedIntentSchema = z.object({
-  category: z.enum(['technical', 'sales', 'support']),
-  confidence: z.number(),
-  sensitive: z.boolean().default(false)
-});
-
-const orchestratorWithGuardrails = async (request, response, context) => {
-  const userPrompt = await request.data.text();
-  
-  // 1. Input validation
-  if (userPrompt.length > 1000) {
-    return response.json({ error: 'Request too long' });
-  }
-  
-  // 2. Analyze intent with validation
-  const { object: intent } = await analyzeIntent(userPrompt, {
-    schema: ValidatedIntentSchema
-  });
-  
-  // 3. Apply routing rules
-  if (intent.sensitive) {
-    // Route sensitive requests to specialized agent
-    return response.handoff(
-      { name: 'compliance-agent' },
-      { 
-        data: JSON.stringify({ query: userPrompt, flagged: true }),
-        contentType: 'application/json'
-      }
-    );
-  }
-  
-  if (intent.confidence < 0.7) {
-    // Low confidence = fallback to human
-    return response.json({
-      message: "I'll connect you with a specialist",
-      transfer: 'human'
-    });
-  }
-  
-  // 4. Route to appropriate agent
-  const agentMap = {
-    technical: 'tech-expert',
-    sales: 'sales-agent',
-    support: 'support-agent'
-  };
-  
-  return response.handoff(
-    { name: agentMap[intent.category] },
-    { data: userPrompt, contentType: 'text/plain' }
-  );
-};`} />
-
-**Why Orchestrators Make Great Guardrails:**
-1. **Single validation point** - Check all inputs before routing
-2. **Access control** - Decide who can access which agents
-3. **Fallback handling** - Gracefully handle edge cases
-4. **Audit trail** - Log all routing decisions
-5. **Rate limiting** - Apply per-user limits before delegation
-
-<Callout type="info">
-See the complete [Conference Concierge implementation](https://github.com/agentuity/agent-AIEWF2025-concierge-template) for a production example of multi-agent routing with schema validation.
-</Callout>
-
-### 2. Rate Limiting
-
-Prevent abuse and control costs:
-
-<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    from datetime import datetime
-
-    user_id = request.metadata.get("user_id")
-    hour_key = f"rate_{user_id}_{datetime.now().hour}"
-    
-    # Check current usage
-    usage = await context.kv.get("rate_limits", hour_key)
-    count = await usage.data.json() if usage.exists else 0
-    
-    if count >= 100:  # 100 requests per hour
-        return response.json({
-            "error": "Rate limit exceeded",
-            "retry_after": 3600
-        })
-    
-    # Increment counter with TTL
-    await context.kv.set("rate_limits", hour_key, count + 1, {"ttl": 3600})
-    
-    # Process request
-    return await handle_request(request)`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const userId = request.metadata.get('user_id');
-  const hourKey = 'rate_' + userId + '_' + new Date().getHours();
-  
-  // Check current usage
-  const usage = await context.kv.get('rate_limits', hourKey);
-  const count = usage.exists ? await usage.data.json() : 0;
-  
-  if (count >= 100) {  // 100 requests per hour
-    return response.json({
-      error: 'Rate limit exceeded',
-      retry_after: 3600
-    });
-  }
-  
-  // Increment counter with TTL
-  await context.kv.set('rate_limits', hourKey, count + 1, { ttl: 3600 });
-  
-  // Process request
-  return await handleRequest(request);
-};`} />
-
-### 4. Domain-Specific Rules
-
-Enforce rules specific to your use case:
-
-<CodeExample py={`async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    query = (await request.data.json()).get("query", "")
-
-    # Domain-specific validation rules
-    inappropriate_requests = ["hack", "illegal", "private information"]
-    for term in inappropriate_requests:
-        if term in query.lower():
-            return response.json({
-                "error": "Cannot assist with inappropriate requests",
-                "reason": f"Request contains prohibited content: '{term}'"
-            })
-
-    # Length validation
-    if len(query) > 1000:
-        return response.json({
-            "error": "Query too long",
-            "max_length": 1000
-        })
-
-    # Process valid request
-    result = await process_query(query, context)
-
-    return response.json({
-        "response": result,
-        "processed_by": context.agent.name
-    })`} js={`const handler: AgentHandler = async (request, response, context) => {
-  const { query } = await request.data.json();
-
-  // Domain-specific validation rules
-  const inappropriateRequests = ['hack', 'illegal', 'private information'];
-  for (const term of inappropriateRequests) {
-    if (query.toLowerCase().includes(term)) {
-      return response.json({
-        error: 'Cannot assist with inappropriate requests',
-        reason: \`Request contains prohibited content: '\${term}'\`
-      });
-    }
-  }
-
-  // Length validation
-  if (query.length > 1000) {
-    return response.json({
-      error: 'Query too long',
-      maxLength: 1000
-    });
-  }
-
-  // Process valid request
-  const result = await processQuery(query, context);
-
-  return response.json({
-    response: result,
-    processedBy: context.agent.name
-  });
-};`} />
-
-## Evaluation Strategies
-
-<Callout type="info">
-**Coming Soon**: Agentuity's integrated prompt library and automated evaluation suite will provide built-in prompt management and continuous evaluation workflows.
-</Callout>
+The full cron demo agent combines this validation pattern with scheduled execution, AI-powered summarization, and KV storage. Check out the [complete implementation](https://github.com/agentuity/examples/tree/add-tutorials/tutorials/03-cron-demo) to see how all the concepts from this module work together.
 
 ### Define Success Metrics
 
@@ -797,305 +466,19 @@ Choose metrics that matter for your domain:
 
 ### Build a Golden Dataset
 
-Create test cases that cover your critical scenarios:
-
-<CodeExample py={`# Golden dataset for concierge testing
-test_cases = [
-    {
-        "id": "sf_local_question",
-        "input": {"query": "Where's good coffee near Moscone Center?"},
-        "expected": {
-            "routed_to": "sf_local_guide",
-            "contains": ["coffee", "moscone", "san francisco"],
-            "confidence": 0.8
-        }
-    },
-    {
-        "id": "conference_question",
-        "input": {"query": "What time is the keynote session?"},
-        "expected": {
-            "routed_to": "conference_expert",
-            "contains": ["keynote", "session", "schedule"]
-        }
-    },
-    {
-        "id": "developer_question",
-        "input": {"query": "How do I implement agent handoffs?"},
-        "expected": {
-            "routed_to": "dev_experience",
-            "contains": ["handoff", "agent", "implementation"]
-        }
-    },
-    {
-        "id": "unclear_request",
-        "input": {"query": "Help me with stuff"},
-        "expected": {
-            "fallback": True,
-            "contains": ["clarify", "help with"]
-        }
-    }
-]
+A golden dataset is a collection of test cases covering your critical scenarios. Each test case includes:
 
-async def evaluate_agent(agent_handler, test_cases):
-    """Run evaluation suite and track success rate."""
-    results = []
-    
-    for test in test_cases:
-        # Run the agent
-        response = await agent_handler(test["input"])
-        
-        # Check expectations
-        passed = True
-        if "fallback" in test["expected"]:
-            # Check for fallback response pattern
-            content = response.get("message", "").lower()
-            passed = any(term in content for term in test["expected"].get("contains", []))
-        elif "routed_to" in test["expected"]:
-            # Check correct routing decision
-            routed_agent = response.get("routed_to")
-            passed = routed_agent == test["expected"]["routed_to"]
-
-            # Also check response content
-            content = response.get("response", "").lower()
-            for term in test["expected"].get("contains", []):
-                if term not in content:
-                    passed = False
-                    break
-        
-        results.append({
-            "test_id": test["id"],
-            "passed": passed,
-            "response": response
-        })
-    
-    # Calculate success rate
-    success_rate = sum(1 for r in results if r["passed"]) / len(results)
-    return {"success_rate": success_rate, "results": results}`} js={`// Golden dataset for concierge testing
-const testCases = [
-  {
-    id: 'sf_local_question',
-    input: { query: "Where's good coffee near Moscone Center?" },
-    expected: {
-      routedTo: 'sf_local_guide',
-      contains: ['coffee', 'moscone', 'san francisco'],
-      confidence: 0.8
-    }
-  },
-  {
-    id: 'conference_question',
-    input: { query: 'What time is the keynote session?' },
-    expected: {
-      routedTo: 'conference_expert',
-      contains: ['keynote', 'session', 'schedule']
-    }
-  },
-  {
-    id: 'developer_question',
-    input: { query: 'How do I implement agent handoffs?' },
-    expected: {
-      routedTo: 'dev_experience',
-      contains: ['handoff', 'agent', 'implementation']
-    }
-  },
-  {
-    id: 'unclear_request',
-    input: { query: 'Help me with stuff' },
-    expected: {
-      fallback: true,
-      contains: ['clarify', 'help with']
-    }
-  }
-];
-
-async function evaluateAgent(agentHandler, testCases) {
-  const results = [];
-
-  for (const test of testCases) {
-    // Run the agent
-    const response = await agentHandler(test.input);
-
-    // Check expectations
-    let passed = true;
-    if (test.expected.fallback) {
-      // Check for fallback response pattern
-      const content = (response.message || '').toLowerCase();
-      passed = test.expected.contains.some(term => content.includes(term));
-    } else if (test.expected.routedTo) {
-      // Check correct routing decision
-      const routedAgent = response.routedTo;
-      passed = routedAgent === test.expected.routedTo;
-
-      // Also check response content
-      const content = (response.response || '').toLowerCase();
-      for (const term of test.expected.contains || []) {
-        if (!content.includes(term)) {
-          passed = false;
-          break;
-        }
-      }
-    }
-    
-    results.push({
-      testId: test.id,
-      passed,
-      response
-    });
-  }
-  
-  // Calculate success rate
-  const successRate = results.filter(r => r.passed).length / results.length;
-  return { successRate, results };
-}`} />
-
-
-## Validation Patterns from Working Agent Systems
-
-Instead of building a new agent from scratch, let's learn validation patterns from Module 4's Conference Concierge - a working system that shows useful validation techniques.
-
-### Key Pattern: Structured LLM Output Validation
-
-The concierge uses validation schemas to ensure AI generates reliable routing decisions:
-
-<CodeExample py={`# Python - Pydantic validation for AI-generated routing decisions
-from pydantic import BaseModel, ValidationError
-from typing import Literal
-
-class UserIntent(BaseModel):
-    agent_type: Literal['sf_local_guide', 'conference_expert', 'dev_experience']
-    confidence: float
-
-# Use AI to analyze intent with validation
-try:
-    ai_response = await generate_structured_intent(user_message)
-    intent = UserIntent(**ai_response)  # Pydantic validates structure
-except ValidationError:
-    # Safe fallback for invalid data
-    intent = UserIntent(agent_type='dev_experience', confidence=0.5)
-
-# Validated data enables confident decision making
-if intent.confidence < 0.8:
-    return response.json({
-        "message": "I'll connect you with a human specialist"
-    })`} js={`// TypeScript - Zod validation for AI-generated routing decisions
-import { z } from 'zod';
-import { generateObject } from 'ai';
-
-const UserIntentSchema = z.object({
-  agentType: z.enum(['sf_local_guide', 'conference_expert', 'dev_experience']),
-  confidence: z.number().min(0).max(1)
-});
-
-// Validation ensures reliable AI output structure
-const { object: userIntent } = await generateObject({
-  model: anthropic('claude-3-5-sonnet-20241022'),
-  schema: UserIntentSchema,  // Zod prevents invalid structures
-  prompt: \`Analyze this user message and determine routing: "\${userMessage}"\`
-});
-
-// Validated data enables confident decision making
-if (userIntent.confidence < 0.8) {
-  return response.json({
-    message: "I'll connect you with a human specialist"
-  });
-}`} />
-
-### Key Pattern: Input Validation
-
-Agents should validate all inputs before processing:
-
-```python
-# From Module 4: Pydantic validation patterns
-from pydantic import BaseModel, Field, ValidationError
-from typing import Literal
-
-class ConversationRequest(BaseModel):
-    message: str = Field(min_length=1, max_length=1000)
-    session_id: str = Field(pattern=r'^[a-zA-Z0-9_-]+$')
-    user_preferences: dict = Field(default_factory=dict)
-
-async def concierge_handler(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Validate input structure with clear error handling
-    try:
-        data = await request.data.json()
-        validated = ConversationRequest(**data)
-    except ValidationError as e:
-        context.logger.warning("Invalid input structure", {"errors": e.errors()})
-        return response.json({
-            "error": "Invalid request format",
-            "details": [{"field": err["loc"][-1], "issue": err["msg"]} for err in e.errors()]
-        })
-
-    # Proceed with validated, type-safe data
-    return await process_conversation(validated, context)
-```
-
-### Key Pattern: Domain-Specific Guardrails
-
-The concierge applies context-aware validation rules:
-
-```typescript
-// Context-aware validation based on agent routing
-async function validateAgentRouting(
-  userIntent: UserIntent,
-  conversationHistory: ConversationRecord,
-  ctx: AgentContext
-) {
-  // Apply routing-specific validation rules
-  if (userIntent.agentType === 'dev_experience') {
-    // Technical questions require minimum context
-    if (userIntent.context.length < 10) {
-      ctx.logger.info('Insufficient context for technical routing');
-      return { valid: false, reason: 'Please provide more detail about your question' };
-    }
-  }
-
-  // Location questions need geographic context
-  if (userIntent.agentType === 'sf_local_guide') {
-    const hasLocationContext = /\b(san francisco|sf|bay area|moscone)\b/i.test(userIntent.context);
-    if (!hasLocationContext) {
-      return { valid: false, reason: 'Please specify your San Francisco location or area of interest' };
-    }
-  }
-
-  return { valid: true };
-}
-```
+- **Input**: The request data sent to your agent
+- **Expected behavior**: What the agent should do (routing decision, response content, error handling)
+- **Success criteria**: How to verify the agent behaved correctly
 
-### Pattern: Error Recovery and Fallbacks
-
-Good validation includes graceful error recovery:
-
-```python
-# Defensive validation with multiple fallback strategies
-async def validate_with_fallbacks(request_data: dict, context: AgentContext):
-    # Strategy 1: Full validation
-    try:
-        validated = ConversationRequest(**request_data)
-        return {"status": "validated", "data": validated}
-    except ValidationError as primary_error:
-        context.logger.info("Primary validation failed, trying fallbacks")
+For example, a concierge agent might have test cases for:
+- Local questions (should route to SF guide)
+- Conference questions (should route to event expert)
+- Developer questions (should route to dev support)
+- Unclear requests (should ask for clarification)
 
-    # Strategy 2: Essential fields only
-    try:
-        essential_fields = {
-            "message": request_data.get("message", ""),
-            "session_id": request_data.get("session_id", f"fallback_{uuid.uuid4()}")
-        }
-        minimal = ConversationRequest(**essential_fields)
-        context.logger.info("Using minimal validation fallback")
-        return {"status": "fallback", "data": minimal}
-    except ValidationError:
-        context.logger.warning("All validation strategies failed")
-
-    # Strategy 3: Safe defaults
-    return {
-        "status": "default",
-        "data": ConversationRequest(
-            message="I need help",
-            session_id=f"emergency_{int(time.time())}"
-        )
-    }
-```
+You can build evaluation functions that run your agent against these test cases and track success rates over time. This helps you catch regressions and measure improvements as you refine your prompts and logic.
 
 ## 🚀 Coming Soon: Integrated Prompts & Evaluations
 
@@ -1108,26 +491,23 @@ Agentuity is working on prompt management and evaluation features:
 ### **Automated Evaluations**
 - Evals that run automatically after every agent session (configurable)
 - Custom evaluation criteria specific to your domain and use cases
-- Integration with your existing CI/CD pipeline
 
 ### **Experimentation Mode**
 - Multi-model comparisons (e.g., GPT-5, Claude, Gemini) on identical prompts
 
-<Callout type="info">
-These features will provide better visibility into agent behavior and systematic ways to improve agent performance over time.
-</Callout>
-
 ## Key Takeaways
 
-- **Guardrails prevent failures** - Input validation, rate limiting, and domain rules protect your agents
-- **Evaluation proves reliability** - Systematic testing with metrics that matter for your domain
-- **Observability is automatic** - Agentuity provides OpenTelemetry integration for comprehensive monitoring
-- **The console shows everything** - Sessions view with color-coded timeline visualization
-- **Production readiness** requires all three pillars working together
+- **Child loggers improve debugging** - Context flows through all log entries automatically
+- **Runtime validation is essential** - TypeScript types and Python type hints aren't enforced at runtime
+- **Validate inputs defensively** - Protect your agent from malformed requests with Zod/Pydantic
+- **Validate AI output structurally** - Ensure reliable, type-safe AI responses with schemas
+- **Custom spans reveal performance** - Track execution flow with attributes and events
+- **Observability is automatic** - Agentuity provides OpenTelemetry integration out of the box
+- **Guardrails preserve autonomy** - Set boundaries without restricting agent capability
 
 ## What's Next?
 
-Now that you understand the fundamentals of production-ready agents, it's time to explore deployment. In the next module, we'll cover Agentuity's deployment environments - from local development through staging to production.
+Now that you understand observability, guardrails, and evaluation strategies, it's time to explore deployment. In the next module, we'll cover Agentuity's deployment environments - from local development through staging to production.
 
 ---
 
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index c05d39b7..e0ab1bb9 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -70,6 +70,15 @@ Build an advanced multi-agent research system that demonstrates mastery of sophi
 
 ### System Architecture
 
+The research system coordinates four specialized agents working together:
+
+| Agent | Role |
+|-------|------|
+| **Orchestrator** | Workflow coordination and error handling |
+| **Researcher** | Recursive research with learning accumulation |
+| **Web Search** | Intelligent search with AI-powered relevance filtering |
+| **Author** | Report synthesis and markdown generation |
+
 <Mermaid chart="
 graph TD
     User[Research Request] --> Orchestrator[Research Orchestrator]
@@ -97,111 +106,188 @@ This sophisticated system builds on concepts from every previous module:
 | **Module 5** | Validation → Research quality assurance |
 | **Module 6** | Deployment → Production research system |
 
-### Key Implementation: Research Orchestration
-
-The orchestrator coordinates the entire research workflow:
-
-<CodeExample py={`# Python - Research orchestration with structured planning
-research_plan = await generate_research_plan(query)
+<Callout type="info">
+The code examples below demonstrate key patterns from the Deep Research system. They're simplified to highlight core concepts. For complete implementations with all helper functions, schemas, and error handling, see the [full GitHub example](#build-this-project-yourself).
+</Callout>
 
-# Coordinate multi-step research workflow
-researcher = await context.get_agent(name="deep-researcher")
-research_result = await researcher.run({
-    "query": query,
-    "plan": research_plan,
-    "max_depth": 3
-})
+### Key Implementation: Research Orchestration
 
-return await research_result.data.json()`} js={`// TypeScript - Research orchestration with structured planning
-const researchPlan = await generateObject({
-  model: anthropic('claude-3-5-sonnet-20241022'),
-  schema: ResearchPlanSchema,
-  prompt: \`Create a research plan for: "\${query}"\`
-});
+The orchestrator is the system's entry point. It receives research requests with configurable depth and breadth parameters, then coordinates the researcher and author agents sequentially using the run-and-wait pattern from Module 4.
+
+<CodeExample py={`# Python - Orchestrator coordinates multi-agent workflow
+request = DeepResearchSchema.parse(await req.data.json())
+query, depth, breadth = request["query"], request.get("depth", 2), request.get("breadth", 3)
+
+try:
+    # Step 1: Deep research via researcher agent
+    researcher = await ctx.get_agent({"name": "researcher"})
+    research_results = await researcher.run({
+        "data": {"query": query, "depth": depth, "breadth": breadth}
+    })
+    research = ResearchSchema.parse(await research_results.data.json())
+
+    # Step 2: Generate report via author agent
+    author = await ctx.get_agent({"name": "author"})
+    report = await (await author.run({"data": research})).data.text()
+
+    return resp.markdown(report)
+except Exception as error:
+    return resp.text(f"Failed to generate report: {error}", {"status": 500})`} js={`// TypeScript - Orchestrator coordinates multi-agent workflow
+const { query, depth = 2, breadth = 3, maxResults = 20 } =
+  DeepResearchSchema.parse(await req.data.json());
+
+try {
+  // Step 1: Deep research via researcher agent
+  const researcher = await ctx.getAgent({ name: "researcher" });
+  const researchResults = await researcher.run({
+    data: { query, depth, breadth, maxResults }
+  });
+  const research = ResearchSchema.parse(await researchResults.data.json());
+
+  // Step 2: Generate report via author agent
+  const author = await ctx.getAgent({ name: "author" });
+  const agentResult = await author.run({ data: research });
+  const report = await agentResult.data.text();
+
+  return resp.markdown(report);
+} catch (error) {
+  return resp.text(\`Failed to generate report: \${error}\`, { status: 500 });
+}`} />
 
-// Coordinate multi-step research workflow
-const researcher = await context.getAgent({ name: 'deep-researcher' });
-const researchResult = await researcher.run({
-  data: JSON.stringify({
-    query,
-    plan: researchPlan.object,
-    maxDepth: 3
-  }),
-  contentType: 'application/json'
-});`} />
+Notice that the orchestrator manages the workflow *without knowing implementation details* of the researcher or author agents.
 
 ### Key Implementation: Recursive Research Pattern
 
-The researcher agent conducts deep, iterative research:
-
-<CodeExample py={`# Python - Recursive research with learning accumulation
-async def conduct_research(query: str, accumulated_knowledge: list, depth: int, context: AgentContext):
-    if depth >= MAX_DEPTH or sufficient_information(accumulated_knowledge):
-        return accumulated_knowledge
-
-    # Conduct research iteration
-    new_findings = await search_and_analyze(query, context)
-    accumulated_knowledge.extend(new_findings)
-
-    # Generate follow-up questions based on findings
-    follow_up_queries = await generate_follow_ups(accumulated_knowledge)
-
-    # Recursive calls for deeper research
-    for follow_up in follow_up_queries:
-        deeper_knowledge = await conduct_research(
-            follow_up, accumulated_knowledge, depth + 1, context
-        )
-        accumulated_knowledge.extend(deeper_knowledge)
-
-    return accumulated_knowledge`} js={`// TypeScript - Recursive research with learning accumulation
-const conductResearch = async (
-  query: string,
-  accumulatedKnowledge: ResearchFinding[],
-  depth: number,
-  context: AgentContext
+The researcher implements *recursive research* with controlled depth and breadth. It generates multiple search queries at each level, extracts learnings from results, and recursively explores follow-up questions - with breadth reducing by half each level to prevent exponential growth.
+
+<CodeExample py={`# Python - Recursive research with depth/breadth control
+async def deep_research(prompt, web_search_agent, accumulated, depth=2, breadth=3):
+    # Base cases: stop when depth exhausted or max results reached
+    if depth == 0 or len(accumulated["searchResults"]) >= 20:
+        return accumulated
+
+    # Generate multiple search queries (breadth-first)
+    queries = await generate_search_queries(prompt, breadth)
+
+    for query in queries:
+        # Execute web search via agent
+        results = await research_web(query, web_search_agent, accumulated)
+        accumulated["searchResults"].extend(results)
+
+        # Extract learnings and generate follow-up questions
+        for result in results:
+            learnings = await generate_learnings(query, result)
+            accumulated["learnings"].append(learnings)
+
+            # Recurse with refined query and reduced breadth
+            refined_query = build_reflection_prompt(prompt, query, learnings)
+            await deep_research(
+                refined_query, web_search_agent, accumulated,
+                depth - 1, math.ceil(breadth / 2)
+            )
+
+    return accumulated`} js={`// TypeScript - Recursive research with depth/breadth control
+const deepResearch = async (
+  prompt: string,
+  webSearchAgent: RemoteAgent,
+  accumulated: Research,
+  depth = 2,
+  breadth = 3
 ) => {
-  if (depth >= MAX_DEPTH || sufficientInformation(accumulatedKnowledge)) {
-    return accumulatedKnowledge;
+  // Base cases: stop when depth exhausted or max results reached
+  if (depth === 0 || accumulated.searchResults.length >= 20) {
+    return accumulated;
+  }
+
+  // Generate multiple search queries (breadth-first)
+  const queries = await generateSearchQueries(prompt, breadth);
+
+  for (const query of queries) {
+    // Execute web search via agent
+    const results = await researchWeb(query, webSearchAgent, accumulated);
+    accumulated.searchResults.push(...results);
+
+    // Extract learnings and generate follow-up questions
+    for (const result of results) {
+      const learnings = await generateLearnings(query, result);
+      accumulated.learnings.push(learnings);
+
+      // Recurse with refined query and reduced breadth
+      const refinedQuery = buildReflectionPrompt(prompt, query, learnings);
+      await deepResearch(
+        refinedQuery, webSearchAgent, accumulated,
+        depth - 1, Math.ceil(breadth / 2)
+      );
+    }
   }
 
-  // Conduct research iteration
-  const newFindings = await searchAndAnalyze(query, context);
-  accumulatedKnowledge.push(...newFindings);
+  return accumulated;
+};`} />
+
+Notice how the base cases prevent runaway recursion (depth limit and max results), while the reflection prompt refines queries based on accumulated learnings for deeper investigation.
+
+### Key Implementation: Web Search with Evaluation
 
-  // Generate follow-up questions based on findings
-  const followUpQueries = await generateFollowUps(accumulatedKnowledge);
+The web search agent integrates the [Exa API](https://docs.exa.ai/reference/getting-started) for web search, then uses AI to evaluate each result's relevance to the query. This filtering ensures only high-quality, non-duplicate sources accumulate across recursive research calls.
 
-  // Recursive calls for deeper research
-  for (const followUp of followUpQueries) {
-    const deeperKnowledge = await conductResearch(
-      followUp, accumulatedKnowledge, depth + 1, context
-    );
-    accumulatedKnowledge.push(...deeperKnowledge);
+<CodeExample py={`# Python - Web search with AI evaluation
+exa = Exa(os.getenv("EXA_API_KEY"))
+{ query, accumulatedSources } = SearchProcessParametersSchema.parse(await req.data.json())
+
+existing_urls = [s["url"] for s in accumulatedSources]
+relevant_results = []
+
+# Fetch raw search results
+raw_results = await exa.search_and_contents(query, num_results=5, livecrawl="always")
+
+# Filter and evaluate each result
+for result in raw_results:
+    # Skip duplicates and low-quality content
+    if result.url in existing_urls or len(result.content) < 50:
+        continue
+
+    # Use AI to evaluate relevance to query
+    if await ai_evaluate_relevance(query, result, existing_urls):
+        relevant_results.append(result)
+        existing_urls.append(result.url)
+
+        if len(relevant_results) >= 3:  # Limit per query
+            break
+
+return resp.json({"searchResults": relevant_results})`} js={`// TypeScript - Web search with AI evaluation
+const exa = new Exa(process.env.EXA_API_KEY!);
+const { query, accumulatedSources } = SearchProcessParametersSchema.parse(
+  await req.data.json()
+);
+
+const existingUrls = accumulatedSources.map(s => s.url);
+const relevantResults: SearchResult[] = [];
+
+// Fetch raw search results
+const { results } = await exa.searchAndContents(query, {
+  numResults: 5,
+  livecrawl: "always"
+});
+
+// Filter and evaluate each result
+for (const result of results) {
+  // Skip duplicates and low-quality content
+  if (existingUrls.includes(result.url) || result.content.length < 50) {
+    continue;
   }
 
-  return accumulatedKnowledge;
-};`} />
+  // Use AI to evaluate relevance to query
+  if (await aiEvaluateRelevance(query, result, existingUrls)) {
+    relevantResults.push(result);
+    existingUrls.push(result.url);
 
-### Key Implementation: Smart Caching Strategies
-
-Different caching approaches based on research depth and complexity:
-
-<CodeExample py={`# Python - Smart caching strategies for research data
-# Different TTL strategies based on research type
-if research_type == 'comprehensive':
-    # Complex research - longer cache (1 hour)
-    await context.kv.set('research', cache_key, results, {'ttl': 3600})
-else:
-    # Quick research - shorter cache (15 minutes) for responsiveness
-    await context.kv.set('research', cache_key, results, {'ttl': 900})`} js={`// TypeScript - Smart caching strategies for research data
-// Different TTL strategies based on research type
-if (researchType === 'comprehensive') {
-  // Complex research - longer cache (1 hour)
-  await context.kv.set('research', cacheKey, results, { ttl: 3600 });
-} else {
-  // Quick research - shorter cache (15 minutes) for responsiveness
-  await context.kv.set('research', cacheKey, results, { ttl: 900 });
-}`} />
+    if (relevantResults.length >= 3) break; // Limit per query
+  }
+}
+
+return resp.json({ searchResults: relevantResults });`} />
+
+The combination of quick filters (duplicate URLs, content length) and AI evaluation balances quality with performance - only 3 relevant results per query prevents overwhelming the researcher with information.
 
 ### Build This Project Yourself
 
@@ -221,13 +307,14 @@ Ready to implement this project? Follow our complete examples:
 
 ### What This System Demonstrates
 
-- **Advanced multi-agent orchestration**: Coordinated workflow between specialized research agents
-- **Recursive algorithms**: Self-improving research with learning accumulation across iterations
-- **External API integration**: Real-world web search with intelligent filtering and relevance evaluation
-- **State accumulation**: Complex memory management and knowledge aggregation
-- **Production patterns**: Error handling, rate limiting, comprehensive observability
+- **Multi-agent orchestration**: Coordinated workflow between orchestrator, researcher, author, and web search agents
+- **Recursive algorithms**: Deep research with learning accumulation and follow-up question generation
+- **External API integration**: Exa web search API with AI-powered relevance evaluation
+- **State accumulation**: Research results, learnings, and queries accumulated across recursive calls
+- **Structured AI responses**: Zod schemas for search queries, learnings, and research data validation
+- **Production patterns**: Error handling, agent validation, comprehensive logging, and markdown report generation
 
-The complete examples show how to build sophisticated research systems that demonstrate mastery of advanced agent concepts.
+The complete example shows how to build sophisticated multi-agent research systems that demonstrate mastery of advanced agent concepts from Modules 1-6.
 
 ## Testing Your Deep Research System
 
diff --git a/content/Training/developers/index.mdx b/content/Training/developers/index.mdx
index c8e6bd6a..8db3c55b 100644
--- a/content/Training/developers/index.mdx
+++ b/content/Training/developers/index.mdx
@@ -14,15 +14,10 @@ Agents are autonomous systems that remember context, reason through problems, ac
 By the end of this course, you'll have deployed:
 - Production agents with persistent memory (stateful, long-running)
 - Multi-agent workflows with seamless agent-to-agent communication
-- Framework-agnostic agents (LangChain, CrewAI, or custom)
+- Framework-agnostic agents (LangChain, CrewAI, custom, etc.)
 - Fully observable systems with [OpenTelemetry](https://opentelemetry.io/) tracing
 - Complete dev → staging → production deployment pipelines
 
-## Time Investment
-- **Full course:** ~20 hours (all modules + capstone project)
-- **Fast track:** ~8 hours (Modules 1, 3, 6 + mini-project)
-- **Framework migration:** ~4 hours (Modules 2 + 6 for developers with existing agent projects)
-
 ## Before You Start
 
 **Required:**
@@ -50,8 +45,8 @@ Framework Migration Guide coming soon for developers moving from AWS Bedrock, Go
 
 Unlike generic AI courses, this curriculum:
 - Focuses on **production deployment**, not just demos
-- Addresses real challenges like memory management, cost optimization, and non-determinism
-- Uses actual industry examples (both successes and cautionary tales)
+- Addresses real challenges like memory management, observability, and guardrails
+- Provides industry insights and best practices
 - Teaches **platform-agnostic concepts** alongside Agentuity-specific implementation
 
 Ready to dive into the world of AI agents? Let's get started with [Module 1: Introduction to Agents](./developers/01-introduction-to-agents).
diff --git a/content/tutorials.json b/content/tutorials.json
index ae2db185..a4163507 100644
--- a/content/tutorials.json
+++ b/content/tutorials.json
@@ -40,22 +40,6 @@
             "path": "Training/developers/05-observability-guardrails-evals.mdx",
             "difficulty": "intermediate",
             "estimatedTime": "25 minutes"
-        },
-        {
-            "id": "06-deployment-environments",
-            "title": "Module 6: Deployment Environments",
-            "description": "From local development to global production",
-            "path": "Training/developers/06-deployment-environments.mdx",
-            "difficulty": "intermediate",
-            "estimatedTime": "20 minutes"
-        },
-        {
-            "id": "07-sandbox-capstone",
-            "title": "Module 7: Advanced Multi-Agent Research System",
-            "description": "Building sophisticated agent coordination with recursive research",
-            "path": "Training/developers/07-sandbox-capstone.mdx",
-            "difficulty": "advanced",
-            "estimatedTime": "45 minutes"
         }
     ]
 }
\ No newline at end of file
diff --git a/examples/training/01-intro/step1-basic-agent.py b/examples/training/01-intro/step1-basic-agent.py
new file mode 100644
index 00000000..27849764
--- /dev/null
+++ b/examples/training/01-intro/step1-basic-agent.py
@@ -0,0 +1,9 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get the name from request data
+    data = await request.data.json()
+    name = data.get("name", "World")
+
+    # Return a simple greeting
+    return response.json({"message": f"Hello, {name}!"})
diff --git a/examples/training/01-intro/step1-basic-agent.ts b/examples/training/01-intro/step1-basic-agent.ts
new file mode 100644
index 00000000..28d9b4c2
--- /dev/null
+++ b/examples/training/01-intro/step1-basic-agent.ts
@@ -0,0 +1,14 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get the name from request data
+  const data = await request.data.json();
+  const name = data.name || 'World';
+
+  // Return a simple greeting
+  return response.json({ message: `Hello, ${name}!` });
+}
diff --git a/examples/training/01-intro/step2-with-logging.py b/examples/training/01-intro/step2-with-logging.py
new file mode 100644
index 00000000..9ce215c4
--- /dev/null
+++ b/examples/training/01-intro/step2-with-logging.py
@@ -0,0 +1,14 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Log the incoming request
+    context.logger.info("Hello agent received a request")
+
+    # Get the name from request data
+    data = await request.data.json()
+    name = data.get("name", "World")
+
+    context.logger.info(f"Greeting {name}")
+
+    # Return a simple greeting
+    return response.json({"message": f"Hello, {name}!"})
diff --git a/examples/training/01-intro/step2-with-logging.ts b/examples/training/01-intro/step2-with-logging.ts
new file mode 100644
index 00000000..06988df9
--- /dev/null
+++ b/examples/training/01-intro/step2-with-logging.ts
@@ -0,0 +1,19 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Log the incoming request
+  context.logger.info('Hello agent received a request');
+
+  // Get the name from request data
+  const data = await request.data.json();
+  const name = data.name || 'World';
+
+  context.logger.info(`Greeting ${name}`);
+
+  // Return a simple greeting
+  return response.json({ message: `Hello, ${name}!` });
+}
diff --git a/examples/training/01-intro/step3-with-state.py b/examples/training/01-intro/step3-with-state.py
new file mode 100644
index 00000000..9db8c5f7
--- /dev/null
+++ b/examples/training/01-intro/step3-with-state.py
@@ -0,0 +1,28 @@
+from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    context.logger.info("Hello agent received a request")
+
+    data = await request.data.json()
+    name = data.get("name", "World")
+
+    # Get current greeting count from KV storage
+    counter_result = await context.kv.get("stats", "greeting_count")
+
+    if counter_result.exists:
+        count = await counter_result.data.json()
+        count += 1
+    else:
+        count = 1
+
+    # Update the counter
+    await context.kv.set("stats", "greeting_count", count)
+
+    context.logger.info(f"Greeting #{count} for {name}")
+
+    return response.json({
+        "message": f"Hello, {name}!",
+        "greeting_number": count,
+        "timestamp": datetime.now().isoformat()
+    })
diff --git a/examples/training/01-intro/step3-with-state.ts b/examples/training/01-intro/step3-with-state.ts
new file mode 100644
index 00000000..eec73bf4
--- /dev/null
+++ b/examples/training/01-intro/step3-with-state.ts
@@ -0,0 +1,34 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  context.logger.info('Hello agent received a request');
+
+  const data = await request.data.json();
+  const name = data.name || 'World';
+
+  // Get current greeting count from KV storage
+  const counterResult = await context.kv.get('stats', 'greeting_count');
+  let count: number;
+
+  if (counterResult.exists) {
+    count = await counterResult.data.json();
+    count++;
+  } else {
+    count = 1;
+  }
+
+  // Update the counter
+  await context.kv.set('stats', 'greeting_count', count);
+
+  context.logger.info(`Greeting #${count} for ${name}`);
+
+  return response.json({
+    message: `Hello, ${name}!`,
+    greeting_number: count,
+    timestamp: new Date().toISOString()
+  });
+}
diff --git a/examples/training/01-intro/step4-with-errors.py b/examples/training/01-intro/step4-with-errors.py
new file mode 100644
index 00000000..5c2b2937
--- /dev/null
+++ b/examples/training/01-intro/step4-with-errors.py
@@ -0,0 +1,41 @@
+from datetime import datetime
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    context.logger.info("Hello agent received a request")
+
+    # Safe input handling with error checking
+    name = "World"
+    try:
+        data = await request.data.json()
+
+        if not data.get("name") or not isinstance(data.get("name"), str):
+            context.logger.warning("No valid name provided in request")
+            return response.json({"error": "Name is required and must be a string"})
+
+        name = data["name"]
+    except Exception as e:
+        context.logger.error(f"Error parsing request: {e}")
+        return response.json({"error": "Invalid JSON in request body"})
+
+    # Get current greeting count with error handling
+    count = 1
+    try:
+        counter_result = await context.kv.get("stats", "greeting_count")
+
+        if counter_result.exists:
+            count = await counter_result.data.json()
+            count += 1
+
+        await context.kv.set("stats", "greeting_count", count)
+    except Exception as e:
+        context.logger.error(f"Error accessing storage: {e}")
+        # Continue with default count rather than failing
+
+    context.logger.info(f"Greeting #{count} for {name}")
+
+    return response.json({
+        "message": f"Hello, {name}!",
+        "greeting_number": count,
+        "timestamp": datetime.now().isoformat()
+    })
diff --git a/examples/training/01-intro/step4-with-errors.ts b/examples/training/01-intro/step4-with-errors.ts
new file mode 100644
index 00000000..b5284775
--- /dev/null
+++ b/examples/training/01-intro/step4-with-errors.ts
@@ -0,0 +1,53 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  context.logger.info('Hello agent received a request');
+
+  // Safe input handling with error checking
+  let name = 'World';
+  try {
+    const data = await request.data.json();
+
+    if (!data.name || typeof data.name !== 'string') {
+      context.logger.warn('No valid name provided in request');
+      return response.json({
+        error: 'Name is required and must be a string'
+      });
+    }
+
+    name = data.name;
+  } catch (error) {
+    context.logger.error(`Error parsing request: ${error}`);
+    return response.json({
+      error: 'Invalid JSON in request body'
+    });
+  }
+
+  // Get current greeting count with error handling
+  let count = 1;
+  try {
+    const counterResult = await context.kv.get('stats', 'greeting_count');
+
+    if (counterResult.exists) {
+      count = await counterResult.data.json();
+      count++;
+    }
+
+    await context.kv.set('stats', 'greeting_count', count);
+  } catch (error) {
+    context.logger.error(`Error accessing storage: ${error}`);
+    // Continue with default count rather than failing
+  }
+
+  context.logger.info(`Greeting #${count} for ${name}`);
+
+  return response.json({
+    message: `Hello, ${name}!`,
+    greeting_number: count,
+    timestamp: new Date().toISOString()
+  });
+}
diff --git a/examples/training/02-anatomy/step1-understanding-triggers.py b/examples/training/02-anatomy/step1-understanding-triggers.py
new file mode 100644
index 00000000..72143f47
--- /dev/null
+++ b/examples/training/02-anatomy/step1-understanding-triggers.py
@@ -0,0 +1,29 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get the trigger type
+    trigger = request.trigger
+
+    context.logger.info(f"Agent triggered via: {trigger}")
+
+    # Different behavior based on trigger
+    if trigger == "webhook":
+        return response.json({
+            "message": "Received webhook trigger",
+            "tip": "Webhooks are great for REST APIs and integrations"
+        })
+    elif trigger == "cron":
+        return response.json({
+            "message": "Scheduled task executed",
+            "tip": "Cron triggers run automatically on schedule"
+        })
+    elif trigger == "manual":
+        return response.json({
+            "message": "Manual trigger from DevMode or Console",
+            "tip": "Manual triggers are perfect for testing"
+        })
+    else:
+        return response.json({
+            "message": f"Triggered via: {trigger}",
+            "availableTriggers": ["webhook", "cron", "manual", "agent", "sms", "email"]
+        })
diff --git a/examples/training/02-anatomy/step1-understanding-triggers.ts b/examples/training/02-anatomy/step1-understanding-triggers.ts
new file mode 100644
index 00000000..622e2c69
--- /dev/null
+++ b/examples/training/02-anatomy/step1-understanding-triggers.ts
@@ -0,0 +1,35 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get the trigger type
+  const trigger = request.trigger;
+
+  context.logger.info(`Agent triggered via: ${trigger}`);
+
+  // Different behavior based on trigger
+  if (trigger === 'webhook') {
+    return response.json({
+      message: 'Received webhook trigger',
+      tip: 'Webhooks are great for REST APIs and integrations'
+    });
+  } else if (trigger === 'cron') {
+    return response.json({
+      message: 'Scheduled task executed',
+      tip: 'Cron triggers run automatically on schedule'
+    });
+  } else if (trigger === 'manual') {
+    return response.json({
+      message: 'Manual trigger from DevMode or Console',
+      tip: 'Manual triggers are perfect for testing'
+    });
+  } else {
+    return response.json({
+      message: `Triggered via: ${trigger}`,
+      availableTriggers: ['webhook', 'cron', 'manual', 'agent', 'sms', 'email']
+    });
+  }
+}
diff --git a/examples/training/02-anatomy/step2-request-data.py b/examples/training/02-anatomy/step2-request-data.py
new file mode 100644
index 00000000..d6c827fa
--- /dev/null
+++ b/examples/training/02-anatomy/step2-request-data.py
@@ -0,0 +1,44 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Check content type to determine how to parse data
+    content_type = request.data.content_type
+
+    context.logger.info(f"Request content type: {content_type}")
+
+    request_data = None
+
+    # Handle different data formats
+    if "application/json" in content_type:
+        request_data = await request.data.json()
+        context.logger.info(f"Parsed as JSON data={request_data}")
+    elif "text/plain" in content_type:
+        request_data = await request.data.text()
+        context.logger.info(f"Parsed as text length={len(request_data)}")
+    else:
+        request_data = await request.data.binary()
+        context.logger.info(f"Parsed as binary size={len(request_data)}")
+
+    # Access metadata - multiple approaches:
+
+    # Approach 1: Using request.get() - SDK convenience method (recommended)
+    session_id = request.get("session_id", "no-session")
+    user_id = request.get("user_id", "anonymous")
+
+    # Approach 2: Using metadata property (returns dict) with dict.get()
+    # session_id = request.metadata.get("session_id", "no-session")
+    # user_id = request.metadata.get("user_id", "anonymous")
+
+    # Approach 3: Direct dictionary access (raises KeyError if missing)
+    # session_id = request.metadata.get("session_id", "no-session")  # Same as approach 2
+    # Or without default: session_id = request.metadata["session_id"]
+
+    return response.json({
+        "received": {
+            "contentType": content_type,
+            "dataType": type(request_data).__name__,
+            "sessionId": session_id,
+            "userId": user_id
+        },
+        "message": "Successfully parsed request data"
+    })
diff --git a/examples/training/02-anatomy/step2-request-data.ts b/examples/training/02-anatomy/step2-request-data.ts
new file mode 100644
index 00000000..f8cbd44b
--- /dev/null
+++ b/examples/training/02-anatomy/step2-request-data.ts
@@ -0,0 +1,50 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Check content type to determine how to parse data
+  const contentType = request.data.contentType;
+
+  context.logger.info(`Request content type: ${contentType}`);
+
+  let requestData: any;
+
+  // Handle different data formats
+  if (contentType.includes('application/json')) {
+    requestData = await request.data.json();
+    context.logger.info('Parsed as JSON', { data: requestData });
+  } else if (contentType.includes('text/plain')) {
+    requestData = await request.data.text();
+    context.logger.info('Parsed as text', { length: requestData.length });
+  } else {
+    requestData = await request.data.binary();
+    context.logger.info('Parsed as binary', { size: requestData.byteLength });
+  }
+
+  // Access metadata - multiple approaches:
+
+  // Approach 1: Using request.get() - SDK convenience method (recommended)
+  const sessionId = request.get('session_id', 'no-session');
+  const userId = request.get('user_id', 'anonymous');
+
+  // Approach 2: Direct property access on metadata object
+  // const sessionId = request.metadata.session_id || 'no-session';
+  // const userId = request.metadata.user_id || 'anonymous';
+
+  // Approach 3: Using optional chaining (safest for nested properties)
+  // const sessionId = request.metadata?.session_id ?? 'no-session';
+  // const userId = request.metadata?.user_id ?? 'anonymous';
+
+  return response.json({
+    received: {
+      contentType,
+      dataType: typeof requestData,
+      sessionId,
+      userId
+    },
+    message: 'Successfully parsed request data'
+  });
+}
diff --git a/examples/training/02-anatomy/step3-structured-logging.py b/examples/training/02-anatomy/step3-structured-logging.py
new file mode 100644
index 00000000..68eb6348
--- /dev/null
+++ b/examples/training/02-anatomy/step3-structured-logging.py
@@ -0,0 +1,50 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # INFO: Normal flow - track what's happening
+    context.logger.info(
+        f"Processing request started agent_id={context.agent.id} "
+        f"agent_name={context.agent.name} session_id={context.sessionId} "
+        f"trigger={request.trigger}"
+    )
+
+    data = await request.data.json()
+    task_type = data.get("task", "unknown")
+
+    # DEBUG: Detailed information for troubleshooting
+    context.logger.debug(
+        f"Request details task_type={task_type} "
+        f"data_keys={list(data.keys())} timestamp={datetime.now().isoformat()}"
+    )
+
+    # Simulate different outcomes
+    if task_type == "risky":
+        # WARNING: Potential issues that don't stop execution
+        context.logger.warning(
+            f"Risky task detected task_type={task_type} "
+            f"recommendation='Review before proceeding'"
+        )
+
+    if task_type == "error":
+        # ERROR: Failures requiring attention
+        context.logger.error(
+            f"Task execution failed task_type={task_type} "
+            f"reason='Invalid task type' action='Returning error response'"
+        )
+
+        return response.json({
+            "error": "Task failed",
+            "details": "Invalid task type: error"
+        })
+
+    # Log successful completion
+    context.logger.info(
+        f"Request processed successfully task_type={task_type} duration=45ms"
+    )
+
+    return response.json({
+        "success": True,
+        "taskType": task_type,
+        "message": "Task completed"
+    })
diff --git a/examples/training/02-anatomy/step3-structured-logging.ts b/examples/training/02-anatomy/step3-structured-logging.ts
new file mode 100644
index 00000000..d09a13f9
--- /dev/null
+++ b/examples/training/02-anatomy/step3-structured-logging.ts
@@ -0,0 +1,60 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // INFO: Normal flow - track what's happening
+  context.logger.info('Processing request started', {
+    agentId: context.agent.id,
+    agentName: context.agent.name,
+    sessionId: context.sessionId,
+    trigger: request.trigger
+  });
+
+  const data = await request.data.json();
+  const taskType = data.task || 'unknown';
+
+  // DEBUG: Detailed information for troubleshooting
+  context.logger.debug('Request details', {
+    taskType,
+    dataKeys: Object.keys(data),
+    timestamp: new Date().toISOString()
+  });
+
+  // Simulate different outcomes
+  if (taskType === 'risky') {
+    // WARN: Potential issues that don't stop execution
+    context.logger.warn('Risky task detected', {
+      taskType,
+      recommendation: 'Review before proceeding'
+    });
+  }
+
+  if (taskType === 'error') {
+    // ERROR: Failures requiring attention
+    context.logger.error('Task execution failed', {
+      taskType,
+      reason: 'Invalid task type',
+      action: 'Returning error response'
+    });
+
+    return response.json({
+      error: 'Task failed',
+      details: 'Invalid task type: error'
+    });
+  }
+
+  // Log successful completion
+  context.logger.info('Request processed successfully', {
+    taskType,
+    duration: '45ms'
+  });
+
+  return response.json({
+    success: true,
+    taskType,
+    message: 'Task completed'
+  });
+}
diff --git a/examples/training/02-anatomy/step4-kv-caching.py b/examples/training/02-anatomy/step4-kv-caching.py
new file mode 100644
index 00000000..7ff08e68
--- /dev/null
+++ b/examples/training/02-anatomy/step4-kv-caching.py
@@ -0,0 +1,47 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    data = await request.data.json()
+    query = data.get("query", "default")
+
+    # Create a cache key
+    cache_key = f"query_{query.lower().replace(' ', '_')}"
+
+    context.logger.info(f"Checking cache cache_key={cache_key}")
+
+    # Check if we have cached data
+    cached = await context.kv.get("demo-cache", cache_key)
+
+    if cached.exists:
+        cached_data = await cached.data.json()
+        context.logger.info(f"Cache hit! cache_key={cache_key}")
+
+        return response.json({
+            "source": "cache",
+            "query": query,
+            "result": cached_data,
+            "message": "Retrieved from cache"
+        })
+
+    # Cache miss - simulate expensive operation
+    context.logger.info(f"Cache miss - computing result cache_key={cache_key}")
+
+    result = {
+        "query": query,
+        "computed": True,
+        "timestamp": datetime.now().isoformat(),
+        "data": f"Processed: {query}"
+    }
+
+    # Store in cache with 5 minute TTL
+    await context.kv.set("demo-cache", cache_key, result, {"ttl": 300})
+
+    context.logger.info(f"Result cached cache_key={cache_key} ttl=300s (5 minutes)")
+
+    return response.json({
+        "source": "fresh",
+        "query": query,
+        "result": result,
+        "message": "Computed and cached for 5 minutes"
+    })
diff --git a/examples/training/02-anatomy/step4-kv-caching.ts b/examples/training/02-anatomy/step4-kv-caching.ts
new file mode 100644
index 00000000..6d8c921e
--- /dev/null
+++ b/examples/training/02-anatomy/step4-kv-caching.ts
@@ -0,0 +1,55 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const data = await request.data.json();
+  const query = data.query || 'default';
+
+  // Create a cache key
+  const cacheKey = `query_${query.toLowerCase().replace(/\s+/g, '_')}`;
+
+  context.logger.info('Checking cache', { cacheKey });
+
+  // Check if we have cached data
+  const cached = await context.kv.get('demo-cache', cacheKey);
+
+  if (cached.exists) {
+    const cachedData = await cached.data.json();
+    context.logger.info('Cache hit!', { cacheKey });
+
+    return response.json({
+      source: 'cache',
+      query,
+      result: cachedData,
+      message: 'Retrieved from cache'
+    });
+  }
+
+  // Cache miss - simulate expensive operation
+  context.logger.info('Cache miss - computing result', { cacheKey });
+
+  const result = {
+    query,
+    computed: true,
+    timestamp: new Date().toISOString(),
+    data: `Processed: ${query}`
+  };
+
+  // Store in cache with 5 minute TTL
+  await context.kv.set('demo-cache', cacheKey, result, { ttl: 300 });
+
+  context.logger.info('Result cached', {
+    cacheKey,
+    ttl: '300s (5 minutes)'
+  });
+
+  return response.json({
+    source: 'fresh',
+    query,
+    result,
+    message: 'Computed and cached for 5 minutes'
+  });
+}
diff --git a/examples/training/02-anatomy/step5-response-formats.py b/examples/training/02-anatomy/step5-response-formats.py
new file mode 100644
index 00000000..15a08476
--- /dev/null
+++ b/examples/training/02-anatomy/step5-response-formats.py
@@ -0,0 +1,43 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    data = await request.data.json()
+    format_type = data.get("format", "json")
+
+    context.logger.info(f"Generating response format={format_type}")
+
+    # Return different formats based on request
+    if format_type == "json":
+        return response.json({
+            "type": "json",
+            "message": "This is a JSON response",
+            "data": {
+                "agent": context.agent.name,
+                "timestamp": datetime.now().isoformat()
+            }
+        })
+    elif format_type == "text":
+        return response.text("This is a plain text response from your agent.")
+    elif format_type == "html":
+        html = f"""
+        <!DOCTYPE html>
+        <html>
+          <head><title>Agent Response</title></head>
+          <body>
+            <h1>HTML Response</h1>
+            <p>This is an HTML response from your agent.</p>
+            <p>Agent: {context.agent.name}</p>
+          </body>
+        </html>
+        """
+        return response.html(html)
+    elif format_type == "empty":
+        # Empty responses are useful for webhooks that don't need data back
+        return response.empty()
+    else:
+        return response.json({
+            "error": "Unknown format",
+            "supportedFormats": ["json", "text", "html", "empty"],
+            "requested": format_type
+        })
diff --git a/examples/training/02-anatomy/step5-response-formats.ts b/examples/training/02-anatomy/step5-response-formats.ts
new file mode 100644
index 00000000..dfd6dfbf
--- /dev/null
+++ b/examples/training/02-anatomy/step5-response-formats.ts
@@ -0,0 +1,48 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const data = await request.data.json();
+  const format = data.format || 'json';
+
+  context.logger.info('Generating response', { format });
+
+  // Return different formats based on request
+  if (format === 'json') {
+    return response.json({
+      type: 'json',
+      message: 'This is a JSON response',
+      data: {
+        agent: context.agent.name,
+        timestamp: new Date().toISOString()
+      }
+    });
+  } else if (format === 'text') {
+    return response.text('This is a plain text response from your agent.');
+  } else if (format === 'html') {
+    const html = `
+      <!DOCTYPE html>
+      <html>
+        <head><title>Agent Response</title></head>
+        <body>
+          <h1>HTML Response</h1>
+          <p>This is an HTML response from your agent.</p>
+          <p>Agent: ${context.agent.name}</p>
+        </body>
+      </html>
+    `;
+    return response.html(html);
+  } else if (format === 'empty') {
+    // Empty responses are useful for webhooks that don't need data back
+    return response.empty();
+  } else {
+    return response.json({
+      error: 'Unknown format',
+      supportedFormats: ['json', 'text', 'html', 'empty'],
+      requested: format
+    });
+  }
+}
diff --git a/examples/training/03-memory/step1-session-memory.py b/examples/training/03-memory/step1-session-memory.py
new file mode 100644
index 00000000..9a7d8025
--- /dev/null
+++ b/examples/training/03-memory/step1-session-memory.py
@@ -0,0 +1,49 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+from aiohttp.web import Response
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = "demo-sessions"
+    session_id = context.sessionId  # Use the current session ID
+
+    try:
+        # Get the user's message
+        user_message = await request.data.text()
+
+        # Retrieve existing session data
+        result = await context.kv.get(bucket, session_id)
+
+        if result.exists:
+            # Session exists - load conversation history
+            messages = await result.data.json()
+            context.logger.info(f"Loaded {len(messages)} existing messages")
+        else:
+            # New session - initialize conversation
+            messages = []
+            context.logger.info("Starting new session")
+
+        # Add the new user message
+        messages.append({
+            "role": "user",
+            "content": user_message,
+            "timestamp": datetime.now().isoformat()
+        })
+
+        # Save conversation with 1-hour TTL (automatic cleanup)
+        await context.kv.set(bucket, session_id, messages, {
+            "ttl": 3600  # 1 hour in seconds
+        })
+
+        context.logger.info(f"Saved {len(messages)} messages with 1-hour TTL")
+
+        # Return conversation summary
+        return response.json({
+            "message": "Message saved to session memory",
+            "messageCount": len(messages),
+            "sessionId": session_id,
+            "expiresIn": "1 hour"
+        })
+
+    except Exception as error:
+        context.logger.error(f"Error managing session memory: {error}")
+        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step1-session-memory.ts b/examples/training/03-memory/step1-session-memory.ts
new file mode 100644
index 00000000..489c3d17
--- /dev/null
+++ b/examples/training/03-memory/step1-session-memory.ts
@@ -0,0 +1,55 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-sessions';
+  const sessionId = context.sessionId; // Use the current session ID
+
+  try {
+    // Get the user's message
+    const userMessage = await request.data.text();
+
+    // Retrieve existing session data
+    const result = await context.kv.get(bucket, sessionId);
+
+    let messages;
+    if (result.exists) {
+      // Session exists - load conversation history
+      messages = await result.data.json();
+      context.logger.info(`Loaded ${messages.length} existing messages`);
+    } else {
+      // New session - initialize conversation
+      messages = [];
+      context.logger.info('Starting new session');
+    }
+
+    // Add the new user message
+    messages.push({
+      role: 'user',
+      content: userMessage,
+      timestamp: new Date().toISOString()
+    });
+
+    // Save conversation with 1-hour TTL (automatic cleanup)
+    await context.kv.set(bucket, sessionId, messages, {
+      ttl: 3600 // 1 hour in seconds
+    });
+
+    context.logger.info(`Saved ${messages.length} messages with 1-hour TTL`);
+
+    // Return conversation summary
+    return response.json({
+      message: 'Message saved to session memory',
+      messageCount: messages.length,
+      sessionId: sessionId,
+      expiresIn: '1 hour'
+    });
+
+  } catch (error) {
+    context.logger.error('Error managing session memory:', error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+}
diff --git a/examples/training/03-memory/step2-persistent-preferences.py b/examples/training/03-memory/step2-persistent-preferences.py
new file mode 100644
index 00000000..439e5268
--- /dev/null
+++ b/examples/training/03-memory/step2-persistent-preferences.py
@@ -0,0 +1,56 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+from aiohttp.web import Response
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = "user-profiles"
+    user_id = "user-123"  # In production, get from request.metadata
+
+    try:
+        # Get user input (preference to update)
+        data = await request.data.json()
+        theme = data.get("theme")
+        language = data.get("language")
+
+        # Retrieve existing user profile
+        result = await context.kv.get(bucket, user_id)
+
+        if result.exists:
+            # Existing user - load and update profile
+            profile = await result.data.json()
+            profile["lastSeen"] = datetime.now().isoformat()
+            profile["interactionCount"] = profile.get("interactionCount", 0) + 1
+
+            context.logger.info(f"Updating profile for returning user ({profile['interactionCount']} interactions)")
+        else:
+            # New user - create profile
+            profile = {
+                "userId": user_id,
+                "preferences": {},
+                "created": datetime.now().isoformat(),
+                "interactionCount": 1
+            }
+
+            context.logger.info("Creating new user profile")
+
+        # Update preferences if provided
+        if theme:
+            profile["preferences"]["theme"] = theme
+        if language:
+            profile["preferences"]["language"] = language
+
+        # Save profile WITHOUT TTL (permanent storage)
+        await context.kv.set(bucket, user_id, profile)
+
+        context.logger.info("Saved user profile (permanent storage)")
+
+        # Return updated profile
+        return response.json({
+            "message": "Profile updated successfully",
+            "profile": profile,
+            "storage": "permanent (no TTL)"
+        })
+
+    except Exception as error:
+        context.logger.error(f"Error managing user profile: {error}")
+        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step2-persistent-preferences.ts b/examples/training/03-memory/step2-persistent-preferences.ts
new file mode 100644
index 00000000..d6545c47
--- /dev/null
+++ b/examples/training/03-memory/step2-persistent-preferences.ts
@@ -0,0 +1,63 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'user-profiles';
+  const userId = 'user-123'; // In production, get from request.metadata
+
+  try {
+    // Get user input (preference to update)
+    const data = await request.data.json();
+    const { theme, language } = data;
+
+    // Retrieve existing user profile
+    const result = await context.kv.get(bucket, userId);
+
+    let profile;
+    if (result.exists) {
+      // Existing user - load and update profile
+      profile = await result.data.json();
+      profile.lastSeen = new Date().toISOString();
+      profile.interactionCount = (profile.interactionCount || 0) + 1;
+
+      context.logger.info(`Updating profile for returning user (${profile.interactionCount} interactions)`);
+    } else {
+      // New user - create profile
+      profile = {
+        userId: userId,
+        preferences: {},
+        created: new Date().toISOString(),
+        interactionCount: 1
+      };
+
+      context.logger.info('Creating new user profile');
+    }
+
+    // Update preferences if provided
+    if (theme) {
+      profile.preferences.theme = theme;
+    }
+    if (language) {
+      profile.preferences.language = language;
+    }
+
+    // Save profile WITHOUT TTL (permanent storage)
+    await context.kv.set(bucket, userId, profile);
+
+    context.logger.info('Saved user profile (permanent storage)');
+
+    // Return updated profile
+    return response.json({
+      message: 'Profile updated successfully',
+      profile: profile,
+      storage: 'permanent (no TTL)'
+    });
+
+  } catch (error) {
+    context.logger.error('Error managing user profile:', error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+}
diff --git a/examples/training/03-memory/step3-vector-basics.py b/examples/training/03-memory/step3-vector-basics.py
new file mode 100644
index 00000000..3c3540fc
--- /dev/null
+++ b/examples/training/03-memory/step3-vector-basics.py
@@ -0,0 +1,80 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from aiohttp.web import Response
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = "demo-knowledge"
+
+    try:
+        user_input = await request.data.text()
+
+        # Sample facts to store (in production, these would come from your knowledge base)
+        facts = [
+            {
+                "key": "fact-1",
+                "document": "Agentuity is an agent-native cloud platform designed for AI agents",
+                "metadata": {"category": "platform", "topic": "overview"}
+            },
+            {
+                "key": "fact-2",
+                "document": "Vector storage enables semantic search by meaning, not keywords",
+                "metadata": {"category": "features", "topic": "storage"}
+            },
+            {
+                "key": "fact-3",
+                "document": "Key-value storage is perfect for session state and caching",
+                "metadata": {"category": "features", "topic": "storage"}
+            }
+        ]
+
+        # Upsert facts into vector storage
+        # Python: Pass array of documents
+        await context.vector.upsert(bucket, facts)
+
+        context.logger.info(f"Upserted {len(facts)} facts to vector storage")
+
+        # Search for relevant facts using semantic similarity
+        search_results = await context.vector.search(
+            bucket,
+            query=user_input,
+            limit=3,
+            similarity=0.5  # Minimum similarity threshold (0-1)
+        )
+
+        context.logger.info(f"Found {len(search_results)} results")
+
+        # Handle empty results
+        if len(search_results) == 0:
+            return response.json({
+                "message": "No relevant facts found",
+                "query": user_input,
+                "trySearching": "Try: 'What is Agentuity?' or 'How does vector storage work?'"
+            })
+
+        # Format results with similarity scores
+        # Note: Search results don't include the document text by default
+        # Store important text in metadata if you need to retrieve it
+        formatted_results = [
+            {
+                "id": result.id,
+                "key": result.key,
+                "category": result.metadata.get("category") if result.metadata else None,
+                "similarity": f"{result.similarity:.2f}"
+            }
+            for result in search_results
+        ]
+
+        # Cleanup demo data
+        for fact in facts:
+            await context.vector.delete(bucket, fact["key"])
+
+        context.logger.info("Cleaned up demo data")
+
+        return response.json({
+            "query": user_input,
+            "resultsFound": len(search_results),
+            "results": formatted_results
+        })
+
+    except Exception as error:
+        context.logger.error(f"Error with vector storage: {error}")
+        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step3-vector-basics.ts b/examples/training/03-memory/step3-vector-basics.ts
new file mode 100644
index 00000000..c387f3fb
--- /dev/null
+++ b/examples/training/03-memory/step3-vector-basics.ts
@@ -0,0 +1,85 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-knowledge';
+
+  try {
+    const userInput = await request.data.text();
+
+    // Sample facts to store (in production, these would come from your knowledge base)
+    const facts = [
+      {
+        key: 'fact-1',
+        document: 'Agentuity is an agent-native cloud platform designed for AI agents',
+        metadata: { category: 'platform', topic: 'overview' }
+      },
+      {
+        key: 'fact-2',
+        document: 'Vector storage enables semantic search by meaning, not keywords',
+        metadata: { category: 'features', topic: 'storage' }
+      },
+      {
+        key: 'fact-3',
+        document: 'Key-value storage is perfect for session state and caching',
+        metadata: { category: 'features', topic: 'storage' }
+      }
+    ];
+
+    // Upsert facts into vector storage
+    // TypeScript: Pass individual objects (not an array)
+    for (const fact of facts) {
+      await context.vector.upsert(bucket, fact);
+    }
+
+    context.logger.info(`Upserted ${facts.length} facts to vector storage`);
+
+    // Search for relevant facts using semantic similarity
+    const searchResults = await context.vector.search(bucket, {
+      query: userInput,
+      limit: 3,
+      similarity: 0.5 // Minimum similarity threshold (0-1)
+    });
+
+    context.logger.info(`Found ${searchResults.length} results`);
+
+    // Handle empty results
+    if (searchResults.length === 0) {
+      return response.json({
+        message: 'No relevant facts found',
+        query: userInput,
+        trySearching: 'Try: "What is Agentuity?" or "How does vector storage work?"'
+      });
+    }
+
+    // Format results with similarity scores
+    // Note: Search results don't include the document text by default
+    // Store important text in metadata if you need to retrieve it
+    const formattedResults = searchResults.map(result => ({
+      id: result.id,
+      key: result.key,
+      category: result.metadata?.category,
+      similarity: result.similarity.toFixed(2)
+    }));
+
+    // Cleanup demo data
+    for (const fact of facts) {
+      await context.vector.delete(bucket, fact.key);
+    }
+
+    context.logger.info('Cleaned up demo data');
+
+    return response.json({
+      query: userInput,
+      resultsFound: searchResults.length,
+      results: formattedResults
+    });
+
+  } catch (error) {
+    context.logger.error('Error with vector storage:', error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+}
diff --git a/examples/training/03-memory/step4-vector-filtering.py b/examples/training/03-memory/step4-vector-filtering.py
new file mode 100644
index 00000000..a4839912
--- /dev/null
+++ b/examples/training/03-memory/step4-vector-filtering.py
@@ -0,0 +1,88 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from aiohttp.web import Response
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = "demo-products"
+
+    try:
+        data = await request.data.json()
+        query = data.get("query")
+        category = data.get("category")
+        in_stock = data.get("inStock")
+
+        # Sample product data
+        products = [
+            {
+                "key": "prod-1",
+                "document": "Ergonomic office chair with lumbar support",
+                "metadata": {"category": "furniture", "price": 299, "inStock": True}
+            },
+            {
+                "key": "prod-2",
+                "document": "Standing desk with adjustable height",
+                "metadata": {"category": "furniture", "price": 499, "inStock": False}
+            },
+            {
+                "key": "prod-3",
+                "document": "Wireless keyboard and mouse combo",
+                "metadata": {"category": "electronics", "price": 79, "inStock": True}
+            },
+            {
+                "key": "prod-4",
+                "document": "LED desk lamp with USB charging",
+                "metadata": {"category": "electronics", "price": 45, "inStock": True}
+            }
+        ]
+
+        # Upsert products
+        await context.vector.upsert(bucket, products)
+
+        context.logger.info(f"Upserted {len(products)} products")
+
+        # Build metadata filters
+        metadata_filters = {}
+        if category:
+            metadata_filters["category"] = category
+        if in_stock is not None:
+            metadata_filters["inStock"] = in_stock
+
+        # Search with semantic similarity + metadata filters
+        search_results = await context.vector.search(
+            bucket,
+            query=query or "office furniture",
+            limit=10,
+            similarity=0.3,  # Lower threshold for broader matches
+            metadata=metadata_filters
+        )
+
+        context.logger.info(
+            f"Found {len(search_results)} results matching filters: {metadata_filters}"
+        )
+
+        # Format results
+        formatted_results = [
+            {
+                "id": result.id,
+                "key": result.key,
+                "category": result.metadata.get("category") if result.metadata else None,
+                "price": result.metadata.get("price") if result.metadata else None,
+                "inStock": result.metadata.get("inStock") if result.metadata else None,
+                "similarity": f"{result.similarity:.2f}"
+            }
+            for result in search_results
+        ]
+
+        # Cleanup demo data
+        for product in products:
+            await context.vector.delete(bucket, product["key"])
+
+        return response.json({
+            "query": query or "office furniture",
+            "filters": metadata_filters,
+            "resultsFound": len(search_results),
+            "results": formatted_results
+        })
+
+    except Exception as error:
+        context.logger.error(f"Error with filtered vector search: {error}")
+        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step4-vector-filtering.ts b/examples/training/03-memory/step4-vector-filtering.ts
new file mode 100644
index 00000000..657078a0
--- /dev/null
+++ b/examples/training/03-memory/step4-vector-filtering.ts
@@ -0,0 +1,92 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-products';
+
+  try {
+    const data = await request.data.json();
+    const { query, category, inStock } = data;
+
+    // Sample product data
+    const products = [
+      {
+        key: 'prod-1',
+        document: 'Ergonomic office chair with lumbar support',
+        metadata: { category: 'furniture', price: 299, inStock: true }
+      },
+      {
+        key: 'prod-2',
+        document: 'Standing desk with adjustable height',
+        metadata: { category: 'furniture', price: 499, inStock: false }
+      },
+      {
+        key: 'prod-3',
+        document: 'Wireless keyboard and mouse combo',
+        metadata: { category: 'electronics', price: 79, inStock: true }
+      },
+      {
+        key: 'prod-4',
+        document: 'LED desk lamp with USB charging',
+        metadata: { category: 'electronics', price: 45, inStock: true }
+      }
+    ];
+
+    // Upsert products
+    for (const product of products) {
+      await context.vector.upsert(bucket, product);
+    }
+
+    context.logger.info(`Upserted ${products.length} products`);
+
+    // Build metadata filters
+    const metadataFilters: Record<string, any> = {};
+    if (category) {
+      metadataFilters.category = category;
+    }
+    if (inStock !== undefined) {
+      metadataFilters.inStock = inStock;
+    }
+
+    // Search with semantic similarity + metadata filters
+    const searchResults = await context.vector.search(bucket, {
+      query: query || 'office furniture',
+      limit: 10,
+      similarity: 0.3, // Lower threshold for broader matches
+      metadata: metadataFilters
+    });
+
+    context.logger.info(
+      `Found ${searchResults.length} results matching filters: ${JSON.stringify(metadataFilters)}`
+    );
+
+    // Format results
+    const formattedResults = searchResults.map(result => ({
+      id: result.id,
+      key: result.key,
+      category: result.metadata?.category,
+      price: result.metadata?.price,
+      inStock: result.metadata?.inStock,
+      similarity: result.similarity.toFixed(2)
+    }));
+
+    // Cleanup demo data
+    for (const product of products) {
+      await context.vector.delete(bucket, product.key);
+    }
+
+    return response.json({
+      query: query || 'office furniture',
+      filters: metadataFilters,
+      resultsFound: searchResults.length,
+      results: formattedResults
+    });
+
+  } catch (error) {
+    context.logger.error('Error with filtered vector search:', error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+}
diff --git a/examples/training/03-memory/step5-object-storage.py b/examples/training/03-memory/step5-object-storage.py
new file mode 100644
index 00000000..7002cc4a
--- /dev/null
+++ b/examples/training/03-memory/step5-object-storage.py
@@ -0,0 +1,52 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+import time
+from aiohttp.web import Response
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = "demo-files"
+    key = f"file-{int(time.time() * 1000)}.txt"
+
+    try:
+        user_input = await request.data.text()
+
+        # Store text content (auto-detect content type)
+        await context.objectstore.put(bucket, key, user_input)
+
+        context.logger.info(f"Stored file: {key}")
+
+        # Retrieve the stored content
+        result = await context.objectstore.get(bucket, key)
+
+        if not result.exists:
+            context.logger.error("File not found after upload")
+            return Response(text="Internal Server Error", status=500)
+
+        content = await result.data.text()
+        context.logger.info(f"Retrieved file content ({len(content)} characters)")
+
+        # Create a temporary public URL (expires in 1 hour)
+        public_url = await context.objectstore.create_public_url(
+            bucket,
+            key,
+            3600000  # 1 hour in milliseconds
+        )
+
+        context.logger.info("Created public URL (expires in 1 hour)")
+
+        # Cleanup - delete the demo file
+        await context.objectstore.delete(bucket, key)
+
+        context.logger.info("Cleaned up demo file")
+
+        return response.json({
+            "message": "File stored and retrieved successfully",
+            "filename": key,
+            "contentLength": len(content),
+            "publicUrl": public_url,
+            "urlExpiresIn": "1 hour",
+            "note": "File was deleted after creating URL (demo cleanup)"
+        })
+
+    except Exception as error:
+        context.logger.error(f"Error with object storage: {error}")
+        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step5-object-storage.ts b/examples/training/03-memory/step5-object-storage.ts
new file mode 100644
index 00000000..04565df8
--- /dev/null
+++ b/examples/training/03-memory/step5-object-storage.ts
@@ -0,0 +1,57 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-files';
+  const key = `file-${Date.now()}.txt`;
+
+  try {
+    const userInput = await request.data.text();
+
+    // Store text content (auto-detect content type)
+    await context.objectstore.put(bucket, key, userInput);
+
+    context.logger.info(`Stored file: ${key}`);
+
+    // Retrieve the stored content
+    const result = await context.objectstore.get(bucket, key);
+
+    if (!result.exists) {
+      context.logger.error('File not found after upload');
+      return new Response('Internal Server Error', { status: 500 });
+    }
+
+    const content = await result.data.text();
+    context.logger.info(`Retrieved file content (${content.length} characters)`);
+
+    // Create a temporary public URL (expires in 1 hour)
+    const publicUrl = await context.objectstore.createPublicURL(
+      bucket,
+      key,
+      3600000 // 1 hour in milliseconds
+    );
+
+    context.logger.info(`Created public URL (expires in 1 hour)`);
+
+    // Cleanup - delete the demo file
+    await context.objectstore.delete(bucket, key);
+
+    context.logger.info('Cleaned up demo file');
+
+    return response.json({
+      message: 'File stored and retrieved successfully',
+      filename: key,
+      contentLength: content.length,
+      publicUrl: publicUrl,
+      urlExpiresIn: '1 hour',
+      note: 'File was deleted after creating URL (demo cleanup)'
+    });
+
+  } catch (error) {
+    context.logger.error('Error with object storage:', error);
+    return new Response('Internal Server Error', { status: 500 });
+  }
+}
diff --git a/examples/training/04-agent-communication/step1-basic-handoff.py b/examples/training/04-agent-communication/step1-basic-handoff.py
new file mode 100644
index 00000000..6857995e
--- /dev/null
+++ b/examples/training/04-agent-communication/step1-basic-handoff.py
@@ -0,0 +1,8 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Simple delegation - pass control to a specialist agent
+    # This agent exits immediately after handoff
+    context.logger.info('Delegating to specialist agent')
+
+    return response.handoff({"name": "specialist-agent"})
diff --git a/examples/training/04-agent-communication/step1-basic-handoff.ts b/examples/training/04-agent-communication/step1-basic-handoff.ts
new file mode 100644
index 00000000..1d3a7260
--- /dev/null
+++ b/examples/training/04-agent-communication/step1-basic-handoff.ts
@@ -0,0 +1,13 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Simple delegation - pass control to a specialist agent
+  // This agent exits immediately after handoff
+  context.logger.info('Delegating to specialist agent');
+
+  return response.handoff({ name: 'specialist-agent' });
+}
diff --git a/examples/training/04-agent-communication/step2-data-formats.py b/examples/training/04-agent-communication/step2-data-formats.py
new file mode 100644
index 00000000..efef4c5b
--- /dev/null
+++ b/examples/training/04-agent-communication/step2-data-formats.py
@@ -0,0 +1,29 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Demonstrate different ways to pass data when handing off
+    # Python infers content type from data type automatically
+
+    # Example 1: Pass plain text (inferred as text/plain)
+    context.logger.info('Example: Passing plain text to analyzer')
+    # Uncomment to use:
+    # return response.handoff(
+    #     {"name": "text-analyzer"},
+    #     "Analyze this text"  # String → text/plain
+    # )
+
+    # Example 2: Pass dict (inferred as application/json)
+    context.logger.info('Example: Passing JSON object to processor')
+    return response.handoff(
+        {"name": "data-processor"},
+        {
+            "message": "Process this data",
+            "timestamp": datetime.now().isoformat()
+        }  # Dict → application/json
+    )
+
+    # Example 3: Pass original request as-is (no data parameter)
+    # Uncomment to use:
+    # context.logger.info('Example: Forwarding original request')
+    # return response.handoff({"name": "passthrough-agent"})
diff --git a/examples/training/04-agent-communication/step2-data-formats.ts b/examples/training/04-agent-communication/step2-data-formats.ts
new file mode 100644
index 00000000..0cd668b6
--- /dev/null
+++ b/examples/training/04-agent-communication/step2-data-formats.ts
@@ -0,0 +1,34 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Demonstrate different ways to pass data when handing off
+
+  // Example 1: Pass plain text with explicit content type
+  context.logger.info('Example: Passing plain text to analyzer');
+  // Uncomment to use:
+  // return response.handoff(
+  //   { name: 'text-analyzer' },
+  //   { data: "Analyze this text", contentType: "text/plain" }
+  // );
+
+  // Example 2: Pass JSON object (SDK auto-detects application/json)
+  context.logger.info('Example: Passing JSON object to processor');
+  return response.handoff(
+    { name: 'data-processor' },
+    {
+      data: {
+        message: "Process this data",
+        timestamp: new Date().toISOString()
+      }
+    }
+  );
+
+  // Example 3: Pass original request as-is (no data parameter)
+  // Uncomment to use:
+  // context.logger.info('Example: Forwarding original request');
+  // return response.handoff({ name: 'passthrough-agent' });
+}
diff --git a/examples/training/04-agent-communication/step3-run-and-wait.py b/examples/training/04-agent-communication/step3-run-and-wait.py
new file mode 100644
index 00000000..e27d7b79
--- /dev/null
+++ b/examples/training/04-agent-communication/step3-run-and-wait.py
@@ -0,0 +1,26 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get the message from the request
+    data = await request.data.json()
+    message = data.get('message')
+
+    context.logger.info('Getting specialist agent handle')
+
+    # Get a reference to the specialist agent
+    agent = await context.get_agent({"name": "message-processor"})
+
+    context.logger.info('Running specialist agent and waiting for response')
+
+    # Run the agent and wait for its response
+    agent_response = await agent.run({"message": message})
+
+    # Process the response from the specialist
+    result = await agent_response.data.json()
+
+    # Return enhanced results to the client
+    return response.json({
+        "original": message,
+        "processed": result,
+        "handledBy": context.agent.name
+    })
diff --git a/examples/training/04-agent-communication/step3-run-and-wait.ts b/examples/training/04-agent-communication/step3-run-and-wait.ts
new file mode 100644
index 00000000..7b68b47c
--- /dev/null
+++ b/examples/training/04-agent-communication/step3-run-and-wait.ts
@@ -0,0 +1,33 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get the message from the request
+  const { message } = await request.data.json();
+
+  context.logger.info('Getting specialist agent handle');
+
+  // Get a reference to the specialist agent
+  const agent = await context.getAgent({ name: 'message-processor' });
+
+  context.logger.info('Running specialist agent and waiting for response');
+
+  // Run the agent and wait for its response
+  // SDK auto-detects content type from data (object → application/json)
+  const agentResponse = await agent.run({
+    data: { message }
+  });
+
+  // Process the response from the specialist
+  const result = await agentResponse.data.json();
+
+  // Return enhanced results to the client
+  return response.json({
+    original: message,
+    processed: result,
+    handledBy: context.agent.name
+  });
+}
diff --git a/examples/training/04-agent-communication/step4-parallel-execution.py b/examples/training/04-agent-communication/step4-parallel-execution.py
new file mode 100644
index 00000000..e076fd0d
--- /dev/null
+++ b/examples/training/04-agent-communication/step4-parallel-execution.py
@@ -0,0 +1,33 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+import asyncio
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get the search query from the request
+    data = await request.data.json()
+    query = data.get('query')
+
+    context.logger.info('Getting multiple specialist agents')
+
+    # Get references to multiple specialist agents
+    web_agent = await context.get_agent({"name": "web-search"})
+    news_agent = await context.get_agent({"name": "news-search"})
+
+    context.logger.info('Running searches in parallel')
+
+    # Execute both searches in parallel
+    web_result, news_result = await asyncio.gather(
+        web_agent.run({"query": query, "source": "web"}),
+        news_agent.run({"query": query, "source": "news"})
+    )
+
+    # Process results from both agents
+    web_data = await web_result.data.json()
+    news_data = await news_result.data.json()
+
+    # Return combined results
+    return response.json({
+        "query": query,
+        "webResults": web_data,
+        "newsResults": news_data,
+        "totalSources": 2
+    })
diff --git a/examples/training/04-agent-communication/step4-parallel-execution.ts b/examples/training/04-agent-communication/step4-parallel-execution.ts
new file mode 100644
index 00000000..c958055e
--- /dev/null
+++ b/examples/training/04-agent-communication/step4-parallel-execution.ts
@@ -0,0 +1,36 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get the search query from the request
+  const { query } = await request.data.json();
+
+  context.logger.info('Getting multiple specialist agents');
+
+  // Get references to multiple specialist agents
+  const webAgent = await context.getAgent({ name: 'web-search' });
+  const newsAgent = await context.getAgent({ name: 'news-search' });
+
+  context.logger.info('Running searches in parallel');
+
+  // Execute both searches in parallel
+  const [webResult, newsResult] = await Promise.all([
+    webAgent.run({ data: { query, source: 'web' } }),
+    newsAgent.run({ data: { query, source: 'news' } })
+  ]);
+
+  // Process results from both agents
+  const webData = await webResult.data.json();
+  const newsData = await newsResult.data.json();
+
+  // Return combined results
+  return response.json({
+    query,
+    webResults: webData,
+    newsResults: newsData,
+    totalSources: 2
+  });
+}
diff --git a/examples/training/04-agent-communication/step5-structured-responses.py b/examples/training/04-agent-communication/step5-structured-responses.py
new file mode 100644
index 00000000..09bb59a7
--- /dev/null
+++ b/examples/training/04-agent-communication/step5-structured-responses.py
@@ -0,0 +1,68 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from pydantic import BaseModel, Field
+from typing import List, Literal
+from anthropic import AsyncAnthropic
+import json
+
+# Define schema for routing decisions
+class RoutingDecision(BaseModel):
+    agent_type: Literal['support', 'sales', 'technical'] = Field(alias='agentType')
+    tags: List[str]
+    confidence: float = Field(ge=0.0, le=1.0)
+    reasoning: str
+
+    class Config:
+        populate_by_name = True
+
+client = AsyncAnthropic()
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    user_message = await request.data.text()
+
+    context.logger.info('Analyzing request for routing')
+
+    # Use AI to generate routing decision as JSON
+    result = await client.messages.create(
+        model="claude-3-5-sonnet-20241022",
+        max_tokens=1000,
+        system="""You are a routing orchestrator. Analyze user messages and determine which
+specialist agent should handle them. Consider the user's intent and return a structured
+routing decision.
+
+You MUST respond with valid JSON matching this schema:
+{
+    "agentType": "support" | "sales" | "technical",
+    "tags": ["tag1", "tag2"],
+    "confidence": 0.0-1.0,
+    "reasoning": "why this agent"
+}
+
+Only respond with the JSON, no other text.""",
+        messages=[{"role": "user", "content": f'Analyze this user message: "{user_message}"'}]
+    )
+
+    # Parse and validate the response
+    try:
+        decision_data = json.loads(result.content[0].text)
+        decision = RoutingDecision(**decision_data)
+    except Exception as e:
+        context.logger.error(f'Failed to parse routing decision: {e}')
+        return response.text("Sorry, I couldn't analyze your request properly.")
+
+    context.logger.info(
+        f'Routing decision: {decision.agent_type} (confidence: {decision.confidence})'
+    )
+
+    # Only route if confidence is high enough
+    if decision.confidence < 0.7:
+        return response.json({
+            "message": "I'm not confident about routing this. Let me connect you with a human.",
+            "reasoning": decision.reasoning,
+            "tags": decision.tags
+        })
+
+    # Route to appropriate agent based on validated decision
+    target_agent = await context.get_agent({"name": f"{decision.agent_type}-agent"})
+    result = await target_agent.run(user_message)
+
+    return response.text(await result.data.text())
diff --git a/examples/training/04-agent-communication/step5-structured-responses.ts b/examples/training/04-agent-communication/step5-structured-responses.ts
new file mode 100644
index 00000000..b2ebcf59
--- /dev/null
+++ b/examples/training/04-agent-communication/step5-structured-responses.ts
@@ -0,0 +1,54 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+import { z } from "zod";
+import { generateObject } from "ai";
+import { anthropic } from "@ai-sdk/anthropic";
+
+// Define schema for routing decisions
+const RoutingDecisionSchema = z.object({
+  agentType: z.enum(['support', 'sales', 'technical']),
+  tags: z.array(z.string()),
+  confidence: z.number().min(0).max(1),
+  reasoning: z.string()
+});
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const userMessage = await request.data.text();
+
+  context.logger.info('Analyzing request for routing');
+
+  // Use AI with structured output to determine routing
+  const { object: decision } = await generateObject({
+    model: anthropic('claude-3-5-sonnet-20241022'),
+    schema: RoutingDecisionSchema,
+    system: `You are a routing orchestrator. Analyze user messages and determine which
+specialist agent should handle them. Consider the user's intent and return a structured
+routing decision.`,
+    prompt: `Analyze this user message and determine routing: "${userMessage}"`
+  });
+
+  context.logger.info(
+    `Routing decision: ${decision.agentType} (confidence: ${decision.confidence})`
+  );
+
+  // Only route if confidence is high enough
+  if (decision.confidence < 0.7) {
+    return response.json({
+      message: "I'm not confident about routing this. Let me connect you with a human.",
+      reasoning: decision.reasoning,
+      tags: decision.tags
+    });
+  }
+
+  // Route to appropriate agent based on validated decision
+  const targetAgent = await context.getAgent({ name: `${decision.agentType}-agent` });
+  const result = await targetAgent.run({
+    data: userMessage,
+    contentType: "text/plain"
+  });
+
+  return response.text(await result.data.text());
+}
diff --git a/examples/training/05-observability-guardrails/step1-child-loggers.py b/examples/training/05-observability-guardrails/step1-child-loggers.py
new file mode 100644
index 00000000..54e6ed1d
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step1-child-loggers.py
@@ -0,0 +1,41 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get request data
+    data = await request.data.json()
+    user_id = data.get("userId", "unknown")
+    request_id = data.get("requestId", context.runId)
+
+    # Note: Child logger functionality coming soon for API consistency
+    # Current approach: Include context in each log message
+
+    # Log processing start
+    context.logger.info(f"Processing request started request_id={request_id} user_id={user_id}")
+
+    try:
+        # Simulate some processing steps
+        context.logger.debug(f"Validating input data request_id={request_id}")
+
+        if not data.get("query"):
+            context.logger.warning(f"Missing query field request_id={request_id} user_id={user_id}")
+            return response.json({"error": "Query is required"})
+
+        query = data["query"]
+        context.logger.debug(f"Processing query request_id={request_id} query_length={len(query)}")
+
+        # Simulate successful processing
+        result = {
+            "message": "Request processed successfully",
+            "query": query,
+            "processedAt": datetime.now().isoformat()
+        }
+
+        context.logger.info(f"Processing completed successfully request_id={request_id} user_id={user_id}")
+
+        return response.json(result)
+
+    except Exception as error:
+        # Error logs also include the context
+        context.logger.error(f"Processing failed request_id={request_id} user_id={user_id} error={str(error)}")
+        return response.json({"error": "Processing failed"}, status=500)
diff --git a/examples/training/05-observability-guardrails/step1-child-loggers.ts b/examples/training/05-observability-guardrails/step1-child-loggers.ts
new file mode 100644
index 00000000..2d9ad8c8
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step1-child-loggers.ts
@@ -0,0 +1,50 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get request data
+  const data = await request.data.json();
+  const userId = data.userId || 'unknown';
+  const requestId = data.requestId || context.runId;
+
+  // Create child logger with context
+  // All logs from this child logger will include these fields
+  const requestLogger = context.logger.child({
+    requestId,
+    userId
+  });
+
+  // Log processing start
+  requestLogger.info('Processing request started');
+
+  try {
+    // Simulate some processing steps
+    requestLogger.debug('Validating input data');
+
+    if (!data.query) {
+      requestLogger.warn('Missing query field');
+      return response.json({ error: 'Query is required' });
+    }
+
+    requestLogger.debug('Processing query', { queryLength: data.query.length });
+
+    // Simulate successful processing
+    const result = {
+      message: 'Request processed successfully',
+      query: data.query,
+      processedAt: new Date().toISOString()
+    };
+
+    requestLogger.info('Processing completed successfully');
+
+    return response.json(result);
+
+  } catch (error) {
+    // Error logs also include the child logger context
+    requestLogger.error('Processing failed', error);
+    return response.json({ error: 'Processing failed' }, { status: 500 });
+  }
+}
diff --git a/examples/training/05-observability-guardrails/step2-input-validation.py b/examples/training/05-observability-guardrails/step2-input-validation.py
new file mode 100644
index 00000000..e8b04b74
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step2-input-validation.py
@@ -0,0 +1,49 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from pydantic import BaseModel, Field, ValidationError
+from typing import Optional, Literal
+from datetime import datetime
+
+# Define Pydantic model for user preferences
+class UserPreferences(BaseModel):
+    language: Literal['en', 'es', 'fr']
+    max_results: int = Field(ge=1, le=50)
+
+# Define Pydantic model for user query
+class UserQuery(BaseModel):
+    query: str = Field(min_length=1, max_length=500)
+    user_id: str
+    preferences: Optional[UserPreferences] = None
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    context.logger.info("Validating incoming request")
+
+    # Validate incoming request with Pydantic
+    try:
+        raw_data = await request.data.json()
+        validated = UserQuery(**raw_data)
+    except ValidationError as e:
+        context.logger.warning(f"Request validation failed errors={e.error_count()}")
+
+        return response.json({
+            "error": "Invalid request",
+            "details": [{"field": err["loc"][-1], "message": err["msg"]}
+                        for err in e.errors()]
+        }, status=400)
+
+    # Use validated data (type-safe)
+    query = validated.query
+    user_id = validated.user_id
+    preferences = validated.preferences
+
+    context.logger.info(f"Request validated successfully user_id={user_id} query_length={len(query)} has_preferences={preferences is not None}")
+
+    # Process with confidence that data is valid
+    processed_response = {
+        "message": "Query processed successfully",
+        "query": query,
+        "userId": user_id,
+        "preferences": preferences.model_dump() if preferences else {"language": "en", "max_results": 10},
+        "processedAt": datetime.now().isoformat()
+    }
+
+    return response.json(processed_response)
diff --git a/examples/training/05-observability-guardrails/step2-input-validation.ts b/examples/training/05-observability-guardrails/step2-input-validation.ts
new file mode 100644
index 00000000..fe61e7e0
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step2-input-validation.ts
@@ -0,0 +1,57 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+import { z } from "zod";
+
+// Define schema for user preferences
+const UserPreferencesSchema = z.object({
+  language: z.enum(['en', 'es', 'fr']),
+  maxResults: z.number().int().min(1).max(50)
+}).optional();
+
+// Define schema for user query
+const UserQuerySchema = z.object({
+  query: z.string().min(1).max(500),
+  userId: z.string(),
+  preferences: UserPreferencesSchema
+});
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  context.logger.info('Validating incoming request');
+
+  // Validate incoming request with Zod
+  const result = UserQuerySchema.safeParse(await request.data.json());
+
+  if (!result.success) {
+    context.logger.warn('Request validation failed', {
+      errors: result.error.issues
+    });
+
+    return response.json({
+      error: 'Invalid request',
+      details: result.error.issues
+    }, { status: 400 });
+  }
+
+  // Use validated data (type-safe)
+  const { query, userId, preferences } = result.data;
+
+  context.logger.info('Request validated successfully', {
+    userId,
+    queryLength: query.length,
+    hasPreferences: !!preferences
+  });
+
+  // Process with confidence that data is valid
+  const processedResponse = {
+    message: 'Query processed successfully',
+    query,
+    userId,
+    preferences: preferences || { language: 'en', maxResults: 10 },
+    processedAt: new Date().toISOString()
+  };
+
+  return response.json(processedResponse);
+}
diff --git a/examples/training/05-observability-guardrails/step3-ai-output-validation.py b/examples/training/05-observability-guardrails/step3-ai-output-validation.py
new file mode 100644
index 00000000..d8367006
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step3-ai-output-validation.py
@@ -0,0 +1,66 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from pydantic import BaseModel, Field, ValidationError
+from typing import Literal
+from datetime import datetime
+import json
+
+# Define Pydantic model for AI-generated sentiment analysis
+class SentimentAnalysis(BaseModel):
+    sentiment: Literal['positive', 'negative', 'neutral']
+    confidence: float = Field(ge=0.0, le=1.0)
+    summary: str
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get user query
+    data = await request.data.json()
+    user_query = data.get("query", "This is a great product!")
+
+    context.logger.info(f"Generating AI analysis query_length={len(user_query)}")
+
+    try:
+        # Use Anthropic for structured generation
+        from anthropic import AsyncAnthropic
+        client = AsyncAnthropic()
+
+        ai_response = await client.messages.create(
+            model="claude-3-5-haiku-20241022",
+            max_tokens=500,
+            system="""You analyze sentiment of text. Respond with valid JSON matching this structure:
+{
+  "sentiment": "positive" | "negative" | "neutral",
+  "confidence": 0.0-1.0,
+  "summary": "brief explanation"
+}
+
+Only respond with the JSON, no other text.""",
+            messages=[{
+                "role": "user",
+                "content": f"Analyze the sentiment of this text: \"{user_query}\""
+            }]
+        )
+
+        # Validate AI response with Pydantic
+        try:
+            response_text = ai_response.content[0].text
+            analysis_data = json.loads(response_text)
+            analysis = SentimentAnalysis(**analysis_data)
+
+            context.logger.info(f"Analysis complete sentiment={analysis.sentiment} confidence={analysis.confidence}")
+
+            return response.json({
+                "query": user_query,
+                "analysis": analysis.model_dump(),
+                "generatedAt": datetime.now().isoformat()
+            })
+
+        except (json.JSONDecodeError, ValidationError) as e:
+            context.logger.error(f"AI returned invalid data: {str(e)}")
+            return response.json({
+                "error": "AI generated invalid response format"
+            }, status=500)
+
+    except Exception as error:
+        context.logger.error(f"AI generation failed: {str(error)}")
+        return response.json({
+            "error": "Failed to generate analysis"
+        }, status=500)
diff --git a/examples/training/05-observability-guardrails/step3-ai-output-validation.ts b/examples/training/05-observability-guardrails/step3-ai-output-validation.ts
new file mode 100644
index 00000000..23f0c372
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step3-ai-output-validation.ts
@@ -0,0 +1,55 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+import { z } from "zod";
+import { generateObject } from "ai";
+import { openai } from "@ai-sdk/openai";
+
+// Define schema for AI-generated sentiment analysis
+const SentimentAnalysisSchema = z.object({
+  sentiment: z.enum(['positive', 'negative', 'neutral']),
+  confidence: z.number().min(0).max(1),
+  summary: z.string()
+});
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get user query
+  const data = await request.data.json();
+  const userQuery = data.query || 'This is a great product!';
+
+  context.logger.info('Generating AI analysis', { queryLength: userQuery.length });
+
+  try {
+    // AI generates validated structured output
+    const analysis = await generateObject({
+      model: openai('gpt-4o-mini'),
+      schema: SentimentAnalysisSchema,
+      prompt: `Analyze the sentiment of this text: "${userQuery}"
+
+      Provide:
+      - sentiment: positive, negative, or neutral
+      - confidence: a number between 0 and 1
+      - summary: a brief explanation (1-2 sentences)`
+    });
+
+    // analysis.object is guaranteed to match schema
+    context.logger.info('Analysis complete', {
+      sentiment: analysis.object.sentiment,
+      confidence: analysis.object.confidence
+    });
+
+    return response.json({
+      query: userQuery,
+      analysis: analysis.object,
+      generatedAt: new Date().toISOString()
+    });
+
+  } catch (error) {
+    context.logger.error('AI generation failed', error);
+    return response.json({
+      error: 'Failed to generate analysis'
+    }, { status: 500 });
+  }
+}
diff --git a/examples/training/05-observability-guardrails/step4-custom-spans.py b/examples/training/05-observability-guardrails/step4-custom-spans.py
new file mode 100644
index 00000000..d2b83dd5
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step4-custom-spans.py
@@ -0,0 +1,64 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from opentelemetry.trace.status import Status, StatusCode
+import asyncio
+import time
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get data in the appropriate format
+    if request.data.content_type == 'application/json':
+        prompt = await request.data.json()
+    elif request.data.content_type == 'text/plain':
+        prompt = await request.data.text()
+    else:
+        prompt = await request.data.text()
+
+    # Create a span for processing
+    with context.tracer.start_as_current_span("process-data") as span:
+        try:
+            # Add attributes to the span
+            span.set_attribute("trigger", request.trigger)
+            span.set_attribute("contentType", request.data.content_type)
+
+            # Add type-specific attributes
+            if request.data.content_type == 'application/json':
+                span.set_attribute("data.type", "json")
+                if isinstance(prompt, dict) and "user" in prompt:
+                    span.set_attribute("user", prompt["user"])
+                if isinstance(prompt, dict) and "action" in prompt:
+                    span.set_attribute("action", prompt["action"])
+            else:
+                span.set_attribute("data.type", "text")
+                span.set_attribute("message.length", len(str(prompt)))
+
+            # Add events to the span
+            span.add_event("processing-started", {
+                "timestamp": int(time.time() * 1000),
+                "hasData": prompt is not None
+            })
+
+            # Simulate some processing work
+            await asyncio.sleep(0.1)
+
+            # Process the data
+            result = {
+                'message': 'Event processed and traced successfully',
+                'data': str(prompt),
+                'traced': True
+            }
+
+            # Add completion event
+            span.add_event("processing-completed", {
+                "success": True
+            })
+
+            # Set status to OK
+            span.set_status(Status(StatusCode.OK))
+
+            return response.json(result)
+
+        except Exception as error:
+            # Record the error in the span
+            span.record_exception(error)
+            span.set_status(Status(StatusCode.ERROR))
+            context.logger.error(f"Error processing data: {str(error)}")
+            raise
diff --git a/examples/training/05-observability-guardrails/step4-custom-spans.ts b/examples/training/05-observability-guardrails/step4-custom-spans.ts
new file mode 100644
index 00000000..f6f101a3
--- /dev/null
+++ b/examples/training/05-observability-guardrails/step4-custom-spans.ts
@@ -0,0 +1,71 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+import { SpanStatusCode } from "@opentelemetry/api";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get data in the appropriate format
+  let prompt: unknown;
+  switch (request.data.contentType) {
+    case 'application/json':
+      prompt = await request.data.json();
+      break;
+    case 'text/plain':
+      prompt = await request.data.text();
+      break;
+    default:
+      prompt = await request.data.text();
+      break;
+  }
+
+  // Create a span for processing
+  return context.tracer.startActiveSpan('process-data', async (span) => {
+    try {
+      // Add common attributes
+      span.setAttribute('trigger', request.trigger);
+      span.setAttribute('contentType', request.data.contentType);
+
+      // Add type-specific attributes
+      if (request.data.contentType === 'text/plain') {
+        span.setAttribute('message.content', prompt as string);
+        span.setAttribute('message.length', (prompt as string).length);
+      } else {
+        span.setAttribute('data.json', JSON.stringify(prompt));
+        span.setAttribute('data.type', typeof prompt);
+      }
+
+      // Add event to mark processing start
+      const startEvent = request.data.contentType === 'text/plain'
+        ? { timestamp: Date.now() }
+        : { timestamp: Date.now(), hasData: prompt !== null, dataType: typeof prompt };
+
+      span.addEvent('processing-started', startEvent);
+
+      // Simulate some processing work
+      await new Promise(resolve => setTimeout(resolve, 100));
+
+      // Process the data
+      const result = {
+        message: 'Event processed and traced',
+        data: prompt as string,
+        traced: true
+      };
+
+      span.addEvent('processing-completed', result);
+
+      // Set status to OK
+      span.setStatus({ code: SpanStatusCode.OK });
+
+      return response.json(result);
+
+    } catch (error) {
+      // Record exception and set error status
+      span.recordException(error as Error);
+      span.setStatus({ code: SpanStatusCode.ERROR });
+      context.logger.error('Error running agent:', error);
+      throw error;
+    }
+  });
+}
diff --git a/lib/tutorial/mdx-parser.ts b/lib/tutorial/mdx-parser.ts
index 2239ff16..353fab75 100644
--- a/lib/tutorial/mdx-parser.ts
+++ b/lib/tutorial/mdx-parser.ts
@@ -29,7 +29,7 @@ export async function parseTutorialMDX(filePath: string): Promise<ParsedTutorial
     const [fullMatch, attributes, stepContent] = match;
 
     // Parse attributes
-    const stepNumber = parseInt(extractAttribute(attributes, 'number') || '0');
+    const stepNumber = parseInt(extractAttribute(attributes, 'number') || '1');
     const title = extractAttribute(attributes, 'title') || `Step ${stepNumber}`;
     const estimatedTime = extractAttribute(attributes, 'estimatedTime');
 
@@ -46,7 +46,10 @@ export async function parseTutorialMDX(filePath: string): Promise<ParsedTutorial
   }
 
   const result = {
-    metadata,
+    metadata: {
+      ...metadata,
+      totalSteps: steps.length  // Calculate from actual parsed steps
+    },
     fullContent: content,
     steps: steps.sort((a, b) => a.stepNumber - b.stepNumber)
   };
diff --git a/lib/tutorial/schemas.ts b/lib/tutorial/schemas.ts
index 30716f2e..77c232eb 100644
--- a/lib/tutorial/schemas.ts
+++ b/lib/tutorial/schemas.ts
@@ -19,18 +19,25 @@ export const StepParamsSchema = z.object({
   stepNumber: z.coerce.number().positive('Step number must be a positive number')
 });
 
-// Response schemas for better type safety
+/**
+ * Response schemas for better type safety
+ * Enforces min(1) to filter out modules without interactive steps
+ */
 export const TutorialListItemSchema = z.object({
   id: z.string(),
   title: z.string(),
   description: z.string(),
-  totalSteps: z.number(),
+  totalSteps: z.number().int().min(1, 'Tutorial must have at least one step'),
   difficulty: z.string().optional(),
   estimatedTime: z.string().optional()
 });
 
+/**
+ * Tutorial step data schema
+ * Enforces 1-indexed steps (prevents step 0)
+ */
 export const TutorialStepDataSchema = z.object({
-  stepNumber: z.number(),
+  stepNumber: z.number().int().min(1, 'Step number must be at least 1'),
   title: z.string(),
   estimatedTime: z.string().optional(),
   mdxContent: z.string(),
diff --git a/lib/validation/middleware.ts b/lib/validation/middleware.ts
index 36ed8e7d..4bc87a7b 100644
--- a/lib/validation/middleware.ts
+++ b/lib/validation/middleware.ts
@@ -61,9 +61,14 @@ export async function parseAndValidateJSON<T>(
   return { success: true, data: result.data };
 }
 
+/**
+ * Tutorial progress validation schema
+ * - Steps are 1-indexed (no step 0 concept)
+ * - Only tutorials with interactive steps are tracked
+ */
 export const TutorialProgressRequestSchema = z.object({
   tutorialId: z.string().min(1),
-  currentStep: z.number().int().min(0),
+  currentStep: z.number().int().min(1),
   totalSteps: z.number().int().min(1)
 });
 

From edea5c75047d04a72f02c727c1847a5e81c64e3e Mon Sep 17 00:00:00 2001
From: Seng Rith <50646727+afterrburn@users.noreply.github.com>
Date: Sun, 19 Oct 2025 12:54:19 -0600
Subject: [PATCH 10/13] Seng/add user guided tutorial (#309)

* add get tutorial progress to the tool list

* add markdown converter for callout and CodeExample

* remove unused code blocks

* fix infinite loading session

* add session edit/removal

* Enhance SessionSidebar with clickable session items and improved accessibility attributes

* Add button to move to sandbox

* update sessions fetch scroll

* adjusting scrollbar width

* adjust sessions bar component and chat message display

* optimistic rename/delete session for instantaneous UX

* fix total steps

* remove unnecessary metadata display

* Update dependencies in package.json and bun.lock for @agentuity/sdk and @biomejs/biome

* fix prompt context building

* fix weird streams

---------

Co-authored-by: afterrburn <sun_rsh@outlook.com>
---
 agent-docs/bun.lock                           | 524 +++++++++++++++++-
 agent-docs/package.json                       |   2 +-
 .../src/agents/agent-pulse/context/builder.ts |  85 ++-
 agent-docs/src/agents/agent-pulse/index.ts    |  15 +-
 .../src/agents/agent-pulse/request/parser.ts  |   3 +
 .../src/agents/agent-pulse/request/types.ts   |   1 +
 agent-docs/src/agents/agent-pulse/tools.ts    |  62 ++-
 agent-docs/src/agents/agent-pulse/tutorial.ts |  85 +++
 .../src/agents/doc-processing/chunk-mdx.ts    |  31 +-
 .../doc-processing/keyword-extraction.ts      |  78 ---
 agent-docs/src/agents/doc-qa/prompt.ts        |  68 +--
 agent-docs/src/agents/doc-qa/types.ts         |  10 -
 .../sessions/[sessionId]/messages/route.ts    |   1 +
 app/api/tutorials/[id]/route.ts               |   8 +-
 .../[id]/steps/[stepNumber]/route.ts          |  10 +-
 app/chat/[sessionId]/page.tsx                 | 108 +++-
 app/chat/components/ChatInput.tsx             |   2 +-
 app/chat/components/ChatMessage.tsx           |  14 +-
 app/chat/components/ChatMessagesArea.tsx      |   4 +-
 app/chat/components/SessionSidebar.tsx        | 342 ++++++++----
 .../components/SessionSidebarSkeleton.tsx     |  81 +--
 app/chat/layout.tsx                           |  66 ++-
 app/chat/types.ts                             |   2 +
 app/global.css                                |  33 ++
 components/TutorialStep.tsx                   |  33 +-
 lib/tutorial/mdx-to-markdown.ts               |  67 +++
 26 files changed, 1339 insertions(+), 396 deletions(-)
 delete mode 100644 agent-docs/src/agents/doc-processing/keyword-extraction.ts
 create mode 100644 lib/tutorial/mdx-to-markdown.ts

diff --git a/agent-docs/bun.lock b/agent-docs/bun.lock
index 06db8b03..77afee2e 100644
--- a/agent-docs/bun.lock
+++ b/agent-docs/bun.lock
@@ -4,7 +4,7 @@
     "": {
       "name": "agent-docs",
       "dependencies": {
-        "@agentuity/sdk": "^0.0.124",
+        "@agentuity/sdk": "^0.0.155",
         "@ai-sdk/openai": "^1.3.22",
         "ai": "^4.3.16",
         "gray-matter": "^4.0.3",
@@ -12,7 +12,7 @@
         "vitest": "^3.2.3",
       },
       "devDependencies": {
-        "@biomejs/biome": "^1.9.4",
+        "@biomejs/biome": "2.1.2",
         "@types/bun": "^1.2.16",
       },
       "peerDependencies": {
@@ -21,7 +21,7 @@
     },
   },
   "packages": {
-    "@agentuity/sdk": ["@agentuity/sdk@0.0.124", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/api-logs": "^0.57.2", "@opentelemetry/auto-instrumentations-node": "^0.56.1", "@opentelemetry/core": "^1.21.0", "@opentelemetry/exporter-logs-otlp-http": "^0.57.2", "@opentelemetry/exporter-metrics-otlp-http": "^0.57.2", "@opentelemetry/exporter-trace-otlp-http": "^0.57.2", "@opentelemetry/host-metrics": "^0.35.5", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-logs": "^0.57.2", "@opentelemetry/sdk-metrics": "^1.30.1", "@opentelemetry/sdk-node": "^0.57.2", "@opentelemetry/semantic-conventions": "^1.30.0", "js-yaml": "^4.1.0", "mailparser": "^3.7.3", "nodemailer": "^7.0.3" }, "peerDependencies": { "typescript": "^5" } }, "sha512-bikpoDWzulygUuifPtMzBBZtyGs2stcyD4KjwWmbt8Oi/HSEuXEOPLVH1OxuPLmNccePqPVpkWWkdrEdU2bxwA=="],
+    "@agentuity/sdk": ["@agentuity/sdk@0.0.155", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/api-logs": "^0.57.2", "@opentelemetry/auto-instrumentations-node": "^0.56.1", "@opentelemetry/core": "^1.21.0", "@opentelemetry/exporter-logs-otlp-http": "^0.57.2", "@opentelemetry/exporter-metrics-otlp-http": "^0.57.2", "@opentelemetry/exporter-trace-otlp-http": "^0.57.2", "@opentelemetry/host-metrics": "^0.35.5", "@opentelemetry/resources": "^1.30.1", "@opentelemetry/sdk-logs": "^0.57.2", "@opentelemetry/sdk-metrics": "^1.30.1", "@opentelemetry/sdk-node": "^0.57.2", "@opentelemetry/semantic-conventions": "^1.30.0", "@traceloop/node-server-sdk": "^0.18.1", "js-yaml": "^4.1.0", "mailparser": "^3.7.4", "nodemailer": "^7.0.3" }, "peerDependencies": { "botbuilder": "^4.23.2", "typescript": "^5" } }, "sha512-ae0V0gO6IvkTxxQkUcPfSiSMWP9bbf397OtEX3i1s8AE/QUb3dAVLqOvkYCkk4AHM1V5rHTr4hqb6fp49QDQ5g=="],
 
     "@ai-sdk/openai": ["@ai-sdk/openai@1.3.22", "", { "dependencies": { "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8" }, "peerDependencies": { "zod": "^3.0.0" } }, "sha512-QwA+2EkG0QyjVR+7h6FE7iOu2ivNqAVMm9UJZkVxxTk5OIq5fFJDTEI/zICEMuHImTTXR2JjsL6EirJ28Jc4cw=="],
 
@@ -33,23 +33,47 @@
 
     "@ai-sdk/ui-utils": ["@ai-sdk/ui-utils@1.2.11", "", { "dependencies": { "@ai-sdk/provider": "1.1.3", "@ai-sdk/provider-utils": "2.2.8", "zod-to-json-schema": "^3.24.1" }, "peerDependencies": { "zod": "^3.23.8" } }, "sha512-3zcwCc8ezzFlwp3ZD15wAPjf2Au4s3vAbKsXQVyhxODHcmu0iyPO2Eua6D/vicq/AUm/BAo60r97O6HU+EI0+w=="],
 
-    "@biomejs/biome": ["@biomejs/biome@1.9.4", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "1.9.4", "@biomejs/cli-darwin-x64": "1.9.4", "@biomejs/cli-linux-arm64": "1.9.4", "@biomejs/cli-linux-arm64-musl": "1.9.4", "@biomejs/cli-linux-x64": "1.9.4", "@biomejs/cli-linux-x64-musl": "1.9.4", "@biomejs/cli-win32-arm64": "1.9.4", "@biomejs/cli-win32-x64": "1.9.4" }, "bin": { "biome": "bin/biome" } }, "sha512-1rkd7G70+o9KkTn5KLmDYXihGoTaIGO9PIIN2ZB7UJxFrWw04CZHPYiMRjYsaDvVV7hP1dYNRLxSANLaBFGpog=="],
+    "@azure/abort-controller": ["@azure/abort-controller@2.1.2", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-nBrLsEWm4J2u5LpAPjxADTlq3trDgVZZXHNKabeXZtpq3d3AbN/KGO82R87rdDz5/lYB024rtEf10/q0urNgsA=="],
 
-    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@1.9.4", "", { "os": "darwin", "cpu": "arm64" }, "sha512-bFBsPWrNvkdKrNCYeAp+xo2HecOGPAy9WyNyB/jKnnedgzl4W4Hb9ZMzYNbf8dMCGmUdSavlYHiR01QaYR58cw=="],
+    "@azure/core-auth": ["@azure/core-auth@1.10.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-util": "^1.13.0", "tslib": "^2.6.2" } }, "sha512-ykRMW8PjVAn+RS6ww5cmK9U2CyH9p4Q88YJwvUslfuMmN98w/2rdGRLPqJYObapBCdzBVeDgYWdJnFPFb7qzpg=="],
 
-    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@1.9.4", "", { "os": "darwin", "cpu": "x64" }, "sha512-ngYBh/+bEedqkSevPVhLP4QfVPCpb+4BBe2p7Xs32dBgs7rh9nY2AIYUL6BgLw1JVXV8GlpKmb/hNiuIxfPfZg=="],
+    "@azure/core-client": ["@azure/core-client@1.10.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-auth": "^1.10.0", "@azure/core-rest-pipeline": "^1.22.0", "@azure/core-tracing": "^1.3.0", "@azure/core-util": "^1.13.0", "@azure/logger": "^1.3.0", "tslib": "^2.6.2" } }, "sha512-Nh5PhEOeY6PrnxNPsEHRr9eimxLwgLlpmguQaHKBinFYA/RU9+kOYVOQqOrTsCL+KSxrLLl1gD8Dk5BFW/7l/w=="],
 
-    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-fJIW0+LYujdjUgJJuwesP4EjIBl/N/TcOX3IvIHJQNsAqvV2CHIogsmA94BPG6jZATS4Hi+xv4SkBBQSt1N4/g=="],
+    "@azure/core-http-compat": ["@azure/core-http-compat@2.3.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-client": "^1.10.0", "@azure/core-rest-pipeline": "^1.22.0" } }, "sha512-az9BkXND3/d5VgdRRQVkiJb2gOmDU8Qcq4GvjtBmDICNiQ9udFmDk4ZpSB5Qq1OmtDJGlQAfBaS4palFsazQ5g=="],
 
-    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@1.9.4", "", { "os": "linux", "cpu": "arm64" }, "sha512-v665Ct9WCRjGa8+kTr0CzApU0+XXtRgwmzIf1SeKSGAv+2scAlW6JR5PMFo6FzqqZ64Po79cKODKf3/AAmECqA=="],
+    "@azure/core-rest-pipeline": ["@azure/core-rest-pipeline@1.22.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-auth": "^1.10.0", "@azure/core-tracing": "^1.3.0", "@azure/core-util": "^1.13.0", "@azure/logger": "^1.3.0", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "sha512-UVZlVLfLyz6g3Hy7GNDpooMQonUygH7ghdiSASOOHy97fKj/mPLqgDX7aidOijn+sCMU+WU8NjlPlNTgnvbcGA=="],
 
-    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-lRCJv/Vi3Vlwmbd6K+oQ0KhLHMAysN8lXoCI7XeHlxaajk06u7G+UsFSO01NAs5iYuWKmVZjmiOzJ0OJmGsMwg=="],
+    "@azure/core-tracing": ["@azure/core-tracing@1.3.1", "", { "dependencies": { "tslib": "^2.6.2" } }, "sha512-9MWKevR7Hz8kNzzPLfX4EAtGM2b8mr50HPDBvio96bURP/9C+HjdH3sBlLSNNrvRAr5/k/svoH457gB5IKpmwQ=="],
 
-    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@1.9.4", "", { "os": "linux", "cpu": "x64" }, "sha512-gEhi/jSBhZ2m6wjV530Yy8+fNqG8PAinM3oV7CyO+6c3CEh16Eizm21uHVsyVBEB6RIM8JHIl6AGYCv6Q6Q9Tg=="],
+    "@azure/core-util": ["@azure/core-util@1.13.1", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "sha512-XPArKLzsvl0Hf0CaGyKHUyVgF7oDnhKoP85Xv6M4StF/1AhfORhZudHtOyf2s+FcbuQ9dPRAjB8J2KvRRMUK2A=="],
 
-    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@1.9.4", "", { "os": "win32", "cpu": "arm64" }, "sha512-tlbhLk+WXZmgwoIKwHIHEBZUwxml7bRJgk0X2sPyNR3S93cdRq6XulAZRQJ17FYGGzWne0fgrXBKpl7l4M87Hg=="],
+    "@azure/identity": ["@azure/identity@4.13.0", "", { "dependencies": { "@azure/abort-controller": "^2.0.0", "@azure/core-auth": "^1.9.0", "@azure/core-client": "^1.9.2", "@azure/core-rest-pipeline": "^1.17.0", "@azure/core-tracing": "^1.0.0", "@azure/core-util": "^1.11.0", "@azure/logger": "^1.0.0", "@azure/msal-browser": "^4.2.0", "@azure/msal-node": "^3.5.0", "open": "^10.1.0", "tslib": "^2.2.0" } }, "sha512-uWC0fssc+hs1TGGVkkghiaFkkS7NkTxfnCH+Hdg+yTehTpMcehpok4PgUKKdyCH+9ldu6FhiHRv84Ntqj1vVcw=="],
 
-    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@1.9.4", "", { "os": "win32", "cpu": "x64" }, "sha512-8Y5wMhVIPaWe6jw2H+KlEm4wP/f7EW3810ZLmDlrEEy5KvBsb9ECEfu/kMWD484ijfQ8+nIi0giMgu9g1UAuuA=="],
+    "@azure/logger": ["@azure/logger@1.3.0", "", { "dependencies": { "@typespec/ts-http-runtime": "^0.3.0", "tslib": "^2.6.2" } }, "sha512-fCqPIfOcLE+CGqGPd66c8bZpwAji98tZ4JI9i/mlTNTlsIWslCfpg48s/ypyLxZTump5sypjrKn2/kY7q8oAbA=="],
+
+    "@azure/msal-browser": ["@azure/msal-browser@4.25.0", "", { "dependencies": { "@azure/msal-common": "15.13.0" } }, "sha512-kbL+Ae7/UC62wSzxirZddYeVnHvvkvAnSZkBqL55X+jaSXTAXfngnNsDM5acEWU0Q/SAv3gEQfxO1igWOn87Pg=="],
+
+    "@azure/msal-common": ["@azure/msal-common@14.16.1", "", {}, "sha512-nyxsA6NA4SVKh5YyRpbSXiMr7oQbwark7JU9LMeg6tJYTSPyAGkdx61wPT4gyxZfxlSxMMEyAsWaubBlNyIa1w=="],
+
+    "@azure/msal-node": ["@azure/msal-node@2.16.3", "", { "dependencies": { "@azure/msal-common": "14.16.1", "jsonwebtoken": "^9.0.0", "uuid": "^8.3.0" } }, "sha512-CO+SE4weOsfJf+C5LM8argzvotrXw252/ZU6SM2Tz63fEblhH1uuVaaO4ISYFuN4Q6BhTo7I3qIdi8ydUQCqhw=="],
+
+    "@biomejs/biome": ["@biomejs/biome@2.1.2", "", { "optionalDependencies": { "@biomejs/cli-darwin-arm64": "2.1.2", "@biomejs/cli-darwin-x64": "2.1.2", "@biomejs/cli-linux-arm64": "2.1.2", "@biomejs/cli-linux-arm64-musl": "2.1.2", "@biomejs/cli-linux-x64": "2.1.2", "@biomejs/cli-linux-x64-musl": "2.1.2", "@biomejs/cli-win32-arm64": "2.1.2", "@biomejs/cli-win32-x64": "2.1.2" }, "bin": { "biome": "bin/biome" } }, "sha512-yq8ZZuKuBVDgAS76LWCfFKHSYIAgqkxVB3mGVVpOe2vSkUTs7xG46zXZeNPRNVjiJuw0SZ3+J2rXiYx0RUpfGg=="],
+
+    "@biomejs/cli-darwin-arm64": ["@biomejs/cli-darwin-arm64@2.1.2", "", { "os": "darwin", "cpu": "arm64" }, "sha512-leFAks64PEIjc7MY/cLjE8u5OcfBKkcDB0szxsWUB4aDfemBep1WVKt0qrEyqZBOW8LPHzrFMyDl3FhuuA0E7g=="],
+
+    "@biomejs/cli-darwin-x64": ["@biomejs/cli-darwin-x64@2.1.2", "", { "os": "darwin", "cpu": "x64" }, "sha512-Nmmv7wRX5Nj7lGmz0FjnWdflJg4zii8Ivruas6PBKzw5SJX/q+Zh2RfnO+bBnuKLXpj8kiI2x2X12otpH6a32A=="],
+
+    "@biomejs/cli-linux-arm64": ["@biomejs/cli-linux-arm64@2.1.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-NWNy2Diocav61HZiv2enTQykbPP/KrA/baS7JsLSojC7Xxh2nl9IczuvE5UID7+ksRy2e7yH7klm/WkA72G1dw=="],
+
+    "@biomejs/cli-linux-arm64-musl": ["@biomejs/cli-linux-arm64-musl@2.1.2", "", { "os": "linux", "cpu": "arm64" }, "sha512-qgHvafhjH7Oca114FdOScmIKf1DlXT1LqbOrrbR30kQDLFPEOpBG0uzx6MhmsrmhGiCFCr2obDamu+czk+X0HQ=="],
+
+    "@biomejs/cli-linux-x64": ["@biomejs/cli-linux-x64@2.1.2", "", { "os": "linux", "cpu": "x64" }, "sha512-Km/UYeVowygTjpX6sGBzlizjakLoMQkxWbruVZSNE6osuSI63i4uCeIL+6q2AJlD3dxoiBJX70dn1enjQnQqwA=="],
+
+    "@biomejs/cli-linux-x64-musl": ["@biomejs/cli-linux-x64-musl@2.1.2", "", { "os": "linux", "cpu": "x64" }, "sha512-xlB3mU14ZUa3wzLtXfmk2IMOGL+S0aHFhSix/nssWS/2XlD27q+S6f0dlQ8WOCbYoXcuz8BCM7rCn2lxdTrlQA=="],
+
+    "@biomejs/cli-win32-arm64": ["@biomejs/cli-win32-arm64@2.1.2", "", { "os": "win32", "cpu": "arm64" }, "sha512-G8KWZli5ASOXA3yUQgx+M4pZRv3ND16h77UsdunUL17uYpcL/UC7RkWTdkfvMQvogVsAuz5JUcBDjgZHXxlKoA=="],
+
+    "@biomejs/cli-win32-x64": ["@biomejs/cli-win32-x64@2.1.2", "", { "os": "win32", "cpu": "x64" }, "sha512-9zajnk59PMpjBkty3bK2IrjUsUHvqe9HWwyAWQBjGLE7MIBjbX2vwv1XPEhmO2RRuGoTkVx3WCanHrjAytICLA=="],
 
     "@cfworker/json-schema": ["@cfworker/json-schema@4.1.1", "", {}, "sha512-gAmrUZSGtKc3AiBL71iNWxDsyUC5uMaKKGdvzYsBoTW/xi42JQHl7eKV2OYzCUqvc+D2RCcf7EXY2iCyFIk6og=="],
 
@@ -271,6 +295,8 @@
 
     "@opentelemetry/sql-common": ["@opentelemetry/sql-common@0.40.1", "", { "dependencies": { "@opentelemetry/core": "^1.1.0" }, "peerDependencies": { "@opentelemetry/api": "^1.1.0" } }, "sha512-nSDlnHSqzC3pXn/wZEZVLuAuJ1MYMXPBwtv2qAbCa3847SaHItdE7SzUq/Jtb0KZmh1zfAbNi3AAMjztTT4Ugg=="],
 
+    "@posthog/core": ["@posthog/core@1.3.0", "", {}, "sha512-hxLL8kZNHH098geedcxCz8y6xojkNYbmJEW+1vFXsmPcExyCXIUUJ/34X6xa9GcprKxd0Wsx3vfJQLQX4iVPhw=="],
+
     "@protobufjs/aspromise": ["@protobufjs/aspromise@1.1.2", "", {}, "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ=="],
 
     "@protobufjs/base64": ["@protobufjs/base64@1.1.2", "", {}, "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg=="],
@@ -333,12 +359,42 @@
 
     "@selderee/plugin-htmlparser2": ["@selderee/plugin-htmlparser2@0.11.0", "", { "dependencies": { "domhandler": "^5.0.3", "selderee": "^0.11.0" } }, "sha512-P33hHGdldxGabLFjPPpaTxVolMrzrcegejx+0GxjrIb9Zv48D8yAIA/QTDR2dFl7Uz7urX8aX6+5bCZslr+gWQ=="],
 
+    "@tootallnate/once": ["@tootallnate/once@2.0.0", "", {}, "sha512-XCuKFP5PS55gnMVu3dty8KPatLqUoy/ZYzDzAGCQ8JNFCkLXzmI7vNHCR+XpbZaMWQK/vQubr7PkYq8g470J/A=="],
+
+    "@traceloop/ai-semantic-conventions": ["@traceloop/ai-semantic-conventions@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0" } }, "sha512-2pOKIG1aE+S/1MzLZKY2qM13ccTM6TtmJm/jk7MfEb9CHwfNi9cjqqrK5uNOZqcGBw5vwfy2G2U8GTNHD9CxYQ=="],
+
+    "@traceloop/instrumentation-anthropic": ["@traceloop/instrumentation-anthropic@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-Qe7U8YwCPoPSurVqwH8wwmvd2ZDPXc2kKPMICAeqZ9vn+K5WNkazZoc0omnx7R3IqO+MTlWudtLtPQmFkHquUw=="],
+
+    "@traceloop/instrumentation-bedrock": ["@traceloop/instrumentation-bedrock@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-0yc97AfswPLOSite9CXtTopsh9i+z0mQ+e/pqZHSFQ+eYIPViIBKBZBx0Sj9H+LpWAwtdHfkAzqiuIjreqLjxg=="],
+
+    "@traceloop/instrumentation-chromadb": ["@traceloop/instrumentation-chromadb@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-tTt//Z6g3S5dD1cKCpusXBZk8E6S3X+0vWAPiopxL6cRrocS922R6yFq3wzrn8y7v82CyzdYBN8TDG6QS89PFA=="],
+
+    "@traceloop/instrumentation-cohere": ["@traceloop/instrumentation-cohere@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-VgaDw/fIEKfRtHWodUzSkI5jR1T83gP2lLsxwE4sEnK0Fni0XWidZMmRAh4sY6WP/eFT6dZGX+HeObTXKNwNDA=="],
+
+    "@traceloop/instrumentation-langchain": ["@traceloop/instrumentation-langchain@0.18.0", "", { "dependencies": { "@langchain/core": "^0.3.70", "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-dQOm4VpK5BvwK5IQE7AUuarVpmv/RhVL3FuHKHG/1Dq3JVcRh9bKQkgtQuRXXdaZRjvDC6CjzRcLtFJu1lF8AQ=="],
+
+    "@traceloop/instrumentation-llamaindex": ["@traceloop/instrumentation-llamaindex@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "lodash": "^4.17.21", "tslib": "^2.8.1" } }, "sha512-cKKMcJHOElIwtThBmOdVvEA3BYAbJCUAY93Y5Wl0clIisW05wnA+wfHBLzIn+p5xtyYLc98MtIvbY1nrPpt35Q=="],
+
+    "@traceloop/instrumentation-openai": ["@traceloop/instrumentation-openai@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "js-tiktoken": "^1.0.20", "tslib": "^2.8.1" } }, "sha512-xEtpr85dWKZy2yGnfLBIlnINE6Ia99QLrd+DuSyba4gEl000C1GTniRBZGE3SzqUaYrcTeCROgbcwzh60crCCw=="],
+
+    "@traceloop/instrumentation-pinecone": ["@traceloop/instrumentation-pinecone@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-vN/dSlewK+0rQ/SVIvEEpvLUB4brk+fyp5vc0VIer0lQHTMBRbaIH6ffrVgSEiUKzgkPSUa81G3iTbK2ngzldg=="],
+
+    "@traceloop/instrumentation-qdrant": ["@traceloop/instrumentation-qdrant@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@traceloop/ai-semantic-conventions": "0.18.0", "tslib": "^2.8.1" } }, "sha512-t1/6ofRwz1eOVBP9Aoj0jQuHl1emFAX8XRK3QAJy/mDy5BiPkN8Zkk46l0pwLHJFe1woQZqAoAn8vlaRgBoicA=="],
+
+    "@traceloop/instrumentation-together": ["@traceloop/instrumentation-together@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "js-tiktoken": "^1.0.20", "tslib": "^2.8.1" } }, "sha512-xsEwQgmWvBNn6Iab+AbA3xWxxZBcQCIB1/yFjCQeKr4n/LyZVHZ4Lrbu2n/h3qVkvK2C0gUsk2VwoJTGRSTHIg=="],
+
+    "@traceloop/instrumentation-vertexai": ["@traceloop/instrumentation-vertexai@0.18.0", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "google-gax": "^4.0.0", "tslib": "^2.8.1" } }, "sha512-k0aaIJh60rYTNh9oOIyGNL8BOQ5Qw53eo75nb1fRvHbUqBPPmqxQJGHOoxM2LkfZq5fm4I2rHav8Cu9zCp/V1w=="],
+
+    "@traceloop/node-server-sdk": ["@traceloop/node-server-sdk@0.18.1", "", { "dependencies": { "@opentelemetry/api": "^1.9.0", "@opentelemetry/core": "^2.0.1", "@opentelemetry/exporter-trace-otlp-proto": "^0.203.0", "@opentelemetry/instrumentation": "^0.203.0", "@opentelemetry/resources": "^2.0.1", "@opentelemetry/sdk-node": "^0.203.0", "@opentelemetry/sdk-trace-base": "^2.0.1", "@opentelemetry/sdk-trace-node": "^2.0.1", "@opentelemetry/semantic-conventions": "^1.36.0", "@traceloop/ai-semantic-conventions": "0.18.0", "@traceloop/instrumentation-anthropic": "0.18.0", "@traceloop/instrumentation-bedrock": "0.18.0", "@traceloop/instrumentation-chromadb": "0.18.0", "@traceloop/instrumentation-cohere": "0.18.0", "@traceloop/instrumentation-langchain": "0.18.0", "@traceloop/instrumentation-llamaindex": "0.18.0", "@traceloop/instrumentation-openai": "0.18.0", "@traceloop/instrumentation-pinecone": "0.18.0", "@traceloop/instrumentation-qdrant": "0.18.0", "@traceloop/instrumentation-together": "0.18.0", "@traceloop/instrumentation-vertexai": "0.18.0", "@types/nunjucks": "^3.2.6", "cross-fetch": "^4.1.0", "eventsource": "^3.0.2", "fetch-retry": "^6.0.0", "nunjucks": "^3.2.4", "papaparse": "^5.5.3", "posthog-node": "^5.5.1", "supports-color": "^10.0.0", "tslib": "^2.8.1", "uuid": "^11.1.0" } }, "sha512-s/QuVHBM1E6KsBoPbOhyIHEKbwmYJqcJezVHvMoS/OOj1bQOp+3hiFOhdFovSpv67nxWODUcbucZyK36bL3FdA=="],
+
     "@types/aws-lambda": ["@types/aws-lambda@8.10.147", "", {}, "sha512-nD0Z9fNIZcxYX5Mai2CTmFD7wX7UldCkW2ezCF8D1T5hdiLsnTWDGRpfRYntU6VjTdLQjOvyszru7I1c1oCQew=="],
 
     "@types/bun": ["@types/bun@1.2.16", "", { "dependencies": { "bun-types": "1.2.16" } }, "sha512-1aCZJ/6nSiViw339RsaNhkNoEloLaPzZhxMOYEa7OzRzO41IGg5n/7I43/ZIAW/c+Q6cT12Vf7fOZOoVIzb5BQ=="],
 
     "@types/bunyan": ["@types/bunyan@1.8.11", "", { "dependencies": { "@types/node": "*" } }, "sha512-758fRH7umIMk5qt5ELmRMff4mLDlN+xyYzC+dkPTdKwbSkJFvz6xwyScrytPU0QIBbRRwbiE8/BIg8bpajerNQ=="],
 
+    "@types/caseless": ["@types/caseless@0.12.5", "", {}, "sha512-hWtVTC2q7hc7xZ/RLbxapMvDMgUnDvKvMOpKal4DrMyfGBUfB1oKaZlIRr6mJL+If3bAP6sV/QneGzF6tJjZDg=="],
+
     "@types/chai": ["@types/chai@5.2.2", "", { "dependencies": { "@types/deep-eql": "*" } }, "sha512-8kB30R7Hwqf40JPiKhVzodJs2Qc1ZJ5zuT3uzw5Hq/dhNCl3G3l83jfpdI1e20BP348+fV7VIL/+FxaXkqBmWg=="],
 
     "@types/connect": ["@types/connect@3.4.38", "", { "dependencies": { "@types/node": "*" } }, "sha512-K6uROf1LD88uDQqJCktA4yzL1YYAK6NgfsI0v/mTgyPKWsX1CnJ0XPSDhViejru1GcRkLWb8RlzFYJRqGUbaug=="],
@@ -349,6 +405,10 @@
 
     "@types/estree": ["@types/estree@1.0.8", "", {}, "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="],
 
+    "@types/jsonwebtoken": ["@types/jsonwebtoken@9.0.6", "", { "dependencies": { "@types/node": "*" } }, "sha512-/5hndP5dCjloafCXns6SZyESp3Ldq7YjH3zwzwczYnjxIT0Fqzk5ROSYVGfFyczIue7IUEj8hkvLbPoLQ18vQw=="],
+
+    "@types/long": ["@types/long@4.0.2", "", {}, "sha512-MqTGEo5bj5t157U6fA/BiDynNkn0YknVdh48CMPkTSpFTVmvao5UQmm7uEF6xBEo7qIMAlY/JSleYaE6VOdpaA=="],
+
     "@types/memcached": ["@types/memcached@2.2.10", "", { "dependencies": { "@types/node": "*" } }, "sha512-AM9smvZN55Gzs2wRrqeMHVP7KE8KWgCJO/XL5yCly2xF6EKa4YlbpK+cLSAH4NG/Ah64HrlegmGqW8kYws7Vxg=="],
 
     "@types/mysql": ["@types/mysql@2.15.26", "", { "dependencies": { "@types/node": "*" } }, "sha512-DSLCOXhkvfS5WNNPbfn2KdICAmk8lLc+/PNvnPnF7gOdMZCxopXduqv0OQ13y/yA/zXTSikZZqVgybUxOEg6YQ=="],
@@ -357,18 +417,28 @@
 
     "@types/node-fetch": ["@types/node-fetch@2.6.12", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.0" } }, "sha512-8nneRWKCg3rMtF69nLQJnOYUcbafYeFSjqkw3jCRLsqkWFlHaoQrr5mXmofFGOx3DKn7UfmBMyov8ySvLRVldA=="],
 
+    "@types/nunjucks": ["@types/nunjucks@3.2.6", "", {}, "sha512-pHiGtf83na1nCzliuAdq8GowYiXvH5l931xZ0YEHaLMNFgynpEqx+IPStlu7UaDkehfvl01e4x/9Tpwhy7Ue3w=="],
+
     "@types/pg": ["@types/pg@8.6.1", "", { "dependencies": { "@types/node": "*", "pg-protocol": "*", "pg-types": "^2.2.0" } }, "sha512-1Kc4oAGzAl7uqUStZCDvaLFqZrW9qWSjXOmBfdgyBP5La7Us6Mg4GBvRlSoaZMhQF/zSj1C8CtKMBkoiT8eL8w=="],
 
     "@types/pg-pool": ["@types/pg-pool@2.0.6", "", { "dependencies": { "@types/pg": "*" } }, "sha512-TaAUE5rq2VQYxab5Ts7WZhKNmuN78Q6PiFonTDdpbx8a1H0M1vhy3rhiMjl+e2iHmogyMw7jZF4FrE6eJUy5HQ=="],
 
+    "@types/request": ["@types/request@2.48.13", "", { "dependencies": { "@types/caseless": "*", "@types/node": "*", "@types/tough-cookie": "*", "form-data": "^2.5.5" } }, "sha512-FGJ6udDNUCjd19pp0Q3iTiDkwhYup7J8hpMW9c4k53NrccQFFWKRho6hvtPPEhnXWKvukfwAlB6DbDz4yhH5Gg=="],
+
     "@types/retry": ["@types/retry@0.12.0", "", {}, "sha512-wWKOClTTiizcZhXnPY4wikVAwmdYHp8q6DmC+EJUzAMsycb7HB32Kh9RN4+0gExjmPmZSAQjgURXIGATPegAvA=="],
 
     "@types/shimmer": ["@types/shimmer@1.2.0", "", {}, "sha512-UE7oxhQLLd9gub6JKIAhDq06T0F6FnztwMNRvYgjeQSBeMc1ZG/tA47EwfduvkuQS8apbkM/lpLpWsaCeYsXVg=="],
 
     "@types/tedious": ["@types/tedious@4.0.14", "", { "dependencies": { "@types/node": "*" } }, "sha512-KHPsfX/FoVbUGbyYvk1q9MMQHLPeRZhRJZdO45Q4YjvFkv4hMNghCWTvy7rdKessBsmtz4euWCWAB6/tVpI1Iw=="],
 
+    "@types/tough-cookie": ["@types/tough-cookie@4.0.5", "", {}, "sha512-/Ad8+nIOV7Rl++6f1BdKxFSMgmoqEoYbHRpPcx3JEfv8VRsQe9Z4mCXeJBzxs7mbHY/XOZZuXlRNfhpVPbs6ZA=="],
+
     "@types/uuid": ["@types/uuid@10.0.0", "", {}, "sha512-7gqG38EyHgyP1S+7+xomFtL+ZNHcKv6DwNaCZmJmo1vgMugyF3TCnXVg4t1uk89mLNwnLtnY3TpOpCOyp1/xHQ=="],
 
+    "@types/ws": ["@types/ws@6.0.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-PpPrX7SZW9re6+Ha8ojZG4Se8AZXgf0GK6zmfqEuCsY49LFDNXO3SByp44X3dFEqtB73lkCDAdUazhAjVPiNwg=="],
+
+    "@typespec/ts-http-runtime": ["@typespec/ts-http-runtime@0.3.1", "", { "dependencies": { "http-proxy-agent": "^7.0.0", "https-proxy-agent": "^7.0.0", "tslib": "^2.6.2" } }, "sha512-SnbaqayTVFEA6/tYumdF0UmybY0KHyKwGPBXnyckFlrrKdhWFrL3a2HIPXHjht5ZOElKGcXfD2D63P36btb+ww=="],
+
     "@vitest/expect": ["@vitest/expect@3.2.3", "", { "dependencies": { "@types/chai": "^5.2.2", "@vitest/spy": "3.2.3", "@vitest/utils": "3.2.3", "chai": "^5.2.0", "tinyrainbow": "^2.0.0" } }, "sha512-W2RH2TPWVHA1o7UmaFKISPvdicFJH+mjykctJFoAkUw+SPTJTGjUNdKscFBrqM7IPnCVu6zihtKYa7TkZS1dkQ=="],
 
     "@vitest/mocker": ["@vitest/mocker@3.2.3", "", { "dependencies": { "@vitest/spy": "3.2.3", "estree-walker": "^3.0.3", "magic-string": "^0.30.17" }, "peerDependencies": { "msw": "^2.4.9", "vite": "^5.0.0 || ^6.0.0 || ^7.0.0-0" }, "optionalPeers": ["msw", "vite"] }, "sha512-cP6fIun+Zx8he4rbWvi+Oya6goKQDZK+Yq4hhlggwQBbrlOQ4qtZ+G4nxB6ZnzI9lyIb+JnvyiJnPC2AGbKSPA=="],
@@ -383,12 +453,16 @@
 
     "@vitest/utils": ["@vitest/utils@3.2.3", "", { "dependencies": { "@vitest/pretty-format": "3.2.3", "loupe": "^3.1.3", "tinyrainbow": "^2.0.0" } }, "sha512-4zFBCU5Pf+4Z6v+rwnZ1HU1yzOKKvDkMXZrymE2PBlbjKJRlrOxbvpfPSvJTGRIwGoahaOGvp+kbCoxifhzJ1Q=="],
 
+    "a-sync-waterfall": ["a-sync-waterfall@1.0.1", "", {}, "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA=="],
+
     "abort-controller": ["abort-controller@3.0.0", "", { "dependencies": { "event-target-shim": "^5.0.0" } }, "sha512-h8lQ8tacZYnR3vNQTgibj+tODHI5/+l06Au2Pcriv/Gmet0eaj4TwWH41sO9wnHDiQsEj19q0drzdWdeAHtweg=="],
 
     "acorn": ["acorn@8.15.0", "", { "bin": { "acorn": "bin/acorn" } }, "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg=="],
 
     "acorn-import-attributes": ["acorn-import-attributes@1.9.5", "", { "peerDependencies": { "acorn": "^8" } }, "sha512-n02Vykv5uA3eHGM/Z2dQrcD56kL8TyDb2p1+0P83PClMnC/nc+anbQRhIOWnSq4Ke/KvDPrY3C9hDtC/A3eHnQ=="],
 
+    "adaptivecards": ["adaptivecards@1.2.3", "", {}, "sha512-amQ5OSW3OpIkrxVKLjxVBPk/T49yuOtnqs1z5ZPfZr0+OpTovzmiHbyoAGDIsu5SNYHwOZFp/3LGOnRaALFa/g=="],
+
     "agent-base": ["agent-base@7.1.3", "", {}, "sha512-jRR5wdylq8CkOe6hei19GGZnxM6rBGwFl3Bg0YItGDimvjGtAvdZk4Pu6Cl4u4Igsws4a1fd1Vq3ezrhn4KmFw=="],
 
     "agentkeepalive": ["agentkeepalive@4.6.0", "", { "dependencies": { "humanize-ms": "^1.2.1" } }, "sha512-kja8j7PjmncONqaTsB8fQ+wE2mSU2DJ9D4XKoJ5PFWIdRMa6SLSN1ff4mOr4jCbfRSsxR4keIiySJU0N9T5hIQ=="],
@@ -401,16 +475,42 @@
 
     "argparse": ["argparse@2.0.1", "", {}, "sha512-8+9WqebbFzpX9OR+Wa6O29asIogeRMzcGtAINdpMHHyAg10f05aSFVBbcEqGf/PXw1EjAZ+q2/bEBg3DvurK3Q=="],
 
+    "asap": ["asap@2.0.6", "", {}, "sha512-BSHWgDSAiKs50o2Re8ppvp3seVHXSRM44cdSsT9FfNEUUZLOGWVCsiWaRPWM1Znn+mqZ1OfVZ3z3DWEzSp7hRA=="],
+
     "assertion-error": ["assertion-error@2.0.1", "", {}, "sha512-Izi8RQcffqCeNVgFigKli1ssklIbpHnCYc6AknXGYoB6grJqyeby7jv12JUQgmTAnIDnbck1uxksT4dzN3PWBA=="],
 
     "asynckit": ["asynckit@0.4.0", "", {}, "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q=="],
 
+    "axios": ["axios@1.12.2", "", { "dependencies": { "follow-redirects": "^1.15.6", "form-data": "^4.0.4", "proxy-from-env": "^1.1.0" } }, "sha512-vMJzPewAlRyOgxV2dU0Cuz2O8zzzx9VYtbJOaBgXFeLc4IV/Eg50n4LowmehOOR61S8ZMpc2K5Sa7g6A4jfkUw=="],
+
     "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
 
+    "base64url": ["base64url@3.0.1", "", {}, "sha512-ir1UPr3dkwexU7FdV8qBBbNDRUhMmIekYMFZfi+C/sLNnRESKPl23nB9b2pltqfOQNnGzsDdId90AEtG5tCx4A=="],
+
     "bignumber.js": ["bignumber.js@9.3.0", "", {}, "sha512-EM7aMFTXbptt/wZdMlBv2t8IViwQL+h6SLHosp8Yf0dqJMTnY6iL32opnAB6kAdL0SZPuvcAzFr31o0c/R3/RA=="],
 
+    "botbuilder": ["botbuilder@4.23.3", "", { "dependencies": { "@azure/core-rest-pipeline": "^1.18.1", "@azure/msal-node": "^2.13.1", "axios": "^1.8.2", "botbuilder-core": "4.23.3", "botbuilder-stdlib": "4.23.3-internal", "botframework-connector": "4.23.3", "botframework-schema": "4.23.3", "botframework-streaming": "4.23.3", "dayjs": "^1.11.13", "filenamify": "^6.0.0", "fs-extra": "^11.2.0", "htmlparser2": "^9.0.1", "uuid": "^10.0.0", "zod": "^3.23.8" } }, "sha512-1gDIQHHYosYBHGXMjvZEJDrcp3NGy3lzHBml5wn9PFqVuIk/cbsCDZs3KJ3g+aH/GGh4CH/ij9iQ2KbQYHAYKA=="],
+
+    "botbuilder-core": ["botbuilder-core@4.23.3", "", { "dependencies": { "botbuilder-dialogs-adaptive-runtime-core": "4.23.3-preview", "botbuilder-stdlib": "4.23.3-internal", "botframework-connector": "4.23.3", "botframework-schema": "4.23.3", "uuid": "^10.0.0", "zod": "^3.23.8" } }, "sha512-48iW739I24piBH683b/Unvlu1fSzjB69ViOwZ0PbTkN2yW5cTvHJWlW7bXntO8GSqJfssgPaVthKfyaCW457ig=="],
+
+    "botbuilder-dialogs-adaptive-runtime-core": ["botbuilder-dialogs-adaptive-runtime-core@4.23.3-preview", "", { "dependencies": { "dependency-graph": "^1.0.0" } }, "sha512-EssyvqK9MobX3gbnUe/jjhLuxpCEeyQeQsyUFMJ236U6vzSQdrAxNH7Jc5DyZw2KKelBdK1xPBdwTYQNM5S0Qw=="],
+
+    "botbuilder-stdlib": ["botbuilder-stdlib@4.23.3-internal", "", { "dependencies": { "@azure/abort-controller": "^2.1.2", "@azure/core-auth": "^1.9.0", "@azure/core-client": "^1.9.2", "@azure/core-http-compat": "^2.1.2", "@azure/core-rest-pipeline": "^1.18.1", "@azure/core-tracing": "^1.2.0" } }, "sha512-fwvIHnKU8sXo1gTww+m/k8wnuM5ktVBAV/3vWJ+ou40zapy1HYjWQuu6sVCRFgMUngpKwhdmoOQsTXsp58SNtA=="],
+
+    "botframework-connector": ["botframework-connector@4.23.3", "", { "dependencies": { "@azure/core-rest-pipeline": "^1.18.1", "@azure/identity": "^4.4.1", "@azure/msal-node": "^2.13.1", "@types/jsonwebtoken": "9.0.6", "axios": "^1.8.2", "base64url": "^3.0.0", "botbuilder-stdlib": "4.23.3-internal", "botframework-schema": "4.23.3", "buffer": "^6.0.3", "cross-fetch": "^4.0.0", "https-proxy-agent": "^7.0.5", "jsonwebtoken": "^9.0.2", "node-fetch": "^2.7.0", "openssl-wrapper": "^0.3.4", "rsa-pem-from-mod-exp": "^0.8.6", "zod": "^3.23.8" } }, "sha512-sChwCFJr3xhcMCYChaOxJoE8/YgdjOPWzGwz5JAxZDwhbQonwYX5O/6Z9EA+wB3TCFNEh642SGeC/rOitaTnGQ=="],
+
+    "botframework-schema": ["botframework-schema@4.23.3", "", { "dependencies": { "adaptivecards": "1.2.3", "uuid": "^10.0.0", "zod": "^3.23.8" } }, "sha512-/W0uWxZ3fuPLAImZRLnPTbs49Z2xMpJSIzIBxSfvwO0aqv9GsM3bTk3zlNdJ1xr40SshQ7WiH2H1hgjBALwYJw=="],
+
+    "botframework-streaming": ["botframework-streaming@4.23.3", "", { "dependencies": { "@types/ws": "^6.0.3", "uuid": "^10.0.0", "ws": "^7.5.10" } }, "sha512-GMtciQGfZXtAW6syUqFpFJQ2vDyVbpxL3T1DqFzq/GmmkAu7KTZ1zvo7PTww6+IT1kMW0lmL/XZJVq3Rhg4PQA=="],
+
+    "buffer": ["buffer@6.0.3", "", { "dependencies": { "base64-js": "^1.3.1", "ieee754": "^1.2.1" } }, "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA=="],
+
+    "buffer-equal-constant-time": ["buffer-equal-constant-time@1.0.1", "", {}, "sha512-zRpUiDwd/xk6ADqPMATG8vc9VPrkck7T07OIx0gnjmJAnHnTVXNQG3vfvWNuiZIkwu9KrKdA1iJKfsfTVxE6NA=="],
+
     "bun-types": ["bun-types@1.2.16", "", { "dependencies": { "@types/node": "*" } }, "sha512-ciXLrHV4PXax9vHvUrkvun9VPVGOVwbbbBF/Ev1cXz12lyEZMoJpIJABOfPcN9gDJRaiKF9MVbSygLg4NXu3/A=="],
 
+    "bundle-name": ["bundle-name@4.1.0", "", { "dependencies": { "run-applescript": "^7.0.0" } }, "sha512-tjwM5exMg6BGRI+kNmTntNsvdZS1X8BFYS6tnJ2hdH0kVxM6/eVZ2xy+FqStSWvYmtfFMDLIxurorHwDKfDz5Q=="],
+
     "cac": ["cac@6.7.14", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
 
     "call-bind-apply-helpers": ["call-bind-apply-helpers@1.0.2", "", { "dependencies": { "es-errors": "^1.3.0", "function-bind": "^1.1.2" } }, "sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ=="],
@@ -433,8 +533,14 @@
 
     "combined-stream": ["combined-stream@1.0.8", "", { "dependencies": { "delayed-stream": "~1.0.0" } }, "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg=="],
 
+    "commander": ["commander@5.1.0", "", {}, "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg=="],
+
     "console-table-printer": ["console-table-printer@2.14.3", "", { "dependencies": { "simple-wcswidth": "^1.0.1" } }, "sha512-X5OCFnjYlXzRuC8ac5hPA2QflRjJvNKJocMhlnqK/Ap7q3DHXr0NJ0TGzwmEKOiOdJrjsSwEd0m+a32JAYPrKQ=="],
 
+    "cross-fetch": ["cross-fetch@4.1.0", "", { "dependencies": { "node-fetch": "^2.7.0" } }, "sha512-uKm5PU+MHTootlWEY+mZ4vvXoCn4fLQxT9dSc1sXVMSFkINTJVN8cAQROpwcKm8bJ/c7rgZVIBWzH5T78sNZZw=="],
+
+    "dayjs": ["dayjs@1.11.18", "", {}, "sha512-zFBQ7WFRvVRhKcWoUh+ZA1g2HVgUbsZm9sbddh8EC5iv93sui8DVVz1Npvz+r6meo9VKfa8NyLWBsQK1VvIKPA=="],
+
     "debug": ["debug@4.4.1", "", { "dependencies": { "ms": "^2.1.3" } }, "sha512-KcKCqiftBJcZr++7ykoDIEwSa3XWowTfNPo92BYxjXiyYEVrUQh2aLyhxBCwww+heortUFxEJYcRzosstTEBYQ=="],
 
     "decamelize": ["decamelize@1.2.0", "", {}, "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA=="],
@@ -443,8 +549,16 @@
 
     "deepmerge": ["deepmerge@4.3.1", "", {}, "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A=="],
 
+    "default-browser": ["default-browser@5.2.1", "", { "dependencies": { "bundle-name": "^4.1.0", "default-browser-id": "^5.0.0" } }, "sha512-WY/3TUME0x3KPYdRRxEJJvXRHV4PyPoUsxtZa78lwItwRQRHhd2U9xOscaT/YTf8uCXIAjeJOFBVEh/7FtD8Xg=="],
+
+    "default-browser-id": ["default-browser-id@5.0.0", "", {}, "sha512-A6p/pu/6fyBcA1TRz/GqWYPViplrftcW2gZC9q79ngNCKAeR/X3gcEdXQHl4KNXV+3wgIJ1CPkJQ3IHM6lcsyA=="],
+
+    "define-lazy-prop": ["define-lazy-prop@3.0.0", "", {}, "sha512-N+MeXYoqr3pOgn8xfyRPREN7gHakLYjhsHhWGT3fWAiL4IkAt0iDw14QiiEm2bE30c5XX5q0FtAA3CK5f9/BUg=="],
+
     "delayed-stream": ["delayed-stream@1.0.0", "", {}, "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ=="],
 
+    "dependency-graph": ["dependency-graph@1.0.0", "", {}, "sha512-cW3gggJ28HZ/LExwxP2B++aiKxhJXMSIt9K48FOXQkm+vuG5gyatXnLsONRJdzO/7VfjDIiaOOa/bs4l464Lwg=="],
+
     "dequal": ["dequal@2.0.3", "", {}, "sha512-0je+qPKHEMohvfRTCEo3CrPG6cAzAYgmzKyxRiYSSDkS6eGJdyVJm7WaYA5ECaAD9wLB2T4EEeymA5aFVcYXCA=="],
 
     "diff-match-patch": ["diff-match-patch@1.0.5", "", {}, "sha512-IayShXAgj/QMXgB0IWmKx+rOPuGMhqm5w6jvFxmVenXKIzRqTAAsbBPT3kWQeGANj3jGgvcvv4yK6SxqYmikgw=="],
@@ -459,10 +573,16 @@
 
     "dunder-proto": ["dunder-proto@1.0.1", "", { "dependencies": { "call-bind-apply-helpers": "^1.0.1", "es-errors": "^1.3.0", "gopd": "^1.2.0" } }, "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A=="],
 
+    "duplexify": ["duplexify@4.1.3", "", { "dependencies": { "end-of-stream": "^1.4.1", "inherits": "^2.0.3", "readable-stream": "^3.1.1", "stream-shift": "^1.0.2" } }, "sha512-M3BmBhwJRZsSx38lZyhE53Csddgzl5R7xGJNk7CVddZD6CcmwMCH8J+7AprIrQKH7TonKxaCjcv27Qmf+sQ+oA=="],
+
+    "ecdsa-sig-formatter": ["ecdsa-sig-formatter@1.0.11", "", { "dependencies": { "safe-buffer": "^5.0.1" } }, "sha512-nagl3RYrbNv6kQkeJIpt6NJZy8twLB/2vtz6yN9Z4vRKHN4/QZJIEbqohALSgwKdnksuY3k5Addp5lg8sVoVcQ=="],
+
     "emoji-regex": ["emoji-regex@8.0.0", "", {}, "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A=="],
 
     "encoding-japanese": ["encoding-japanese@2.2.0", "", {}, "sha512-EuJWwlHPZ1LbADuKTClvHtwbaFn4rOD+dRAbWysqEOXRc2Uui0hJInNJrsdH0c+OhJA4nrCBdSkW4DD5YxAo6A=="],
 
+    "end-of-stream": ["end-of-stream@1.4.5", "", { "dependencies": { "once": "^1.4.0" } }, "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg=="],
+
     "entities": ["entities@4.5.0", "", {}, "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw=="],
 
     "es-define-property": ["es-define-property@1.0.1", "", {}, "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g=="],
@@ -487,6 +607,10 @@
 
     "eventemitter3": ["eventemitter3@4.0.7", "", {}, "sha512-8guHBZCwKnFhYdHr2ysuRWErTwhoN2X8XELRlrRwpmfeY2jjuUN4taQMsULKUVo1K4DvZl+0pgfyoysHxvmvEw=="],
 
+    "eventsource": ["eventsource@3.0.7", "", { "dependencies": { "eventsource-parser": "^3.0.1" } }, "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA=="],
+
+    "eventsource-parser": ["eventsource-parser@3.0.6", "", {}, "sha512-Vo1ab+QXPzZ4tCa8SwIHJFaSzy4R6SHf7BY79rFBDf0idraZWAkYrDjDj8uWaSm3S2TK+hJ7/t1CEmZ7jXw+pg=="],
+
     "expect-type": ["expect-type@1.2.1", "", {}, "sha512-/kP8CAwxzLVEeFrMm4kMmy4CCDlpipyA7MYLVrdJIkV0fYF0UaigQHRsxHiuY/GEea+bh4KSv3TIlgr+2UL6bw=="],
 
     "extend": ["extend@3.0.2", "", {}, "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g=="],
@@ -495,7 +619,15 @@
 
     "fdir": ["fdir@6.4.6", "", { "peerDependencies": { "picomatch": "^3 || ^4" }, "optionalPeers": ["picomatch"] }, "sha512-hiFoqpyZcfNm1yc4u8oWCf9A2c4D3QjCrks3zmoVKVxpQRzmPNar1hUJcBG2RQHvEVGDN+Jm81ZheVLAQMK6+w=="],
 
-    "form-data": ["form-data@4.0.3", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-qsITQPfmvMOSAdeyZ+12I1c+CKSstAFAwu+97zrnWAbIr5u8wfsExUzCesVLC8NgHuRUqNN4Zy6UPWUTRGslcA=="],
+    "fetch-retry": ["fetch-retry@6.0.0", "", {}, "sha512-BUFj1aMubgib37I3v4q78fYo63Po7t4HUPTpQ6/QE6yK6cIQrP+W43FYToeTEyg5m2Y7eFUtijUuAv/PDlWuag=="],
+
+    "filename-reserved-regex": ["filename-reserved-regex@3.0.0", "", {}, "sha512-hn4cQfU6GOT/7cFHXBqeBg2TbrMBgdD0kcjLhvSQYYwm3s4B6cjvBfb7nBALJLAXqmU5xajSa7X2NnUud/VCdw=="],
+
+    "filenamify": ["filenamify@6.0.0", "", { "dependencies": { "filename-reserved-regex": "^3.0.0" } }, "sha512-vqIlNogKeyD3yzrm0yhRMQg8hOVwYcYRfjEoODd49iCprMn4HL85gK3HcykQE53EPIpX3HcAbGA5ELQv216dAQ=="],
+
+    "follow-redirects": ["follow-redirects@1.15.11", "", {}, "sha512-deG2P0JfjrTxl50XGCDyfI97ZGVCxIpfKYmfyrQ54n5FO/0gfIES8C/Psl6kWVDolizcaaxZJnTS0QSMxvnsBQ=="],
+
+    "form-data": ["form-data@4.0.4", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-KrGhL9Q4zjj0kiUt5OO4Mr/A/jlI2jDYs5eHBpYHPcBEVSiipAvn2Ko2HnPe20rmcuuvMHNdZFp+4IlGTMF0Ow=="],
 
     "form-data-encoder": ["form-data-encoder@1.7.2", "", {}, "sha512-qfqtYan3rxrnCk1VYaA4H+Ms9xdpPqvLZa6xmMgFvhO32x7/3J/ExcTd6qpxM0vH2GdMI+poehyBZvqfMTto8A=="],
 
@@ -503,6 +635,8 @@
 
     "forwarded-parse": ["forwarded-parse@2.1.2", "", {}, "sha512-alTFZZQDKMporBH77856pXgzhEzaUVmLCDk+egLgIgHst3Tpndzz8MnKe+GzRJRfvVdn69HhpW7cmXzvtLvJAw=="],
 
+    "fs-extra": ["fs-extra@11.3.2", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-Xr9F6z6up6Ws+NjzMCZc6WXg2YFRlrLP9NQDO3VQrWrfiojdhS56TzueT88ze0uBdCTwEIhQ3ptnmKeWGFAe0A=="],
+
     "fsevents": ["fsevents@2.3.3", "", { "os": "darwin" }, "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw=="],
 
     "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
@@ -517,12 +651,20 @@
 
     "get-proto": ["get-proto@1.0.1", "", { "dependencies": { "dunder-proto": "^1.0.1", "es-object-atoms": "^1.0.0" } }, "sha512-sTSfBjoXBp89JvIKIefqw7U2CCebsc74kiY6awiGogKtoSGbgjYE/G/+l9sF3MWFPNc9IcoOC4ODfKHfxFmp0g=="],
 
+    "google-auth-library": ["google-auth-library@9.15.1", "", { "dependencies": { "base64-js": "^1.3.0", "ecdsa-sig-formatter": "^1.0.11", "gaxios": "^6.1.1", "gcp-metadata": "^6.1.0", "gtoken": "^7.0.0", "jws": "^4.0.0" } }, "sha512-Jb6Z0+nvECVz+2lzSMt9u98UsoakXxA2HGHMCxh+so3n90XgYWkq5dur19JAJV7ONiJY22yBTyJB1TSkvPq9Ng=="],
+
+    "google-gax": ["google-gax@4.6.1", "", { "dependencies": { "@grpc/grpc-js": "^1.10.9", "@grpc/proto-loader": "^0.7.13", "@types/long": "^4.0.0", "abort-controller": "^3.0.0", "duplexify": "^4.0.0", "google-auth-library": "^9.3.0", "node-fetch": "^2.7.0", "object-hash": "^3.0.0", "proto3-json-serializer": "^2.0.2", "protobufjs": "^7.3.2", "retry-request": "^7.0.0", "uuid": "^9.0.1" } }, "sha512-V6eky/xz2mcKfAd1Ioxyd6nmA61gao3n01C+YeuIwu3vzM9EDR6wcVzMSIbLMDXWeoi9SHYctXuKYC5uJUT3eQ=="],
+
     "google-logging-utils": ["google-logging-utils@0.0.2", "", {}, "sha512-NEgUnEcBiP5HrPzufUkBzJOD/Sxsco3rLNo1F1TNf7ieU8ryUzBhqba8r756CjLX7rn3fHl6iLEwPYuqpoKgQQ=="],
 
     "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
 
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
     "gray-matter": ["gray-matter@4.0.3", "", { "dependencies": { "js-yaml": "^3.13.1", "kind-of": "^6.0.2", "section-matter": "^1.0.0", "strip-bom-string": "^1.0.0" } }, "sha512-5v6yZd4JK3eMI3FqqCouswVqwugaA9r4dNZB1wwcmrD02QkV5H0y7XBQW8QwQqEaZY1pM9aqORSORhJRdNK44Q=="],
 
+    "gtoken": ["gtoken@7.1.0", "", { "dependencies": { "gaxios": "^6.0.0", "jws": "^4.0.0" } }, "sha512-pCcEwRi+TKpMlxAQObHDQ56KawURgyAf6jtIY046fJ5tIv3zDe/LEIubckAO8fj6JnAxLdmWkUfNyulQ2iKdEw=="],
+
     "has-flag": ["has-flag@4.0.0", "", {}, "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ=="],
 
     "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
@@ -535,24 +677,36 @@
 
     "html-to-text": ["html-to-text@9.0.5", "", { "dependencies": { "@selderee/plugin-htmlparser2": "^0.11.0", "deepmerge": "^4.3.1", "dom-serializer": "^2.0.0", "htmlparser2": "^8.0.2", "selderee": "^0.11.0" } }, "sha512-qY60FjREgVZL03vJU6IfMV4GDjGBIoOyvuFdpBDIX9yTlDw0TjxVBQp+P8NvpdIXNJvfWBTNul7fsAQJq2FNpg=="],
 
-    "htmlparser2": ["htmlparser2@8.0.2", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1", "entities": "^4.4.0" } }, "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA=="],
+    "htmlparser2": ["htmlparser2@9.1.0", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.1.0", "entities": "^4.5.0" } }, "sha512-5zfg6mHUoaer/97TxnGpxmbR7zJtPwIYFMZ/H5ucTlPZhKvtum05yiPK3Mgai3a0DyVxv7qYqoweaEd2nrYQzQ=="],
+
+    "http-proxy-agent": ["http-proxy-agent@7.0.2", "", { "dependencies": { "agent-base": "^7.1.0", "debug": "^4.3.4" } }, "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig=="],
 
     "https-proxy-agent": ["https-proxy-agent@7.0.6", "", { "dependencies": { "agent-base": "^7.1.2", "debug": "4" } }, "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw=="],
 
     "humanize-ms": ["humanize-ms@1.2.1", "", { "dependencies": { "ms": "^2.0.0" } }, "sha512-Fl70vYtsAFb/C06PTS9dZBo7ihau+Tu/DNCk/OyHhea07S+aeMWpFFkUaXRa8fI+ScZbEI8dfSxwY7gxZ9SAVQ=="],
 
-    "iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
+    "iconv-lite": ["iconv-lite@0.7.0", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-cf6L2Ds3h57VVmkZe+Pn+5APsT7FpqJtEhhieDCvrE2MK5Qk9MyffgQyuxQTm6BChfeZNtcOLHp9IcWRVcIcBQ=="],
+
+    "ieee754": ["ieee754@1.2.1", "", {}, "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA=="],
 
     "import-in-the-middle": ["import-in-the-middle@1.14.1", "", { "dependencies": { "acorn": "^8.14.0", "acorn-import-attributes": "^1.9.5", "cjs-module-lexer": "^1.2.2", "module-details-from-path": "^1.0.3" } }, "sha512-FygQ6qrqLkLoT0eCKymIKvFH2bAiGDNwg0Cc6I8MevNXxhTAgwLu7it4vVwCpFjyEiJLPrjKodP9fIJAMKpIBw=="],
 
+    "inherits": ["inherits@2.0.4", "", {}, "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ=="],
+
     "is-core-module": ["is-core-module@2.16.1", "", { "dependencies": { "hasown": "^2.0.2" } }, "sha512-UfoeMA6fIJ8wTYFEUjelnaGI67v6+N7qXJEvQuIGa99l4xsCruSYOVSQ0uPANn4dAzm8lkYPaKLrrijLq7x23w=="],
 
+    "is-docker": ["is-docker@3.0.0", "", { "bin": { "is-docker": "cli.js" } }, "sha512-eljcgEDlEns/7AXFosB5K/2nCM4P7FQPkGc/DWLy5rmFEWvZayGrik1d9/QIY5nJ4f9YsVvBkA6kJpHn9rISdQ=="],
+
     "is-extendable": ["is-extendable@0.1.1", "", {}, "sha512-5BMULNob1vgFX6EjQw5izWDxrecWK9AM72rugNr0TFldMOi0fj6Jk+zeKIt0xGj4cEfQIJth4w3OKWOJ4f+AFw=="],
 
     "is-fullwidth-code-point": ["is-fullwidth-code-point@3.0.0", "", {}, "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg=="],
 
+    "is-inside-container": ["is-inside-container@1.0.0", "", { "dependencies": { "is-docker": "^3.0.0" }, "bin": { "is-inside-container": "cli.js" } }, "sha512-KIYLCCJghfHZxqjYBE7rEy0OBuTd5xCHS7tHVgvCLkx7StIoaxwNW3hCALgEUjFfeRk+MG/Qxmp/vtETEF3tRA=="],
+
     "is-stream": ["is-stream@2.0.1", "", {}, "sha512-hFoiJiTl63nn+kstHGBtewWSKnQLpyb155KHheA1l39uvtO9nWIop1p3udqPcUd/xbF1VLMO4n7OI6p7RbngDg=="],
 
+    "is-wsl": ["is-wsl@3.1.0", "", { "dependencies": { "is-inside-container": "^1.0.0" } }, "sha512-UcVfVfaK4Sc4m7X3dUSoHoozQGBEFeDC+zVo06t98xe8CzHSZZBekNXH+tu0NalHolcJ/QAGqS46Hef7QXBIMw=="],
+
     "js-tiktoken": ["js-tiktoken@1.0.20", "", { "dependencies": { "base64-js": "^1.5.1" } }, "sha512-Xlaqhhs8VfCd6Sh7a1cFkZHQbYTLCwVJJWiHVxBYzLPxW0XsoxBy1hitmjkdIjD3Aon5BXLHFwU5O8WUx6HH+A=="],
 
     "js-tokens": ["js-tokens@9.0.1", "", {}, "sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ=="],
@@ -565,8 +719,16 @@
 
     "jsondiffpatch": ["jsondiffpatch@0.6.0", "", { "dependencies": { "@types/diff-match-patch": "^1.0.36", "chalk": "^5.3.0", "diff-match-patch": "^1.0.5" }, "bin": { "jsondiffpatch": "bin/jsondiffpatch.js" } }, "sha512-3QItJOXp2AP1uv7waBkao5nCvhEv+QmJAd38Ybq7wNI74Q+BBmnLn4EDKz6yI9xGAIQoUF87qHt+kc1IVxB4zQ=="],
 
+    "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="],
+
     "jsonpointer": ["jsonpointer@5.0.1", "", {}, "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ=="],
 
+    "jsonwebtoken": ["jsonwebtoken@9.0.2", "", { "dependencies": { "jws": "^3.2.2", "lodash.includes": "^4.3.0", "lodash.isboolean": "^3.0.3", "lodash.isinteger": "^4.0.4", "lodash.isnumber": "^3.0.3", "lodash.isplainobject": "^4.0.6", "lodash.isstring": "^4.0.1", "lodash.once": "^4.0.0", "ms": "^2.1.1", "semver": "^7.5.4" } }, "sha512-PRp66vJ865SSqOlgqS8hujT5U4AOgMfhrwYIuIhfKaoSCZcirrmASQr8CX7cUg+RMih+hgznrjp99o+W4pJLHQ=="],
+
+    "jwa": ["jwa@1.4.2", "", { "dependencies": { "buffer-equal-constant-time": "^1.0.1", "ecdsa-sig-formatter": "1.0.11", "safe-buffer": "^5.0.1" } }, "sha512-eeH5JO+21J78qMvTIDdBXidBd6nG2kZjg5Ohz/1fpa28Z4CcsWUzJ1ZZyFq/3z3N17aZy+ZuBoHljASbL1WfOw=="],
+
+    "jws": ["jws@3.2.2", "", { "dependencies": { "jwa": "^1.4.1", "safe-buffer": "^5.0.1" } }, "sha512-YHlZCB6lMTllWDtSPHz/ZXTsi8S00usEV6v1tjq8tOUZzw7DpSDWVXjXDre6ed1w/pd495ODpHZYSdkRTsa0HA=="],
+
     "kind-of": ["kind-of@6.0.3", "", {}, "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw=="],
 
     "langchain": ["langchain@0.3.28", "", { "dependencies": { "@langchain/openai": ">=0.1.0 <0.6.0", "@langchain/textsplitters": ">=0.0.0 <0.2.0", "js-tiktoken": "^1.0.12", "js-yaml": "^4.1.0", "jsonpointer": "^5.0.1", "langsmith": "^0.3.29", "openapi-types": "^12.1.3", "p-retry": "4", "uuid": "^10.0.0", "yaml": "^2.2.1", "zod": "^3.25.32" }, "peerDependencies": { "@langchain/anthropic": "*", "@langchain/aws": "*", "@langchain/cerebras": "*", "@langchain/cohere": "*", "@langchain/core": ">=0.3.58 <0.4.0", "@langchain/deepseek": "*", "@langchain/google-genai": "*", "@langchain/google-vertexai": "*", "@langchain/google-vertexai-web": "*", "@langchain/groq": "*", "@langchain/mistralai": "*", "@langchain/ollama": "*", "@langchain/xai": "*", "axios": "*", "cheerio": "*", "handlebars": "^4.7.8", "peggy": "^3.0.2", "typeorm": "*" }, "optionalPeers": ["@langchain/anthropic", "@langchain/aws", "@langchain/cerebras", "@langchain/cohere", "@langchain/deepseek", "@langchain/google-genai", "@langchain/google-vertexai", "@langchain/google-vertexai-web", "@langchain/groq", "@langchain/mistralai", "@langchain/ollama", "@langchain/xai", "axios", "cheerio", "handlebars", "peggy", "typeorm"] }, "sha512-h4GGlBJNGU/Sj2PipW9kL+ewj7To3c+SnnNKH3HZaVHEqGPMHVB96T1lLjtCLcZCyUfabMr/zFIkLNI4War+Xg=="],
@@ -577,23 +739,39 @@
 
     "libbase64": ["libbase64@1.3.0", "", {}, "sha512-GgOXd0Eo6phYgh0DJtjQ2tO8dc0IVINtZJeARPeiIJqge+HdsWSuaDTe8ztQ7j/cONByDZ3zeB325AHiv5O0dg=="],
 
-    "libmime": ["libmime@5.3.6", "", { "dependencies": { "encoding-japanese": "2.2.0", "iconv-lite": "0.6.3", "libbase64": "1.3.0", "libqp": "2.1.1" } }, "sha512-j9mBC7eiqi6fgBPAGvKCXJKJSIASanYF4EeA4iBzSG0HxQxmXnR3KbyWqTn4CwsKSebqCv2f5XZfAO6sKzgvwA=="],
+    "libmime": ["libmime@5.3.7", "", { "dependencies": { "encoding-japanese": "2.2.0", "iconv-lite": "0.6.3", "libbase64": "1.3.0", "libqp": "2.1.1" } }, "sha512-FlDb3Wtha8P01kTL3P9M+ZDNDWPKPmKHWaU/cG/lg5pfuAwdflVpZE+wm9m7pKmC5ww6s+zTxBKS1p6yl3KpSw=="],
 
     "libqp": ["libqp@2.1.1", "", {}, "sha512-0Wd+GPz1O134cP62YU2GTOPNA7Qgl09XwCqM5zpBv87ERCXdfDtyKXvV7c9U22yWJh44QZqBocFnXN11K96qow=="],
 
     "linkify-it": ["linkify-it@5.0.0", "", { "dependencies": { "uc.micro": "^2.0.0" } }, "sha512-5aHCbzQRADcdP+ATqnDuhhJ/MRIqDkZX5pyjFHRRysS8vZ5AbqGEoFIb6pYHPZ+L/OC2Lc+xT8uHVVR5CAK/wQ=="],
 
+    "lodash": ["lodash@4.17.21", "", {}, "sha512-v2kDEe57lecTulaDIuNTPy3Ry4gLGJ6Z1O3vE1krgXZNrsQ+LFTGHVxVjcXPs17LhbZVGedAJv8XZ1tvj5FvSg=="],
+
     "lodash.camelcase": ["lodash.camelcase@4.3.0", "", {}, "sha512-TwuEnCnxbc3rAvhf/LbG7tJUDzhqXyFnv3dtzLOPgCG/hODL7WFnsbwktkD7yUV0RrreP/l1PALq/YSg6VvjlA=="],
 
+    "lodash.includes": ["lodash.includes@4.3.0", "", {}, "sha512-W3Bx6mdkRTGtlJISOvVD/lbqjTlPPUDTMnlXZFnVwi9NKJ6tiAk6LVdlhZMm17VZisqhKcgzpO5Wz91PCt5b0w=="],
+
+    "lodash.isboolean": ["lodash.isboolean@3.0.3", "", {}, "sha512-Bz5mupy2SVbPHURB98VAcw+aHh4vRV5IPNhILUCsOzRmsTmSQ17jIuqopAentWoehktxGd9e/hbIXq980/1QJg=="],
+
+    "lodash.isinteger": ["lodash.isinteger@4.0.4", "", {}, "sha512-DBwtEWN2caHQ9/imiNeEA5ys1JoRtRfY3d7V9wkqtbycnAmTvRRmbHKDV4a0EYc678/dia0jrte4tjYwVBaZUA=="],
+
+    "lodash.isnumber": ["lodash.isnumber@3.0.3", "", {}, "sha512-QYqzpfwO3/CWf3XP+Z+tkQsfaLL/EnUlXWVkIk5FUPc4sBdTehEqZONuyRt2P67PXAk+NXmTBcc97zw9t1FQrw=="],
+
+    "lodash.isplainobject": ["lodash.isplainobject@4.0.6", "", {}, "sha512-oSXzaWypCMHkPC3NvBEaPHf0KsA5mvPrOPgQWDsbg8n7orZ290M0BmC/jgRZ4vcJ6DTAhjrsSYgdsW/F+MFOBA=="],
+
+    "lodash.isstring": ["lodash.isstring@4.0.1", "", {}, "sha512-0wJxfxH1wgO3GrbuP+dTTk7op+6L41QCXbGINEmD+ny/G/eCqGzxyCsh7159S+mgDDcoarnBw6PC1PS5+wUGgw=="],
+
+    "lodash.once": ["lodash.once@4.1.1", "", {}, "sha512-Sb487aTOCr9drQVL8pIxOzVhafOjZN9UU54hiN8PU3uAiSV7lx1yYNpbNmex2PK6dSJoNTSJUUswT651yww3Mg=="],
+
     "long": ["long@5.3.2", "", {}, "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA=="],
 
     "loupe": ["loupe@3.1.3", "", {}, "sha512-kkIp7XSkP78ZxJEsSxW3712C6teJVoeHHwgo9zJ380de7IYyJ2ISlxojcH2pC5OFLewESmnRi/+XCDIEEVyoug=="],
 
     "magic-string": ["magic-string@0.30.17", "", { "dependencies": { "@jridgewell/sourcemap-codec": "^1.5.0" } }, "sha512-sNPKHvyjVf7gyjwS4xGTaW/mCnF8wnjtifKBEhxfZ7E/S8tQ0rssrwGNn6q8JH/ohItJfSQp9mBtQYuTlH5QnA=="],
 
-    "mailparser": ["mailparser@3.7.3", "", { "dependencies": { "encoding-japanese": "2.2.0", "he": "1.2.0", "html-to-text": "9.0.5", "iconv-lite": "0.6.3", "libmime": "5.3.6", "linkify-it": "5.0.0", "mailsplit": "5.4.3", "nodemailer": "7.0.3", "punycode.js": "2.3.1", "tlds": "1.259.0" } }, "sha512-0RM14cZF0gO1y2Q/82hhWranispZOUSYHwvQ21h12x90NwD6+D5q59S5nOLqCtCdYitHN58LJXWEHa4RWm7BYA=="],
+    "mailparser": ["mailparser@3.7.5", "", { "dependencies": { "encoding-japanese": "2.2.0", "he": "1.2.0", "html-to-text": "9.0.5", "iconv-lite": "0.7.0", "libmime": "5.3.7", "linkify-it": "5.0.0", "mailsplit": "5.4.6", "nodemailer": "7.0.9", "punycode.js": "2.3.1", "tlds": "1.260.0" } }, "sha512-o59RgZC+4SyCOn4xRH1mtRiZ1PbEmi6si6Ufnd3tbX/V9zmZN1qcqu8xbXY62H6CwIclOT3ppm5u/wV2nujn4g=="],
 
-    "mailsplit": ["mailsplit@5.4.3", "", { "dependencies": { "libbase64": "1.3.0", "libmime": "5.3.6", "libqp": "2.1.1" } }, "sha512-PFV0BBh4Tv7Omui5FtXXVtN4ExAxIi8Yvmb9JgBz+J6Hnnrv/YYXLlKKudLhXwd3/qWEATOslRsnzVCWDeCnmQ=="],
+    "mailsplit": ["mailsplit@5.4.6", "", { "dependencies": { "libbase64": "1.3.0", "libmime": "5.3.7", "libqp": "2.1.1" } }, "sha512-M+cqmzaPG/mEiCDmqQUz8L177JZLZmXAUpq38owtpq2xlXlTSw+kntnxRt2xsxVFFV6+T8Mj/U0l5s7s6e0rNw=="],
 
     "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
 
@@ -615,10 +793,20 @@
 
     "nodemailer": ["nodemailer@7.0.3", "", {}, "sha512-Ajq6Sz1x7cIK3pN6KesGTah+1gnwMnx5gKl3piQlQQE/PwyJ4Mbc8is2psWYxK3RJTVeqsDaCv8ZzXLCDHMTZw=="],
 
+    "nunjucks": ["nunjucks@3.2.4", "", { "dependencies": { "a-sync-waterfall": "^1.0.0", "asap": "^2.0.3", "commander": "^5.1.0" }, "peerDependencies": { "chokidar": "^3.3.0" }, "optionalPeers": ["chokidar"], "bin": { "nunjucks-precompile": "bin/precompile" } }, "sha512-26XRV6BhkgK0VOxfbU5cQI+ICFUtMLixv1noZn1tGU38kQH5A5nmmbk/O45xdyBhD1esk47nKrY0mvQpZIhRjQ=="],
+
+    "object-hash": ["object-hash@3.0.0", "", {}, "sha512-RSn9F68PjH9HqtltsSnqYC1XXoWe9Bju5+213R98cNGttag9q9yAOTzdbsqvIa7aNm5WffBZFpWYr2aWrklWAw=="],
+
+    "once": ["once@1.4.0", "", { "dependencies": { "wrappy": "1" } }, "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w=="],
+
+    "open": ["open@10.2.0", "", { "dependencies": { "default-browser": "^5.2.1", "define-lazy-prop": "^3.0.0", "is-inside-container": "^1.0.0", "wsl-utils": "^0.1.0" } }, "sha512-YgBpdJHPyQ2UE5x+hlSXcnejzAvD0b22U2OuAP+8OnlJT+PjWPxtgmGqKKc+RgTM63U9gN0YzrYc71R2WT/hTA=="],
+
     "openai": ["openai@4.104.0", "", { "dependencies": { "@types/node": "^18.11.18", "@types/node-fetch": "^2.6.4", "abort-controller": "^3.0.0", "agentkeepalive": "^4.2.1", "form-data-encoder": "1.7.2", "formdata-node": "^4.3.2", "node-fetch": "^2.6.7" }, "peerDependencies": { "ws": "^8.18.0", "zod": "^3.23.8" }, "optionalPeers": ["ws", "zod"], "bin": { "openai": "bin/cli" } }, "sha512-p99EFNsA/yX6UhVO93f5kJsDRLAg+CTA2RBqdHK4RtK8u5IJw32Hyb2dTGKbnnFmnuoBv5r7Z2CURI9sGZpSuA=="],
 
     "openapi-types": ["openapi-types@12.1.3", "", {}, "sha512-N4YtSYJqghVu4iek2ZUvcN/0aqH1kRDuNqzcycDxhOUpg7GdvLa2F3DgS6yBNhInhv2r/6I0Flkn7CqL8+nIcw=="],
 
+    "openssl-wrapper": ["openssl-wrapper@0.3.4", "", {}, "sha512-iITsrx6Ho8V3/2OVtmZzzX8wQaKAaFXEJQdzoPUZDtyf5jWFlqo+h+OhGT4TATQ47f9ACKHua8nw7Qoy85aeKQ=="],
+
     "p-finally": ["p-finally@1.0.0", "", {}, "sha512-LICb2p9CB7FS+0eR1oqWnHhp0FljGLZCWBE9aix0Uye9W8LTQPwMTYVGWQWIw9RdQiDg4+epXQODwIYJtSJaow=="],
 
     "p-queue": ["p-queue@6.6.2", "", { "dependencies": { "eventemitter3": "^4.0.4", "p-timeout": "^3.2.0" } }, "sha512-RwFpb72c/BhQLEXIZ5K2e+AhgNVmIejGlTgiB9MzZ0e93GRvqZ7uSi0dvRF7/XIXDeNkra2fNHBxTyPDGySpjQ=="],
@@ -627,6 +815,8 @@
 
     "p-timeout": ["p-timeout@3.2.0", "", { "dependencies": { "p-finally": "^1.0.0" } }, "sha512-rhIwUycgwwKcP9yTOOFK/AKsAopjjCakVqLHePO3CC6Mir1Z99xT+R63jZxAT5lFZLa2inS5h+ZS2GvR99/FBg=="],
 
+    "papaparse": ["papaparse@5.5.3", "", {}, "sha512-5QvjGxYVjxO59MGU2lHVYpRWBBtKHnlIAcSe1uNFCkkptUh63NFRj0FJQm7nR67puEruUci/ZkjmEFrjCAyP4A=="],
+
     "parseley": ["parseley@0.12.1", "", { "dependencies": { "leac": "^0.6.0", "peberminta": "^0.9.0" } }, "sha512-e6qHKe3a9HWr0oMRVDTRhKce+bRO8VGQR3NyVwcjwrbhMmFCX9KszEV35+rn4AdilFAq9VPxP/Fe1wC9Qjd2lw=="],
 
     "path-parse": ["path-parse@1.0.7", "", {}, "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw=="],
@@ -657,12 +847,20 @@
 
     "postgres-interval": ["postgres-interval@1.2.0", "", { "dependencies": { "xtend": "^4.0.0" } }, "sha512-9ZhXKM/rw350N1ovuWHbGxnGh/SNJ4cnxHiM0rxE4VN41wsg8P8zWn9hv/buK00RP4WvlOyr/RBDiptyxVbkZQ=="],
 
+    "posthog-node": ["posthog-node@5.10.0", "", { "dependencies": { "@posthog/core": "1.3.0" } }, "sha512-uNN+YUuOdbDSbDMGk/Wq57o2YBEH0Unu1kEq2PuYmqFmnu+oYsKyJBrb58VNwEuYsaXVJmk4FtbD+Tl8BT69+w=="],
+
+    "proto3-json-serializer": ["proto3-json-serializer@2.0.2", "", { "dependencies": { "protobufjs": "^7.2.5" } }, "sha512-SAzp/O4Yh02jGdRc+uIrGoe87dkN/XtwxfZ4ZyafJHymd79ozp5VG5nyZ7ygqPM5+cpLDjjGnYFUkngonyDPOQ=="],
+
     "protobufjs": ["protobufjs@7.5.3", "", { "dependencies": { "@protobufjs/aspromise": "^1.1.2", "@protobufjs/base64": "^1.1.2", "@protobufjs/codegen": "^2.0.4", "@protobufjs/eventemitter": "^1.1.0", "@protobufjs/fetch": "^1.1.0", "@protobufjs/float": "^1.0.2", "@protobufjs/inquire": "^1.1.0", "@protobufjs/path": "^1.1.2", "@protobufjs/pool": "^1.1.0", "@protobufjs/utf8": "^1.1.0", "@types/node": ">=13.7.0", "long": "^5.0.0" } }, "sha512-sildjKwVqOI2kmFDiXQ6aEB0fjYTafpEvIBs8tOR8qI4spuL9OPROLVu2qZqi/xgCfsHIwVqlaF8JBjWFHnKbw=="],
 
+    "proxy-from-env": ["proxy-from-env@1.1.0", "", {}, "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg=="],
+
     "punycode.js": ["punycode.js@2.3.1", "", {}, "sha512-uxFIHU0YlHYhDQtV4R9J6a52SLx28BCjT+4ieh7IGbgwVJWO+km431c4yRlREUAsAmt/uMjQUyQHNEPf0M39CA=="],
 
     "react": ["react@19.1.0", "", {}, "sha512-FS+XFBNvn3GTAWq26joslQgWNoFu08F4kl0J4CgdNKADkdSGXQyTCnKteIAJy96Br6YbpEU1LSzV5dYtjMkMDg=="],
 
+    "readable-stream": ["readable-stream@3.6.2", "", { "dependencies": { "inherits": "^2.0.3", "string_decoder": "^1.1.1", "util-deprecate": "^1.0.1" } }, "sha512-9u/sniCrY3D5WdsERHzHE4G2YCXqoG5FTHUiCC4SIbr6XcLZBY05ya9EKjYek9O5xOAwjGq+1JdGBAS7Q9ScoA=="],
+
     "require-directory": ["require-directory@2.1.1", "", {}, "sha512-fGxEI7+wsG9xrvdjsrlmL22OMTTiHRwAMroiEeMgq8gzoLC/PQr7RsRDSTLUg/bZAZtF+TVIkHc6/4RIKrui+Q=="],
 
     "require-in-the-middle": ["require-in-the-middle@7.5.2", "", { "dependencies": { "debug": "^4.3.5", "module-details-from-path": "^1.0.3", "resolve": "^1.22.8" } }, "sha512-gAZ+kLqBdHarXB64XpAe2VCjB7rIRv+mU8tfRWziHRJ5umKsIHN2tLLv6EtMw7WCdP19S0ERVMldNvxYCHnhSQ=="],
@@ -671,8 +869,16 @@
 
     "retry": ["retry@0.13.1", "", {}, "sha512-XQBQ3I8W1Cge0Seh+6gjj03LbmRFWuoszgK9ooCpwYIrhhoO80pfq4cUkU5DkknwfOfFteRwlZ56PYOGYyFWdg=="],
 
+    "retry-request": ["retry-request@7.0.2", "", { "dependencies": { "@types/request": "^2.48.8", "extend": "^3.0.2", "teeny-request": "^9.0.0" } }, "sha512-dUOvLMJ0/JJYEn8NrpOaGNE7X3vpI5XlZS/u0ANjqtcZVKnIxP7IgCFwrKTxENw29emmwug53awKtaMm4i9g5w=="],
+
     "rollup": ["rollup@4.43.0", "", { "dependencies": { "@types/estree": "1.0.7" }, "optionalDependencies": { "@rollup/rollup-android-arm-eabi": "4.43.0", "@rollup/rollup-android-arm64": "4.43.0", "@rollup/rollup-darwin-arm64": "4.43.0", "@rollup/rollup-darwin-x64": "4.43.0", "@rollup/rollup-freebsd-arm64": "4.43.0", "@rollup/rollup-freebsd-x64": "4.43.0", "@rollup/rollup-linux-arm-gnueabihf": "4.43.0", "@rollup/rollup-linux-arm-musleabihf": "4.43.0", "@rollup/rollup-linux-arm64-gnu": "4.43.0", "@rollup/rollup-linux-arm64-musl": "4.43.0", "@rollup/rollup-linux-loongarch64-gnu": "4.43.0", "@rollup/rollup-linux-powerpc64le-gnu": "4.43.0", "@rollup/rollup-linux-riscv64-gnu": "4.43.0", "@rollup/rollup-linux-riscv64-musl": "4.43.0", "@rollup/rollup-linux-s390x-gnu": "4.43.0", "@rollup/rollup-linux-x64-gnu": "4.43.0", "@rollup/rollup-linux-x64-musl": "4.43.0", "@rollup/rollup-win32-arm64-msvc": "4.43.0", "@rollup/rollup-win32-ia32-msvc": "4.43.0", "@rollup/rollup-win32-x64-msvc": "4.43.0", "fsevents": "~2.3.2" }, "bin": { "rollup": "dist/bin/rollup" } }, "sha512-wdN2Kd3Twh8MAEOEJZsuxuLKCsBEo4PVNLK6tQWAn10VhsVewQLzcucMgLolRlhFybGxfclbPeEYBaP6RvUFGg=="],
 
+    "rsa-pem-from-mod-exp": ["rsa-pem-from-mod-exp@0.8.6", "", {}, "sha512-c5ouQkOvGHF1qomUUDJGFcXsomeSO2gbEs6hVhMAtlkE1CuaZase/WzoaKFG/EZQuNmq6pw/EMCeEnDvOgCJYQ=="],
+
+    "run-applescript": ["run-applescript@7.1.0", "", {}, "sha512-DPe5pVFaAsinSaV6QjQ6gdiedWDcRCbUuiQfQa2wmWV7+xC9bGulGI8+TdRmoFkAPaBXk8CrAbnlY2ISniJ47Q=="],
+
+    "safe-buffer": ["safe-buffer@5.2.1", "", {}, "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ=="],
+
     "safer-buffer": ["safer-buffer@2.1.2", "", {}, "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg=="],
 
     "section-matter": ["section-matter@1.0.0", "", { "dependencies": { "extend-shallow": "^2.0.1", "kind-of": "^6.0.0" } }, "sha512-vfD3pmTzGpufjScBh50YHKzEu2lxBWhVEHsNGoEXmCmn2hKGfeNLYMzCJpe8cD7gqX7TJluOVpBkAequ6dgMmA=="],
@@ -697,15 +903,23 @@
 
     "std-env": ["std-env@3.9.0", "", {}, "sha512-UGvjygr6F6tpH7o2qyqR6QYpwraIjKSdtzyBdyytFOHmPZY917kwdwLG0RbOjWOnKmnm3PeHjaoLLMie7kPLQw=="],
 
+    "stream-events": ["stream-events@1.0.5", "", { "dependencies": { "stubs": "^3.0.0" } }, "sha512-E1GUzBSgvct8Jsb3v2X15pjzN1tYebtbLaMg+eBOUOAxgbLoSbT2NS91ckc5lJD1KfLjId+jXJRgo0qnV5Nerg=="],
+
+    "stream-shift": ["stream-shift@1.0.3", "", {}, "sha512-76ORR0DO1o1hlKwTbi/DM3EXWGf3ZJYO8cXX5RJwnul2DEg2oyoZyjLNoQM8WsvZiFKCRfC1O0J7iCvie3RZmQ=="],
+
     "string-width": ["string-width@4.2.3", "", { "dependencies": { "emoji-regex": "^8.0.0", "is-fullwidth-code-point": "^3.0.0", "strip-ansi": "^6.0.1" } }, "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g=="],
 
+    "string_decoder": ["string_decoder@1.3.0", "", { "dependencies": { "safe-buffer": "~5.2.0" } }, "sha512-hkRX8U1WjJFd8LsDJ2yQ/wWWxaopEsABU1XfkM8A+j0+85JAGppt16cr1Whg6KIbb4okU6Mql6BOj+uup/wKeA=="],
+
     "strip-ansi": ["strip-ansi@6.0.1", "", { "dependencies": { "ansi-regex": "^5.0.1" } }, "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A=="],
 
     "strip-bom-string": ["strip-bom-string@1.0.0", "", {}, "sha512-uCC2VHvQRYu+lMh4My/sFNmF2klFymLX1wHJeXnbEJERpV/ZsVuonzerjfrGpIGF7LBVa1O7i9kjiWvJiFck8g=="],
 
     "strip-literal": ["strip-literal@3.0.0", "", { "dependencies": { "js-tokens": "^9.0.1" } }, "sha512-TcccoMhJOM3OebGhSBEmp3UZ2SfDMZUEBdRA/9ynfLi8yYajyWX3JiXArcJt4Umh4vISpspkQIY8ZZoCqjbviA=="],
 
-    "supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+    "stubs": ["stubs@3.0.0", "", {}, "sha512-PdHt7hHUJKxvTCgbKX9C1V/ftOcjJQgz8BZwNfV5c4B6dcGqlpelTbJ999jBGZ2jYiPAwcX5dP6oBwVlBlUbxw=="],
+
+    "supports-color": ["supports-color@10.2.2", "", {}, "sha512-SS+jx45GF1QjgEXQx4NJZV9ImqmO2NPz5FNsIHrsDjh2YsHnawpan7SNQ1o8NuhrbHZy9AZhIoCUiCeaW/C80g=="],
 
     "supports-preserve-symlinks-flag": ["supports-preserve-symlinks-flag@1.0.0", "", {}, "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w=="],
 
@@ -713,6 +927,8 @@
 
     "systeminformation": ["systeminformation@5.23.8", "", { "os": "!aix", "bin": { "systeminformation": "lib/cli.js" } }, "sha512-Osd24mNKe6jr/YoXLLK3k8TMdzaxDffhpCxgkfgBHcapykIkd50HXThM3TCEuHO2pPuCsSx2ms/SunqhU5MmsQ=="],
 
+    "teeny-request": ["teeny-request@9.0.0", "", { "dependencies": { "http-proxy-agent": "^5.0.0", "https-proxy-agent": "^5.0.0", "node-fetch": "^2.6.9", "stream-events": "^1.0.5", "uuid": "^9.0.0" } }, "sha512-resvxdc6Mgb7YEThw6G6bExlXKkv6+YbuzGg9xuXxSgxJF7Ozs+o8Y9+2R3sArdWdW8nOokoQb1yrpFB0pQK2g=="],
+
     "throttleit": ["throttleit@2.1.0", "", {}, "sha512-nt6AMGKW1p/70DF/hGBdJB57B8Tspmbp5gfJ8ilhLnt7kkr2ye7hzD6NVG8GGErk2HWF34igrL2CXmNIkzKqKw=="],
 
     "tinybench": ["tinybench@2.9.0", "", {}, "sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg=="],
@@ -727,18 +943,24 @@
 
     "tinyspy": ["tinyspy@4.0.3", "", {}, "sha512-t2T/WLB2WRgZ9EpE4jgPJ9w+i66UZfDc8wHh0xrwiRNN+UwH98GIJkTeZqX9rg0i0ptwzqW+uYeIF0T4F8LR7A=="],
 
-    "tlds": ["tlds@1.259.0", "", { "bin": { "tlds": "bin.js" } }, "sha512-AldGGlDP0PNgwppe2quAvuBl18UcjuNtOnDuUkqhd6ipPqrYYBt3aTxK1QTsBVknk97lS2JcafWMghjGWFtunw=="],
+    "tlds": ["tlds@1.260.0", "", { "bin": { "tlds": "bin.js" } }, "sha512-78+28EWBhCEE7qlyaHA9OR3IPvbCLiDh3Ckla593TksfFc9vfTsgvH7eS+dr3o9qr31gwGbogcI16yN91PoRjQ=="],
 
     "tr46": ["tr46@0.0.3", "", {}, "sha512-N3WMsuqV66lT30CrXNbEjx4GEwlow3v6rr4mCcv6prnfwhS01rkgyFdjPNBYd9br7LpXV1+Emh01fHnq2Gdgrw=="],
 
+    "tslib": ["tslib@2.8.1", "", {}, "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w=="],
+
     "typescript": ["typescript@5.8.3", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-p1diW6TqL9L07nNxvRMM7hMMw4c5XOo/1ibL4aAIGmSAt9slTE1Xgw5KWuof2uTOvCg9BY7ZRi+GaF+7sfgPeQ=="],
 
     "uc.micro": ["uc.micro@2.1.0", "", {}, "sha512-ARDJmphmdvUk6Glw7y9DQ2bFkKBHwQHLi2lsaH6PPmz/Ka9sFOBsBluozhDltWmnv9u/cF6Rt87znRTPV+yp/A=="],
 
     "undici-types": ["undici-types@7.8.0", "", {}, "sha512-9UJ2xGDvQ43tYyVMpuHlsgApydB8ZKfVYTsLDhXkFL/6gfkp+U8xTGdh8pMJv1SpZna0zxG1DwsKZsreLbXBxw=="],
 
+    "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
+
     "use-sync-external-store": ["use-sync-external-store@1.5.0", "", { "peerDependencies": { "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" } }, "sha512-Rb46I4cGGVBmjamjphe8L/UnvJD+uPPtTkNvX5mZgqdbavhI4EbgIWJiIHXJ8bc/i9EQGPRh4DwEURJ552Do0A=="],
 
+    "util-deprecate": ["util-deprecate@1.0.2", "", {}, "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw=="],
+
     "uuid": ["uuid@10.0.0", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-8XkAphELsDnEGrDxUOHB3RGvXz6TeuYSGEZBOjtTtPm2lwhGBjLgOzLHB63IUWfBpNucQjND6d3AOudO+H3RWQ=="],
 
     "vite": ["vite@6.3.5", "", { "dependencies": { "esbuild": "^0.25.0", "fdir": "^6.4.4", "picomatch": "^4.0.2", "postcss": "^8.5.3", "rollup": "^4.34.9", "tinyglobby": "^0.2.13" }, "optionalDependencies": { "fsevents": "~2.3.3" }, "peerDependencies": { "@types/node": "^18.0.0 || ^20.0.0 || >=22.0.0", "jiti": ">=1.21.0", "less": "*", "lightningcss": "^1.21.0", "sass": "*", "sass-embedded": "*", "stylus": "*", "sugarss": "*", "terser": "^5.16.0", "tsx": "^4.8.1", "yaml": "^2.4.2" }, "optionalPeers": ["@types/node", "jiti", "less", "lightningcss", "sass", "sass-embedded", "stylus", "sugarss", "terser", "tsx", "yaml"], "bin": { "vite": "bin/vite.js" } }, "sha512-cZn6NDFE7wdTpINgs++ZJ4N49W2vRp8LCKrn3Ob1kYNtOo21vfDoaV5GzBfLU4MovSAB8uNRm4jgzVQZ+mBzPQ=="],
@@ -757,6 +979,12 @@
 
     "wrap-ansi": ["wrap-ansi@7.0.0", "", { "dependencies": { "ansi-styles": "^4.0.0", "string-width": "^4.1.0", "strip-ansi": "^6.0.0" } }, "sha512-YVGIj2kamLSTxw6NsZjoBxfSwsn0ycdesmc4p+Q21c5zPuZ1pl+NfxVdxPtdHvmNVOQ6XSYG4AUtyt/Fi7D16Q=="],
 
+    "wrappy": ["wrappy@1.0.2", "", {}, "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ=="],
+
+    "ws": ["ws@7.5.10", "", { "peerDependencies": { "bufferutil": "^4.0.1", "utf-8-validate": "^5.0.2" }, "optionalPeers": ["bufferutil", "utf-8-validate"] }, "sha512-+dbF1tHwZpXcbOJdVOkzLDxZP1ailvSxM6ZweXTegylPny803bFhA+vqBYw4s31NSAk4S2Qz+AKXK9a4wkdjcQ=="],
+
+    "wsl-utils": ["wsl-utils@0.1.0", "", { "dependencies": { "is-wsl": "^3.1.0" } }, "sha512-h3Fbisa2nKGPxCpm89Hk33lBLsnaGBvctQopaBSOW/uIs6FTe1ATyAnKFJrzVs9vpGdsTe73WF3V4lIsk4Gacw=="],
+
     "xtend": ["xtend@4.0.2", "", {}, "sha512-LKYU1iAXJXUgAXn9URjiu+MWhyUXHsvfp7mcuYm9dSUKK0/CjtrUwFAxD82/mCWbtLsGjFIad0wIsod4zrTAEQ=="],
 
     "y18n": ["y18n@5.0.8", "", {}, "sha512-0pfFzegeDWJHJIAmTLRP2DwHjdF5s7jo9tuztdQxAhINCdvS+3nGINqPd00AphqJR/0LhANUS6/+7SCb98YOfA=="],
@@ -771,6 +999,12 @@
 
     "zod-to-json-schema": ["zod-to-json-schema@3.24.5", "", { "peerDependencies": { "zod": "^3.24.1" } }, "sha512-/AuWwMP+YqiPbsJx5D6TfgRTc4kTLjsh5SOcd4bLsfUg2RcEXrFMJl1DGgdHy2aCfsIA/cr/1JM0xcB2GZji8g=="],
 
+    "@azure/identity/@azure/msal-node": ["@azure/msal-node@3.8.0", "", { "dependencies": { "@azure/msal-common": "15.13.0", "jsonwebtoken": "^9.0.0", "uuid": "^8.3.0" } }, "sha512-23BXm82Mp5XnRhrcd4mrHa0xuUNRp96ivu3nRatrfdAqjoeWAGyD0eEAafxAOHAEWWmdlyFK4ELFcdziXyw2sA=="],
+
+    "@azure/msal-browser/@azure/msal-common": ["@azure/msal-common@15.13.0", "", {}, "sha512-8oF6nj02qX7eE/6+wFT5NluXRHc05AgdCC3fJnkjiJooq8u7BcLmxaYYSwc2AfEkWRMRi6Eyvvbeqk4U4412Ag=="],
+
+    "@azure/msal-node/uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="],
+
     "@langchain/openai/zod": ["zod@3.25.32", "", {}, "sha512-OSm2xTIRfW8CV5/QKgngwmQW/8aPfGdaQFlrGoErlgg/Epm7cjb6K6VEyExfe65a3VybUOnu381edLb0dfJl0g=="],
 
     "@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
@@ -787,22 +1021,272 @@
 
     "@opentelemetry/sdk-trace-base/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.28.0", "", {}, "sha512-lp4qAiMTD4sNWW4DbKLBkfiMZ4jbAboJIGOQr5DvciMRI494OapieI9qiODpOt0XBr1LjIDy1xAGAnVs5supTA=="],
 
+    "@traceloop/instrumentation-anthropic/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-anthropic/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-anthropic/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-bedrock/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-bedrock/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-bedrock/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-chromadb/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-chromadb/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-chromadb/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-cohere/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-cohere/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-cohere/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-langchain/@langchain/core": ["@langchain/core@0.3.78", "", { "dependencies": { "@cfworker/json-schema": "^4.0.2", "ansi-styles": "^5.0.0", "camelcase": "6", "decamelize": "1.2.0", "js-tiktoken": "^1.0.12", "langsmith": "^0.3.67", "mustache": "^4.2.0", "p-queue": "^6.6.2", "p-retry": "4", "uuid": "^10.0.0", "zod": "^3.25.32", "zod-to-json-schema": "^3.22.3" } }, "sha512-Nn0x9erQlK3zgtRU1Z8NUjLuyW0gzdclMsvLQ6wwLeDqV91pE+YKl6uQb+L2NUDs4F0N7c2Zncgz46HxrvPzuA=="],
+
+    "@traceloop/instrumentation-langchain/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-langchain/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-langchain/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-llamaindex/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-llamaindex/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-llamaindex/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-openai/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-openai/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-openai/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-pinecone/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-pinecone/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-pinecone/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-qdrant/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-qdrant/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-together/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-together/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-together/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-vertexai/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/instrumentation-vertexai/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/instrumentation-vertexai/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/core": ["@opentelemetry/core@2.1.0", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-RMEtHsxJs/GiHHxYT58IY57UXAQTuUnZVco6ymDEqTNlJKTimM4qPUPVe8InNFyBjhHBEAx4k3Q8LtNayBsbUQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto": ["@opentelemetry/exporter-trace-otlp-proto@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-1xwNTJ86L0aJmWRwENCJlH4LULMG2sOXWIVw+Szta4fkqKVY50Eo4HoVKKq6U9QEytrWCr8+zjw0q/ZOeXpcAQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/instrumentation": ["@opentelemetry/instrumentation@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "import-in-the-middle": "^1.8.1", "require-in-the-middle": "^7.1.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ke1qyM+3AK2zPuBPb6Hk/GCsc5ewbLvPNkEuELx/JmANeEp6ZjnZ+wypPAJSucTw0wvCGrUaibDSdcrGFoWxKQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/resources": ["@opentelemetry/resources@2.1.0", "", { "dependencies": { "@opentelemetry/core": "2.1.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-1CJjf3LCvoefUOgegxi8h6r4B/wLSzInyhGP2UmIBYNlo4Qk5CZ73e1eEyWmfXvFtm1ybkmfb2DqWvspsYLrWw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node": ["@opentelemetry/sdk-node@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/exporter-logs-otlp-grpc": "0.203.0", "@opentelemetry/exporter-logs-otlp-http": "0.203.0", "@opentelemetry/exporter-logs-otlp-proto": "0.203.0", "@opentelemetry/exporter-metrics-otlp-grpc": "0.203.0", "@opentelemetry/exporter-metrics-otlp-http": "0.203.0", "@opentelemetry/exporter-metrics-otlp-proto": "0.203.0", "@opentelemetry/exporter-prometheus": "0.203.0", "@opentelemetry/exporter-trace-otlp-grpc": "0.203.0", "@opentelemetry/exporter-trace-otlp-http": "0.203.0", "@opentelemetry/exporter-trace-otlp-proto": "0.203.0", "@opentelemetry/exporter-zipkin": "2.0.1", "@opentelemetry/instrumentation": "0.203.0", "@opentelemetry/propagator-b3": "2.0.1", "@opentelemetry/propagator-jaeger": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "@opentelemetry/sdk-trace-node": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-zRMvrZGhGVMvAbbjiNQW3eKzW/073dlrSiAKPVWmkoQzah9wfynpVPeL55f9fVIm0GaBxTLcPeukWGy0/Wj7KQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.1.0", "", { "dependencies": { "@opentelemetry/core": "2.1.0", "@opentelemetry/resources": "2.1.0", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-uTX9FBlVQm4S2gVQO1sb5qyBLq/FPjbp+tmGoxu4tIgtYGmBYB44+KX/725RFDe30yBSaA9Ml9fqphe1hbUyLQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-trace-node": ["@opentelemetry/sdk-trace-node@2.1.0", "", { "dependencies": { "@opentelemetry/context-async-hooks": "2.1.0", "@opentelemetry/core": "2.1.0", "@opentelemetry/sdk-trace-base": "2.1.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-SvVlBFc/jI96u/mmlKm86n9BbTCbQ35nsPoOohqJX6DXH92K0kTe73zGY5r8xoI1QkjR9PizszVJLzMC966y9Q=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/node-server-sdk/uuid": ["uuid@11.1.0", "", { "bin": { "uuid": "dist/esm/bin/uuid" } }, "sha512-0/A9rDy9P7cJ+8w1c9WD9V//9Wj15Ce2MPz8Ri6032usz+NfePxx5AcN3bN+r6ZL6jEo066/yNYB3tn4pQEx+A=="],
+
+    "@types/node-fetch/form-data": ["form-data@4.0.3", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.12" } }, "sha512-qsITQPfmvMOSAdeyZ+12I1c+CKSstAFAwu+97zrnWAbIr5u8wfsExUzCesVLC8NgHuRUqNN4Zy6UPWUTRGslcA=="],
+
+    "@types/request/form-data": ["form-data@2.5.5", "", { "dependencies": { "asynckit": "^0.4.0", "combined-stream": "^1.0.8", "es-set-tostringtag": "^2.1.0", "hasown": "^2.0.2", "mime-types": "^2.1.35", "safe-buffer": "^5.2.1" } }, "sha512-jqdObeR2rxZZbPSGL+3VckHMYtu+f9//KXBsVny6JSX/pa38Fy+bGjuG8eW/H6USNQWhLi8Num++cU2yOCNz4A=="],
+
     "gaxios/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
 
+    "google-auth-library/jws": ["jws@4.0.0", "", { "dependencies": { "jwa": "^2.0.0", "safe-buffer": "^5.0.1" } }, "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg=="],
+
+    "google-gax/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
+
     "gray-matter/js-yaml": ["js-yaml@3.14.1", "", { "dependencies": { "argparse": "^1.0.7", "esprima": "^4.0.0" }, "bin": { "js-yaml": "bin/js-yaml.js" } }, "sha512-okMH7OXXJ7YrN9Ok3/SXrnu4iX9yOk+25nqX4imS2npuvTYDmo/QEZoqwZkYaIDk3jVvBOTOIEgEhaLOynBS9g=="],
 
+    "gtoken/jws": ["jws@4.0.0", "", { "dependencies": { "jwa": "^2.0.0", "safe-buffer": "^5.0.1" } }, "sha512-KDncfTmOZoOMTFG4mBlG0qUIOlc03fmzH+ru6RgYVZhPkyiy/92Owlt/8UEN+a4TXR1FQetfIpJE8ApdvdVxTg=="],
+
+    "html-to-text/htmlparser2": ["htmlparser2@8.0.2", "", { "dependencies": { "domelementtype": "^2.3.0", "domhandler": "^5.0.3", "domutils": "^3.0.1", "entities": "^4.4.0" } }, "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA=="],
+
     "langsmith/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
 
+    "libmime/iconv-lite": ["iconv-lite@0.6.3", "", { "dependencies": { "safer-buffer": ">= 2.1.2 < 3.0.0" } }, "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw=="],
+
+    "mailparser/nodemailer": ["nodemailer@7.0.9", "", {}, "sha512-9/Qm0qXIByEP8lEV2qOqcAW7bRpL8CR9jcTwk3NBnHJNmP9fIJ86g2fgmIXqHY+nj55ZEMwWqYAT2QTDpRUYiQ=="],
+
     "openai/@types/node": ["@types/node@18.19.112", "", { "dependencies": { "undici-types": "~5.26.4" } }, "sha512-i+Vukt9POdS/MBI7YrrkkI5fMfwFtOjphSmt4WXYLfwqsfr6z/HdCx7LqT9M7JktGob8WNgj8nFB4TbGNE4Cog=="],
 
     "rollup/@types/estree": ["@types/estree@1.0.7", "", {}, "sha512-w28IoSUCJpidD/TGviZwwMJckNESJZXFu7NBZ5YJ4mEUnNraUn9Pm8HSZm/jDF1pDWYKspWE7oVphigUPRakIQ=="],
 
+    "teeny-request/http-proxy-agent": ["http-proxy-agent@5.0.0", "", { "dependencies": { "@tootallnate/once": "2", "agent-base": "6", "debug": "4" } }, "sha512-n2hY8YdoRE1i7r6M0w9DIw5GgZN0G25P8zLCRQ8rjXtTU3vsNFBI/vWK/UIeE6g5MUUz6avwAPXmL6Fy9D/90w=="],
+
+    "teeny-request/https-proxy-agent": ["https-proxy-agent@5.0.1", "", { "dependencies": { "agent-base": "6", "debug": "4" } }, "sha512-dFcAjpTQFgoLMzC2VwU+C/CbS7uRL0lWmxDITmqm7C+7F0Odmj6s9l6alZc6AELXhrnggM2CeWSXHGOdX2YtwA=="],
+
+    "teeny-request/uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
+
     "wrap-ansi/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
 
+    "@azure/identity/@azure/msal-node/@azure/msal-common": ["@azure/msal-common@15.13.0", "", {}, "sha512-8oF6nj02qX7eE/6+wFT5NluXRHc05AgdCC3fJnkjiJooq8u7BcLmxaYYSwc2AfEkWRMRi6Eyvvbeqk4U4412Ag=="],
+
+    "@azure/identity/@azure/msal-node/uuid": ["uuid@8.3.2", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-+NYs2QeMWy+GWFOEm9xnn6HCDp0l7QBD7ml8zLUmJ+93Q5NF0NocErnwkTkXVFNiX3/fpC6afS8Dhb/gz7R7eg=="],
+
+    "@traceloop/instrumentation-anthropic/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-bedrock/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-chromadb/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-cohere/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-langchain/@langchain/core/langsmith": ["langsmith@0.3.74", "", { "dependencies": { "@types/uuid": "^10.0.0", "chalk": "^4.1.2", "console-table-printer": "^2.12.1", "p-queue": "^6.6.2", "p-retry": "4", "semver": "^7.6.3", "uuid": "^10.0.0" }, "peerDependencies": { "@opentelemetry/api": "*", "@opentelemetry/exporter-trace-otlp-proto": "*", "@opentelemetry/sdk-trace-base": "*", "openai": "*" }, "optionalPeers": ["@opentelemetry/api", "@opentelemetry/exporter-trace-otlp-proto", "@opentelemetry/sdk-trace-base", "openai"] }, "sha512-ZuW3Qawz8w88XcuCRH91yTp6lsdGuwzRqZ5J0Hf5q/AjMz7DwcSv0MkE6V5W+8hFMI850QZN2Wlxwm3R9lHlZg=="],
+
+    "@traceloop/instrumentation-langchain/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-llamaindex/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-openai/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-pinecone/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-qdrant/@opentelemetry/core/@opentelemetry/semantic-conventions": ["@opentelemetry/semantic-conventions@1.37.0", "", {}, "sha512-JD6DerIKdJGmRp4jQyX5FlrQjA4tjOw1cvfsPAZXfOOEErMUHjPcPSICS+6WnM0nB0efSFARh0KAZss+bvExOA=="],
+
+    "@traceloop/instrumentation-qdrant/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-together/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/instrumentation-vertexai/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/core": ["@opentelemetry/core@2.0.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-MaZk9SJIDgo1peKevlbhP6+IwIiNPNmswNL4AF0WaQJLbHXjr9SrZMgS12+iqr9ToV4ZVosCcc0f8Rg67LXjxw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/resources": ["@opentelemetry/resources@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/instrumentation/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/core": ["@opentelemetry/core@2.0.1", "", { "dependencies": { "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-MaZk9SJIDgo1peKevlbhP6+IwIiNPNmswNL4AF0WaQJLbHXjr9SrZMgS12+iqr9ToV4ZVosCcc0f8Rg67LXjxw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-grpc": ["@opentelemetry/exporter-logs-otlp-grpc@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-grpc-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/sdk-logs": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-g/2Y2noc/l96zmM+g0LdeuyYKINyBwN6FJySoU15LHPLcMN/1a0wNk2SegwKcxrRdE7Xsm7fkIR5n6XFe3QpPw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http": ["@opentelemetry/exporter-logs-otlp-http@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/sdk-logs": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-s0hys1ljqlMTbXx2XiplmMJg9wG570Z5lH7wMvrZX6lcODI56sG4HL03jklF63tBeyNwK2RV1/ntXGo3HgG4Qw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-proto": ["@opentelemetry/exporter-logs-otlp-proto@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-trace-base": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-nl/7S91MXn5R1aIzoWtMKGvqxgJgepB/sH9qW0rZvZtabnsjbf8OQ1uSx3yogtvLr0GzwD596nQKz2fV7q2RBw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-grpc": ["@opentelemetry/exporter-metrics-otlp-grpc@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/exporter-metrics-otlp-http": "0.203.0", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-grpc-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-metrics": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-FCCj9nVZpumPQSEI57jRAA89hQQgONuoC35Lt+rayWY/mzCAc6BQT7RFyFaZKJ2B7IQ8kYjOCPsF/HGFWjdQkQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-http": ["@opentelemetry/exporter-metrics-otlp-http@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-metrics": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-HFSW10y8lY6BTZecGNpV3GpoSy7eaO0Z6GATwZasnT4bEsILp8UJXNG5OmEsz4SdwCSYvyCbTJdNbZP3/8LGCQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-proto": ["@opentelemetry/exporter-metrics-otlp-proto@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/exporter-metrics-otlp-http": "0.203.0", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-metrics": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-OZnhyd9npU7QbyuHXFEPVm3LnjZYifuKpT3kTnF84mXeEQ84pJJZgyLBpU4FSkSwUkt/zbMyNAI7y5+jYTWGIg=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-prometheus": ["@opentelemetry/exporter-prometheus@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-metrics": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-2jLuNuw5m4sUj/SncDf/mFPabUxMZmmYetx5RKIMIQyPnl6G6ooFzfeE8aXNRf8YD1ZXNlCnRPcISxjveGJHNg=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-grpc": ["@opentelemetry/exporter-trace-otlp-grpc@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-grpc-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-322coOTf81bm6cAA8+ML6A+m4r2xTCdmAZzGNTboPXRzhwPt4JEmovsFAs+grpdarObd68msOJ9FfH3jxM6wqA=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http": ["@opentelemetry/exporter-trace-otlp-http@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-ZDiaswNYo0yq/cy1bBLJFe691izEJ6IgNmkjm4C6kE9ub/OMQqDXORx2D2j8fzTBTxONyzusbaZlqtfmyqURPw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-zipkin": ["@opentelemetry/exporter-zipkin@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": "^1.0.0" } }, "sha512-a9eeyHIipfdxzCfc2XPrE+/TI3wmrZUDFtG2RRXHSbZZULAny7SyybSvaDvS77a7iib5MPiAvluwVvbGTsHxsw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/propagator-b3": ["@opentelemetry/propagator-b3@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-Hc09CaQ8Tf5AGLmf449H726uRoBNGPBL4bjr7AnnUpzWMvhdn61F78z9qb6IqB737TffBsokGAK1XykFEZ1igw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/propagator-jaeger": ["@opentelemetry/propagator-jaeger@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-7PMdPBmGVH2eQNb/AtSJizQNgeNTfh6jQFqys6lfhd6P4r+m/nTh3gKPPpaCXVdRQ+z93vfKk+4UGty390283w=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/resources": ["@opentelemetry/resources@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-dZOB3R6zvBwDKnHDTB4X1xtMArB/d324VsbiPkX/Yu0Q8T2xceRthoIVFhJdvgVM2QhGVUyX9tzwiNxGtoBJUw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-vM2+rPq0Vi3nYA5akQD2f3QwossDnTDLvKbea6u/A2NZ3XDkPxMfo/PNrDoXhDUD/0pPo2CdH5ce/thn9K0kLw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-wf8OaJoSnujMAHWR3g+/hGvNcsC16rf9s1So4JlMiFaFHiE4HpIA3oUh+uWZQ7CNuK8gVW/pQSkgoa5HkkOl0g=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/sdk-trace-base": ["@opentelemetry/sdk-trace-base@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/semantic-conventions": "^1.29.0" }, "peerDependencies": { "@opentelemetry/api": ">=1.3.0 <1.10.0" } }, "sha512-xYLlvk/xdScGx1aEqvxLwf6sXQLXCjk3/1SQT9X9AoN5rXRhkdvIFShuNNmtTEPRBqcsMbS4p/gJLNI2wXaDuQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node": ["@opentelemetry/sdk-trace-node@2.0.1", "", { "dependencies": { "@opentelemetry/context-async-hooks": "2.0.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-UhdbPF19pMpBtCWYP5lHbTogLWx9N0EBxtdagvkn5YtsAnCBZzL7SjktG+ZmupRgifsHMjwUaCCaVmqGfSADmA=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-trace-node/@opentelemetry/context-async-hooks": ["@opentelemetry/context-async-hooks@2.1.0", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-zOyetmZppnwTyPrt4S7jMfXiSX9yyfF0hxlA8B5oo2TtKl+/RGCy7fi4DrBfIf3lCPrkKsRBWZZD7RFojK7FDg=="],
+
+    "google-auth-library/jws/jwa": ["jwa@2.0.1", "", { "dependencies": { "buffer-equal-constant-time": "^1.0.1", "ecdsa-sig-formatter": "1.0.11", "safe-buffer": "^5.0.1" } }, "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg=="],
+
     "gray-matter/js-yaml/argparse": ["argparse@1.0.10", "", { "dependencies": { "sprintf-js": "~1.0.2" } }, "sha512-o5Roy6tNG4SL/FOkCAN6RzjiakZS25RLYFrcMttJqbdd8BWrnA+fGz57iN5Pb06pvBGvl5gQ0B48dJlslXvoTg=="],
 
+    "gtoken/jws/jwa": ["jwa@2.0.1", "", { "dependencies": { "buffer-equal-constant-time": "^1.0.1", "ecdsa-sig-formatter": "1.0.11", "safe-buffer": "^5.0.1" } }, "sha512-hRF04fqJIP8Abbkq5NKGN0Bbr3JxlQ+qhZufXVr0DvujKy93ZCbXZMHDL4EOtodSbCWxOqR8MS1tXA5hwqCXDg=="],
+
     "langsmith/chalk/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
 
+    "langsmith/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
+
     "openai/@types/node/undici-types": ["undici-types@5.26.5", "", {}, "sha512-JlCMO+ehdEIKqlFxk6IfVoAUVmgz7cU7zD/h9XZ0qzeosSHmUJVOzSQvvYSYWXkFXC+IfLKSIffhv0sVZup6pA=="],
+
+    "teeny-request/http-proxy-agent/agent-base": ["agent-base@6.0.2", "", { "dependencies": { "debug": "4" } }, "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ=="],
+
+    "teeny-request/https-proxy-agent/agent-base": ["agent-base@6.0.2", "", { "dependencies": { "debug": "4" } }, "sha512-RZNwNclF7+MS/8bDg70amg32dyeZGZxiDuQmZxKLAlQjr3jGyLx+4Kkk58UO7D2QdgFIQCovuSuZESne6RG6XQ=="],
+
+    "@traceloop/instrumentation-langchain/@langchain/core/langsmith/chalk": ["chalk@4.1.2", "", { "dependencies": { "ansi-styles": "^4.1.0", "supports-color": "^7.1.0" } }, "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/api-logs": ["@opentelemetry/api-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-9B9RU0H7Ya1Dx/Rkyc4stuBZSGVQF27WigitInx2QQoj6KUpEFYPKoWjdFTunJYxmXmh17HeBvbMa1EhGyPmqQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-logs": ["@opentelemetry/sdk-logs@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.4.0 <1.10.0" } }, "sha512-vM2+rPq0Vi3nYA5akQD2f3QwossDnTDLvKbea6u/A2NZ3XDkPxMfo/PNrDoXhDUD/0pPo2CdH5ce/thn9K0kLw=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/exporter-trace-otlp-proto/@opentelemetry/otlp-transformer/@opentelemetry/sdk-metrics": ["@opentelemetry/sdk-metrics@2.0.1", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1" }, "peerDependencies": { "@opentelemetry/api": ">=1.9.0 <1.10.0" } }, "sha512-wf8OaJoSnujMAHWR3g+/hGvNcsC16rf9s1So4JlMiFaFHiE4HpIA3oUh+uWZQ7CNuK8gVW/pQSkgoa5HkkOl0g=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-grpc-exporter-base": ["@opentelemetry/otlp-grpc-exporter-base@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-te0Ze1ueJF+N/UOFl5jElJW4U0pZXQ8QklgSfJ2linHN0JJsuaHG8IabEUi2iqxY8ZBDlSiz1Trfv5JcjWWWwQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-logs-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-grpc-exporter-base": ["@opentelemetry/otlp-grpc-exporter-base@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-te0Ze1ueJF+N/UOFl5jElJW4U0pZXQ8QklgSfJ2linHN0JJsuaHG8IabEUi2iqxY8ZBDlSiz1Trfv5JcjWWWwQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-metrics-otlp-proto/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-grpc-exporter-base": ["@opentelemetry/otlp-grpc-exporter-base@0.203.0", "", { "dependencies": { "@grpc/grpc-js": "^1.7.1", "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-exporter-base": "0.203.0", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-te0Ze1ueJF+N/UOFl5jElJW4U0pZXQ8QklgSfJ2linHN0JJsuaHG8IabEUi2iqxY8ZBDlSiz1Trfv5JcjWWWwQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-grpc/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-exporter-base": ["@opentelemetry/otlp-exporter-base@0.203.0", "", { "dependencies": { "@opentelemetry/core": "2.0.1", "@opentelemetry/otlp-transformer": "0.203.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Wbxf7k+87KyvxFr5D7uOiSq/vHXWommvdnNE7vECO3tAhsA2GfOlpWINCMWUEPdHZ7tCXxw6Epp3vgx3jU7llQ=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/exporter-trace-otlp-http/@opentelemetry/otlp-transformer": ["@opentelemetry/otlp-transformer@0.203.0", "", { "dependencies": { "@opentelemetry/api-logs": "0.203.0", "@opentelemetry/core": "2.0.1", "@opentelemetry/resources": "2.0.1", "@opentelemetry/sdk-logs": "0.203.0", "@opentelemetry/sdk-metrics": "2.0.1", "@opentelemetry/sdk-trace-base": "2.0.1", "protobufjs": "^7.3.0" }, "peerDependencies": { "@opentelemetry/api": "^1.3.0" } }, "sha512-Y8I6GgoCna0qDQ2W6GCRtaF24SnvqvA8OfeTi7fqigD23u8Jpb4R5KFv/pRvrlGagcCLICMIyh9wiejp4TXu/A=="],
+
+    "@traceloop/node-server-sdk/@opentelemetry/sdk-node/@opentelemetry/sdk-trace-node/@opentelemetry/context-async-hooks": ["@opentelemetry/context-async-hooks@2.0.1", "", { "peerDependencies": { "@opentelemetry/api": ">=1.0.0 <1.10.0" } }, "sha512-XuY23lSI3d4PEqKA+7SLtAgwqIfc6E/E9eAQWLN1vlpC53ybO3o6jW4BsXo1xvz9lYyyWItfQDDLzezER01mCw=="],
+
+    "@traceloop/instrumentation-langchain/@langchain/core/langsmith/chalk/ansi-styles": ["ansi-styles@4.3.0", "", { "dependencies": { "color-convert": "^2.0.1" } }, "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg=="],
+
+    "@traceloop/instrumentation-langchain/@langchain/core/langsmith/chalk/supports-color": ["supports-color@7.2.0", "", { "dependencies": { "has-flag": "^4.0.0" } }, "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw=="],
   }
 }
diff --git a/agent-docs/package.json b/agent-docs/package.json
index b1e59c26..bd9289a0 100644
--- a/agent-docs/package.json
+++ b/agent-docs/package.json
@@ -27,7 +27,7 @@
 		"typescript": "^5"
 	},
 	"dependencies": {
-		"@agentuity/sdk": "^0.0.124",
+		"@agentuity/sdk": "^0.0.155",
 		"@ai-sdk/openai": "^1.3.22",
 		"ai": "^4.3.16",
 		"gray-matter": "^4.0.3",
diff --git a/agent-docs/src/agents/agent-pulse/context/builder.ts b/agent-docs/src/agents/agent-pulse/context/builder.ts
index 63a0221f..7885a9ec 100644
--- a/agent-docs/src/agents/agent-pulse/context/builder.ts
+++ b/agent-docs/src/agents/agent-pulse/context/builder.ts
@@ -1,58 +1,105 @@
 import type { AgentContext } from "@agentuity/sdk";
 
 export async function buildSystemPrompt(tutorialContext: string, ctx: AgentContext): Promise<string> {
-  try {
-    const systemPrompt = `=== ROLE ===
+        try {
+                // Role definition
+                const rolePrompt = `<ROLE>
 You are Pulse, an AI assistant designed to help developers learn and navigate the Agentuity platform through interactive tutorials and clear guidance. Your primary goal is to assist users with understanding and using the Agentuity SDK effectively. When a user's query is vague, unclear, or lacks specific intent, subtly suggest relevant interactive tutorial to guide them toward learning the platform. For clear, specific questions related to the Agentuity SDK or other topics, provide direct, accurate, and concise answers without mentioning tutorials unless relevant. Always maintain a friendly and approachable tone to encourage engagement.
 
 Your role is to ensure user have a smooth tutorial experience!
 
 When user is asking to move to the next tutorial, simply increment the step for them.
+</ROLE>`;
+                const tutorialDirectionRole = `<TUTORIAL_DIRECTION_ROLE>
+When user is asking questions related to one of the tutorials, help them with that specific tutorial. If the user's question indicates they haven't started any particular tutorial that we have listed, gently point out that specific tutorial to them. Suggest that they start it based on their tutorial progress. You can use the getUserTutorialProgress tool to check if the user has completed that tutorial yet and help them begin at the appropriate step.
 
-=== PERSONALITY ===
+Use getUserTutorialProgress when:
+- A user asks about a topic covered in a specific tutorial
+- You want to recommend the next tutorial they should try
+- You need to know if they've already learned something from a previous tutorial
+- They ask about their learning progress or what to learn next
+
+Let the user know that you have observed their tutorial progress and can help them with that specific tutorial.
+</TUTORIAL_DIRECTION_ROLE>`;
+                // Personality traits
+                const personalityPrompt = `<PERSONALITY>
 - Friendly and encouraging with light humour  
 - Patient with learners at all levels  
 - Clear and concise in explanations  
 - Enthusiastic about teaching and problem-solving
+</PERSONALITY>`;
 
-=== Available Tools or Functions ===
+                // Available tools
+                const toolsPrompt = `<AVAILABLE_TOOLS>
 You have access to various tools you can use -- use when appropriate!
 1. Tutorial management  
    - startTutorialAtStep: Starting the user off at a specific step of a tutorial.
+   - getUserTutorialProgress: Check which tutorials the user has started or completed.
 2. General assistance
    - askDocsAgentTool: retrieve Agentuity documentation snippets
+</AVAILABLE_TOOLS>`;
 
-=== TOOL-USAGE RULES (must follow) ===
+                // Tool usage rules
+                const toolUsagePrompt = `<TOOL_USAGE_RULES>
 - startTutorialById must only be used when user select a tutorial. If the user starts a new tutorial, the step number should be set to one. Valid step is between 1 and totalSteps of the specific tutorial.
+- getUserTutorialProgress should be called when you need to know what tutorials the user has completed or is working on. This helps provide personalized recommendations.
 - **askDocsAgentTool usage:**
   - ALWAYS use askDocsAgentTool for questions about the Agentuity SDK, platform features, APIs, or CLI commands.
   - Examples: AgentContext, AgentRequest, AgentResponse, ctx.logger, ctx.vector, resp.json, deployment, authentication, agent configuration.
   - For non-Agentuity questions (general programming concepts), you may answer directly without the tool.
   - Treat doc results as authoritative. If docs don't cover it, inform the user.
 
-=== RESPONSE STYLE (format guidelines) ===
+CRITICAL - NO HALLUCINATION RULE:
+- You MUST NOT tell the user you are "setting them up", "starting", "loading", or "preparing" a tutorial step UNLESS you have actually called the startTutorialById tool in this turn.
+- If you have NOT called startTutorialById, you can only suggest, recommend, or offer to start a tutorial (e.g., "Would you like me to start tutorial X?" or "I can set up tutorial Y for you if you'd like").
+- NEVER say phrases like "I'm setting you up with step X", "Let me start the tutorial for you", or "I've prepared tutorial Y" unless the startTutorialById tool has been executed in the current response.
+- The tool call is what actually sets up the tutorial - your words alone do NOT set anything up.
+</TOOL_USAGE_RULES>`;
+
+                // Response style guidelines
+                const responseStylePrompt = `<RESPONSE_STYLE>
 - Begin with a short answer, then elaborate if necessary.
 - Add brief comments to complex code; skip obvious lines.
 - End with a question when further clarification could help the user.
+</RESPONSE_STYLE>`;
 
-=== SAFETY & BOUNDARIES ===
+                // Safety and boundaries
+                const safetyPrompt = `<SAFETY_AND_BOUNDARIES>
 - If asked for private data or secrets, refuse.  
-- If the user requests actions outside your capabilities, apologise and explain.  
-- Keep every response < 400 words
-
-Generate a response to the user query accordingly and try to be helpful
+- If the user requests actions outside your capabilities, apologise and explain.
+- Generate a response to the user prompt with factual information provided to you -- no hallucinations or guesswork. Be helpful and concise.
+</SAFETY_AND_BOUNDARIES>`;
 
-=== CONTEXT ===
+                // Context section
+                const contextPrompt = `<CONTEXT>
 ${tutorialContext}
+</CONTEXT>`;
+
+                // Assemble the complete system prompt
+                const systemPrompt = `${rolePrompt}
+
+${personalityPrompt}
+
+${toolsPrompt}
+
+${toolUsagePrompt}
+
+${tutorialDirectionRole}
+
+${responseStylePrompt}
+
+${safetyPrompt}
+
+${contextPrompt}
 
-=== END OF PROMPT ===
+<END_OF_PROMPT>
 
 Stream your reasoning steps clearly.`;
 
-    ctx.logger.debug("Built system prompt with tutorial context");
-    return systemPrompt;
-  } catch (error) {
-    ctx.logger.error("Failed to build system prompt: %s", error instanceof Error ? error.message : String(error));
-    throw error; // Re-throw for centralized handling
-  }
+                ctx.logger.debug("Built system prompt with tutorial context");
+                return systemPrompt;
+        } catch (error) {
+                ctx.logger.error("Failed to build system prompt: %s", error instanceof Error ? error.message : String(error));
+                throw error; // Re-throw for centralized handling
+        }
 } 
\ No newline at end of file
diff --git a/agent-docs/src/agents/agent-pulse/index.ts b/agent-docs/src/agents/agent-pulse/index.ts
index 05a786ef..94a3ae19 100644
--- a/agent-docs/src/agents/agent-pulse/index.ts
+++ b/agent-docs/src/agents/agent-pulse/index.ts
@@ -31,14 +31,18 @@ async function buildContext(
 			tutorialState
 		);
 
-		return `===AVAILABLE TUTORIALS====
-
+		return `<CONTEXT>
+			
+	<AVAILABLE_TUTORIALS>
     ${tutorialContent}
+	</AVAILABLE_TUTORIALS>
 
+	<CURRENT_USER_TUTORIAL_INFO>
     ${currentTutorialInfo}
+	</CURRENT_USER_TUTORIAL_INFO>
 
     Note: You should not expose the details of the tutorial IDs to the user.
-`;
+</CONTEXT>`;
 	} catch (error) {
 		ctx.logger.error("Error building tutorial context: %s", error);
 		return defaultFallbackContext();
@@ -72,7 +76,7 @@ function buildCurrentTutorialInfo(
  * Returns fallback context when tutorial list can't be loaded
  */
 function defaultFallbackContext(): string {
-	return `===AVAILABLE TUTORIALS====
+	return `=== AVAILABLE TUTORIALS ====
 Unable to load tutorial list currently`;
 }
 
@@ -97,10 +101,11 @@ export default async function Agent(
 		let systemPrompt: string = "";
 		// Direct LLM access won't require any tools or system prompt
 		if (!parsedRequest.useDirectLLM) {
-			// Create tools with state context
+			// Create tools with state context and userId
 			tools = await createTools({
 				state,
 				agentContext: ctx,
+				userId: parsedRequest.userId,
 			});
 
 			// Build tutorial context and system prompt
diff --git a/agent-docs/src/agents/agent-pulse/request/parser.ts b/agent-docs/src/agents/agent-pulse/request/parser.ts
index 3fdff583..1d29bff6 100644
--- a/agent-docs/src/agents/agent-pulse/request/parser.ts
+++ b/agent-docs/src/agents/agent-pulse/request/parser.ts
@@ -10,11 +10,13 @@ export function parseAgentRequest(
 		let conversationHistory: any[] = [];
 		let tutorialData: any = undefined;
 		let useDirectLLM = false;
+		let userId: string | undefined = undefined;
 
 		if (jsonData && typeof jsonData === "object" && !Array.isArray(jsonData)) {
 			const body = jsonData as any;
 			message = body.message || "";
 			useDirectLLM = body.use_direct_llm || false;
+			userId = body.userId || undefined;
 			if (Array.isArray(body.conversationHistory)) {
 				conversationHistory = body.conversationHistory.map((msg: any) => {
 					return {
@@ -34,6 +36,7 @@ export function parseAgentRequest(
 			conversationHistory,
 			tutorialData,
 			useDirectLLM,
+			userId,
 		};
 	} catch (error) {
 		ctx.logger.error(
diff --git a/agent-docs/src/agents/agent-pulse/request/types.ts b/agent-docs/src/agents/agent-pulse/request/types.ts
index 3f14e830..08c4fa1d 100644
--- a/agent-docs/src/agents/agent-pulse/request/types.ts
+++ b/agent-docs/src/agents/agent-pulse/request/types.ts
@@ -13,4 +13,5 @@ export interface ParsedAgentRequest {
   conversationHistory: ConversationMessage[];
   tutorialData?: TutorialState;
   useDirectLLM?: boolean;
+  userId?: string;
 }
\ No newline at end of file
diff --git a/agent-docs/src/agents/agent-pulse/tools.ts b/agent-docs/src/agents/agent-pulse/tools.ts
index 6ca21035..ee63b12b 100644
--- a/agent-docs/src/agents/agent-pulse/tools.ts
+++ b/agent-docs/src/agents/agent-pulse/tools.ts
@@ -3,7 +3,7 @@ import { z } from "zod";
 import { ActionType } from "./state";
 import type { AgentState } from "./state";
 import type { AgentContext } from "@agentuity/sdk";
-import { getTutorialMeta } from "./tutorial";
+import { getTutorialMeta, getUserTutorialProgress } from "./tutorial";
 
 /**
  * Context passed to tools for state management and logging
@@ -11,20 +11,21 @@ import { getTutorialMeta } from "./tutorial";
 interface ToolContext {
     state: AgentState;
     agentContext: AgentContext;
+    userId?: string;
 }
 
 /**
  * Factory function that creates tools with state management context
  */
 export async function createTools(context: ToolContext) {
-    const { state, agentContext } = context;
+    const { state, agentContext, userId } = context;
     const DOC_QA_AGENT_NAME = "doc-qa";
     const docQaAgent = await agentContext.getAgent({ name: DOC_QA_AGENT_NAME });
     /**
      * Tool for starting a tutorial - adds action to state queue
      */
     const startTutorialAtStep = tool({
-        description: "Start a specific tutorial for the user. You must call this function in order for the user to see the tutorial step content. The tutorial content will be injected to the final response automatically -- you do not have to narrate the tutorial content. The step number should be between 1 and the total number of steps in the tutorial.",
+        description: "Start a specific tutorial for the user. You must call this function in order for the user to see the tutorial step content. The tutorial content will be injected to the final response automatically -- you do not have to narrate the tutorial content. The step number should be between 1 and the total number of steps in the tutorial. On successful execution, return the title of which the tutorial is starting, the total steps in the tutorial, and the description of the tutorial. Otherwise, return error message based on the error reason.",
         parameters: z.object({
             tutorialId: z.string().describe("The exact ID of the tutorial to start"),
             stepNumber: z.number().describe("The step number of the tutorial to start (1 to total available steps in the tutorial)")
@@ -56,7 +57,7 @@ export async function createTools(context: ToolContext) {
             });
             agentContext.logger.info("Added start_tutorial action to state for: %s at step %d", tutorialId, stepNumber);
             return `Starting "${data.title}". Total steps: ${data.totalSteps} \n\n Description: ${data.description}`;
-        },
+        }
     });
 
     /**
@@ -93,10 +94,63 @@ This tool provides authoritative, up-to-date documentation specific to the Agent
         },
     });
 
+    /**
+     * Tool to fetch user's tutorial progress
+     * This helps the agent understand which tutorials the user has completed or started
+     */
+    const getUserTutorialProgressTool = tool({
+        description: "Fetch the user's tutorial progress to see which tutorials they have started, completed, or not yet begun. Use this when you need to recommend tutorials based on what the user has already done, or when answering questions about topics covered in specific tutorials.",
+        parameters: z.object({}),
+        execute: async () => {
+            if (!userId) {
+                agentContext.logger.warn("Cannot fetch tutorial progress: userId not available");
+                return "Unable to fetch tutorial progress - user identification not available.";
+            }
+
+            agentContext.logger.info("Fetching tutorial progress for user: %s", userId);
+            const progressResponse = await getUserTutorialProgress(userId, agentContext);
+
+            if (!progressResponse.success || !progressResponse.data) {
+                agentContext.logger.error("Failed to fetch tutorial progress: %s", progressResponse.error);
+                return `Unable to fetch tutorial progress at this time.`;
+            }
+
+            const progress = progressResponse.data;
+            const tutorials = progress.tutorials || {};
+            const tutorialList = Object.values(tutorials);
+
+            if (tutorialList.length === 0) {
+                return "User has not started any tutorials yet.";
+            }
+
+            const completed = tutorialList.filter(t => t.completedAt);
+            const inProgress = tutorialList.filter(t => !t.completedAt);
+
+            let summary = `User Tutorial Progress:\n`;
+
+            if (completed.length > 0) {
+                summary += `\nCompleted Tutorials (${completed.length}):\n`;
+                completed.forEach(t => {
+                    summary += `  - ${t.tutorialId}: Completed on ${new Date(t.completedAt!).toLocaleDateString()}\n`;
+                });
+            }
+
+            if (inProgress.length > 0) {
+                summary += `\nIn Progress (${inProgress.length}):\n`;
+                inProgress.forEach(t => {
+                    summary += `  - ${t.tutorialId}: Step ${t.currentStep}/${t.totalSteps}, Last accessed: ${new Date(t.lastAccessedAt).toLocaleDateString()}\n`;
+                });
+            }
+
+            return summary;
+        },
+    });
+
     // Return tools object
     return {
         startTutorialById: startTutorialAtStep,
         queryOtherAgent: askDocsAgentTool,
+        getUserTutorialProgress: getUserTutorialProgressTool,
     };
 }
 
diff --git a/agent-docs/src/agents/agent-pulse/tutorial.ts b/agent-docs/src/agents/agent-pulse/tutorial.ts
index 7f41472f..5a5719d7 100644
--- a/agent-docs/src/agents/agent-pulse/tutorial.ts
+++ b/agent-docs/src/agents/agent-pulse/tutorial.ts
@@ -156,6 +156,91 @@ export async function getTutorialStep(tutorialId: string, stepNumber: number, ct
     return responseData;
   } catch (error) {
     ctx.logger.error('Error fetching tutorial step %d for tutorial %s: %s', stepNumber, tutorialId, error);
+    return {
+      success: false,
+      error: `Network error: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+export interface UserTutorialProgress {
+  userId: string;
+  tutorials: {
+    [tutorialId: string]: {
+      tutorialId: string;
+      currentStep: number;
+      totalSteps: number;
+      startedAt: string;
+      completedAt?: string;
+      lastAccessedAt: string;
+    };
+  };
+}
+
+/**
+ * Fetches the user's tutorial progress from the API
+ */
+export async function getUserTutorialProgress(
+  userId: string,
+  ctx: AgentContext
+): Promise<ApiResponse<UserTutorialProgress>> {
+  try {
+    if (!userId) {
+      return {
+        success: false,
+        error: 'User ID is required to fetch tutorial progress'
+      };
+    }
+
+    const response = await fetch(
+      `${TUTORIAL_API_BASE_URL}/api/users/tutorial-state`,
+      {
+        headers: {
+          'Cookie': `chat_user_id=${userId}`
+        }
+      }
+    );
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({ 
+        error: response.statusText 
+      })) as { error?: string; details?: any };
+      
+      ctx.logger.error(
+        'Failed to fetch user tutorial progress: %s', 
+        JSON.stringify(errorData)
+      );
+      
+      return {
+        success: false,
+        status: response.status,
+        error: errorData.error || response.statusText,
+        details: errorData.details
+      };
+    }
+
+    const responseData = await response.json() as ApiResponse<UserTutorialProgress>;
+    
+    if (!responseData.success) {
+      return {
+        success: false,
+        error: responseData.error || 'Failed to fetch tutorial progress'
+      };
+    }
+
+    ctx.logger.info(
+      'Fetched tutorial progress for user %s: %d tutorials', 
+      userId, 
+      Object.keys(responseData.data?.tutorials || {}).length
+    );
+    
+    return responseData;
+  } catch (error) {
+    ctx.logger.error(
+      'Error fetching user tutorial progress: %s', 
+      error instanceof Error ? error.message : String(error)
+    );
+    
     return {
       success: false,
       error: `Network error: ${error instanceof Error ? error.message : String(error)}`
diff --git a/agent-docs/src/agents/doc-processing/chunk-mdx.ts b/agent-docs/src/agents/doc-processing/chunk-mdx.ts
index 9554d874..5bf1ee79 100644
--- a/agent-docs/src/agents/doc-processing/chunk-mdx.ts
+++ b/agent-docs/src/agents/doc-processing/chunk-mdx.ts
@@ -61,36 +61,36 @@ export function createContentAwareSplitter(contentType: string) {
 			chunkOverlap: 0,
 			separators: ['\n---\n'],
 		});
-	}if (contentType === 'code_block') {
+	} if (contentType === 'code_block') {
 		return new RecursiveCharacterTextSplitter({
 			chunkSize: 800,
 			chunkOverlap: 100,
 			separators: ['\n```\n', '\n\n', '\n'],
 		});
-	}if (contentType === 'header_section') {
+	} if (contentType === 'header_section') {
 		return new RecursiveCharacterTextSplitter({
 			chunkSize: 1200,
 			chunkOverlap: 150,
 			separators: ['\n## ', '\n### ', '\n#### ', '\n\n', '\n'],
 		});
-	}if (contentType === 'table') {
+	} if (contentType === 'table') {
 		return new RecursiveCharacterTextSplitter({
 			chunkSize: 1500,
 			chunkOverlap: 0,
 			separators: ['\n\n'],
 		});
-	}if (contentType === 'list') {
+	} if (contentType === 'list') {
 		return new RecursiveCharacterTextSplitter({
 			chunkSize: 800,
 			chunkOverlap: 100,
 			separators: ['\n\n', '\n- ', '\n* ', '\n+ '],
 		});
 	}
-		return new RecursiveCharacterTextSplitter({
-			chunkSize: 1000,
-			chunkOverlap: 200,
-			separators: ['\n\n', '\n', ' '],
-		});
+	return new RecursiveCharacterTextSplitter({
+		chunkSize: 1000,
+		chunkOverlap: 200,
+		separators: ['\n\n', '\n', ' '],
+	});
 }
 
 export async function hybridChunkDocument(doc: Document) {
@@ -114,19 +114,6 @@ export async function hybridChunkDocument(doc: Document) {
 	return finalChunks;
 }
 
-export async function generateDocsChunks(docsPath: string) {
-	const loader = new DirectoryLoader(docsPath, {
-		'.mdx': (filePath: string) => new TextLoader(filePath),
-	});
-	const docs = await loader.load();
-	const allChunks: any[] = [];
-	for (const doc of docs) {
-		const docChunks = await hybridChunkDocument(doc);
-		allChunks.push(...docChunks);
-	}
-	return allChunks;
-}
-
 /**
  * Chunks and enriches a single MDX doc with metadata.
  * - Parses and removes frontmatter
diff --git a/agent-docs/src/agents/doc-processing/keyword-extraction.ts b/agent-docs/src/agents/doc-processing/keyword-extraction.ts
deleted file mode 100644
index d0ab7e22..00000000
--- a/agent-docs/src/agents/doc-processing/keyword-extraction.ts
+++ /dev/null
@@ -1,78 +0,0 @@
-import { openai } from '@ai-sdk/openai';
-import { generateText } from 'ai';
-
-export interface KeywordExtractionResult {
-	keywords: string[];
-	source: string;
-	chunkPreview?: string;
-}
-
-export interface KeywordExtractionOptions {
-	model?: string; // e.g., 'gpt-4o', 'gpt-3.5-turbo'
-	maxKeywords?: number;
-	logger?: {
-		info: (msg: string, ...args: any[]) => void;
-		error: (msg: string, ...args: any[]) => void;
-	};
-}
-
-/**
- * Extracts keywords from a documentation chunk using an LLM (Vercel AI SDK).
- * Prompts the LLM to return a JSON array of keywords, with fallback for comma-separated output.
- * @param chunkContent The text content of the documentation chunk.
- * @param options Optional settings for model, maxKeywords, and logger.
- * @returns Promise<KeywordExtractionResult> Structured result with keywords and metadata.
- * @throws Error if the LLM fails to generate a valid JSON response.
- */
-export async function extractKeywordsWithLLM(
-	chunkContent: string,
-	options: KeywordExtractionOptions = {}
-): Promise<KeywordExtractionResult> {
-	const {
-		model = 'gpt-4o',
-		maxKeywords = 10,
-		logger = { info: () => {}, error: () => {} },
-	} = options;
-
-	const prompt = `You are an expert technical documentation assistant.
-
-Given the following documentation chunk, extract 5 to 10 important keywords or key phrases that would help a developer search for or understand this content. Focus on technical terms, API names, function names, CLI commands, configuration options, and unique concepts. Avoid generic words.
-
-Return the keywords as a JSON array in the following format:
-{
-  "keywords": ["keyword1", "keyword2", ...]
-}
-
-Documentation chunk:
-"""
-${chunkContent}
-"""
-`;
-
-	logger.info(
-		'Extracting keywords for chunk (length: %d)...',
-		chunkContent.length
-	);
-	const result = await generateText({
-		model: openai(model),
-		prompt,
-		maxTokens: 150,
-		temperature: 0.2,
-	});
-	const raw = result.text || '';
-	let keywords: string[] = [];
-	const parsed = JSON.parse(raw);
-	if (Array.isArray(parsed.keywords)) {
-		keywords = parsed.keywords
-			.map((k: string) => k.trim())
-			.filter((k: string) => Boolean(k))
-			.filter((k: string, i: number, arr: string[]) => arr.indexOf(k) === i)
-			.slice(0, maxKeywords);
-	}
-	logger.info('Extracted keywords: %o', keywords);
-	return {
-		keywords,
-		source: 'llm',
-		chunkPreview: chunkContent.slice(0, 100),
-	};
-}
diff --git a/agent-docs/src/agents/doc-qa/prompt.ts b/agent-docs/src/agents/doc-qa/prompt.ts
index 24aa5f01..3f549256 100644
--- a/agent-docs/src/agents/doc-qa/prompt.ts
+++ b/agent-docs/src/agents/doc-qa/prompt.ts
@@ -1,9 +1,7 @@
 import type { AgentContext } from '@agentuity/sdk';
 import { openai } from '@ai-sdk/openai';
-import { generateObject, generateText } from 'ai';
+import { generateText } from 'ai';
 
-import type { PromptType } from './types';
-import { PromptClassificationSchema } from './types';
 
 export async function rephraseVaguePrompt(
 	ctx: AgentContext,
@@ -70,67 +68,3 @@ Return ONLY the query text, nothing else.`;
 		return input;
 	}
 }
-
-/**
- * Determines the prompt type based on the input string using LLM classification.
- * Uses specific, measurable criteria to decide between Normal and Agentic RAG.
- * @param ctx - Agent Context for logging and LLM access
- * @param input - The input string to analyze
- * @returns {Promise<PromptType>} - The determined PromptType
- */
-export async function getPromptType(
-	ctx: AgentContext,
-	input: string
-): Promise<PromptType> {
-	const systemPrompt = `
-You are a query classifier that determines whether a user question requires simple retrieval (Normal) or complex reasoning (Thinking).
-
-Use these SPECIFIC criteria for classification:
-
-**THINKING (Agentic RAG) indicators:**
-- Multi-step reasoning required (e.g., "compare and contrast", "analyze pros/cons")  
-- Synthesis across multiple concepts (e.g., "how does X relate to Y")
-- Scenario analysis (e.g., "what would happen if...", "when should I use...")
-- Troubleshooting/debugging questions requiring logical deduction
-- Questions with explicit reasoning requests ("explain why", "walk me through")
-- Comparative analysis ("which is better for...", "what are the trade-offs")
-
-**NORMAL (Simple RAG) indicators:**
-- Direct factual lookups (e.g., "what is...", "how do I install...")
-- Simple how-to questions with clear answers
-- API reference queries  
-- Configuration/syntax questions
-- Single-concept definitions
-
-Respond with a JSON object containing:
-- type: "Normal" or "Thinking"  
-- confidence: 0.0-1.0 (how certain you are)
-- reasoning: brief explanation of your classification
-
-Be conservative - when in doubt, default to "Normal" for better performance.`;
-
-	try {
-		const result = await generateObject({
-			model: openai('gpt-4o-mini'), // Use faster model for classification
-			system: systemPrompt,
-			prompt: `Classify this user query: "${input}"`,
-			schema: PromptClassificationSchema,
-			maxTokens: 200,
-		});
-
-		ctx.logger.info(
-			'Prompt classified as %s (confidence: %f): %s',
-			result.object.type,
-			result.object.confidence,
-			result.object.reasoning
-		);
-
-		return result.object.type as PromptType;
-	} catch (error) {
-		ctx.logger.error(
-			'Error classifying prompt, defaulting to Normal: %o',
-			error
-		);
-		return 'Normal' as PromptType;
-	}
-}
diff --git a/agent-docs/src/agents/doc-qa/types.ts b/agent-docs/src/agents/doc-qa/types.ts
index 8e37facf..6cab6e6a 100644
--- a/agent-docs/src/agents/doc-qa/types.ts
+++ b/agent-docs/src/agents/doc-qa/types.ts
@@ -13,16 +13,6 @@ export const AnswerSchema = z.object({
 	documents: z.array(z.string()),
 });
 
-export const PromptTypeSchema = z.enum(['Normal', 'Thinking']);
-
-export const PromptClassificationSchema = z.object({
-	type: PromptTypeSchema,
-	confidence: z.number().min(0).max(1),
-	reasoning: z.string(),
-});
-
 // Generated TypeScript types
 export type RelevantDoc = z.infer<typeof RelevantDocSchema>;
 export type Answer = z.infer<typeof AnswerSchema>;
-export type PromptType = z.infer<typeof PromptTypeSchema>;
-export type PromptClassification = z.infer<typeof PromptClassificationSchema>;
diff --git a/app/api/sessions/[sessionId]/messages/route.ts b/app/api/sessions/[sessionId]/messages/route.ts
index 523b43d1..169cd6df 100644
--- a/app/api/sessions/[sessionId]/messages/route.ts
+++ b/app/api/sessions/[sessionId]/messages/route.ts
@@ -230,6 +230,7 @@ export async function POST(
         -DEFAULT_CONVERSATION_HISTORY_LIMIT
       ),
       tutorialData: currentTutorialState,
+      userId: userId,
     };
 
     // Prepare headers with optional bearer token
diff --git a/app/api/tutorials/[id]/route.ts b/app/api/tutorials/[id]/route.ts
index 9b4245cd..b8770071 100644
--- a/app/api/tutorials/[id]/route.ts
+++ b/app/api/tutorials/[id]/route.ts
@@ -31,11 +31,17 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
     
     const parsed = await parseTutorialMDXCached(filePath);
     
+    // Calculate totalSteps if missing from frontmatter
+    const totalSteps = parsed.metadata.totalSteps ?? parsed.steps.length;
+    
     return NextResponse.json({
       success: true,
       data: {
         id,
-        metadata: parsed.metadata,
+        metadata: {
+          ...parsed.metadata,
+          totalSteps
+        },
         fullContent: parsed.fullContent,
         steps: parsed.steps.map(step => ({
           stepNumber: step.stepNumber,
diff --git a/app/api/tutorials/[id]/steps/[stepNumber]/route.ts b/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
index 53979777..ab285bc2 100644
--- a/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
+++ b/app/api/tutorials/[id]/steps/[stepNumber]/route.ts
@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from 'next/server';
 import { parseTutorialMDXCached } from '@/lib/tutorial/mdx-parser';
 import { StepParamsSchema } from '@/lib/tutorial/schemas';
 import { getTutorialFilePath } from '@/lib/tutorial';
+import { convertMdxToMarkdown } from '@/lib/tutorial/mdx-to-markdown';
 
 interface RouteParams {
   params: Promise<{ id: string; stepNumber: string }>;
@@ -38,17 +39,20 @@ export async function GET(request: NextRequest, { params }: RouteParams) {
       );
     }
 
+    // Calculate totalSteps if missing from frontmatter
+    const totalSteps = parsed.metadata.totalSteps ?? parsed.steps.length;
+
     return NextResponse.json({
       success: true,
       data: {
         tutorialId: id,
-        totalSteps: parsed.metadata.totalSteps,
+        totalSteps,
         currentStep: stepNum,
         tutorialStep: {
           title: step.title,
-          mdx: step.mdxContent,
+          mdx: convertMdxToMarkdown(step.mdxContent),
           snippets: step.snippets,
-          totalSteps: parsed.metadata.totalSteps,
+          totalSteps,
           estimatedTime: step.estimatedTime,
         }
       }
diff --git a/app/chat/[sessionId]/page.tsx b/app/chat/[sessionId]/page.tsx
index ef569ef4..0546c4e1 100644
--- a/app/chat/[sessionId]/page.tsx
+++ b/app/chat/[sessionId]/page.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import { useEffect, useState } from 'react';
+import { useEffect, useState, useRef } from 'react';
 import { useParams } from "next/navigation";
 import { Allotment } from "allotment";
 import "allotment/dist/style.css";
@@ -20,6 +20,11 @@ export default function ChatSessionPage() {
   const { sessions, setSessions, revalidateSessions } = useSessions();
   const [creationError, setCreationError] = useState<string | null>(null);
 
+  // Refs for throttling text streaming updates
+  const textAccumulatorRef = useRef<string>('');
+  const streamingMessageIdRef = useRef<string | null>(null);
+  const updateTimerRef = useRef<NodeJS.Timeout | null>(null);
+
 
   const handleSendMessage = async (content: string, sessionId: string) => {
     if (!content || !sessionId) return;
@@ -52,19 +57,36 @@ export default function ChatSessionPage() {
         newMessage,
         {
           onTextDelta: (textDelta) => {
-            setSession(prev => {
-              if (!prev) return prev;
-              const updatedMessages = prev.messages.map(msg => {
-                if (msg.id === assistantMessage.id) {
-                  return {
-                    ...msg,
-                    content: msg.content + textDelta
-                  };
-                }
-                return msg;
+            // Accumulate the text in the ref
+            textAccumulatorRef.current += textDelta;
+            streamingMessageIdRef.current = assistantMessage.id;
+            
+            // Clear any existing timer
+            if (updateTimerRef.current) {
+              clearTimeout(updateTimerRef.current);
+            }
+            
+            // Throttle updates to every 50ms
+            updateTimerRef.current = setTimeout(() => {
+              const accumulatedText = textAccumulatorRef.current;
+              
+              setSession(prev => {
+                if (!prev) return prev;
+                const updatedMessages = prev.messages.map(msg => {
+                  if (msg.id === assistantMessage.id) {
+                    return {
+                      ...msg,
+                      content: msg.content + accumulatedText
+                    };
+                  }
+                  return msg;
+                });
+                return { ...prev, messages: updatedMessages };
               });
-              return { ...prev, messages: updatedMessages };
-            });
+              
+              // Reset accumulator after updating
+              textAccumulatorRef.current = '';
+            }, 50);
           },
 
           onTutorialData: (tutorialData) => {
@@ -80,12 +102,51 @@ export default function ChatSessionPage() {
           },
 
           onFinish: (finalSession) => {
+            // Clear any pending updates and flush remaining text
+            if (updateTimerRef.current) {
+              clearTimeout(updateTimerRef.current);
+              updateTimerRef.current = null;
+            }
+            
+            // Flush any remaining accumulated text before setting final session
+            if (textAccumulatorRef.current) {
+              setSession(prev => {
+                if (!prev) return prev;
+                const updatedMessages = prev.messages.map(msg => {
+                  if (msg.id === streamingMessageIdRef.current) {
+                    return {
+                      ...msg,
+                      content: msg.content + textAccumulatorRef.current
+                    };
+                  }
+                  return msg;
+                });
+                return { ...prev, messages: updatedMessages };
+              });
+            }
+            
+            // Reset refs
+            textAccumulatorRef.current = '';
+            streamingMessageIdRef.current = null;
+            
+            // Set the final session
             setSession(finalSession);
             setSessions(prev => prev.map(s => s.sessionId === sessionId ? finalSession : s));
           },
 
           onError: (error) => {
             console.error('Error sending message:', error);
+            
+            // Clear any pending updates
+            if (updateTimerRef.current) {
+              clearTimeout(updateTimerRef.current);
+              updateTimerRef.current = null;
+            }
+            
+            // Reset refs
+            textAccumulatorRef.current = '';
+            streamingMessageIdRef.current = null;
+            
             setSession(prev => {
               if (!prev) return prev;
               const updatedMessages = prev.messages.map(msg =>
@@ -101,6 +162,17 @@ export default function ChatSessionPage() {
 
     } catch (error) {
       console.error('Error sending message:', error);
+      
+      // Clear any pending updates
+      if (updateTimerRef.current) {
+        clearTimeout(updateTimerRef.current);
+        updateTimerRef.current = null;
+      }
+      
+      // Reset refs
+      textAccumulatorRef.current = '';
+      streamingMessageIdRef.current = null;
+      
       setSession(prevSession => {
         if (!prevSession) return prevSession;
         const filteredMessages = prevSession.messages.filter(msg =>
@@ -161,8 +233,16 @@ export default function ChatSessionPage() {
         setCreationError(error.message || 'Error creating session');
         revalidateSessions?.();
       });
-  }, [sessionId]);
+  }, [sessionId, sessions]);
 
+  // Cleanup effect to clear any pending timers on unmount
+  useEffect(() => {
+    return () => {
+      if (updateTimerRef.current) {
+        clearTimeout(updateTimerRef.current);
+      }
+    };
+  }, []);
 
   const toggleEditor = () => { setEditorOpen(false) };
   const stopServer = () => { };
diff --git a/app/chat/components/ChatInput.tsx b/app/chat/components/ChatInput.tsx
index 0422b2ac..c5387034 100644
--- a/app/chat/components/ChatInput.tsx
+++ b/app/chat/components/ChatInput.tsx
@@ -52,7 +52,7 @@ export function ChatInput({
             onKeyDown={handleKeyDown}
             placeholder="Ask about Agentuity or request tutorials..."
             className="w-full px-3 py-2 text-sm text-gray-200 placeholder-gray-400
-          bg-transparent border-0 focus:outline-none agentuity-scrollbar
+          bg-transparent border-0 focus:outline-none scrollbar-thin
           min-h-[40px] max-h-[16rem] pr-10 overflow-y-auto resize-none"
             rows={2}
           />
diff --git a/app/chat/components/ChatMessage.tsx b/app/chat/components/ChatMessage.tsx
index 4c340d2d..aa4d0bc3 100644
--- a/app/chat/components/ChatMessage.tsx
+++ b/app/chat/components/ChatMessage.tsx
@@ -84,13 +84,13 @@ export const ChatMessageComponent = React.memo(function ChatMessageComponent({
     const tutorialSnippets = message.tutorialData?.tutorialStep.snippets as TutorialSnippet[] | undefined;
     const currentStep = message.tutorialData?.currentStep;
     const totalSteps = message.tutorialData?.totalSteps;
-    
+
     // Memoize tutorial content transformation to avoid Rules of Hooks violation
-    const memoizedTutorialContent = useMemo(() => 
-        tutorialMdx ? transformMdxWithSnippets(tutorialMdx, tutorialSnippets || []) : null, 
+    const memoizedTutorialContent = useMemo(() =>
+        tutorialMdx ? transformMdxWithSnippets(tutorialMdx, tutorialSnippets || []) : null,
         [tutorialMdx, tutorialSnippets]
     );
-    
+
     const handleOpenInEditor = (code: string) => {
         setEditorContent(code);
         setEditorOpen(true);
@@ -115,9 +115,9 @@ export const ChatMessageComponent = React.memo(function ChatMessageComponent({
                             {message.content === '' ? (
                                 <div className="flex items-center gap-4 text-gray-300 mb-4">
                                     <div className="flex space-x-2">
-                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite]"/>
-                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite_0.2s]"/>
-                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite_0.4s]"/>
+                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite]" />
+                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite_0.2s]" />
+                                        <div className="w-3 h-3 bg-gradient-to-br from-cyan-400 to-teal-500 rounded-full animate-[pulse_1.2s_ease-in-out_infinite_0.4s]" />
                                     </div>
                                     <span className="text-sm tracking-wide text-gray-200">Agent is processing...</span>
                                 </div>
diff --git a/app/chat/components/ChatMessagesArea.tsx b/app/chat/components/ChatMessagesArea.tsx
index e8ebd11c..adb8a722 100644
--- a/app/chat/components/ChatMessagesArea.tsx
+++ b/app/chat/components/ChatMessagesArea.tsx
@@ -1,6 +1,6 @@
 'use client';
 
-import React, { useRef, useEffect,useState } from 'react';
+import React, { useRef, useEffect, useState } from 'react';
 import { ChatMessageComponent } from './ChatMessage';
 import { ChatInput } from './ChatInput';
 import { Session } from '../types';
@@ -51,7 +51,7 @@ export function ChatMessagesArea({
         <div className="flex-1 flex flex-col min-w-0 h-full">
             <div
                 ref={messagesContainerRef}
-                className="flex-1 p-4 md:p-6 space-y-6 h-full  overflow-y-auto agentuity-scrollbar"
+                className="flex-1 p-4 md:p-6 space-y-6 h-full overflow-y-auto scrollbar-thin"
                 style={{ maxHeight: 'calc(100vh - 120px)', overflowY: 'auto' }}
             >
                 {session.messages.map((message) => (
diff --git a/app/chat/components/SessionSidebar.tsx b/app/chat/components/SessionSidebar.tsx
index 6e8b7e7e..7f920f98 100644
--- a/app/chat/components/SessionSidebar.tsx
+++ b/app/chat/components/SessionSidebar.tsx
@@ -1,32 +1,20 @@
 'use client';
 
-import { useState } from 'react';
+import { useState, useEffect, useRef } from 'react';
 import {
-  Plus,
+  PenSquare,
   BookAIcon,
   MessageCircle,
   ChevronLeft,
-  ChevronRight
+  ChevronRight,
+  ChevronDown,
+  MoreVertical,
+  Pencil,
+  Trash2
 } from 'lucide-react';
 import { AgentuityLogo } from '@/components/icons/AgentuityLogo';
 import { Session, SessionSidebarProps } from '../types';
 
-// Helper function to format relative dates
-const formatRelativeDate = (date: Date): string => {
-  const now = new Date();
-  const diffInMs = now.getTime() - date.getTime();
-  const diffInDays = Math.floor(diffInMs / (1000 * 60 * 60 * 24));
-
-  if (diffInDays === 0) return 'Today';
-  if (diffInDays === 1) return 'Yesterday';
-  if (diffInDays < 7) return `${diffInDays} days ago`;
-
-  return date.toLocaleDateString('en-US', {
-    month: 'short',
-    day: 'numeric'
-  });
-};
-
 // Helper function to truncate text with ellipsis
 const truncateText = (text: string, maxLength: number): string => {
   if (text.length <= maxLength) return text;
@@ -38,11 +26,53 @@ export function SessionSidebar({
   sessions,
   onSessionSelect,
   onNewSession,
+  onDeleteSession,
+  onEditSession,
   hasMore,
   onLoadMore,
   isLoadingMore
 }: SessionSidebarProps) {
   const [isCollapsed, setIsCollapsed] = useState(true);
+  const [openMenuId, setOpenMenuId] = useState<string | null>(null);
+  const [editingId, setEditingId] = useState<string | null>(null);
+  const [editTitle, setEditTitle] = useState('');
+  const menuRef = useRef<HTMLDivElement>(null);
+  const sessionsListRef = useRef<HTMLDivElement>(null);
+  const previousSessionsLengthRef = useRef(sessions.length);
+  const shouldScrollRef = useRef(false);
+
+  // Close dropdown when clicking outside
+  useEffect(() => {
+    const handleClickOutside = (event: MouseEvent) => {
+      if (menuRef.current && !menuRef.current.contains(event.target as Node)) {
+        setOpenMenuId(null);
+      }
+    };
+
+    if (openMenuId) {
+      document.addEventListener('mousedown', handleClickOutside);
+      return () => {
+        document.removeEventListener('mousedown', handleClickOutside);
+      };
+    }
+  }, [openMenuId]);
+
+  // Scroll to bottom when new sessions are loaded after clicking load more
+  useEffect(() => {
+    if (shouldScrollRef.current && sessions.length > previousSessionsLengthRef.current) {
+      // Use requestAnimationFrame to ensure DOM has been updated
+      requestAnimationFrame(() => {
+        if (sessionsListRef.current) {
+          sessionsListRef.current.scrollTo({
+            top: sessionsListRef.current.scrollHeight,
+            behavior: 'smooth'
+          });
+        }
+      });
+      shouldScrollRef.current = false;
+    }
+    previousSessionsLengthRef.current = sessions.length;
+  }, [sessions]);
 
   const toggleCollapsed = () => {
     setIsCollapsed(!isCollapsed);
@@ -52,6 +82,53 @@ export function SessionSidebar({
     onSessionSelect(sessionId);
   };
 
+  const handleMenuToggle = (sessionId: string, e: React.MouseEvent) => {
+    e.stopPropagation();
+    setOpenMenuId(openMenuId === sessionId ? null : sessionId);
+  };
+
+  const handleEditStart = (session: Session, e: React.MouseEvent) => {
+    e.stopPropagation();
+    setEditingId(session.sessionId);
+    setEditTitle(session.title || getSessionPreview(session));
+    setOpenMenuId(null);
+  };
+
+  const handleEditSave = (sessionId: string) => {
+    if (editTitle.trim() && onEditSession) {
+      onEditSession(sessionId, editTitle.trim());
+    }
+    setEditingId(null);
+  };
+
+  const handleEditCancel = () => {
+    setEditingId(null);
+  };
+
+  const handleEditBlur = (sessionId: string) => {
+    // Cancel if empty, otherwise save
+    if (!editTitle.trim()) {
+      handleEditCancel();
+    } else {
+      handleEditSave(sessionId);
+    }
+  };
+
+  const handleDelete = (sessionId: string, e: React.MouseEvent) => {
+    e.stopPropagation();
+    if (onDeleteSession && confirm('Are you sure you want to delete this session?')) {
+      onDeleteSession(sessionId);
+    }
+    setOpenMenuId(null);
+  };
+
+  const handleLoadMore = () => {
+    if (onLoadMore && !isLoadingMore) {
+      shouldScrollRef.current = true;
+      onLoadMore();
+    }
+  };
+
   // Get session display title
   const getSessionPreview = (session: Session) => {
     if (session.title && session.title.trim().length > 0) {
@@ -63,42 +140,43 @@ export function SessionSidebar({
     }
     return 'New conversation';
   };
-  const relativeDate = formatRelativeDate(new Date());
 
   return (
     <div
       className={`
           fixed lg:static inset-y-0 left-0 z-50
-          transform transition-all duration-300 ease-out
-          -translate-x-full lg:translate-x-0
+          transform -translate-x-full lg:translate-x-0
           ${isCollapsed ? 'w-12 lg:w-12' : 'w-70 lg:w-70'}
           bg-black/20 backdrop-blur-md border-r border-white/10
           flex flex-col h-full
+          transition-[width] duration-300 ease-in-out
         `}
     >
       {/* Header Section */}
-      <div className="p-3 border-b border-white/8">
+      <div className={`p-3 ${isCollapsed ? '' : 'border-b border-white/8'}`}>
         <div className="flex items-center justify-between">
-          {!isCollapsed && (
-            <div className="flex items-center gap-3 min-w-0">
-              <div className="w-8 h-8 bg-cyan-500/10 rounded-lg flex items-center justify-center border border-cyan-500/20">
-                <AgentuityLogo className="w-4 h-4 text-cyan-400" />
-              </div>
-              <div className="min-w-0">
-                <h1 className="text-sm font-semibold text-gray-200 truncate">
-                  Agentuity
-                </h1>
-                <p className="text-xs text-gray-400 truncate">
-                  AI Playground
-                </p>
-              </div>
+          <div className={`
+            flex items-center gap-3 min-w-0
+            transition-opacity duration-200
+            ${isCollapsed ? 'opacity-0 pointer-events-none w-0' : 'opacity-100'}
+          `}>
+            <div className="w-8 h-8 bg-cyan-500/10 rounded-lg flex items-center justify-center border border-cyan-500/20">
+              <AgentuityLogo className="w-4 h-4 text-cyan-400" />
             </div>
-          )}
+            <div className="min-w-0">
+              <h1 className="text-sm font-semibold text-gray-200 truncate">
+                Agentuity
+              </h1>
+              <p className="text-xs text-gray-400 truncate">
+                AI Playground
+              </p>
+            </div>
+          </div>
 
           {/* Desktop Toggle Button */}
           <button
             onClick={toggleCollapsed}
-            className="hidden lg:flex items-center justify-center w-6 h-6 rounded-md text-gray-400 hover:text-gray-200 hover:bg-white/5 transition-colors"
+            className="hidden lg:flex items-center justify-center w-6 h-6 rounded-md text-gray-400 hover:text-gray-200 hover:bg-white/5 transition-colors flex-shrink-0"
             aria-label={isCollapsed ? 'Expand sidebar' : 'Collapse sidebar'}
           >
             {isCollapsed ? (
@@ -111,48 +189,63 @@ export function SessionSidebar({
       </div>
 
       {/* Action Section */}
-      <div className="p-2 border-b border-white/8">
+      <div className='p-2'>
         <button
           onClick={onNewSession}
           className={`
-              w-full flex items-center gap-3 p-1 rounded-lg
-              bg-cyan-500/10 hover:bg-cyan-500/20 border border-cyan-500/20
-              text-cyan-400 hover:text-cyan-300 transition-all duration-200
-              ${isCollapsed ? 'justify-center' : 'justify-start'}
+              w-full flex items-center gap-3 p-2 rounded-lg
+              hover:bg-cyan-500/20 hover:text-cyan-300 transition-colors duration-200
+              justify-start
             `}
           aria-label="Start new chat"
         >
-          <Plus className="w-5 h-5 flex-shrink-0" />
-          {!isCollapsed && (
-            <span className="text-sm font-medium">New Chat</span>
+          <PenSquare className="w-4 h-4" />
+          {!isCollapsed && (<span className={`
+            text-sm font-medium whitespace-nowrap
+            transition-opacity duration-200 opacity-100
+            `}>
+            New Chat
+          </span>
           )}
         </button>
       </div>
-
       {/* Sessions List */}
-      <div className="flex-1 overflow-y-auto">
-        <div className="p-2 space-y-1">
-            {sessions.map((session: Session) => {
-              const isActive = session.sessionId === currentSessionId;
-              const preview = getSessionPreview(session);
-              const isTutorial = session.isTutorial;
-              // Use current timestamp since we don't have updatedAt anymore
-
-              return (
-                <button
-                  key={session.sessionId}
-                  onClick={() => handleSessionClick(session.sessionId)}
-                  className={`
-                      w-full flex items-center gap-2 p-2 rounded-lg text-left
-                      transition-all duration-200 group
+      {!isCollapsed && (
+        <p className="text-sm text-gray-400 p-2">Chats</p>
+      )}
+      <div
+        ref={sessionsListRef}
+        className={`
+          flex-1 overflow-y-auto scrollbar-thin
+          transition-opacity duration-200 p-2
+          ${isCollapsed ? 'opacity-0 h-0 overflow-hidden pointer-events-none' : 'opacity-100'}
+        `}
+      >
+        <div className="space-y-1">
+          {sessions.map((session: Session) => {
+            const isActive = session.sessionId === currentSessionId;
+            const preview = getSessionPreview(session);
+            const isTutorial = session.isTutorial;
+            const isEditing = editingId === session.sessionId;
+            const isMenuOpen = openMenuId === session.sessionId;
+
+            return (
+              <div
+                key={session.sessionId}
+                onClick={() => handleSessionClick(session.sessionId)}
+                className={`
+                      relative w-full flex items-center gap-2 p-2 rounded-lg text-left
+                      transition-all duration-200 group cursor-pointer justify-start
                       ${isActive
-                      ? 'bg-cyan-500/10 border border-cyan-500/20 text-cyan-400'
-                      : 'hover:bg-white/5 text-gray-300 hover:text-gray-200'
-                    }
-                      ${isCollapsed ? 'justify-center' : 'justify-start'}
+                    ? 'bg-cyan-500/10 border border-cyan-500/20 text-cyan-400'
+                    : 'hover:bg-white/5 text-gray-300 hover:text-gray-200'
+                  }
                     `}
-                  aria-label={`Switch to conversation: ${preview}`}
-                  title={isCollapsed ? preview : undefined}
+                role="button"
+                aria-label={`Switch to conversation: ${preview}`}
+              >
+                <div
+                  className="flex items-center gap-2 flex-1 min-w-0"
                 >
                   <div className="flex-shrink-0">
                     {isTutorial ? (
@@ -162,42 +255,91 @@ export function SessionSidebar({
                     )}
                   </div>
 
-                  {!isCollapsed && (
-                    <div className="flex-1 min-w-0">
-                      <div className="flex items-center justify-between mb-1">
-                        <p className="text-sm font-medium truncate">
-                          {truncateText(preview, 25)}
-                        </p>
-                        <span className="text-xs text-gray-400 flex-shrink-0 ml-2">
-                          {relativeDate}
-                        </span>
-                      </div>
-                      <div className="flex items-center gap-2 text-xs text-gray-500">
-                        <span>{session.messages?.length || 0} messages</span>
+                  <div className="flex-1 min-w-0">
+                    {isEditing ? (
+                      <input
+                        type="text"
+                        value={editTitle}
+                        onChange={(e) => setEditTitle(e.target.value)}
+                        onBlur={() => handleEditBlur(session.sessionId)}
+                        onKeyDown={(e) => {
+                          if (e.key === 'Enter') {
+                            handleEditBlur(session.sessionId);
+                          } else if (e.key === 'Escape') {
+                            handleEditCancel();
+                          }
+                        }}
+                        onClick={(e) => e.stopPropagation()}
+                        className="w-full bg-black/30 border border-cyan-500/30 rounded px-2 py-1 text-sm text-gray-200 focus:outline-none focus:border-cyan-500/50"
+                        autoFocus
+                      />
+                    ) : (
+                      <p className="text-sm font-medium truncate">
+                        {truncateText(preview, 25)}
+                      </p>
+                    )}
+                  </div>
+                </div>
+
+                {/* Action Menu Button */}
+                {!isEditing && (onDeleteSession || onEditSession) && (
+                  <div className="relative flex-shrink-0" ref={isMenuOpen ? menuRef : null}>
+                    <button
+                      onClick={(e) => handleMenuToggle(session.sessionId, e)}
+                      className="p-1 rounded hover:bg-white/10 opacity-0 group-hover:opacity-100 transition-opacity"
+                      aria-label="Session actions"
+                    >
+                      <MoreVertical className="w-4 h-4" />
+                    </button>
+
+                    {/* Dropdown Menu */}
+                    {isMenuOpen && (
+                      <div className="absolute right-0 top-8 z-50 bg-gray-900 border border-white/10 rounded-lg shadow-lg py-1 min-w-[150px]">
+                        {onEditSession && (
+                          <button
+                            onClick={(e) => handleEditStart(session, e)}
+                            className="w-full flex items-center gap-2 px-3 py-2 text-sm text-gray-300 hover:bg-white/10"
+                          >
+                            <Pencil className="w-4 h-4" />
+                            Rename
+                          </button>
+                        )}
+                        {onDeleteSession && (
+                          <button
+                            onClick={(e) => handleDelete(session.sessionId, e)}
+                            className="w-full flex items-center gap-2 px-3 py-2 text-sm text-red-400 hover:bg-red-500/10"
+                          >
+                            <Trash2 className="w-4 h-4" />
+                            Delete
+                          </button>
+                        )}
                       </div>
-                    </div>
-                  )}
-                </button>
-              );
-            })}
-          </div>
+                    )}
+                  </div>
+                )}
+              </div>
+            );
+          })}
+        </div>
       </div>
 
       {/* Footer Section */}
-      <div className="p-3 border-t border-white/8">
-        {!isCollapsed && (
-          <>
-            {typeof onLoadMore === 'function' && hasMore && (
-              <button
-                onClick={onLoadMore}
-                disabled={isLoadingMore}
-                className="w-full px-2 py-1 text-sm rounded-md bg-white/5 hover:bg-white/10 disabled:opacity-60"
-              >
-                {isLoadingMore ? 'Loading...' : 'Load more'}
-              </button>
-            )}
-          </>
-        )}
+      <div className={`p-3 ${isCollapsed ? '' : 'border-t border-white/8'}`}>
+        <div className={`
+          transition-opacity duration-200
+          ${isCollapsed ? 'opacity-0 h-0 overflow-hidden' : 'opacity-100'}
+        `}>
+          {typeof onLoadMore === 'function' && hasMore && (
+            <button
+              onClick={handleLoadMore}
+              disabled={isLoadingMore}
+              className="w-full flex items-center justify-center p-2 rounded-md bg-white/5 hover:bg-white/10 disabled:opacity-60 transition-colors"
+              aria-label={isLoadingMore ? 'Loading more sessions...' : 'Load more sessions'}
+            >
+              <ChevronDown className={`w-5 h-5 text-gray-400 ${isLoadingMore ? 'animate-pulse' : ''}`} />
+            </button>
+          )}
+        </div>
       </div>
     </div>
   );
diff --git a/app/chat/components/SessionSidebarSkeleton.tsx b/app/chat/components/SessionSidebarSkeleton.tsx
index 7377808f..778542cc 100644
--- a/app/chat/components/SessionSidebarSkeleton.tsx
+++ b/app/chat/components/SessionSidebarSkeleton.tsx
@@ -1,7 +1,7 @@
 'use client';
 
 import { useState } from 'react';
-import { ChevronLeft, ChevronRight, Plus } from 'lucide-react';
+import { ChevronLeft, ChevronRight, PenSquare } from 'lucide-react';
 import { Skeleton } from '@/components/ui/skeleton';
 
 export function SessionSidebarSkeleton() {
@@ -11,29 +11,31 @@ export function SessionSidebarSkeleton() {
     <div
       className={`
         fixed lg:static inset-y-0 left-0 z-50 
-        transform transition-all duration-300 ease-out
-        -translate-x-full lg:translate-x-0
+        transform -translate-x-full lg:translate-x-0
         ${isCollapsed ? 'w-12 lg:w-12' : 'w-70 lg:w-70'}
         bg-black/20 backdrop-blur-md border-r border-white/10
         flex flex-col h-full
+        transition-[width] duration-300 ease-in-out
       `}
     >
       {/* Header */}
-      <div className="p-3 border-b border-white/8">
+      <div className={`p-3 ${isCollapsed ? '' : 'border-b border-white/8'}`}>
         <div className="flex items-center justify-between">
-          {!isCollapsed && (
-            <div className="flex items-center gap-3 min-w-0">
-              <Skeleton className="w-8 h-8 rounded-lg" />
-              <div className="min-w-0 space-y-1">
-                <Skeleton className="h-3 w-24" />
-                <Skeleton className="h-2 w-20" />
-              </div>
+          <div className={`
+            flex items-center gap-3 min-w-0
+            transition-opacity duration-200
+            ${isCollapsed ? 'opacity-0 pointer-events-none w-0' : 'opacity-100'}
+          `}>
+            <Skeleton className="w-8 h-8 rounded-lg" />
+            <div className="min-w-0 space-y-1">
+              <Skeleton className="h-3 w-24" />
+              <Skeleton className="h-2 w-20" />
             </div>
-          )}
+          </div>
 
           <button
             onClick={() => setIsCollapsed(v => !v)}
-            className="hidden lg:flex items-center justify-center w-6 h-6 rounded-md text-gray-400 hover:text-gray-200 hover:bg-white/5 transition-colors"
+            className="hidden lg:flex items-center justify-center w-6 h-6 rounded-md text-gray-400 hover:text-gray-200 hover:bg-white/5 transition-colors flex-shrink-0"
             aria-label={isCollapsed ? 'Expand sidebar' : 'Collapse sidebar'}
           >
             {isCollapsed ? (
@@ -46,52 +48,57 @@ export function SessionSidebarSkeleton() {
       </div>
 
       {/* Action */}
-      <div className="p-2 border-b border-white/8">
+      <div className={`p-2 ${isCollapsed ? '' : 'border-b border-white/8'}`}>
         <button
           className={`
-            w-full flex items-center gap-3 p-1 rounded-lg
-            bg-white/5 border border-white/10 text-gray-300 cursor-not-allowed
-            ${isCollapsed ? 'justify-center' : 'justify-start'}
+            w-full flex items-center gap-2 p-2 rounded-lg
+            bg-white/5 text-gray-300 cursor-not-allowed border border-white/10
+            justify-start
           `}
           aria-label="Start new chat"
           disabled
         >
-          <Plus className="w-5 h-5 flex-shrink-0 opacity-60" />
-          {!isCollapsed && (
-            <span className="text-sm font-medium opacity-60">New Chat</span>
-          )}
+          <PenSquare className="w-4 h-4 flex-shrink-0 opacity-60" />
+          <span className={`
+            text-sm font-medium opacity-60 whitespace-nowrap
+            transition-opacity duration-200
+            ${isCollapsed ? 'opacity-0 w-0 overflow-hidden' : 'opacity-60'}
+          `}>
+            New Chat
+          </span>
         </button>
       </div>
 
       {/* List */}
-      <div className="flex-1 overflow-y-auto p-2 space-y-1">
+      <div className={`
+        flex-1 overflow-y-auto p-2 space-y-1 transition-opacity duration-200
+        ${isCollapsed ? 'opacity-0 h-0 overflow-hidden pointer-events-none' : ''}
+      `}>
         {Array.from({ length: 6 }).map((_, i) => (
           <div
             key={i}
-            className={`
-              w-full flex items-center gap-2 p-2 rounded-lg
-              ${isCollapsed ? 'justify-center' : 'justify-start'}
-            `}
+            className="w-full flex items-center gap-2 p-2 rounded-lg justify-start"
           >
             <Skeleton className="w-4 h-4 rounded" />
-            {!isCollapsed && (
-              <div className="flex-1 min-w-0 space-y-2">
-                <div className="flex items-center justify-between">
-                  <Skeleton className="h-3 w-32" />
-                  <Skeleton className="h-2 w-12" />
-                </div>
-                <Skeleton className="h-2 w-24" />
+            <div className="flex-1 min-w-0 space-y-2">
+              <div className="flex items-center justify-between">
+                <Skeleton className="h-3 w-32" />
+                <Skeleton className="h-2 w-12" />
               </div>
-            )}
+              <Skeleton className="h-2 w-24" />
+            </div>
           </div>
         ))}
       </div>
 
       {/* Footer */}
-      <div className="p-3 border-t border-white/8">
-        {!isCollapsed && (
+      <div className={`p-3 ${isCollapsed ? '' : 'border-t border-white/8'}`}>
+        <div className={`
+          transition-opacity duration-200
+          ${isCollapsed ? 'opacity-0 h-0 overflow-hidden' : 'opacity-100'}
+        `}>
           <Skeleton className="h-7 w-full" />
-        )}
+        </div>
       </div>
     </div>
   );
diff --git a/app/chat/layout.tsx b/app/chat/layout.tsx
index e0c5ad29..3107d3f4 100644
--- a/app/chat/layout.tsx
+++ b/app/chat/layout.tsx
@@ -1,16 +1,16 @@
- 'use client';
+'use client';
 
 import { usePathname, useRouter } from "next/navigation";
 import { Session } from "./types";
 import { sessionService } from "./services/sessionService";
 import { SessionSidebar } from "./components/SessionSidebar";
- import { SessionSidebarSkeleton } from './components/SessionSidebarSkeleton';
+import { SessionSidebarSkeleton } from './components/SessionSidebarSkeleton';
 import { SessionContext } from './SessionContext';
 import useSWRInfinite from 'swr/infinite';
 
 
 
- export default function ChatLayout({ children }: { children: React.ReactNode }) {
+export default function ChatLayout({ children }: { children: React.ReactNode }) {
     const pathname = usePathname();
     const router = useRouter();
 
@@ -23,7 +23,7 @@ import useSWRInfinite from 'swr/infinite';
     };
 
     const fetchPage = async ([, cursor]: [string, number]) => {
-        const res = await sessionService.getSessionsPage({ cursor, limit: 10 });
+        const res = await sessionService.getSessionsPage({ cursor, limit: 20 });
         if (!res.success || !res.data) throw new Error(res.error || 'Failed to fetch sessions');
         return res.data;
     };
@@ -64,6 +64,62 @@ import useSWRInfinite from 'swr/infinite';
     const handleNewSession = () => router.push('/chat');
     const loadMore = () => setSize(size + 1);
 
+    const handleDeleteSession = async (sessionIdToDelete: string) => {
+        // Optimistically remove the session from the cache
+        const updatedPages = pages.map(page => ({
+            ...page,
+            sessions: page.sessions.filter(s => s.sessionId !== sessionIdToDelete),
+            pagination: {
+                ...page.pagination,
+                total: page.pagination.total - 1
+            }
+        }));
+
+        // Update cache optimistically without revalidating
+        await swrMutate(updatedPages, { revalidate: false });
+
+        // If we're deleting the current session, navigate to /chat
+        if (sessionIdToDelete === sessionId) {
+            router.push('/chat');
+        }
+
+        // Call the API to delete the session
+        const response = await sessionService.deleteSession(sessionIdToDelete);
+        if (!response.success) {
+            // If deletion failed, revalidate to restore the correct state
+            alert(`Failed to delete session: ${response.error}`);
+            await swrMutate(undefined, { revalidate: true });
+        }
+    };
+
+    const handleEditSession = async (sessionIdToEdit: string, newTitle: string) => {
+        const sessionToEdit = sessions.find(s => s.sessionId === sessionIdToEdit);
+        if (!sessionToEdit) {
+            alert('Session not found');
+            return;
+        }
+
+        const updatedSession: Session = {
+            ...sessionToEdit,
+            title: newTitle
+        };
+
+        // Optimistically update the session in the cache
+        const updatedPages = pages.map(page => ({
+            ...page,
+            sessions: page.sessions.map(s =>
+                s.sessionId === sessionIdToEdit ? updatedSession : s
+            )
+        }));
+
+        await swrMutate(updatedPages, { revalidate: false });
+        const response = await sessionService.updateSession(updatedSession);
+        if (!response.success) {
+            alert(`Failed to update session: ${response.error}`);
+            await swrMutate(undefined, { revalidate: true });
+        }
+    };
+
     return (
         <div className="agentuity-background flex h-screen text-white overflow-hidden">
             {/* Sidebar: show skeleton while loading, real sidebar when ready */}
@@ -75,6 +131,8 @@ import useSWRInfinite from 'swr/infinite';
                     sessions={sessions}
                     onSessionSelect={handleSessionSelect}
                     onNewSession={handleNewSession}
+                    onDeleteSession={handleDeleteSession}
+                    onEditSession={handleEditSession}
                     hasMore={hasMore}
                     onLoadMore={loadMore}
                     isLoadingMore={isLoadingMore}
diff --git a/app/chat/types.ts b/app/chat/types.ts
index c8f14308..e1fc987d 100644
--- a/app/chat/types.ts
+++ b/app/chat/types.ts
@@ -63,6 +63,8 @@ export interface SessionSidebarProps {
   sessions: Session[];
   onSessionSelect: (sessionId: string) => void;
   onNewSession: () => void;
+  onDeleteSession?: (sessionId: string) => void;
+  onEditSession?: (sessionId: string, newTitle: string) => void;
   hasMore?: boolean;
   onLoadMore?: () => void;
   isLoadingMore?: boolean;
diff --git a/app/global.css b/app/global.css
index b379f21b..27efe56a 100644
--- a/app/global.css
+++ b/app/global.css
@@ -201,3 +201,36 @@ figure > div:nth-child(2) {
 article > p {
 	margin-bottom: 1rem;
 }
+
+/* Custom scrollbar styling for session sidebar - invisible until hover */
+.scrollbar-thin {
+	scrollbar-width: thin;
+	scrollbar-color: transparent transparent;
+	transition: scrollbar-color 0.2s ease;
+}
+
+.scrollbar-thin:hover {
+	scrollbar-color: rgba(255, 255, 255, 0.15) transparent;
+}
+
+.scrollbar-thin::-webkit-scrollbar {
+	width: 6px;
+}
+
+.scrollbar-thin::-webkit-scrollbar-track {
+	background: transparent;
+}
+
+.scrollbar-thin::-webkit-scrollbar-thumb {
+	background: transparent;
+	border-radius: 3px;
+	transition: background 0.2s ease;
+}
+
+.scrollbar-thin:hover::-webkit-scrollbar-thumb {
+	background: rgba(255, 255, 255, 0.15);
+}
+
+.scrollbar-thin::-webkit-scrollbar-thumb:hover {
+	background: rgba(255, 255, 255, 0.3);
+}
diff --git a/components/TutorialStep.tsx b/components/TutorialStep.tsx
index 8256028d..2dda8cd4 100644
--- a/components/TutorialStep.tsx
+++ b/components/TutorialStep.tsx
@@ -1,4 +1,7 @@
+'use client';
+
 import React from 'react';
+import Link from 'next/link';
 
 interface TutorialStepProps {
   number: number;
@@ -9,7 +12,35 @@ interface TutorialStepProps {
 
 export function TutorialStep({ number, title, estimatedTime, children }: TutorialStepProps) {
   return (
-    <div data-tutorial-step={number} data-title={title} data-estimated-time={estimatedTime}>
+    <div data-tutorial-step={number} data-title={title} data-estimated-time={estimatedTime} className="relative group">
+      <div className="flex items-start justify-end gap-4 mb-4">
+        <Link
+          href="/chat"
+          className="inline-flex items-center gap-2 px-4 py-2 text-sm font-medium text-white bg-gradient-to-r from-purple-600 to-indigo-600 rounded-lg hover:from-purple-700 hover:to-indigo-700 transition-all duration-200 shadow-sm hover:shadow-md no-underline whitespace-nowrap"
+          title="Open interactive sandbox to explore this step"
+        >
+          <svg
+            className="w-4 h-4"
+            fill="none"
+            stroke="currentColor"
+            viewBox="0 0 24 24"
+          >
+            <path
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              strokeWidth={2}
+              d="M14.752 11.168l-3.197-2.132A1 1 0 0010 9.87v4.263a1 1 0 001.555.832l3.197-2.132a1 1 0 000-1.664z"
+            />
+            <path
+              strokeLinecap="round"
+              strokeLinejoin="round"
+              strokeWidth={2}
+              d="M21 12a9 9 0 11-18 0 9 9 0 0118 0z"
+            />
+          </svg>
+          Move to Sandbox
+        </Link>
+      </div>
       {children}
     </div>
   );
diff --git a/lib/tutorial/mdx-to-markdown.ts b/lib/tutorial/mdx-to-markdown.ts
new file mode 100644
index 00000000..f6fad9dc
--- /dev/null
+++ b/lib/tutorial/mdx-to-markdown.ts
@@ -0,0 +1,67 @@
+/**
+ * Converts MDX content with JSX components to plain markdown
+ * that can be rendered by ReactMarkdown in the chat interface
+ */
+
+/**
+ * Strips MDX-specific JSX components and converts them to plain markdown
+ */
+export function convertMdxToMarkdown(mdxContent: string): string {
+  let result = mdxContent;
+
+  // Remove <TutorialStep> wrapper tags - keep the content inside
+  result = result.replace(/<TutorialStep[^>]*>/g, '');
+  result = result.replace(/<\/TutorialStep>/g, '');
+
+  // Convert <Callout> to blockquote with emoji prefix
+  result = result.replace(
+    /<Callout\s+type="info"[^>]*>([\s\S]*?)<\/Callout>/g,
+    (_, content) => `\n> ℹ️ **Info**\n${content.split('\n').map((line: string) => `> ${line}`).join('\n')}\n`
+  );
+  result = result.replace(
+    /<Callout\s+type="warning"[^>]*>([\s\S]*?)<\/Callout>/g,
+    (_, content) => `\n> ⚠️ **Warning**\n${content.split('\n').map((line: string) => `> ${line}`).join('\n')}\n`
+  );
+  result = result.replace(
+    /<Callout\s+type="tip"[^>]*>([\s\S]*?)<\/Callout>/g,
+    (_, content) => `\n> 💡 **Tip**\n${content.split('\n').map((line: string) => `> ${line}`).join('\n')}\n`
+  );
+  result = result.replace(
+    /<Callout[^>]*>([\s\S]*?)<\/Callout>/g,
+    (_, content) => `\n> ${content.split('\n').map((line: string) => `> ${line}`).join('\n')}\n`
+  );
+
+  // Handle <CodeExample> - extract just one language version (prefer JS)
+  // This regex matches CodeExample tags with backtick-delimited code spanning multiple lines
+  // We match from <CodeExample to /> accounting for nested content including > characters
+  result = result.replace(
+    /<CodeExample\s+[\s\S]*?\/>/g,
+    (full) => {
+      // Try to extract js code first, fallback to py
+      // Match js={`...`} where content can span multiple lines and contain any characters
+      const jsMatch = full.match(/js=\{`([\s\S]*?)`\s*\}/);
+      const pyMatch = full.match(/py=\{`([\s\S]*?)`\s*\}/);
+
+      if (jsMatch) {
+        const code = jsMatch[1].trim();
+        return `\n\`\`\`javascript\n${code}\n\`\`\`\n`;
+      } else if (pyMatch) {
+        const code = pyMatch[1].trim();
+        return `\n\`\`\`python\n${code}\n\`\`\`\n`;
+      }
+      return '';
+    }
+  );
+
+  // Remove any other HTML-like tags that aren't standard markdown
+  // but preserve links and basic formatting
+  result = result.replace(/<div[^>]*>/g, '\n');
+  result = result.replace(/<\/div>/g, '\n');
+  result = result.replace(/<a\s+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/g, '[$2]($1)');
+
+  // Clean up excessive newlines
+  result = result.replace(/\n{3,}/g, '\n\n');
+
+  return result.trim();
+}
+

From 733fbcc6682fdec9e28abf305f5e4e4ccd06dabd Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Mon, 27 Oct 2025 13:37:04 -0700
Subject: [PATCH 11/13] Update example snippets, MDX content

---
 .../developers/01-introduction-to-agents.mdx  |  65 +++++----
 .../developers/02-anatomy-of-an-agent.mdx     | 138 ++++++++++--------
 .../Training/developers/03-agent-memory.mdx   |  66 +++------
 .../05-observability-guardrails-evals.mdx     |  66 ++++++---
 .../training/01-intro/step1-basic-agent.py    |  31 +++-
 .../training/01-intro/step1-basic-agent.ts    |  32 +++-
 .../training/01-intro/step2-with-logging.py   |  35 ++++-
 .../training/01-intro/step2-with-logging.ts   |  36 ++++-
 .../training/01-intro/step3-with-state.py     |  48 +++---
 .../training/01-intro/step3-with-state.ts     |  49 ++++---
 .../training/01-intro/step4-with-errors.py    |  72 +++++----
 .../training/01-intro/step4-with-errors.ts    |  67 +++++----
 .../step1-understanding-triggers.py           |  10 ++
 .../step1-understanding-triggers.ts           |  15 +-
 .../training/02-anatomy/step2-request-data.py |  55 ++++---
 .../training/02-anatomy/step2-request-data.ts |  52 +++----
 .../02-anatomy/step3-response-formats.py      |  68 +++++++++
 .../02-anatomy/step3-response-formats.ts      |  64 ++++++++
 .../02-anatomy/step3-structured-logging.py    |  50 -------
 .../02-anatomy/step3-structured-logging.ts    |  60 --------
 .../02-anatomy/step4-context-agent-info.py    |  57 ++++++++
 .../02-anatomy/step4-context-agent-info.ts    |  64 ++++++++
 .../training/02-anatomy/step4-kv-caching.py   |  47 ------
 .../training/02-anatomy/step4-kv-caching.ts   |  55 -------
 .../02-anatomy/step5-context-logging.py       |  47 ++++++
 .../02-anatomy/step5-context-logging.ts       |  58 ++++++++
 .../02-anatomy/step5-response-formats.py      |  43 ------
 .../02-anatomy/step5-response-formats.ts      |  48 ------
 .../02-anatomy/step6-context-storage.py       |  54 +++++++
 .../02-anatomy/step6-context-storage.ts       |  58 ++++++++
 .../03-memory/step1-session-memory.py         |  83 ++++++-----
 .../03-memory/step1-session-memory.ts         |  81 +++++-----
 .../03-memory/step2-persistent-preferences.py |  56 -------
 .../03-memory/step2-persistent-preferences.ts |  63 --------
 .../training/03-memory/step2-vector-basics.py |  83 +++++++++++
 .../training/03-memory/step2-vector-basics.ts |  87 +++++++++++
 .../training/03-memory/step3-vector-basics.py |  80 ----------
 .../training/03-memory/step3-vector-basics.ts |  85 -----------
 .../03-memory/step3-vector-filtering.py       |  92 ++++++++++++
 .../03-memory/step3-vector-filtering.ts       |  94 ++++++++++++
 ...ect-storage.py => step4-object-storage.py} |   9 ++
 ...ect-storage.ts => step4-object-storage.ts} |   8 +
 .../03-memory/step4-vector-filtering.py       |  88 -----------
 .../03-memory/step4-vector-filtering.ts       |  92 ------------
 .../step1-basic-handoff.py                    |  10 ++
 .../step1-basic-handoff.ts                    |   8 +
 .../step2-data-formats.py                     |  10 ++
 .../step2-data-formats.ts                     |   8 +
 .../step3-run-and-wait.py                     |  10 ++
 .../step3-run-and-wait.ts                     |   8 +
 .../step4-parallel-execution.py               |  10 ++
 .../step4-parallel-execution.ts               |   8 +
 .../step5-structured-responses.py             |  10 ++
 .../step5-structured-responses.ts             |   9 ++
 .../step1-child-loggers.py                    |   4 +-
 .../step1-child-loggers.ts                    |   4 +-
 .../step2-input-validation.py                 |  16 +-
 .../step2-input-validation.ts                 |  11 +-
 .../step3-ai-output-validation.py             |  17 ++-
 .../step3-ai-output-validation.ts             |   7 +-
 60 files changed, 1566 insertions(+), 1195 deletions(-)
 create mode 100644 examples/training/02-anatomy/step3-response-formats.py
 create mode 100644 examples/training/02-anatomy/step3-response-formats.ts
 delete mode 100644 examples/training/02-anatomy/step3-structured-logging.py
 delete mode 100644 examples/training/02-anatomy/step3-structured-logging.ts
 create mode 100644 examples/training/02-anatomy/step4-context-agent-info.py
 create mode 100644 examples/training/02-anatomy/step4-context-agent-info.ts
 delete mode 100644 examples/training/02-anatomy/step4-kv-caching.py
 delete mode 100644 examples/training/02-anatomy/step4-kv-caching.ts
 create mode 100644 examples/training/02-anatomy/step5-context-logging.py
 create mode 100644 examples/training/02-anatomy/step5-context-logging.ts
 delete mode 100644 examples/training/02-anatomy/step5-response-formats.py
 delete mode 100644 examples/training/02-anatomy/step5-response-formats.ts
 create mode 100644 examples/training/02-anatomy/step6-context-storage.py
 create mode 100644 examples/training/02-anatomy/step6-context-storage.ts
 delete mode 100644 examples/training/03-memory/step2-persistent-preferences.py
 delete mode 100644 examples/training/03-memory/step2-persistent-preferences.ts
 create mode 100644 examples/training/03-memory/step2-vector-basics.py
 create mode 100644 examples/training/03-memory/step2-vector-basics.ts
 delete mode 100644 examples/training/03-memory/step3-vector-basics.py
 delete mode 100644 examples/training/03-memory/step3-vector-basics.ts
 create mode 100644 examples/training/03-memory/step3-vector-filtering.py
 create mode 100644 examples/training/03-memory/step3-vector-filtering.ts
 rename examples/training/03-memory/{step5-object-storage.py => step4-object-storage.py} (84%)
 rename examples/training/03-memory/{step5-object-storage.ts => step4-object-storage.ts} (85%)
 delete mode 100644 examples/training/03-memory/step4-vector-filtering.py
 delete mode 100644 examples/training/03-memory/step4-vector-filtering.ts

diff --git a/content/Training/developers/01-introduction-to-agents.mdx b/content/Training/developers/01-introduction-to-agents.mdx
index 4d41f20e..249a20fb 100644
--- a/content/Training/developers/01-introduction-to-agents.mdx
+++ b/content/Training/developers/01-introduction-to-agents.mdx
@@ -224,7 +224,7 @@ agentuity dev
 
 You'll use DevMode throughout the tutorial below to test each step as you build your agent.
 
-### Build Your First Agent Step-by-Step
+## Build Your First Agent Step-by-Step
 
 Work through these steps to build your first agent. Each step adds new capabilities - follow along by creating a project (`agentuity create`), or read through to understand the patterns.
 
@@ -232,7 +232,7 @@ Work through these steps to build your first agent. Each step adds new capabilit
 
 <TutorialStep number={1} title="Create a Basic Agent" estimatedTime="3 minutes">
 
-Let's start with the simplest possible agent - it accepts a name and returns a greeting:
+Let's start with a simple agent that echoes back any data you send it. Notice how it checks `contentType` first to determine the correct parsing method:
 
 <CodeFromFiles snippets={[
   { path: "/examples/training/01-intro/step1-basic-agent.ts", lang: "ts", title: "TypeScript" },
@@ -241,10 +241,13 @@ Let's start with the simplest possible agent - it accepts a name and returns a g
 
 **What this demonstrates:**
 - Basic request/response pattern
-- JSON input handling
-- Simple response generation
+- ContentType-first parsing (check type before parsing)
+- Handling multiple data formats (JSON and text)
+- Structured response with timestamp
 - Core agent structure (AgentRequest, AgentResponse, AgentContext)
 
+**Key insight:** Real-world agents handle multiple input formats gracefully. Check `contentType` to determine the correct parsing method and handle different data formats.
+
 **Try it yourself:** Create a new project with `agentuity create`, replace the default agent code with the code above, and run `agentuity dev` to test it.
 
 </TutorialStep>
@@ -275,7 +278,7 @@ Now let's add logging so we can see what's happening inside our agent:
 
 <TutorialStep number={3} title="Add State Management" estimatedTime="5 minutes">
 
-Let's make the agent remember how many times it has greeted people using Agentuity's built-in key-value storage:
+Let's make the agent track total requests using Agentuity's built-in key-value storage:
 
 <CodeFromFiles snippets={[
   { path: "/examples/training/01-intro/step3-with-state.ts", lang: "ts", title: "TypeScript" },
@@ -283,18 +286,19 @@ Let's make the agent remember how many times it has greeted people using Agentui
 ]} />
 
 **What changed:**
-- Uses `context.kv.get()` to read state
-- Uses `context.kv.set()` to update state
+- Tracks total requests globally
+- Uses simple KV key (`total-requests`)
+- Uses `context.kv.get()` to read state and `context.kv.set()` to update
 - Checks `result.exists` to handle first-time execution
-- State persists across invocations
+- Returns request count in response statistics
 
-**Key insight:** Agents need memory to be truly useful. Agentuity provides built-in key-value storage so you don't need external databases for simple state.
+**Key insight:** Agents need memory to be truly useful. Agentuity provides built-in key-value storage so you don't need external databases for simple state. State management is a common pattern you'll see throughout the platform.
 
 <Callout type="info">
 We cover all storage APIs later in [Module 3: Agent Memory](/Training/developers/03-agent-memory). You can also read more by checking out our guide on [Key-Value Storage](/Guides/key-value).
 </Callout>
 
-**Try it:** Call this agent multiple times. Watch the counter increment and persist across calls.
+**Try it:** Call this agent multiple times with any data. Watch the global request counter increment with each call.
 
 </TutorialStep>
 
@@ -302,7 +306,7 @@ We cover all storage APIs later in [Module 3: Agent Memory](/Training/developers
 
 <TutorialStep number={4} title="Add Error Handling" estimatedTime="5 minutes">
 
-Agents need defensive error handling to gracefully handle invalid inputs:
+Agents need defensive error handling with proper status codes to gracefully handle invalid inputs and system failures:
 
 <CodeFromFiles snippets={[
   { path: "/examples/training/01-intro/step4-with-errors.ts", lang: "ts", title: "TypeScript" },
@@ -310,17 +314,17 @@ Agents need defensive error handling to gracefully handle invalid inputs:
 ]} />
 
 **What changed:**
-- Try/catch blocks around JSON parsing
-- Input validation (checks for valid name)
-- Graceful error responses
-- Defensive storage handling (continues even if storage fails)
+- Try/catch blocks around data parsing
+- Proper HTTP status codes (400 for bad requests)
+- Graceful error responses with clear messages
+- Defensive storage handling with graceful degradation (continues even if storage fails)
+- Clear error logging for debugging
 
-**Key insight:** Agents interact with unpredictable inputs and external systems. Error handling ensures they fail gracefully and provide useful feedback.
+**Key insight:** Agents interact with unpredictable inputs and external systems. Error handling with proper status codes ensures they fail gracefully and provide useful feedback to users.
 
-**Try it:** Send invalid JSON or missing data to see how the agent handles errors.
+**Try it:** Test with malformed data to see error handling. Notice how storage failures don't crash the agent - it continues with default values.
 
 </TutorialStep>
-
 ### Deploy Your Tutorial Agent
 
 Now that you've built and tested your agent locally, deploy it to Agentuity's agent-native infrastructure:
@@ -353,10 +357,9 @@ Ready to see everything in action? Clone a complete example that combines all th
 </div>
 
 This lab project includes:
-- Error handling and input validation
+- Error handling with graceful degradation
 - Multiple input types (JSON and text)
-- Personal statistics tracking per user
-- Memory management with TTL-based expiration
+- Global request tracking with KV storage
 - DevMode test scenarios via `welcome()` function
 - Complete `agentuity.yaml` configuration
 
@@ -364,9 +367,9 @@ After cloning the lab, try the following:
 1. Run `agentuity dev` to start DevMode
 2. Use the clickable prompts from the `welcome()` function
 3. Test with both JSON and text inputs
-4. Call the agent multiple times with the same name to see statistics
+4. Call the agent multiple times to see the global request counter increment
 5. Monitor the logs to see detailed operation tracking
-6. Check the key-value storage to see the personal greeting counts
+6. Check the key-value storage to see the total request count
 7. Check the Sessions tab for performance metrics
 
 <Callout type="info">
@@ -380,16 +383,16 @@ This complete implementation shows patterns you'll use throughout the training m
 agentuity dev
 ```
 
-2. **Test with the clickable prompts** from the `welcome()` function in the lab examples
+2. **Test with the clickable prompts** from the `welcome()` function in the examples
 3. **Try different inputs:**
-   - Valid JSON: `{"name": "Alice"}`
-   - Plain text: `"Bob"`
+   - Valid JSON: `{"user": "Alice", "action": "login"}`
+   - Plain text: `"Hello, world!"`
    - Invalid data to test error handling
-4. **Call multiple times** with the same name to see the greeting counter increment
+4. **Call multiple times** to see the global request counter increment
 5. **Monitor observability:**
    - Check the Logs tab to see structured logging
    - View the Sessions tab for performance metrics
-   - Inspect key-value storage to see persisted counts
+   - Inspect key-value storage to see the total request count
 
 ## Key Takeaways
 
@@ -404,10 +407,10 @@ agentuity dev
 You've just built and deployed your first agent on infrastructure designed specifically for agents. In the next module, we'll dive deeper into the anatomy of an agent - understanding planning, reasoning loops, tool invocation, and how agents really work under the hood.
 
 But first, take a moment to experiment with your agent. Try:
-- Calling it with different names and at different times
+- Sending different JSON objects and text data
 - Checking the logs in the DevMode interface
-- Calling it multiple times to see the counter increment
-- Testing error cases like missing names
+- Calling it multiple times to see the request counter increment
+- Testing error cases with malformed data
 - Monitoring the key-value storage in the dashboard
 
 Remember: you're not just learning a new framework, you're learning a fundamentally new way to build software. Welcome to the age of agents!
diff --git a/content/Training/developers/02-anatomy-of-an-agent.mdx b/content/Training/developers/02-anatomy-of-an-agent.mdx
index 0f7fa1a5..0f0b8f89 100644
--- a/content/Training/developers/02-anatomy-of-an-agent.mdx
+++ b/content/Training/developers/02-anatomy-of-an-agent.mdx
@@ -180,9 +180,9 @@ Every agent needs to know *how* it was triggered. The same agent code can behave
 
 ### Step 2: Working with Request Data
 
-<TutorialStep number={2} title="Working with Request Data" estimatedTime="4 min">
+<TutorialStep number={2} title="Working with Request Data" estimatedTime="3 min">
 
-Agents receive data in various formats—JSON, text, binary. The SDK provides methods to handle each format and access metadata about the request.
+Agents receive data in various formats and need to parse it correctly. This step shows you how to handle different content types and access request properties.
 
 <CodeFromFiles snippets={[
   { path: "/examples/training/02-anatomy/step2-request-data.ts", lang: "ts", title: "TypeScript" },
@@ -190,103 +190,121 @@ Agents receive data in various formats—JSON, text, binary. The SDK provides me
 ]} />
 
 **What this demonstrates:**
-- Content type detection via `request.data.contentType` (TypeScript) or `request.data.content_type` (Python)
-- Parsing different data formats (JSON, text, binary)
-- Accessing metadata using multiple approaches:
-  - `request.get(key, default)` - SDK convenience method (recommended)
-  - `request.metadata` property - Returns the full metadata dict/object
-  - Direct property/dict access for specific use cases
+- **Content type detection**: Check `request.data.contentType` (TypeScript) or `request.data.content_type` (Python)
+- **Parsing different formats**: Use `json()`, `text()`, or `binary()` based on content type
+- **Request properties**: Access `request.trigger` and `request.metadata`
 
 **Try it:**
-1. Send JSON data: `{"name": "Alice", "action": "greet"}`
-2. Send plain text: `"Hello, agent!"`
-3. Check the logs to see how content type detection works
-4. Notice the commented examples showing different ways to access metadata
+1. Send JSON: `{"message": "Hello", "count": 42}` - see JSON parsing
+2. Send plain text: `"Plain text message"` - see text parsing
+3. Check the logs to see content type detection in action
 
 </TutorialStep>
 
-### Step 3: Structured Logging
+### Step 3: Response Formats
 
-<TutorialStep number={3} title="Structured Logging" estimatedTime="4 min">
+<TutorialStep number={3} title="Response Formats" estimatedTime="3 min">
 
-Effective logging is crucial for debugging and monitoring. Use appropriate log levels and structured data to make your logs searchable and actionable.
+Agents can return responses in various formats depending on your use case - including text for simple integrations, markdown for formatted content, and streaming for progressive responses. JSON (which you've seen in previous steps) is most common for APIs, while `response.empty()` is useful for webhooks that don't need data back.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/02-anatomy/step3-structured-logging.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/02-anatomy/step3-structured-logging.py", lang: "python", title: "Python" }
+  { path: "/examples/training/02-anatomy/step3-response-formats.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step3-response-formats.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
-- Using different log levels (`info`, `warn`, `error`, `debug`)
-- Including structured context in logs
-- Conditional logging based on task type
+- Returning plain text with `response.text()`
+- Returning formatted markdown with `response.markdown()`
+- Streaming progressive responses with `response.stream()`
+- Using the Vercel AI SDK (for TypeScript) or OpenAI Chat Completions (for Python) for streaming
 
 **Try it:**
-1. Send `{"task": "normal"}` - see INFO logs
-2. Send `{"task": "risky"}` - see WARN logs
-3. Send `{"task": "error"}` - see ERROR logs
-4. Check the Console Logs tab to see structured data
-
-**Best Practice:** Include context in every log (agent ID, session ID, request details) to help with debugging later.
+1. Click `"Show text response"` - see simple plain text
+2. Click `"Show markdown response"` - see rich formatted content with headings, lists, and code blocks
+3. Click `"Show streaming response"` - watch content appear progressively as it's generated
 
 </TutorialStep>
 
-### Step 4: Introduction to KV Storage
+### Step 4: Exploring Agent Context
 
-<TutorialStep number={4} title="Introduction to KV Storage" estimatedTime="5 min">
+<TutorialStep number={4} title="Exploring Agent Context" estimatedTime="3 min">
 
-Key-value storage lets agents cache data, manage state, and avoid redundant work. This is a simple caching pattern—check cache first, compute if needed, then store with TTL.
+The `context` object gives your agent access to platform services and runtime information. Let's explore what's available.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/02-anatomy/step4-kv-caching.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/02-anatomy/step4-kv-caching.py", lang: "python", title: "Python" }
+  { path: "/examples/training/02-anatomy/step4-context-agent-info.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step4-context-agent-info.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
-- Checking cache with `context.kv.get()`
-- Cache hit vs. cache miss handling
-- Storing data with TTL using `context.kv.set()`
+- **Agent information**: Access `context.agent.id`, `context.agent.name`, and description
+- **Runtime details**: Check SDK version, DevMode status, project/deployment IDs
+- **Platform services**: Preview available services (storage, logging, communication)
 
 **Try it:**
-1. Send `{"query": "hello"}` - first request computes and caches
-2. Send `{"query": "hello"}` again - returns from cache
-3. Send `{"query": "world"}` - different key, fresh computation
-4. Wait 5 minutes and retry - cache expired, recomputes
+1. Send `"Agent Info"` - see current agent details
+2. Send `"Runtime Info"` - see SDK version, DevMode status, and IDs
+3. Send `"Platform Services"` - see available context services
+4. Note these services (like `context.kv`) that you'll use in later steps
 
-**Key Concepts:**
-- **Bucket**: First parameter (`'demo-cache'`) - organizes related keys
-- **Key**: Second parameter (unique identifier for the data)
-- **TTL**: Time-to-live in seconds (data expires automatically)
-- **No TTL**: Omit TTL for permanent storage
+</TutorialStep>
 
-<Callout type="info">
-We'll explore advanced memory patterns (session, persistent, vector) in [**Module 3: Agent Memory**](/Training/developers/03-agent-memory).
-</Callout>
+### Step 5: Structured Logging
+
+<TutorialStep number={5} title="Structured Logging" estimatedTime="3 min">
+
+Effective logging is crucial for debugging and monitoring. Use appropriate log levels and structured data to make your logs searchable and actionable.
+
+<CodeFromFiles snippets={[
+  { path: "/examples/training/02-anatomy/step5-context-logging.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step5-context-logging.py", lang: "python", title: "Python" }
+]} />
+
+**What this demonstrates:**
+- Using different log levels: `info`, `debug`, `warn`, `error`
+- Including structured context in logs (objects in TypeScript, key=value in Python)
+- Logging throughout the request lifecycle
+
+**Try it:**
+1. Send plain text: `"Testing structured logging"` - see logs at all levels
+2. Send JSON: `{"user": "testuser", "action": "checkout"}` - see logged data
+3. Check the Logs tab to see all log levels with structured metadata
+
+**Best Practice:** Include context in every log (agent ID, trigger, timestamps) to make debugging easier.
 
 </TutorialStep>
 
-### Step 5: Response Formats
+### Step 6: Introduction to KV Storage
 
-<TutorialStep number={5} title="Response Formats" estimatedTime="3 min">
+<TutorialStep number={6} title="Introduction to KV Storage" estimatedTime="4 min">
 
-Agents can return responses in various formats depending on who's calling them—JSON for APIs, HTML for browsers, text for simple integrations, or empty for webhooks.
+Key-value storage lets agents store and retrieve data quickly. This step demonstrates the fundamental pattern: check if data exists, retrieve it if found, or generate and store it if not.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/02-anatomy/step5-response-formats.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/02-anatomy/step5-response-formats.py", lang: "python", title: "Python" }
+  { path: "/examples/training/02-anatomy/step6-context-storage.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/02-anatomy/step6-context-storage.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
-- Returning JSON with `response.json()`
-- Returning text with `response.text()`
-- Returning HTML with `response.html()`
-- Returning empty response with `response.empty()`
+- Retrieving data with `context.kv.get()`
+- Checking if data exists with `.exists` property
+- Storing data with `context.kv.set()` and optional TTL
 
 **Try it:**
-1. Send `{"format": "json"}` - structured data response
-2. Send `{"format": "text"}` - plain text response
-3. Send `{"format": "html"}` - view in browser
-4. Send `{"format": "empty"}` - no response body (useful for webhooks or to handle cases where no "actual" response is needed)
+1. Send `"hello"` - generates a unique result code and stores it
+2. Send `"hello"` again - retrieves the same result code from storage
+3. Send `"world"` - different storage key, generates new result
+4. Wait 5 minutes and retry `"hello"` - TTL expired, generates new result
+
+**Key Concepts:**
+- **Bucket**: First parameter (`'demo-storage'`) - organizes related data
+- **Key**: Second parameter (unique identifier for the stored data)
+- **TTL**: Time-to-live in seconds (data expires automatically)
+- **Use Cases**: Session state, caching API responses, temporary configuration
+
+<Callout type="info">
+This storage pattern powers many use cases: caching (like the Weather Agent lab you'll build at the end of this module), session management, and more. We'll explore advanced memory patterns in [**Module 3: Agent Memory**](/Training/developers/03-agent-memory).
+</Callout>
 
 </TutorialStep>
 
@@ -527,7 +545,7 @@ Learn more about configuring triggers in the [Agent Configuration Guide](/Cloud/
 You now understand agent anatomy—the building blocks every agent shares. In **Module 3: Agent Memory**, we'll dive deep into how agents remember, learn, and maintain state across interactions.
 
 **Before moving on:**
-1. Complete all 5 tutorial steps
+1. Complete all 6 tutorial steps
 2. Build and test the weather agent
 3. Experiment with different triggers and cache TTLs
 4. Review the logs to see patterns emerge
diff --git a/content/Training/developers/03-agent-memory.mdx b/content/Training/developers/03-agent-memory.mdx
index 19889f2a..9323d9f3 100644
--- a/content/Training/developers/03-agent-memory.mdx
+++ b/content/Training/developers/03-agent-memory.mdx
@@ -89,57 +89,35 @@ Short-term conversation context needs automatic cleanup. Key-value storage with
 ]} />
 
 **What this demonstrates:**
-- Using `context.sessionId` for consistent session tracking
+- Storing an array of messages in KV storage with a simple key
 - Checking `result.exists` to handle new vs returning sessions
 - Setting TTL (3600 seconds = 1 hour) for automatic expiration
-- Building conversation history by appending messages
+- Building conversation history by appending messages to an array
 
 **Try it:**
-1. Send a message - creates a new session
-2. Send another message - retrieves and appends to history
-3. Check back later - session data expires automatically (after 1 hour in this example; adjust as needed)
-4. Check DevMode logs to see session operations
+1. Send "Hello, this is my first message" - creates new chat history
+2. Send "Here is my second message" - retrieves and appends to history
+3. Send "And a third message" - see all 3 messages stored
+4. Wait 1 hour (or check back later) - session data expires automatically
+5. Check DevMode KV viewer to see the `chat-history` key and stored messages
 
 **Key insight:** TTL-based memory is perfect for temporary data like chat sessions, preventing manual cleanup and storage costs.
 
-</TutorialStep>
-
-### Step 2: Persistent Preferences
-
-<TutorialStep number={2} title="Persistent Preferences with KV" estimatedTime="4 min">
-
-User profiles and preferences should survive restarts. Omitting the TTL parameter makes data permanent until explicitly deleted.
-
-<CodeFromFiles snippets={[
-  { path: "/examples/training/03-memory/step2-persistent-preferences.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/03-memory/step2-persistent-preferences.py", lang: "python", title: "Python" }
-]} />
-
-**What this demonstrates:**
-- Permanent storage by omitting TTL parameter
-- Handling first-time users (create profile) vs returning users (update profile)
-- Tracking interaction counts and timestamps
-- Updating nested preference objects
-
-**Try it:**
-1. Send `{"theme": "dark", "language": "en"}` - creates profile
-2. Send `{"theme": "light"}` - updates theme, keeps language
-3. Restart DevMode - profile persists
-4. Check interaction count incrementing
-
-**Key insight:** No TTL means data persists forever, perfect for user profiles, settings, and application state.
+<Callout type="info">
+**TTL vs Permanent Storage**: Include a `ttl` parameter (in seconds) for automatic expiration (e.g., `3600` = 1 hour), or omit it for permanent storage.
+</Callout>
 
 </TutorialStep>
 
-### Step 3: Basic Search
+### Step 2: Vector Storage Basics
 
-<TutorialStep number={3} title="Vector Upsert & Basic Search" estimatedTime="6 min">
+<TutorialStep number={2} title="Vector Upsert & Basic Search" estimatedTime="6 min">
 
 Vector storage enables semantic search—finding information by meaning rather than keywords. Documents are converted to embeddings automatically.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/03-memory/step3-vector-basics.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/03-memory/step3-vector-basics.py", lang: "python", title: "Python" }
+  { path: "/examples/training/03-memory/step2-vector-basics.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step2-vector-basics.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
@@ -160,15 +138,15 @@ Vector storage enables semantic search—finding information by meaning rather t
 
 </TutorialStep>
 
-### Step 4: Metadata Filtering
+### Step 3: Vector Metadata Filtering
 
-<TutorialStep number={4} title="Vector Metadata Filtering" estimatedTime="5 min">
+<TutorialStep number={3} title="Vector Metadata Filtering" estimatedTime="5 min">
 
 Combine semantic similarity with structured filters to narrow results by category, user, status, or any metadata field.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/03-memory/step4-vector-filtering.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/03-memory/step4-vector-filtering.py", lang: "python", title: "Python" }
+  { path: "/examples/training/03-memory/step3-vector-filtering.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step3-vector-filtering.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
@@ -192,15 +170,15 @@ Combine semantic similarity with structured filters to narrow results by categor
 
 </TutorialStep>
 
-### Step 5: Object Storage Basics
+### Step 4: Object Storage Basics
 
-<TutorialStep number={5} title="Object Storage Basics" estimatedTime="5 min">
+<TutorialStep number={4} title="Object Storage Basics" estimatedTime="5 min">
 
 Files and media need different storage than structured data. Object storage handles binary content and provides shareable public URLs.
 
 <CodeFromFiles snippets={[
-  { path: "/examples/training/03-memory/step5-object-storage.ts", lang: "ts", title: "TypeScript" },
-  { path: "/examples/training/03-memory/step5-object-storage.py", lang: "python", title: "Python" }
+  { path: "/examples/training/03-memory/step4-object-storage.ts", lang: "ts", title: "TypeScript" },
+  { path: "/examples/training/03-memory/step4-object-storage.py", lang: "python", title: "Python" }
 ]} />
 
 **What this demonstrates:**
diff --git a/content/Training/developers/05-observability-guardrails-evals.mdx b/content/Training/developers/05-observability-guardrails-evals.mdx
index 68257e70..afa79abe 100644
--- a/content/Training/developers/05-observability-guardrails-evals.mdx
+++ b/content/Training/developers/05-observability-guardrails-evals.mdx
@@ -169,6 +169,8 @@ The key idea: validate structure first, then use an LLM to evaluate content appr
 <CodeExample py={`from datetime import datetime
 from pydantic import BaseModel, Field, ValidationError
 from typing import Optional, Literal
+from aiohttp.web import Response
+import json
 
 class UserQuery(BaseModel):
     query: str = Field(min_length=1, max_length=1000)
@@ -187,18 +189,27 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
         raw_data = await request.data.json()
         validated = UserQuery(**raw_data)
     except ValidationError as e:
-        return response.json({
-            'error': 'Invalid request',
-            'details': e.errors()
-        })
-    
+        return Response(
+            text=json.dumps({
+                'error': 'Invalid request',
+                'details': [{'field': err['loc'][-1], 'message': err['msg']}
+                            for err in e.errors()]
+            }),
+            status=400,
+            content_type='application/json'
+        )
+
     # 2. Use LLM jury for content evaluation
     evaluation = await evaluate_with_jury(validated.query, context)
     if not evaluation.approved:
-        return response.json({
-            'error': 'Content policy violation',
-            'reason': evaluation.reason
-        })
+        return Response(
+            text=json.dumps({
+                'error': 'Content policy violation',
+                'reason': evaluation.reason
+            }),
+            status=403,
+            content_type='application/json'
+        )
 
     # 3. Process validated and approved data
     return await process_query(validated.query, validated.user_id)
@@ -275,19 +286,25 @@ const handler = async (request, response, context) => {
   const result = UserQuerySchema.safeParse(await request.data.json());
 
   if (!result.success) {
-    return response.json({
-      error: 'Invalid request',
-      details: result.error.issues
-    });
+    return new Response(
+      JSON.stringify({
+        error: 'Invalid request',
+        details: result.error.issues
+      }),
+      { status: 400, headers: { 'Content-Type': 'application/json' } }
+    );
   }
 
   // 2. Use LLM jury for content evaluation
   const evaluation = await evaluateWithJury(result.data.query, context);
   if (!evaluation.approved) {
-    return response.json({
-      error: 'Content policy violation',
-      reason: evaluation.reason
-    });
+    return new Response(
+      JSON.stringify({
+        error: 'Content policy violation',
+        reason: evaluation.reason
+      }),
+      { status: 403, headers: { 'Content-Type': 'application/json' } }
+    );
   }
 
   // 3. Process validated and approved data
@@ -332,6 +349,8 @@ Here's how it validates Hacker News API responses before processing:
 <CodeExample py={`from datetime import datetime
 from pydantic import BaseModel, ValidationError
 from typing import Optional, List
+from aiohttp.web import Response
+import json
 
 # Schema for Hacker News story
 class HNStory(BaseModel):
@@ -382,7 +401,11 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
         )
     except ValidationError as e:
         context.logger.error(f"Digest validation failed: {e}")
-        return response.json({"error": "Failed to create digest"})
+        return Response(
+            text=json.dumps({"error": "Failed to create digest"}),
+            status=500,
+            content_type='application/json'
+        )
     
     # Store validated digest
     await context.kv.set("digest", "latest", digest.model_dump())
@@ -439,10 +462,13 @@ const handler = async (request, response, context) => {
     timestamp: new Date().toISOString(),
     source: 'Hacker News API'
   });
-  
+
   if (!digestResult.success) {
     context.logger.error('Digest validation failed', digestResult.error);
-    return response.json({ error: 'Failed to create digest' });
+    return new Response(
+      JSON.stringify({ error: 'Failed to create digest' }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
   }
   
   // Store validated digest
diff --git a/examples/training/01-intro/step1-basic-agent.py b/examples/training/01-intro/step1-basic-agent.py
index 27849764..90415c73 100644
--- a/examples/training/01-intro/step1-basic-agent.py
+++ b/examples/training/01-intro/step1-basic-agent.py
@@ -1,9 +1,30 @@
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+from datetime import datetime
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Get the name from request data
-    data = await request.data.json()
-    name = data.get("name", "World")
+    received_data = None
 
-    # Return a simple greeting
-    return response.json({"message": f"Hello, {name}!"})
+    # Check content type first, then parse accordingly
+    if request.data.content_type == 'application/json':
+        received_data = await request.data.json()
+    elif request.data.content_type == 'text/plain':
+        received_data = await request.data.text()
+    else:
+        received_data = await request.data.text()
+
+    return response.json({
+        'message': 'Request received',
+        'contentType': request.data.content_type,
+        'received': received_data,
+        'timestamp': datetime.utcnow().isoformat() + 'Z'
+    })
+
+def welcome():
+    return {
+        'welcome': 'Welcome to your first agent! Send JSON or text data and see it echoed back.',
+        'prompts': [
+            {'data': json.dumps({'hello': 'world'}), 'contentType': 'application/json'},
+            {'data': 'Hello, world!', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/01-intro/step1-basic-agent.ts b/examples/training/01-intro/step1-basic-agent.ts
index 28d9b4c2..66936ffc 100644
--- a/examples/training/01-intro/step1-basic-agent.ts
+++ b/examples/training/01-intro/step1-basic-agent.ts
@@ -5,10 +5,32 @@ export default async function Agent(
   response: AgentResponse,
   context: AgentContext
 ) {
-  // Get the name from request data
-  const data = await request.data.json();
-  const name = data.name || 'World';
+  let receivedData: unknown = null;
 
-  // Return a simple greeting
-  return response.json({ message: `Hello, ${name}!` });
+  // Check content type first, then parse accordingly
+  switch (request.data.contentType) {
+    case 'application/json':
+      receivedData = await request.data.json();
+      break;
+    case 'text/plain':
+      receivedData = await request.data.text();
+      break;
+    default:
+      receivedData = await request.data.text();
+  }
+
+  return response.json({
+    message: 'Request received',
+    contentType: request.data.contentType,
+    received: receivedData,
+    timestamp: new Date().toISOString()
+  });
 }
+
+export const welcome = () => ({
+  welcome: 'Welcome to your first agent! Send JSON or text data and see it echoed back.',
+  prompts: [
+    { data: JSON.stringify({ hello: 'world' }), contentType: 'application/json' },
+    { data: 'Hello, world!', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/01-intro/step2-with-logging.py b/examples/training/01-intro/step2-with-logging.py
index 9ce215c4..93023792 100644
--- a/examples/training/01-intro/step2-with-logging.py
+++ b/examples/training/01-intro/step2-with-logging.py
@@ -1,14 +1,33 @@
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+from datetime import datetime
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Log the incoming request
-    context.logger.info("Hello agent received a request")
+    context.logger.info('Agent invoked', {'contentType': request.data.content_type})
 
-    # Get the name from request data
-    data = await request.data.json()
-    name = data.get("name", "World")
+    received_data = None
 
-    context.logger.info(f"Greeting {name}")
+    if request.data.content_type == 'application/json':
+        received_data = await request.data.json()
+    elif request.data.content_type == 'text/plain':
+        received_data = await request.data.text()
+    else:
+        received_data = await request.data.text()
 
-    # Return a simple greeting
-    return response.json({"message": f"Hello, {name}!"})
+    context.logger.info('Request received', {'data': received_data})
+
+    return response.json({
+        'message': 'Request received and logged',
+        'contentType': request.data.content_type,
+        'received': received_data,
+        'timestamp': datetime.utcnow().isoformat() + 'Z'
+    })
+
+def welcome():
+    return {
+        'welcome': 'Send data and watch the logs appear in DevMode.',
+        'prompts': [
+            {'data': json.dumps({'action': 'test', 'value': 123}), 'contentType': 'application/json'},
+            {'data': 'Testing logs', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/01-intro/step2-with-logging.ts b/examples/training/01-intro/step2-with-logging.ts
index 06988df9..fd6ddd7e 100644
--- a/examples/training/01-intro/step2-with-logging.ts
+++ b/examples/training/01-intro/step2-with-logging.ts
@@ -5,15 +5,35 @@ export default async function Agent(
   response: AgentResponse,
   context: AgentContext
 ) {
-  // Log the incoming request
-  context.logger.info('Hello agent received a request');
+  context.logger.info('Agent invoked', { contentType: request.data.contentType });
 
-  // Get the name from request data
-  const data = await request.data.json();
-  const name = data.name || 'World';
+  let receivedData: unknown = null;
 
-  context.logger.info(`Greeting ${name}`);
+  switch (request.data.contentType) {
+    case 'application/json':
+      receivedData = await request.data.json();
+      break;
+    case 'text/plain':
+      receivedData = await request.data.text();
+      break;
+    default:
+      receivedData = await request.data.text();
+  }
 
-  // Return a simple greeting
-  return response.json({ message: `Hello, ${name}!` });
+  context.logger.info('Request received', { data: receivedData });
+
+  return response.json({
+    message: 'Request received and logged',
+    contentType: request.data.contentType,
+    received: receivedData,
+    timestamp: new Date().toISOString()
+  });
 }
+
+export const welcome = () => ({
+  welcome: 'Send data and watch the logs appear in DevMode.',
+  prompts: [
+    { data: JSON.stringify({ action: 'test', value: 123 }), contentType: 'application/json' },
+    { data: 'Testing logs', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/01-intro/step3-with-state.py b/examples/training/01-intro/step3-with-state.py
index 9db8c5f7..e9c0c662 100644
--- a/examples/training/01-intro/step3-with-state.py
+++ b/examples/training/01-intro/step3-with-state.py
@@ -1,28 +1,42 @@
-from datetime import datetime
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+from datetime import datetime
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    context.logger.info("Hello agent received a request")
+    context.logger.info('Agent invoked')
 
-    data = await request.data.json()
-    name = data.get("name", "World")
+    received_data = None
 
-    # Get current greeting count from KV storage
-    counter_result = await context.kv.get("stats", "greeting_count")
-
-    if counter_result.exists:
-        count = await counter_result.data.json()
-        count += 1
+    if request.data.content_type == 'application/json':
+        received_data = await request.data.json()
+    elif request.data.content_type == 'text/plain':
+        received_data = await request.data.text()
     else:
-        count = 1
+        received_data = await request.data.text()
 
-    # Update the counter
-    await context.kv.set("stats", "greeting_count", count)
+    # Track total requests using KV storage
+    result = await context.kv.get('request-stats', 'total-requests')
+    count = 1
+    if result.exists:
+        count = int(await result.data.text()) + 1
+    await context.kv.set('request-stats', 'total-requests', str(count))
 
-    context.logger.info(f"Greeting #{count} for {name}")
+    context.logger.info('Request processed', {'requestNumber': count})
 
     return response.json({
-        "message": f"Hello, {name}!",
-        "greeting_number": count,
-        "timestamp": datetime.now().isoformat()
+        'message': 'Request received',
+        'contentType': request.data.content_type,
+        'received': received_data,
+        'stats': {'totalRequests': count},
+        'timestamp': datetime.utcnow().isoformat() + 'Z'
     })
+
+def welcome():
+    return {
+        'welcome': 'Send multiple requests and watch the counter increment!',
+        'prompts': [
+            {'data': json.dumps({'test': 'request 1'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'test': 'request 2'}), 'contentType': 'application/json'},
+            {'data': 'Request 3', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/01-intro/step3-with-state.ts b/examples/training/01-intro/step3-with-state.ts
index eec73bf4..8610398b 100644
--- a/examples/training/01-intro/step3-with-state.ts
+++ b/examples/training/01-intro/step3-with-state.ts
@@ -5,30 +5,45 @@ export default async function Agent(
   response: AgentResponse,
   context: AgentContext
 ) {
-  context.logger.info('Hello agent received a request');
+  context.logger.info('Agent invoked');
 
-  const data = await request.data.json();
-  const name = data.name || 'World';
+  let receivedData: unknown = null;
 
-  // Get current greeting count from KV storage
-  const counterResult = await context.kv.get('stats', 'greeting_count');
-  let count: number;
-
-  if (counterResult.exists) {
-    count = await counterResult.data.json();
-    count++;
-  } else {
-    count = 1;
+  switch (request.data.contentType) {
+    case 'application/json':
+      receivedData = await request.data.json();
+      break;
+    case 'text/plain':
+      receivedData = await request.data.text();
+      break;
+    default:
+      receivedData = await request.data.text();
   }
 
-  // Update the counter
-  await context.kv.set('stats', 'greeting_count', count);
+  // Track total requests using KV storage
+  const result = await context.kv.get('request-stats', 'total-requests');
+  let count = 1;
+  if (result.exists) {
+    count = Number(await result.data.text()) + 1;
+  }
+  await context.kv.set('request-stats', 'total-requests', String(count));
 
-  context.logger.info(`Greeting #${count} for ${name}`);
+  context.logger.info('Request processed', { requestNumber: count });
 
   return response.json({
-    message: `Hello, ${name}!`,
-    greeting_number: count,
+    message: 'Request received',
+    contentType: request.data.contentType,
+    received: receivedData,
+    stats: { totalRequests: count },
     timestamp: new Date().toISOString()
   });
 }
+
+export const welcome = () => ({
+  welcome: 'Send multiple requests and watch the counter increment!',
+  prompts: [
+    { data: JSON.stringify({ test: 'request 1' }), contentType: 'application/json' },
+    { data: JSON.stringify({ test: 'request 2' }), contentType: 'application/json' },
+    { data: 'Request 3', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/01-intro/step4-with-errors.py b/examples/training/01-intro/step4-with-errors.py
index 5c2b2937..5fb1dd3b 100644
--- a/examples/training/01-intro/step4-with-errors.py
+++ b/examples/training/01-intro/step4-with-errors.py
@@ -1,41 +1,53 @@
-from datetime import datetime
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+from datetime import datetime
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    context.logger.info("Hello agent received a request")
-
-    # Safe input handling with error checking
-    name = "World"
-    try:
-        data = await request.data.json()
-
-        if not data.get("name") or not isinstance(data.get("name"), str):
-            context.logger.warning("No valid name provided in request")
-            return response.json({"error": "Name is required and must be a string"})
+    context.logger.info('Agent invoked')
 
-        name = data["name"]
-    except Exception as e:
-        context.logger.error(f"Error parsing request: {e}")
-        return response.json({"error": "Invalid JSON in request body"})
+    received_data = None
 
-    # Get current greeting count with error handling
+    # Parse with error handling
+    try:
+        if request.data.content_type == 'application/json':
+            received_data = await request.data.json()
+        elif request.data.content_type == 'text/plain':
+            received_data = await request.data.text()
+        else:
+            received_data = await request.data.text()
+    except Exception as error:
+        context.logger.error('Failed to parse request data', {'error': str(error)})
+        return response.json(
+            {'error': 'Invalid request data'},
+            status=400
+        )
+
+    # Track total requests with error handling
     count = 1
     try:
-        counter_result = await context.kv.get("stats", "greeting_count")
-
-        if counter_result.exists:
-            count = await counter_result.data.json()
-            count += 1
+        result = await context.kv.get('request-stats', 'total-requests')
+        if result.exists:
+            count = int(await result.data.text()) + 1
+        await context.kv.set('request-stats', 'total-requests', str(count))
+    except Exception as error:
+        context.logger.error('KV storage error', {'error': str(error)})
+        # Continue with default count - graceful degradation
 
-        await context.kv.set("stats", "greeting_count", count)
-    except Exception as e:
-        context.logger.error(f"Error accessing storage: {e}")
-        # Continue with default count rather than failing
-
-    context.logger.info(f"Greeting #{count} for {name}")
+    context.logger.info('Request processed', {'requestNumber': count})
 
     return response.json({
-        "message": f"Hello, {name}!",
-        "greeting_number": count,
-        "timestamp": datetime.now().isoformat()
+        'message': 'Request received',
+        'contentType': request.data.content_type,
+        'received': received_data,
+        'stats': {'totalRequests': count},
+        'timestamp': datetime.utcnow().isoformat() + 'Z'
     })
+
+def welcome():
+    return {
+        'welcome': 'Test error handling by sending valid and invalid data.',
+        'prompts': [
+            {'data': json.dumps({'valid': 'data'}), 'contentType': 'application/json'},
+            {'data': 'Valid text', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/01-intro/step4-with-errors.ts b/examples/training/01-intro/step4-with-errors.ts
index b5284775..d7685f0e 100644
--- a/examples/training/01-intro/step4-with-errors.ts
+++ b/examples/training/01-intro/step4-with-errors.ts
@@ -5,49 +5,58 @@ export default async function Agent(
   response: AgentResponse,
   context: AgentContext
 ) {
-  context.logger.info('Hello agent received a request');
+  context.logger.info('Agent invoked');
 
-  // Safe input handling with error checking
-  let name = 'World';
-  try {
-    const data = await request.data.json();
+  let receivedData: unknown = null;
 
-    if (!data.name || typeof data.name !== 'string') {
-      context.logger.warn('No valid name provided in request');
-      return response.json({
-        error: 'Name is required and must be a string'
-      });
+  // Parse with error handling
+  try {
+    switch (request.data.contentType) {
+      case 'application/json':
+        receivedData = await request.data.json();
+        break;
+      case 'text/plain':
+        receivedData = await request.data.text();
+        break;
+      default:
+        receivedData = await request.data.text();
     }
-
-    name = data.name;
   } catch (error) {
-    context.logger.error(`Error parsing request: ${error}`);
-    return response.json({
-      error: 'Invalid JSON in request body'
-    });
+    context.logger.error('Failed to parse request data', { error });
+    return response.json(
+      { error: 'Invalid request data' },
+      { status: 400 }
+    );
   }
 
-  // Get current greeting count with error handling
+  // Track total requests with error handling
   let count = 1;
   try {
-    const counterResult = await context.kv.get('stats', 'greeting_count');
-
-    if (counterResult.exists) {
-      count = await counterResult.data.json();
-      count++;
+    const result = await context.kv.get('request-stats', 'total-requests');
+    if (result.exists) {
+      count = Number(await result.data.text()) + 1;
     }
-
-    await context.kv.set('stats', 'greeting_count', count);
+    await context.kv.set('request-stats', 'total-requests', String(count));
   } catch (error) {
-    context.logger.error(`Error accessing storage: ${error}`);
-    // Continue with default count rather than failing
+    context.logger.error('KV storage error', { error });
+    // Continue with default count - graceful degradation
   }
 
-  context.logger.info(`Greeting #${count} for ${name}`);
+  context.logger.info('Request processed', { requestNumber: count });
 
   return response.json({
-    message: `Hello, ${name}!`,
-    greeting_number: count,
+    message: 'Request received',
+    contentType: request.data.contentType,
+    received: receivedData,
+    stats: { totalRequests: count },
     timestamp: new Date().toISOString()
   });
 }
+
+export const welcome = () => ({
+  welcome: 'Test error handling by sending valid and invalid data.',
+  prompts: [
+    { data: JSON.stringify({ valid: 'data' }), contentType: 'application/json' },
+    { data: 'Valid text', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step1-understanding-triggers.py b/examples/training/02-anatomy/step1-understanding-triggers.py
index 72143f47..26bafddf 100644
--- a/examples/training/02-anatomy/step1-understanding-triggers.py
+++ b/examples/training/02-anatomy/step1-understanding-triggers.py
@@ -1,4 +1,5 @@
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
     # Get the trigger type
@@ -27,3 +28,12 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
             "message": f"Triggered via: {trigger}",
             "availableTriggers": ["webhook", "cron", "manual", "agent", "sms", "email"]
         })
+
+def welcome():
+    return {
+        'welcome': 'Learn how agents respond to different trigger types (webhook, cron, manual).',
+        'prompts': [
+            {'data': 'Test manual trigger', 'contentType': 'text/plain'},
+            {'data': json.dumps({'test': 'data'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/02-anatomy/step1-understanding-triggers.ts b/examples/training/02-anatomy/step1-understanding-triggers.ts
index 622e2c69..42a3ad7f 100644
--- a/examples/training/02-anatomy/step1-understanding-triggers.ts
+++ b/examples/training/02-anatomy/step1-understanding-triggers.ts
@@ -16,14 +16,9 @@ export default async function Agent(
       message: 'Received webhook trigger',
       tip: 'Webhooks are great for REST APIs and integrations'
     });
-  } else if (trigger === 'cron') {
-    return response.json({
-      message: 'Scheduled task executed',
-      tip: 'Cron triggers run automatically on schedule'
-    });
   } else if (trigger === 'manual') {
     return response.json({
-      message: 'Manual trigger from DevMode or Console',
+      message: 'Manual trigger from DevMode/Console',
       tip: 'Manual triggers are perfect for testing'
     });
   } else {
@@ -33,3 +28,11 @@ export default async function Agent(
     });
   }
 }
+
+export const welcome = () => ({
+  welcome: 'Learn how agents respond to different trigger types (webhook, cron, manual).',
+  prompts: [
+    { data: 'Test manual trigger', contentType: 'text/plain' },
+    { data: JSON.stringify({ test: 'data' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step2-request-data.py b/examples/training/02-anatomy/step2-request-data.py
index d6c827fa..b32d761a 100644
--- a/examples/training/02-anatomy/step2-request-data.py
+++ b/examples/training/02-anatomy/step2-request-data.py
@@ -1,44 +1,43 @@
 from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # Check content type to determine how to parse data
+    # Get the content type and trigger information
     content_type = request.data.content_type
+    trigger = request.trigger
 
-    context.logger.info(f"Request content type: {content_type}")
+    context.logger.info(f"Processing {content_type} request via {trigger} trigger")
 
-    request_data = None
+    # Parse data based on content type
+    parsed_data = None
 
-    # Handle different data formats
     if "application/json" in content_type:
-        request_data = await request.data.json()
-        context.logger.info(f"Parsed as JSON data={request_data}")
+        parsed_data = await request.data.json()
+        context.logger.info(f"Parsed as JSON keys={list(parsed_data.keys())}")
     elif "text/plain" in content_type:
-        request_data = await request.data.text()
-        context.logger.info(f"Parsed as text length={len(request_data)}")
+        parsed_data = await request.data.text()
+        context.logger.info(f"Parsed as text length={len(parsed_data)}")
     else:
-        request_data = await request.data.binary()
-        context.logger.info(f"Parsed as binary size={len(request_data)}")
-
-    # Access metadata - multiple approaches:
-
-    # Approach 1: Using request.get() - SDK convenience method (recommended)
-    session_id = request.get("session_id", "no-session")
-    user_id = request.get("user_id", "anonymous")
-
-    # Approach 2: Using metadata property (returns dict) with dict.get()
-    # session_id = request.metadata.get("session_id", "no-session")
-    # user_id = request.metadata.get("user_id", "anonymous")
-
-    # Approach 3: Direct dictionary access (raises KeyError if missing)
-    # session_id = request.metadata.get("session_id", "no-session")  # Same as approach 2
-    # Or without default: session_id = request.metadata["session_id"]
+        parsed_data = await request.data.binary()
+        context.logger.info(f"Parsed as binary size={len(parsed_data)}")
 
+    # Return parsed data with request metadata
     return response.json({
-        "received": {
+        "received": parsed_data,
+        "request": {
             "contentType": content_type,
-            "dataType": type(request_data).__name__,
-            "sessionId": session_id,
-            "userId": user_id
+            "trigger": trigger,
+            "metadata": request.metadata or {}
         },
         "message": "Successfully parsed request data"
     })
+
+def welcome():
+    return {
+        'welcome': 'Learn how to parse different data formats and access request properties.',
+        'prompts': [
+            {'data': json.dumps({'message': 'Hello', 'count': 42}), 'contentType': 'application/json'},
+            {'data': 'Plain text message', 'contentType': 'text/plain'},
+            {'data': 'Another message', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/02-anatomy/step2-request-data.ts b/examples/training/02-anatomy/step2-request-data.ts
index f8cbd44b..c8442bb2 100644
--- a/examples/training/02-anatomy/step2-request-data.ts
+++ b/examples/training/02-anatomy/step2-request-data.ts
@@ -5,46 +5,42 @@ export default async function Agent(
   response: AgentResponse,
   context: AgentContext
 ) {
-  // Check content type to determine how to parse data
+  // Get the content type and trigger information
   const contentType = request.data.contentType;
+  const trigger = request.trigger;
 
-  context.logger.info(`Request content type: ${contentType}`);
+  context.logger.info(`Processing ${contentType} request via ${trigger} trigger`);
 
-  let requestData: any;
+  // Parse data based on content type
+  let parsedData: any;
 
-  // Handle different data formats
   if (contentType.includes('application/json')) {
-    requestData = await request.data.json();
-    context.logger.info('Parsed as JSON', { data: requestData });
+    parsedData = await request.data.json();
+    context.logger.info('Parsed as JSON', { keys: Object.keys(parsedData) });
   } else if (contentType.includes('text/plain')) {
-    requestData = await request.data.text();
-    context.logger.info('Parsed as text', { length: requestData.length });
+    parsedData = await request.data.text();
+    context.logger.info('Parsed as text', { length: parsedData.length });
   } else {
-    requestData = await request.data.binary();
-    context.logger.info('Parsed as binary', { size: requestData.byteLength });
+    parsedData = await request.data.binary();
+    context.logger.info('Parsed as binary', { size: parsedData.byteLength });
   }
 
-  // Access metadata - multiple approaches:
-
-  // Approach 1: Using request.get() - SDK convenience method (recommended)
-  const sessionId = request.get('session_id', 'no-session');
-  const userId = request.get('user_id', 'anonymous');
-
-  // Approach 2: Direct property access on metadata object
-  // const sessionId = request.metadata.session_id || 'no-session';
-  // const userId = request.metadata.user_id || 'anonymous';
-
-  // Approach 3: Using optional chaining (safest for nested properties)
-  // const sessionId = request.metadata?.session_id ?? 'no-session';
-  // const userId = request.metadata?.user_id ?? 'anonymous';
-
+  // Return parsed data with request metadata
   return response.json({
-    received: {
+    received: parsedData,
+    request: {
       contentType,
-      dataType: typeof requestData,
-      sessionId,
-      userId
+      trigger,
+      metadata: request.metadata || {}
     },
     message: 'Successfully parsed request data'
   });
 }
+
+export const welcome = () => ({
+  welcome: 'Learn how to parse different data formats and access request properties.',
+  prompts: [
+    { data: JSON.stringify({ message: 'Hello', count: 42 }), contentType: 'application/json' },
+    { data: 'Plain text message', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step3-response-formats.py b/examples/training/02-anatomy/step3-response-formats.py
new file mode 100644
index 00000000..26b68cea
--- /dev/null
+++ b/examples/training/02-anatomy/step3-response-formats.py
@@ -0,0 +1,68 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+
+def welcome():
+    return {
+        'welcome': 'Learn how to return different response formats (text, markdown, streaming).',
+        'prompts': [
+            {'data': 'Show text response', 'contentType': 'text/plain'},
+            {'data': 'Show markdown response', 'contentType': 'text/plain'},
+            {'data': 'Show streaming response', 'contentType': 'text/plain'}
+        ]
+    }
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    prompt = await request.data.text()
+
+    context.logger.info('Received request', {'prompt': prompt})
+
+    # Plain text response
+    if prompt == 'Show text response':
+        return response.text('This is a plain text response from your agent.')
+
+    # Note: We've seen response.json() in previous steps
+
+    # Markdown response (formatted text)
+    if prompt == 'Show markdown response':
+        markdown = f"""# Agent Response
+
+This is a **markdown** response with rich formatting.
+
+## Features
+- Lists
+- **Bold** and *italic* text
+- Code blocks
+
+```json
+{{
+  "agent": "{context.agent.name}",
+  "timestamp": "{datetime.now().isoformat()}"
+}}
+```"""
+
+        return response.markdown(markdown)
+
+    # Stream response (using the OpenAI Chat Completions API)
+    if prompt == 'Show streaming response':
+        from openai import AsyncOpenAI
+        client = AsyncOpenAI()
+
+        try:
+            chat_completion = await client.chat.completions.create(
+                model='gpt-5-nano',
+                messages=[{
+                    'role': 'user',
+                    'content': 'Tell me a short story about AI agents. Limit your response to 250 words.'
+                }],
+                stream=True
+            )
+
+            return response.stream(chat_completion, lambda x: x.choices[0].delta.content, contentType='text/markdown')
+
+        except Exception as error:
+            context.logger.error(f'Error streaming response: {error}')
+            return response.text('Error generating stream', status=500)
+
+    # Note: Use response.empty() when you don't need to send data back (useful for webhooks)
+
+    return response.text('Try one of the example prompts to see different response formats.')
diff --git a/examples/training/02-anatomy/step3-response-formats.ts b/examples/training/02-anatomy/step3-response-formats.ts
new file mode 100644
index 00000000..e4259261
--- /dev/null
+++ b/examples/training/02-anatomy/step3-response-formats.ts
@@ -0,0 +1,64 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+import { openai } from '@ai-sdk/openai';
+import { streamText } from 'ai';
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const prompt = await request.data.text();
+
+  context.logger.info('Received request', { prompt });
+
+  // Plain text response
+  if (prompt === 'Show text response') {
+    return response.text('This is a plain text response from your agent.');
+  }
+
+  // Note: We've seen response.json() in previous steps
+
+  // Markdown response (formatted text)
+  if (prompt === 'Show markdown response') {
+    const markdown = `# Agent Response
+
+This is a **markdown** response with rich formatting.
+
+## Features
+- Lists
+- **Bold** and *italic* text
+- Code blocks
+
+\`\`\`json
+{
+  "agent": "${context.agent.name}",
+  "timestamp": "${new Date().toISOString()}"
+}
+\`\`\``;
+
+    return response.markdown(markdown);
+  }
+
+  // Stream response (using the Vercel AI SDK)
+  if (prompt === 'Show streaming response') {
+    const result = await streamText({
+      model: openai('gpt-5-nano'),
+      prompt: 'Tell me a short story about AI agents. Limit your response to 250 words.'
+    });
+
+    return response.stream(result.textStream, 'text/markdown');
+  }
+
+  // Note: Use response.empty() when you don't need to send data back (useful for webhooks)
+
+  return response.text('Try one of the example prompts to see different response formats.');
+}
+
+export const welcome = () => ({
+  welcome: 'Learn how to return different response formats (text, markdown, streaming).',
+  prompts: [
+    { data: 'Show text response', contentType: 'text/plain' },
+    { data: 'Show markdown response', contentType: 'text/plain' },
+    { data: 'Show streaming response', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step3-structured-logging.py b/examples/training/02-anatomy/step3-structured-logging.py
deleted file mode 100644
index 68eb6348..00000000
--- a/examples/training/02-anatomy/step3-structured-logging.py
+++ /dev/null
@@ -1,50 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from datetime import datetime
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    # INFO: Normal flow - track what's happening
-    context.logger.info(
-        f"Processing request started agent_id={context.agent.id} "
-        f"agent_name={context.agent.name} session_id={context.sessionId} "
-        f"trigger={request.trigger}"
-    )
-
-    data = await request.data.json()
-    task_type = data.get("task", "unknown")
-
-    # DEBUG: Detailed information for troubleshooting
-    context.logger.debug(
-        f"Request details task_type={task_type} "
-        f"data_keys={list(data.keys())} timestamp={datetime.now().isoformat()}"
-    )
-
-    # Simulate different outcomes
-    if task_type == "risky":
-        # WARNING: Potential issues that don't stop execution
-        context.logger.warning(
-            f"Risky task detected task_type={task_type} "
-            f"recommendation='Review before proceeding'"
-        )
-
-    if task_type == "error":
-        # ERROR: Failures requiring attention
-        context.logger.error(
-            f"Task execution failed task_type={task_type} "
-            f"reason='Invalid task type' action='Returning error response'"
-        )
-
-        return response.json({
-            "error": "Task failed",
-            "details": "Invalid task type: error"
-        })
-
-    # Log successful completion
-    context.logger.info(
-        f"Request processed successfully task_type={task_type} duration=45ms"
-    )
-
-    return response.json({
-        "success": True,
-        "taskType": task_type,
-        "message": "Task completed"
-    })
diff --git a/examples/training/02-anatomy/step3-structured-logging.ts b/examples/training/02-anatomy/step3-structured-logging.ts
deleted file mode 100644
index d09a13f9..00000000
--- a/examples/training/02-anatomy/step3-structured-logging.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  // INFO: Normal flow - track what's happening
-  context.logger.info('Processing request started', {
-    agentId: context.agent.id,
-    agentName: context.agent.name,
-    sessionId: context.sessionId,
-    trigger: request.trigger
-  });
-
-  const data = await request.data.json();
-  const taskType = data.task || 'unknown';
-
-  // DEBUG: Detailed information for troubleshooting
-  context.logger.debug('Request details', {
-    taskType,
-    dataKeys: Object.keys(data),
-    timestamp: new Date().toISOString()
-  });
-
-  // Simulate different outcomes
-  if (taskType === 'risky') {
-    // WARN: Potential issues that don't stop execution
-    context.logger.warn('Risky task detected', {
-      taskType,
-      recommendation: 'Review before proceeding'
-    });
-  }
-
-  if (taskType === 'error') {
-    // ERROR: Failures requiring attention
-    context.logger.error('Task execution failed', {
-      taskType,
-      reason: 'Invalid task type',
-      action: 'Returning error response'
-    });
-
-    return response.json({
-      error: 'Task failed',
-      details: 'Invalid task type: error'
-    });
-  }
-
-  // Log successful completion
-  context.logger.info('Request processed successfully', {
-    taskType,
-    duration: '45ms'
-  });
-
-  return response.json({
-    success: true,
-    taskType,
-    message: 'Task completed'
-  });
-}
diff --git a/examples/training/02-anatomy/step4-context-agent-info.py b/examples/training/02-anatomy/step4-context-agent-info.py
new file mode 100644
index 00000000..08496dd8
--- /dev/null
+++ b/examples/training/02-anatomy/step4-context-agent-info.py
@@ -0,0 +1,57 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    prompt = await request.data.text()
+
+    context.logger.info(f"Received: {prompt}")
+
+    # Show agent information
+    if prompt == 'Agent Info':
+        return response.json({
+            "agent": {
+                "id": context.agent.id,
+                "name": context.agent.name,
+                "description": context.agent.description or "No description"
+            },
+            "message": "Current agent details"
+        })
+
+    # Show runtime/environment information
+    if prompt == 'Runtime Info':
+        return response.json({
+            "runtime": {
+                "sdkVersion": context.sdkVersion,
+                "devmode": context.devmode,
+                "projectId": context.projectId,
+                "deploymentId": context.deploymentId
+            },
+            "message": "Runtime and environment information"
+        })
+
+    # Show available platform services
+    if prompt == 'Platform Services':
+        return response.json({
+            "services": {
+                "storage": ["kv", "vector", "objectstore"],
+                "observability": ["logger", "tracer"],
+                "communication": ["get_agent", "email"]
+            },
+            "message": "Access these services via the context object",
+            "example": "context.kv, context.logger, context.get_agent(), etc."
+        })
+
+    # Default response
+    return response.json({
+        "message": "Try one of the example prompts to explore agent context",
+        "availableCommands": ["Agent Info", "Runtime Info", "Platform Services"]
+    })
+
+def welcome():
+    return {
+        'welcome': 'Explore the agent context object and available platform services.',
+        'prompts': [
+            {'data': 'Agent Info', 'contentType': 'text/plain'},
+            {'data': 'Runtime Info', 'contentType': 'text/plain'},
+            {'data': 'Platform Services', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/02-anatomy/step4-context-agent-info.ts b/examples/training/02-anatomy/step4-context-agent-info.ts
new file mode 100644
index 00000000..77b84e80
--- /dev/null
+++ b/examples/training/02-anatomy/step4-context-agent-info.ts
@@ -0,0 +1,64 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const prompt = await request.data.text();
+
+  context.logger.info(`Received: ${prompt}`);
+
+  // Show agent information
+  if (prompt === 'Agent Info') {
+    return response.json({
+      agent: {
+        id: context.agent.id,
+        name: context.agent.name,
+        description: context.agent.description || 'No description'
+      },
+      message: 'Current agent details'
+    });
+  }
+
+  // Show runtime/environment information
+  if (prompt === 'Runtime Info') {
+    return response.json({
+      runtime: {
+        sdkVersion: context.sdkVersion,
+        devmode: context.devmode,
+        projectId: context.projectId,
+        deploymentId: context.deploymentId
+      },
+      message: 'Runtime and environment information'
+    });
+  }
+
+  // Show available platform services
+  if (prompt === 'Platform Services') {
+    return response.json({
+      services: {
+        storage: ['kv', 'vector', 'objectstore'],
+        observability: ['logger', 'tracer'],
+        communication: ['getAgent', 'email']
+      },
+      message: 'Access these services via the context object',
+      example: 'context.kv, context.logger, context.getAgent(), etc.'
+    });
+  }
+
+  // Default response
+  return response.json({
+    message: 'Try one of the example prompts to explore agent context',
+    availableCommands: ['Agent Info', 'Runtime Info', 'Platform Services']
+  });
+}
+
+export const welcome = () => ({
+  welcome: 'Explore the agent context object and available platform services.',
+  prompts: [
+    { data: 'Agent Info', contentType: 'text/plain' },
+    { data: 'Runtime Info', contentType: 'text/plain' },
+    { data: 'Platform Services', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step4-kv-caching.py b/examples/training/02-anatomy/step4-kv-caching.py
deleted file mode 100644
index 7ff08e68..00000000
--- a/examples/training/02-anatomy/step4-kv-caching.py
+++ /dev/null
@@ -1,47 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from datetime import datetime
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    data = await request.data.json()
-    query = data.get("query", "default")
-
-    # Create a cache key
-    cache_key = f"query_{query.lower().replace(' ', '_')}"
-
-    context.logger.info(f"Checking cache cache_key={cache_key}")
-
-    # Check if we have cached data
-    cached = await context.kv.get("demo-cache", cache_key)
-
-    if cached.exists:
-        cached_data = await cached.data.json()
-        context.logger.info(f"Cache hit! cache_key={cache_key}")
-
-        return response.json({
-            "source": "cache",
-            "query": query,
-            "result": cached_data,
-            "message": "Retrieved from cache"
-        })
-
-    # Cache miss - simulate expensive operation
-    context.logger.info(f"Cache miss - computing result cache_key={cache_key}")
-
-    result = {
-        "query": query,
-        "computed": True,
-        "timestamp": datetime.now().isoformat(),
-        "data": f"Processed: {query}"
-    }
-
-    # Store in cache with 5 minute TTL
-    await context.kv.set("demo-cache", cache_key, result, {"ttl": 300})
-
-    context.logger.info(f"Result cached cache_key={cache_key} ttl=300s (5 minutes)")
-
-    return response.json({
-        "source": "fresh",
-        "query": query,
-        "result": result,
-        "message": "Computed and cached for 5 minutes"
-    })
diff --git a/examples/training/02-anatomy/step4-kv-caching.ts b/examples/training/02-anatomy/step4-kv-caching.ts
deleted file mode 100644
index 6d8c921e..00000000
--- a/examples/training/02-anatomy/step4-kv-caching.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  const data = await request.data.json();
-  const query = data.query || 'default';
-
-  // Create a cache key
-  const cacheKey = `query_${query.toLowerCase().replace(/\s+/g, '_')}`;
-
-  context.logger.info('Checking cache', { cacheKey });
-
-  // Check if we have cached data
-  const cached = await context.kv.get('demo-cache', cacheKey);
-
-  if (cached.exists) {
-    const cachedData = await cached.data.json();
-    context.logger.info('Cache hit!', { cacheKey });
-
-    return response.json({
-      source: 'cache',
-      query,
-      result: cachedData,
-      message: 'Retrieved from cache'
-    });
-  }
-
-  // Cache miss - simulate expensive operation
-  context.logger.info('Cache miss - computing result', { cacheKey });
-
-  const result = {
-    query,
-    computed: true,
-    timestamp: new Date().toISOString(),
-    data: `Processed: ${query}`
-  };
-
-  // Store in cache with 5 minute TTL
-  await context.kv.set('demo-cache', cacheKey, result, { ttl: 300 });
-
-  context.logger.info('Result cached', {
-    cacheKey,
-    ttl: '300s (5 minutes)'
-  });
-
-  return response.json({
-    source: 'fresh',
-    query,
-    result,
-    message: 'Computed and cached for 5 minutes'
-  });
-}
diff --git a/examples/training/02-anatomy/step5-context-logging.py b/examples/training/02-anatomy/step5-context-logging.py
new file mode 100644
index 00000000..4a81cd1a
--- /dev/null
+++ b/examples/training/02-anatomy/step5-context-logging.py
@@ -0,0 +1,47 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+from datetime import datetime
+import json
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Parse data based on content type
+    if request.data.content_type == 'application/json':
+        received_data = await request.data.json()
+    elif request.data.content_type == 'text/plain':
+        received_data = await request.data.text()
+    else:
+        received_data = await request.data.text()
+
+    # INFO: Normal flow - track what's happening
+    context.logger.info(
+        f"Processing request started agent_id={context.agent.id} "
+        f"trigger={request.trigger} content_type={request.data.content_type}"
+    )
+
+    # DEBUG: Detailed information for troubleshooting
+    context.logger.debug(
+        f"Request details data={received_data} timestamp={datetime.now().isoformat()}"
+    )
+
+    # WARN: Demonstrate warning level (non-critical issues)
+    context.logger.warning(
+        f"Example warning message note='Warnings indicate potential issues but execution continues'"
+    )
+
+    # ERROR: Demonstrate error level
+    context.logger.error(
+        f"Example error message error_type=demonstration"
+    )
+
+    return response.json({
+        "message": "Check the logs below to see different log levels",
+        "received": received_data
+    })
+
+def welcome():
+    return {
+        'welcome': 'Use structured logging with different levels (info, debug, warn, error).',
+        'prompts': [
+            {'data': 'Testing structured logging', 'contentType': 'text/plain'},
+            {'data': json.dumps({'user': 'testuser', 'action': 'checkout'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/02-anatomy/step5-context-logging.ts b/examples/training/02-anatomy/step5-context-logging.ts
new file mode 100644
index 00000000..2cda0670
--- /dev/null
+++ b/examples/training/02-anatomy/step5-context-logging.ts
@@ -0,0 +1,58 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Parse data based on content type
+  let receivedData: unknown;
+
+  switch (request.data.contentType) {
+    case 'application/json':
+      receivedData = await request.data.json();
+      break;
+    case 'text/plain':
+      receivedData = await request.data.text();
+      break;
+    default:
+      receivedData = await request.data.text();
+      break;
+  }
+
+  // INFO: Normal flow - track what's happening
+  context.logger.info('Processing request started', {
+    agentId: context.agent.id,
+    trigger: request.trigger,
+    contentType: request.data.contentType
+  });
+
+  // DEBUG: Detailed information for troubleshooting
+  context.logger.debug('Request details', {
+    data: receivedData,
+    timestamp: new Date().toISOString()
+  });
+
+  // WARN: Demonstrate warning level (non-critical issues)
+  context.logger.warn('Example warning message', {
+    note: 'Warnings indicate potential issues but execution continues'
+  });
+
+  // ERROR: Demonstrate error level
+  context.logger.error('Example error message', {
+    errorType: 'demonstration'
+  });
+
+  return response.json({
+    message: 'Check the logs below to see different log levels',
+    received: receivedData
+  });
+}
+
+export const welcome = () => ({
+  welcome: 'Use structured logging with different levels (info, debug, warn, error).',
+  prompts: [
+    { data: 'Testing structured logging', contentType: 'text/plain' },
+    { data: JSON.stringify({ user: 'testuser', action: 'checkout' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/02-anatomy/step5-response-formats.py b/examples/training/02-anatomy/step5-response-formats.py
deleted file mode 100644
index 15a08476..00000000
--- a/examples/training/02-anatomy/step5-response-formats.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from datetime import datetime
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    data = await request.data.json()
-    format_type = data.get("format", "json")
-
-    context.logger.info(f"Generating response format={format_type}")
-
-    # Return different formats based on request
-    if format_type == "json":
-        return response.json({
-            "type": "json",
-            "message": "This is a JSON response",
-            "data": {
-                "agent": context.agent.name,
-                "timestamp": datetime.now().isoformat()
-            }
-        })
-    elif format_type == "text":
-        return response.text("This is a plain text response from your agent.")
-    elif format_type == "html":
-        html = f"""
-        <!DOCTYPE html>
-        <html>
-          <head><title>Agent Response</title></head>
-          <body>
-            <h1>HTML Response</h1>
-            <p>This is an HTML response from your agent.</p>
-            <p>Agent: {context.agent.name}</p>
-          </body>
-        </html>
-        """
-        return response.html(html)
-    elif format_type == "empty":
-        # Empty responses are useful for webhooks that don't need data back
-        return response.empty()
-    else:
-        return response.json({
-            "error": "Unknown format",
-            "supportedFormats": ["json", "text", "html", "empty"],
-            "requested": format_type
-        })
diff --git a/examples/training/02-anatomy/step5-response-formats.ts b/examples/training/02-anatomy/step5-response-formats.ts
deleted file mode 100644
index dfd6dfbf..00000000
--- a/examples/training/02-anatomy/step5-response-formats.ts
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  const data = await request.data.json();
-  const format = data.format || 'json';
-
-  context.logger.info('Generating response', { format });
-
-  // Return different formats based on request
-  if (format === 'json') {
-    return response.json({
-      type: 'json',
-      message: 'This is a JSON response',
-      data: {
-        agent: context.agent.name,
-        timestamp: new Date().toISOString()
-      }
-    });
-  } else if (format === 'text') {
-    return response.text('This is a plain text response from your agent.');
-  } else if (format === 'html') {
-    const html = `
-      <!DOCTYPE html>
-      <html>
-        <head><title>Agent Response</title></head>
-        <body>
-          <h1>HTML Response</h1>
-          <p>This is an HTML response from your agent.</p>
-          <p>Agent: ${context.agent.name}</p>
-        </body>
-      </html>
-    `;
-    return response.html(html);
-  } else if (format === 'empty') {
-    // Empty responses are useful for webhooks that don't need data back
-    return response.empty();
-  } else {
-    return response.json({
-      error: 'Unknown format',
-      supportedFormats: ['json', 'text', 'html', 'empty'],
-      requested: format
-    });
-  }
-}
diff --git a/examples/training/02-anatomy/step6-context-storage.py b/examples/training/02-anatomy/step6-context-storage.py
new file mode 100644
index 00000000..0bb22477
--- /dev/null
+++ b/examples/training/02-anatomy/step6-context-storage.py
@@ -0,0 +1,54 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+import random
+import string
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    # Get the query as plain text
+    query = await request.data.text()
+
+    # Create a storage key from the query
+    storage_key = query.lower().replace(' ', '_')
+
+    context.logger.info(f"Checking storage storage_key={storage_key}")
+
+    # Try to get from storage first
+    stored = await context.kv.get("demo-storage", storage_key)
+
+    if stored.exists:
+        # Found in storage - return stored data
+        stored_result = await stored.data.text()
+        context.logger.info(f"Found in storage! storage_key={storage_key}")
+
+        return response.json({
+            "source": "storage",
+            "query": query,
+            "result": stored_result,
+            "message": "Retrieved from storage"
+        })
+
+    # Not found in storage - generate result
+    context.logger.info(f"Not found in storage - generating result storage_key={storage_key}")
+
+    code = ''.join(random.choices(string.ascii_uppercase + string.digits, k=5))
+    result = f"Result {code} generated by {context.agent.name}"
+
+    # Store in KV storage with 5 minute TTL (300 seconds)
+    await context.kv.set("demo-storage", storage_key, result, {"ttl": 300})
+
+    context.logger.info(f"Result stored storage_key={storage_key} ttl=300s")
+
+    return response.json({
+        "source": "generated",
+        "query": query,
+        "result": result,
+        "message": "Generated and stored for 5 minutes - send the same message again to retrieve from storage!"
+    })
+
+def welcome():
+    return {
+        'welcome': 'Learn KV storage - send the same message twice to see it retrieved from storage.',
+        'prompts': [
+            {'data': 'hello', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/02-anatomy/step6-context-storage.ts b/examples/training/02-anatomy/step6-context-storage.ts
new file mode 100644
index 00000000..4bf980e5
--- /dev/null
+++ b/examples/training/02-anatomy/step6-context-storage.ts
@@ -0,0 +1,58 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  // Get the query as plain text
+  const query = await request.data.text();
+
+  // Create a storage key from the query
+  const storageKey = query.toLowerCase().replace(/\s+/g, '_');
+
+  context.logger.info('Checking storage', { storageKey });
+
+  // Try to get from storage first
+  const stored = await context.kv.get('demo-storage', storageKey);
+
+  if (stored.exists) {
+    // Found in storage - return stored data
+    const storedResult = await stored.data.text();
+    context.logger.info('Found in storage!', { storageKey });
+
+    return response.json({
+      source: 'storage',
+      query,
+      result: storedResult,
+      message: 'Retrieved from storage'
+    });
+  }
+
+  // Not found in storage - generate result
+  context.logger.info('Not found in storage - generating result', { storageKey });
+
+  const code = Math.random().toString(36).substring(2, 7).toUpperCase();
+  const result = `Result ${code} generated by ${context.agent.name}`;
+
+  // Store in KV storage with 5 minute TTL (300 seconds)
+  await context.kv.set('demo-storage', storageKey, result, { ttl: 300 });
+
+  context.logger.info('Result stored', {
+    storageKey,
+    ttl: '300s (5 minutes)'
+  });
+
+  return response.json({
+    source: 'generated',
+    result,
+    message: 'Generated and stored for 5 minutes - send the same message again to retrieve from storage!'
+  });
+}
+
+export const welcome = () => ({
+  welcome: 'Learn KV storage - send the same message twice to see it retrieved from storage.',
+  prompts: [
+    { data: 'hello', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/03-memory/step1-session-memory.py b/examples/training/03-memory/step1-session-memory.py
index 9a7d8025..565bfc3d 100644
--- a/examples/training/03-memory/step1-session-memory.py
+++ b/examples/training/03-memory/step1-session-memory.py
@@ -1,49 +1,58 @@
 from agentuity import AgentRequest, AgentResponse, AgentContext
 from datetime import datetime
-from aiohttp.web import Response
+
+def welcome():
+    return {
+        'welcome': 'Store conversation history in session memory with automatic TTL-based expiry.',
+        'prompts': [
+            {'data': 'Hello, this is my first message', 'contentType': 'text/plain'},
+            {'data': 'Here is my second message', 'contentType': 'text/plain'},
+            {'data': 'And a third message', 'contentType': 'text/plain'}
+        ]
+    }
 
 async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    bucket = "demo-sessions"
-    session_id = context.sessionId  # Use the current session ID
+    bucket = 'demo-sessions'
+    key = 'chat-history'
 
-    try:
-        # Get the user's message
-        user_message = await request.data.text()
+    # Initialize messages array
+    messages = []
 
-        # Retrieve existing session data
-        result = await context.kv.get(bucket, session_id)
+    # Retrieve existing session data
+    try:
+        result = await context.kv.get(bucket, key)
 
         if result.exists:
             # Session exists - load conversation history
             messages = await result.data.json()
-            context.logger.info(f"Loaded {len(messages)} existing messages")
+            context.logger.info(f'Loaded {len(messages)} existing messages')
         else:
-            # New session - initialize conversation
-            messages = []
-            context.logger.info("Starting new session")
-
-        # Add the new user message
-        messages.append({
-            "role": "user",
-            "content": user_message,
-            "timestamp": datetime.now().isoformat()
-        })
-
-        # Save conversation with 1-hour TTL (automatic cleanup)
-        await context.kv.set(bucket, session_id, messages, {
-            "ttl": 3600  # 1 hour in seconds
-        })
-
-        context.logger.info(f"Saved {len(messages)} messages with 1-hour TTL")
-
-        # Return conversation summary
-        return response.json({
-            "message": "Message saved to session memory",
-            "messageCount": len(messages),
-            "sessionId": session_id,
-            "expiresIn": "1 hour"
-        })
-
+            context.logger.info('Starting new session')
     except Exception as error:
-        context.logger.error(f"Error managing session memory: {error}")
-        return Response(text="Internal Server Error", status=500)
+        context.logger.error(f'Error retrieving session: {error}')
+        # Continue with empty array if retrieval fails
+
+    # Get user message
+    user_message = await request.data.text()
+
+    # Add the new user message
+    messages.append({
+        'role': 'user',
+        'content': user_message,
+        'timestamp': datetime.now().isoformat()
+    })
+
+    # Save conversation with 1-hour TTL (automatic expiration)
+    # Note: Omit the ttl parameter for permanent storage
+    await context.kv.set(bucket, key, messages, {
+        'ttl': 3600  # 1 hour in seconds
+    })
+
+    context.logger.info(f'Saved {len(messages)} messages with 1-hour TTL')
+
+    # Return conversation summary
+    return response.json({
+        'message': 'Message saved to session memory',
+        'messageCount': len(messages),
+        'expiresIn': '1 hour'
+    })
diff --git a/examples/training/03-memory/step1-session-memory.ts b/examples/training/03-memory/step1-session-memory.ts
index 489c3d17..4779da4f 100644
--- a/examples/training/03-memory/step1-session-memory.ts
+++ b/examples/training/03-memory/step1-session-memory.ts
@@ -1,55 +1,70 @@
 import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
 
+// Define a simple message type for session memory
+type SessionMessage = {
+  role: string;
+  content: string;
+  timestamp: string;
+};
+
 export default async function Agent(
   request: AgentRequest,
   response: AgentResponse,
   context: AgentContext
 ) {
   const bucket = 'demo-sessions';
-  const sessionId = context.sessionId; // Use the current session ID
+  const key = 'chat-history';
 
-  try {
-    // Get the user's message
-    const userMessage = await request.data.text();
+  // Initialize with proper type
+  let messages: SessionMessage[] = [];
 
-    // Retrieve existing session data
-    const result = await context.kv.get(bucket, sessionId);
+  // Retrieve existing session data
+  try {
+    const result = await context.kv.get(bucket, key);
 
-    let messages;
     if (result.exists) {
-      // Session exists - load conversation history
-      messages = await result.data.json();
+      // Cast to our type
+      messages = await result.data.json() as SessionMessage[];
       context.logger.info(`Loaded ${messages.length} existing messages`);
     } else {
-      // New session - initialize conversation
-      messages = [];
       context.logger.info('Starting new session');
     }
+  } catch (error) {
+    context.logger.error('Error retrieving session:', error);
+    // Continue with empty array if retrieval fails
+  }
 
-    // Add the new user message
-    messages.push({
-      role: 'user',
-      content: userMessage,
-      timestamp: new Date().toISOString()
-    });
+  // Get user message
+  const userMessage = await request.data.text();
 
-    // Save conversation with 1-hour TTL (automatic cleanup)
-    await context.kv.set(bucket, sessionId, messages, {
-      ttl: 3600 // 1 hour in seconds
-    });
+  // Add the new user message
+  messages.push({
+    role: 'user',
+    content: userMessage,
+    timestamp: new Date().toISOString()
+  });
 
-    context.logger.info(`Saved ${messages.length} messages with 1-hour TTL`);
+  // Save conversation with 1-hour TTL (automatic expiration)
+  // Note: Omit the ttl parameter for permanent storage
+  await context.kv.set(bucket, key, messages, {
+    ttl: 3600 // 1 hour in seconds
+  });
 
-    // Return conversation summary
-    return response.json({
-      message: 'Message saved to session memory',
-      messageCount: messages.length,
-      sessionId: sessionId,
-      expiresIn: '1 hour'
-    });
+  context.logger.info(`Saved ${messages.length} messages with 1-hour TTL`);
 
-  } catch (error) {
-    context.logger.error('Error managing session memory:', error);
-    return new Response('Internal Server Error', { status: 500 });
-  }
+  // Return conversation summary
+  return response.json({
+    message: 'Message saved to session memory',
+    messageCount: messages.length,
+    expiresIn: '1 hour'
+  });
 }
+
+export const welcome = () => ({
+  welcome: 'Store conversation history in session memory with automatic TTL-based expiry.',
+  prompts: [
+    { data: 'Hello, this is my first message', contentType: 'text/plain' },
+    { data: 'Here is my second message', contentType: 'text/plain' },
+    { data: 'And a third message', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/03-memory/step2-persistent-preferences.py b/examples/training/03-memory/step2-persistent-preferences.py
deleted file mode 100644
index 439e5268..00000000
--- a/examples/training/03-memory/step2-persistent-preferences.py
+++ /dev/null
@@ -1,56 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from datetime import datetime
-from aiohttp.web import Response
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    bucket = "user-profiles"
-    user_id = "user-123"  # In production, get from request.metadata
-
-    try:
-        # Get user input (preference to update)
-        data = await request.data.json()
-        theme = data.get("theme")
-        language = data.get("language")
-
-        # Retrieve existing user profile
-        result = await context.kv.get(bucket, user_id)
-
-        if result.exists:
-            # Existing user - load and update profile
-            profile = await result.data.json()
-            profile["lastSeen"] = datetime.now().isoformat()
-            profile["interactionCount"] = profile.get("interactionCount", 0) + 1
-
-            context.logger.info(f"Updating profile for returning user ({profile['interactionCount']} interactions)")
-        else:
-            # New user - create profile
-            profile = {
-                "userId": user_id,
-                "preferences": {},
-                "created": datetime.now().isoformat(),
-                "interactionCount": 1
-            }
-
-            context.logger.info("Creating new user profile")
-
-        # Update preferences if provided
-        if theme:
-            profile["preferences"]["theme"] = theme
-        if language:
-            profile["preferences"]["language"] = language
-
-        # Save profile WITHOUT TTL (permanent storage)
-        await context.kv.set(bucket, user_id, profile)
-
-        context.logger.info("Saved user profile (permanent storage)")
-
-        # Return updated profile
-        return response.json({
-            "message": "Profile updated successfully",
-            "profile": profile,
-            "storage": "permanent (no TTL)"
-        })
-
-    except Exception as error:
-        context.logger.error(f"Error managing user profile: {error}")
-        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step2-persistent-preferences.ts b/examples/training/03-memory/step2-persistent-preferences.ts
deleted file mode 100644
index d6545c47..00000000
--- a/examples/training/03-memory/step2-persistent-preferences.ts
+++ /dev/null
@@ -1,63 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  const bucket = 'user-profiles';
-  const userId = 'user-123'; // In production, get from request.metadata
-
-  try {
-    // Get user input (preference to update)
-    const data = await request.data.json();
-    const { theme, language } = data;
-
-    // Retrieve existing user profile
-    const result = await context.kv.get(bucket, userId);
-
-    let profile;
-    if (result.exists) {
-      // Existing user - load and update profile
-      profile = await result.data.json();
-      profile.lastSeen = new Date().toISOString();
-      profile.interactionCount = (profile.interactionCount || 0) + 1;
-
-      context.logger.info(`Updating profile for returning user (${profile.interactionCount} interactions)`);
-    } else {
-      // New user - create profile
-      profile = {
-        userId: userId,
-        preferences: {},
-        created: new Date().toISOString(),
-        interactionCount: 1
-      };
-
-      context.logger.info('Creating new user profile');
-    }
-
-    // Update preferences if provided
-    if (theme) {
-      profile.preferences.theme = theme;
-    }
-    if (language) {
-      profile.preferences.language = language;
-    }
-
-    // Save profile WITHOUT TTL (permanent storage)
-    await context.kv.set(bucket, userId, profile);
-
-    context.logger.info('Saved user profile (permanent storage)');
-
-    // Return updated profile
-    return response.json({
-      message: 'Profile updated successfully',
-      profile: profile,
-      storage: 'permanent (no TTL)'
-    });
-
-  } catch (error) {
-    context.logger.error('Error managing user profile:', error);
-    return new Response('Internal Server Error', { status: 500 });
-  }
-}
diff --git a/examples/training/03-memory/step2-vector-basics.py b/examples/training/03-memory/step2-vector-basics.py
new file mode 100644
index 00000000..2c75bc2b
--- /dev/null
+++ b/examples/training/03-memory/step2-vector-basics.py
@@ -0,0 +1,83 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+
+def welcome():
+    return {
+        'welcome': 'Perform semantic search using vector storage to find relevant facts.',
+        'prompts': [
+            {'data': 'What is Agentuity?', 'contentType': 'text/plain'},
+            {'data': 'Tell me about vector storage', 'contentType': 'text/plain'},
+            {'data': 'How does semantic search work?', 'contentType': 'text/plain'}
+        ]
+    }
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = 'demo-knowledge'
+    user_input = await request.data.text()
+
+    # Sample facts to store
+    facts = [
+        {
+            'key': 'fact-1',
+            'document': 'Agentuity is an agent-native cloud platform designed for AI agents',
+            'metadata': {'category': 'platform', 'topic': 'overview'}
+        },
+        {
+            'key': 'fact-2',
+            'document': 'Vector storage enables semantic search by meaning, not keywords',
+            'metadata': {'category': 'features', 'topic': 'storage'}
+        },
+        {
+            'key': 'fact-3',
+            'document': 'Key-value storage is perfect for session state and caching',
+            'metadata': {'category': 'features', 'topic': 'storage'}
+        }
+    ]
+
+    # Upsert facts into vector storage
+    # Python: Pass array of documents
+    await context.vector.upsert(bucket, facts)
+
+    context.logger.info(f'Upserted {len(facts)} facts to vector storage')
+
+    # Search for relevant facts using semantic similarity
+    search_results = await context.vector.search(
+        bucket,
+        query=user_input,
+        limit=3,
+        similarity=0.5  # Minimum similarity threshold (0-1)
+    )
+
+    context.logger.info(f'Found {len(search_results)} results')
+
+    # Handle empty results
+    if len(search_results) == 0:
+        return response.json({
+            'message': 'No relevant facts found',
+            'query': user_input,
+            'trySearching': "Try: 'What is Agentuity?' or 'How does vector storage work?'"
+        })
+
+    # Format results with similarity scores
+    # Note: Search results don't include the document text by default
+    # Store important text in metadata if you need to retrieve it
+    formatted_results = [
+        {
+            'id': result.id,
+            'key': result.key,
+            'category': result.metadata.get('category') if result.metadata else None,
+            'similarity': f'{result.similarity:.2f}'
+        }
+        for result in search_results
+    ]
+
+    # Cleanup demo data
+    for fact in facts:
+        await context.vector.delete(bucket, fact['key'])
+
+    context.logger.info('Cleaned up demo data')
+
+    return response.json({
+        'query': user_input,
+        'resultsFound': len(search_results),
+        'results': formatted_results
+    })
diff --git a/examples/training/03-memory/step2-vector-basics.ts b/examples/training/03-memory/step2-vector-basics.ts
new file mode 100644
index 00000000..a996d861
--- /dev/null
+++ b/examples/training/03-memory/step2-vector-basics.ts
@@ -0,0 +1,87 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-knowledge';
+  const userInput = await request.data.text();
+
+  // Sample facts to store
+  const facts = [
+    {
+      key: 'fact-1',
+      document: 'Agentuity is an agent-native cloud platform designed for AI agents',
+      metadata: { category: 'platform', topic: 'overview' }
+    },
+    {
+      key: 'fact-2',
+      document: 'Vector storage enables semantic search by meaning, not keywords',
+      metadata: { category: 'features', topic: 'storage' }
+    },
+    {
+      key: 'fact-3',
+      document: 'Key-value storage is perfect for session state and caching',
+      metadata: { category: 'features', topic: 'storage' }
+    }
+  ];
+
+  // Upsert facts into vector storage
+  // TypeScript: Pass individual objects (not an array)
+  for (const fact of facts) {
+    await context.vector.upsert(bucket, fact);
+  }
+
+  context.logger.info(`Upserted ${facts.length} facts to vector storage`);
+
+  // Search for relevant facts using semantic similarity
+  const searchResults = await context.vector.search(bucket, {
+    query: userInput,
+    limit: 3,
+    similarity: 0.5 // Minimum similarity threshold (0-1)
+  });
+
+  context.logger.info(`Found ${searchResults.length} results`);
+
+  // Handle empty results
+  if (searchResults.length === 0) {
+    return response.json({
+      message: 'No relevant facts found',
+      query: userInput,
+      trySearching: 'Try: "What is Agentuity?" or "How does vector storage work?"'
+    });
+  }
+
+  // Format results with similarity scores
+  // Note: Search results don't include the document text by default
+  // Store important text in metadata if you need to retrieve it
+  const formattedResults = searchResults.map(result => ({
+    id: result.id,
+    key: result.key,
+    category: result.metadata?.category,
+    similarity: result.similarity.toFixed(2)
+  }));
+
+  // Cleanup demo data
+  for (const fact of facts) {
+    await context.vector.delete(bucket, fact.key);
+  }
+
+  context.logger.info('Cleaned up demo data');
+
+  return response.json({
+    query: userInput,
+    resultsFound: searchResults.length,
+    results: formattedResults
+  });
+}
+
+export const welcome = () => ({
+  welcome: 'Perform semantic search using vector storage to find relevant facts.',
+  prompts: [
+    { data: 'What is Agentuity?', contentType: 'text/plain' },
+    { data: 'Tell me about vector storage', contentType: 'text/plain' },
+    { data: 'How does semantic search work?', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/03-memory/step3-vector-basics.py b/examples/training/03-memory/step3-vector-basics.py
deleted file mode 100644
index 3c3540fc..00000000
--- a/examples/training/03-memory/step3-vector-basics.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from aiohttp.web import Response
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    bucket = "demo-knowledge"
-
-    try:
-        user_input = await request.data.text()
-
-        # Sample facts to store (in production, these would come from your knowledge base)
-        facts = [
-            {
-                "key": "fact-1",
-                "document": "Agentuity is an agent-native cloud platform designed for AI agents",
-                "metadata": {"category": "platform", "topic": "overview"}
-            },
-            {
-                "key": "fact-2",
-                "document": "Vector storage enables semantic search by meaning, not keywords",
-                "metadata": {"category": "features", "topic": "storage"}
-            },
-            {
-                "key": "fact-3",
-                "document": "Key-value storage is perfect for session state and caching",
-                "metadata": {"category": "features", "topic": "storage"}
-            }
-        ]
-
-        # Upsert facts into vector storage
-        # Python: Pass array of documents
-        await context.vector.upsert(bucket, facts)
-
-        context.logger.info(f"Upserted {len(facts)} facts to vector storage")
-
-        # Search for relevant facts using semantic similarity
-        search_results = await context.vector.search(
-            bucket,
-            query=user_input,
-            limit=3,
-            similarity=0.5  # Minimum similarity threshold (0-1)
-        )
-
-        context.logger.info(f"Found {len(search_results)} results")
-
-        # Handle empty results
-        if len(search_results) == 0:
-            return response.json({
-                "message": "No relevant facts found",
-                "query": user_input,
-                "trySearching": "Try: 'What is Agentuity?' or 'How does vector storage work?'"
-            })
-
-        # Format results with similarity scores
-        # Note: Search results don't include the document text by default
-        # Store important text in metadata if you need to retrieve it
-        formatted_results = [
-            {
-                "id": result.id,
-                "key": result.key,
-                "category": result.metadata.get("category") if result.metadata else None,
-                "similarity": f"{result.similarity:.2f}"
-            }
-            for result in search_results
-        ]
-
-        # Cleanup demo data
-        for fact in facts:
-            await context.vector.delete(bucket, fact["key"])
-
-        context.logger.info("Cleaned up demo data")
-
-        return response.json({
-            "query": user_input,
-            "resultsFound": len(search_results),
-            "results": formatted_results
-        })
-
-    except Exception as error:
-        context.logger.error(f"Error with vector storage: {error}")
-        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step3-vector-basics.ts b/examples/training/03-memory/step3-vector-basics.ts
deleted file mode 100644
index c387f3fb..00000000
--- a/examples/training/03-memory/step3-vector-basics.ts
+++ /dev/null
@@ -1,85 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  const bucket = 'demo-knowledge';
-
-  try {
-    const userInput = await request.data.text();
-
-    // Sample facts to store (in production, these would come from your knowledge base)
-    const facts = [
-      {
-        key: 'fact-1',
-        document: 'Agentuity is an agent-native cloud platform designed for AI agents',
-        metadata: { category: 'platform', topic: 'overview' }
-      },
-      {
-        key: 'fact-2',
-        document: 'Vector storage enables semantic search by meaning, not keywords',
-        metadata: { category: 'features', topic: 'storage' }
-      },
-      {
-        key: 'fact-3',
-        document: 'Key-value storage is perfect for session state and caching',
-        metadata: { category: 'features', topic: 'storage' }
-      }
-    ];
-
-    // Upsert facts into vector storage
-    // TypeScript: Pass individual objects (not an array)
-    for (const fact of facts) {
-      await context.vector.upsert(bucket, fact);
-    }
-
-    context.logger.info(`Upserted ${facts.length} facts to vector storage`);
-
-    // Search for relevant facts using semantic similarity
-    const searchResults = await context.vector.search(bucket, {
-      query: userInput,
-      limit: 3,
-      similarity: 0.5 // Minimum similarity threshold (0-1)
-    });
-
-    context.logger.info(`Found ${searchResults.length} results`);
-
-    // Handle empty results
-    if (searchResults.length === 0) {
-      return response.json({
-        message: 'No relevant facts found',
-        query: userInput,
-        trySearching: 'Try: "What is Agentuity?" or "How does vector storage work?"'
-      });
-    }
-
-    // Format results with similarity scores
-    // Note: Search results don't include the document text by default
-    // Store important text in metadata if you need to retrieve it
-    const formattedResults = searchResults.map(result => ({
-      id: result.id,
-      key: result.key,
-      category: result.metadata?.category,
-      similarity: result.similarity.toFixed(2)
-    }));
-
-    // Cleanup demo data
-    for (const fact of facts) {
-      await context.vector.delete(bucket, fact.key);
-    }
-
-    context.logger.info('Cleaned up demo data');
-
-    return response.json({
-      query: userInput,
-      resultsFound: searchResults.length,
-      results: formattedResults
-    });
-
-  } catch (error) {
-    context.logger.error('Error with vector storage:', error);
-    return new Response('Internal Server Error', { status: 500 });
-  }
-}
diff --git a/examples/training/03-memory/step3-vector-filtering.py b/examples/training/03-memory/step3-vector-filtering.py
new file mode 100644
index 00000000..88580fb0
--- /dev/null
+++ b/examples/training/03-memory/step3-vector-filtering.py
@@ -0,0 +1,92 @@
+from agentuity import AgentRequest, AgentResponse, AgentContext
+import json
+
+def welcome():
+    return {
+        'welcome': 'Search with semantic similarity + metadata filters (category, price, availability).',
+        'prompts': [
+            {'data': json.dumps({'query': 'desk furniture'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'query': 'office setup', 'category': 'furniture'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'query': 'electronics', 'inStock': True}), 'contentType': 'application/json'}
+        ]
+    }
+
+async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
+    bucket = 'demo-products'
+    data = await request.data.json()
+    query = data.get('query')
+    category = data.get('category')
+    in_stock = data.get('inStock')
+
+    # Sample product data
+    products = [
+        {
+            'key': 'prod-1',
+            'document': 'Ergonomic office chair with lumbar support',
+            'metadata': {'category': 'furniture', 'price': 299, 'inStock': True}
+        },
+        {
+            'key': 'prod-2',
+            'document': 'Standing desk with adjustable height',
+            'metadata': {'category': 'furniture', 'price': 499, 'inStock': False}
+        },
+        {
+            'key': 'prod-3',
+            'document': 'Wireless keyboard and mouse combo',
+            'metadata': {'category': 'electronics', 'price': 79, 'inStock': True}
+        },
+        {
+            'key': 'prod-4',
+            'document': 'LED desk lamp with USB charging',
+            'metadata': {'category': 'electronics', 'price': 45, 'inStock': True}
+        }
+    ]
+
+    # Upsert products
+    await context.vector.upsert(bucket, products)
+
+    context.logger.info(f'Upserted {len(products)} products')
+
+    # Build metadata filters
+    metadata_filters = {}
+    if category:
+        metadata_filters['category'] = category
+    if in_stock is not None:
+        metadata_filters['inStock'] = in_stock
+
+    # Search with semantic similarity + metadata filters
+    search_results = await context.vector.search(
+        bucket,
+        query=query or 'office furniture',
+        limit=10,
+        similarity=0.3,  # Lower threshold for broader matches
+        metadata=metadata_filters
+    )
+
+    context.logger.info(
+        f"Found {len(search_results)} results matching filters: {metadata_filters}"
+    )
+
+    # Format results
+    formatted_results = [
+        {
+            'id': result.id,
+            'key': result.key,
+            'category': result.metadata.get('category') if result.metadata else None,
+            'price': result.metadata.get('price') if result.metadata else None,
+            'inStock': result.metadata.get('inStock') if result.metadata else None,
+            'similarity': f'{result.similarity:.2f}'
+        }
+        for result in search_results
+    ]
+
+    # Cleanup demo data
+    for product in products:
+        await context.vector.delete(bucket, product['key'])
+
+    return response.json({
+        'query': query or 'office furniture',
+        'filters': metadata_filters,
+        'resultsFound': len(search_results),
+        'results': formatted_results
+    })
diff --git a/examples/training/03-memory/step3-vector-filtering.ts b/examples/training/03-memory/step3-vector-filtering.ts
new file mode 100644
index 00000000..df72e479
--- /dev/null
+++ b/examples/training/03-memory/step3-vector-filtering.ts
@@ -0,0 +1,94 @@
+import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
+
+export default async function Agent(
+  request: AgentRequest,
+  response: AgentResponse,
+  context: AgentContext
+) {
+  const bucket = 'demo-products';
+  const data = await request.data.json();
+  const { query, category, inStock } = data;
+
+  // Sample product data
+  const products = [
+    {
+      key: 'prod-1',
+      document: 'Ergonomic office chair with lumbar support',
+      metadata: { category: 'furniture', price: 299, inStock: true }
+    },
+    {
+      key: 'prod-2',
+      document: 'Standing desk with adjustable height',
+      metadata: { category: 'furniture', price: 499, inStock: false }
+    },
+    {
+      key: 'prod-3',
+      document: 'Wireless keyboard and mouse combo',
+      metadata: { category: 'electronics', price: 79, inStock: true }
+    },
+    {
+      key: 'prod-4',
+      document: 'LED desk lamp with USB charging',
+      metadata: { category: 'electronics', price: 45, inStock: true }
+    }
+  ];
+
+  // Upsert products
+  for (const product of products) {
+    await context.vector.upsert(bucket, product);
+  }
+
+  context.logger.info(`Upserted ${products.length} products`);
+
+  // Build metadata filters
+  const metadataFilters: Record<string, any> = {};
+  if (category) {
+    metadataFilters.category = category;
+  }
+  if (inStock !== undefined) {
+    metadataFilters.inStock = inStock;
+  }
+
+  // Search with semantic similarity + metadata filters
+  const searchResults = await context.vector.search(bucket, {
+    query: query || 'office furniture',
+    limit: 10,
+    similarity: 0.3, // Lower threshold for broader matches
+    metadata: metadataFilters
+  });
+
+  context.logger.info(
+    `Found ${searchResults.length} results matching filters: ${JSON.stringify(metadataFilters)}`
+  );
+
+  // Format results
+  const formattedResults = searchResults.map(result => ({
+    id: result.id,
+    key: result.key,
+    category: result.metadata?.category,
+    price: result.metadata?.price,
+    inStock: result.metadata?.inStock,
+    similarity: result.similarity.toFixed(2)
+  }));
+
+  // Cleanup demo data
+  for (const product of products) {
+    await context.vector.delete(bucket, product.key);
+  }
+
+  return response.json({
+    query: query || 'office furniture',
+    filters: metadataFilters,
+    resultsFound: searchResults.length,
+    results: formattedResults
+  });
+}
+
+export const welcome = () => ({
+  welcome: 'Search with semantic similarity + metadata filters (category, price, availability).',
+  prompts: [
+    { data: JSON.stringify({ query: 'desk furniture' }), contentType: 'application/json' },
+    { data: JSON.stringify({ query: 'office setup', category: 'furniture' }), contentType: 'application/json' },
+    { data: JSON.stringify({ query: 'electronics', inStock: true }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/03-memory/step5-object-storage.py b/examples/training/03-memory/step4-object-storage.py
similarity index 84%
rename from examples/training/03-memory/step5-object-storage.py
rename to examples/training/03-memory/step4-object-storage.py
index 7002cc4a..f0798527 100644
--- a/examples/training/03-memory/step5-object-storage.py
+++ b/examples/training/03-memory/step4-object-storage.py
@@ -50,3 +50,12 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
     except Exception as error:
         context.logger.error(f"Error with object storage: {error}")
         return Response(text="Internal Server Error", status=500)
+
+def welcome():
+    return {
+        'welcome': 'Store files in object storage and generate temporary public URLs.',
+        'prompts': [
+            {'data': 'This is a sample document content', 'contentType': 'text/plain'},
+            {'data': 'Another test file with different content', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/03-memory/step5-object-storage.ts b/examples/training/03-memory/step4-object-storage.ts
similarity index 85%
rename from examples/training/03-memory/step5-object-storage.ts
rename to examples/training/03-memory/step4-object-storage.ts
index 04565df8..df43537f 100644
--- a/examples/training/03-memory/step5-object-storage.ts
+++ b/examples/training/03-memory/step4-object-storage.ts
@@ -55,3 +55,11 @@ export default async function Agent(
     return new Response('Internal Server Error', { status: 500 });
   }
 }
+
+export const welcome = () => ({
+  welcome: 'Store files in object storage and generate temporary public URLs.',
+  prompts: [
+    { data: 'This is a sample document content', contentType: 'text/plain' },
+    { data: 'Another test file with different content', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/03-memory/step4-vector-filtering.py b/examples/training/03-memory/step4-vector-filtering.py
deleted file mode 100644
index a4839912..00000000
--- a/examples/training/03-memory/step4-vector-filtering.py
+++ /dev/null
@@ -1,88 +0,0 @@
-from agentuity import AgentRequest, AgentResponse, AgentContext
-from aiohttp.web import Response
-
-async def run(request: AgentRequest, response: AgentResponse, context: AgentContext):
-    bucket = "demo-products"
-
-    try:
-        data = await request.data.json()
-        query = data.get("query")
-        category = data.get("category")
-        in_stock = data.get("inStock")
-
-        # Sample product data
-        products = [
-            {
-                "key": "prod-1",
-                "document": "Ergonomic office chair with lumbar support",
-                "metadata": {"category": "furniture", "price": 299, "inStock": True}
-            },
-            {
-                "key": "prod-2",
-                "document": "Standing desk with adjustable height",
-                "metadata": {"category": "furniture", "price": 499, "inStock": False}
-            },
-            {
-                "key": "prod-3",
-                "document": "Wireless keyboard and mouse combo",
-                "metadata": {"category": "electronics", "price": 79, "inStock": True}
-            },
-            {
-                "key": "prod-4",
-                "document": "LED desk lamp with USB charging",
-                "metadata": {"category": "electronics", "price": 45, "inStock": True}
-            }
-        ]
-
-        # Upsert products
-        await context.vector.upsert(bucket, products)
-
-        context.logger.info(f"Upserted {len(products)} products")
-
-        # Build metadata filters
-        metadata_filters = {}
-        if category:
-            metadata_filters["category"] = category
-        if in_stock is not None:
-            metadata_filters["inStock"] = in_stock
-
-        # Search with semantic similarity + metadata filters
-        search_results = await context.vector.search(
-            bucket,
-            query=query or "office furniture",
-            limit=10,
-            similarity=0.3,  # Lower threshold for broader matches
-            metadata=metadata_filters
-        )
-
-        context.logger.info(
-            f"Found {len(search_results)} results matching filters: {metadata_filters}"
-        )
-
-        # Format results
-        formatted_results = [
-            {
-                "id": result.id,
-                "key": result.key,
-                "category": result.metadata.get("category") if result.metadata else None,
-                "price": result.metadata.get("price") if result.metadata else None,
-                "inStock": result.metadata.get("inStock") if result.metadata else None,
-                "similarity": f"{result.similarity:.2f}"
-            }
-            for result in search_results
-        ]
-
-        # Cleanup demo data
-        for product in products:
-            await context.vector.delete(bucket, product["key"])
-
-        return response.json({
-            "query": query or "office furniture",
-            "filters": metadata_filters,
-            "resultsFound": len(search_results),
-            "results": formatted_results
-        })
-
-    except Exception as error:
-        context.logger.error(f"Error with filtered vector search: {error}")
-        return Response(text="Internal Server Error", status=500)
diff --git a/examples/training/03-memory/step4-vector-filtering.ts b/examples/training/03-memory/step4-vector-filtering.ts
deleted file mode 100644
index 657078a0..00000000
--- a/examples/training/03-memory/step4-vector-filtering.ts
+++ /dev/null
@@ -1,92 +0,0 @@
-import type { AgentRequest, AgentResponse, AgentContext } from "@agentuity/sdk";
-
-export default async function Agent(
-  request: AgentRequest,
-  response: AgentResponse,
-  context: AgentContext
-) {
-  const bucket = 'demo-products';
-
-  try {
-    const data = await request.data.json();
-    const { query, category, inStock } = data;
-
-    // Sample product data
-    const products = [
-      {
-        key: 'prod-1',
-        document: 'Ergonomic office chair with lumbar support',
-        metadata: { category: 'furniture', price: 299, inStock: true }
-      },
-      {
-        key: 'prod-2',
-        document: 'Standing desk with adjustable height',
-        metadata: { category: 'furniture', price: 499, inStock: false }
-      },
-      {
-        key: 'prod-3',
-        document: 'Wireless keyboard and mouse combo',
-        metadata: { category: 'electronics', price: 79, inStock: true }
-      },
-      {
-        key: 'prod-4',
-        document: 'LED desk lamp with USB charging',
-        metadata: { category: 'electronics', price: 45, inStock: true }
-      }
-    ];
-
-    // Upsert products
-    for (const product of products) {
-      await context.vector.upsert(bucket, product);
-    }
-
-    context.logger.info(`Upserted ${products.length} products`);
-
-    // Build metadata filters
-    const metadataFilters: Record<string, any> = {};
-    if (category) {
-      metadataFilters.category = category;
-    }
-    if (inStock !== undefined) {
-      metadataFilters.inStock = inStock;
-    }
-
-    // Search with semantic similarity + metadata filters
-    const searchResults = await context.vector.search(bucket, {
-      query: query || 'office furniture',
-      limit: 10,
-      similarity: 0.3, // Lower threshold for broader matches
-      metadata: metadataFilters
-    });
-
-    context.logger.info(
-      `Found ${searchResults.length} results matching filters: ${JSON.stringify(metadataFilters)}`
-    );
-
-    // Format results
-    const formattedResults = searchResults.map(result => ({
-      id: result.id,
-      key: result.key,
-      category: result.metadata?.category,
-      price: result.metadata?.price,
-      inStock: result.metadata?.inStock,
-      similarity: result.similarity.toFixed(2)
-    }));
-
-    // Cleanup demo data
-    for (const product of products) {
-      await context.vector.delete(bucket, product.key);
-    }
-
-    return response.json({
-      query: query || 'office furniture',
-      filters: metadataFilters,
-      resultsFound: searchResults.length,
-      results: formattedResults
-    });
-
-  } catch (error) {
-    context.logger.error('Error with filtered vector search:', error);
-    return new Response('Internal Server Error', { status: 500 });
-  }
-}
diff --git a/examples/training/04-agent-communication/step1-basic-handoff.py b/examples/training/04-agent-communication/step1-basic-handoff.py
index 6857995e..1127a54d 100644
--- a/examples/training/04-agent-communication/step1-basic-handoff.py
+++ b/examples/training/04-agent-communication/step1-basic-handoff.py
@@ -6,3 +6,13 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
     context.logger.info('Delegating to specialist agent')
 
     return response.handoff({"name": "specialist-agent"})
+
+def welcome():
+    import json
+    return {
+        'welcome': 'Learn basic agent delegation using response.handoff() to transfer control.',
+        'prompts': [
+            {'data': 'Delegate this task', 'contentType': 'text/plain'},
+            {'data': json.dumps({'task': 'process'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/04-agent-communication/step1-basic-handoff.ts b/examples/training/04-agent-communication/step1-basic-handoff.ts
index 1d3a7260..4f7bcec1 100644
--- a/examples/training/04-agent-communication/step1-basic-handoff.ts
+++ b/examples/training/04-agent-communication/step1-basic-handoff.ts
@@ -11,3 +11,11 @@ export default async function Agent(
 
   return response.handoff({ name: 'specialist-agent' });
 }
+
+export const welcome = () => ({
+  welcome: 'Learn basic agent delegation using response.handoff() to transfer control.',
+  prompts: [
+    { data: 'Delegate this task', contentType: 'text/plain' },
+    { data: JSON.stringify({ task: 'process' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/04-agent-communication/step2-data-formats.py b/examples/training/04-agent-communication/step2-data-formats.py
index efef4c5b..8750f8c6 100644
--- a/examples/training/04-agent-communication/step2-data-formats.py
+++ b/examples/training/04-agent-communication/step2-data-formats.py
@@ -27,3 +27,13 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
     # Uncomment to use:
     # context.logger.info('Example: Forwarding original request')
     # return response.handoff({"name": "passthrough-agent"})
+
+def welcome():
+    import json
+    return {
+        'welcome': 'Pass different data formats (text, JSON) when handing off to other agents.',
+        'prompts': [
+            {'data': json.dumps({'message': 'First request'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'message': 'Second request', 'priority': 'high'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/04-agent-communication/step2-data-formats.ts b/examples/training/04-agent-communication/step2-data-formats.ts
index 0cd668b6..53916a9d 100644
--- a/examples/training/04-agent-communication/step2-data-formats.ts
+++ b/examples/training/04-agent-communication/step2-data-formats.ts
@@ -32,3 +32,11 @@ export default async function Agent(
   // context.logger.info('Example: Forwarding original request');
   // return response.handoff({ name: 'passthrough-agent' });
 }
+
+export const welcome = () => ({
+  welcome: 'Pass different data formats (text, JSON) when handing off to other agents.',
+  prompts: [
+    { data: JSON.stringify({ message: 'First request' }), contentType: 'application/json' },
+    { data: JSON.stringify({ message: 'Second request', priority: 'high' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/04-agent-communication/step3-run-and-wait.py b/examples/training/04-agent-communication/step3-run-and-wait.py
index e27d7b79..88d0b384 100644
--- a/examples/training/04-agent-communication/step3-run-and-wait.py
+++ b/examples/training/04-agent-communication/step3-run-and-wait.py
@@ -24,3 +24,13 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
         "processed": result,
         "handledBy": context.agent.name
     })
+
+def welcome():
+    import json
+    return {
+        'welcome': 'Use getAgent() and run() to call another agent and wait for its response.',
+        'prompts': [
+            {'data': json.dumps({'message': 'Hello from coordinator'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'message': 'Process this data'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/04-agent-communication/step3-run-and-wait.ts b/examples/training/04-agent-communication/step3-run-and-wait.ts
index 7b68b47c..55b9c270 100644
--- a/examples/training/04-agent-communication/step3-run-and-wait.ts
+++ b/examples/training/04-agent-communication/step3-run-and-wait.ts
@@ -31,3 +31,11 @@ export default async function Agent(
     handledBy: context.agent.name
   });
 }
+
+export const welcome = () => ({
+  welcome: 'Use getAgent() and run() to call another agent and wait for its response.',
+  prompts: [
+    { data: JSON.stringify({ message: 'Hello from coordinator' }), contentType: 'application/json' },
+    { data: JSON.stringify({ message: 'Process this data' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/04-agent-communication/step4-parallel-execution.py b/examples/training/04-agent-communication/step4-parallel-execution.py
index e076fd0d..dc594d83 100644
--- a/examples/training/04-agent-communication/step4-parallel-execution.py
+++ b/examples/training/04-agent-communication/step4-parallel-execution.py
@@ -31,3 +31,13 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
         "newsResults": news_data,
         "totalSources": 2
     })
+
+def welcome():
+    import json
+    return {
+        'welcome': 'Execute multiple agents in parallel using asyncio.gather() for faster results.',
+        'prompts': [
+            {'data': json.dumps({'query': 'artificial intelligence'}), 'contentType': 'application/json'},
+            {'data': json.dumps({'query': 'cloud computing'}), 'contentType': 'application/json'}
+        ]
+    }
diff --git a/examples/training/04-agent-communication/step4-parallel-execution.ts b/examples/training/04-agent-communication/step4-parallel-execution.ts
index c958055e..8b126350 100644
--- a/examples/training/04-agent-communication/step4-parallel-execution.ts
+++ b/examples/training/04-agent-communication/step4-parallel-execution.ts
@@ -34,3 +34,11 @@ export default async function Agent(
     totalSources: 2
   });
 }
+
+export const welcome = () => ({
+  welcome: 'Execute multiple agents in parallel using Promise.all() for faster results.',
+  prompts: [
+    { data: JSON.stringify({ query: 'artificial intelligence' }), contentType: 'application/json' },
+    { data: JSON.stringify({ query: 'cloud computing' }), contentType: 'application/json' }
+  ]
+});
diff --git a/examples/training/04-agent-communication/step5-structured-responses.py b/examples/training/04-agent-communication/step5-structured-responses.py
index 09bb59a7..b3a8c4c7 100644
--- a/examples/training/04-agent-communication/step5-structured-responses.py
+++ b/examples/training/04-agent-communication/step5-structured-responses.py
@@ -66,3 +66,13 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
     result = await target_agent.run(user_message)
 
     return response.text(await result.data.text())
+
+def welcome():
+    return {
+        'welcome': 'Use Pydantic schemas with AI to make intelligent routing decisions with structured output.',
+        'prompts': [
+            {'data': 'I need help with my account password', 'contentType': 'text/plain'},
+            {'data': 'Can you tell me about pricing plans?', 'contentType': 'text/plain'},
+            {'data': 'The API is returning 500 errors', 'contentType': 'text/plain'}
+        ]
+    }
diff --git a/examples/training/04-agent-communication/step5-structured-responses.ts b/examples/training/04-agent-communication/step5-structured-responses.ts
index b2ebcf59..95aa6e19 100644
--- a/examples/training/04-agent-communication/step5-structured-responses.ts
+++ b/examples/training/04-agent-communication/step5-structured-responses.ts
@@ -52,3 +52,12 @@ routing decision.`,
 
   return response.text(await result.data.text());
 }
+
+export const welcome = () => ({
+  welcome: 'Use AI SDK with Zod schemas to make intelligent routing decisions with structured output.',
+  prompts: [
+    { data: 'I need help with my account password', contentType: 'text/plain' },
+    { data: 'Can you tell me about pricing plans?', contentType: 'text/plain' },
+    { data: 'The API is returning 500 errors', contentType: 'text/plain' }
+  ]
+});
diff --git a/examples/training/05-observability-guardrails/step1-child-loggers.py b/examples/training/05-observability-guardrails/step1-child-loggers.py
index 54e6ed1d..9f416aab 100644
--- a/examples/training/05-observability-guardrails/step1-child-loggers.py
+++ b/examples/training/05-observability-guardrails/step1-child-loggers.py
@@ -37,5 +37,5 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
 
     except Exception as error:
         # Error logs also include the context
-        context.logger.error(f"Processing failed request_id={request_id} user_id={user_id} error={str(error)}")
-        return response.json({"error": "Processing failed"}, status=500)
+        context.logger.error(f"Error processing request request_id={request_id} user_id={user_id} error={str(error)}")
+        raise  # SDK returns 500 automatically
diff --git a/examples/training/05-observability-guardrails/step1-child-loggers.ts b/examples/training/05-observability-guardrails/step1-child-loggers.ts
index 2d9ad8c8..39982a1d 100644
--- a/examples/training/05-observability-guardrails/step1-child-loggers.ts
+++ b/examples/training/05-observability-guardrails/step1-child-loggers.ts
@@ -44,7 +44,7 @@ export default async function Agent(
 
   } catch (error) {
     // Error logs also include the child logger context
-    requestLogger.error('Processing failed', error);
-    return response.json({ error: 'Processing failed' }, { status: 500 });
+    requestLogger.error('Error processing request:', error);
+    throw error; // SDK returns 500 automatically
   }
 }
diff --git a/examples/training/05-observability-guardrails/step2-input-validation.py b/examples/training/05-observability-guardrails/step2-input-validation.py
index e8b04b74..6680ecae 100644
--- a/examples/training/05-observability-guardrails/step2-input-validation.py
+++ b/examples/training/05-observability-guardrails/step2-input-validation.py
@@ -2,6 +2,8 @@
 from pydantic import BaseModel, Field, ValidationError
 from typing import Optional, Literal
 from datetime import datetime
+from aiohttp.web import Response
+import json
 
 # Define Pydantic model for user preferences
 class UserPreferences(BaseModel):
@@ -24,11 +26,15 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
     except ValidationError as e:
         context.logger.warning(f"Request validation failed errors={e.error_count()}")
 
-        return response.json({
-            "error": "Invalid request",
-            "details": [{"field": err["loc"][-1], "message": err["msg"]}
-                        for err in e.errors()]
-        }, status=400)
+        return Response(
+            text=json.dumps({
+                "error": "Invalid request",
+                "details": [{"field": err["loc"][-1], "message": err["msg"]}
+                            for err in e.errors()]
+            }),
+            status=400,
+            content_type='application/json'
+        )
 
     # Use validated data (type-safe)
     query = validated.query
diff --git a/examples/training/05-observability-guardrails/step2-input-validation.ts b/examples/training/05-observability-guardrails/step2-input-validation.ts
index fe61e7e0..cd8d552a 100644
--- a/examples/training/05-observability-guardrails/step2-input-validation.ts
+++ b/examples/training/05-observability-guardrails/step2-input-validation.ts
@@ -29,10 +29,13 @@ export default async function Agent(
       errors: result.error.issues
     });
 
-    return response.json({
-      error: 'Invalid request',
-      details: result.error.issues
-    }, { status: 400 });
+    return new Response(
+      JSON.stringify({
+        error: 'Invalid request',
+        details: result.error.issues
+      }),
+      { status: 400, headers: { 'Content-Type': 'application/json' } }
+    );
   }
 
   // Use validated data (type-safe)
diff --git a/examples/training/05-observability-guardrails/step3-ai-output-validation.py b/examples/training/05-observability-guardrails/step3-ai-output-validation.py
index d8367006..9730d5bf 100644
--- a/examples/training/05-observability-guardrails/step3-ai-output-validation.py
+++ b/examples/training/05-observability-guardrails/step3-ai-output-validation.py
@@ -2,6 +2,7 @@
 from pydantic import BaseModel, Field, ValidationError
 from typing import Literal
 from datetime import datetime
+from aiohttp.web import Response
 import json
 
 # Define Pydantic model for AI-generated sentiment analysis
@@ -55,12 +56,16 @@ async def run(request: AgentRequest, response: AgentResponse, context: AgentCont
 
         except (json.JSONDecodeError, ValidationError) as e:
             context.logger.error(f"AI returned invalid data: {str(e)}")
-            return response.json({
-                "error": "AI generated invalid response format"
-            }, status=500)
+            return Response(
+                text=json.dumps({"error": "AI response validation failed"}),
+                status=500,
+                content_type='application/json'
+            )
 
     except Exception as error:
         context.logger.error(f"AI generation failed: {str(error)}")
-        return response.json({
-            "error": "Failed to generate analysis"
-        }, status=500)
+        return Response(
+            text=json.dumps({"error": "AI generation failed"}),
+            status=500,
+            content_type='application/json'
+        )
diff --git a/examples/training/05-observability-guardrails/step3-ai-output-validation.ts b/examples/training/05-observability-guardrails/step3-ai-output-validation.ts
index 23f0c372..5e461016 100644
--- a/examples/training/05-observability-guardrails/step3-ai-output-validation.ts
+++ b/examples/training/05-observability-guardrails/step3-ai-output-validation.ts
@@ -48,8 +48,9 @@ export default async function Agent(
 
   } catch (error) {
     context.logger.error('AI generation failed', error);
-    return response.json({
-      error: 'Failed to generate analysis'
-    }, { status: 500 });
+    return new Response(
+      JSON.stringify({ error: 'AI generation failed' }),
+      { status: 500, headers: { 'Content-Type': 'application/json' } }
+    );
   }
 }

From b4600f83a225b9beca8296abfda525cdc3a4046e Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Mon, 27 Oct 2025 15:28:44 -0700
Subject: [PATCH 12/13] Update lab links

---
 content/Training/developers/04-agent-collaboration.mdx | 7 ++++---
 content/Training/developers/07-sandbox-capstone.mdx    | 7 ++++---
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/content/Training/developers/04-agent-collaboration.mdx b/content/Training/developers/04-agent-collaboration.mdx
index 01c95458..da2cac02 100644
--- a/content/Training/developers/04-agent-collaboration.mdx
+++ b/content/Training/developers/04-agent-collaboration.mdx
@@ -393,10 +393,11 @@ Ready to implement this project? You'll need multiple specialized agents for the
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     TypeScript
   </a>
-  <div className="inline-flex items-center gap-2 px-4 py-3 bg-gray-400 text-white rounded-lg no-underline text-sm font-medium cursor-not-allowed opacity-75">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/04-concierge-py" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
-    Python (Coming Soon)
-  </div>
+    Python
+  </a>
 </div>
 
 <Callout type="warning">
diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index e0ab1bb9..186793d7 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -299,10 +299,11 @@ Ready to implement this project? Follow our complete examples:
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     TypeScript
   </a>
-  <div className="inline-flex items-center gap-2 px-4 py-3 bg-gray-400 text-white rounded-lg no-underline text-sm font-medium cursor-not-allowed opacity-75">
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/agents/deep_research_py" target="_blank" rel="noopener noreferrer"
+     className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
-    Python (Coming Soon)
-  </div>
+    Python
+  </a>
 </div>
 
 ### What This System Demonstrates

From e1ca28f7184b5724c62c808af370876c9308f89c Mon Sep 17 00:00:00 2001
From: parteeksingh24 <parteek.singh24@gmail.com>
Date: Mon, 27 Oct 2025 16:28:30 -0700
Subject: [PATCH 13/13] Reorganize Module 7 labs

---
 content/Training/developers/07-sandbox-capstone.mdx | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/Training/developers/07-sandbox-capstone.mdx b/content/Training/developers/07-sandbox-capstone.mdx
index 186793d7..facd8f88 100644
--- a/content/Training/developers/07-sandbox-capstone.mdx
+++ b/content/Training/developers/07-sandbox-capstone.mdx
@@ -294,12 +294,12 @@ The combination of quick filters (duplicate URLs, content length) and AI evaluat
 Ready to implement this project? Follow our complete examples:
 
 <div className="flex flex-wrap gap-3 mb-6">
-  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/07-deep-research-ts" target="_blank" rel="noopener noreferrer"
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/07-deep-research-js" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     TypeScript
   </a>
-  <a href="https://github.com/agentuity/examples/tree/add-tutorials/agents/deep_research_py" target="_blank" rel="noopener noreferrer"
+  <a href="https://github.com/agentuity/examples/tree/add-tutorials/training/07_deep_research_py" target="_blank" rel="noopener noreferrer"
      className="inline-flex items-center gap-2 px-4 py-3 bg-gray-900 text-white rounded-lg hover:bg-gray-800 transition-colors no-underline text-sm font-medium">
     <svg className="w-4 h-4" fill="currentColor" viewBox="0 0 20 20"><path d="M12 0c-6.626 0-12 5.373-12 12 0 5.302 3.438 9.8 8.207 11.387.599.111.793-.261.793-.577v-2.234c-3.338.726-4.033-1.416-4.033-1.416-.546-1.387-1.333-1.756-1.333-1.756-1.089-.745.083-.729.083-.729 1.205.084 1.839 1.237 1.839 1.237 1.07 1.834 2.807 1.304 3.492.997.107-.775.418-1.305.762-1.604-2.665-.305-5.467-1.334-5.467-5.931 0-1.311.469-2.381 1.236-3.221-.124-.303-.535-1.524.117-3.176 0 0 1.008-.322 3.301 1.23.957-.266 1.983-.399 3.003-.404 1.02.005 2.047.138 3.006.404 2.291-1.552 3.297-1.30 3.297-1.30.653 1.653.242 2.874.118 3.176.77.84 1.235 1.911 1.235 3.221 0 4.609-2.807 5.624-5.479 5.921.43.372.823 1.102.823 2.222v3.293c0 .319.192.694.801.576 4.765-1.589 8.199-6.086 8.199-11.386 0-6.627-5.373-12-12-12z"/></svg>
     Python