En esta guía vas a aprender cómo usar el Agent Builder de OpenAI para diseñar agentes que no solo “hablan”, sino que siguen procesos, toman decisiones, usan herramientas, y se integran con sistemas reales. La idea es que termines con algo tangible: un flujo funcionando, ejemplos listos para copiar, y un paso a paso final para montar un chatbot de WhatsApp conectado a tu agente.
Base oficial: Agent Builder funciona como un lienzo visual para componer workflows con nodos conectados; el proceso típico es diseñar → publicar (con versión e ID) → desplegar (por ejemplo con ChatKit o exportando a Agents SDK).
Un agente es un sistema con un modelo como “cerebro” y un conjunto de instrucciones + herramientas + reglas para cumplir tareas. Puede enrutar pedidos, buscar información, pedir confirmaciones, ejecutar acciones y devolver resultados.
Agent Builder de OpenAI es una UI visual donde armás un workflow conectando nodos (pasos). Cada conexión define qué datos pasan entre pasos, y vos configurás cada nodo como si fuera un “bloque” de lógica.
Acá van usos típicos donde Agent Builder brilla:
Soporte al cliente: clasificar consultas, buscar en documentación (File search), responder con tono consistente, escalar a humano si hace falta.
Ventas/SDR: calificar leads, detectar intención, hacer preguntas, ofrecer próximos pasos, registrar datos, derivar a un cierre.
Operaciones: “tomá esto → validalo → transformalo → mandalo a X sistema”.
Asistentes internos: responder políticas internas, onboarding, manuales, procedimientos.
Automatizaciones con control: ejecutar acciones, pero con “User approval” antes de tocar algo sensible.
En el panel New agent (Draft) con categorías. Cada ítem es un tipo de nodo:
Agent: el nodo “pensante”. Acá definís instrucciones, modelo y cómo responde. Es el músculo principal del flujo.
Classify: clasifica una entrada en categorías (por ejemplo: Ventas / Soporte / Facturación). Perfecto para ruteo.
End: termina el workflow y devuelve el resultado final.
Note: anotaciones internas para vos o tu equipo. No ejecuta lógica; documenta.
File search: permite recuperar información desde archivos/bases indexadas para responder con contexto (ideal para FAQs, manuales, PDFs internos).
Guardrails: reglas de seguridad/comportamiento (por ejemplo, evitar prompt injection, limitar temas, forzar formatos, bloquear datos sensibles).
MCP: conector para herramientas externas mediante el enfoque MCP (cuando querés que el agente “hable” con servicios/acciones externas de forma estandarizada). Plataforma OpenAI
If / else: bifurcación. “Si pasó X, andá por A; si no, por B”.
While: bucle. “Repetí hasta que se cumpla una condición” (por ejemplo, pedir más datos hasta tener nombre + mail + necesidad).
User approval: freno con confirmación humana. Útil para: enviar emails, crear tickets, cargar datos en CRM, etc.
Transform: convierte/normaliza datos (texto → JSON, limpiar campos, extraer email/teléfono, formatear una respuesta).
Set state: guarda variables de estado (memoria del workflow): nombre del lead, etapa, producto, presupuesto, etc.
Todo esto encaja con la idea oficial: un workflow se compone de nodos y conexiones que controlan secuencia y flujo.
Start (izquierda) → My agent (Agent) (derecha)
Una línea conecta ambos: eso representa el paso de datos del input al agente.
Arriba se ven controles del editor (por ejemplo, ejecutar/preview, opciones del proyecto).
Abajo se ven controles típicos del canvas (mover, agregar, deshacer/rehacer, etc.).
Qué significa ese flujo: el usuario escribe algo → Start lo ingresa al historial y lo expone como texto → el nodo Agent toma eso y responde.
Un agente que:
entiende el mensaje,
decide si es ventas o soporte,
responde con el tono correcto,
y guarda datos si es lead.
Entrá a Agent Builder desde la plataforma.
Creá un “New agent” (queda en Draft mientras editás).
Arrastrá Start.
Arrastrá Classify.
Arrastrá Agent (uno para Ventas y otro para Soporte).
Arrastrá End.
Conectá así:
Start → Classify
Desde Classify, bifurcás:
si categoría = ventas → Agent (Ventas) → End
si categoría = soporte → Agent (Soporte) → End
(La bifurcación la podés hacer con salidas del Classify o con If/else, según cómo lo estés modelando.)
Creá categorías claras:
VENTAS
SOPORTE
OTRO
Y agregá ejemplos (pocos pero buenos):
“¿Cuánto sale?” → VENTAS
“No anda el login” → SOPORTE
“Hola” → OTRO
Instrucciones sugeridas (copiá/pegá y ajustá):
Rol: Asistente de ventas breve, profesional y útil.
Objetivo: calificar en 5 preguntas máximo: nombre, empresa, qué necesita, urgencia, presupuesto.
Restricciones: no inventar precios, si faltan datos pedirlos, ofrecer agendar demo.
Tip SEO/negocio: pedí siempre un siguiente paso (link, llamada, demo). Ventas ama los próximos pasos.
Rol: Soporte técnico paso a paso.
Regla: si el problema requiere datos (URL, plugin, captura), pedirlos antes de adivinar.
Cierre: confirmar si se resolvió o escalar.
Si querés que “recuerde” datos:
Después del Agent de Ventas, agregá Set state.
Guardá variables:
lead_name
lead_company
lead_need
Luego cerrás en End.
Agent Builder tiene Preview para ejecutar el workflow y ver qué hace cada nodo, paso por paso.
Usuario: “Hola, necesito una web y quiero saber planes.”
→ Classify: VENTAS
→ Agent Ventas: pregunta 2–3 cosas y propone demo.
Usuario: “Desde ayer no me carga el checkout.”
→ SOPORTE
→ Agent Soporte: pide URL + plugins + si hubo updates + consola del navegador.
Una arquitectura de ventas típica y efectiva:
Classify: detecta intención (curioso vs lead caliente vs soporte).
Agent (SDR): hace preguntas cortas y ordenadas.
Transform: extrae datos en formato limpio (por ejemplo, JSON con nombre/mail).
User approval: “¿Confirmás que enviemos propuesta / agendemos llamada?”
MCP (opcional): mandar datos a CRM, Sheets, email, etc.
En otras palabras: tu agente deja de “conversar lindo” y empieza a operar un embudo.
Cuando el flujo te cierra:
Publish: crea una versión “snapshot” con ID y versionado.
Deploy (dos caminos típicos):
ChatKit: si lo querés embebido como chat en web/app (rápido).
Export a Agents SDK: si querés correrlo vos en tu backend y conectarlo a otros canales (WhatsApp, Telegram, etc.).
Acá vamos con el camino más común para WhatsApp: WhatsApp ↔ (Twilio) ↔ tu servidor (webhook) ↔ tu agente (Agents SDK / workflow exportado).
Nota: WhatsApp requiere un proveedor/API y un webhook público para recibir mensajes. Twilio suele ser la forma más directa para empezar (sandbox) y luego pasar a producción.
Una cuenta en Twilio con WhatsApp habilitado (sandbox o número).
Un servidor simple (tu PC sirve) con Node.js instalado.
Una forma de exponer tu servidor a internet: ngrok (para pruebas).
Tu workflow listo en Agent Builder y exportado (Agents SDK) o accesible como deployment que puedas invocar desde backend.
Armá el workflow (Start → Agent → End mínimo).
Probalo con Preview.
Publish.
Andá a la opción de Code para exportar/usar con Agents SDK (según te ofrezca el panel).
Entrá a Twilio.
Activá WhatsApp Sandbox.
Twilio te da:
un número de WhatsApp,
un código tipo “join XXXX”.
Desde tu WhatsApp personal, mandás ese “join …” al número de Twilio para vincular tu chat al sandbox.
Vas a armar un servidor que:
recibe el mensaje de WhatsApp,
se lo pasa a tu agente,
responde a WhatsApp con el texto generado.
Ejemplo en Node.js (simple y directo). Pegalo en un archivo server.js:
Ahora instalás dependencias y corrés:
Instalá ngrok.
Corré:
Te va a dar una URL pública tipo https://xxxxx.ngrok-free.app.
Tu endpoint final queda:https://xxxxx.ngrok-free.app/whatsapp
Este patrón (Flask/FastAPI/Express + ngrok) es el flujo típico para pruebas de bots en WhatsApp.
En la consola de Twilio (WhatsApp sandbox):
Buscá “When a message comes in” (o similar).
Pegá tu URL pública + /whatsapp.
Guardá.
Mandá un mensaje a tu chat con el sandbox:
“Hola”
“Quiero contratar”
“No me funciona X”
Si el webhook responde, Twilio te devuelve el mensaje. Si no, revisá:
que el server esté corriendo,
que ngrok esté activo,
que la URL en Twilio sea la de ngrok correcta,
y que el endpoint sea /whatsapp.
Acá reemplazás el reply falso por la ejecución real del workflow exportado.
La forma exacta depende de cómo lo exportes, pero el concepto es siempre el mismo:
Recibir texto del usuario.
Pasárselo a tu runner (Agents SDK / workflow).
Devolver texto final.
Referencia oficial: podés diseñar en Agent Builder y luego descargar/usar con Agents SDK para desplegarlo vos.
Si querés que esto no se caiga cuando alguien escribe “hola” a las 3 AM:
Guardá historial por usuario (from) en una DB (Redis sirve mucho).
Sumá Guardrails en tu workflow (bloqueos, límites, formato).
Usá User approval si el bot va a enviar cosas sensibles (emails, presupuestos, altas).
Pasá de ngrok a un hosting real (VPS / Cloud Run / Render / etc.).
Los desarrollos actuales sugieren que su evolución irá en varias direcciones:
Procesamiento de video en tiempo real con menor costo computacional.
Modelos capaces de ejecutarse de forma local sin depender completamente de la nube.
Asistentes personales con voz natural, memoria persistente y capacidad de planificación.
Integración en dispositivos físicos como automóviles, electrodomésticos y sensores urbanos.
Colaboración prolongada entre humanos e IA en proyectos largos y complejos.
El horizonte es amplio y su adopción apenas está comenzando.
Agent Builder de OpenAI te permite pasar de “un chat que responde” a un sistema con pasos, decisiones, herramientas y memoria, todo armado en un canvas visual y listo para publicar con versiones. Y cuando lo combinás con un webhook (por ejemplo WhatsApp vía Twilio), el agente deja de vivir en una demo y empieza a operar donde importa: en tu canal de atención y ventas. Si tu objetivo es tener procesos repetibles (y no depender de la “inspiración” del día), esto es literalmente ponerle rieles a la IA… sin sacarle potencia.
OpenAI – Agent Builder (documentación oficial)
Guía completa sobre el constructor visual de agentes, nodos, publicación y despliegue.
👉 https://platform.openai.com/docs/agents/agent-builder
OpenAI – Agents (conceptos generales)
Explicación conceptual de qué son los agentes, cómo funcionan y para qué se utilizan.
👉 https://platform.openai.com/docs/agents
OpenAI – Nodes Reference (referencia de nodos)
Documentación detallada de cada tipo de nodo disponible en Agent Builder (Agent, Classify, If/Else, Tools, etc.).
👉 https://platform.openai.com/docs/agents/nodes
OpenAI – Agents SDK
SDK oficial para ejecutar agentes creados en Agent Builder desde tu propio backend.
👉 https://platform.openai.com/docs/agents/sdk
OpenAI – Agent Platform Overview
Visión general de la plataforma de agentes: diseño, versionado, publicación y despliegue.
👉 https://platform.openai.com/docs/guides/agents
OpenAI Developers – Building Agents
Guía práctica para construir agentes paso a paso, con ejemplos de flujos y buenas prácticas.
👉 https://platform.openai.com/docs/guides/building-agents
OpenAI – Tool & Guardrails Concepts
Documentación sobre seguridad, guardrails y control de comportamiento de agentes.
👉 https://platform.openai.com/docs/agents/guardrails
Twilio – WhatsApp API Overview
Introducción oficial a la API de WhatsApp de Twilio y su funcionamiento.
👉 https://www.twilio.com/whatsapp
Twilio – WhatsApp Sandbox Quickstart
Guía paso a paso para probar un chatbot de WhatsApp usando el sandbox de Twilio.
👉 https://www.twilio.com/docs/whatsapp/sandbox
Twilio – Receive and Respond to WhatsApp Messages
Ejemplos técnicos de webhooks para recibir y responder mensajes de WhatsApp.
👉 https://www.twilio.com/docs/whatsapp/tutorial/responding-to-incoming-messages
ngrok – Exposing Local Servers
Documentación oficial para exponer servidores locales y probar webhooks.
👉 https://ngrok.com/docs
Node.js – Express Framework
Framework utilizado en el ejemplo de webhook para WhatsApp.
👉 https://expressjs.com/
© 2026 Kiwi Soluciones Digitales
