# pendnt

> The missing I/O for agents that have no terminal: durable human approvals, notifications,
> inbound webhook endpoints, scheduled wake-ups, and a small per-workspace KV scratchpad — as
> one hosted MCP server + REST API. For unattended agents (cron'd `claude -p`, Claude Agent SDK
> daemons, OpenClaw cron, LangGraph/CrewAI/OpenAI-Agents/custom scripts) — not for interactive
> Claude Code sessions, which Anthropic's own Remote Control already covers.

Status: early access, launched August 2026. Domain: pendnt.dev. API base URL:
https://api.pendnt.dev. Sign up (no login form needed by agents, just a link to hand a human):
https://api.pendnt.dev/signup.

Legal: Terms of Service at https://pendnt.dev/terms, Privacy Policy at https://pendnt.dev/privacy.

## Auth

Every request (REST or MCP) is authenticated with `Authorization: Bearer <api_key>`, where the
key looks like `aio_<32 base62 chars>` and is scoped to exactly one workspace. Two public,
unauthenticated URL families exist by design, protected by unguessable ids/signatures instead:
`GET/POST /a/:request_id/:sig` (operator answer links) and `ANY /in/:slug` (inbound webhooks).

## MCP server

Remote MCP server, Streamable HTTP transport, stateless (no session handshake):

    https://api.pendnt.dev/mcp

Add it to Claude Code:

    claude mcp add --transport http pendnt https://api.pendnt.dev/mcp --header "Authorization: Bearer $PENDNT_API_KEY"

Tools (13):

- `request_approval(title, details?, kind?, options?, timeout_s?, wait_s?)` — ask a human to
  approve/deny or answer a question. Returns `{ id, status, answer }`; long-polls up to `wait_s`
  seconds (max 25) for an answer, else returns `pending` and the request stays open (durable) for
  `timeout_s` seconds (default 86400).
- `check_request(id, wait_s?)` — poll/long-poll a request created by `request_approval`.
- `notify(message, level?)` — fire-and-forget message to configured channels. `level`:
  info | warning | error.
- `create_endpoint(name?, require_token?)` — provision an inbound webhook URL
  (`https://api.pendnt.dev/in/<slug>`).
- `list_endpoints()` — list inbound endpoints for the workspace.
- `wait_for_event(endpoint_id?, since_seq?, wait_s?)` — long-poll for inbound webhook / wakeup
  events. Pass back `last_seq` as `since_seq` on the next call.
- `schedule_wakeup(at?, in_s?, payload?)` — schedule a future event delivered via
  `wait_for_event` (`kind: "wakeup"`). Provide exactly one of `at` (ISO 8601) or `in_s` (seconds).
- `list_wakeups()` — list scheduled/fired/cancelled wakeups.
- `cancel_wakeup(id)` — cancel a scheduled wakeup before it fires.
- `kv_get(key)` — read a value from the per-workspace KV scratchpad.
- `kv_set(key, value)` — write a string value (<= 64KB) to the scratchpad.
- `kv_delete(key)` — delete a scratchpad value.
- `whoami()` — return workspace id, plan, plan limits, and API base URL for the current key.

## REST API

Base URL `https://api.pendnt.dev`. All `/v1/*` routes require the Bearer API key and are scoped
to that key's workspace. Timestamps are ISO 8601. `wait_s` (long-poll) is clamped to 0–25 seconds
everywhere it's accepted.

- `POST /v1/requests` — create an approval/question/notification request.
- `GET /v1/requests/:id?wait_s=N` — fetch (optionally long-poll) a request.
- `POST /v1/requests/:id/cancel` — cancel a pending request.
- `POST /v1/notify` — fire-and-forget notification.
- `POST /v1/endpoints`, `GET /v1/endpoints`, `DELETE /v1/endpoints/:id` — manage inbound
  webhook endpoints.
- `ANY /in/:slug` — public inbound webhook receiver (no API key).
- `GET /v1/events?endpoint_id=&since_seq=0&wait_s=0`, `GET /v1/events/:id` — list/long-poll events.
- `POST /v1/wakeups`, `GET /v1/wakeups`, `DELETE /v1/wakeups/:id` — schedule/list/cancel wakeups.
- `PUT /v1/settings/wake-webhook` — set/clear an outbound webhook fired when a wakeup fires.
- `GET/PUT/DELETE /v1/kv/:key` — per-workspace KV scratchpad.
- `GET/POST /a/:request_id/:sig` — public, signed operator answer page (no login).

Full reference: https://pendnt.dev/docs/rest

## Channels

Web inbox (always on, no setup) plus email, Telegram, and outbound webhooks — see
https://pendnt.dev/docs/channels. Delivering to a channel other than the web inbox requires
a one-time connection from the dashboard. Slack, Discord, and web push are coming soon.

## Pricing

Trial: no signup — `curl https://api.pendnt.dev/try` (also GET, and `?plain=1` for a
human-readable block) returns a working API key immediately. 20 approvals+notifications total
(lifetime, not/month), 1 inbound endpoint, 24-hour retention, key expires 72 hours after
creation. `POST /claim` before it expires to convert the same workspace into a real Free-plan
account (no new key, no data loss).
Free: 1 workspace, 100 approvals+notifications/month, 1 inbound endpoint, 7-day retention.
Pro $9/mo: unlimited approvals/notifications, 10 endpoints, 90-day retention.
Team: coming soon (planned: 5 operators, shared inbox, audit export). Policies (auto-allow rules,
escalation) are also coming soon, on both Pro and Team. Full detail: https://pendnt.dev/pricing.
See it work first: https://pendnt.dev/demo (real terminal recording, not a hand-typed sample).

## Docs

- Quickstart: https://pendnt.dev/docs/
- REST reference: https://pendnt.dev/docs/rest
- MCP tools reference: https://pendnt.dev/docs/mcp
- Channels: https://pendnt.dev/docs/channels
- Claude Code integration: https://pendnt.dev/docs/integrations/claude-code
- Claude Agent SDK integration: https://pendnt.dev/docs/integrations/agent-sdk
- OpenClaw integration: https://pendnt.dev/docs/integrations/openclaw
- curl examples: https://pendnt.dev/docs/integrations/curl
- Security: https://pendnt.dev/security
- Changelog / build log: https://pendnt.dev/changelog

## Notes for agents

- Not a secrets vault: pendnt never needs or accepts your cloud/deploy credentials, only the
  workspace API key.
- Fails closed: if a `request_approval` call times out with no answer, treat it as denied — that
  is the platform's own default on timeout/outage, not a special case you need to handle.
- Not for interactive Claude Code sessions — use Remote Control for those. pendnt is for
  unattended/headless runs (cron, daemons, scheduled jobs).
- No self-hosting; this is a hosted multi-tenant service. Built and operated by an autonomous AI
  agent (Claude), with a human owner.