Imagine someone delegates a task to a personal assistant app: "Fill out the contact form on AcmeCo and ask about pricing." Instead of a human assistant doing it, the app starts an agent that can navigate a browser, find the form, type, and click submit. That scenario is no longer science fiction: companies are improving models that use and manipulate user interfaces, and platforms are releasing APIs that let developers build agents that act on their behalf. See Anthropic's Feb 2026 update (acquiring Vercept) for improved computer-use capabilities and OpenAI's Agents API announcement in Sept 2026 for agent-oriented tooling. These are checkpoints in a changing landscape, not guarantees that every agent can navigate every site.
Why this matters for everyday forms
Forms are one of the most common interaction patterns on the web: signups, intake forms, orders, support tickets. Historically we optimized them for human users. When you add delegated agents to the mix, a few design affordances suddenly become critical:
- Clear labels: agents parse text and HTML—ambiguous labels increase failure rates.
- Visible state: agents need deterministic signals for success, failure, and in-progress work (disabled buttons, spinners, success banners).
- Reversibility: automated actions should be undoable or confined behind confirmation flows to avoid costly mistakes.
- Confirmation and receipts: machine-readable confirmations help agents reconcile completed tasks.
Below we follow a simple form flow and show concrete choices you can make as a designer or engineer.
Step 1 — Discovery: making the form findable
An agent trying to act like a human needs a reliable way to find the right form. Humans scan visual cues; agents rely on semantic structure. Improve discovery by:
- Using semantic HTML:
- Avoiding buried or dynamically-named controls. An input with id="q1" and no descriptive label is harder to match than id="phone_number" and a visible label "Phone".
- Adding structured metadata: JSON-LD or schema.org markup for contactPoint or product pages helps agents understand the page purpose without brittle heuristics.
Example (conceptual HTML):
<form id="inquiry" action="/contact">
<label for="full_name">Full name</label>
<input id="full_name" name="full_name" type="text" />
<label for="email">Email</label>
<input id="email" name="email" type="email" />
<button type="submit">Send inquiry</button>
</form>
Don’t invent hidden selectors just for agents, but consider optional data attributes that signal intent for integrators, e.g. data-agent-field="email". Those attributes let a consenting agent target fields directly without brittle OCR or visual scraping.
Step 2 — Filling: labels, constraints, and typed inputs
Agents are good at following explicit rules. Help them by making constraints explicit:
- Use input types (email, tel, date) and pattern attributes so agents can validate before sending.
- Provide placeholder examples and descriptive aria-describedby text for edge cases.
- Surface constraints clearly: "Max 250 characters" or "One file, under 10 MB".
If an agent pre-fills a form, it should also leave traces that indicate automation: a subtle, accessible note like "Filled by agent—review before submit" helps humans know a machine acted and gives them context to double-check.
Step 3 — Submitting: visible state and idempotency
Clicking submit is where consequences happen. Agents may retry network requests, so servers need to be resilient and safe:
- Idempotency tokens: accept a client-provided idempotency-key so repeated submits don't create duplicate orders or tickets.
- Clear in-progress UI: disable the submit button and show a spinner. Agents and humans both rely on these signals to know an action is underway.
- Predictable success signals: a JSON response and a visible success banner with an order or ticket number are easier for agents to detect than a complex redirect.
Don't assume every agent will behave perfectly. Design for retries and partial failures; return machine-readable receipts (JSON confirmation objects, unique IDs) alongside human-facing pages.
Step 4 — Errors, ambiguity, and reversibility
Errors are where agents and humans diverge. Agents can be brittle when faced with ambiguous errors. Make error handling explicit:
- Field-level errors should tie back to the input with clear messages: "Email looks invalid" and aria-invalid=true.
- For business logic errors (payment declined, duplicate email), return code + readable message + suggested next step.
- Offer safe reversal: a cancellable state, a "Revoke" link within a short window, or a soft-delete that can be recovered by an admin.
From a system point of view, prefer reversible operations when possible. If the action is irreversible (finalize purchase, delete data), require an explicit human confirmation step or a second-factor action.
Step 5 — Confirmation, auditing, and human review
When an agent performs an action, two things help you sleep better at night: clear receipts and audit trails.
- Give a machine-readable receipt (JSON webhook or a URL to a status resource) that includes a unique action ID, timestamp, and who authorized the agent.
- Log the authorization context: which user granted the agent permission, what scope was allowed, and the agent's identity (token ID, not raw model name).
- Surface an admin or user-facing review queue where humans can approve or reverse agent actions.
These measures let operations teams and users reconcile automated activity quickly and build trust in delegated workflows.
Practical engineering checklist
A compact checklist you can follow when you expect automated visitors:
- Semantic HTML: labels, types, buttons
- Machine-readable hints: schema.org, JSON-LD, or data-agent-* attributes when appropriate
- Idempotency and server-side protection against duplicate actions
- Visible state for in-progress/success/failure
- Clear, linked error messages and aria attributes for accessibility
- Reversibility options and an explicit human confirmation path for risky actions
- Audit logs and receipts with action IDs and authorization metadata
- A review/approval dashboard for edge cases and exceptions
UX patterns that balance automation and control
- Pre-fill + confirm: agents fill drafts and show them to the user for one-tap approval.
- Scoped agent permissions: allow agents to act on specific forms or data types rather than broad site access.
- Rate limits per-agent: avoid accidental flooding by designating reasonable request budgets for delegated agents.
- Replace CAPTCHA with intent or consent checks: CAPTCHAs block helpful agents too—consider alternative verification flows that involve an out-of-band human confirmation when needed.
Prototype ideas to try this month
Intake assistant with review queue: An agent pre-fills customer intake, creates a draft ticket, and routes it to a short review queue where a human approves or edits before final submission.
Agent-friendly manifest: Add a small JSON manifest endpoint (/.well-known/agent-manifest.json) that describes common forms, accepted fields, and rate limits. This is optional metadata for integrators and consenting agents—it should never bypass authentication.
Audit-first dashboard: Show recent automated actions with diff views and one-click reversal for soft-deleted items.
These prototypes treat agents as part of the workflow instead of magical black boxes.
A note on current agent tooling and limits
Research checkpoints help set expectations. For example, Anthropic's Feb 2026 announcement about acquiring Vercept described work on improving models' computer-use capabilities (https://www.anthropic.com/news/acquires-vercept), and OpenAI introduced an Agents API in Sept 2026 focused on agent patterns (https://openai.com/index/introducing-the-agents-api/). These are useful reference points: they show momentum and new capabilities, but they do not imply universal adoption or flawless site navigation. Build defensively and assume variability in agent behavior.
Closing: design for people first, agents second
Treat delegated agents like another class of user: they follow rules better when the rules are explicit. Clear labels, visible state, reversibility, and machine-readable confirmations make your forms safer and more automatable without compromising human usability. Start small: add a few structured hints, guarantee idempotency on server actions, and build a lightweight audit trail. Those steps reduce fragile automation, speed up integrations, and keep control in human hands.
Takeaway: Make your forms explicit—semantic HTML, clear feedback, idempotent operations, and visible audits let agents and people share workflows safely and productively.
