> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gloo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Schedules

> Platform ops console for recurring crons, the operator-wide workflow-trigger rollup, and pending one-off jobs, with server-derived health, run history, and permission-gated controls.

The **Schedules** section (`/platform/schedules`) is the operator surface for every scheduled
job the platform runs: the recurring platform crons (workflow watchdog, retention sweepers, budget
resets, drift alerts, model catalog sync, governance reminders, sandbox heartbeats, Judge metrics
aggregation and others), the workflow triggers across the org unit, and pending one-off jobs.

This entire page is **admin-only**. All three tabs — Recurring, Upcoming, and the
operator-wide Triggers rollup — require Platform admin; non-admins are redirected to the builder
scheduling surface at [Production › Workflows › Schedules](https://docs.gloo.com/forge/console/production/workflows/triggers.md#scheduling-workflows),
where builders manage their own workflow schedules per-workflow. The Triggers tab here is the
platform-wide trigger rollup, not the builder's scheduling home.

## What you can do

* **Check the health of every platform cron** on the Recurring tab, failing and overdue ones first.
* **Open a cron's run history**, with each run's outcome, duration and error.
* **Pause, resume or run a cron now**, with `platform:manage`.
* **See what fires next**: up to 72 hours of scheduled work on the Upcoming tab.
* **Review every workflow trigger** in the org unit on the Triggers tab.

## What you can see

The page has three tabs. The active tab is persisted in the URL (`?tab=recurring` / `?tab=upcoming` / `?tab=triggers`) so links are shareable.

> [tab] Recurring
>
> A **health-first** inventory of every platform cron Forge ships. A KPI health band sits above the table, and rows are ranked by attention — anything failing or overdue floats to the top.
>
> ![Schedules — Recurring tab](https://mintcdn.com/gloo-b243725a/Ndtg9NEpwGc2OULA/forge/images/console/platform/schedules-light.png?fit=max\&auto=format\&n=Ndtg9NEpwGc2OULA\&q=85\&s=28080ea7b4e671ac90e21596de1e193c)
>
> Schedules → Recurring — Forge Console at `/platform/schedules?tab=recurring`
>
> The **KPI health band** summarizes the fleet at a glance: healthy, needs-attention (failing + overdue), degraded, paused, and due-in-the-next-hour counts.
>
> | Column | What it tells you |
> | - | - |
> | **Name** | The manifest entry's stable identifier plus a one-line description |
> | **Health** | A color-coded badge derived server-side from real run telemetry: `healthy`, `degraded` (a failure among the last 5 settled runs), `failing` (most recent settled run failed), `overdue` (an interval cron silent past its threshold), `paused`, or `no data` (telemetry still warming up). This is where color lives — category chips are neutral |
> | **Category** | A neutral metadata chip (`lifecycle`, `retention`, `budget`, `observability`, `platform_services`, `telemetry`, `governance`, `curation`, `workflow`, `chat`, `sandbox`, or `other`) |
> | **Cadence** | Human-readable string from the manifest (`every 60s`, `daily 04:30 UTC`, etc.) |
> | **Run history** | A sparkline of the last ≤20 run outcomes, newest first |
> | **Next fire** | Relative ("in 12m") with the absolute timestamp on hover. Shows `—` when the cron is paused |
> | **Last run** | The most recent settled run's outcome and duration |
> | **Failures** | Count of failures over the last ≤20 telemetry runs. Rendered red when non-zero |
>
> Filters above the table narrow by category, health, and a case-insensitive name search; they compose. Each row exposes **Pause / Resume** and **Run now** controls, and clicking a row opens the drill-in drawer (see below).

> [tab] Upcoming
>
> A chronologically ascending forward-look across three sources, sorted by the next time each job is expected to fire.
>
> ![Schedules — Upcoming tab](https://mintcdn.com/gloo-b243725a/Ndtg9NEpwGc2OULA/forge/images/console/platform/schedules-upcoming-light.png?fit=max\&auto=format\&n=Ndtg9NEpwGc2OULA\&q=85\&s=27e9368fd6986b87c656e614466f9838)
>
> Schedules → Upcoming — Forge Console at `/platform/schedules?tab=upcoming`
>
> The timeline view unifies three sources into one chronologically ordered list:
>
> * **Platform** rows — recurring entries from the manifest, expanded into their fire times within the selected window.
> * **Workflow** rows — operator-defined `workflowTriggers` next-firing times. The category badge reads "Workflow trigger" to distinguish them from platform crons with `category: "workflow"`. Each row links to `/production/workflows/<id>` for the owning workflow.
> * **One-off** rows — one-time jobs the platform has scheduled to run later. These have no category — the badge column shows `—`.
>
> The **window selector** offers 1h / 6h / 24h / 72h. The server enforces a hard 72h cap to bound the per-cron fire-iteration cost.
>
> The Upcoming query is only subscribed when the tab is active. Switching tabs back to Recurring unsubscribes; switching back resubscribes. This keeps the steady-state cost of the page on the Recurring side, where the row count is bounded by the manifest.

> [tab] Triggers
>
> The **operator-wide** workflow-trigger rollup — every recurring (cron) and one-shot schedule across the org-unit, in one admin table. Builders create and edit their own triggers from the per-workflow [Schedule tab](https://docs.gloo.com/forge/console/production/workflows/triggers.md#scheduling-workflows) in Production › Workflows; this tab is the platform-wide view of all of them.
>
> ![Schedules — Triggers tab](https://mintcdn.com/gloo-b243725a/Ndtg9NEpwGc2OULA/forge/images/console/platform/schedules-triggers-light.png?fit=max\&auto=format\&n=Ndtg9NEpwGc2OULA\&q=85\&s=88a0f7ba84d8a31803d5f27558491f19)
>
> Schedules → Triggers — Forge Console at `/platform/schedules?tab=triggers`
>
> Each row shows the workflow, the human-readable schedule, the next computed fire time, the trigger's status, and its owner. Rows expose **Edit**, **Pause / Resume**, **Run now**, and **Delete** actions; the **+ New schedule** button at the top of the toolbar opens the create dialog.
>
> Filters above the table narrow by workflow and by active-only status. The list is paginated and loads more rows on demand.
>
> **Pause and Delete race the scheduler safely.** The scheduler's claim of a due trigger is the fire. A schedule that follows the active version runs the version that is active when the scheduler claims the fire, even if a newer version is published before the run starts. A pause or delete that commits before a claimed scheduled fire launches cancels that fire and records why (a `workflow_trigger_fire_skipped` audit event); a one-shot is consumed when it is claimed, so pausing it afterwards does not stop that fire; a fire that already launched is a run — cancel it from the run (or with `runs:manage` over the API).
>
> **A schedule stops when its creator loses authority.** Before every fire the scheduler checks that the person who created the schedule still holds `workflows:manage` at both org units the schedule was created against: the workflow's home and the schedule's own org unit, the unit its runs are recorded in, which decides who can read them (a grant at the unit, at one of its ancestors, or at the platform covers it). If they do not — the role was removed or now covers only another unit, their worker seat or person was deactivated, or the creator cannot be found or is not a person — the fire launches nothing and the schedule is paused, with a `workflow_trigger_refused` audit event whose reason begins `creator_authority_lost` (`creator_authority_lost: trigger org unit (<unit id>): …` when only the schedule's own org unit was lost). A schedule whose workflow was deleted is paused the same way after one refused fire (reason `creator_authority_lost: the workflow no longer exists (workflow-missing)`). Resuming does not change the creator, so the next fire pauses it again; to keep the schedule running, delete it and create it again as someone who holds `workflows:manage` at both. If the check cannot be decided (an existing workflow's home org unit is missing or cannot be resolved, the schedule's own org unit cannot be resolved and the creator holds no platform grant, the creator's role grants are too many to read in full, or their person record's merge history is corrupt), that fire is refused and recorded with reason `creator_authority_indeterminate`, and the schedule keeps running.

## Drill-in drawer

Clicking a recurring row opens a side drawer with the cron's run history: each run's trigger (`cron` tick or operator `manual`), start time, duration, outcome, and — on failure — the captured error text. A duration trend surfaces slow-downs over time. The drawer also carries the **Pause / Resume** and **Run now** controls.

## How the data flows

Every platform cron runs through one dispatcher. It checks whether the cron is paused (a cron that
has never been paused or resumed counts as enabled) and records the run before the job starts. A
follow-up job then records each run's outcome, duration and error. Run history is kept for 30 days.

* **Recurring** shows one row per platform cron: its next fire time, worked out from the cadence; whether
  it is enabled; its health; and its last 20 run outcomes, read from that run history.
* **Upcoming** merges the scheduled work from its three sources in fire-time order, up to 72 hours
  ahead. A paused cron shows no upcoming fires.
* The drawer reads one cron's run history, and the row controls pause, resume or run a cron now.

Reading the roster, the upcoming list and a cron's history needs `platform:read`. Pausing, resuming
and running a cron now need `platform:manage`. The Console page is also limited to platform
administrators: anyone else is redirected away from it. The permissions apply to every request,
including requests made outside this page.

Relative times on the page refresh together every 30 seconds.

## Scheduling your own work

Platform crons ship with Forge. You cannot add one from this page, the Console or the API.
To run your own work on a schedule, give a workflow a recurring (cron) or one-shot schedule
from its **Schedule** tab: see [Scheduling workflows](https://docs.gloo.com/forge/console/production/workflows/triggers.md#scheduling-workflows).
Integrators can create the same schedules through the API with
[createTrigger](https://docs.gloo.com/forge/reference/http-api/workflows/createTrigger.md).

## What's not on this page

* **Editing a platform cron's cadence.** Cadence ships with Forge and changes only with a release. Operators can pause / resume and run-now, but not re-time a cron from the console.
  (Workflow-trigger CRUD, including cadence edits, lives on the Triggers tab.)
* **Convex internal scheduled work older than the next 72 hours.** The pending-jobs portion of
  the Upcoming tab is bounded by the window selector for performance.

## Key state to watch

* **Needs attention** in the KPI health band — failing and overdue crons, which also rank first in the Recurring table.
* **Failures** column — a red non-zero count means failures among the last 20 runs; open the row's drawer for the error text.
* **Paused** crons — a paused cron shows `—` for its next fire and projects nothing on the Upcoming tab.
* **Paused triggers** on the Triggers tab — a trigger whose creator lost `workflows:manage` is paused with a `workflow_trigger_refused` audit event.

## Related surfaces

* [Workflow schedules](https://docs.gloo.com/forge/console/production/workflow-schedules.md) for operator-created workflow
  triggers and their cadence.
* [Runs](https://docs.gloo.com/forge/console/production/runs.md) for executions that a schedule has already launched.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.