Schedules

A schedule starts a run at a fixed time. Use schedules for reports, reviews, sweeps, and reminders. Instruction automations and code automations can both run on a schedule.

Use schedules for:

• daily user health reports,
• weekly pipeline reviews,
• monthly reports on a calendar day,
• first-weekday or last-weekday reviews, such as the first Monday or the last Friday,
• morning support digests,
• weekly marketing ideas,
• recurring blocker sweeps,
• checks of a service that cannot send events.

With instructions

A scheduled instruction automation starts the managed agent with your instructions at each scheduled time. Make it from Automations in the sidebar, or ask Type in the Space. See Create and Manage Automations.

Template prompts can propose scheduled automations as starting points. In the setup conversation, choose the proposals that fit the role. Confirm the cadence, the time zone, the destination, and the enabled state before Type makes an automation. A new automation is disabled unless you explicitly ask Type to start it.

Good scheduled instructions say how often the automation runs, which sources the managed agent checks, what output it makes, and who gets the result.

Interval schedules

Enter a whole-minute interval from 1 to 1,440 minutes (24 hours), for example 5, 17, or 90 minutes. Choose the days on which the automation can run.

If an agent makes an automation with an interval below 15 minutes, the automation starts paused. Open the automation in Type to enable it.

Note

Custom interval authoring is a separate rollout. Until the reader upgrade is on all instances, choose a preset interval.

Monthly schedules

A monthly automation can run on:

• a numbered calendar day, from the 1st to the 31st,
• the first occurrence of a weekday, such as the first Monday,
• the last occurrence of a weekday, such as the last Friday.

If a numbered day does not exist in a shorter month, Type runs the automation on the last day of that month. For example, a schedule for the 31st runs on the last day of February.

Model, accounts, and failures

• To choose the model, reasoning, speed, and connected accounts, see Run a Managed Agent.
• Type pauses a scheduled instruction automation after three failed runs in a row. See Recover an automatically paused schedule.

With code

A code automation uses a recurring source. Choose a fixed interval, stepped backoff, or a cron expression. See Run Code for the basics of a code automation.

Run at an interval

src/main.ts

export const deployment = {
  subscriptions: {
    check: {
      title: "Check every 15 minutes",
      description: "Look for new orders",
      source: { kind: "recurring", schedule: { kind: "interval", everySeconds: 900 } },
    },
  },
} satisfies AutomationDeployment;

• everySeconds must be at least 60, and a multiple of 60.
• The first run starts at the next scheduler check after the deploy. Later runs stay on the same interval from the previous run.

Run on a cron schedule

source: {
  kind: "recurring",
  schedule: { kind: "cron", expression: "0 9 * * 1-5", timezone: "America/New_York" },
},

This runs at 9:00 each weekday in New York time.

• timezone is required. Use an IANA name, for example Europe/London or UTC.
• The schedule can run at most one time each minute. A seconds field that runs more often is rejected.
• The expression must have a future run. If a schedule has no more runs, Type pauses the subscription.

Slow the cadence over time

Use a stepped schedule when checks should become less frequent as time passes:

src/main.ts

export const deployment = {
  expiration: { kind: "duration", afterSeconds: 345600 }, // Four days from first activation
  subscriptions: {
    check: {
      title: "Monitor with backoff",
      description: "Check frequently at first, then slow down",
      source: {
        kind: "recurring",
        schedule: {
          kind: "stepped",
          steps: [
            { everySeconds: 60, forSeconds: 3600 },
            { everySeconds: 600, forSeconds: 3600 },
            { everySeconds: 3600, forSeconds: 21600 },
            { everySeconds: 86400 },
          ],
        },
      },
    },
  },
} satisfies AutomationDeployment;

This checks every minute for an hour, every ten minutes for an hour, hourly for six hours, then daily until expiration. This is elapsed-time cadence; failed runs still follow the automation’s existing failure policy.

• The first run is one interval after activation. Each step starts its own interval grid.
• An occurrence exactly at a step’s endpoint belongs to that step. The next step’s first run is one new interval after the boundary.
• Use 2–32 steps. Intervals and durations are positive whole minutes; intervals cannot decrease and each timed step lasts at least one interval.
• Only the final step omits forSeconds. Use expiration by duration, run count, or timestamp to stop it; without expiration the final interval repeats indefinitely.
• Time continues during pauses. Resume skips missed runs and retains elapsed age.
• Changing the schedule restarts its cadence. Code-only edits preserve it. Neither edit resets the original expiration deadline or run count.

Deploy with type-cli automations deploy ./monitor --space operations, or ask Type to configure the same schedule in chat. scheduled-actions get <id> --space operations --json returns the persisted ISO next-run timestamps in subscriptionNextDueAt. The trigger view refreshes these times every minute. Paused, archived, or expired schedules have no next run. The web view lists each cadence stage, emphasizes the current stage, and shows configured expiration separately.

Use the scheduled time

The method gets a RecurringEvent:

export default class {
  async check(ctx: AutomationContext, event: RecurringEvent) {
    // event.scheduledAt is the planned time, for example "2026-10-13T13:00:00.000Z"
    const sent = await ctx.write.sendMessage(
      { channelId: "ch_abc123", content: "Daily check started" },
      { effectKey: `daily-check:${event.scheduledAt}` },
    );
    if (sent.isErr()) return err(sent.error);
    return ctx.setOutput({ messageId: sent.value.messageId });
  }
}

Use event.scheduledAt in effect keys and in time windows. Do not use the current clock time for these. If Type runs the same tick again, scheduledAt stays the same.

Read a service that cannot send events

Code automations can receive events only from Slack, GitHub, and custom webhook adapters. For other services, read the service on a schedule:

1. Read new items since the last run. Use a checkpoint to remember the last item.
2. Process only the new items.
3. Save the new checkpoint.

Tip

Use events when the service can send them. Events are faster, and they do not use runs when nothing changed. Use a schedule only when events cannot do the job.

Limitations

• Instruction intervals are whole minutes from 1 to 1,440. Code intervals are at least 60 seconds and a multiple of 60.
• Cron expressions are for code automations. Instruction automations use interval, specific-time, and monthly schedules.
• A schedule does not run while the automation is paused. Type does not run missed ticks when you resume.
• In code, you cannot use match, schema, or debounce with a recurring source.
• scheduledAt is the planned time. The real start time can be later.