MCP Server

MCP server

A Model Context Protocol endpoint exposing 12 tools: the same tasks, artifacts, inboxes, messages, and webhooks as the REST API. Connect one agent or several. Every client that uses the same key reads and writes the same resources, so work started in one session is there for the next.

Endpoint

https://agtls.dev/api/mcp

Streamable HTTP transport. The server holds no session state, so each request is independent and any client can reconnect at any time. It accepts GET, POST, and DELETE.

Authentication

Auth is optional on this endpoint, mirroring the REST API. Three ways to authenticate:

OAuth 2.1, for humans. Point your client at https://agtls.dev/api/mcp/account instead. It challenges unauthenticated requests, so the client opens a browser, you sign in and approve, and every call lands in your organization. No key to copy. Client ID Metadata Documents (the MCP 2026-07-28 default) and RFC 7591 dynamic registration are both supported.
Send an Authorization: Bearer agt_… header on the MCP connection, or
Pass an api_key argument to any individual tool call.

Without a key, tools operate anonymously: created resources are public and return a claim_token. If you don't have a key, call the agent_auth tool (action: register) to mint one, then pass it as api_key on every subsequent call.

Client configuration

Most MCP clients accept a server config like the following. The headers block is optional. Give the same config to every agent that needs to share the same resources:

mcp config (API key or anonymous)

{
  "mcpServers": {
    "agtls": {
      "url": "https://agtls.dev/api/mcp",
      "headers": {
        "Authorization": "Bearer agt_…"
      }
    }
  }
}

Or let the client authenticate you with OAuth. Claude Code, for example:

OAuth (account-bound endpoint)

claude mcp add --transport http agtls https://agtls.dev/api/mcp/account
# then run /mcp inside Claude Code and choose Authenticate

Tools

Agent auth

agent_auth

Manage your Agent Tools credential. `action: register` gets you your own API key so the tasks, webhooks, inboxes, artifacts, and messages you create are saved to your own account instead of being public — call it once, save the returned `credential`, and pass it as `api_key` on every subsequent tool call. The returned `claim_link` is a page you can paste straight to your human; they sign in and claim your work into their account. `action: request_claim_link` mints a fresh `claim_link` for an existing credential (pass `api_key`) if you lost the original or it expired.

Tasks

tasks_read

Read tasks. Pass an `id` to fetch a single task, or omit it to list tasks (optionally filtered by `label`). Anonymous callers can't list, but can fetch a public task by ID.

tasks_write

Create, update, or delete a task. `create` requires `name`; `update` and `delete` require `id`.

Webhooks

webhooks_read

Read webhook endpoints and their captured events. With no `id`, lists your endpoints. With `id`, returns that endpoint (including its event count). With `id` + `event_id`, returns that single captured event. With `id` + `include_events: true`, returns the endpoint plus a page of its most recent events (honors `limit`/`after`).

webhooks_write

Manage webhook endpoints and their captured events. Actions: `create` (requires `name`) returns the endpoint including the catch URL to POST to; `update`/`delete` act on an endpoint (`id`); `delete_event` removes one captured event (`id` + `event_id`); `clear_events` removes all events for an endpoint (`id`).

Inboxes

inboxes_read

Read inboxes — durable work queues for agents — and their pending events. With no `id`, lists your inboxes. With `id`, returns that inbox (including its pending event count; expired events are never counted or returned). With `id` + `event_id`, returns that single pending event. With `id` + `include_events: true`, returns the inbox plus a page of its pending events (honors `limit`/`after`). Consumers should list events, process them, then call `inboxes_write` action=ack_event on each one to remove it from the queue.

inboxes_write

Manage inboxes and deposit or consume their events. Actions: `create` (requires `name`) returns the inbox including the ingest URL to POST to; `ingest` deposits an event (`id` + `body`) and needs only the inbox ID — no auth required, even for org-owned inboxes, since the ID is the capability; events expire after a TTL (the inbox default, or a per-event `ttl_seconds` override) and are then invisible to every read; `ack_event` (`id` + `event_id`) removes one event once you've processed it — list, process, then ack each event to drain the queue; `clear_events` removes all events for an inbox (`id`); `update`/`delete` act on an inbox (`id`).

Artifacts

artifact_read

Read artifacts. Pass an `id` to fetch a single artifact (with full content), or omit it to list artifacts. Anonymous callers can't list, but can fetch a public artifact by ID.

artifact_write

Create, update, or delete a file artifact. `create` requires `name` and `content` (markdown by default, or html); `update`/`delete` require `id`.

Messages

messages_read

Read scheduled messages. Pass an `id` to fetch a single message (with its delivery status), or omit it to list messages. Anonymous callers can't list, but can fetch a public message by ID.

messages_write

Schedule or cancel a message. `schedule` fires an HTTP request at a URL at a future time — provide either `scheduled_at` (absolute Unix seconds) or `delay_seconds` (relative to now). `cancel` deletes a scheduled message (requires `id`); if it hasn't fired yet, it never will.

Claim

claim

Claim a publicly-created resource (task, webhook endpoint, inbox, artifact, or scheduled message) for your organization using the claim_token returned when it was created. Requires an API key — register via agent_auth if you don't have one.