Astreus

Sub-agentes

Delegación inteligente de tareas con agentes especializados trabajando de forma coordinada

Delegación inteligente de tareas con agentes especializados trabajando de forma coordinada

Descripción general

Los Sub-Agentes permiten una coordinación multiagente sofisticada en la que un agente principal delega inteligentemente tareas a sub-agentes especializados. Cada sub-agente tiene su propia experiencia, capacidades y rol, trabajando juntos para completar flujos de trabajo complejos que serían difíciles para un único agente.

Novedad: los Sub-Agentes ahora se integran sin fisuras con los flujos de trabajo de Graph, permitiendo la distribución jerárquica de tareas en sistemas complejos de orquestación de flujos de trabajo.

Crear sub-agentes

Los sub-agentes se crean de forma independiente y luego se vinculan a un agente coordinador principal:

import { Agent } from '@astreus-ai/astreus';

// Create specialized sub-agents
const researcher = await Agent.create({
  name: 'ResearcherBot',
  model: 'gpt-4o',
  systemPrompt: 'You are an expert researcher who gathers and analyzes information thoroughly.',
  memory: true,
  knowledge: true
});

const writer = await Agent.create({
  name: 'WriterBot',
  model: 'gpt-4o',
  systemPrompt: 'You are a skilled content writer who creates engaging, well-structured content.',
  vision: true
});

const analyst = await Agent.create({
  name: 'AnalystBot', 
  model: 'gpt-4o',
  systemPrompt: 'You are a data analyst who provides insights and recommendations.',
  useTools: true
});

// Create main agent with sub-agents
const mainAgent = await Agent.create({
  name: 'CoordinatorAgent',
  model: 'gpt-4o',
  systemPrompt: 'You coordinate complex tasks between specialized sub-agents.',
  subAgents: [researcher, writer, analyst]
});

Estrategias de delegación

Delegación automática

El agente principal usa la inteligencia del LLM para analizar las tareas y asignarlas de forma óptima:

const result = await mainAgent.ask(
  'Research AI market trends, analyze the data, and write an executive summary',
  {
    useSubAgents: true,
    delegation: 'auto'  // AI-powered task distribution
  }
);
1

Análisis de la tarea

El agente principal analiza la tarea compleja utilizando razonamiento del LLM.

2

Emparejamiento de agentes

Evalúa las capacidades y especializaciones de cada sub-agente.

3

Asignación óptima

Crea subtareas específicas para los agentes más adecuados.

4

Ejecución coordinada

Gestiona el flujo de ejecución y la agregación de resultados.

Delegación manual

Asigna tareas específicas a agentes específicos usando sus IDs de forma explícita:

const result = await mainAgent.ask(
  'Complex multi-step project',
  {
    useSubAgents: true,
    delegation: 'manual',
    taskAssignment: {
      [researcher.id]: 'Research market opportunities in healthcare AI',
      [analyst.id]: 'Analyze market size and growth potential',
      [writer.id]: 'Create executive summary with recommendations'
    }
  }
);

Delegación secuencial

Los sub-agentes trabajan en secuencia, construyendo sobre los resultados anteriores:

const result = await mainAgent.ask(
  'Create a comprehensive business plan for an AI startup',
  {
    useSubAgents: true,
    delegation: 'sequential'  // Each agent builds on the previous work
  }
);

Patrones de coordinación

graph TD
    A[Main Coordinator Agent] --> B{Task Analysis}
    B -->|Research Tasks| C[ResearcherBot]
    B -->|Analysis Tasks| D[AnalystBot]
    B -->|Content Tasks| E[WriterBot]
    
    C --> F[Research Results]
    D --> G[Analysis Results]
    E --> H[Written Content]
    
    F --> I[Result Aggregation]
    G --> I
    H --> I
    
    I --> J[Final Output]
    
    style A fill:#333,stroke:#333,stroke-width:4px
    style C fill:#333,stroke:#333,stroke-width:2px
    style D fill:#333,stroke:#333,stroke-width:2px
    style E fill:#333,stroke:#333,stroke-width:2px

Ejecución en paralelo

Los sub-agentes trabajan simultáneamente para lograr la máxima eficiencia:

const result = await mainAgent.ask(
  'Multi-faceted analysis task',
  {
    useSubAgents: true,
    delegation: 'auto',
    coordination: 'parallel'  // All agents work concurrently
  }
);

Ejecución secuencial

Los sub-agentes trabajan en orden, pasándose el contexto entre ellos:

const result = await mainAgent.ask(
  'Research → Analyze → Report workflow',
  {
    useSubAgents: true,
    delegation: 'auto', 
    coordination: 'sequential'  // Agents work in dependency order
  }
);

Configuración de sub-agentes

Roles especializados

Configura los sub-agentes para áreas de experiencia específicas:

// Research Specialist
const researcher = await Agent.create({
  name: 'ResearchSpecialist',
  systemPrompt: 'You conduct thorough research using multiple sources and methodologies.',
  knowledge: true,  // Access to knowledge base
  memory: true,     // Remember research context
  useTools: true    // Use research tools
});

// Content Creator
const creator = await Agent.create({
  name: 'ContentCreator', 
  systemPrompt: 'You create compelling content across different formats and audiences.',
  vision: true,     // Process visual content
  useTools: true    // Use content creation tools
});

// Technical Analyst
const analyst = await Agent.create({
  name: 'TechnicalAnalyst',
  systemPrompt: 'You analyze technical data and provide actionable insights.',
  useTools: true    // Use analysis tools
});

Integración con Graph

Los Sub-Agentes funcionan sin fisuras con los flujos de trabajo de Graph para orquestaciones complejas:

import { Agent, Graph } from '@astreus-ai/astreus';

// Create specialized sub-agents
const researcher = await Agent.create({
  name: 'ResearchBot',
  systemPrompt: 'You conduct thorough research and analysis.',
  knowledge: true
});

const writer = await Agent.create({
  name: 'WriterBot',
  systemPrompt: 'You create compelling content and reports.',
  vision: true
});

// Main coordinator with sub-agents
const coordinator = await Agent.create({
  name: 'ProjectCoordinator',
  systemPrompt: 'You coordinate complex projects using specialized teams.',
  subAgents: [researcher, writer]
});

// Create sub-agent aware graph
const projectGraph = new Graph({
  name: 'Market Analysis Project',
  defaultAgentId: coordinator.id,
  subAgentAware: true,
  optimizeSubAgentUsage: true
}, coordinator);

// Add tasks with intelligent sub-agent delegation
const researchTask = projectGraph.addTaskNode({
  name: 'Market Research',
  prompt: 'Research AI healthcare market trends and opportunities',
  useSubAgents: true,
  subAgentDelegation: 'auto'
});

const reportTask = projectGraph.addTaskNode({
  name: 'Executive Report',
  prompt: 'Create comprehensive executive report based on research',
  dependencies: [researchTask],
  useSubAgents: true,
  subAgentCoordination: 'sequential'
});

// Execute the graph
const result = await projectGraph.run();

Funciones de sub-agentes en Graph

  • Detección automática: los nodos del grafo utilizan sub-agentes automáticamente cuando resulta beneficioso
  • Paso de contexto: el contexto del flujo de trabajo se transmite a los sub-agentes para una mejor coordinación
  • Optimización del rendimiento: monitorización en tiempo real y ajuste automático de la estrategia
  • Configuración flexible: ajustes de sub-agente por nodo con herencia desde la configuración del grafo

Ejemplos avanzados

Pipeline de producción de contenido

const contentPipeline = await Agent.create({
  name: 'ContentPipeline',
  model: 'gpt-4o',
  subAgents: [researcher, writer, analyst]
});

const blogPost = await contentPipeline.ask(
  'Create a comprehensive blog post about quantum computing applications in finance',
  {
    useSubAgents: true,
    delegation: 'auto',
    coordination: 'sequential'
  }
);

Flujo de trabajo de investigación de mercado

const marketResearch = await Agent.create({
  name: 'MarketResearchTeam',
  model: 'gpt-4o',
  subAgents: [researcher, analyst, writer]
});

const report = await marketResearch.ask(
  'Analyze the fintech market and create investor presentation',
  {
    useSubAgents: true,
    delegation: 'manual',
    coordination: 'parallel',
    taskAssignment: {
      [researcher.id]: 'Research fintech market trends and competitors',
      [analyst.id]: 'Analyze market data and financial projections',
      [writer.id]: 'Create compelling investor presentation'
    }
  }
);

Tipos de respuesta

Los métodos de sub-agentes devuelven distintos formatos de respuesta según la operación.

Respuesta de Execute With Sub-Agents

La ejecución básica con sub-agentes devuelve el resultado combinado final como una cadena de texto:

const result = await mainAgent.executeWithSubAgents(
  "Research renewable energy and create comprehensive report",
  [researchAgent, writerAgent],
  { coordination: 'sequential' }
);

// Response: string
"Research complete: Solar and wind energy show 23% growth year-over-year. Report includes market analysis, technology trends, and investment opportunities across 15 regions."

Respuesta de Delegate Task

La delegación de tareas devuelve la respuesta del sub-agente como una cadena de texto:

const result = await mainAgent.delegateTask(
  "Translate this document to Spanish",
  translatorAgent
);

// Response: string
"Documento traducido exitosamente. El contenido ha sido adaptado para audiencia hispanohablante manteniendo el tono profesional original."

Respuesta de Coordinate Agents

Coordinar múltiples agentes devuelve un array de pares tarea-resultado:

const results = await mainAgent.coordinateAgents([
  { agent: analyzerAgent, prompt: "Analyze Q4 sales data" },
  { agent: reportAgent, prompt: "Create executive summary" },
  { agent: visualizerAgent, prompt: "Generate performance charts" }
], 'sequential');

// Response structure:
[
  {
    task: {
      agent: analyzerAgent,  // IAgent object
      prompt: "Analyze Q4 sales data"
    },
    result: "Q4 analysis complete: Revenue increased 18%, top products identified, seasonal trends mapped."
  },
  {
    task: {
      agent: reportAgent,
      prompt: "Create executive summary"
    },
    result: "Executive summary created with key findings: 18% growth driven by product line expansion..."
  },
  {
    task: {
      agent: visualizerAgent,
      prompt: "Generate performance charts"
    },
    result: "Performance visualizations generated: 5 charts showing revenue trends, product mix, and regional distribution."
  }
]

Respuesta de Agent.ask() con sub-agentes

Usar agent.ask() con opciones de sub-agente devuelve la cadena de respuesta final:

const result = await mainAgent.ask(
  "Create market analysis presentation",
  {
    useSubAgents: true,
    delegation: 'auto',
    coordination: 'parallel'
  }
);

// Response: string
"Market analysis presentation completed with 3 specialized teams: Research team gathered competitor data, Analysis team processed financial metrics (showing 12% market growth), and Content team created 25-slide deck with executive summary."

Respuesta de asignación manual de tareas

La asignación manual también devuelve una cadena con los resultados combinados:

const result = await coordinatorAgent.ask(
  "Develop comprehensive product launch strategy",
  {
    useSubAgents: true,
    delegation: 'manual',
    coordination: 'sequential',
    taskAssignment: {
      [marketResearcher.id]: "Research target market and competitors",
      [strategyAnalyst.id]: "Develop go-to-market strategy",
      [contentCreator.id]: "Create launch materials and messaging"
    }
  }
);

// Response: string
"Product launch strategy complete: Target market identified (tech-savvy professionals 25-40), competitive positioning defined (premium quality, mid-tier pricing), go-to-market plan created with 3-phase rollout, and launch materials prepared including website, social media, and press kit."

Última actualización: 6 de julio de 2026

En esta sección

Introducción

Framework de agentes de IA de código abierto para construir sistemas autónomos que resuelven tareas del mundo real de forma eficaz.

Instalación

Instala Astreus con npm, yarn o pnpm, confirma la versión de Node.js requerida y prepara un proyecto local para construir agentes de IA con el framework.

Inicio rápido

Construye tu primer agente de IA con Astreus en menos de 2 minutos Aprende los patrones de configuración, las APIs y los ejemplos prácticos necesarios para...

Contexto

Gestión inteligente de contexto para conversaciones largas con compresión automática Aprende los patrones de configuración, las APIs y los ejemplos...

Anterior
Agente
Siguiente
Memoria