Hoy en CES 2026 NVIDIA mostró cómo convertir agentes de IA en compañeros físicos y de escritorio usando DGX Spark y Reachy Mini. ¿Te imaginas un asistente que te vea, te hable y pueda mover un brazo para ayudarte, todo controlado por modelos abiertos y ejecutándose en tu propio hardware? Aquí te explico paso a paso la arquitectura, los componentes y cómo replicar la demo.
Qué presentó NVIDIA en CES 2026
NVIDIA juntó varios bloques abiertos para crear agentes que piensan, ven y actúan en el mundo real. Entre las piezas clave están:
- Modelos de razonamiento: NVIDIA Nemotron (ejemplo: Nemotron 3 Nano).
- Modelos de visión: Nemotron Nano 2 VL (VLM).
- Text-to-speech: ejemplo en la demo usa ElevenLabs.
- Orquestación: NeMo Agent Toolkit (NeMo Agent Toolkit + nat).
- Hardware de cómputo: DGX Spark para inferencia local y acelerada.
- Endpoint físico o simulado: Reachy Mini (o su simulador).
La idea es simple y poderosa: no depender de un único "todo en uno" sino combinar modelos especializados (texto, visión, voz), un router que decide a qué modelo enviar cada petición, y una capa de herramientas (tools) que ejecutan acciones físicas o consultas externas.
Por qué Reachy Mini importa
¿Para qué un robot pequeño en tu escritorio? Porque transforma una interfaz de chat en una experiencia multisensorial. Cuando el agente puede ver con una cámara, hablar en voz natural y mover actuadores, la interacción se siente más natural y útil.
Reachy Mini es pensado para ser hackeable: sensores, actuadores y APIs accesibles desde Python. Puedes correrlo en simulación para desarrollar o en hardware real para desplegar, manteniendo control total sobre modelos, prompts y acciones.
Arquitectura del demo y componentes clave
Componentes y responsabilidades generales:
- Nemotron reasoning LLM: decisiones y razonamiento complejo.
- Nemotron VLM: interpretar imágenes y responder preguntas visuales.
- Router (routing_llm): decide la ruta (chit_chat, image_understanding, other).
- ReAct agent + tools: maneja llamadas a herramientas (ej. búsqueda, control del robot).
- NeMo Agent Toolkit: conecta y orquesta modelos, rutas y herramientas.
- Pipecat bot: gestiona flujo en tiempo real de audio, video y movimiento.
- Reachy Mini daemon: expone la interfaz local (o simulada) para control del robot.
Requisitos prácticos de recursos:
- Modelo de razonamiento: ~65 GB en disco.
- Modelo de visión: ~28 GB en disco.
- Python 3.10+ y entorno
uvpara ejecutar los servicios.
Opciones de despliegue:
- Local: ejecutar los modelos en DGX Spark o GPU con VRAM suficiente.
- Cloud: endpoints en NVIDIA Brev, Hugging Face Inference Endpoints.
- Serverless: llamar a endpoints administrados (NVIDIA/Hugging Face).
Orquestación, routing y llamadas a herramientas (tool calling)
El diseño enfatiza el enrutamiento por intención:
- Chit chat -> modelo rápido y económico.
- Preguntas visuales -> VLM con imagen del robot.
- Acciones físicas o búsquedas en tiempo real -> ReAct agent con tools.
Buenas prácticas técnicas:
- Mantén esquemas de tools claros (nombre, descripción, argumentos).
- Limita el número de pasos con
max_tool_callspara evitar loops. - Para hardware real, usa un patrón de "confirm before actuation" para seguridad.
Ejemplo simplificado de configuración de rutas (concepto):
functions:
wikipedia_search:
_type: wiki_search
max_results: 2
react_agent:
_type: react_agent
llm_name: agent_llm
tool_names: [wikipedia_search]
router:
_type: router
route_config:
- name: other
description: preguntas que requieren razonamiento o herramientas
- name: chit_chat
description: charla simple
- name: image_understanding
description: preguntas que requieren ver la imagen
El demo sugiere usar el LLM Router de NVIDIA como referencia de producción para evaluación, balance costo-latencia y monitoreo.
Pasos prácticos para replicar la demo
- Clona el repositorio con el código de ejemplo:
git clone git@github.com:brevdev/reachy-personal-assistant
cd reachy-personal-assistant
- Configura claves si accedes a endpoints remotos (si vas a auto-hospedar no son necesarias):
Crea un archivo .env con:
NVIDIA_API_KEY=your_nvidia_api_key_here
ELEVENLABS_API_KEY=your_elevenlabs_api_key_here
- Levanta el NeMo Agent Toolkit (nat) para servir el workflow de chat:
cd nat
uv venv
uv sync
uv run --env-file ../.env nat serve --config_file src/ces_tutorial/config.yml --port 8001
- Verifica con una petición de prueba (ejemplo curl):
curl -s http://localhost:8001/v1/chat/completions -H "Content-Type: application/json" -d '{"model":"test","messages":[{"role":"user","content":"What is the capital of France?"}]}'
- Inicia el daemon de Reachy (simulado por defecto):
cd bot
uv run mjpython -m reachy_mini.daemon.app.main --sim --no-localhost-only (macOS)
o
uv run -m reachy_mini.daemon.app.main --sim --no-localhost-only (Linux)
- Arranca el servicio del bot (cliente Pipecat):
cd bot
uv venv
uv sync
uv run --env-file ../.env python main.py
- Abre la Pipecat Playground en
http://localhost:7860/, haz click en CONNECT, y concede micrófono/cámara.
Tendrás dos ventanas clave: la simulación de Reachy y la Pipecat Playground. Cuando el sistema muestre STATUS READY, el bot te saludará y podrás comenzar a probar prompts de texto o visión.
Ejemplos de prueba:
- Texto: "Explica qué puedes hacer en una frase."
- Visión: "¿Qué estoy sosteniendo frente a la cámara?"
Consideraciones de seguridad y rendimiento
- Privacidad: al ejecutar localmente en tu DGX Spark y controlar los endpoints, mantienes visibilidad completa del flujo de datos.
- Latencia: enrutar las consultas a modelos pequeños para charlas y a VLM remotos solo cuando sea necesario reduce costos y latencia.
- Profiling: NeMo Agent Toolkit ofrece métricas de tokens, latencia y cuellos de botella. Úsalas para ajustar modelos y rutas.
Dónde seguir si quieres profundizar
- Auto-hospedar modelos con NIM o vLLM para reducir dependencia de endpoints.
- Revisar el ejemplo LLM Router de NVIDIA para políticas de enrutamiento avanzadas.
- Explorar el SDK y docs de Reachy Mini para crear comportamientos físicos más complejos.
- Contribuir o adaptar la repo para apps comunitarias y casos de uso específicos.
Transformar un agente de texto en una presencia física controlada por modelos abiertos cambia la forma en que pensamos la asistente personal: deja de ser caja negra y pasa a ser un sistema controlable, extensible y explorable.