Quickstart

Connect an agent, create a project, schedule a request, check it later. Two ways in: from an MCP client, or from code with the Agent Auth SDK.

How agents sign in

RunLater uses Agent Auth. An agent generates its own keys and registers them with the gateway; there is no account, password or API key. Each identity gets one project with a free trial. Discovery is at https://gateway.runlater.io/.well-known/agent-configuration.

Keep the keys. The project belongs to the key that created it. If the keys are lost, so is access to the project.

From an MCP client

Add RunLater as a remote MCP server at https://gateway.runlater.io/mcp. The first time it connects, your client opens a RunLater page in the browser; click Connect. There's no account to create: that connection gets its own project and free trial, and the client keeps it signed in.

Claude Codeclaude mcp add --transport http runlater https://gateway.runlater.io/mcp

ChatGPT (Plugins → Add custom MCP server)chatgpt.com/plugins → + → Add custom MCP server
  URL:            https://gateway.runlater.io/mcp
  Authentication: OAuth

OpenAI Codex# ~/.codex/config.toml
[mcp_servers.runlater]
url = "https://gateway.runlater.io/mcp"

# then sign in once
codex mcp login runlater

Grokgrok.com → Connectors → Custom
  Server URL: https://gateway.runlater.io/mcp

clients that take a JSON config (Cursor, Claude Desktop and others){
  "mcpServers": {
    "runlater": { "url": "https://gateway.runlater.io/mcp" }
  }
}

Menu names move around between releases; what every client needs is the URL above, with OAuth sign-in. Custom connectors may depend on your plan, and on a workspace an admin may have to allow them.

Each RunLater capability is a tool: create_project, then schedule_http, create_cron or watch_http, and later get_task. If the connection is removed, so is access to its project; connecting again starts a new one.

Or run the Agent Auth bridge locally

For an Agent Auth identity instead, add the Agent Auth bridge as a local MCP server. It runs on your machine, stores the agent's keys in ~/.agent-auth (encrypted with the key you set), and talks to RunLater for you.

claude_desktop_config.json, or your client's MCP settings{
  "mcpServers": {
    "runlater": {
      "command": "npx",
      "args": ["@auth/agent-cli@0.5.1", "mcp", "--url", "https://gateway.runlater.io"],
      "env": { "AGENT_AUTH_ENCRYPTION_KEY": "<32 random bytes, hex>" }
    }
  }
}

The bridge offers generic Agent Auth tools rather than one tool per RunLater feature. Ask the agent to schedule something with RunLater and it will:

1. call connect_agent with provider https://gateway.runlater.io,
2. use list_capabilities to read what RunLater offers,
3. call execute_capability with create_project, then schedule_http, and later get_task.

From code

Use @auth/agent in TypeScript or JavaScript. Every RunLater feature is a capability you execute by name; results come back in data.

agent.mjsimport { AgentAuthClient, MemoryStorage } from "@auth/agent";

const client = new AgentAuthClient({
  storage: new MemoryStorage(), // use persistent storage: losing the keys loses the project
  directoryUrl: null,
  allowDirectDiscovery: true,
});

// 1. Register an identity. No account, no API key.
const { agentId } = await client.connectAgent({
  provider: "https://gateway.runlater.io",
  mode: "autonomous",
  name: "my agent",
  capabilities: ["create_project", "get_project", "schedule_http", "get_task",
                 "list_tasks", "cancel_task", "redrive_task",
                 "create_cron", "get_cron", "list_crons", "delete_cron", "watch_http",
                 "read_inbox", "ack_inbox", "set_wake", "delete_wake",
                 "set_secret", "list_secrets", "delete_secret",
                 "create_hook", "list_hooks", "update_hook", "delete_hook"],
});
const run = (capability, args = {}) =>
  client.executeCapability({ agentId, capability, arguments: args }).then((r) => r.data);

// 2. Create the project once. Keep signing_secret for the destination.
const project = await run("create_project");

// 3. Schedule a request for tomorrow.
const task = await run("schedule_http", {
  url: "https://example.com/hooks/reminder",
  body: JSON.stringify({ remind: "invoice #42" }),
  headers: { "Content-Type": "application/json" },
  run_at_ms: Date.now() + 24 * 60 * 60 * 1000,
  idempotency_key: "reminder-invoice-42",
});

// 4. Later: did it happen?
const status = await run("get_task", { task_id: task.id });
console.log(status.status, status.attempts);

When RunLater adds a capability

An agent is granted the capabilities that existed when it connected. When RunLater adds one, such as the cron tools (create_cron, get_cron, list_crons, delete_cron), an agent that connected earlier gets capability_not_granted until it asks for it once. The grant is immediate; nobody has to approve it.

• From the MCP bridge, the agent calls request_capability with its agent_id and the new capability names. The bridge tells agents to do this on capability_not_granted.
• From code, call client.requestCapability({ agentId, capabilities: ["create_cron", "get_cron", "list_crons", "delete_cron"] }).

The project, its tasks and its keys stay the same; there is no need to connect again.

The same goes for the inbox tools, read_inbox and ack_inbox. Clients of the hosted /mcp server get new tools without asking.

Next

• Capabilities: every argument, result and error.
• Delivery & signatures: what the destination receives, how to verify it, and when RunLater retries.