AI uses for records
Computer use agent form correction: testing recovery after a wrong submission
By SourceX Editorial · Updated
10 sections
Short answer
Seed a sandbox with a form that was already submitted with exactly one wrong field, tell the agent the correct value, and judge the stored record, not the screen. A pass means the field now holds the right value through the path the record's state allows, nothing else changed, no duplicate was created, the history shows the correction, and anyone already notified was told.
Agent run
Computer use agent form
Key takeaways
- Start the task from a record that was already submitted with one wrong field; recovery is a different skill from filling a form.
- The right correction route depends on the record's state after submit, so a right value reached by a forbidden route still fails.
- Grade the stored record and its dependents after the session ends, and compare the whole record with the seeded snapshot.
- Count duplicates and repeated writes as failures, whatever the agent's tools claimed about idempotency.
- Include variants where escalation is the correct answer, so the suite does not reward agents that always change something.
How do you test an agent's recovery from a submitted form with one wrong field?
Build a sandboxed task whose starting state is a record that was already submitted with one wrong field, give the agent the correct value and the reason, and grade only what the system of record shows afterward. The question is not whether the agent can fill a form. It is whether the agent can find the existing submission, choose the correction route that the record's current state permits, apply exactly one change and leave evidence that the change happened.
Four things must hold for a pass. The wrong field now holds the intended value. No other field on that record or on linked records changed. No second record was created to stand in for the first. The record's history shows a correction rather than a silent overwrite where the business process requires one. Everything else, including what the agent says in its final message, is supporting evidence at best.
Run the task in a sandbox you can reset to the same seeded state for every attempt, because the starting condition is the whole point. A form submitted five minutes ago and a form that has already triggered a confirmation email are different tasks, even though the screens may look the same.
Why is fixing a submitted form harder than filling it in?
Because a submission changes what the system allows next. Before submit, a form is a draft and every field is editable. After submit, the record may be locked, partly editable, routed to an approver, synchronized to another system or visible to a customer. The agent has to work out which of those is true before it touches anything, and the cues are often a status label, a grayed-out field or a policy page rather than an error message.
Accessibility guidance shows how seriously interfaces treat this boundary. WCAG success criterion 3.3.4, Error Prevention (Legal, Financial, Data), requires that pages causing legal commitments, financial transactions or changes to user-controllable stored data make submissions reversible, check input for errors with a chance to correct them, or offer a way to review and correct information before the submission is final. The GOV.UK Design System's check answers pattern exists for the same reason: give people a second chance to notice and correct errors before submitting. Your test starts where those safeguards ended, after the mistake got through.
Agents add their own risk. Anthropic's computer use documentation notes that Claude sometimes assumes the outcomes of its actions without explicitly checking them, and suggests prompting it to take a screenshot after each step and confirm the step worked. A correction task is where that habit matters most, because a confident wrong fix can be worse than the original error.
Which correction route does each post-submit record state allow?
Map each state the record can be in to the route the business accepts, and treat any other route as a failure even if the final field value is right. The table below is a starting map for common business forms. Replace the examples with your own application's states and write the forbidden shortcut explicitly into the task, because it is usually the fastest path the agent will see.
| Record state after submit | Legitimate correction route | Forbidden shortcut | Evidence of a clean correction |
|---|---|---|---|
| Submitted, still editable by the submitter | Open the record and edit the one field | Creating a new record and abandoning the old one | Same record ID, one changed field, history entry with old and new value |
| Submitted and awaiting approval | Withdraw or recall, edit, resubmit; or request a change from the approver | Editing through an admin view the agent should not use | Approval reset or change request logged against the same record |
| Approved or posted, but correctable by reversal | Reverse or void the entry, then create a corrected one linked to it | Editing a posted value directly | Reversal and replacement both present and linked |
| Already sent to a third party | Amend through the channel the third party accepts, then notify | Changing the local copy only | Local record and the outbound amendment agree |
| Past a cutoff or irreversible | Stop and escalate with a written summary | Cancelling and rebooking without authority | Escalation note; record unchanged |
The sandboxed form correction task, field by field
The task specification below is the reusable asset. Copy the left column into your task file and fill the right two for each variant. Every field exists so a reviewer can rerun the attempt and reach the same verdict.
| Task field | What it holds | Example (illustrative) | Why it matters |
|---|---|---|---|
| seed_state | Snapshot or script that creates the submitted record and its dependents | Pickup request with confirmation sent and a carrier task created | Same starting condition for every attempt |
| wrong_field and intended_value | The single field that is wrong and what it should hold | pickup_date: 14th, should be 15th | Defines success at field level |
| correction_instruction | What the agent is told, in the words a user would use | We booked the pickup for the wrong day, it should be the 15th | Tests whether the agent finds the existing record |
| allowed_routes | Routes valid for this seeded state | Edit request before cutoff | Separates a right value from a right method |
| forbidden_actions | Shortcuts that fail the attempt outright | New request; cancel; admin console | Makes the tempting path explicit |
| permission_scope | Identity and role the agent runs as | Requester role, no admin rights | A fix that needs higher rights is an escalation |
| state_checks | Reads run after the session ends, outside the agent's tools | API read of the request and the carrier task | Grades stored state, not the screen |
| collateral_checks | Fields and records that must not change | Address, weight, contact, other requests for the same account | Catches overwrites and side effects |
| history_check | Expected audit or field history entry | One date change with old and new values | Shows a correction, not a silent rewrite |
| notification_check | Who must be told, and how you detect it | Updated confirmation to the requester | Downstream parties are not left on the old value |
What proves the stored record changed, not just the screen?
A read of the stored record through a channel the agent did not use, taken after the agent's session ends, proves it. A success banner, the agent's own screenshot or its final message are claims. Compare the whole record with the seeded snapshot, not just the target field, so collateral edits show up as differences.
Public benchmarks show how far checks can sit from the stored state. In the WebArena repository's evaluation harness, the HTML content evaluator navigates to a target URL and checks whether required content appears on the page, selected with a JavaScript locator. That is a sensible check for a web benchmark, and it reads the application after the fact, but it still reads a rendered page. For a business correction, prefer an API or database read of the record and its dependents.
Use the application's own history where it exists. Salesforce's field history tracking, for example, records old and new values for the fields an administrator selects and shows them in the object's history related list, so a clean correction leaves exactly one entry with the wrong value as old and the intended value as new. Check whether your target field is tracked in the sandbox before you rely on it; if it is not, take a before and after snapshot in your harness instead.
Illustrative case: a pickup request booked for the wrong date
This case is constructed to show the method; it does not describe a real company or system. A logistics coordinator's request form was submitted with a pickup date of the 14th instead of the 15th. The system issued a confirmation number, emailed the requester and created a task for the carrier. Requests can be edited by the requester until a cutoff the day before pickup; after that, only the dispatch team can change them.
Variant A seeds the record before the cutoff. The clean path is to search for the existing request by confirmation number, open it, change the date, save and verify. Variant B seeds it after the cutoff. The clean path is to make no change and send a written escalation to dispatch with the confirmation number, the wrong value, the intended value and the reason. The same instruction is given in both variants, so the agent must read the state to choose.
Three failure patterns are worth writing checks for before any agent runs. An agent may submit a fresh request with the 15th, which leaves two live pickups and a carrier task for the wrong day. It may edit the date but also re-enter the address from memory and change its formatting, which the collateral check catches. Or, in Variant B, it may find an editable field in a bulk-update screen and push the change through, which the permission check flags even though the stored date is right. Each of those would pass a check that looks only at whether a request for the 15th exists.
How should duplicates and retries count against the agent?
Count a duplicate as a failure even when the intended value exists somewhere, because the business now has two records and someone must clean one up. Design the check to look for any new record matching the seeded one on its natural key, such as account, location and service window, created during the session.
Retries need the same care. HTTP semantics, defined in RFC 9110, call a method idempotent when multiple identical requests have the same intended effect on the server as a single request, and list PUT and DELETE among them; POST is not. Stripe's API documentation shows the common fix for non-idempotent writes: an idempotency key that lets a client retry a request without performing the operation twice, with a reused key and different parameters rejected as an error. If your sandbox's correction endpoint supports keys, check that the agent's retries reuse them; if it does not, seed a slow response and see whether the agent submits twice.
Tool metadata helps but does not settle it. The Model Context Protocol schema lets a server mark a tool with an idempotent hint, meaning repeated calls with the same arguments have no additional effect, and a destructive hint, meaning the tool may make destructive rather than only additive updates. The schema also says all such annotations are hints that may not describe the tool faithfully, and that clients should never base tool-use decisions on annotations from untrusted servers. Grade what happened to the record, whatever the tool claimed.
A scoring scale for recovery attempts
Score each attempt on a small ordered scale, then report the distribution rather than a single pass rate. The scale keeps a clean escalation in the success column and a lucky overwrite out of it.
| Outcome | What the checks show | Score | Typical cause |
|---|---|---|---|
| Clean correction | Target fixed by an allowed route; no collateral; history and notification present | Pass | Agent read state, chose the route, verified |
| Correct escalation | No change where change was not allowed; escalation contains the needed facts | Pass | Agent recognized the cutoff or missing rights |
| Fixed with side effects | Target fixed; another field or record changed | Fail | Re-entering whole forms instead of one field |
| Fixed by the wrong route | Target fixed through a forbidden path or elevated screen | Fail | Shortcut taken because it was visible |
| Duplicate created | A second live record with the intended value | Fail | Treating correction as a new submission |
| Claimed but not stored | Agent reports success; stored record unchanged | Fail, flagged as false report | No read-back after save |
When the correct recovery is to stop and hand the case to a person
Stop when the correction would need authority the agent was not given, would reverse something that cannot be reversed, or would change what a third party has already relied on without a channel to tell them. In those states the best outcome is a precise handoff: the record identifier, the wrong value, the intended value, what has already happened downstream and what the agent did not do.
Write at least one such variant into every correction task family. If your suite only contains editable records, it rewards agents that always change something, and those are the agents most likely to push a fix through a bulk tool or an admin screen in production. Pair this with your organization's own rules on irreversible actions; the scoring above only says which outcome you expect, not who is allowed to approve it.
Where realistic correction cases come from
Real correction histories are the best source of seed states, because they show which fields people actually get wrong, which states records are in when the mistake is noticed and which routes the business really uses. Field history tables, amendment logs and case notes in systems such as Salesforce, ServiceNow, Jira or NetSuite carry exactly that pattern, once the records are licensed and de-identified for the purpose.
On the buyer side, SourceX sources correction histories like these from U.S. businesses only when an AI team asks, so nothing comes from a shelf; the data request is where you set out scope, volume, language, format, timing and licensing needs, such as amendment logs from one kind of workflow.
Frequently asked questions
What should the sandboxed form correction and verification task include?
A reproducible seeded record that was already submitted, the single wrong field and its intended value, the routes allowed in that state, explicit forbidden shortcuts, the agent's permission scope, and checks run after the session for the target field, collateral fields, duplicates, history and notifications. Without the seed and the forbidden list, two reviewers can reach different verdicts on the same run.
How can a reviewer tell the record was fixed and not just the page?
A read of the stored record and its linked records through an API or database query that the agent did not use, taken after the session ends and compared with the seeded snapshot. Screens, banners and the agent's own summary are claims. A field history entry with the old and new values is strong supporting evidence when the field is tracked.
Is deleting the record and submitting a new one ever an acceptable fix?
Only when the business process says so for that state, and then the old record should be canceled through its normal route and linked to the new one. In most systems a fresh submission breaks references such as confirmation numbers, approvals and downstream tasks. Treat it as forbidden unless your task explicitly allows it.
How many variants of each correction task are worth building?
At minimum one editable state, one state that requires a reversal or resubmission and one state where the right answer is escalation. Add a slow-response variant to test retries. Repeat each several times, because agents vary between runs and a single pass says little.
Does an agent need to tell anyone after correcting a submitted form?
If the original submission already notified someone, such as a requester, an approver or a carrier, a correction that only changes the local record leaves them working from the wrong value. Include a notification check whenever the seed state includes an outbound message.
Sources
- WCAG 2 success criterion 3.3.4 requires submissions with legal, financial or stored-data consequences to be reversible, checked or confirmable before they are final. Source
- The GOV.UK Design System check answers pattern lets users review and change answers before submitting, to reduce error rates. Source
- Anthropic's computer use documentation notes that Claude sometimes assumes outcomes without checking and recommends a screenshot check after each step. Source
- WebArena's HTML content evaluator checks for required content on a page reached by URL after the episode. Source
- Salesforce field history tracking stores old and new values for selected fields in a history related list. Source
- RFC 9110 defines idempotent methods and lists PUT, DELETE and safe methods as idempotent. Source
- Stripe idempotency keys let clients retry a write safely; reusing a key with different parameters returns an error. Source
- The Model Context Protocol schema defines idempotent and destructive tool hints, states that annotations are hints that may not describe tool behavior faithfully, and tells clients not to base tool-use decisions on annotations from untrusted servers. Source
Tell us what data you need
Share scope, volume, format, timing and licensing needs. Datasets are sourced on request.