Inicio / Artículos

Gestionar agentes de IA con el marco CARE: Claridad, Autonomía y más.

Gestionar agentes de IA con el marco CARE: Claridad, Autonomía, Relación e Igualdad aplicadas a la delegación, los contratos de los agentes, la elección de modelos y el contexto.

Editor: REACTAPP.TOP7 min de lectura1565 palabras

Fuentes: You Already Know How to Manage Agents: The CARE Framework for AI Engineering

La formación en gestión a veces enseña cosas que se aplican al software de manera más directa de lo esperado. El marco CARE de la formación en liderazgo, con sus cuatro principios de Claridad, Autonomía, Relación e Igualdad, se corresponde casi uno a uno con las prácticas establecidas para gestionar agentes de IA. Seguir estos mismos principios al trabajar con agentes es una forma razonable de esperar mejores resultados. A continuación, cada principio se explica teniendo en cuenta a un agente de IA en el rol del miembro del equipo al que se le delega la tarea.

Situación actual

Hace uno o dos años, trabajar con un asistente de programación parecía consistir en una serie de comandos sencillos: crear una función, corregir un error, añadir pruebas. Hoy en día, los agentes pueden navegar por un repositorio, ejecutar comandos de shell, buscar información en la documentación, editar varios archivos a la vez, ejecutar pruebas y pasar el trabajo a subagentes. Sin embargo, a menudo siguen siendo gestionados como si fueran un sistema de autocompletado. El cuello de botella ya no es tanto la solicitud de acciones, sino la delegación.

En resumen, las cuatro preguntas CARE son:

  • Claridad: ¿cómo se ve el éxito?
  • Autonomía: ¿hasta qué punto puede tomar el control la persona?
  • Relación: ¿quién debería realizar este trabajo?
  • Equidad: ¿qué necesitan para tener éxito?

Los gerentes técnicos y líderes ya saben cuán importante es cada uno de estos aspectos para obtener buenos resultados sin tener que supervisar constantemente al ejecutor.

Claridad: defina los resultados, no las instrucciones

Supongamos que un interesado desea el uso del caché en el endpoint del perfil de usuario, y que la tarea será realizada por un agente de GenAI. Una solicitud típicamente vaga sería “implemente el caché para el endpoint del perfil de usuario”. Para una persona que conoce el sistema suena claro, pero en realidad no lo es. El agente tiene decenas de preguntas sin respuesta: ¿Qué endpoint exactamente? ¿Qué se almacenará en caché? ¿Por cuánto tiempo? ¿Qué hace que una entrada sea inválida? ¿Qué infraestructura de caché ya existe? ¿Qué se considera como tarea completada?

La claridad no significa una instrucción más larga; significa que el resultado deseado y las restricciones son inequívocos. Una versión más precisa de esa tarea:

Goal:
Reduce repeated database reads from GET /users/{id}.

Constraints:
- Use the existing Redis abstraction.
- Do not introduce a new dependency.
- Cache only successful responses.
- TTL: 10 minutes.
- Existing public API behavior must not change.

Before implementing:
- Inspect similar caching implementations in the repository.
- Identify how cache invalidation is handled elsewhere.

Validation:
- Existing tests must pass.
- Add tests for cache hit, cache miss, and invalidation.

Definition of done:
The implementation is complete when the endpoint behaves identically
from the client's perspective and repeated reads no longer hit MSSQL.

La ingeniería de prompts es solo una faceta de la claridad. La verdadera habilidad consiste en describir el trabajo de manera lo suficientemente buena como para que otra persona pueda llevarlo a cabo, algo que los gerentes y líderes hacen a diario.

Autonomía: responsabilidad, no solo instrucciones

Puede parecer que no existe la microgestión para los agentes, pero sí la hay. Cuando un agente depende de estímulos constantes, la causa habitual es la falta de claridad e instrucciones. Imagina una sesión como esta:

Find the problem.
Okay, fix it.
Now run the tests.
There's an error. Fix that.
Run them again.

El usuario coordina cada paso manualmente, y eso agota a ambas partes.

Un agente puede comprender una tarea perfectamente y aún así carecer de autonomía. La autonomía se refiere a la responsabilidad: qué puede decidir el agente, qué puede cambiar, hasta dónde debe actuar por sí solo y cuándo debe solicitar ayuda. Un contrato de agente expresa esto claramente:

You own this task until it is implemented and validated.

You may:
- inspect any file in the repository
- modify files related to this feature
- run builds, tests and static analysis
- create focused subagents for research or validation

After implementation:
1. Run the relevant test suite.
2. Inspect your diff for unintended changes.
3. Validate the implementation against the acceptance criteria.
4. Fix issues you discover before returning.

Escalate only if:
- the requested behavior conflicts with existing architecture
- required credentials/access are unavailable
- the change would require modifying a public API

La claridad determina el destino, y la autonomía define cuánto del viaje está bajo el control del agente. Sin embargo, la autonomía no significa poder hacer lo que se quiera; una autonomía saludable va acompañada de límites.

Relación: conoce a los agentes

La relación aquí se refiere a la calibración, no al antropomorfismo. Consiste en el conocimiento acumulado sobre las fortalezas, debilidades, modos de fallo y historial de los modelos y agentes en uso. Un gerente aprende dónde cada persona realiza su mejor trabajo, y ese mismo entendimiento debería desarrollarse también con respecto a una estructura de IA:

| Work                                  | Agent/model characteristic          |
| ------------------------------------- | ----------------------------------- |
| Repository-wide architecture research | Strong reasoning + large context    |
| Small mechanical refactor             | Fast, inexpensive model             |
| UI implementation from screenshots    | Strong vision model                 |
| Test generation                       | Fast coding specialist              |
| Final architecture critique           | Independent high-reasoning reviewer |

Una configuración con un solo modelo, un contexto gigantesco y todas las tareas asignadas a él está lejos de ser ideal. El trabajo debería destinarse a agentes equipados para ello. Los diseños multiagente no se trata de tener más agentes, sino de asignar tareas bien delimitadas al agente más adecuado para llevarlas a cabo:

Main Agent
│
├── Research Agent
│   └── Investigate existing caching patterns
│
├── Implementation Agent
│   └── Make the code change
│
└── Reviewer Agent
    └── Validate implementation independently

La relación mejora a medida que el sistema acumula conocimiento sobre decisiones arquitectónicas, convenciones de codificación, modos de fallo recurrentes, decisiones anteriores y qué modelos funcionan bien en qué tareas. En resumen, la relación se debe a la comprensión de los modelos más el contexto acumulado.

Equidad: proporcionar lo que necesita el agente

Una queja frecuente es “la IA volvió a alucinar” o “produció contenido de mala calidad”. Pero hay que analizar qué se le dio realmente al agente. No había documentación de API, requisitos de tickets, registros, código de ejemplo, notas de arquitectura ni forma de acceder a la aplicación en ejecución. ¿Fue un fallo del modelo, o se le pidió a alguien que resolviera un problema sin la información necesaria?

Supongamos que el agente pudiera encontrar o recibir todo eso:

.agent/
│
├── context/
│   ├── architecture.md
│   ├── domain.md
│   └── conventions.md
│
├── skills/
│   ├── debug-production.md
│   ├── review-mr.md
│   └── implement-feature.md
│
├── references/
│   ├── api-spec/
│   ├── examples/
│   └── decisions/
│
└── tools/
    ├── git
    ├── jira
    ├── logs
    ├── browser
    └── tests

El diseño exacto importa menos que el principio. Los agentes necesitan instrucciones adecuadas y herramientas. Un agente de depuración de producción puede requerir código, registros, trazas, despliegues recientes e historial de Git. Un agente de interfaz de usuario puede necesitar código, una captura de pantalla, el sistema de diseño, un navegador y documentación de componentes. Un revisor puede necesitar la diferencia entre versiones, el archivo completo, pruebas, el ticket, código similar y las pautas del repositorio. La inteligencia es la misma, pero la equidad difiere. Antes de concluir que el modelo no es capaz, pregúntese si estaba equipado para serlo.

CARE como lente de depuración

La dirección del proceso va desde la motivación hasta la delegación y finalmente la orquestación, y el papel del líder cambia junto con ella. Las personas talentosas ya rinden mal cuando los objetivos no están claros, hay microgestión, las tareas no se ajustan a sus capacidades o faltan recursos. Aplicar ese conocimiento a los agentes significa que los mismos hábitos de gestión ahora funcionan para todos aquellos que generan soluciones en un equipo, sean humanos o no.

Las cuatro características en una sola definición de agente

Los entornos de ejecución difieren en su estructura, pero una definición funcional de agente suele incluir los principios CARE de la siguiente manera:

---
name: implementation-agent
description: Implements scoped repository changes end-to-end. Use proactively for feature, bug-fix, and refactor tasks that require code changes and validation.
tools: Read, Grep, Glob, Edit, Write, Bash
model: inherit
---

You are an implementation agent responsible for completing scoped coding tasks end-to-end.

When given a task:

1. **Investigate**
   - Read the relevant code before changing it.
   - Search for similar implementations and existing project conventions.
   - Do not guess when repository evidence is available.

2. **Plan**
   - Form a short plan covering the files to change, the implementation approach, and validation.

3. **Implement**
   - Make the smallest change that fully satisfies the task.
   - Reuse existing patterns and dependencies.
   - Do not modify unrelated code.

4. **Validate**
   - Run the relevant tests, build/type-check, and lint/static analysis when available.
   - If your change causes a failure, fix it and validate again.

5. **Review**
   - Inspect the final diff.
   - Remove accidental or unrelated changes.
   - Confirm the requested behavior and acceptance criteria are satisfied.

Continue autonomously until the task is complete.

Escalate only when required access is unavailable, requirements materially conflict, or the task would require a destructive action or a public API/architecture change outside the requested scope.

The task is done only when the implementation is complete, relevant validation passes, and the final diff has been reviewed.

La delegación es la habilidad emergente

Los agentes no son personas, pero los sistemas construidos en torno a ellos sufren fallos de gestión sorprendentemente similares a los humanos. Si se les da a los agentes un objetivo poco claro, se controla cada paso que dan, se les asigna el modelo incorrecto o se les niega contexto e herramientas, su rendimiento disminuye. A medida que los agentes se vuelven más capaces, la ventaja ya no se limitará a modelos más potentes o instrucciones más precisas. Los equipos que aprenden a delegar bien sacarán el máximo provecho de la IA.

Leer más