Introducing Restless: Documentation for the Agentic Era

ReadMe has spent a decade making it easier for developers to understand APIs. Today, we're launching something that goes further, because understanding isn't enough anymore.

For ten years, ReadMe has been the place API companies send their developers. You publish your docs. Developers read them, write some code, and integrate. That model worked.

It's still working. But it no longer tells the whole story.

Over 65% of traffic hitting API documentation today doesn't come from a developer sitting at a laptop. It comes from an AI agent. Claude, Cursor, a custom workflow, an autonomous service. Something that doesn't read, doesn't interpret, and doesn't open a support ticket when it hits a wall. It just fails. Silently. And moves on.

ReadMe was built for a world where a human was always in the loop. That world is changing fast. So are we.

Today we're launching Restless.

From DevDash to something bigger

If you've been a ReadMe customer, you know DevDash. We built it because the docs page alone wasn't enough. You needed to see who was actually hitting your endpoints, where they were getting stuck, and what broke. It gave you a window into your API that the docs couldn't.

Restless is the next step. It moves from observation to action. Not "here's who hit this endpoint," but "here's what happened, here's why it failed, and here's what we did about it before the caller gave up."

This isn't just a new product. It's a different position in the stack.

The shift no one prepared for

The documentation playbook hasn't changed much in a decade. Write clear endpoint descriptions. Add code samples. Build a playground. Keep it updated.

That playbook assumed a human was reading. The human would hit friction, re-read the docs, try a different parameter, and eventually figure it out. The docs were a safety net.

Agents don't use safety nets. They parse an error response, evaluate whether it's worth retrying, and make a decision in milliseconds. If the error is a bare 500 with no context, they move on. If they move on, so does your customer.

This is not a future problem. A developer churns after two weeks. You check the logs. Three errors on day four. No one reached out. Your docs didn't cover the edge case. An agent hit a 500, got no useful context, and switched to a different provider. You never knew.

The channel growing fastest in your API traffic is the one you have the least visibility into and the least ability to help.

What Restless does

Restless sits in the request path. Not in your docs, not in a dashboard you check on Fridays. In the layer where your API actually gets used.

One line of code on top of your existing routes. That's the setup.

Here's what happens after:

Full visibility into every caller. Developers, agents, internal services, automated workflows. You see who's hitting your API, which integrations are healthy, and which ones are quietly dying. Not the sanitized version. The real picture.

Enriched errors at the moment they happen. When a caller hits an error, Restless intercepts it and returns context: what went wrong, why it failed, and what to try instead. Real time. The caller doesn't have to file a ticket or read a troubleshooting guide. They get what they need to keep going.

Machine-readable by default. Agents don't read documentation. They consume structured context at the protocol level. Restless formats error responses to be useful to machines, not just humans. An agent that gets a useful error response retries with better parameters. An agent that gets a raw 500 leaves.

A self-healing feedback loop. Every failed interaction becomes institutional knowledge. Restless surfaces the failure, diagnoses it with context, and propagates the fix back into your docs and endpoint metadata so the same failure doesn't happen twice. Your API gets smarter with every interaction, without anyone manually triaging support tickets.

This is what makes agentic API consumption different from everything before it. A human developer can read between the lines of an ambiguous error. An agent cannot. One documentation gap, multiplied across every agent that hits it, becomes a retention crisis you can't see coming. Restless turns that multiplier around. Every agent interaction stress-tests your API surface. The fixes compound. The API gets progressively easier to integrate with, automatically.

Documentation isn't a website anymore

When ReadMe launched, documentation was a website. You built it, you maintained it, developers went to read it. We made that experience better.

Restless is what documentation becomes when your fastest-growing audience never visits a website. It's embedded in your API responses. It's alive in the request path. It learns from every interaction and improves without human intervention.

The teams who will win the next wave of API adoption aren't the ones with the most comprehensive docs site. They're the ones whose APIs self-correct at the moment of failure and give every caller, human or machine, exactly what they need to keep going.

You're in control of what Restless returns. You can tune the enrichment logic, define recovery paths, and review every interaction. This isn't a black box. It's your API, running smarter.

Get started in minutes

npx api init

That's it. No docs pipeline to rebuild. No site to redesign. No separate infrastructure to maintain. Restless works alongside your existing ReadMe setup. If you've already got DevDash, Restless is the next layer.

We're giving the first cohort of teams 60 days free to see what Restless surfaces. The teams we've worked with so far have seen things they didn't know to look for: agent traffic they had no visibility into, error patterns repeating silently across integrations, and support tickets that should never have existed.

The API is the product now

There was a time when the documentation was the interface between your API and the developer. That's still true for a lot of your users. But it's no longer the only interface, and it's no longer the dominant one.

ReadMe started as a better way to publish docs. Restless is what comes after docs. It's your API fighting for every customer at the exact moment something goes wrong.

The question isn't whether agentic API consumption is coming. It's here. The question is whether your API is ready for it.

Get started free or book 30 minutes to get a walkthrough.