DEMOGOD
{/* Tambo components render here */}
;
}
```
**What happens:**
1. User asks voice question
2. Voice AI decides: "This needs a visual"
3. Voice AI calls `renderComponent("TrendChart", {data: [...]})`
4. Tambo renders TrendChart with those props
5. Voice AI speaks explanation while chart appears
**Zero manual mapping. Agent orchestrates both voice and visuals.**
## Four Voice AI Demo Scenarios That Were Impossible Before Tambo
### Scenario 1: "Show me how this feature works"
**Old approach:** Voice describes the feature. User tries to find it on screen. Gets confused. Drops off.
**Tambo approach:**
```typescript
// Voice AI hears: "Show me how bulk imports work"
agent.render("BulkImportModal", {
mode: "demo",
sampleData: demoCSV,
stepHighlight: "upload"
});
// Voice: "You start by uploading a CSV file like this..."
agent.render("BulkImportModal", {
mode: "demo",
sampleData: demoCSV,
stepHighlight: "mapping"
});
// Voice: "Then map your columns to our fields..."
```
User **sees** the exact feature while voice explains each step.
### Scenario 2: "Compare these two options for me"
**Old approach:** Voice says "Option A has X, Option B has Y." User forgets what X was by the time voice reaches Y.
**Tambo approach:**
```typescript
agent.render("ComparisonTable", {
options: [
{name: "Starter", features: ["Feature A", "Feature B"], price: "$29"},
{name: "Pro", features: ["Feature A", "Feature B", "Feature C", "Feature D"], price: "$99"}
],
highlightDifferences: true
});
```
Voice: "Here's the comparison - Pro adds Feature C and Feature D..."
User **sees** side-by-side comparison while hearing explanation. Can reference table after voice finishes.
### Scenario 3: "Walk me through setup"
**Old approach:** Voice lists steps. User takes notes. Tries to follow notes later. Gets stuck.
**Tambo approach:**
```typescript
// Render checklist that updates as voice progresses
agent.render("SetupChecklist", {
steps: [
{title: "Create account", status: "complete"},
{title: "Connect integrations", status: "current"},
{title: "Invite team", status: "pending"}
],
currentStep: 1
});
```
Voice: "You've created your account. Now let's connect your integrations..."
Checklist **shows progress** visually. User knows where they are in setup flow.
### Scenario 4: "What happened last month?"
**Old approach:** Voice recites numbers. User glazes over.
**Tambo approach:**
```typescript
agent.render("MonthlyReport", {
metrics: {
revenue: {value: "$42,130", change: "+18%"},
users: {value: "1,204", change: "+12%"},
churn: {value: "2.3%", change: "-0.4%"}
},
charts: ["revenue_trend", "user_growth"],
period: "January 2026"
});
```
Voice: "Last month revenue increased 18% to $42k, users grew 12%..."
User **sees** formatted report with charts while hearing highlights. Can explore details after voice finishes.
## The MCP Integration Advantage (Why Tambo + Voice AI Is More Than UI)
Tambo ships with MCP (Model Context Protocol) integration. This matters because Voice AI demos need MORE than just UI rendering. They need:
- **Data fetching**: "Show me my analytics" → agent fetches real user data via MCP tool
- **Actions**: "Create a test import" → agent calls API via MCP tool, then renders result
- **Persistence**: "Save this filter" → agent stores filter via MCP tool, renders confirmation
**Example: Voice AI demo that fetches real data**
```typescript
// MCP tool definition
const analyticsServer = {
name: "analytics",
tools: {
getMetrics: {
description: "Fetch user metrics for date range",
parameters: z.object({
startDate: z.string(),
endDate: z.string(),
metrics: z.array(z.string())
}),
execute: async ({startDate, endDate, metrics}) => {
const data = await fetchAnalytics(startDate, endDate, metrics);
return data;
}
}
}
};
// Voice AI uses MCP tool + Tambo rendering
async function handleQuery(query: string) {
if (query.includes("show my analytics")) {
// Agent calls MCP tool to get data
const data = await agent.useTool("analytics.getMetrics", {
startDate: "2026-01-01",
endDate: "2026-01-31",
metrics: ["revenue", "users"]
});
// Agent renders component with real data
agent.render("AnalyticsDashboard", {
data: data,
period: "January 2026"
});
// Agent speaks summary
agent.speak(`Here's your January analytics. Revenue was ${data.revenue}...`);
}
}
```
**This is the complete Voice AI demo stack:**
- Voice handles conversation
- Tambo handles UI rendering
- MCP handles data/actions
User gets: Conversational interface + Visual demonstrations + Real product data.
## What This Means for Voice AI Demo Product Strategy
If you're building Voice AI demo products (or considering it), Tambo just changed your roadmap.
### Before Tambo
**Voice AI demo product checklist:**
- ✅ Build voice conversation engine
- ✅ Train on product documentation
- ✅ Handle common demo questions
- ❌ Build entire custom UI framework for agent-driven rendering
- ❌ Maintain component library
- ❌ Handle component state synchronization
- ❌ Debug agent → UI rendering pipeline
- ❌ Build prop validation system
- ❌ Handle interaction callbacks
**Estimated engineering time:** 6-12 months for visual rendering layer
### After Tambo
**Voice AI demo product checklist:**
- ✅ Build voice conversation engine
- ✅ Train on product documentation
- ✅ Handle common demo questions
- ✅ `npm install @tambo-ai/react`
- ✅ Wrap existing React components with Tambo schemas
**Estimated engineering time:** 2-4 weeks for visual rendering layer
**Tambo absorbed the entire "agent-driven UI rendering" problem.** You just define your component library, and agents can use it.
### Strategic Implications
**1. Voice-only demos are dead**
If your competitor's Voice AI demo can SHOW users features while explaining them, and yours can only DESCRIBE features, you've already lost.
Tambo makes voice + visual demos trivially easy. Voice-only is now the "MVP that never shipped visual layer."
**2. Demo quality becomes component quality**
Your demo is only as good as your component library. If you have well-designed, reusable React components for your product's key workflows, Tambo-powered Voice AI can demonstrate them immediately.
If your product UI is a mess of tightly coupled components, your demo will be too.
**This creates pressure to build better component architectures.** Which is good for your product AND your demo.
**3. Demo infrastructure = product infrastructure**
Before: Demo team builds separate "demo flow" that approximates product.
After: Demo agent renders your ACTUAL product components with REAL data.
**Demos become integration tests.** If demo breaks, your component broke. If component works, demo works.
## The One Missing Piece (And How to Build It)
Tambo handles UI rendering. Voice AI handles conversation. But there's one gap: **synchronization.**
**The problem:** Voice AI speaks at ~150 words per minute. UI components render instantly. If agent renders a complex dashboard and immediately starts explaining it, user sees dashboard flash on screen before they're ready to look at it.
**The solution:** Render choreography.
```typescript
async function synchronizedDemo(explanation: string, component: string, props: any) {
// Start speaking
const speech = agent.speak(explanation);
// Wait for speech to start (user is now listening)
await speech.started();
// Render component AFTER user hears intro
agent.render(component, props);
// Wait for speech to finish
await speech.finished();
// Component stays visible for 3 seconds after speech ends
await sleep(3000);
// Ready for next demo step
}
```
**Pattern:**
1. Voice introduces what's about to be shown
2. Component renders while voice is explaining
3. Component remains visible briefly after voice finishes
4. Next step begins
This prevents "visual overwhelm" where components render faster than user can process them.
### Advanced: Contextual Rendering Based on Voice Pacing
```typescript
// Parse speech transcript for render timing cues
const renderCues = {
"let me show you": {delay: 500}, // Render 0.5s after phrase
"here's": {delay: 200}, // Render 0.2s after phrase
"take a look at": {delay: 800} // Render 0.8s after phrase
};
async function contextualRender(transcript: string, component: string, props: any) {
// Detect render cue in transcript
for (const [phrase, config] of Object.entries(renderCues)) {
if (transcript.includes(phrase)) {
await sleep(config.delay);
agent.render(component, props);
return;
}
}
// Default: render immediately
agent.render(component, props);
}
```
Voice says: "Let me show you the analytics dashboard..."
Component renders 0.5 seconds after "let me show you" - right as user's attention shifts from listening to looking.
**This timing choreography doesn't exist yet in Tambo.** But it's buildable on top of Tambo's primitives.
## Why Open Source Matters Here
Tambo is MIT licensed. 8.2k GitHub stars. Active development.
**This matters for Voice AI demos because:**
**1. No vendor lock-in**
You're not building on a proprietary platform that could rug pull pricing, shut down, or pivot away from your use case.
Your Voice AI demo infrastructure is yours. Fork it if you need to.
**2. Community component libraries**
As Tambo adoption grows, community will build component libraries specifically for common demo patterns:
- Feature comparison tables
- Onboarding checklists
- Analytics dashboards
- Form builders
- Data visualizations
You won't need to build these from scratch. Import community components, customize for your product.
**3. Integration ecosystem**
MCP integration means Tambo works with any MCP-compatible tool. As MCP ecosystem grows (which it is rapidly), your Voice AI demo automatically gets new capabilities.
Want to demo Salesforce integration? MCP Salesforce server exists → Tambo agent can fetch real Salesforce data → render it in demo.
**4. Inspectability**
When something breaks in your Voice AI demo's visual rendering, you can read Tambo's source code to understand why.
When proprietary SDKs break, you file a support ticket and wait.
## The Timeline: When Voice AI Demos Go Visual
**Q1 2026 (now):** Early adopters integrate Tambo with Voice AI demos. Mostly custom implementations. "Look what we built" posts on Twitter.
**Q2 2026:** First Voice AI demo products ship with Tambo integration as core feature. Comparison tables show "voice + visual" as differentiator vs "voice only" competitors.
**Q3 2026:** Community component libraries for common demo patterns emerge. "Tambo Demo Components" packages on npm.
**Q4 2026:** Voice-only demos are legacy. Industry expectation: Voice AI demos show AND tell.
**2027:** New problem emerges: Demos are TOO good. Users expect product to work exactly like visually-perfect demo. Product teams scramble to match demo quality.
**This timeline is fast because the technology is READY.** Tambo 1.0 shipped. Voice AI works. React components exist. It's integration work, not research.
## What to Build Right Now
If you're building Voice AI demo products (or adding Voice AI demos to existing products), here's your roadmap:
### Phase 1: Component Audit (Week 1)
**Task:** Identify which product features are most frequently demoed.
**Output:** List of 10-15 "core demo components" (dashboards, forms, onboarding flows, key feature screens).
**Goal:** Know which components need Tambo integration first.
### Phase 2: Tambo Wrapper (Week 1-2)
**Task:** Wrap core demo components with Tambo schemas.
```typescript
const demoComponents: TamboComponent[] = [
{
name: "AnalyticsDashboard",
description: "Main analytics dashboard with metrics and charts",
component: AnalyticsDashboard,
propsSchema: z.object({
dateRange: z.object({start: z.string(), end: z.string()}),
metrics: z.array(z.string())
})
},
// ... 10-15 more components
];
```
**Output:** Tambo-wrapped component library for your product.
### Phase 3: Voice + Tambo Integration (Week 2-3)
**Task:** Connect Voice AI agent to Tambo rendering.
**Pattern:** Agent tool calling → `renderComponent` tool → Tambo renders.
**Output:** Working Voice AI demo that can both speak and render components.
### Phase 4: Render Choreography (Week 3-4)
**Task:** Add timing synchronization between voice and visual rendering.
**Output:** Polished demo experience where components appear at contextually appropriate moments (not too early, not too late).
### Phase 5: MCP Data Integration (Week 4+)
**Task:** Connect MCP tools so agent can render components with real product data.
**Output:** Demos that show actual user data, not fake demo data.
**Timeline: 4-6 weeks from zero to production Voice AI demo with visual rendering.**
Compare to pre-Tambo timeline: 6-12 months to build custom agent-driven UI rendering framework.
## The Competitive Moat This Creates
If you're first in your market to ship Voice AI demos with visual rendering (via Tambo), you create a moat that's hard to cross.
**Why:**
**1. Demo quality becomes product perception**
Users assume your product is as polished as your demo. Voice + visual demo = "This company has their shit together."
Voice-only demo from competitor = "This feels like an MVP."
**2. Sales cycle compression**
Demos that SHOW features convert faster than demos that DESCRIBE features. If your demo cycle is 30% shorter than competitors because users understand product faster, you win deals before competitor even gets to final pitch.
**3. Product feedback loop**
When your demo uses real product components, demo quality directly reflects product quality. This creates internal pressure to improve product components (which improves demo, which improves conversion, which justifies more product investment).
**Virtuous cycle:** Better components → Better demos → More customers → More resources → Better components.
**4. Community component libraries**
Once you've built Tambo-wrapped components for your product, you can open-source generic versions. "Analytics Dashboard Component for SaaS Demos" on npm.
Community contributes improvements. Your product benefits. Competitors using your components means their demos look like yours (brand advantage).
## The One Warning
Tambo makes it **trivially easy** to render UI components during Voice AI demos. This creates a new failure mode: **visual overload.**
**The problem:** Agent can render components faster than users can process them.
```typescript
// BAD: Rendering too many components too fast
agent.render("Dashboard", {...});
agent.render("UserTable", {...});
agent.render("FilterPanel", {...});
agent.render("ExportModal", {...});
// User sees four components flash on screen and comprehends NONE of them
```
**The solution:** Render choreography (discussed earlier) + render budget.
```typescript
// GOOD: Render budget limits simultaneous components
const RENDER_BUDGET = {
maxSimultaneousComponents: 2,
minTimeBetweenRenders: 3000, // 3 seconds
};
async function renderWithBudget(component: string, props: any) {
if (currentlyRendered.length >= RENDER_BUDGET.maxSimultaneousComponents) {
await waitForRenderSlot();
}
if (timeSinceLastRender() < RENDER_BUDGET.minTimeBetweenRenders) {
await sleep(RENDER_BUDGET.minTimeBetweenRenders - timeSinceLastRender());
}
agent.render(component, props);
}
```
**Rule of thumb:** User can process ~1-2 new visual elements per 5 seconds of voice explanation.
If voice is explaining a feature for 10 seconds, render at most 2-3 components during that explanation.
**Visual pacing matters as much as voice pacing.**
## The Bottom Line
Tambo 1.0 just made Voice AI demos 10x better by adding the visual layer.
**Before Tambo:** Voice AI demos could explain your product.
**After Tambo:** Voice AI demos can explain AND demonstrate your product.
**The difference:** Explanation = user imagines your product. Demonstration = user SEES your product.
And seeing is converting.
---
**Voice AI demos that show AND tell aren't the future—they're available right now via Tambo.** The only question is whether you're building them before your competitors do, or explaining to your board why competitor demos look so much better than yours.
The components exist. The integration is straightforward. The timeline is weeks, not months.
Ship voice + visual demos. Or watch someone else do it first.
---
*Learn more:*
- [Tambo on GitHub](https://github.com/tambo-ai/tambo)
- [Tambo Documentation](https://tambo.ai)
- [Show HN: Tambo 1.0 discussion](https://news.ycombinator.com/item?id=42888888)
Tambo Just Solved Voice AI's Missing Visual Layer (And It's Open Source)
# Tambo Just Solved Voice AI's Missing Visual Layer (And It's Open Source)
**Meta Description:** Tambo 1.0 lets AI agents render React components with streaming props. Voice AI demos that can show AND tell just became trivially easy to build. Here's why this matters.
---
## The Problem No One Was Talking About (Until Tambo 1.0 Shipped)
Voice AI demos can talk. They can explain features, answer questions, guide users through workflows. But they've always had one fundamental limitation: **they can't show you what they're talking about.**
You ask your Voice AI demo agent, "How does the analytics dashboard work?" and it describes the dashboard in words. Explains the metrics. Walks through the filters. But you're staring at a static page while a voice describes something you can't see.
Now Tambo 1.0 just shipped, and the entire equation changed.
**Tambo is a generative UI toolkit for React.** AI agents pick which components to render and stream props to them in real time. MCP integration built in. Open source (MIT). 8.2k GitHub stars.
And suddenly, Voice AI demos don't just explain the analytics dashboard. **They render it while explaining it.**
## What Tambo Actually Does (In Plain English)
Before Tambo, if you wanted an AI agent to show users a UI component, you had three bad options:
**Option 1: Hardcode everything**
- Agent says "Here's the dashboard"
- You manually coded: "When agent says X, show component Y"
- Zero flexibility, breaks constantly
**Option 2: Let the agent write code**
- Agent generates React JSX
- You eval() it (security nightmare)
- Or you parse it (reliability nightmare)
**Option 3: Just don't show anything**
- Agent describes UI in words
- User imagines what it looks like
- Demos suck
**Tambo's approach:**
```typescript
const components: TamboComponent[] = [
{
name: "AnalyticsDashboard",
description: "Shows user metrics with filters and date ranges",
component: AnalyticsDashboard,
propsSchema: z.object({
metrics: z.array(z.string()),
dateRange: z.object({
start: z.string(),
end: z.string()
}),
filters: z.record(z.any())
}),
},
];
```
The agent sees: "AnalyticsDashboard component available - shows user metrics with filters and date ranges"
User asks: "Show me last week's conversion metrics"
Agent responds:
1. **Verbally**: "Here's your conversion dashboard for last week..."
2. **Visually**: Streams props `{metrics: ["conversion_rate", "revenue"], dateRange: {start: "2026-02-04", end: "2026-02-11"}}` to AnalyticsDashboard component
3. **Component renders in real time** with those exact props
No hardcoding. No eval(). No security risks. Just: **Agent picks component. Agent streams props. Component renders.**
## Why This Matters for Voice AI Demos Specifically
Voice AI demos have been stuck in "podcast mode" - they can narrate, but they can't illustrate.
### The Current Voice AI Demo Experience
```
User: "How does your product handle bulk imports?"
Voice AI: "Great question! Our bulk import feature supports CSV and JSON
formats up to 10,000 rows. You'll find the import button in the top right
of the data table. Click it, select your file, map your columns to our
fields, and preview before importing. We also validate data types and
show you any errors before processing."
```
**User mental state:** "Okay I think I understand... where's that button again?"
### The Tambo-Enabled Voice AI Demo Experience
```
User: "How does your product handle bulk imports?"
Voice AI: "Great question! Let me show you..."
[AnalyticsDashboard component renders with import button highlighted]
Voice AI: "Here's the import button. Let me show you the flow..."
[BulkImportModal component renders]
Voice AI: "You can drag a file here. Let me show you with sample data..."
[Component updates with sample CSV, shows column mapping interface]
Voice AI: "Map your columns like this... and here's the preview..."
[PreviewTable component renders with validation warnings shown]
Voice AI: "See these validation warnings? That's how we catch errors before processing."
```
**User mental state:** "Oh I literally see exactly how this works."
The difference: **Voice AI went from narrator to demonstrator.**
## Three Voice AI Demo Use Cases Tambo Unlocks
### 1. Progressive Feature Revelation
**The pattern:** Voice AI explains a feature while progressively revealing UI elements.
**Without Tambo:**
Voice describes "three-step onboarding flow" and hopes user can visualize steps 1, 2, and 3.
**With Tambo:**
```typescript
// Step 1: Show overview
agent.render("OnboardingSteps", {
currentStep: 0,
steps: ["Profile", "Integrations", "Team Setup"],
highlight: null
});
// Step 2: Focus on current step
agent.render("OnboardingSteps", {
currentStep: 1,
steps: ["Profile", "Integrations", "Team Setup"],
highlight: "Integrations"
});
// Step 3: Show integration options
agent.render("IntegrationGrid", {
integrations: ["Salesforce", "HubSpot", "Stripe"],
recommended: "Salesforce"
});
```
Voice AI says: "You start with profile setup... then connect your tools... let me show you the integration options..."
And the UI **literally shows you** each step as the voice describes it.
### 2. Dynamic Data Visualization During Explanation
**The pattern:** Voice AI answers questions about data by rendering charts with the answer.
**Example query:** "How did our conversion rate trend last quarter?"
**Without Tambo:**
"Your conversion rate started at 3.2% in November, increased to 3.8% in December, and ended at 4.1% in January."
**User mental state:** Trying to visualize those numbers, probably doesn't remember them by the time voice finishes.
**With Tambo:**
```typescript
agent.render("TrendChart", {
data: [
{month: "Nov", value: 3.2},
{month: "Dec", value: 3.8},
{month: "Jan", value: 4.1}
],
type: "line",
highlight: "upward trend",
annotation: "18% increase quarter-over-quarter"
});
```
Voice AI says: "Your conversion rate increased 18% quarter-over-quarter..." **while rendering the trend line chart**
User **sees** the trend while hearing the explanation. Information retention goes from ~20% (audio only) to ~70% (audio + visual).
### 3. Interactive Demo Exploration
**The pattern:** Voice AI renders interactive components user can manipulate while voice provides guidance.
This is where Tambo's **interactable components** shine:
```typescript
{
name: "FilterBuilder",
description: "Lets users build custom data filters interactively",
component: FilterBuilder,
propsSchema: z.object({
availableFields: z.array(z.string()),
currentFilters: z.array(z.object({
field: z.string(),
operator: z.enum(["equals", "contains", "greater_than"]),
value: z.any()
}))
}),
onInteraction: async (action, args) => {
if (action === "filter_added") {
return {update: {currentFilters: [...currentFilters, args.newFilter]}};
}
}
}
```
Voice AI says: "Try adding a filter for users who signed up in the last 30 days..."
User **clicks** "Add Filter" in the rendered component.
Tambo detects interaction, calls `onInteraction("filter_added", {newFilter: {...}})`.
Voice AI responds: "Great! Now let's add a revenue filter to see high-value users..."
**User is actively participating in the demo** while voice guides them. Not watching. Not listening. **Doing.**
## How Tambo Compares to Alternatives (And Why It Wins for Voice AI)
Tambo hit 1.0 recently. The repo includes a comparison table vs competitors. Let me translate that table into "what matters for Voice AI demos":
### Vercel AI SDK
**What it does:** Streaming text and function calling
**Voice AI demo fit:** Good for conversational logic, but no UI rendering. You still need to build "when agent says X, show Y" mappings manually.
**Tambo advantage:** Tambo handles both conversation AND visual rendering.
### CopilotKit
**What it does:** Copilot integration framework
**Voice AI demo fit:** Built for code assistance workflows, not product demos. Heavy on context sharing, light on dynamic UI generation.
**Tambo advantage:** Purpose-built for generative UI, not copilot patterns.
### Assistant UI
**What it does:** Pre-built chat components
**Voice AI demo fit:** Great if you want a chat interface. Doesn't help if you need to render product-specific components (dashboards, forms, data tables).
**Tambo advantage:** You bring your own components. Agent picks from YOUR component library.
### Tambo's Differentiator for Voice AI Demos
Tambo is the only toolkit where:
1. **Agent picks which component to show** (not hardcoded by you)
2. **Agent streams props dynamically** (not static predetermined values)
3. **Components are YOUR React components** (not generic chat UI)
4. **MCP integration built in** (agent can call tools while rendering UI)
For Voice AI demos, this means: **Voice agent and visual rendering are synchronized automatically.**
## The Technical Architecture Voice AI Demos Need
Let's talk implementation. How do you actually build a Voice AI demo with Tambo?
### Architecture Pattern: Voice + Visual Companion
```
┌─────────────────┐
│ Voice AI Agent │
│ (conversation) │
└────────┬────────┘
│
├─────> [Speech Output] ──> User hears
│
└─────> [Tambo Render] ──> User sees
│
┌──────▼──────┐
│ Tambo │
│ Component │
│ Picker │
└──────┬──────┘
│
┌─────────────┴─────────────┐
│ │
[Component A] [Component B]
Dashboard Form Builder
```
**Voice AI handles:**
- Understanding user questions
- Explaining features
- Guiding through workflows
- Deciding WHEN to show visuals
**Tambo handles:**
- Selecting WHICH component to render
- Streaming props to components
- Capturing user interactions with components
- Updating components as conversation progresses
### Example: Voice AI Demo with Tambo Integration
```typescript
import { useTambo } from '@tambo-ai/react';
import { generateText } from 'ai';
function VoiceAIDemo() {
const { render, components } = useTambo({
components: [
AnalyticsDashboard,
BulkImportModal,
OnboardingSteps,
TrendChart,
FilterBuilder
],
model: 'claude-3-5-sonnet-20250219'
});
async function handleVoiceInput(userQuery: string) {
// Voice AI processes query
const response = await generateText({
model: 'claude-3-5-sonnet-20250219',
messages: [
{role: 'system', content: `You are a product demo agent.
You can explain features AND render UI components to show them.
Available components: ${components.map(c => c.description).join(', ')}`},
{role: 'user', content: userQuery}
],
tools: {
renderComponent: {
description: 'Render a UI component to show the user',
parameters: z.object({
componentName: z.string(),
props: z.record(z.any())
}),
execute: async ({componentName, props}) => {
render(componentName, props);
return {success: true};
}
}
}
});
// Agent automatically calls renderComponent when appropriate
// Voice output plays while component renders
speakText(response.text);
}
return
← Back to Blog