El programa de IA entrenado que genera texto, código o respuestas. No es una base de datos con respuestas guardadas: es una red de pesos que, dada una entrada, calcula la salida más probable.
Diccionario
El vocabulario del AI coding, en simple.
Definiciones cortas y escaneables de los términos que aparecen todo el tiempo cuando programás con agentes. Buscá entre los términos de abajo, o saltá a una sección.
63 términos
El Modelo
Los números internos del modelo (los "pesos") que se ajustaron durante el entrenamiento. Cuando alguien dice que un modelo tiene "70B", se refiere a 70 mil millones de estos parámetros.
La unidad mínima que el modelo lee y escribe: trozos de palabras, no letras ni palabras enteras. "Programación" puede ser 3 o 4 tokens. Todo se mide y se cobra en tokens.
El proceso de cortar tu texto en tokens antes de que el modelo lo procese. Explica por qué a veces el modelo se confunde contando letras: no ve letras, ve tokens.
El acto de usar un modelo ya entrenado para generar una respuesta. Cada vez que le mandás un prompt y esperás la salida, eso es una inferencia.
El mecanismo de fondo: el modelo escribe un token a la vez, eligiendo cada uno según lo que vino antes. La respuesta entera se construye token por token, no de un saque.
Un ajuste que controla cuánto se arriesga el modelo al elegir cada token. Baja = respuestas más predecibles y repetibles; alta = más creativas y variadas.
Que el mismo prompt puede dar respuestas distintas en dos corridas. Es esperable: el modelo elige entre opciones probables, así que no esperes resultados idénticos siempre.
Hasta qué fecha llega lo que el modelo aprendió en su entrenamiento. No conoce nada que pasó después, salvo que se lo cuentes en el prompt o le des una herramienta de búsqueda.
Modo en que el modelo "piensa en voz alta" antes de responder, generando pasos intermedios. Mejora tareas difíciles a cambio de más tokens y más tiempo.
Un modelo que entiende más que texto: imágenes, capturas de pantalla, a veces audio. Útil para pegarle un screenshot de un error o un diseño y que lo lea.
Sesiones, Contexto y Turnos
Una conversación continua con el agente, desde que la abrís hasta que la cerrás. Todo lo que se dijo en la sesión vive en su contexto y se va acumulando.
El máximo de tokens que el modelo puede tener "a la vista" en una sola inferencia: tu prompt, el historial y los archivos leídos. Lo que no entra, el modelo no lo ve.
Toda la información que el modelo tiene cargada en este momento para responder: instrucciones, conversación, archivos y resultados de herramientas. Es su memoria de trabajo del instante.
Un ciclo de ida y vuelta: vos hablás, el agente actúa y responde. Una tarea compleja se resuelve en varios turnos, no en uno solo.
El mensaje que le mandás al modelo. Un buen prompt es específico, da contexto y dice qué resultado esperás; un prompt vago da resultados vagos.
Las instrucciones de fondo que definen cómo se comporta el agente: su rol, sus reglas y su tono. El usuario no siempre lo ve, pero condiciona todas las respuestas.
Cuando la conversación se acerca al límite de la ventana, el agente resume lo viejo para hacer lugar. Ganás espacio, pero se pierde detalle: lo importante hay que reanclarlo.
Cuando una sesión larga se va llenando de ruido y el agente empieza a perder el hilo o a contradecirse. La cura suele ser arrancar una sesión limpia con un buen resumen.
El degrade de calidad cuando la ventana está demasiado llena: aunque entre todo, el modelo presta menos atención a cada parte. Más contexto no siempre es mejor.
Pensar el contexto como un recurso limitado: cada archivo, cada salida de herramienta y cada mensaje gastan del mismo bolsillo. Gestionarlo bien mantiene al agente filoso.
Herramientas y Entorno
Una acción que el agente puede ejecutar más allá de escribir texto: leer un archivo, correr un comando, buscar en la web. Las herramientas son lo que convierte un chat en un agente.
El momento en que el modelo decide usar una herramienta y arma la petición con sus argumentos. El sistema la ejecuta y le devuelve el resultado para que siga.
Un estándar abierto para conectar agentes con herramientas y datos externos. En vez de programar cada integración a mano, un servidor MCP expone capacidades que el agente puede usar.
Un proceso que ofrece herramientas y recursos por el protocolo MCP: GitHub, una base de datos, tu sistema de archivos. Lo enchufás al agente y queda disponible.
La interfaz de línea de comandos: el agente vive en tu terminal y opera tu proyecto directo desde ahí. Es el entorno natural de herramientas como Claude Code.
Un entorno aislado donde el agente puede ejecutar comandos sin tocar tu sistema real. Da seguridad para dejarlo trabajar sin pedir permiso a cada paso.
Las reglas que deciden qué puede hacer el agente sin preguntarte. Una buena allowlist le deja correr lo rutinario solo y te consulta lo riesgoso.
Una copia de trabajo extra del mismo repo de git, en otra carpeta y otra rama. Permite que varios agentes trabajen en paralelo sin pisarse los archivos.
Un agente que el agente principal lanza para una tarea acotada, con su propio contexto. Devuelve solo la conclusión, así el agente padre no se llena de ruido.
Un paquete de instrucciones y archivos que le enseña al agente a hacer algo concreto (publicar un reel, generar audio). Se carga solo cuando hace falta.
Modos de Fallo
Cuando el modelo inventa algo con total seguridad: una función que no existe, una cita falsa, un dato erróneo. Suena convincente, pero no es real; siempre conviene verificar.
La tendencia del modelo a afirmar cosas con seguridad aunque no esté seguro. Rara vez te dice "no sé"; por eso hay que pedirle que muestre evidencia.
Cuando el modelo te da la razón solo por complacerte, en vez de señalar el error. Si querés crítica honesta, pedísela explícitamente.
Cuando el agente se traba repitiendo la misma acción fallida una y otra vez. Suele pasar al chocar con un error que no entiende; conviene cortarlo y redirigir.
Cuando el agente agrega más de lo que pediste: abstracciones, opciones y archivos que nadie necesitaba. Hace la tarea, pero infla el cambio y el riesgo.
Cuando el agente reemplaza código real por un comentario tipo "// resto igual" y borra cosas que importaban. Revisá siempre el diff antes de aceptar.
Un ataque donde un contenido externo (una página, un issue, un archivo) trae instrucciones ocultas que el agente obedece sin querer. Por eso no hay que confiar ciego en lo que lee.
En sesiones largas el agente deja de seguir una regla que diste al principio, porque quedó sepultada bajo todo lo nuevo. Reafirmá lo crítico o ponelo en un archivo de reglas.
Handoffs / Transferencias
Pasar el trabajo de un agente (o una sesión) a otro sin perder el hilo. La clave es un buen resumen del estado: qué se hizo, qué falta y por qué.
Una nota corta que captura dónde quedó la tarea: decisiones tomadas, archivos tocados y próximos pasos. Es lo que permite retomar sin re-explicar todo.
El documento que define qué hay que construir antes de empezar a programar. Una buena spec es el mejor handoff posible: el agente trabaja contra ella sin adivinar.
Coordinar varios agentes o pasos hacia un objetivo: quién hace qué, en qué orden y cómo se juntan los resultados. Un agente "orquestador" reparte y consolida.
Un punto guardado del trabajo (un commit, una nota, un resumen) al que podés volver si algo sale mal. Hacer checkpoints seguido es la red de seguridad del trabajo con agentes.
Deshacer los cambios del agente y volver al último estado bueno. Con git limpio y commits chicos, un rollback es barato; sin eso, duele.
Memoria y Dirección
Información que el agente recuerda entre sesiones, no solo dentro de una. A diferencia del contexto (que se borra al cerrar), la memoria persiste y se reutiliza.
El archivo de instrucciones del proyecto que el agente lee al arrancar: convenciones, reglas y dónde vive cada cosa. Es la forma más directa de dirigirlo de manera estable.
Guiar al agente mientras trabaja, sin reescribir todo: corregir el rumbo, acotar el alcance, marcar prioridades. Buen steering ahorra muchas idas y vueltas.
Comandos que se disparan solos en momentos clave del trabajo del agente (antes de un commit, al terminar). Sirven para automatizar reglas que el agente no debería tener que recordar.
Una instrucción corta y permanente que querés que el agente respete siempre. Cuando un error se repite, escribir una regla evita que vuelva a pasar.
Mostrarle al agente uno o dos ejemplos del resultado que querés, en vez de solo describirlo. A menudo un buen ejemplo dirige mejor que un párrafo de instrucciones.
Atar las respuestas del agente a fuentes reales (tu código, tus docs) en vez de a lo que "cree". Anclar bien reduce alucinaciones y hace verificable el resultado.
Recuperar fragmentos relevantes de tus documentos y meterlos en el contexto antes de responder. Le da al modelo información fresca y específica que no tenía de entrenamiento.
Patrones de Trabajo
Un modo donde el agente primero propone un plan y espera tu aprobación antes de tocar nada. Ideal para tareas grandes: alineás el rumbo antes de gastar trabajo.
Dejar que el agente ejecute todo sin pedir permiso a cada paso. Rapidísimo y peligroso a la vez: usalo solo en un sandbox o con git limpio para poder revertir.
Programar describiendo lo que querés en lenguaje natural y dejando que el agente escriba el código. Va bien para prototipos; para producción hay que revisar y entender lo que sale.
Escribir primero los tests y dejar que el agente programe hasta que pasen. Los tests le dan un objetivo verificable y atajan la sobre-ingeniería.
Que el agente compruebe su propio trabajo: correr la app, los tests o el build y arreglar lo que rompió. Sin verificación, "listo" no significa que funcione.
Mantener puntos de revisión donde una persona aprueba antes de seguir. Reservá el control humano para lo irreversible o caro, y automatizá el resto.
Un agente que corre solo, en paralelo, y te avisa cuando termina. Te libera para hacer otra cosa mientras él se ocupa de una tarea larga.
Lanzar varios agentes a la vez sobre partes independientes de un problema y juntar los resultados. Acelera el trabajo cuando las piezas no dependen entre sí.
Lo que entra y lo que no entra en una tarea. Definir el scope chico y claro es la mejor forma de obtener buen resultado de un agente: hacé esto, no más que esto.
Leer exactamente qué cambió antes de aceptarlo, línea por línea. Es el hábito que más separa el trabajo con agentes que funciona del que te explota después.