Ir al contenido principal
Español— Elegir un idioma
Menú

Estrategias de contexto para agentes

Lección 14 de 20 Actualizado el 28 de julio de 2026 Avanzado
En esta página
  1. El desafío del contexto para los agentes
  2. Una memoria de tres niveles
  3. Domesticar los resultados de las herramientas
  4. Cuando varios agentes trabajan juntos
  5. Puntos clave

El desafío del contexto para los agentes

Un agente autónomo encadena decenas de llamadas a la API: razona, utiliza herramientas, lee resultados e itera. En cada paso, el contexto crece. La diferencia respecto a una conversación ordinaria es que este crecimiento no proviene del usuario, sino del propio agente: una consulta SQL que devuelve trescientas filas, una página web completa recuperada o un archivo de registro entero leído. Sin una estrategia de gestión, un agente alcanza el límite de contexto en pocas iteraciones, a menudo antes de finalizar la tarea que le has asignado.

Diseñar un agente que gestione su memoria de forma eficaz se reduce, por tanto, a responder tres preguntas: qué debe permanecer intacto, qué se puede resumir y qué no debería haber entrado en el contexto en primer lugar. Abordaremos estas cuestiones en ese orden.

Una memoria de tres niveles

La estructura que utilizamos se basa en la distinción clásica entre memoria de trabajo, memoria episódica y memoria semántica. La memoria de trabajo contiene las acciones más recientes en su forma bruta, ya que el agente las necesita exactamente así para decidir qué hacer a continuación. La memoria episódica conserva resúmenes de pasos anteriores: el agente sabe que exploró una determinada pista y qué obtuvo de ella, sin necesidad de releer los detalles. Por último, la memoria semántica acumula hechos establecidos de una vez por todas —el ID del cliente, la versión del esquema de la base de datos, la restricción presupuestaria— que nunca deben perderse en un resumen.

from dataclasses import dataclass, field

@dataclass
class AgentMemory:
    """Sistema de memoria de tres niveles para un agente."""

    # Nivel 1: memoria de trabajo (contexto actual)
    working: list[dict] = field(default_factory=list)

    # Nivel 2: memoria episódica (resúmenes de pasos anteriores)
    episodes: list[str] = field(default_factory=list)

    # Nivel 3: memoria semántica (hechos permanentes)
    facts: list[str] = field(default_factory=list)

    max_tokens_working: int = 20_000
    max_episodes: int = 10

    def add_action(self, action: str, result: str):
        """Añade una acción a la memoria de trabajo."""
        self.working.append({
            "action": action,
            "result": result[:2000],  # Truncar resultados largos
        })
        self._check_compaction()

    def add_fact(self, fact: str):
        """Añade un hecho permanente."""
        if fact not in self.facts:
            self.facts.append(fact)

    def _check_compaction(self):
        tokens = sum(
            len(str(e)) // 4 for e in self.working
        )
        if tokens > self.max_tokens_working:
            self._compact()

    def _compact(self):
        """Compacta la memoria de trabajo en un episodio."""
        import openai
        client = openai.OpenAI()

        text = "\n".join(
            f"Action: {a['action']}\nResult: {a['result']}"
            for a in self.working[:-2]
        )

        response = client.responses.create(
            model="gpt-5.6-terra",
            input=(
                "Resume estas acciones del agente en 3-5 puntos clave. "
                "Conserva los hechos importantes, resultados y decisiones.\n\n"
                f"{text}"
            ),
            max_output_tokens=300,
        )

        self.episodes.append(response.output_text)
        self.working = self.working[-2:]  # Mantener las últimas 2 acciones

        # Limitar el número de episodios
        if len(self.episodes) > self.max_episodes:
            self.episodes = self.episodes[-self.max_episodes:]

    def build_context(self) -> str:
        """Construye el contexto completo para la siguiente llamada."""
        parts = []

        if self.facts:
            parts.append(
                "Hechos establecidos:\n" + "\n".join(f"- {f}" for f in self.facts)
            )

        if self.episodes:
            parts.append(
                "Historial resumido:\n" + "\n---\n".join(self.episodes)
            )

        if self.working:
            parts.append(
                "Acciones recientes:\n" + "\n".join(
                    f"- {a['action']} → {a['result'][:500]}"
                    for a in self.working
                )
            )

        return "\n\n".join(parts)

Dos parámetros merecen discusión antes de que los copies tal cual. El truncamiento de 2.000 caracteres en add_action protege contra herramientas verbosas, pero corta a ciegas: si tus herramientas devuelven JSON, acabarás con un objeto inválido en medio de tu contexto. Y max_episodes: 10 impone una amnesia acotada: en el undécimo resumen, el primero desaparece. Para un agente que se ejecuta durante mucho tiempo, promueve los hechos importantes a facts antes de que salgan de la ventana episódica, o los perderás permanentemente.

Domesticar los resultados de las herramientas

Las herramientas suelen devolver resultados voluminosos: páginas web, resultados SQL, contenidos de archivos. Esta es, con diferencia, la causa principal de saturación del contexto para un agente, y también la más fácil de solucionar, ya que se gestiona en la ingestión y no después del hecho.

La función siguiente ofrece tres estrategias de truncamiento. El modo start conviene a documentos donde lo esencial está al principio, como un artículo o un informe. El modo start_end funciona cuando el final contiene la información decisiva: un rastro de ejecución donde el error aparece al final, un archivo de registro o una respuesta paginada donde el total figura al final. El modo summary cuesta una llamada a la API adicional, lo cual solo se justifica para contenidos largos que sean realmente útiles para el resto del razonamiento.

def truncate_tool_result(
    result: str,
    max_tokens: int = 2000,
    strategy: str = "start_end",
) -> str:
    """Trunca el resultado de una herramienta conservando la información clave."""
    estimated_tokens = len(result) // 4

    if estimated_tokens <= max_tokens:
        return result

    max_chars = max_tokens * 4

    match strategy:
        case "start":
            return result[:max_chars] + "\n[... truncado]"

        case "start_end":
            half = max_chars // 2
            return (
                result[:half]
                + "\n[... medio truncado ...]\n"
                + result[-half:]
            )

        case "summary":
            import openai
            client = openai.OpenAI()
            response = client.responses.create(
                model="gpt-5.6-terra",
                input=f"Resume estos datos conservando lo esencial:\n{result}",
                max_output_tokens=max_tokens,
            )
            return response.output_text

    return result[:max_chars]

Los resultados tabulares requieren un tratamiento especial. Cortar una tabla SQL por la mitad elimina la cabecera o distorsiona la sensación de volumen: el agente ve veinte filas y concluye que la tabla contiene solo veinte. El filtro siguiente mantiene la cabecera, una muestra del principio y del final, y —este es el punto clave— indica explícitamente el número de filas omitidas y el total. El agente sabe entonces que está viendo un extracto y puede decidir ejecutar una consulta de agregación en lugar de razonar sobre una muestra.

def filter_sql_result(result: str, question: str) -> str:
    """Filtra un resultado SQL para conservar solo lo relevante."""
    lines = result.strip().split("\n")

    if len(lines) <= 20:
        return result

    # Mantener la cabecera y las primeras/últimas líneas
    header = lines[0]
    first_lines = lines[1:6]
    last_lines = lines[-5:]

    return (
        f"{header}\n"
        + "\n".join(first_lines)
        + f"\n[... {len(lines) - 11} líneas omitidas ...]\n"
        + "\n".join(last_lines)
        + f"\n\nTotal: {len(lines) - 1} filas"
    )

Cuando varios agentes trabajan juntos

Cuando varios subagentes trabajan en paralelo, la tentación es darles a todos el contexto completo, solo por seguridad. Esa es la mejor manera de multiplicar tu factura por el número de agentes mientras degradas su rendimiento, ya que un contexto abarrotado hace que el modelo sea menos preciso en su propia tarea. En su lugar, comparte el contexto mínimo: el objetivo global para que el agente entienda a qué contribuye, su propio rol, las restricciones comunes y un extracto acotado de los resultados producidos por sus compañeros.

@dataclass
class SharedContext:
    """Contexto compartido entre subagentes."""
    objective: str
    constraints: list[str]
    partial_results: dict[str, str] = field(default_factory=dict)

    def context_for_sub_agent(self, role: str) -> str:
        """Genera un contexto dirigido para un subagente."""
        return (
            f"Global objective: {self.objective}\n"
            f"Your role: {role}\n"
            f"Constraints: {', '.join(self.constraints)}\n"
            f"Results from other agents:\n"
            + "\n".join(
                f"- {k}: {v[:200]}"
                for k, v in self.partial_results.items()
            )
        )

El límite de 200 caracteres por resultado parcial refleja una intención: un subagente necesita saber qué han encontrado los demás, no cómo lo han encontrado. Si tus agentes necesitan el detalle completo de los resultados vecinos, probablemente necesites replantear cómo has dividido los roles.

Puntos clave

  • Estructura la memoria del agente en tres niveles: trabajo, episódica, semántica
  • Compacta automáticamente cuando la memoria de trabajo supera el umbral
  • Trunca los resultados de las herramientas antes de inyectarlos en el contexto
  • Indica siempre que un resultado ha sido truncado y en qué medida
  • Para configuraciones multiagente, comparte un contexto mínimo dirigido por rol