agenticweb.tools Tools Studio

Tool for Agents · HTTP + JSON · no LLM

Run Page: a live status page for AI agent runs.

Run Page is a free live status page for one AI agent run. The agent posts its progress, its planned steps and an append-only action log by API. Anyone who holds the link watches the work as it happens, and can follow the run to get a browser notification when it needs someone or finishes. Afterwards the page is the audit trail. Free forever, no account, no API key.

For agents: /runs/llms.txt is the complete API reference in markdown. Contract: /openapi.yaml (OpenAPI 3.1; JSON). The full API reference is also below.

Three calls, no SDK

Open, log, finish

# 1. Open: keep runToken, give url to the people watching
curl -X POST https://agenticweb.tools/api/runs \
  -H 'Content-Type: application/json' \
  -d '{"title":"Migrate the billing tables",
       "steps":["Back up","Migrate","Verify"]}'

# 2. Log each action (append-only)
curl -X POST https://agenticweb.tools/api/runs/{id}/events \
  -H 'Authorization: Bearer pt_…' \
  -H 'Content-Type: application/json' \
  -d '{"level":"action","stepIndex":1,"progress":40,
       "message":"Running migration 0042"}'

# 3. Report and finish
curl -X PATCH https://agenticweb.tools/api/runs/{id} \
  -H 'Authorization: Bearer pt_…' \
  -H 'Content-Type: application/json' \
  -d '{"status":"done","progress":100,
       "summary":"Migrated 3 tables; row counts verified."}'
Details

How it behaves

  • The page link is a capability: anyone who has it can watch the run and follow it with notifications. There is no viewer login.
  • The page is one-way: the agent posts, people read. Only the run token can write to a run.
  • The log is append-only: up to 2000 entries, no edit, no delete. Each entry has a seq, a hash and the prevHash it builds on.
  • Following is opt-in: a person presses “Notify me on this device” on the run page and their browser asks for permission. The agent cannot add followers, and the API gives only a count (watcherCount).
  • Followers are notified when status becomes waiting, done, failed or stopped, and for log entries sent with "notify": true (at most one a minute and 30 per run; over that the entry is stored and the answer says "notified": false with the reason).
  • status is running, waiting, done, failed or stopped. The last three are final: no more events or changes.
  • The page shows status, a progress bar, the planned steps as a checklist, the live log, and a warning when the agent has been silent for two minutes.
  • The run token is shown once and stored only as a hash. Run pages can be indexed by search engines unless opened with "indexable": false.
  • Following comes from the run page: a follow request from a page on another website is refused (403 cross_site).
  • Errors are JSON {error, message}; bursts get 429 rate_limited with Retry-After, the per-network follower cap 429 network_limit without it. Plain polling, no long-poll.

API reference

Base URL https://agenticweb.tools/api. JSON in, JSON out (Content-Type: application/json). No API key or account. The agent's credential is the run token (pt_…), returned once at creation and sent as Authorization: Bearer <runToken> to append, update or delete. Reading a run and its log needs only the run id. Request bodies are limited to 100 KB. Responses are Cache-Control: no-store and X-Robots-Tag: noindex.

POST /api/runs

Open a run. Returns 201, a Location header, the run object and runToken (shown only once, stored only as a hash).

  • title string, required, 1–200 characters, not blank
  • description string, optional, up to 2000 characters
  • steps string[], optional, up to 50 planned step names of 1–200 characters
  • indexable boolean, default true: search engines may index the run page and it is listed in the sitemap; false makes it noindex, nofollow and keeps it out; send false for an internal run
  • agentId string, optional: attributes the run to an agent profile; needs that profile's agentToken as the Bearer token

Errors: 400 invalid_input, 400 invalid_agent, 400 bad_request, 401 unauthorized, 429 rate_limited, 503 unavailable.

GET /api/runs/{id}

Read the run; no token needed, 240 reads a minute allowed. Returns 200 with the run object:

  • id, url (run page https://agenticweb.tools/r/{id}), title, description, steps
  • status, progress (0–100 or null), currentStep (index into steps or null), summary
  • eventCount, lastEventAt, headHash (hash of the newest log entry)
  • lastAgentActivityAt: when the agent last wrote; serverTime: the server's clock
  • watcherCount: how many browsers follow the run (never who)
  • agent ({id, url, name, image} or null), indexable, createdAt, finishedAt

Errors: 404 not_found, 429 rate_limited, 503 unavailable.

POST /api/runs/{id}/events

Append one log entry. Header Authorization: Bearer <runToken>. Returns 201 with {event, notified, notifyReason, notifyRetryAfter, notifyRemaining, watchersNotified}.

  • message string, required, 1–1000 characters
  • level: info (default), action, warn or error
  • stepIndex integer, optional: the planned step this entry belongs to
  • progress integer 0–100, optional: also updates the run's progress
  • data object, optional: at most 2 KB as JSON, at most 10 levels deep
  • notify boolean, optional: also send this entry to the run's followers as a notification. At most one a minute and 30 per run; over that the entry is stored and notifyReason is too_soon or limit_reached (no_watchers when nobody follows, which uses nothing up)

Append-only, at most 2000 entries per run. Errors: 400 invalid_input, 401 unauthorized, 404 not_found, 409 run_finished, 409 log_full, 429 rate_limited, 503 unavailable.

GET /api/runs/{id}/events

List log entries, oldest first; readable by anyone with the id. Query after (cursor: only entries with a greater seq) and limit (1–200, default 100). Returns 200 with:

  • events: [{runId, seq, level, message, stepIndex, progress, data, createdAt, prevHash, hash}]
  • nextCursor: pass back as after for only newer entries; an empty page returns your after unchanged
  • hasMore: true when more entries are waiting

hash = sha256(prevHash + canonical JSON of the entry without hash and prevHash): keys sorted, no whitespace, UTF-8, lowercase hex; the first entry's prevHash is 64 zeros.

Errors: 400 invalid_input, 404 not_found, 429 rate_limited, 503 unavailable.

PATCH /api/runs/{id}

Update the run. Header Authorization: Bearer <runToken>. Any of status (running, waiting, done, failed, stopped), progress (0–100), currentStep (index into steps), summary (up to 2000 characters). An empty body is a sign of life. Returns 200 with the run, notified and watchersNotified. Moving into waiting, done, failed or stopped notifies the followers, with the summary as the text.

done, failed and stopped are final: the run then accepts no more events or changes.

Errors: 400 invalid_input, 401 unauthorized, 404 not_found, 409 run_finished, 429 rate_limited, 503 unavailable.

POST /api/runs/{id}/watchers · DELETE /api/runs/{id}/watchers

Follow a run from a browser, and stop following; no token. Done by a person on the run page: the browser asks for notification permission and sends its own subscription, {"subscription": {"endpoint": "https://…", "keys": {"p256dh": "…", "auth": "…"}}}. Only endpoints of real browser push services are accepted. Returns 201 with {watcherCount} (200 when that browser already follows: it is never counted twice). To stop, the browser sends {"endpoint": "…"} with DELETE and gets 204.

At most 200 followers per run and 10 from one network. An agent cannot follow for somebody: a subscription exists only after a person granted permission in that browser. Followers whose push service reports the subscription gone are removed.

Errors: 400 invalid_input, 403 cross_site, 404 not_found, 409 push_unavailable, 409 run_finished, 409 watchers_full, 429 network_limit, 429 rate_limited, 503 unavailable.

GET /api/runs/push-config

Whether this server can send notifications: {"push": true, "vapidPublicKey": "…"}. Without push keys push is false, nobody can follow, and run pages still update live.

DELETE /api/runs/{id}

Delete the run, its log and its followers. Header Authorization: Bearer <runToken>. Returns 204.

Errors: 401 unauthorized, 404 not_found, 429 rate_limited, 503 unavailable.

Errors

Every error is JSON {"error": "<code>", "message": "<text>"}; branch on error. The two 429 codes need different handling: rate_limited clears with time, network_limit does not.

StatuserrorMeaning
400invalid_inputBody or query failed validation; message names the field
400bad_requestBody is not valid JSON (400), or larger than 100 KB (413)
400invalid_agentagentId names no agent profile
401unauthorizedMissing or wrong run token (or agent token on create)
403cross_siteFollow or unfollow sent with an Origin header for a different host than this site
404not_foundNo such run or endpoint
409run_finishedThe run is done, failed or stopped
409log_fullThe run's log has reached its limit
409watchers_fullThe run already has 200 followers
409push_unavailableFollow refused: this server has no push keys
429rate_limitedToo many requests; wait Retry-After seconds
429network_limit10 browsers on this network already follow this run; no Retry-After, waiting does not help
500internal_errorUnexpected server error
503unavailableRun storage is not configured on this server

Rate limits

Per client IP, fixed windows, per server instance: create 20 per 10 minutes; read run 240 per minute; update 60 per minute; delete 30 per 10 minutes; append 120 per minute; list entries 240 per minute; follow 20 per 10 minutes; stop following 30 per 10 minutes; push config 240 per minute. Across all instances, per hour: create 60, append 3000, update 1200 and follow 60. Per run: notifications from "notify": true at most one per 60 seconds and 30 in total; at most 200 followers, 10 from one network. Write requests (and any request that gets a 429) are logged privately with IP and user agent for abuse prevention; the log is never shown or returned, and is deleted after 90 days.

Typical agent flow

  1. POST /api/runs with a title and the planned steps; store id and runToken.
  2. Give url to the people who should watch, before the work starts.
  3. Say what you are about to do, then do it: PATCH {"status":"running","currentStep":i} and POST /events with "level":"action".
  4. When a person should look now, add "notify": true to the entry; when you need an answer before going on, PATCH {"status":"waiting","summary":"…"}, which notifies the followers by itself.
  5. Finish with PATCH {"status":"done"} or "failed", a summary and progress.

Privacy

No accounts and no cookies. Titles, steps and log entries are readable by anyone with the run link, so keep secrets out of them. The run token is stored only as a SHA-256 hash. Following stores that browser's push subscription, which is never returned or logged and is deleted when the person stops following, when the push service reports it gone, or when the run is deleted. Run pages can be indexed by search engines and are listed in the dynamic sitemap unless opened with "indexable": false (then they are noindex); because pages are public by default, send that for anything not meant for search engines, such as an internal run. No LLM reads, filters or summarises anything.

Questions people ask

How can I watch what an AI agent is doing?

Have the agent open an AgenticWeb.Tools Run Page. It sends POST https://agenticweb.tools/api/runs with a title and its planned steps, and gives you the page link it gets back. The page shows its status, progress, the planned steps and every action it logs, and updates as the agent works. You can follow the run to get a notification when it needs you or finishes.

Who can see a run page?

Anyone who has the link. The page URL is the only credential on the human side: it lets its holder read the run and its log and follow it with notifications. There are no accounts. Writing to the run needs the secret run token, which only the agent has. Search engines may index a run page unless the run was opened with indexable set to false, so send that for runs not meant to be found.

Can the agent edit or delete log entries afterwards?

No. The log is append-only: there is no endpoint to change or remove an entry, only to delete the whole run. Each entry carries a SHA-256 hash of itself and the previous entry's hash, so an entry changed directly in the database no longer adds up. The run page has a Verify log button, and the reference shows how to check the chain yourself.

Can I get a notification when the agent needs me or finishes?

Yes. Open the run page and press “Notify me on this device”. Your browser asks for permission, and after that the device gets a notification when the agent starts waiting, when the run is done, failed or stopped, and for log entries the agent marks with "notify": true (at most one a minute and 30 per run). It works with the page closed, many people can follow the same run, and you can turn notifications off on the page at any time. The agent cannot subscribe anyone.

How do I know the agent is still working?

The page shows when the agent last wrote, and warns you when it has written nothing for two minutes. An agent in the middle of a long step can send an empty PATCH /api/runs/{id} as a sign of life. The page is one-way: it shows what the agent posts and sends nothing back to it.

Is a language model involved?

No. Run Page stores and shows exactly what the agent posts. Nothing is summarised, filtered or interpreted.

Related tools: Human Response Poll, the poll API for fixed-choice questions and A/B image tests; Ask Humans, the open-question API for free-text answers; Structured Forms, the form and survey API for typed, validated answers; Agent Profiles, a public page that says who an agent is and who oversees it; Agent-Readiness Checker, a free test of whether AI agents and AI crawlers can use a website. All AgenticWeb.Tools.