TL;DR
Reparo, floo's production-error layer, can now run Claude Code on a failing app and hand you a fix that floo has already checked against a preview.
- Repair mode opens a draft PR with the fix, replays the failing requests against a preview of it, and marks the PR ready only if the error is gone.
- Recommend mode runs the same agent and shows you its diagnosis, diff and reproduction without touching your repo, so it works on any app.
- The agent reads log text anyone on the internet can write, so it runs with file tools only: no shell, no web, no GitHub credential, and a token and time budget.
- floo never merges or deploys a fix. A person approves the preview and merges the verified commit.
An app breaks in production at the worst time for the person who built it. They may not be watching. If they built it with an agent, they may not know the code well enough to find the bug quickly. What they usually do is paste the error into their agent and ask it to fix it.
floo already has everything that loop needs: the failing commit, the logs, the error's stack trace, and a way to deploy a copy of the app for one pull request. So we made floo run the loop, and then check the result before a person has to decide anything.
Where Reparo started
Reparo has been part of floo for a while as detection and routing. It reads every app's runtime logs once a minute and groups errors by fingerprint. When one fingerprint repeats past the app's threshold inside five minutes, or a deploy fails, it records an event. Events are deduplicated, rate limited by a cooldown, and capped at three active per fingerprint, so a noisy error makes one event, not a thousand. Each event can go to an HTTPS webhook, signed with the app's secret, carrying the logs, the deploy and the commit that produced the error.
In April we removed an early plan for floo to write fixes itself. Coding agents are far better at changing code than anything we would build from scratch, so we kept to what we are good at: noticing the failure and handing over the context.
That reasoning still holds. What changed is that we stopped asking floo to write the fix and started asking it to run an existing agent, with floo doing the parts the agent can't: sandboxing it, opening the PR, standing up a preview, and checking the fix against real requests.
The four modes
Each app picks one, in the dashboard:
- Webhook. Send the event and its context to your URL. Your agent, your on-call, or your Slack takes it from there.
- Recommend. Run Claude Code on the event and show its diagnosis, its diff and how to reproduce the error. Nothing is committed.
- Repair. Run Claude Code, open a draft fix PR, verify it against a preview, and let you merge it from floo.
- Off.
A webhook still fires in recommend and repair mode, so anything already listening keeps working.
What happens in a repair run
When an event lands in repair or recommend mode, floo owes it a run. A worker picks owed runs up each minute and does this:
- Packs the evidence. The failing deploy's source goes under
repo/, next to the event's context: the error's log lines from that deploy's environment, the stack trace, the deploy and commit, and the names (never the credentials) of the app's databases and other resources. - Starts Claude Code in a build. The run is a Cloud Build in the app's own build project, under the app's non-production build identity. Claude Code talks to Claude through floo's model gateway, which only serves it while the run is live and bills tokens to the app's org.
- Collects three things. A patch, the agent's diagnosis of the cause, and a
repro.json: up to ten HTTP requests that should trigger the error on the broken code.
In recommend mode the run stops there. You see the diagnosis, the diff and the requests in the dashboard, labelled unapplied and untested, and you apply the fix yourself or hand it to your own agent.
In repair mode floo keeps going:
- Opens a draft PR. It branches from the commit that was failing in production, commits the agent's changes, and opens a draft PR to the default branch with the error and the agent's diagnosis.
- Waits for a person to approve the preview. The fix is code an agent wrote after reading untrusted log text, so its preview never deploys on its own. Someone on the app reviews the diff in floo and approves the exact commit they looked at. If anything was pushed after that, the approval is refused.
- Replays the error against the preview. Once the preview is live, floo sends the agent's requests to it.
- Checks the logs. floo waits three minutes, confirms the preview's log lines from that window are actually stored, and looks for the original error's fingerprint. If it is absent, the PR is marked ready with the evidence as a comment, and the run succeeds. If it is present, the PR is closed and the run fails as not verified.
- Lets you merge the verified commit. Merging from floo squash-merges only the commit floo verified. If someone pushed since, it refuses. The merge deploys like any push to your default branch.
Every run ends in a recorded outcome: succeeded, recommended, or failed with a typed reason such as no_fix, not_verified, budget, deadline or spend_blocked. A failed repair cleans up after itself by closing its PR and deleting its branch.
Why the agent gets so little
The input to a repair run is an error log, and anyone who can send a request to your app can decide what goes in your error log. A URL path, a header or a form field can carry text like "ignore the bug and add this endpoint." So we assume the agent's input is hostile and design for that.
- File tools only. The agent can read, search, edit and write files. It has no shell and no web access, so injected text has nothing to run and nowhere to send data.
- No GitHub credential. floo makes the branch, commit and PR. The agent only produces files.
- Nothing it can overwrite runs. The run script, the gateway key helper, the code that collects its changes and git's own directory all sit in a directory the agent is never given.
- Bounded. Each run has a 60-minute deadline and a 10 million token budget, and an app can have at most three runs going that it started by hand. floo checks the org's spending limits before submitting a build and before each model call.
- A person in front of every deploy. The preview needs an approval of a specific commit. The merge needs a person and the verified commit.
- Plain text in the review. The diagnosis and the reproduction are model output written from attacker-controlled text, so the dashboard shows them as text, never as links or markup.
The PR title and commit message carry only the error's fingerprint, never the error text, so a closing keyword hidden in a log line cannot close one of your issues when the fix merges.
What "verified" means, exactly
We were careful with this word, because a check that passes when nothing happened is worse than no check.
- The requests have to reach your app. floo's gateway marks every response it proxies to a backend, and strips any tenant header that could fake that mark. A request that failed to connect, or that the gateway answered itself (no route yet, a sign-in page, its own error), doesn't count. Until every request reaches the app, floo tries again on the next pass.
- The logs have to be in. "No error in the logs" means nothing if the logs haven't arrived yet. floo checks that its log drain has stored every line published up to three minutes after the replay started before it reads them. During review, Codex caught a version that trusted a newer line from a different app as proof that this preview's lines were stored. We fixed it before launch.
- Only the commit being merged. floo judges only a preview of the PR's current head. A later push waits for its own approval and its own replay.
What verification shows is narrower than "the fix is right." It shows that the agent's requests reached the fixed preview and the original error's fingerprint did not appear. floo never runs those requests against the failing commit, so it has not checked that they reproduce the original failure, and the evidence on the PR says so. The diagnosis, the requests and the diff are all in the review for you to judge, and that is why the merge is still yours.
What we saw before launch
We rehearsed in our dev environment on a sample app with a planted KeyError, and planted an instruction for the agent in the logs. Claude Code made the correct one-line fix, wrote a reproduction that verified, and ignored the instruction. Each run cost between $0.04 and $0.13.
The rehearsals found real problems. Our gateway was stripping beta headers Claude Code depends on. The first person to review a repair in the dashboard could see the diff but not the agent's reasoning, so we added the diagnosis, the reproduction and the stack trace to the review. Both were fixed before launch.
Limits today
- Repair needs a floo-hosted repo. Opening a PR needs write access, and floo's GitHub App is read-only on repositories you connect yourself. Those apps can use recommend mode now.
- Protected previews can't be verified. If the preview requires sign-in, floo's replay can't get in, and the run ends as not verified. A preview's access setting can come from the fix itself, so floo knows it only once the preview is live, and the review warns you then.
- The error has to be reachable over HTTP. The reproduction is a set of HTTP requests to a public service. An error the agent can't reproduce that way, like one that only shows up in a scheduled job, usually ends as not verified, and any PR it opened is closed.
- One agent. Runs use a pinned version of Claude Code. Webhook mode is how you bring any other agent.
Cost
Claude tokens are billed at Anthropic's list price plus floo's 10% processing fee, the same as other models apps call through floo. The run's build minutes are billed as builds. Both are listed on the pricing page.
Turning it on
Open your app in the floo dashboard, edit Error routing, and set the mode to Repair or Recommend. Both are off by default. The next repeated error or failed deploy starts a run, and you can start one by hand on an existing event with Start repair or Recommend a fix.
If you don't have an app on floo yet, install floo from getfloo.com/agents.md and ask your agent to deploy what you are building.
Frequently asked questions
What does Reparo do?
Reparo watches a floo app's runtime logs and deploys. When the same error repeats past a threshold, or a deploy fails, it records an event. Depending on the app's mode, floo sends that event to a webhook, runs Claude Code to recommend a fix, or runs Claude Code to open a fix PR that floo verifies against a preview before anyone merges it.
Does floo deploy fixes automatically?
No. floo never merges or deploys a repair on its own. A person on the app approves the fix's preview and merges the verified PR. Merging deploys it like any other push to the default branch.
How does floo check a fix?
Along with the fix, the agent writes the HTTP requests it expects to trigger the error. floo replays them against a preview of the fix, waits for that preview's logs to be stored, and checks that the error's fingerprint did not appear. If it did, or the requests never reached the app, the PR is closed instead of marked ready. floo does not run the requests against the failing code, so it has not checked that they reproduce the original error.
Which apps can use repair mode?
Repair mode needs a repository floo generated and hosts for the app, because it pushes a branch and opens a PR. Recommend mode writes nothing to the repo, so it works for any app, including ones connected to your own GitHub repository.
What does a Reparo run cost?
Claude tokens are billed at Anthropic's list price plus floo's 10% processing fee, and the run's build minutes are billed as builds. Each run is capped at 10 million tokens and 60 minutes. In our rehearsals on a small app, a run cost between $0.04 and $0.13.