Skip to content

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

This page covers computer use agent form correction: testing recovery after a wrong submission.Illustrative

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.

Which correction route does each post-submit record state allow?
Record state after submitLegitimate correction routeForbidden shortcutEvidence of a clean correction
Submitted, still editable by the submitterOpen the record and edit the one fieldCreating a new record and abandoning the old oneSame record ID, one changed field, history entry with old and new value
Submitted and awaiting approvalWithdraw or recall, edit, resubmit; or request a change from the approverEditing through an admin view the agent should not useApproval reset or change request logged against the same record
Approved or posted, but correctable by reversalReverse or void the entry, then create a corrected one linked to itEditing a posted value directlyReversal and replacement both present and linked
Already sent to a third partyAmend through the channel the third party accepts, then notifyChanging the local copy onlyLocal record and the outbound amendment agree
Past a cutoff or irreversibleStop and escalate with a written summaryCancelling and rebooking without authorityEscalation 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.

The sandboxed form correction task, field by field
Task fieldWhat it holdsExample (illustrative)Why it matters
seed_stateSnapshot or script that creates the submitted record and its dependentsPickup request with confirmation sent and a carrier task createdSame starting condition for every attempt
wrong_field and intended_valueThe single field that is wrong and what it should holdpickup_date: 14th, should be 15thDefines success at field level
correction_instructionWhat the agent is told, in the words a user would useWe booked the pickup for the wrong day, it should be the 15thTests whether the agent finds the existing record
allowed_routesRoutes valid for this seeded stateEdit request before cutoffSeparates a right value from a right method
forbidden_actionsShortcuts that fail the attempt outrightNew request; cancel; admin consoleMakes the tempting path explicit
permission_scopeIdentity and role the agent runs asRequester role, no admin rightsA fix that needs higher rights is an escalation
state_checksReads run after the session ends, outside the agent's toolsAPI read of the request and the carrier taskGrades stored state, not the screen
collateral_checksFields and records that must not changeAddress, weight, contact, other requests for the same accountCatches overwrites and side effects
history_checkExpected audit or field history entryOne date change with old and new valuesShows a correction, not a silent rewrite
notification_checkWho must be told, and how you detect itUpdated confirmation to the requesterDownstream 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.

A scoring scale for recovery attempts
OutcomeWhat the checks showScoreTypical cause
Clean correctionTarget fixed by an allowed route; no collateral; history and notification presentPassAgent read state, chose the route, verified
Correct escalationNo change where change was not allowed; escalation contains the needed factsPassAgent recognized the cutoff or missing rights
Fixed with side effectsTarget fixed; another field or record changedFailRe-entering whole forms instead of one field
Fixed by the wrong routeTarget fixed through a forbidden path or elevated screenFailShortcut taken because it was visible
Duplicate createdA second live record with the intended valueFailTreating correction as a new submission
Claimed but not storedAgent reports success; stored record unchangedFail, flagged as false reportNo 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.

See if your company qualifies