Seu agent é texto (Kyutai: agora vê e age em real-time)

Seu agent é texto (Kyutai: agora vê e age em real-time)

What just happened (October 2026):

Kyutai released CADRE (video autoencoders):

"Problem: Video world models = slow (high latency)."

"Cause: Text-to-video autoencoders pack many frames (wait for processing)."

"Solution: CADRE = specialized video autoencoders (low latency)."

"Performance: 230ms latency (interactive, real-time)."

"Speed: 20 fps on single H100 GPU (efficient)."

"Implication: Agents can now see and react in real-time (embodied AI possible)."

What this means for your company:

Current situation (your SaaS agent in production):

Setup (typical agent today): Your agent: Customer support chatbot (WhatsApp) Input: Text messages only Processing: Text → LLM → Response (no perception) Latency: 2-5 seconds (acceptable for text) Capability: Answers questions, handles simple requests Limitation: Can't see, can't perceive, can't understand context

Agent capabilities (text-only):

Can do:
  ✓ Answer questions ("What's my order?")
  ✓ Process text commands ("Please return my item")
  ✓ Retrieve info (lookup customer data)
  ✓ Generate responses (text-based)
  
Can't do:
  ✗ See what customer is looking at (no vision)
  ✗ React to visual changes (no perception)
  ✗ Understand environment (no context)
  ✗ Guide user through physical space (no spatial awareness)
  ✗ Verify identity via face (no vision capability)
  ✗ Confirm physical product issues (can't see damaged item)
  ✗ React in real-time (video requires low latency)
  ✗ Guide assembly or usage (can't see hands/steps)
  

The problem (what you're missing):

Scenario 1: Product assembly (IKEA furniture)
  Customer: "I'm stuck on step 3"
  Your agent: "Try turning the piece clockwise"
  Reality: Agent can't see what customer is seeing (guessing)
  Problem: Wrong advice (customer gets frustrated)
  
Scenario 2: Identity verification (bank/fintech)
  Customer: "Verify my identity for withdrawal"
  Your agent: "Can you provide ID number?"
  Reality: Agent can't see customer (can't verify is really them)
  Problem: Security risk (fraud possible, agent can't detect)
  
Scenario 3: Damage verification (insurance)
  Customer: "My package arrived damaged"
  Your agent: "Describe the damage"
  Reality: Agent can't see damage (trusting customer's words)
  Problem: Fraud risk (customer could lie, claim false damage)
  
Scenario 4: Real-time guidance (field service)
  Customer: "How do I fix this server?"
  Your agent: "Check the power cable"
  Reality: Agent can't see server (sequential text back-and-forth)
  Problem: Slow (customer waits for each instruction, latency adds up)
  

Latency matters (why 230ms vs 2-5s is game-changing):

Scenario: Customer on video call with agent
  
With text-based agent (current):
  Time 0s: Customer asks question (speaks → text conversion)
  Time 0-2s: Agent processes text
  Time 2-5s: Agent generates response
  Time 5-7s: Agent speaks response (TTS)
  Time 7s: Customer hears answer (7 second delay)
  Experience: Feels like bad Zoom call (lag)
  Problem: Breaks conversation flow (unnatural)
  
With video agent (CADRE, 230ms latency):
  Time 0s: Customer shows object/action
  Time 0-0.23s: Agent sees via camera
  Time 0.23-0.5s: Agent processes (understand what happened)
  Time 0.5-1s: Agent responds (text or voice)
  Time 1s: Customer hears answer (1 second delay)
  Experience: Feels like natural conversation (real-time)
  Problem solved: Latency low enough for interactivity
  

The implication:

230ms latency = game-changing (enables real-time interaction)
Previous world models = 500ms-2s latency (too slow)
CADRE = 230ms latency (interactive, finally viable)

What becomes possible:
  - Agent watches customer in real-time
  - Agent sees problem (damaged item, wrong assembly, etc)
  - Agent reacts immediately (next 230ms)
  - Conversation feels natural (no perceptual lag)
  - User experience: Like talking to human (not bot)

---

The problem: Text-only agents are stateless and unaware (you're missing 90% of context)

Why perception matters (the vision problem)

Text agents = blind. Video agents = can see. One sees context, one guesses. Choose. 👀

Comparison: Text-only vs Video-aware agent

Scenario: Customer calls ("I need help with my order")

Text-only agent (current): Agent: "What can I help with?" Customer: "It's not working" Agent: "Can you describe the problem?" Customer: "It's broken" Agent: "Please be specific" Customer: [frustrated] "I'm sending you a picture!" Agent: "I can't see pictures" [lie, can't process vision] Result: Customer gives up, escalates to human Time wasted: 5 minutes Satisfaction: Low (feels ignored)

Video-aware agent (CADRE): Agent: "What can I help with?" Customer: [shows broken item on camera] Agent: [watches for 230ms] Agent: "I see the problem. The hinge is broken. Here's how to fix it..." [Agent can see and react immediately] Result: Customer gets instant accurate help Time: 1 minute (4x faster) Satisfaction: High (feels understood)

The difference: Text agent: Requires customer to DESCRIBE problem (lossy, slow) Video agent: SEES the problem (direct, fast) Latency matters: If video agent is slow (2s), breaks flow CADRE solves: 230ms = feels real-time (interactive)

Business impact:

Support tickets (text-only agent): Volume: 1000 tickets/day Resolved by agent: 30% (rest need human) Resolution time: 10 minutes (back-and-forth) Cost: R$50 per ticket (human escalation)

Support tickets (video-aware agent, CADRE): Volume: 1000 tickets/day Resolved by agent: 70% (agent can see & verify) Resolution time: 2 minutes (immediate understanding) Cost: R$15 per ticket (less escalation) Savings: R$35k/day (if 1000 tickets = 700 resolved) Improvement: 3x more resolved, 5x cheaper

Market reality: Your company: Text agents (30% resolution rate) Competitor: Video agents (70% resolution rate) Enterprise customer: "Why choose you if competitor solves 2x more?" Deal lost: R$500k contract (to competitor with video capability)

Why low latency is critical (230ms vs 2 seconds)

Humans perceive lag > 500ms. 230ms feels real-time. Difference = conversation vs awkward delay. 🎥⚡

Latency perception (cognitive science):

0-100ms: Imperceptible (feels real-time) 100-200ms: Minimal perception (almost real-time) 200-500ms: Noticeable but acceptable (conversations work) 500ms-1s: Noticeable lag (feels slow, breaks flow) 1s+: Awkward (feels like talking to someone far away)

Current video world models (without CADRE): Latency: 500ms-2s typical Perception: Feels slow, laggy Interaction: Breaks conversation flow Use case: Not viable for real-time (feels like talking to bot)

Kyutai CADRE (new standard): Latency: 230ms Perception: Feels real-time Interaction: Natural conversation flow Use case: Finally viable for real-time interactive agents

Practical example (video assembly guide):

Scenario: Customer assembling IKEA furniture (video call)

Old approach (500ms latency): Time 0s: Customer shows current step Time 0-0.5s: Agent "sees" (camera feed processing) Time 0.5-1s: Agent understands what's happening Time 1-2s: Agent generates instructions Time 2s: "Turn the piece 45 degrees clockwise" Time 2-3s: Customer follows instruction Time 3s: Customer moves to next step Total: 3 seconds for one instruction Feeling: Slow, customer waits for agent (frustrating)

New approach (230ms latency, CADRE): Time 0s: Customer shows current step Time 0-0.23s: Agent "sees" (CADRE processes video) Time 0.23-0.5s: Agent understands what's happening Time 0.5-1s: Agent generates instructions Time 1s: "Turn the piece 45 degrees clockwise" Time 1-1.5s: Customer follows instruction Time 1.5s: Customer moves to next step Total: 1.5 seconds for one instruction Feeling: Natural, real-time (like human guide)

Impact: Old: 10 steps = 30 seconds of agent interaction New: 10 steps = 15 seconds of agent interaction Speedup: 2x faster Customer experience: Feels natural (vs feels robotic)

Market implication:

Companies using old video models (500ms+): Use case: Limited (mostly async, recorded videos) Real-time: Not viable (feels too slow)

Companies using CADRE (230ms): Use case: Broad (real-time interactive) Real-time: Viable (feels natural) Competitive advantage: Can do things competitors can't

---

How CADRE enables embodied agents (the future of AI automation)

From text chatbots to embodied robots (vision → action)

230ms latency unlocks embodied AI. Agents that see and act. Welcome to the future. 🤖👁️⚡

Agent evolution:

Stage 1: Text chatbots (2023-2024) Input: Text only Processing: LLM Output: Text only Latency: 2-5 seconds Use case: Support tickets, FAQ, simple routing Limitation: Blind (no perception)

Stage 2: Voice assistants (2024-2025) Input: Voice (converted to text) Processing: LLM Output: Voice Latency: 2-5 seconds (same as text) Use case: Phone support, voice commands Limitation: Still blind (only audio, no vision)

Stage 3: Video agents (2025-2026, CADRE enables) Input: Video + voice (multimodal) Processing: Video autoencoder + LLM Output: Voice + action instructions Latency: 230ms (CADRE breakthrough) Use case: Real-time guidance, verification, embodied tasks Capability: Can see and react (no longer blind)

Stage 4: Embodied robots (2026-2027, CADRE enables) Input: Sensor data (cameras, depth, lidar) Processing: Video world model + planning Output: Robot actions (movement, manipulation) Latency: 230ms per action (real-time control loop) Use case: Warehouse robots, field service, manufacturing Capability: Acts in physical world (not just talks)

Use cases enabled by CADRE:

1. Real-time video support (agent watches, guides) Example: "I see your cable is loose. Plug it in here [points]" Latency requirement: < 500ms (CADRE: 230ms ✓)

2. Identity verification (agent sees face, verifies) Example: "I see your ID. Verified. Proceeding with transaction." Latency requirement: < 500ms (CADRE: 230ms ✓) Processing: Liveness detection (is person real?)

3. Quality inspection (agent sees defects, flags) Example: "I see a crack here. This item qualifies for return." Latency requirement: < 1s (CADRE: 230ms ✓) Processing: Defect detection (visual inspection)

4. Assembly guidance (agent watches, instructs) Example: "You're doing step 3 wrong. The joint goes here [shows]." Latency requirement: < 500ms (CADRE: 230ms ✓) Processing: Action understanding (what is customer doing?)

5. Field service (agent guides technician remotely) Example: "I see the server. Remove the top panel first." Latency requirement: < 500ms (CADRE: 230ms ✓) Processing: Equipment recognition (identify device, understand state)

6. Warehouse robots (agent controls robot with vision) Example: [Robot picks up package] → [Agent sees] → [Robot delivers] Latency requirement: < 230ms (CADRE: 230ms ✓) Processing: Visual control loop (real-time decision making)

7. XR/AR guidance (agent appears in user's view) Example: [User wears AR glasses] → [Agent sees live view] → [Overlays instructions] Latency requirement: < 100ms (CADRE: 230ms ✗ tight but possible) Processing: Real-time 3D understanding

Competitive advantage (who wins):

Company A (text agents only): Capabilities: Text support, FAQ, routing Limitations: Can't see, can't verify, can't guide Use case: Limited (support tickets only) Revenue: R$100k/mo (basic support automation)

Company B (video agents, CADRE-based): Capabilities: Real-time video support, verification, guidance Advantages: Can see, verify, guide in real-time Use case: Broad (support + sales + verification + field service) Revenue: R$500k/mo (multiple use cases)

Market outcome: Company B: Wins (5x more use cases, 5x more revenue) Company A: Loses (feature-limited competitor)

---

How to implement video agents (practical roadmap)

From chatbot to vision-enabled agent (step-by-step)

Phase 1: Assess (week 1)

Question 1: Do your customers send videos/images? Yes: Video capability needed (priority) No: Maybe not critical (defer to later)

Question 2: Would seeing customer problem improve resolution? Example: Customer says "Item broken" Current: You ask them to describe (lossy) Better: You see video (direct) Answer: Yes (probably applies)

Question 3: Are there real-time scenarios (video calls)? Example: Live support chat with video Current: Text-based only (agent can't see) Better: Agent watches (video autoencoder) Answer: Depends on your use case

Decision: Is video capability valuable? If yes: Proceed to phase 2 If no: Stick with text agents (for now)

Phase 2: Plan (week 1-2)

Step 1: Choose video model Option A: Use CADRE (open source, 230ms) Option B: Use proprietary (OpenAI, Anthropic, Google) Option C: Use existing (less optimized, slower) Recommendation: CADRE (open, fast, optimized)

Step 2: Design integration Architecture: Input: Customer video (from WhatsApp, camera, etc) Processing: CADRE autoencoder (extract visual features) Processing: Add to LLM context (multimodal input) Output: Agent response (text or action instruction) Latency: Video encoding: ~50ms LLM processing: ~100-150ms Total: ~200-250ms (acceptable)

Step 3: Identify use cases Use case 1: Product verification (see what customer is holding) Use case 2: Damage verification (insurance/returns) Use case 3: Identity verification (KYC) Use case 4: Real-time guidance (assembly, repair) Use case 5: Quality inspection (manufacturing) Select: Top 2-3 use cases (start small)

Phase 3: Build (week 2-4)

Step 1: Integrate CADRE Setup: Download CADRE model (open source) Integration: Add to agent pipeline (between video input & LLM) Testing: Verify latency (should be ~230ms)

Step 2: Update agent prompt Old: "Customer says their order is broken" New: "I can see the customer's order. It shows [visual description from CADRE]. The issue is [identified]. Here's how to fix it [action]" Key: Agent now reasons about visual input (not just text)

Step 3: Build video input interface Option A: Camera on device (web/mobile) Option B: Video upload (customer sends video) Option C: Video call (real-time streaming) Recommendation: Start with option A (web camera, simplest)

Step 4: Test Test 1: Latency (measure end-to-end response time) Test 2: Accuracy (does agent correctly understand what it sees?) Test 3: User experience (does video help resolution?)

Phase 4: Deploy (week 4-5)

Step 1: Gradual rollout Rollout 1: 10% of users (measure impact) Rollout 2: 50% (if positive results) Rollout 3: 100% (full launch)

Step 2: Monitor Metric 1: Resolution rate (should increase) Metric 2: Time-to-resolution (should decrease) Metric 3: Customer satisfaction (should increase) Metric 4: Latency (should be < 500ms)

Step 3: Iterate Feedback: Ask users "Did seeing help?" Improvement: Refine CADRE preprocessing (improve visual input) Improvement: Improve agent prompts (better at interpreting vision)

Phase 5: Scale (week 5+)

Step 1: Add more use cases Use case 2: Add identity verification (KYC) Use case 3: Add damage verification (insurance) Use case 4: Add real-time guidance (assembly)

Step 2: Optimize latency If: Average latency is 350ms Action: Optimize CADRE inference (quantization, distillation) Goal: Reduce to < 250ms (more responsive)

Step 3: Extend to embodied agents If: Video agents working well Next: Add robot arms / field robots Capability: Agent controls physical device (based on vision) Use case: Warehouse automation, field service

---

The bottom line: Text agents are blind. Video agents (CADRE) can see and react in real-time. Future belongs to embodied AI.

Kyutai CADRE: 230ms latency enables interactive video agents. Your agent is text-only (unaware). Competitors building video agents now (will win). Join the future. 🎥🤖⚡

Reality check:

Your agent today: Input: Text only (blind) Latency: 2-5 seconds Resolution rate: 30% (rest escalate to human) Use case: Text support (limited) Limitation: Can't see context (guesses)

Your agent with CADRE: Input: Video + text (can see) Latency: 230ms (real-time) Resolution rate: 70% (more problems solved) Use case: Support + verification + guidance (broad) Capability: Understands context (sees it)

Competitive advantage: Speed: 2-5 seconds → 230ms (10-20x faster) Resolution: 30% → 70% (resolves 2-3x more) Use cases: 1 → 5+ (broad platform) Revenue: R$100k/mo → R$500k+/mo (bigger market)

Next steps:

1. This week: Assess if video capability valuable (use cases?)
2. Week 1: Plan integration (CADRE architecture)
3. Week 2-4: Build video agent (implement CADRE)
4. Week 4-5: Deploy (gradual rollout)
5. Week 5+: Scale (add use cases, optimize)
6. Month 3: Build embodied agents (robots, XR)

Why now:

Reason 1: CADRE released (low-latency video finally viable) Reason 2: Your competitors haven't done this yet (advantage window) Reason 3: Implementation is fast (4 weeks) Reason 4: ROI is massive (2-3x more problems solved) Reason 5: Market will shift (embodied AI = future)

→ OpenClaw: Video Agents, Real-Time Latency, Embodied AI, Visual Perception, Interactive Agents, CADRE Integration

Your agent is blind (text-only). CADRE: 230ms latency enables real-time video agents. See + react instantly. Join embodied AI revolution. 👁️⚡🤖