Mejora de la calidad del agente para optimizar el uso de inteligencia artificial

Introducción

Cuando los agentes tienen un alcance bien definido, han recibido instrucciones claras y operan dentro de límites claros, la eficiencia de tokens mejora de forma natural. Los agentes de alta calidad completan tareas en menos intentos, siguen flujos de trabajo más claros con menos reprocesos y evitan ciclos de depuración y corrección costosos.

Siga las estrategias expuestas en este artículo para mejorar tanto la calidad del agente como su AI credits eficiencia.

1. Elija el modelo adecuado para la tarea correcta

La elección del modelo es una de las formas más rápidas de mejorar la calidad del agente y la eficiencia de los costos, pero a menudo se pasa por alto. Un patrón común es establecer de forma predeterminada el modelo más capaz para cada tarea, pero esto a menudo aumenta el uso de tokens sin mejorar el resultado. En algunos escenarios pesados de ejecución, el uso excesivo de modelos de razonamiento puede reducir la calidad, ya que el modelo puede sobrecargar la tarea o introducir cambios innecesarios.

Elija el modelo en función del trabajo implicado:

• Modelos de razonamiento: mejor para las decisiones de arquitectura, la depuración compleja, el diseño del sistema y las tareas que requieren un análisis más profundo.
• Modelos de gama media: mejor cuando el plan ya está claro y el agente debe ejecutar de forma eficaz.
• Modelos más ligeros: mejores para refactorización, tareas de formato, actualizaciones de documentación y otros cambios rutinarios y bien delimitados.

Use tanta capacidad como requiera la tarea y tan poco como sea necesario. La capacidad de búsqueda de coincidencias con la tarea mejora los resultados y controla directamente los costos a escala.

Para obtener un desglose por modelo y tipo de tarea, consulte Comparación de modelos de IA mediante diferentes tareas.

Configurar el nivel de razonamiento del modelo

Algunos modelos también admiten niveles de razonamiento configurables, que determinan cuánto razona el modelo antes de responder. Un nivel superior puede mejorar las respuestas a problemas complejos, pero consume más tokens y, por tanto, más créditos, por lo que debe usar el nivel normal de forma predeterminada y elevarlo solo para tareas más difíciles. El razonamiento configurable está disponible para Visual Studio Code y CLI de Copilot para los modelos admitidos.

Consulte Modelos de IA admitidos en GitHub Copilot.

Utilice Copilot selección automática de modelos

Copilot selección automática de modelos elige un modelo adecuado para ti, según el objetivo de tu tarea.

Consulte Acerca de Copilotselección automática de modelos.

2. Proporcionar instrucciones claras en sus avisos

El mensaje establece la dirección de todo lo que hace el agente. Cuando una instrucción es imprecisa, el agente tiene que deducir la intención, explorar más el contexto y tomar decisiones de criterio. Eso suele dar lugar a reintentos, desviaciones del alcance y uso innecesario de tokens.

Los avisos bien estructurados tienen tres cualidades:

• Una definición de tarea clara. En lugar de "corregir este problema", explique cuál es el problema, dónde se produce y cuál es el aspecto esperado del resultado.
• Contexto pertinente proporcionado por adelantado. Si ya sabes qué archivos, servicios, registros, errores o datos de entrada son importantes, inclúyelos. Esto ayuda al agente a evitar la exploración innecesaria.
• Una condición de parada clara. Indique al agente qué significa «hecho». Sin un punto de detención, los agentes pueden continuar más allá del objetivo agregando confirmaciones adicionales, refactorizando código no relacionado o expandiendo el ámbito.

Esta guía agregada no aumenta significativamente el uso del token, pero puede reducir significativamente el número de ejecuciones de agente necesarias para alcanzar el resultado correcto.

Para consultar las prácticas recomendadas de ingeniería de prompts, vea Ingeniería de mensajes para GitHub Copilot Chat.

3. Mantén tu contexto reducido

Copilot envía como tokens de entrada el contexto al que tiene acceso, y ese contexto se va acumulando: las pestañas abiertas del editor, los archivos adjuntos y todo el intercambio de una conversación larga cuentan como contexto.

Para mantener el contexto bajo control, considere la posibilidad de hacer lo siguiente:

Inicia una nueva conversación cuando cambies de problema

Un hilo largo arrastra todo su historial en cada nueva petición. Al pasar a una tarea no relacionada, inicie una nueva conversación. Por ejemplo:

• En CLI de Copilot uso /new (o /clear)
• En Chat de Copiloto, inicie una nueva sesión de chat.

Compacte las sesiones largas CLI de Copilot que quiera continuar

Cuando necesites que el hilo continúe, pero haya crecido mucho, ejecuta /compact en CLI de Copilot para resumir el historial y reducir la ventana de contexto, centrando opcionalmente el resumen en un aspecto concreto (por ejemplo, /compact focus on the auth module).

Además, puede usar /context para comprobar el uso actual en cualquier momento.

Consulte Administración del contexto en CLI de GitHub Copilot.

Asigna a Copilot un mapa de tu proyecto

Un archivo de instrucciones personalizado bien mantenido, como un AGENTS.md archivo o .github/copilot-instructions.md , proporciona a los agentes una visión general estructural del repositorio para que no tengan que leer un gran número de archivos solo para orientarse a sí mismos. Consulte Compatibilidad con diferentes tipos de instrucciones personalizadas.

Traiga solo las herramientas que necesita.

Los conjuntos de herramientas grandes (por ejemplo, la cantidad de herramientas de un servidor MCP completo) añaden contexto con cada solicitud. Cuando se ajuste al flujo de trabajo, habilite solo los conjuntos de herramientas pertinentes para la tarea.

Consulte Configuración de conjuntos de herramientas para el servidor MCP de GitHub.

Aprovecha el almacenamiento en caché de contexto

Copilot reutiliza el contexto que ya has enviado mediante la caché, lo que reduce el coste de los turnos posteriores. Sin embargo, el contexto almacenado en caché expira después de un período de inactividad y no se reutiliza al cambiar los modelos a mitad de sesión. En ambos casos, el contexto se vuelve a enviar y se factura de nuevo como tokens de entrada nuevos. Para sacar el máximo partido al almacenamiento en caché, mantenga el trabajo relacionado dentro de una misma sesión continua y evite cambiar de modelo a mitad del proceso.

4. Reducir errores repetidos con un copilot-instructions.md archivo

Las instrucciones persistentes mejoran la coherencia entre las interacciones del agente, pero su valor depende completamente de cómo se escriben. Un copilot-instructions.md archivo en el nivel de repositorio es la manera más directa de codificar esta guía. Las instrucciones personales y las de nivel de organización pueden añadirse para lograr una mayor coherencia.

Las mejores instrucciones son breves, específicas y fundamentadas en el comportamiento real del agente observado, no los procedimientos recomendados genéricos que suenan bien, pero no se aplican al sistema.

Qué incluir:

• Marcos, bibliotecas o patrones de diseño necesarios
• Problemas conocidos que tiende a repetir el agente
• Expectativas sobre la salida, como "ser conciso" o "devolver solo código"
• Convenciones específicas del equipo que debe seguir el agente
• Comandos de compilación, prueba y lint

Qué evitar:

• Documentación larga y genérica
• Guía generada por IA que no refleja su sistema real
• Preferencias puntuales o detalles que rara vez se usan
• Instrucciones sobrecargadas que hacen que el contexto esté ruidoso

Mantenga las instrucciones actualizadas a medida que evoluciona el código base, la arquitectura, los estándares y los flujos de trabajo. Dado que estas instrucciones se incluyen en el contexto del agente en cada ejecución, incluso pequeñas mejoras pueden reducir los errores recurrentes y disminuir el desperdicio de tokens con el tiempo.

Para obtener más información, vea Agregar instrucciones personalizadas del repositorio para GitHub Copilot.

5. Investigación, planificación y luego implementación

Uno de los mayores cambios en el trabajo eficaz con agentes se aleja de hacer todo en una sola sesión. Cuando la investigación, la planificación y la implementación se producen conjuntamente, el contexto crece rápidamente, la información irrelevante se acumula y la calidad del agente se degrada con el tiempo.

Dividir el trabajo en fases claras:

• Investigación: Use el agente para explorar el código base, identificar los archivos pertinentes y comprender las dependencias.
• Plan: Cree un plan o una especificación detallados y estructurados antes de realizar cambios. Aquí es donde los modelos de razonamiento son más valiosos.
  • En CLI de Copilot, usa /plan.
  • En Chat de Copiloto en Visual Studio Code, seleccione "Plan" en el menú desplegable del agente o escriba plan en la ventana de contexto.
• Implementar: Ejecute según el plan utilizando un contexto específico y un modelo adecuado para ello.

Iniciar una nueva sesión entre fases evita arrastrar contexto innecesario. Arrastrar el contexto de fases anteriores puede aumentar el uso de tokens, introducir sesgos y reducir la claridad para el agente. Cada fase debe funcionar solo con lo que necesita. Para obtener orientación sobre cómo delimitar correctamente las sesiones, consulte Procedimientos recomendados para usar GitHub Copilot para trabajar en tareas.

6. Agregar límites de protección deterministas

Los agentes no son deterministas y no acertarán siempre, especialmente en flujos de trabajo de múltiples pasos. Sin mecanismos de control, los pequeños errores pueden acumularse rápidamente: los agentes se basan en resultados incorrectos, se desvían aún más del objetivo y hacen que la depuración sea más costosa y lleve más tiempo.

Los controles deterministas presentan señales claras de paso/error:

• Las pruebas unitarias comprueban que los cambios del agente generaron el comportamiento esperado.
• Linters aplica la estructura y la coherencia, evitando problemas de formato, desfase de estilo y trabajo de limpieza evitable.
• Los análisis de seguridad detectan los patrones de riesgo de forma temprana, antes de que sean más difíciles de corregir.

En conjunto, estos controles crean un bucle estrecho de retroalimentación: el agente realiza un cambio, una prueba, una regla o un análisis evalúan ese cambio, y el agente se corrige antes de seguir avanzando. Esto evita largas cadenas de cambios incorrectos, que son uno de los principales impulsores del desperdicio de tokens.

Los equipos que invierten en estas salvaguardas observan menos reintentos, una ejecución más rápida de las tareas y un comportamiento más predecible de los agentes. A menudo reducen el consumo total de tokens incluso si los pasos individuales usan ligeramente más tokens por adelantado.

Pasos siguientes

Además de mejorar la eficiencia del agente, también puede supervisar y administrar sus gastos para aprovechar al máximo su AI credits:

• Usa los controles de tu panel y de tu presupuesto. La página «Uso de IA», en https://github.com/settings/billing, desglosa el consumo por función y modelo, para que puedas ver en qué se están gastando realmente tus créditos y ajustar tu uso en consecuencia.
• Identifique patrones costosos antes de que se acumulen. Dentro de una CLI de Copilot sesión, use /usage para ver las métricas de nivel de sesión y para detectar patrones costosos a medida que trabaja. Además, /chronicle tips analiza el historial de sesión reciente y expone las oportunidades para usar Copilot de forma más eficaz.
• Actualiza para obtener un límite mayor. Si alcanza con frecuencia su límite mensual, un plan superior puede resultarle más económico que pagar por consumo adicional, ya que los planes superiores incluyen más AI credit. Consulte Información sobre los planes y ventajas de GitHub Copilot para individuos y Visualización y cambio del plan de GitHub Copilot.