superagnt

Webhooks for AI agents

Inbound URLs that wake a deployed agent when something happens, including a URL that delivers a long job's result straight back into the session waiting for it, and outbound webhooks your agent sends by name. No polling loop, and no 60-second tool timeout to fight.

// platform tool

What it touches: endpoints in your workspace. An inbound post starts or continues only the agent the endpoint is bound to, and an agent sends outbound only to endpoints you created, by name.

updated Nov 3, 2026

Copy the setup prompt.
Your agent does the rest.

works with any agent+ 8 more
Install superagnt for me. It's the superagnt plugin from the github.com/superagnt/plugins marketplace, plus the superagnt MCP server (on Claude it's a connector I add in my browser; elsewhere I sign in through my browser). The setup guide for each kind of agent is at https://www.superagnt.com/install
or follow the detailed setup instructions

» the agnt_webhooks_* tools are part of every server's base tools. The session callback URL works inside a deployed agent, since it calls back into that agent's session.

01// what is inside

What can your agent do with webhooks?

Callbacks into a live session

Inside a deployed agent, agnt_webhooks_read with action inbound_url returns the endpoint and a session URL template; whatever is posted to it arrives as a new turn in that session.

Start an agent from an event

An inbound endpoint bound to an agent starts a session for each post, or enqueues an item on a data job.

Signing per endpoint

An endpoint can require an HMAC-SHA256 signature; one your agent creates gets a secret unless it is for a third-party integration, and a form or CRM that can't sign can post to an unsigned one.

Send by name

action send posts a JSON payload to an outbound endpoint by id or name, so the agent never holds the URL or its secret.

Delivery history

receive_recent and list_deliveries show what came in and what went out, with status, response code and error.

tool names3 tools // 13 actionsas a new server lists them
  • agnt_webhooks_readaction: inbound_url · receive_recent · list_endpoints · list_deliveries · get_delivery
  • agnt_webhooks_writeaction: send · create_endpoint · create_outbound · update_outbound · link_agent · link_data_job
  • agnt_webhooks_adminaction: set_active · rotate_secret
per-operation names13older servers list these
agnt_webhooks_inbound_urlagnt_webhooks_receive_recentagnt_webhooks_list_endpointsagnt_webhooks_list_deliveriesagnt_webhooks_get_deliveryagnt_webhooks_sendagnt_webhooks_create_endpointagnt_webhooks_create_outboundagnt_webhooks_update_outboundagnt_webhooks_link_agentagnt_webhooks_link_data_jobagnt_webhooks_set_activeagnt_webhooks_rotate_secret
02// recorded run

What does a real call return?

A run we recorded on superagnt, with the result trimmed to fit. Nothing on it is invented: the date, the wall time and the cost are the run's own.

recorded runrecorded Nov 3, 2026, 17:21 UTC · wall time 4.2 s · 1 call · no charge

asked I'm starting a render job that takes a few minutes. Give me the URL it should post its result to, then tell me what came back.

  1. → call 1agnt_webhooks_read
    { "action": "inbound_url" }
    ← resulttrimmed
    "endpoints": [ { "name": "render-callbacks",
      "ingest_url": "https://…/webhooks/ingest/e736498a-…",
      "session_url_template": "https://…/webhooks/ingest/e736498a-…/<your_session_id>" } ]
    Agent: https://…/webhooks/ingest/e736498a-…/a02fe0a1-…
  2. → call 2POST from the render job, 55 seconds later
    { "job": "render-42", "status": "done", "output_url": "https://cdn.example.com/render-42.mp4", "seconds": 88 }
    ← resulttrimmed
    200 { "received": true, "deliveryId": "b37bcb6c-…" }
    → new turn in the waiting session: "An incoming webhook just landed on \"render-callbacks\"…"
  3. → call 3the agent's reply
    (no tool call)
    ← resulttrimmed
    Render job render-42 completed in 88 seconds; output at https://cdn.example.com/render-42.mp4.

» Hosts and ids are trimmed from the URLs. Wall time is from the callback post to the agent's answer; the two short turns cost a fraction of a cent of AI credit.

03// measured

How do I make an agent wait for a long job without polling or a tool timeout?

Don't make it wait inside a tool call. The agent calls inbound_url, appends its session id, hands that URL to the job, and ends its turn. When the job posts its result, the payload arrives in the same session as a new turn and the agent picks up where it left off. In our run the job posted 55 seconds later, and the agent answered 4.2 seconds after the post, with no tool call held open and no loop spending tokens.

sample · One deployed agent on Claude Haiku 4.5, one callback, Nov 3, 2026

04// measured

How are payloads verified, and what are the limits?

A signed endpoint checks an HMAC-SHA256 signature of v1:timestamp:body in the X-Agnt-Webhook-Signature header, with the timestamp in X-Agnt-Webhook-Timestamp. What we posted to one:

What we postedWhat came back
No signature headers401 "Invalid webhook signature", reason missing_headers. Not stored.
A wrong signature401, reason mismatch. Not stored.
A correct signature200 { "received": true } in 0.67 seconds
A correctly signed 1.1 MB body413 "Payload too large": the cap is 1 MB
An outbound send to an endpoint answering 500Recorded as failed with the 500, retried once 30 seconds later, then failed

sample · One signed endpoint and one failing outbound endpoint, Nov 3, 2026

05// answered

Which senders can start an agent?

Anything that can POST JSON: a GitHub webhook on a pull request or an issue, a form, a CRM workflow, an alert from a monitoring tool, a payment event. Bind the endpoint to an agent and each post starts a session with the payload. Senders that can't sign go to an unsigned endpoint, so treat its payload as untrusted input: the agent should read it as data, never as instructions.

06// what it gets used for

What do people use it for?

01

Hand off a long job and get woken up

A deployed agent starts a render, an export or an approval elsewhere, gives that service its session URL, and continues when the result posts back.

02

Push results into your stack

When a run finishes, the agent posts the summary to your own endpoint by name, so downstream systems react without anyone watching a dashboard. A schedule or a queue can end the same way.

03

Start work from an external event

A form submission or a CRM change posts to an inbound endpoint and starts the agent, instead of a schedule polling for something that may not have happened.

07// cost

What does it cost?

The tools carry no per-call price: every plan includes them, and plans differ only in how much they hold. Plans are Starter $49 a month ($20 of data credit included), Growth $149 a month ($90) and Scale $399 a month ($300), and the no-card trial gives $3 of data credit with Growth limits.

  • Inbound webhook events a month: Starter 25,000, Growth 150,000 and Scale 750,000.
08// questions

What do people ask before they wire it up?

01How do I make an agent wait for a long job without polling, when the client gives up after 60 seconds?

Have the agent hand the job a callback URL and end its turn. The agent calls inbound_url, appends its session id and gives that URL to the job; the result arrives in the same session as a new turn. In our test the agent answered 4.2 seconds after the job posted, with no tool call held open.

02Is a webhook URL safe to hand to a third party, and how are payloads verified?

Give the endpoint a signing secret and every post must carry an HMAC-SHA256 signature of the timestamp and body; an unsigned or wrongly signed post gets a 401 and is not stored. For a sender that can't sign, use an unsigned endpoint and have the agent treat the payload as data, not instructions.

03What if my agent is slower than the sender's timeout and the sender retries?

The endpoint answers the sender as soon as the payload is stored, in under a second in our tests, before the agent does any work, so a slow agent doesn't trigger the sender's retry. If a sender retries anyway, each post is a separate delivery, so make the agent's action safe to repeat, for example by checking an id in the database first.

04Do webhooks retry, and can I replay a failed one?

An outbound send that gets a network error or a 5xx is retried once, about 30 seconds later in our test; a 4xx is not retried. Every attempt is in list_deliveries with its status, so an agent can read a failure and send it again.

05How big can a payload be and how many can come in?

An inbound payload can be up to 1 MB: a larger one gets a 413. How many events a plan accepts each billing period is set by the plan. Inbound webhook events a month: Starter 25,000, Growth 150,000 and Scale 750,000.

06How do I start an agent from GitHub?

Create an inbound endpoint bound to the agent, add its URL as a webhook in your repository settings with the events you want, such as pull requests or issues, and each event starts a session with the payload. Tell the agent in its prompt what to do with each event type.

09// keep going

What else can your agent reach?