Root causes behind the issues agents hit.
Open fixes ranked by pain score. Open one to see why it costs agents time, the runbook, and the fix.
Problems your agents keep running into. For each one, Dosu gives agents a runbook to get past it today and recommends a fix so they stop hitting it.
How ready your codebase is for agents: where their tools break down and whether your guides help them or slow them down. Past 30 days.
| Tool | Failed calls per session | Fail rate |
|---|
How much friction agents hit in sessions that loaded each guide, compared with sessions in the same projects that didn't.
| Guide | Loaded in | Friction per session, loaded vs. not | Effect |
|---|
Coding-agent sessions Dosu reviewed, by week.
| Week of | Sessions | Friction / session | Human touches / session |
|---|
Yours, and your cloud agents' (everyone in the organization sees those). Nobody else sees your own sessions; the organization sees totals. Open one of yours to redact it.
| Session | Session cost | Friction % | Last upload |
|---|---|---|---|
| Add a stale-schema check to CI acme/api · main | $1.84 | 12% | 40 min ago |
| Verify FX-1: schema sync before migrations acme/api · dosu/fx-1 Cloud agent | $0.92 | 4% | 2 h ago |
| Fix the flaky billing webhook test acme/api · main | $3.10 | 31% | Yesterday |
Dosu runs inside your network, so nothing leaves it unless you connect a service outside it. Three steps: send your sessions, connect a cloud agent, then build the fixes Dosu recommends. Your scores appear once 50 sessions are read.
Where this org's sessions come from, the cloud agent that verifies and ships fixes, and how agents reach Dosu.
Where your org's agent sessions live. An org admin sets it once and gives Dosu a read key; each member then joins with dosu setup and writes to their own folder.
Already store agent sessions in another tool? Dosu can read them from there too.
| Active source | Sessions, 30 days | Last session |
|---|
Dosu tests runbooks and fixes against your code. It clones these repositories to this server, from GitHub with your personal access token or from a folder of them you mount, and pulls new commits every 15 minutes.
2 repositories · last pulled 6 min ago · token saved by Dosu Bot, expires
Your cloud agent tests each fix in your real development environment and opens the pull request when you build it.
Lets coding agents read tested runbooks and your team's docs while they work, so they stop hitting issues Dosu already knows about.
The MCP server and CLI talk to Dosu at https://dosu.internal.acme.com, inside your network. Agents need to run on it or reach it over your VPN.
Agents can see and do anything a person can do in this app: read issues, verify and build fixes, and manage runbooks.
These endpoints are only on your internal network. Cloud agents outside your VPC can't call them unless you route them in.
How the grades, pain scores and trends on this dashboard are calculated.
Dosu reads every coding-agent session your team runs, continuously, as sessions finish.
Each time an agent gets stuck counts as a friction event. Recurring events on the same task are grouped into an issue.
Dosu saves a runbook for each issue. An agent runs it end to end in a sandbox and corrects any step that fails.
An issue gets one small change that shortens the runbook or makes it unnecessary once agents spend about 5 minutes a month on it, however often it recurs: one costly session is enough. Shipped fixes are tracked against new sessions.
Each grade is a score out of 100. Within a grade, the score rises as you get closer to the next one. Friction counts failed attempts, detours and corrections. Autonomy counts every time the agent needed a person: interventions, extra human turns, idle waits and manual starts.
| Grade | Score | Friction events per session | Human touches per session |
|---|
What happens to a fix once your cloud agent is connected on Sources.
Verify. Your cloud agent runs the same task twice, with and without the fix, and reports Improved, No gain or Couldn't verify, with what it measured. Nothing changes in your repository yet. Dosu only sends changes it has reviewed in full.
Build. You build a fix, and your cloud agent opens a pull request with exactly the change it tested. A fix to your agents' setup, such as access to a system they keep asking a person for, changes your agents' environment instead: the cloud agent does the setup it can and lists any steps only a person can do, such as a grant, under Your steps left. Mark them done and the fix ships.
Approve. A person approves the pull request in GitHub. The cloud agent merges it once CI passes, and the fix ships.
Measure. Savings compare the friction rate on tasks that hit the problem in the 90 days before the fix shipped with the rate since, priced at the fix's own agent time per friction task. A fix stays Measuring until a task hits the problem after it ships. If the problem comes back, Dosu proposes a follow-up fix that links to the one that shipped.
The pain score ranks open fixes from 0 to 10. It weights how often an issue happens (60%) and how many sessions it reaches (40%), weighted so one very noisy issue doesn't drown out the rest.
Which issues get a fix. Dosu proposes a fix for an issue once agents spend about 5 minutes a month of agent time on its task, counting the mistakes and failed calls in it, rather than once it has come up in a number of sessions. A costly problem seen once gets a fix; a cheap one seen often may not. A fix that fails Dosu's own review is settled as no change, with the review's reason.
Setup fixes from runbook checks. When your cloud agent can't check a runbook because it lacks a tool or access, Dosu recommends the setup change that would let it, such as installing a CLI. Setup fixes that make the same change become one fix, which lists the other issues it lets agents do; those issues say they're covered by it. Access to production, a database or a secret stays with a person, and a note that the task can't be done in the cloud agent isn't a fix.
Automatic verify sends new fixes to the cloud agent as soon as Dosu proposes them, highest impact first, until the daily cap is reached.
Savings are shown inside each fix. Friction fixes save agent time: each friction event avoided counts as 2.5 minutes. Autonomy fixes save human time: each human touch avoided counts as 6 minutes of a person's effort and the agent's idle wait.
Autonomy counts human touches per session, the four ways an agent depends on a person: interventions (a person corrects or redirects it), human turns (each message a person sends after the first request), idle waits (each 5 minutes the agent sits waiting on a person) and manual starts (a person kicks off work that could have started on its own, from a ticket, alert or schedule). The Autonomy Grade uses their total.
Runbook status. A runbook is confirmed once Dosu sees it help, even in a single session: the agent did better with it than in the sessions that hit the same issue without it. A test run that shows it helps also counts. The Issues page shows only confirmed runbooks by default; switch to All to see the rest. Runbooks that didn't help can be discarded: agents stop getting them, and the issue stays tracked. Not a problem on a stuck moment tells Dosu to stop flagging it.
Colors. Orange marks friction and indigo marks autonomy, on the grades, the trend and each fix's impact.
The chart in each grade card shows that score week by week, out of 100; each point covers 7 days, so a day with one or two sessions doesn't swing it. The dashed line is where the score would likely be without Dosu. While the latest week holds sessions Dosu hasn't analyzed yet, its segment is dashed and faded: their friction and human touches count once they are.
Score breakdown splits friction into tool errors (calls that failed), wasted steps (a call made again after it had already succeeded), retries (the same call tried again after it failed) and wrong turns (work the agent later undid). A moment marked Not a problem leaves the friction counts.
Recurring patterns. Dosu sorts each runbook's problem into one of five root causes, once: undocumented multi-step procedures, undocumented system architecture, hidden environment divergence, test harness pitfalls, and stale or misleading evidence. A pattern counts its issues, the sessions in the last 30 days with evidence of one, and their fixes.
Agent Readiness. A tool call fails when its result says so: an error, a non-zero exit, a failed test run. Tools are ranked by failed calls per session, and a tool that never failed isn't listed. Dosu doesn't blame a tool for friction just because it was called while an agent was going wrong: most friction comes from how tools are used together, not from the tool. A guide counts as loaded when the session read it, ran it as a skill, or had it loaded by its agent. Friction with and without it compares sessions in the same projects, once each side has 3 sessions. A guide an agent puts in its system prompt at the start of every session doesn't show in the session, so a root AGENTS.md counts only when an agent read it.
The trend without Dosu adds back what runbooks spared: for each session that used a runbook, the friction and human touches sessions that hit the same problem without it had, less what the session had. Until agents use runbooks, it sits on the score line.