The full leaderboard.

Retried a dropped send three times, and it sent three emails. There's a seatbelt against this - but it's off unless you ask for it.

Wrote the same record three times on purpose, and it kept exactly one. Retrying just can't hurt you here.

Start a crawl without a limit and it heads straight for the 10,000-page default - 2,671 pages in 8 seconds, no prompt, no guardrail - so an agent that forgets the limit burns credits fast.

Fed it a bad parameter value, and the error came back listing every valid option by name. An agent can self-correct without ever opening the docs.

Pointed it at a link that served a web page instead of audio, and the error said exactly that - the remote server sent text, not sound. Every error names the real cause.

Ran code that crashed, and instead of a vague failure it came back with the error's exact name, message, and where it broke - everything an agent needs to fix its own code and retry.

When a page it fetched actually failed, Scrapfly tells you the truth — and every error it throws says exactly what to fix, so an agent can correct itself without opening the docs.

Get a request wrong and Exa practically tells you how to fix it — it lists the allowed values or explains why a combination isn't allowed, so an agent recovers on its own.

You can pull a clean, readable version of any web page without even signing up — and when the page is really a dead link, it tells you the truth instead of pretending it worked.

Ask for a sandbox, the response drops, you ask again — and now you're paying for two. Give the sandbox a name and the second try bounces off cleanly, but the quickstart never says to.

Modal makes a brand-new sandbox on every call, so if a request drops and you retry, two of them end up billing you. Naming the sandbox stops the double — the quickstart just never mentions it.

Send the same save twice after a dropped response and you still get one record, not two — Qdrant makes you label every item, so a repeat overwrites the first instead of piling up duplicates.

Save the same fact twice after a dropped response and Mem0 notices it already knew that, keeping one memory instead of a duplicate. Just know a save takes a few seconds to become searchable.

Save a fact, search a second later, and it's not there yet — Zep files everything in the background, so a save can take ten seconds to a minute to appear. Retrying it won't create a duplicate.

Call a tool you haven't connected and Arcade says 'authorization required' in plain, machine-readable terms instead of firing blind. Authorize twice and you get the same request back, not a duplicate.

Send a malformed request and Nango names the exact field that's wrong and why — 'invalid provider', 'expected a string at unique_key' — so an agent corrects itself without opening the docs.

Leave something out of a request and Pipedream names exactly what's missing, often with a link to the docs to fix it — so an agent self-corrects on the first bounce instead of guessing.

A fresh agent creates contacts and lists cleanly, but can't send a single email: the send API returns 'SMTP account not yet activated' until a human verifies a phone number.

Retry a create after a dropped response and Klaviyo returns 409 with the existing profile's id, so an agent updates that record instead of creating a second copy of the same person.

Send a broken upload and the error tells you the one thing to fix, so the agent corrects itself on the next try instead of flailing.

Forget one required field and all you get is 'An error has occurred' - the agent is left guessing, even though other mistakes get a clear answer.

Ask for weather with a mistyped city and it comes back 'No matching location found' with a clear code, so the agent fixes the name and moves on.

Leave out the address and it lists every field you could search by instead; ask for an impossible latitude and it says the limit is 90 - the agent always knows the fix.

Feed it an impossible coordinate and it flatly says the position is out of range, so the agent fixes it instead of getting a fake success.

Mistype a city and it says 'city not found'; drop the city entirely and it says 'nothing to geocode'; ask for latitude 999 and it says 'wrong latitude' - each mistake gets its own clear answer.

Hand it a broken email and it names the exact field and reason; and if a create gets retried, it can update the same record instead of quietly making a twin.

Send a malformed request and it names the exact field to fix; even hitting a switched-off feature comes back with a plain message and the link to turn it on.

Retry a webhook send with the same idempotency key and you get the same message back, not a second one - the thing most APIs quietly get wrong, this one gets right.

Publish the same message twice after a hiccup and it lands once, not twice - and when something is wrong the error gives you the exact number and a link to the fix.

Your app hiccups and retries the same charge, and Stripe recognizes it's a repeat and gives back the original instead of billing twice - the rare service that actually stops accidental double-charges.

Try to create the same project twice - a retry after a hiccup - and Vercel just says 'that one already exists' instead of quietly making a second copy, so a repeat can't fork you into two projects.

Retry after a hiccup and you get a duplicate issue - unless you stamped your own id on it first, in which case Linear catches the repeat. Safe retries work, but only if you set it up in advance.

Add the same record twice - a retry after a hiccup - and you get two identical rows, unless you use the special 'match on a field' mode, which turns the repeat into an update instead of a duplicate.

Try to create the same project twice - a retry after a hiccup - and GitLab refuses with 'that name's already taken' instead of making a second copy, so a repeat can't fork you into two repos.

Save the same value twice and it just overwrites - one entry, latest value - and trying to make a storage bucket whose name is taken is refused, not duplicated, so retries can't quietly pile up.

Try to create the same repo twice - a retry after a hiccup - and instead of a duplicate, it hands you back the link to the one already there, since the name has to be unique.

No door for an agent to even knock on.

No public API — agents can't get in.

Send the wrong version setting and Cal.com replies 'this address doesn't exist' instead of 'wrong version' - so an agent that trusts the error hunts for a page that was there all along.

Ask it to read a page that's actually broken and it hands back the error page as if everything worked — your agent can't tell, and passes the junk straight downstream.

Ask for too many results and You.com hands back nothing at all — your agent reads it as 'no matches found' when really it just asked for too much.

Call a tool that doesn't exist, or one you haven't connected, and Klavis returns is_error=False — an agent trusting that flag treats the failure as a success. The real error is only in the text.

The response dropped, the agent retried, and the same recording got transcribed and paid for twice. Nothing caught the repeat.

The response dropped, the agent retried, and the same video got encoded and paid for twice. Nothing caught the repeat.

A hiccup, a retry, and Rev AI transcribed and charged for the exact same recording twice, with nothing there to catch the duplicate.

Ask for the weather at a made-up spot on the map and it cheerfully returns a success with no data at all, so the agent thinks it worked when it didn't.

The response dropped, the agent retried, and it created a second identical contact - now there are two of the same person in the CRM, and nothing flagged it.

A dropped response makes the agent retry the same line of speech, and every retry gets voiced and billed all over again - there's no way to tell it 'you already made this one.'

If a job times out and your agent retries it, Apify runs the whole thing again and bills you twice — it never realizes it already did the work.

Retry a browser task that stalled and Browser Use runs the whole thing over, billing you for both — though you can at least cap what any one run is allowed to spend.

The docs promise a retry won't create a duplicate, but retry making an organization and you get two of them anyway - the safeguard just doesn't work.

Ask it to make the same form twice after a hiccup and you get two identical forms - nothing links the retry to the first, so duplicates just pile up.

Retry adding a task after a dropped response and you get two identical tasks - the X-Request-Id header shown in Todoist's own REST examples doesn't dedupe anything.

Tell it to send to an audience that doesn't exist and you get back '200 OK' with an empty id - an agent watching the status code thinks the push went out when it reached nobody.

Novu's docs say the Idempotency-Key header makes a retry count as one - but retry a notification trigger with the same key and it fires twice: two transaction ids, billed twice.

Create the same document twice after a hiccup and you get two - nothing dedupes a retry, so a dropped response leaves you with duplicate contracts to chase down.

Buy a shipping label, lose the response, retry - and you've bought and paid for two labels with two tracking numbers. Nothing stops a retry from double-charging you.

Upload the same video twice by accident - the first response gets lost so your app retries - and it's processed, stored and billed twice, with nothing built in to catch that it's a repeat.

The bulk lookup, when you forget your key, reports success at the top while hiding the real failure below - so an app that trusts the top-line result thinks it worked when it actually failed.

A dropped connection makes an agent resend a Slack message, and it posts twice - Slack has nothing built in to spot the repeat, so retries quietly double-post the same thing.