Astreus

Agendador

Execução simples baseada em tempo com configuração mínima Aprenda os padrões de configuração, as APIs e os exemplos práticos necessários para criar sistemas...

Execução simples baseada em tempo com configuração mínima

Visão Geral

O agendador (scheduler) do Astreus fornece execução simples baseada em tempo para tarefas e grafos usando strings de agendamento intuitivas. Nenhuma configuração complexa é necessária - basta adicionar um campo schedule e pronto!

Agendamento Básico de Tarefas

Agende tarefas individuais com sintaxe simples:

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

const agent = await Agent.create({
  name: 'SchedulerAgent',
  model: 'gpt-4o'
});

// Create a scheduled task - scheduler starts automatically when needed
const scheduledTask = await agent.createTask({
  prompt: 'Generate monthly report for December',
  schedule: 'once@2024-12-25@09:00'
});

// Create a recurring task
const dailyTask = await agent.createTask({
  prompt: 'Daily health check and status report',
  schedule: 'daily@08:00'
});

// Execute the task - scheduler will handle the scheduling automatically
await agent.executeTask(scheduledTask.id);

Configuração de Agendamento

Use strings de agendamento simples para uma configuração fácil:

// Supported schedule formats:
'daily@07:00'                    // Daily at 7 AM
'weekly@monday@09:00'            // Weekly on Monday at 9 AM
'monthly@1@10:00'                // Monthly on 1st day at 10 AM
'hourly'                         // Every hour (default time)
'@15:30'                         // Once today at 3:30 PM
'once@2024-12-25@10:00'          // Once on specific date and time

// Delay-based schedules:
'after:5s'                       // Run after 5 seconds
'after:30m'                      // Run after 30 minutes
'after:2h'                       // Run after 2 hours

// Examples:
await agent.createTask({
  prompt: 'Morning briefing',
  schedule: 'daily@08:00'
});

await agent.createTask({
  prompt: 'Weekly report',
  schedule: 'weekly@friday@17:00'
});

Agendamento de Grafos com Dependências

Agende grafos com resolução inteligente de dependências:

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

const graph = new Graph({
  name: 'Morning Workflow',
  defaultAgentId: agent.id
}, agent);

// Node A: Data collection at 6 AM
const nodeA = graph.addTaskNode({
  name: 'Data Collection',
  prompt: 'Collect overnight data from all sources',
  schedule: 'once@2024-12-20@06:00'
});

// Node B: Processing (depends on A completing first)
const nodeB = graph.addTaskNode({
  name: 'Data Processing',
  prompt: 'Process collected data and generate insights',
  schedule: 'once@2024-12-20@07:00',
  dependsOn: ['Data Collection'] // Must wait for A
});

// Node C: Report generation at 8 AM
const nodeC = graph.addTaskNode({
  name: 'Report Generation',
  prompt: 'Generate morning executive report',
  schedule: 'once@2024-12-20@08:00',
  dependsOn: ['Data Processing']
});

// Execute - scheduler starts automatically for scheduled nodes
await graph.run();

// Result: A runs at 06:00, B waits and runs after A (~06:05), C runs at 08:00

Padrões Recorrentes

Crie agendamentos recorrentes sofisticados:

1

Agendamentos Diários

// Every day at 8 AM
{
  type: 'recurring',
  executeAt: new Date('2024-12-20T08:00:00Z'),
  recurrence: {
    pattern: 'daily',
    interval: 1,
    maxExecutions: 365 // Stop after 1 year
  }
}

// Every 3 days
{
  type: 'recurring',
  executeAt: new Date('2024-12-20T08:00:00Z'),
  recurrence: {
    pattern: 'daily',
    interval: 3
  }
}
2

Agendamentos Semanais

// Every Monday at 9 AM
{
  type: 'recurring',
  executeAt: new Date('2024-12-23T09:00:00Z'), // Monday
  recurrence: {
    pattern: 'weekly',
    interval: 1,
    daysOfWeek: [1] // Monday
  }
}

// Every Monday and Friday
{
  type: 'recurring',
  executeAt: new Date('2024-12-23T09:00:00Z'),
  recurrence: {
    pattern: 'weekly',
    interval: 1,
    daysOfWeek: [1, 5] // Monday and Friday
  }
}
3

Mensal e Anual

// 15th of every month
{
  type: 'recurring',
  executeAt: new Date('2024-12-15T10:00:00Z'),
  recurrence: {
    pattern: 'monthly',
    interval: 1,
    dayOfMonth: 15
  }
}

// Every January 1st
{
  type: 'recurring',
  executeAt: new Date('2025-01-01T00:00:00Z'),
  recurrence: {
    pattern: 'yearly',
    interval: 1,
    monthOfYear: 1
  }
}

Lógica de Resolução de Dependências

O agendador resolve de forma inteligente conflitos entre agendamentos e dependências:

ScenarioBehavior
Nó agendado antes da dependênciaEspera a dependência ser concluída
Nó agendado depois da dependênciaÉ executado no horário agendado
Múltiplas dependênciasEspera TODAS as dependências
Dependências circularesErro lançado durante a validação
Nós agendados/imediatos misturadosFuncionam juntos perfeitamente

O agendador fornece uma base robusta para construir fluxos de trabalho de IA automatizados e baseados em tempo que respeitam as dependências e escalam com suas necessidades.

Última atualização: 6 de julho de 2026

Nesta seção

Introdução

Framework de agentes de IA open-source para construir sistemas autônomos que resolvem tarefas do mundo real de forma eficaz.

Instalação

Instale o Astreus com npm, yarn ou pnpm, confirme a versão necessária do Node.js e prepare um projeto local para construir agentes de IA com o framework.

Início Rápido

Construa seu primeiro agente de IA com Astreus em menos de 2 minutos Aprenda os padrões de configuração, as APIs e os exemplos práticos necessários para...

Agente

Entidade central de IA com capacidades modulares e composição baseada em decorators Aprenda os padrões de configuração, as APIs e os exemplos práticos...

Anterior
Grafo
Próximo
Conhecimento