Agentes, prompts, skills, MCP: el vocabulario completo del desarrollo con IA en 2026

Abriste Claude Code, leíste sobre CLAUDE.md. Luego encontraste que Cursor usa .cursorrules. Después alguien mencionó AGENTS.md. GitHub Copilot tiene copilot-instructions. Y encima de eso: skills, MCP, function calling, plugins, slash commands, subagentes.

El problema no es que las herramientas sean complicadas. El problema es que cada una inventó su propio vocabulario para describir conceptos casi idénticos, y ahora el ecosistema parece más caótico de lo que es.

Este artículo es el mapa. Después de leerlo, vas a entender qué término corresponde a qué concepto, qué es estándar y qué es vendor-specific, y cuáles de estas tecnologías van a sobrevivir.

1. Los archivos de contexto: cada herramienta, su propio nombre

El concepto es simple: le das al agente un archivo que describe tu proyecto, tus convenciones, cómo trabajas. El agente lo lee al inicio de cada sesión y "recuerda" el contexto.

El problema es que cada herramienta llamó ese archivo de forma diferente:

El estándar emergente: AGENTS.md

En agosto de 2025, OpenAI publicó la especificación AGENTS.md como un formato neutral. En diciembre del mismo año, lo donaron a la Linux Foundation bajo el paraguas del AAIF — Agentic AI Interoperability Foundation.

Resultado: más de 60,000 repositorios open source ya tienen un AGENTS.md, y lo soportan Cursor, Copilot, Devin, Aider, Zed, Warp, Factory, Jules, Amp, y Windsurf.

Dato curioso: muchos asumen que AGENTS.md es un estándar "de la comunidad". Es de OpenAI. Lo crearon, lo publicaron, y luego lo donaron para que tuviera credibilidad neutral.

CLAUDE.md vs AGENTS.md: ¿cuál usar?

Si trabajas principalmente con Claude Code: CLAUDE.md. Si trabajas con múltiples herramientas en el mismo repo: AGENTS.md. Si usas OpenCode: cualquiera de los dos funciona — lee ambos.

El contenido que va en esos archivos es idéntico: instrucciones de proyecto, convenciones de código, qué herramientas están disponibles, qué no hacer. La diferencia es solo el nombre del archivo.

El sistema más sofisticado: Kiro de AWS

Kiro introdujo cuatro modos de inclusión para sus archivos de contexto (.kiro/steering/*.md):

• always: se incluye en todas las interacciones
• fileMatch: se incluye cuando se edita un archivo que cumple un patrón
• auto: el agente decide si incluirlo
• manual: solo cuando el usuario lo pide explícitamente

Ningún competidor tiene esto. Es el sistema más granular del mercado hoy.

2. Skills: el nuevo estándar para procedimientos reutilizables

Un skill es un procedimiento nombrado que el agente puede ejecutar. Piénsalo como una función: tiene nombre, recibe contexto, y ejecuta una secuencia de pasos.

La confusión con los slash commands

En Claude Code original, existían los Commands — archivos .md en .claude/commands/ que se activaban escribiendo /nombre-del-comando. Eran simples: un archivo markdown con instrucciones.

En diciembre de 2025, Anthropic publicó la especificación Agent Skills en agentskills.io. Los skills reemplazaron a los commands con un formato más estructurado:

.claude/skills/
  deploy-production/
    SKILL.md          ← definición del skill
    checklist.md      ← archivos de soporte
    validate.sh       ← scripts que el skill puede usar

El frontmatter mínimo de un SKILL.md según el estándar:

---
name: deploy-production
description: Verifica, buildea y despliega a producción con rollback automático
---

Claude Code extiende esto con campos propios: allowed-tools, context, agent, paths, disable-model-invocation, y más.

La velocidad de adopción

En 48 horas de publicado el estándar:

• Microsoft (VS Code) anunció soporte
• OpenAI (Codex) lo adoptó

Hoy, 32 herramientas leen el mismo SKILL.md del mismo directorio. Esto es inusual en el ecosistema de IA, donde la fragmentación es la norma.

Dónde viven los skills por herramienta

3. Plugins, Function Calling y MCP: la historia de cómo las herramientas se conectan al mundo

Esta sección tiene historia. Y la historia importa para entender por qué el ecosistema terminó donde está.

ChatGPT Plugins: el experimento que falló (2023-2024)

En marzo de 2023, OpenAI lanzó los ChatGPT Plugins. La idea: cualquier servicio podía publicar un plugin, y los usuarios los instalaban en ChatGPT para extender sus capacidades.

Duró menos de un año.

En abril de 2024, OpenAI deprecó los plugins y los reemplazó con GPT Actions. El problema de los plugins no era técnico — era de distribución y confianza. Los usuarios no sabían qué plugins instalar, los desarrolladores no sabían si valía la pena construirlos, y el modelo de seguridad era opaco.

Los GPT Actions resolvieron parte del problema al integrar las extensiones directamente en los GPTs personalizados. Pero el concepto "plugin" como categoría nunca sobrevivió.

Function Calling: el estándar de bajo nivel

Mientras tanto, OpenAI publicó Function Calling (hoy llamado tool calling) — un mecanismo a nivel de API donde defines funciones que el modelo puede invocar, y el modelo devuelve una llamada estructurada cuando necesita usarlas.

{
  "name": "get_weather",
  "description": "Obtiene el clima actual de una ciudad",
  "parameters": {
    "type": "object",
    "properties": {
      "city": { "type": "string" }
    }
  }
}

Este patrón se convirtió en el estándar de facto a nivel de API. Claude lo adoptó, Gemini lo adoptó, Mistral lo adoptó. Es la base técnica sobre la que se construye todo lo demás.

El problema: function calling es local al request. Las herramientas se definen en cada llamada, no son descubribles, y requieren que la aplicación cliente las maneje explícitamente.

MCP: el protocolo ganador

En noviembre de 2024, Anthropic publicó el Model Context Protocol (MCP). La diferencia conceptual con function calling:

Function calling: Las herramientas están embebidas en el request. El cliente decide qué herramientas existen.

MCP: Las herramientas son servicios independientes con dirección de red. El cliente conecta servidores MCP y descubre dinámicamente qué herramientas ofrecen. No hay vendor lock-in. Un servidor MCP de filesystem funciona igual en Claude Code, Cursor, Copilot y Zed.

La adopción fue extraordinariamente rápida:

• Noviembre 2024: Anthropic lanza MCP
• Enero 2025: Cursor y Windsurf lo adoptan
• Marzo 2025: OpenAI lo adopta oficialmente
• Q3 2025: Microsoft publica servidores MCP para GitHub, Azure, y Teams
• Diciembre 2025: Se dona a la Linux Foundation (AAIF)
• Marzo 2026: Google añade soporte en Gemini API y Vertex AI

Hoy: más de 10,000 servidores MCP públicos, 97 millones de descargas mensuales del SDK.

Cómo se ve un servidor MCP en la práctica

Un servidor MCP expone tres tipos de recursos:

• Tools: funciones que el modelo puede invocar (run_query, create_file, send_email)
• Resources: datos que el modelo puede leer (archivos, filas de DB, contenido de API)
• Prompts: plantillas de prompts reutilizables

El cliente (Claude Code, Cursor, etc.) se conecta al servidor, lista qué ofrece, y el modelo puede usar cualquiera de esos recursos durante la sesión.

4. Agente vs Copiloto: la distinción técnica que importa

Este es el malentendido más frecuente. La confusión es parcialmente culpa de GitHub, que llamó "Copilot" a su herramienta y luego le añadió "Agent Mode".

La distinción técnica es simple: el bucle.

Copiloto: sugerir y esperar

Un copiloto actúa una vez por interacción. Tú preguntas, él sugiere, tú decides. No hay autonomía entre turnos.

Usuario → Prompt → Modelo → Respuesta → Usuario (fin)

GitHub Copilot en modo completado de código es un copiloto puro. Cursor en Ask Mode también.

Agente: objetivos y bucles

Un agente recibe un objetivo, no una pregunta. Luego ejecuta un bucle:

Objetivo → Percibir estado → Planificar acción → Ejecutar → 
Observar resultado → ¿Objetivo cumplido? → No → Percibir estado → ...

Claude Code es un agente. Devin es un agente. GitHub Copilot en Agent Mode (el modo asíncrono de larga duración) es un agente.

El punto de confusión: GitHub Copilot tiene cinco modos

GitHub Copilot hoy existe en cinco variantes con nombres distintos:

1. Code Completion: autocompletado inline, el copiloto clásico
2. Ask Mode: chat con el codebase, aún copiloto
3. Edit Mode: edita múltiples archivos, semi-agente (sin bucle)
4. Agent Mode: bucle autónomo, ejecuta comandos, instala dependencias
5. Coding Agent: versión asíncrona para tareas largas (issues de GitHub)

El nombre "Copilot" abarca todo el espectro. Por eso la confusión.

La definición operacional que usamos en Aiuda Labs

Un sistema es un agente si puede:

1. Ejecutar acciones sin aprobación por cada paso
2. Observar los resultados de sus acciones
3. Modificar su plan basado en esos resultados
4. Persistir en el objetivo a través de múltiples ciclos

Por esta definición: Claude Code, Devin, OpenCode en modo autónomo, y GitHub Copilot Agent Mode son agentes. El resto son copilotos con capacidades variables.

5. Multi-agente: cuando los agentes se coordinan

Un solo agente tiene limitaciones de contexto y de tiempo de ejecución. La respuesta del ecosistema: orquestar múltiples agentes.

El patrón orquestador-subagente

El agente principal (orquestador) recibe el objetivo, lo descompone en subtareas, y delega cada subtarea a un subagente especializado. Los subagentes trabajan en paralelo o en secuencia, y reportan resultados al orquestador.

Claude Code lo hace explícitamente: el Task tool lanza subagentes en worktrees aislados. Cada subagente tiene su propio contexto, sus propias herramientas, y no contamina el contexto del orquestador.

Google A2A: el protocolo de comunicación entre agentes

En 2025, Google publicó el protocolo A2A (Agent to Agent). Si MCP resuelve la comunicación agente-herramienta, A2A resuelve la comunicación agente-agente.

Con A2A, un agente Claude puede delegar una subtarea a un agente Gemini, recibir el resultado, y continuar. Los agentes se descubren mutuamente, negocian capacidades, y se coordinan sin que el desarrollador codifique las integraciones manualmente.

El stack completo de interoperabilidad resultante:

AGENTS.md / CLAUDE.md          ← contexto de proyecto
Agent Skills (SKILL.md)        ← procedimientos reutilizables
MCP                            ← herramientas y recursos
A2A                            ← comunicación entre agentes

Estas cuatro piezas, todas donadas a la Linux Foundation o construidas sobre estándares abiertos, forman la infraestructura para agentes interoperables entre vendors.

6. Prompts como artefactos versionables

El último concepto que cierra el mapa: los prompts no son texto efímero que escribes en el chat. Son artefactos de primera clase que viven en el repositorio, se versionan con git, y se comparten con el equipo.

Dónde viven los prompts por herramienta

La diferencia entre un prompt de sistema y un prompt de usuario:

• Sistema: siempre activo, define el comportamiento base del agente en el proyecto
• Usuario: se activa a demanda (slash command, tecla de atajo), ejecuta una acción específica

Un ejemplo concreto: tienes .claude/commands/review-pr.md con instrucciones para revisar un PR según tus estándares. Escribes /review-pr y Claude Code ejecuta esa revisión con el contexto del PR actual. Ese prompt vive en git, lo revisa el equipo, evoluciona con el proyecto.

El mapa completo

Si tuvieras que explicarle a alguien el ecosistema en una tabla:

Lo que esto significa en la práctica

Si desarrollas con IA en 2026, estas son las decisiones concretas:

1. Escribe un archivo de contexto. Si usas una sola herramienta, usa su formato nativo. Si tu equipo usa múltiples herramientas, usa AGENTS.md — es el formato con mayor adopción y está respaldado por la Linux Foundation.

2. Crea skills para los procedimientos que repites. Despliegue a producción, revisión de código, generación de tests — todo lo que ejecutas más de tres veces merece un skill. El formato SKILL.md funciona en 32 herramientas.

3. Usa MCP para conectar herramientas externas. ¿Necesitas que el agente acceda a tu base de datos, tu Jira, tu Slack? Usa un servidor MCP en lugar de escribir la integración a mano. El ecosistema de servidores MCP ya tiene lo que necesitas.

4. Distingue entre copiloto y agente. Para tareas de edición rápida, un copiloto (Cursor en Edit Mode, Copilot Code Completion) es suficiente y más predecible. Para tareas de múltiples pasos con incertidumbre (migrar un sistema, implementar una feature compleja, depurar un error de producción), un agente (Claude Code, Devin, Copilot Agent Mode) es la herramienta correcta.

5. Versiona todo. Context files, skills, y prompts viven en el repositorio. Son parte del código, no del chat.

El vocabulario se estabilizó más de lo que parece desde fuera. Los estándares que importan — AGENTS.md, Agent Skills, MCP — tienen respaldo institucional y adopción real. Lo que quedó fuera —plugins, cursorrules legacy, commands de Claude Code— está en proceso de desaparecer.

El ecosistema de agentes de IA en 2026 tiene más infraestructura compartida que fragmentación. Ya es posible construir un skill que funcione en Claude Code, Cursor, y OpenCode sin modificarlo. Eso no era cierto hace 18 meses.

Referencias

La información de este artículo fue verificada contra la documentación oficial de cada herramienta. Las fuentes principales:

Archivos de contexto

• Claude Code — CLAUDE.md docs
• GitHub Copilot — Custom instructions
• Cursor — Rules docs
• Windsurf — Memories & Rules
• OpenCode — Rules
• Kiro — Steering docs
• Zed — AI Rules
• AGENTS.md specification
• Linux Foundation AAIF announcement

Skills

• Agent Skills open standard — agentskills.io
• Claude Code Skills docs
• OpenCode Skills
• The Decoder — Agent Skills adoption

MCP

• Model Context Protocol — documentación oficial
• MCP adoption statistics 2026
• OpenAI adopts MCP — anuncio oficial

Agentes y protocolos

• GitHub Copilot modes — docs oficiales
• Google A2A protocol announcement
• OpenAI Function Calling