Cron dies with the box.
A host reboots or crashes and the job is just gone: no retry, no record, no alert. You find out when something downstream is missing.
Durable scheduling for the agentic era
Scheduled HTTP delivery that never gets silently lost.
Hand SchedStack a destination and a time, over API or MCP. It delivers, retries until it lands, and never drops the request. Backed by a published100–300 ms accuracy SLO.
- Never silently lost
- Signed, verifiable delivery
- 100–300 ms p99 dispatch SLO
THE PROBLEM
Why not just use cron?
Every team reaches for cron, a queue, or a hand-rolled timer first. Each one loses requests in a way you only notice too late.
Queues weren't built for time.
Bolting delays onto a message queue means lost timers and silent drops under failure. Scheduling is an afterthought, not the guarantee.
Agents can't wait.
Stateless agents and serverless functions can't hold a durable timer across hours or days. They need to hand the clock to something that will.
HOW IT WORKS
A destination and a time. We do the rest.
Schedule
POST a destination and a time: a one-shot delay, an absolute instant, or a recurring cron with a timezone. Or just ask over MCP in plain language.
Deliver
SchedStack sends a signed request to your endpoint and retries with backoff until it lands. Nothing is dropped silently along the way.
Confirm & replay
Every attempt is recorded. Exhausted deliveries land in dead-letter, inspectable and replayable on demand. A bad hour is never a lost request.
WHY SCHEDSTACK
Built for durable scheduling and the agentic era.
A primitive, not a platform. No SDK to adopt, no workflow DSL to learn: just a destination, a time, and guarantees.
Schedule in plain language
A first-class MCP server lets agents schedule the future as "in 2h", ISO, or cron, with a next-fire preview before anything commits.
Never silently lost
At-least-once made safe with signatures and idempotency. Failures land in dead-letter, replayable on demand. Nothing dropped on the floor.
DST-correct recurrence
Spring-forward and fall-back handled correctly. "9am local" stays 9am across the change, with no double-fires and no skips.
Published accuracy SLO
A stated 100–300 ms p99 dispatch-initiation SLO. We publish the number instead of hand-waving about reliability.
Test and live modes
Isolated test and live modes from day one, Stripe-style. Build and verify against test data without ever touching production.
Failure-path pricing
Retries do not multiply your bill. You are not punished for the failures SchedStack exists to handle.
Agent-native · MCP
The durable timer your agents can't hold themselves.
Stateless agents and functions can't wait. SchedStack is the scheduling layer they call over MCP. The server owns the clock, so the model doesn't have to. Forgiving timing, a next-fire preview before anything commits, and the same delivery guarantees as the API.
preview_schedulecreate_schedulelist_schedulescancel_schedulelist_deliveriesreplay_delivery
{
"tool": "create_schedule",
"arguments": {
"when": "next monday at 9am",
"endpoint": "https://api.acme.com/agent/run",
"body": "{\"task\":\"weekly digest\"}"
}
}TRUST · DELIVERY CONTRACT
Delivery you can prove.
At-least-once, made safe. Every request is signed so you can reject anything that isn't genuinely from SchedStack, and dedupe on the idempotency key. The full contract (headers, retries, dead-letter) is documented, not implied.
- Signed, every time. Each delivery carries Sched-Signature, Sched-Timestamp, Sched-Delivery-Id, Sched-Attempt and a stable Idempotency-Key.
- Retried with backoff. Transient failures retry on an exponential backoff with jitter until your endpoint confirms or the budget is spent.
- Dead-letter + replay. Exhausted deliveries are kept, inspectable, and replayable. Never dropped, never a mystery.
import crypto from 'node:crypto';
// Reject anything not genuinely from SchedStack.
export function verify(req, rawBody, secret) {
const sig = req.headers['sched-signature']; // "t=<unix>,v1=<hex>[,v1=<hex>]"
const id = req.headers['sched-delivery-id'];
const att = req.headers['sched-attempt'];
const t = sig.match(/t=(\d+)/)?.[1];
const signed = `${t}.${id}.${att}.${req.method}.${req.path}.${rawBody}`;
const exp = crypto.createHmac('sha256', secret)
.update(signed).digest('hex');
// Multiple v1= appear during rotation; accept ANY match.
return sig.split(',')
.filter(p => p.startsWith('v1='))
.map(p => p.slice(3))
.some(v => v.length === exp.length && crypto.timingSafeEqual(
Buffer.from(v), Buffer.from(exp)));
}HOW WE COMPARE
A primitive, not a platform.
No SDK, no worker model, no workflow DSL. Just HTTP, with the guarantees built in. We don't ship fan-out, URL-groups, or topics; that's a deliberate choice, not a gap.
| Capability | SchedStack | QStash | Posthook | Inngest | Cron |
|---|---|---|---|---|---|
| Scheduled HTTP delivery | Core | Yes | Core | Via steps | Manual |
| No SDK required (just HTTP) | Yes | Yes | Yes | SDK | n/a |
| Agent-native MCP server | Yes | No | No | No | No |
| DST-correct recurrence | Yes | Limited | Yes | Limited | No |
| Published accuracy SLO | Yes | No | No | No | No |
| Dead-letter + replay | Yes | Yes | Yes | Yes | No |
FAQ
Questions, answered.
How can an AI agent schedule a task to run later?
An agent cannot hold a timer inside a single model call, so it needs an external service that owns the clock. SchedStack exposes an MCP server: your agent calls create_schedule with a destination and a time, and SchedStack calls your endpoint back at the right moment, retried until it lands.
What is SchedStack?
SchedStack is durable scheduled HTTP delivery. You hand it a destination and a time, one-shot or recurring, and it delivers, retries until it lands, and never silently loses an accepted delivery.
How is it different from QStash or a cron job service?
Cron dies with the host and keeps no record. QStash is a messaging platform where scheduling is one feature. SchedStack is built around scheduling: DST-correct recurrence, a published accuracy SLO, and a first-class MCP server.
Can I try it without touching production?
Yes. SchedStack has isolated test and live modes from day one. Build and verify in test mode, then flip to live. Test data never mixes with production.
What does "never silently lost" mean?
Once SchedStack accepts a schedule, it owns delivery end to end: it retries with backoff until your endpoint confirms, and on exhaustion the delivery lands in a dead-letter queue you can inspect and replay. It is never dropped without a trace.
How do I verify a delivery really came from SchedStack?
Every outbound request is signed. Verify the Sched-Signature header (HMAC-SHA256 over timestamp, delivery id, attempt, method, path, and body) and dedupe on the Idempotency-Key. Receiver code samples are in the docs.
What is the accuracy SLO?
SchedStack publishes a 100–300 ms p99 dispatch-initiation SLO: the time from a schedule becoming due to dispatch beginning.
Does it handle time zones and DST?
Yes. Recurring schedules are DST-correct: "9am local" stays 9am across spring-forward and fall-back, with no double-fires or skips.
Stop losing scheduled requests.
Join the waitlist for early access, or start in the docs today against the live API.
No spam. Early access keys roll out weekly.