Astreus

Planer

Einfache zeitbasierte Ausführung mit minimalem Setup Lerne die Einrichtungsmuster, APIs und praktischen Beispiele kennen, die du zum Aufbau zuverlässiger...

Einfache zeitbasierte Ausführung mit minimalem Setup

Übersicht

Der Astreus-Scheduler bietet einfache zeitbasierte Ausführung für Tasks und Graphen mithilfe intuitiver Zeitplan-Strings. Keine komplexe Konfiguration nötig - füge einfach ein schedule-Feld hinzu und du bist fertig!

Grundlegende Task-Planung

Plane einzelne Tasks mit einfacher Syntax:

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);

Zeitplan-Konfiguration

Verwende einfache Zeitplan-Strings für eine unkomplizierte Konfiguration:

// 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'
});

Graph-Planung mit Abhängigkeiten

Plane Graphen mit intelligenter Abhängigkeitsauflösung:

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

Wiederkehrende Muster

Erstelle anspruchsvolle wiederkehrende Zeitpläne:

1

Tägliche Zeitpläne

// 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

Wöchentliche Zeitpläne

// 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

Monatlich und jährlich

// 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
  }
}

Logik der Abhängigkeitsauflösung

Der Scheduler löst Konflikte zwischen Zeitplänen und Abhängigkeiten intelligent auf:

ScenarioBehavior
Node scheduled before dependencyWartet auf den Abschluss der Abhängigkeit
Node scheduled after dependencyLäuft zur geplanten Zeit
Multiple dependenciesWartet auf ALLE Abhängigkeiten
Circular dependenciesFehler wird während der Validierung ausgelöst
Mixed scheduled/immediate nodesFunktioniert nahtlos zusammen

Der Scheduler bietet eine robuste Grundlage für den Aufbau automatisierter, zeitbasierter KI-Workflows, die Abhängigkeiten respektieren und mit deinen Anforderungen skalieren.

Zuletzt aktualisiert: 6. Juli 2026