Your users ask Claude, ChatGPT or Microsoft Copilot to do real work through your MCP. Your analytics show the calls, not whether the job got done.
The first report is free. The price for the next five jobs is printed on it.
One result a user wants from your product, from start to finish.
For example: “Turn these meeting notes into three tasks with owners and due dates.”
A job is done when the result is in your product. Not when the agent says so.
You built your UI, your API and your MCP. Each one has a team, goals and a written user journey. The interface your user brings is different. It is a chat with their own AI agent, and nobody on your side owns it.
That agent takes a wrong turn. It hands the job back to the user. Or it reports a success that never happened. Agents don’t open support tickets, so none of this reaches your team.
Your user draws a simple conclusion: this product doesn’t work with my AI. Then they try the next one.
An MCP raises the bar. People expect it to just work. When it fails, they blame the product, not the agent.
We tested 15 products that say an AI agent can sign itself up. At 6 of them, it could.
19 sign-up paths · 177 agent runs · 3 model families
We pick the agents your users bring: Copilot, ChatGPT and Claude, or open-source models for developer tools. They take one of your key jobs with what your users’ agents get: your MCP, your API and your public docs.
We don’t ask the agent whether it worked. Every finished job leaves a trace in your product, so we look for the trace.
Where the job breaks, we write short directions for that exact step, or the change your MCP needs. You publish them on your own domain.
The same check runs again on every release, yours and the models’. A new model version can repeat old mistakes and add new ones.
Caches, harnesses and context servers live in each user’s agent setup. Every user has to install one, and most never will. Our fix lives on your domain, next to your product, so every agent gets it.
More context doesn’t solve this. Agents need directions at the step where they go wrong.
| Agent-side tools | Docka | |
|---|---|---|
| Where the fix lives | In each user’s agent setup | On your domain |
| Who has to act | Every user | Your team, once |
| Who gets through | Users who installed it | Every agent that arrives |
Every number below comes from recorded agent runs, graded against the product itself.
Every agent got a working key. Checking it was the weak step. One agent in 11 looked for a “who am I” endpoint and got a 404. Three used a public endpoint that works without any key, which proves nothing. We reported it. They shipped the endpoint and one sentence telling agents to use it.
Agents had to sign up and get a working API key. We added five lines of directions: where the agent entrance is, which call to make, how to check the key.
Same hosted MCP server, same job, same models. Copilot turned the model’s ready call into a question for the user, so the call never reached monday. We reported it on GitHub with a tested fix. monday shipped it five days later, and a second fix on October 7.
The same test before and after, run again on the vendor’s live release.
“Docka showed us that agents could get through signup and pointed out where they ran into trouble afterward. That’s feedback we can build on.”
We publish our measurements openly in a series called Can Agents Run It?
Every call they made in your product, where they turned the wrong way, what it cost, and whether the job really finished.
Short directions for the step that breaks, or the change your MCP needs. Yours to publish on your domain.
The same agents on the same job after the fix, so you can see it finish.
The first report covers one job, and it’s free. The price for the next five jobs is printed on the report. After the fix, we re-check the job on every release, yours and the models’.
One job that matters, and a way in: a free tier, a trial or a test account. We don’t install anything to run the check.
No. Every finished job leaves a trace in your product: a task on the board, a row in the database, a working key. We check that trace directly.
It depends on the case. For enterprise software, we test with what your users already have: Microsoft Copilot, ChatGPT and Claude. For developer tools, we add several open-source models. We’ve worked with 25+ models so far, so we can match the mix your users bring. Either way, the agents reach your product the way your users’ agents do: through your MCP, your API or your UI.
Then the report says so. You don’t pay for a fix you don’t need.
Not reliably. A new model version can repeat the old one’s mistakes and add its own. That’s why the check runs again after every model release.
You can. It takes a rig with several agents, a check on your product for every job, and a re-run after every release. Most teams never build one. We already run it.
Tell us about your product and one job. We’ll run it with the agents your users bring and send you the report.
Prefer to talk first? Book a call →
We’ll reply by email to agree on the job and a way in.
No reply? Write to eugene@docka.ai.