Scheduler / Planning Agent

The backend agent that breaks a multi-step process into ordered subtasks, schedules each one, and triggers the right agent exactly when it's due.

What Is the Scheduler / Planning Agent?

The Scheduler / Planning Agent is one of TotalApp's Core Agents. It breaks a long, multi-step process — a project's approval chain, a multi-stage onboarding flow — into ordered subtasks, schedules each one, and triggers the right agent via SSE or webhook exactly when that step is due.

A multi-step process is too long and too dependent on external timing to run as a single step. The Scheduler / Planning Agent owns the handoffs between steps: decomposing the plan, tracking dependencies, and firing each subtask's trigger at the right moment — instead of every workflow author having to build their own ad-hoc scheduling logic.

In one sentence

Give the Scheduler / Planning Agent a multi-step goal — it decomposes it into ordered, dependency-aware subtasks, and triggers the right agent for each one exactly when it's due, whether that's once or on a recurring schedule.

How It Works — Plan, Schedule, Trigger

1. Task Decomposition → 2. Dependency Scheduling → 3. Scheduled Triggering

Phase	What happens
1. Task Decomposition	A multi-step process is decomposed into subtasks with explicit dependencies. The full plan is visible and editable before it starts executing.
2. Dependency Scheduling	The agent handles both sequential steps and steps that can run in parallel, and re-plans automatically if an earlier step's outcome changes what comes next.
3. Scheduled Triggering	Each step fires via SSE or webhook — no polling loop required on either side. Stalled steps are flagged once they pass their expected completion window.

Handles one-off plans and recurring schedules alike

The same decomposition-and-trigger mechanism serves both a single multi-step plan (a specific project's approval chain) and a recurring scheduled workflow (a monthly close process) — there's no separate system for the two.

Key Capabilities

Automatic Decomposition

Breaks a long process into clear, individually schedulable subtasks with dependencies, visible and editable before execution begins.

SSE & Webhook Triggers

Fires the right agent exactly when a step is due — no polling required, keeping the system responsive without wasted overhead.

Recurring & One-Off

Handles both a single multi-step plan and a recurring scheduled workflow with the same underlying mechanism.

Full Execution Timeline

See every step's status, past and in progress, for any plan running in the system — nothing is opaque once a plan starts executing.

Output — What You Get Back

Field	Meaning
`plan`	The decomposed list of subtasks with their dependencies, visible before execution starts.
`step_status`	Per-step status — pending, in progress, completed, or stalled — for the full execution timeline.
`next_trigger`	When and how the next pending step will fire (SSE or webhook).

Stalled steps are flagged, not silently retried forever

A step that passes its expected completion window without finishing is explicitly flagged as stalled rather than being silently retried indefinitely — this surfaces broken handoffs instead of masking them.

Frequently Asked Questions

Can I see the plan before it starts running?

Yes — the full decomposed plan, including step order and dependencies, is visible and editable before execution begins.

What happens if an earlier step changes what should happen next?

The agent re-plans automatically — the remaining subtasks and their scheduling adjust based on the actual outcome of the step that just completed, rather than following a rigid predetermined sequence.

Does it poll for step completion?

No — triggering is event-driven via SSE or webhook, not a polling loop, which keeps overhead low even for plans with many steps or long delays between them.

How is a stalled step surfaced?

It's flagged in the execution timeline once it passes its expected completion window, and this can be wired to the Notification / Alerting Agent so the right people are told immediately rather than discovering it later.