Cuando los agentes de inteligencia artificial (AI) de producción manejan tareas como el análisis de datos y la generación de informes, la gestión de contexto puede convertirse en un cuello de botella importante. Una ventana de 200K-token suena generosa hasta que una tarea del mundo real consume la mayor parte de ella en minutos. El análisis de datos y la generación de informes hacen que el agente falle en la ejecución, pierda precisión o aumente los costos. Ya existe una guía publicada que aborda esto, pero las técnicas individuales son más fáciles de leer que de aplicar. Aplicadas juntas, hacen una diferencia medible: en la implementación de referencia que se describe en este post, una sola herramienta de escritura y ejecución reduce los tokens que cada script agrega al contexto en aproximadamente un 95 por ciento, y la carga de habilidades bajo demanda reduce la llamada del sistema en aproximadamente un 97 por ciento.

Deep Insight, una solución de análisis de datos de multiagente de código abierto construida sobre el SDK de Strands Agents y Amazon Bedrock AgentCore, que sirve como implementación de referencia en todo el proceso.

Serie de posts

• Parte 1: 5 desafíos de producción en sistemas de multiagente y cómo Deep Insight los resolvió.
• Parte 2: Cuatro capas de ingeniería de contexto para agentes de inteligencia artificial de producción: Cómo Deep Insight las aplica en código en funcionamiento.
• Parte 3: Ingeniería de harness en la práctica: mover Deep Insight de desarrollo a producción. (Próximamente)

El primer post definió cinco desafíos clave que los sistemas de multiagente de producción deben resolver. Presentó cómo Strands Agents SDK, Amazon Bedrock y Bedrock AgentCore, y AWS Fargate abordan diferentes capas del problema, con ejemplos de código. Este segundo post toma las cuatro capas de práctica de ingeniería de contexto que se encuentran sobre esa arquitectura y muestra cada una implementada. El tercer post te guía a través de la implementación y operación de agentes en una red privada segura en Amazon Virtual Private Cloud (Amazon VPC), cubriendo todo lo necesario para operaciones del mundo real.

¿Qué es la ingeniería de contexto?

La ingeniería de contexto es la disciplina de optimizar la información en la ventana de contexto limitada de un modelo de lenguaje grande (LLM) para que los agentes funcionen de la mejor manera posible. Anthropic Claude Sonnet 4.5, disponible en Amazon Bedrock, ofrece una ventana de contexto de 200K, pero las tareas de producción complejas rápidamente la exceden. Por ejemplo, una solicitud aparentemente sencilla como “Analizar datos de ventas y crear un informe DOCX” pasa por varias etapas: carga y exploración de datos (5 min), análisis de ventas basado en categorías (3 min), generación de cinco gráficos para análisis de series temporales (10 min), validación estadística (3 min) y generación final del informe (5 min). En conjunto, consumen más de 150K tokens en 15 minutos.

Procesar tales tareas en un solo contexto causa problemas: la ventana se desborda a mitad de tarea, el contexto estancado degrada el rendimiento y los errores requieren volver a ejecutar toda la pipeline. A medida que el contexto crece, la atención a la información importante disminuye y la ineficiencia aumenta el costo bajo el precio por token.

“A medida que aumenta el número de tokens en la ventana de contexto, disminuye la capacidad del modelo para recordar información de ese contexto con precisión (pudrición de contexto).”

— Anthropic, “Effective Context Engineering for AI Agents” (2025.09)

La ingeniería de contexto resuelve exactamente estos problemas, y no es solo una colección de técnicas. Abarcando el diseño de arquitectura, la escritura de prompts, la implementación de herramientas y la verificación, es una disciplina en capas donde cada capa compensa lo que las anteriores pasan por alto. Esta publicación detalla el enfoque de cuatro capas que puede aplicar para gestionar el contexto de manera eficiente.

Cómo manejar tareas que exceden la ventana de contexto

Anthropic ha publicado varias técnicas para manejar tareas de horizonte largo. Deep Insight agrupa estas técnicas en cuatro capas, con cada capa abordando las limitaciones de las demás. La siguiente tabla establece las cuatro capas.

Las secciones que siguen analizan cada capa en orden, describiendo lo que prescribe la capa, por qué las capas anteriores solas son insuficientes y cómo se implementa la práctica en Deep Insight.

1. Aislamiento de contexto a través de arquitectura de multiagente

Asigne a cada agente especializado su propia ventana de contexto y pase solo resultados comprimidos al coordinador. Deep Insight hace esto con una jerarquía de Coordinador, Planificador, Revisor de planes, Supervisor y Agentes de herramientas (Codificador, Validador, Informador, Seguidor, Auditor).

Con un solo agente, toda la información, desde las solicitudes de usuario hasta la exploración de datos, análisis, generación de gráficos, validación y generación de informes, se acumula en un contexto y fácilmente excede la ventana. Dar a cada agente su propio contexto mantiene incluso al Codificador, que utiliza el más, por debajo de 25K tokens en total. Cada agente recibe solo lo que necesita y señaliza a otros con un aviso de finalización y un resumen breve.

La clave del aislamiento es minimizar la información compartida. Deep Insight utiliza un diccionario de Python, shared_state, que almacena solo cuatro cosas:

• messages: El mensaje final del agente anterior (no la historia de conversación completa).
• clues: Resúmenes comprimidos recopilados de cada agente.
• full_plan: Una lista de verificación generada por Planificador y actualizada por Seguidor.
• history: Un registro breve de nombres y mensajes de agentes.

Las pistas utilizan un formato de pista fijo CLUES_FORMAT: en lugar de la conversación completa de cada agente (decenas de miles de tokens), solo se pasan resultados core comprimidos.

# coder_agent_tool.py -- context passing format
CLUES_FORMAT = "Here is clues from {}:\n\n<clues>\n{}\n</clues>\n\n"
RESPONSE_FORMAT = "Response from {}:\n\n<response>\n{}\n</response>\n\n*Please execute the next step.*"

# After Coder completes: add only compressed result to clues
clues += CLUES_FORMAT.format("coder", response["text"])

Este patrón es el recomendado en el post de Anthropic “Cómo construimos nuestro sistema de investigación de multiagente”, que describe un patrón de coordinador-trabajador en el que un agente principal delega a subagentes especializados, con cada agente trabajando solo dentro de su propio contexto. No necesitas construirlo tú mismo: el patrón de agentes como herramientas en el SDK de Strands Agents proporciona este aislamiento a nivel de framework.

2. Control de flujo de contexto a través de solicitudes

El aislamiento de la capa 1 solo no es suficiente: incluso con contextos independientes, un agente que genera respuestas largas infla el contexto del Supervisor. La capa 2 limita la salida de cada agente a través de solicitudes.

Para Deep Insight, utilizamos instrucciones para limitar la cantidad de información que cada agente devuelve al Supervisor. Tres reglas realizan la mayor parte del trabajo, como lo muestran las instrucciones de Deep Insight.

“Comience con el modelo más fuerte y una instrucción simple. Luego agregue instrucciones específicas de forma incremental basadas en casos de fallas observados en realidad.”

— Anthropic, “Ingeniería de contexto efectiva para agentes de IA” (2025.09)

Detalle de implementación 2-1: Presupuestos de tokens de salida explícitos por agente

La instrucción de cada agente especifica un recuento máximo de tokens de respuesta, lo que evita respuestas largas que contaminan el contexto del Supervisor.

La publicación de Anthropic ” Herramientas de escritura efectivas para agentes” sugiere dar a las herramientas una opción de respuesta CONCISA o DETALLADA para la eficiencia del contexto. Aplicar la misma idea un nivel más arriba, en la instrucción del sistema de cada agente. En Deep Insight, todos los agentes comparten un formato estandarizado:

## Status
[SUCCESS | PARTIAL_SUCCESS | ERROR]
## Completed Tasks
- [Task 1 from FULL_PLAN -- use exact wording so Tracker can match]
- [Task 2 -- be specific, not generic]
## Key Insights
- [Key finding 1 with numbers and ratios]
- [Key finding 2 with business implications]
## Generated Files
- ./artifacts/chart.png -- brief description
- ./artifacts/calculation_metadata.json -- N calculations

Detalle de implementación 2-2: Filosofía de código autocontenido

La instrucción del agente Coder establece explícitamente “las variables no persisten entre scripts”. Cada script debe incluir todas las importaciones necesarias y cargar los datos directamente. La instrucción proporciona ejemplos correctos e incorrectos:

# WRONG -- Attempting to use a variable from Turn 1 in Turn 2
# Turn 1:
df = pd.read_csv('data.csv')
total = df['Amount'].sum()

# Turn 2:
print(f"Total: {total}")  # NameError: name 'total' is not defined

# CORRECT -- Every script is self-contained
import pandas as pd
df = pd.read_csv('./artifacts/cache/df_main.csv')  # Load from cache
total = df['Amount'].sum()
print(f"Total: {total}")

La razón por la que esta regla se relaciona con la ingeniería de contexto es que hacer referencia a variables de scripts anteriores requiere que el agente “recuerde” conversaciones anteriores, lo que significa que el código anterior debe permanecer en contexto. El principio autocontenido significa que el código anterior se puede eliminar de forma segura del contexto.

Detalle de implementación 2-3: Regla de finalización de sección del Supervisor

La instrucción del Supervisor incluye la regla “No avanzar al siguiente agente hasta que todos los elementos de la lista de verificación en la sección del agente actual estén marcados [x]”. Expresamos esta regla en la instrucción porque decidir si el trabajo del Coder está completo requiere que el Supervisor interprete el plan utilizando información de las actualizaciones del Tracker. Este juicio es difícil de expresar solo en código.

3. “Solo referencias en contexto, datos reales en archivos”

La Capa 1 aísla el contexto entre agentes, y la Capa 2 limita la salida dentro de los agentes. Pero cuando el agente Coder genera 100 líneas de código Python, ese código en sí mismo entra en el contexto. Incluso con instrucciones de instrucción de “responder brevemente”, algunos códigos no se pueden escribir brevemente. La Capa 3 utiliza el diseño de herramientas para mover el contenido pesado fuera del contexto, hacia el sistema de archivos. Cuatro técnicas llevan la mayor parte del beneficio, como muestran los detalles de implementación siguientes.

Detalle de implementación 3-1: Mover código fuera del contexto con la herramienta Write y Execute

El Coder lee el plan de análisis, escribe Python y lo ejecuta para generar visualizaciones. Pero cuando el código se vuelve largo, el enfoque convencional (herramientas de escritura y ejecución de archivos separados) agrega 100 líneas directamente al contexto por script, acumulando más de 1,000 líneas.

La solución es colapsar los dos pasos en una sola herramienta, para que el código nunca entre en el contexto como un mensaje. El agente Coder de Deep Insight utiliza un write_and_execute_tool para esto.

Aquí está parte de la herramienta write_and_execute_tool. Después de escribir y ejecutar el archivo, devuelve solo un resumen: “Escribió 105 líneas, ejecución exitosa, análisis de cinco categorías completado”. El código permanece en el archivo y alrededor de tres líneas de resumen permanecen en el contexto. Basado en este ejemplo, eso ahorra alrededor del 95 por ciento de los tokens.

# write_and_execute_tool.py
def _handle_write_and_execute_tool(file_path, content, timeout=300):
    """Write a Python script and immediately execute it."""
    # Step 1: Write file
    with open(file_path, 'w', encoding='utf-8') as f:
        f.write(content)
    # Step 2: Execute immediately
    result = subprocess.run(
        f"python {file_path}",
        shell=True,
        capture_output=True,
        timeout=timeout
    )
    # Return only summary
    return f"Written {len(content.split(chr(10)))} lines to {file_path}\n" \
        f"Execution successful\n" \
        f"Output: {result.stdout[:500]}"  # Only first 500 chars

“Filtrado del lado del servidor: filtrado de datos en la capa de ejecución antes de que lleguen al contexto, reducción del 98,7% de tokens (150K a 2K).”

— Anthropic, “Code Execution with MCP” (2025.11)

Detalle de implementación 3-2: Reutilizar lógica común como módulos en el agente Coder

Los módulos comunes se reutilizan en análisis. En lugar de regenerarlos cada vez, definir funciones frecuentemente utilizadas como un módulo una vez e importarlos, lo que evita el desperdicio de tokens y la duplicación de contexto.

Sin esto, definir funciones como to_python_type() o track_calculation() en cada análisis produce 200–300 líneas de código duplicado en 10 análisis. Deep Insight genera un módulo llamado coder_analysis_utils.py antes de la primera tarea. Incluye funciones para convertir tipos numpy, rastrear metadatos de cálculo y guardar en JSON. Los análisis posteriores lo importan, reemplazando 20–30 líneas regeneradas con dos líneas de importación, lo que ahorra tokens y mejora la consistencia y la depuración.

# coder_analysis_utils.py -- common module generated before first task
import numpy as np
import json
from datetime import datetime

_calculations = []

def to_python_type(value):
    """Convert numpy/pandas types to Python native types"""
    if isinstance(value, (np.integer, np.int64)): return int(value)
    elif isinstance(value, (np.floating, np.float64)): return float(value)
    elif isinstance(value, np.ndarray): return value.tolist()
    return value

def track_calculation(calc_id, value, description, formula,
                      source_file, source_columns, importance):
    """Track calculation metadata -- Validator independently verifies later"""
    _calculations.append({
        "id": calc_id, "value": to_python_type(value),
        "description": description, "formula": formula,
        "source_file": source_file, "source_columns": source_columns,
        "importance": importance
    })

def save_calculation_metadata(path="./artifacts/calculation_metadata.json"):
    """Save all tracked calculations to JSON"""
    with open(path, 'w', encoding='utf-8') as f:
        json.dump({"generated_at": datetime.now().isoformat(),
                   "calculations": _calculations}, f, ensure_ascii=False, indent=2)

Detalle de implementación 3-3: Guardar y compartir resultados de análisis a través de la toma de notas estructurada

Usamos la toma de notas estructurada para compartir resultados de análisis detallados sin pasarlos por el contexto de cada agente. Deep Insight almacena estos resultados en un archivo llamado all_results.txt, que luego es leído por los agentes según sea necesario.

Por ejemplo, el agente Coder agrega resultados a all_results.txt después de cada tarea de análisis:

with open('./artifacts/all_results.txt', 'a', encoding='utf-8') as f:
    f.write(f"""
## Category Sales Analysis (completed at: 14:32)
- Top revenue category: Fruit (417,166,008 KRW, 45% of total)
- Top 3 categories: Fruit, Vegetables, Meat (78% of total)
- Generated file: ./artifacts/category_sales_chart.png
""")

El Coder registra resultados detallados en este archivo después de cada análisis, y el Reporter lo lee al escribir el informe final. Otros agentes colaboran a través de all_results.txt de la misma manera.

Sin la toma de notas, el Coder pasa resultados detallados al Supervisor después de cada tarea, acumulándolos en su contexto. Con la toma de notas, solo se pasa un mensaje de aproximadamente 30 tokens como “Análisis de ventas de categorías completo, 3 ideas clave encontradas, resultados detallados guardados en all_results.txt”, y el Reporter lee el archivo cuando sea necesario.

El patrón se generaliza más allá de un solo archivo. El propio sistema de archivos puede servir como el bus de comunicación entre agentes, como lo hace en Deep Insight:

“El enfoque”justo a tiempo”, que carga dinámicamente los datos en el contexto en tiempo de ejecución en lugar de procesar todos los datos relevantes de antemano, mantiene el contexto fresco, relevante y adaptable al estado evolutivo de la tarea.”

— Anthropic, “Effective Context Engineering for AI Agents” (2025.09)

Detalle de implementación 3-4: Cargar solo el conocimiento necesario con Habilidades

En lugar de poner todo el conocimiento especializado en la llamada del sistema, este enfoque lo carga solo cuando es necesario. Incluir todas las guías de habilidades (comprobación de estructuras de datos, generación de README, creación de habilidades, escritura de llamadas del sistema, creación de herramientas) agregaría más de 20.000 tokens, cargaría información innecesaria en el agente Coder en cada llamada y forzaría una redeploy para agregar una habilidad.

El sistema de Habilidades de Deep Insight carga solo un catálogo de habilidades de unos 500 tokens al inicio, con la lista de habilidades que solo contiene nombres y descripciones breves. Cuando un usuario solicita “Crear un archivo README”, el agente decide “Necesito la habilidad de generador de README” y llama a skill_tool(skill_name="readme-generator"). El SkillLoader lee readme-generator/SKILL.md y devuelve una guía detallada de unos 3K tokens.

# 1. Skill Discovery (at initialization)
from src.utils.skills.skill_utils import initialize_skills
available_skills, skill_prompt = initialize_skills(
    skill_dirs=["./skills"],
    verbose=True
)

# 2. Add to System Prompt (~500-token catalog)
system_prompt = base_prompt + skill_prompt

# 3. Runtime -- Agent loads skill when needed
# Agent decides: "This is README generation, I need the readme-generator skill"
# -> skill_tool(skill_name="readme-generator")
# -> Returns full SKILL.md content (~3K tokens)

Cada habilidad se define como un archivo SKILL.md compuesto por frontmatter YAML y guía markdown detallada. Incluye metadatos como nombre, descripción, licencia y herramientas permitidas, junto con descripción general, cuándo usar esta habilidad, instrucciones detalladas y mejores prácticas. Para agregar una nueva habilidad, crear un nuevo directorio bajo habilidades/ y escribir un archivo SKILL.md, y se descubre automáticamente.

Al inicio, el agente carga un catálogo de habilidades de unos 500 tokens en lugar de desperdiciar más de 20.000 tokens en guías completas (aproximadamente un 97 por ciento menos). Cuando sea necesario, puede cargar unos pocos miles de tokens adicionales de instrucciones detalladas para habilidades.

4. Verificar la calidad con agentes de verificación y salvaguardas

Incluso con las capas 1-3, queda un riesgo: los agentes aislados no pueden ver el trabajo de los demás, por lo que si el Coder calcula mal, el Reporter lleva ese error al informe. La capa 4 es la última línea de defensa.

“Proporcionar herramientas de prueba para que el agente pueda autoverificar características y corregir errores que no son obvios desde el código solo. Hacer que el modelo comprometa su progreso en git con mensajes de compromiso descriptivos y escriba resúmenes de progreso en un archivo de progreso.”

— Anthropic, “Arneses efectivos para agentes de ejecución prolongada” (2025.11)

Detalle de implementación 4-1: Agentes Tracker, Validator y Auditor: seguimiento del progreso y aseguramiento de la calidad

Tracker actualiza la lista de verificación del plan en tiempo real. Cuando el Coder completa la carga de datos, el Supervisor llama a Tracker, que actualiza el elemento del plan de [ ] a [x] en función de información como “Carga de datos completa (1,000 filas, 5 columnas).” Esto ayuda a los usuarios y al sistema a saber exactamente en qué punto se encuentra el progreso.

Validator re-ejecuta de forma independiente los cálculos del Coder para verificar la precisión. Lee calculation_metadata.json, vuelve a realizar cada cálculo a partir de los datos de origen y compara: las coincidencias dentro de 0.01 pasan, las discrepancias se marcan. Los cálculos verificados se envían a citations.json para que el Reporter los cite. Después de que el Reporter termine, el Auditor verifica el DOCX final contra citations.json y calculation_metadata.json sin modificarlos. Registra los defectos de citación en audit_findings.json y puede solicitar hasta dos reintentos dirigidos al Reporter.

Detalle de implementación 4-2: Priorización de cálculos para verificación

Verificar cada cálculo es ineficiente, por lo que se reduce el alcance de la verificación por importancia. El OptimizedValidator de Deep Insight aplica los siguientes umbrales:

• Más de 50 cálculos: filtrado agresivo, se verifican todos los de alta prioridad y solo 10 de prioridad media.
• Más de 20 cálculos: filtrado moderado, se verifican todos los de alta prioridad y 15 de prioridad media.
• 20 cálculos o menos: se verifican la mayoría, todos los de alta prioridad, todos los de prioridad media y 5 de baja prioridad.

También aplica comparación segura de tipos: para evitar problemas de tipos entre numpy y Python, todos los valores se convierten a float() y se verifican para una diferencia absoluta inferior a 0.01:

# validator.md -- type-safe numerical comparison
try:
    match = abs(float(expected) - float(actual)) < 0.01
except:
    match = str(expected) == str(actual)

Detalle de implementación 4-3: SummarizingConversationManager: la última red de seguridad

El contexto aún puede desbordarse en casos excepcionales, por lo que se mantiene una red de seguridad bajo las otras capas. Deep Insight utiliza el SummarizingConversationManager en el SDK de Strands Agents para esto.

# strands_sdk_utils.py -- safety net configuration at agent creation
agent = Agent(
    model=llm,
    system_prompt=system_prompts,
    tools=tools,
    conversation_manager=SummarizingConversationManager(
        summary_ratio=0.5,  # summarize oldest 50% on overflow
        preserve_recent_messages=10,  # always preserve 10 most recent messages
        summarization_system_prompt=apply_prompt_template("summarization", {})
    )
)

En caso de desbordamiento, el LLM resume el 50 por ciento más antiguo de los mensajes en uno, mientras siempre conserva los 10 más recientes para mantener el contexto de la tarea actual. La solicitud de resumen (summarization.md) requiere que clues, plans y tracking status se conserven exactamente tal como están.

Detalle de implementación 4-4: Cacheo de solicitudes selectivo para optimización de costos

La ingeniería de contexto abarca la optimización de costos, no solo el ahorro de tokens. Habilita el cacheo de solicitudes por agente, según la frecuencia con la que cada uno se llama con la misma solicitud. Configuraciones por agente de Deep Insight:

Los agentes con cacheo habilitado insertan puntos de cache en las solicitudes de sistema y definiciones de herramientas, reduciendo los costos de tokens de entrada hasta un 90 por ciento en llamadas repetidas. Esta es una función admitida de forma nativa por el SDK de Strands Agents. El revisor de planes no aparece en la tabla porque es un paso de bucle humano que recopila aprobación o comentarios del usuario en lugar de llamar a un modelo.

Conclusión

Esta publicación ha detallado el enfoque de ingeniería de cuatro capas que puede utilizar para gestionar eficientemente el contexto para tareas complejas que exceden la ventana de contexto.

• Capa 1 (aislamiento a nivel de arquitectura): Cada agente trabaja en un contexto independiente a través de una arquitectura multiagente, pasando solo resúmenes comprimidos.
• Capa 2 (control basado en instrucciones): Los presupuestos de tokens de salida, los formatos de respuesta estandarizados y la filosofía de código autocontenido limitan activamente el flujo de contexto.
• Capa 3 (uso del sistema de archivos): write_and_execute_tool mantiene el código fuera del contexto, el sistema de archivos sirve como un bus de comunicación entre agentes y el conocimiento se carga de forma diferida solo cuando se necesita.
• Capa 4 (verificación y salvaguardas): La verificación de cálculo independiente del Validador, la auditoría de citación de solo lectura del Auditor del informe final, el seguimiento de progreso del Tracker, la prevención de desbordamiento del SummarizingConversationManager y la caché de instrucciones selectiva gestionan tanto la calidad como el costo.

Cada capa forma un sistema de defensa que compensa lo que las capas anteriores pasan por alto. Cuando el aislamiento de arquitectura es insuficiente, las instrucciones limitan la salida. Cuando las instrucciones son insuficientes, las herramientas mantienen el contenido externo. Y cuando aún surgen problemas, la verificación los detecta.

Cada una de estas capas está documentada en las publicaciones de ingeniería de Anthropic, “Ingeniería de contexto efectiva para agentes de IA”, “Ejecución de código con MCP”, y “Cómo construimos nuestro sistema de investigación multiagente”. Gran parte de lo que recomiendan ya se incluye en el SDK de Strands Agents en lugar de ser algo que debes construir: SummarizingConversationManager, caché de instrucciones y el patrón de agentes como herramientas.

Al construir agentes de producción, la ventana de contexto de LLM por sí sola rara vez es suficiente. Aplica estas técnicas de ingeniería de contexto para gestionar el contexto de forma eficiente y escalar tus agentes para cargas de trabajo de producción.

Deep Insight, la implementación de referencia utilizada aquí, es de código abierto. Revisa el código y extiéndelo para tu dominio.

• GitHub
• Taller

Acerca de los autores