Works with Claude, ChatGPT and Grok · free trial

Your agent's session ends. The work doesn't.

AgentLater keeps going after your agent stops: it sends signed HTTPS requests later, watches long jobs and acts when they finish, receives webhooks, and keeps every result in an inbox the next session reads. It can even wake the agent up.

Connect your agent Read the quickstart

the agent, todayschedule_http({
  url: "https://example.com/hooks/reminder",
  body: "{\"remind\":\"invoice #42\"}",
  delay: "24h"
})

get_task, tomorrow{
  "id": "task_3bc148a4ebabd050a7bf",
  "status": "succeeded",
  "attempt_count": 2,
  "attempts": [
    { "number": 1, "outcome": "http_503" },
    { "number": 2, "outcome": "http_200" }
  ]
}

Get started

Connect your agent in a minute

AgentLater is a set of tools your agent calls over MCP, so it works with Claude, ChatGPT and Grok, any other client that speaks MCP, or your own code. There is no dashboard, no sign-up and no API key to paste. Each connection gets its own project with a free trial.

Claude

In Claude Code, run one command. In Claude Desktop or claude.ai, add a custom connector. Either way, approve the connection on the page that opens.

# Claude Code
claude mcp add --transport http runlater https://gateway.agentlater.io/mcp

# Claude Desktop or claude.ai
Settings → Connectors → Add custom connector
  URL: https://gateway.agentlater.io/mcp

ChatGPT

On chatgpt.com/plugins, add a custom MCP server with this URL, then sign in when ChatGPT asks.

chatgpt.com/plugins → + → Add custom MCP server
  URL:            https://gateway.agentlater.io/mcp
  Authentication: OAuth

Grok

Add a custom connector at grok.com and approve the connection on the page that opens.

grok.com → Connectors → Custom
  Server URL: https://gateway.agentlater.io/mcp

Any other MCP client

Codex, Cursor and the rest: add https://gateway.agentlater.io/mcp as a remote MCP server and sign in when asked. The quickstart has the details for each.

{
  "mcpServers": {
    "runlater": { "url": "https://gateway.agentlater.io/mcp" }
  }
}

Your own agent, in code

Use the Agent Auth SDK. The agent makes its own keys and gets its own project.

import { AgentAuthClient } from "@auth/agent";

const client = new AgentAuthClient({
  storage, // persistent: losing the keys loses the project
  directoryUrl: null,
  allowDirectDiscovery: true,
});
const { agentId } = await client.connectAgent({
  provider: "https://gateway.agentlater.io",
  mode: "autonomous",
  name: "my agent",
  // the full list is in the quickstart
  capabilities: ["create_project", "schedule_http", "watch_http", "read_inbox"],
});
const run = (capability, args = {}) =>
  client.executeCapability({ agentId, capability, arguments: args });
await run("create_project");

Then just ask

Your agent reads what each tool does. Describe the outcome and when you want it, and it picks the calls.

you, to your agentUse AgentLater to watch https://deploy.example.com/deployments/123
every 5 minutes. When status is SUCCEEDED, start the smoke tests at
https://ci.example.com/smoke and put the result in the inbox.
Next session, read the inbox first.

What your agent can do

Everything that has to happen while it's gone

Each of these is a tool call. They share the same signed, retried, recorded delivery underneath.

Do it later

Send a signed HTTPS request in 90 seconds or 7 days, retried with backoff until it lands.

schedule_http

Do it now, in order

Queue a request to run in the background. Requests in one queue run one at a time, in order, even through retries.

queue_http

Do it every day

Crons on a UTC schedule, with an alert when runs start failing.

create_cron

Wait for a job, then act

Poll a status URL until it says done, then send the next request itself.

watch_http · on_match

Hear back without a server

Results, captured responses and alerts land in an inbox the next session reads.

read_inbox · capture

Get woken up

When the inbox gets something, AgentLater calls the trigger that starts your agent.

set_wake

Receive webhooks

A URL for GitHub, Stripe or CI. Signatures checked, noise filtered, events into the inbox.

create_hook

Keep secrets out of prompts

Store a token once, bound to its hosts; requests say {{secret:NAME}} instead.

set_secret

Examples

What it looks like

What the agent sends. In an MCP client you ask in plain words and see these calls go by.

Watch a deploy, then test it

No agent turn in between: when the deploy reports SUCCEEDED, the smoke tests start.

watch_http({
  url: "https://deploy.example.com/deployments/123",
  every: "5m",
  deadline: "6h",
  until: { path: "/status", in: ["SUCCEEDED"] },
  on_match: {
    url: "https://ci.example.com/smoke",
    headers: { "Authorization": "Bearer {{secret:CI_TOKEN}}" },
    callback_url: "inbox"
  }
})

Hear only about failed CI

create_hook({
  name: "ci-failures",
  verify: { scheme: "github", secret: "…" },
  accept: [{
    headers: { "X-GitHub-Event": ["workflow_run"] },
    path: "/workflow_run/conclusion",
    in: ["failure"]
  }]
})
// → { url: "https://hooks.agentlater.io/h/prj_…/hk_…" }

Pick up where you left off

The next session starts from a report, not from checking everything again.

// next session
get_project()  // → { inbox_unread: 2, … }
read_inbox({ ack: true })
// → [{ event: "task.finished", task: { status: "succeeded",
//      response: { status: 200, body: "{\"passed\":42}" } } },
//    { event: "hook.received", hook: "ci-failures", … }]

How it works

Four steps, no infrastructure

No server, queue or cron job to run. AgentLater holds the work and the results until your agent comes back.

Connect
Add AgentLater to your MCP client, or register from code. The agent gets its own identity.
Create a project
create_project starts a free trial: 100 delivery attempts over 7 days.
Hand it the waiting
Schedule, watch, run a cron or open a hook. Then the session can end.
Hear back
Read the inbox next session, get woken up, or check get_task.

Delivery

Built to be trusted with “later”

Delivery is at least once. A 2xx response means the destination accepted the request; AgentLater says so, and nothing more.

Signed deliveries

Every request carries an HMAC-SHA256 signature, so the destination knows it came from your project.

Retries with backoff

Timeouts, 429s and 5xx responses are retried with growing, jittered delays. Retry-After is respected.

Every attempt recorded

Each try keeps its time and HTTP status or error. “Did it happen?” has a real answer.

Safe to repeat

With an idempotency key, a retried call returns the same task instead of a duplicate.

Public HTTPS only

Destinations must be public https:// names. Private networks, IPs and localhost are refused.

Secrets stay put

A secret only goes to the hosts it was set for, and is never shown back, not even in responses.

Limits

Free to start, $5 when you need more

Everything above is in the trial. When it runs out, your agent sends you a payment link: 50,000 more attempts for $5, with no account or subscription. Receiving webhooks and reading the inbox cost nothing.

How delivery works →

Free trial	100 delivery attempts over 7 days, per project
More attempts	50,000 for $5, valid 12 months; leftovers carry over
Projects	One per agent host
Schedule ahead	Up to 7 days, and before the project's attempts expire
Request body	64 KiB
Headers	32 headers, 8 KiB in total
Attempts per task	1–5 (default 5)
Attempt timeout	10 seconds; redirects are not followed
Tasks held	1,000 per project (20,000 once paid), finished ones included until purged
Retention	Tasks and attempts are kept 30 days after they finish
Crons	10 per project, each running at most once an hour
Watches	A poll every 5 minutes to 24 hours, for up to 7 days
Captured responses	First 16 KiB and 4 headers, kept 7 days after the task finishes
Inbox	10,000 events per project; unread kept 30 days, acked 7 days
Wake	At most one per 1 minute to 24 hours (default 15 minutes); off after 3 failures in a row
Secrets	50 per project, 4 KiB each, each bound to at most 20 hosts
Hooks	20 per project; 60 requests a minute each; 1,000 events a day (10,000 once paid), 100 per unverified hook; 256 KiB per request

Give your agent a sense of later

Connect it from Claude, ChatGPT or Grok, and hand it the waiting.

Connect your agent See every capability