Estudio de Arquitectura y Orquestación Agéntica: el Dominio más Grande del Examen CCA

Arquitectura y Orquestación Agéntica vale el 27% del examen CCA Foundations, más que cualquier otro dominio.

Cubre cómo diseñas sistemas donde Claude no solo responde una pregunta, sino que planifica, llama a herramientas, delega trabajo a otros agentes y decide cuándo ha terminado.

Este artículo recorre los patrones de orquestación que aparecen con más frecuencia en los escenarios del examen, con ilustraciones prácticas en Python construidas sobre el SDK de anthropic.

Resumen

Los sistemas multiagente intercambian simplicidad por capacidad, y el examen evalúa si sabes cuándo vale la pena hacer ese intercambio.

Un único agente bien definido con buenas herramientas supera casi siempre a un sistema multiagente mal descompuesto.

Los patrones centrales que vale la pena conocer son los pipelines secuenciales, las topologías supervisor-trabajador y el fan-out paralelo con un paso de fusión.

Cada patrón necesita una condición de terminación explícita, o corre el riesgo de entrar en un bucle más allá de su utilidad.

Las preguntas de orquestación en el examen suelen centrarse en elegir la arquitectura más pequeña que resuelve el problema, no la más sofisticada.

Receta

Tarjeta de receta de referencia rápida: la forma mínima de un bucle supervisor-trabajador.

from anthropic import Anthropic
 
client = Anthropic()
 
def run_worker(task: str, model: str = "claude-sonnet-5") -> str:
    """Un agente trabajador con un propósito único que hace un trabajo y retorna."""
    response = client.messages.create(
        model=model,
        max_tokens=1024,
        system="Eres un agente trabajador enfocado. Haz exactamente la tarea dada. Devuelve solo el resultado.",
        messages=[{"role": "user", "content": task}],
    )
    return response.content[0].text
 
def run_supervisor(goal: str, max_steps: int = 5) -> str:
    """Un supervisor que descompone un objetivo en tareas de trabajador y se detiene al completarse."""
    completed_work = []
    for step in range(max_steps):
        plan_prompt = f"Objetivo: {goal}\nCompletado hasta ahora: {completed_work}\nSiguiente subtarea única, o DONE si está terminado:"
        plan = run_worker(plan_prompt, model="claude-sonnet-5")
        if plan.strip().upper().startswith("DONE"):
            break
        result = run_worker(plan)
        completed_work.append({"task": plan, "result": result})
    return "\n".join(w["result"] for w in completed_work)

Cuándo usar esto:

• El objetivo se descompone naturalmente en un número pequeño y acotado de subtareas independientes.
• Cada subtarea se beneficia de un prompt de sistema más específico que el que necesitaría el objetivo general.
• Necesitas una condición de parada explícita en lugar de una conversación abierta.
• Estás dispuesto a asumir la latencia y el costo de múltiples llamadas al modelo para un mejor aislamiento de tareas.

Ejemplo de Trabajo

from anthropic import Anthropic
from dataclasses import dataclass
 
client = Anthropic()
 
@dataclass
class AgentResult:
    agent_name: str
    output: str
 
def draft_agent(topic: str) -> AgentResult:
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=512,
        system="Redacta un breve esquema técnico. Devuelve solo el esquema, sin preámbulos.",
        messages=[{"role": "user", "content": f"Esquema: {topic}"}],
    )
    return AgentResult("draft", response.content[0].text)
 
def critic_agent(draft: str) -> AgentResult:
    response = client.messages.create(
        model="claude-opus-4-8",
        max_tokens=512,
        system="Critica un esquema técnico buscando lagunas y riesgos fácticos. Sé conciso. Devuelve solo la crítica.",
        messages=[{"role": "user", "content": draft}],
    )
    return AgentResult("critic", response.content[0].text)
 
def reviser_agent(draft: str, critique: str) -> AgentResult:
    response = client.messages.create(
        model="claude-sonnet-5",
        max_tokens=768,
        system="Revisa un borrador de esquema dada una crítica. Devuelve solo el esquema revisado.",
        messages=[{"role": "user", "content": f"Borrador:\n{draft}\n\nCrítica:\n{critique}"}],
    )
    return AgentResult("reviser", response.content[0].text)
 
def orchestrate_draft_critique_revise(topic: str) -> str:
    """Un pipeline secuencial de tres agentes: borrador -> crítico -> revisor.
 
    Cada agente tiene un solo trabajo y un prompt de sistema específico, que es el
    patrón que el examen llama 'diseño de agente de única responsabilidad'.
    """
    draft = draft_agent(topic)
    critique = critic_agent(draft.output)
    final = reviser_agent(draft.output, critique.output)
    return final.output
 
if __name__ == "__main__":
    result = orchestrate_draft_critique_revise("Estrategia de migración de bases de datos sin tiempo de inactividad")
    print(result)

Lo que esto demuestra:

• Un pipeline secuencial donde la salida de cada agente se convierte en la entrada del siguiente, sin estado mutable compartido.
• Mezcla deliberada de modelos: un modelo más potente (Opus 4.8) para el paso de crítica, donde la calidad del juicio es lo más importante, y un modelo más rápido (Sonnet 5) para redactar y revisar.
• Prompts de sistema de única responsabilidad por agente, que el examen evalúa como un principio de diseño distinto de la ingeniería de prompts en sí.
• No se necesita lógica de bucle o terminación aquí, porque el pipeline tiene una longitud fija y conocida, lo cual es en sí mismo una elección de diseño que vale la pena reconocer.

Profundización

Cómo Funciona

• Un pipeline secuencial pasa la salida hacia adelante a través de una cadena fija de agentes; es la forma adecuada cuando el número de pasos se conoce de antemano.
• Una topología supervisor-trabajador tiene un agente que planifica y despacha, y uno o más agentes trabajadores que ejecutan; es la forma adecuada cuando el número de pasos no se conoce hasta el tiempo de ejecución.
• Un fan-out paralelo despacha subtareas idénticas o relacionadas a múltiples agentes concurrentemente, y luego fusiona los resultados; es la forma adecuada cuando las subtareas son independientes y la latencia importa más que la secuenciación.
• Toda orquestación no trivial necesita una condición de terminación explícita: un presupuesto de pasos, una señal "DONE" que el supervisor puede emitir, o una verificación de validación que confirme que el objetivo se ha cumplido.
• El paso de contexto entre agentes es una decisión de diseño, no una certeza: pasa solo lo que el siguiente agente necesita, no todo el historial de conversación, o inflarás el costo de tokens de cada llamada posterior.

Patrones de Orquestación de un Vistazo

Terminación y Seguridad de Bucles

MAX_STEPS = 8
 
def safe_supervisor_loop(goal: str) -> str:
    step = 0
    history = []
    while step < MAX_STEPS:
        step += 1
        next_action = run_worker(f"Objetivo: {goal}\nHistorial: {history}\nSiguiente paso o DONE:")
        if "DONE" in next_action.upper():
            break
        history.append(next_action)
    else:
        # El bucle agotó MAX_STEPS sin una señal DONE - tratar como un fallo, no un éxito.
        raise RuntimeError(f"El supervisor no terminó dentro de {MAX_STEPS} pasos para el objetivo: {goal}")
    return "\n".join(history)

Un presupuesto de pasos fijo combinado con una ruta de fallo explícita (en lugar de devolver silenciosamente un resultado parcial) es el patrón que el examen recompensa: un agente que no puede decirte que falló es peor que uno que lanza una excepción.

Notas de Python

# Prefiere dataclasses tipados o TypedDicts para las cargas útiles entre agentes en lugar de diccionarios crudos,
# para que un desajuste de esquema entre agentes falle rápidamente en lugar de aparecer como un
# confuso error de formato de prompt descendente.
from typing import TypedDict
 
class SubtaskResult(TypedDict):
    agent: str
    task: str
    output: str

Trampas

• Añadir un segundo agente cuando una herramienta más grande sería suficiente. Un solo agente con una herramienta bien diseñada a menudo reemplaza a todo un "agente auxiliar". Solución: intenta expandir la superficie de herramientas antes de recurrir a la orquestación.
• Sin condición de terminación en un bucle supervisor. Si se deja sin límites, un bucle de planificación puede ejecutarse hasta agotar el presupuesto o el contexto. Solución: siempre establece un límite de pasos fijo y trata de excederlo como un error lanzado, no como una truncación silenciosa.
• Pasar el historial completo de la conversación a cada trabajador. Esto multiplica el costo de tokens linealmente con la profundidad del pipeline sin ningún beneficio. Solución: pasa solo los campos específicos que el siguiente agente necesita realmente.
• Usar el mismo modelo y prompt de sistema para cada agente en el pipeline. Esto desperdicia la oportunidad de igualar la potencia del modelo con la dificultad de la tarea. Solución: reserva un modelo más potente para pasos que requieran mucho juicio, como la crítica o la síntesis.
• Tratar el fan-out paralelo como gratuito. Las llamadas concurrentes aún consumen límites de tasa y cuestan lo mismo por llamada; el fan-out reduce la latencia, no el costo. Solución: dimensiona el fan-out al número real de subtareas independientes, no por sí mismo.
• Sin estrategia de fusión definida antes de que comience el fan-out. Si no sabes cómo reconciliarás las salidas conflictivas de los trabajadores, las improvisarás mal bajo presión. Solución: diseña la fusión (por ejemplo, "el supervisor arbitra", "voto mayoritario", "concatenar") antes de despachar.

Alternativas

Preguntas Frecuentes

Relacionados

• Lo que Realmente Evalúa el Examen Claude Certified Architect - el modelo mental general del examen en el que encaja este dominio.
• Dominios del Examen CCA Foundations de un Vistazo - dónde se sitúa este dominio del 27% en relación con los otros cuatro.
• Diseño de Herramientas, Integración MCP y Gestión de Contexto: Lista de Verificación del Dominio CCA - las decisiones de diseño de herramientas que a menudo determinan si la orquestación es incluso necesaria.
• Caso de Estudio: Construcción de un Agente de Soporte al Cliente de Producción de Principio a Fin - estos patrones de orquestación aplicados a una construcción de producción completa.
• Mejores Prácticas del Examen CCA Foundations - guía práctica para aplicar patrones de orquestación a construcciones reales.

Versiones de Stack: Escrito contra la línea de modelos Claude actual a partir de ~junio de 2026 - Claude Fable 5, Claude Opus 4.8, Claude Sonnet 5 (el predeterminado), y Claude Haiku 4.5 - y el SDK oficial de Python anthropic (última versión 0.x). Los nombres de los modelos, precios, formato del examen y versiones del SDK cambian rápidamente; verifica los detalles actuales en platform.claude.com/docs y la guía oficial del examen CCA antes de confiar en ellos.