DEV Community

Rose
Rose

Posted on

Schedules are easy to demo and hard to trust

A schedule is the easiest thing to show in a demo and the hardest thing to be trusted with in production. You type 0 9 * * * in a box, hit a button, and a message arrives. Everyone in the room says "nice." Nobody asks the three questions that decide whether that schedule is worth anything to you: what happens if the process is asleep at 09:00, what happens if the 09:00 run is still going at 09:05, and how would I know if last night's run never fired at all?

That gap — between a schedule that fires and a schedule you'd put a real job on — is where most agent scheduling tools quietly give up. This post is about the mechanisms that close it, and about what to go and check in any tool you're considering, ours included.

The problem, in the words of everyone who has run a cron

If you've run a cron on a box you own, you already know the failure modes. They are old and unglamorous:

  • The box was off, or restarting. Cron fires nothing, and says nothing. The job simply didn't happen, and you find out days later from the absence of a file.
  • Timezone drift. A job meant for 09:00 local becomes 09:00 UTC after a runtime change, and it fires at 1am — or twice, once under each rule, depending on how the fix was made.
  • Overlap. The job normally takes 90 seconds. One night it takes 40 minutes because an upstream API was slow. The next firing starts on top of it and now two copies are writing the same records.
  • Silent failure. The job ran, threw, and the scheduler logged "started." Start is not success.

An agent makes every one of those worse, because an agent run is a non-deterministic, long-lived, expensive thing that can change state on your machines. A cron entry that misfires is a nuisance. An agent schedule that misfires can send the email twice, deploy twice, or open the same PR again.

So the question isn't "does it have a scheduler." Every agent framework has a scheduler. The question is what the scheduler promises, and whether those promises are enforced by the platform or left to the model's good manners.

Mechanism one: work is written down before anything wakes

The single most useful property I've found to look for is this: is the job a durable record, or is it a timer in a process's memory?

If it's a timer, then the schedule only exists while the process does. Restart the process and you've lost the pending fire; the next fire happens only if the process stayed up long enough to reach it. That's fine for a demo on your laptop. It's not fine for anything that has to happen on a night you weren't watching.

The mechanism to ask about is a saved job that an agent is woken to execute — the work exists independently of the worker. At AgentParley, every job is saved before an agent wakes, and long missions carry on through restarts. On the crews page, the same property is stated from another angle: every piece of work is written down before an agent is woken; if a worker dies mid-step, another picks it up; and a sweep re-wakes anything left unfinished. A reply that was saved but not delivered is re-sent without paying for a second model call.

Work through what that means concretely, because it's more than "it survives a restart." The useful distinction is between work that has not run, work in progress, and work whose result was saved. A crash in the middle should be recoverable. A system that can only tell you "the schedule fired" is omitting the part you actually need to know.

Mechanism two: the limit is what decides overlap, and it should queue, not fail

Here's a design decision that's easy to miss and expensive to get wrong. When a scheduled run is due but the agent is already busy, what happens?

Three answers exist in the wild: fire anyway (two runs, same agent, overlapping state — the worst), skip silently (your job didn't happen and nothing says so), or wait its turn. Of the three, waiting is the only one that's safe to run unattended, and it's the one you should test for on day one.

At AgentParley this is a documented, numbered limit rather than an emergent behaviour. The pricing page lists chats working at once — 1 on Free, 3 on Solo, 10 on Entrepreneur — and states plainly: "Over your working-at-once limit, work simply waits its turn. Nothing fails." Specialists and schedules both count toward that number, which is the honest way to do it: a schedule is work, so it competes for the same slots as everything else and gets accounted for.

There's a related mechanism worth understanding, because it changes what a schedule can do rather than just when it fires. Per-run step limits exist (8, 12 and 20 steps on Free, Solo and Entrepreneur), but they don't cap the work: when a run uses its steps, the agent goes back in the queue and carries on from where it left off. A scheduled job that needs more than one slot's worth of work resumes rather than dying at the limit. If a tool's step limit kills the job instead, your nightly work becomes quietly partial — which is worse than not running it.

Mechanism three: waiting costs nothing, and that includes a failed run's wait

A schedule spends most of its life not running. The question is whether the system spends anything to keep it there.

An agent waiting on a build, a timer or a colleague makes no model calls until something arrives. In the crews page's phrasing, it sleeps. And an agent waiting on a person is told to snooze rather than spin.

Be careful here, because this is where a lot of copy — including ours, in earlier drafts — gets sloppy. Token caching does not make a schedule cheap. Prompt caches live minutes, not days. A nightly job is not billing at cached rates because it "saw this prompt before" — it's a fresh run with a fresh prompt, and you should price it as one. What keeps a waiting schedule free is that it makes zero calls, not that the calls are discounted. Those are different mechanisms and conflating them is how people end up with a surprise bill.

Mechanism four: time is a configuration, not a clock in the prompt

Timezone handling is where I'd be most suspicious of any new tool, because it's the failure that produces the wrong-but-plausible outcome: the job runs, it just runs at the wrong time, and nothing looks broken.

Two things are worth separating.

First, the schedule's own timezone — the zone the recurrence is defined in, stored with the schedule, so a job meant for 09:00 in your city stays at 09:00 in your city across a daylight-saving shift rather than sliding an hour. Ask directly whether the zone is stored per schedule. If the answer is "it uses the server's clock," you've found a job that will drift.

Second — and this one is specific to agents rather than cron — the clock should not be in the cached part of the prompt. This is the failure the comparison page documents in OpenClaw: an open issue reports that heartbeats miss the prompt cache because the current time sits in the cached start of the prompt. That has nothing to do with which product you pick and everything to do with how you build an agent: a stable prefix and a growing history keep the cache; a clock at the top rewrites it every single fire. If you're building this yourself, that's the design rule. In a scheduled agent, it's the difference between several full-price prompt writes a day and none.

(Caveat, stated because I don't have the verification for more: the recurrence semantics of AgentParley's schedules — exactly how a missed slot is treated, whether DST-ambiguous local times are resolved to the earlier or later instant — is not something I've been able to confirm from a public page. Test it before you depend on it. I say so here rather than imply a guarantee I can't point at.)

Mechanism five: run evidence, and the difference between "started" and "succeeded"

The last mechanism is the one that determines whether you'll trust the thing in a month: what record does a run leave behind?

A last-success timestamp is not a record. It tells you the most recent run that reported success, and says nothing about whether every slot in between actually produced one. A run started in the log is not a record either. What you want, per run: which schedule and which version of it, which slot it was for, which timezone was stored, what instant that resolved to, whether it started, whether it finished, what the outcome was, and — for jobs that touch the outside world — a receipt that it landed.

On AgentParley, the observable surface is real but I want to be precise about what I've verified. The Activity page shows what's running now, what needs you, and what happened since your last visit. Each specialist has a live card showing what it's doing and what it has cost, with a Stop button, and you can read any specialist's transcript as it's written. The Usage page breaks spend down per agent, per chat, per model and per schedule, and exports as CSV. A provider error is retried up to five times and then you're told, plainly, rather than failing into silence.

What I have not been able to verify from a public page is a per-slot ledger — a table of "every scheduled slot, and whether it produced a run." So I won't claim one. If you're evaluating any tool including this one, ask for that table specifically. It is the single best question: it's the one a last-success timestamp can't fake.

The checklist I'd use on any scheduler

If you're picking between tools — AgentParley, a hosted alternative, or your own cron and a shell script — these are the five questions in order of how much they'll cost you to get wrong:

  1. Is the job saved before a worker wakes, and what happens if the worker dies mid-run?
  2. When a run is due and the agent is busy, does it fire, skip, or queue? A tool that fires anyway is not ready for unattended work.
  3. Does a step or turn limit truncate the work, or does the job resume?
  4. Is the timezone stored per schedule — and is the current time in the stable part of the prompt?
  5. Can I see every slot, not just the last one that succeeded?

Nothing on that list requires an opinion about multi-agent design or which model you run. That's the point. Scheduling trust is downstream of bookkeeping, and bookkeeping is a thing you can look at.

Where a hosted scheduler is the wrong call

Being fair to the alternative: if you want total control of the recurrence logic — custom catch-up rules, your own retry topology, an on-call rotation wired into the failure path — a cron you own, on a box you own, is more honest than any hosted scheduler, because you can read and change every line of it. You'll pay for that in the box staying up and you'll write the run ledger yourself. That's a real trade, and for some jobs it's the right one.

What you get instead by taking it hosted is that bookkeeping without owning the worker: the working-at-once limits are in the pricing table rather than discovered at 2am, updates ship on their side, and the platform carries the state that lets a crashed step be picked up by someone else.

A closing note

If you're weighing AgentParley for scheduled work specifically, the OpenClaw alternative page covers the trade against self-hosting — including the places OpenClaw is the better pick, which we put on the page deliberately. For the specifics of plans, schedules and limits, agentparley.ai is the place to look; the pricing page lists the exact numbers rather than a floor.

Top comments (1)

Collapse
 
sara_builds profile image
Sara •

The per-slot ledger is the piece I’d want to see before trusting a schedule in production. Do you record a stable run ID for each intended slot, including its timezone-resolved instant, so retries can be idempotent and operators can tell a missed run from a delayed one?