Verification guide · 10 minutes
How to verify that an AI agent actually completed the job

An agent’s success message is only a statement about what it believes happened. Reliable verification checks the system that was supposed to change.
When an AI agent says “done,” it may be reporting a completed action, a successful API request, or only the end of its own workflow. Those are different things.
The dependable question is not “What did the agent log?” It is: Can I observe the requested result in the live system where it matters?
The real problem: reports are not outcomes
Imagine asking an agent to publish a page, send an email, or update a record. The agent may finish without an obvious error, yet the result can still be missing because:
- the request reached the wrong account, workspace, or environment;
- the operation was accepted but processed asynchronously;
- the draft was saved, but not published;
- the message was created, but not sent;
- the change was overwritten by a later process;
- the agent misunderstood the requested target.
These failures are difficult to detect if you inspect only an agent log. A log can prove that the agent attempted an action. It usually cannot prove that a person can now see, receive, or use the result.
A reproducible verification workflow
Use the following workflow whenever an agent changes a website, email account, document repository, database, or other external system.
1. Write down the expected observable result
Before starting, describe the result in terms that another person could check without reading the agent’s internal trace.
Weak expectation:
The agent updates the page.
Strong expectation:
After completion, an unauthenticated visitor can open
https://example.test/status and see the heading "Service status"
and the new sentence "Maintenance ends at 18:00 UTC".
For an email task, define the recipient, subject, and a distinctive body phrase. For a record update, define the record identifier and the exact field value. For a public page, define the URL and the text or visual element that must be visible.
2. Capture the starting state
Check the target before asking the agent to act. This prevents an existing result from being mistaken for a new one.
Useful starting-state evidence includes:
- a screenshot showing the old page or record;
- the current value copied into a private test note;
- an HTTP response or page source saved for comparison;
- the absence of a message in the sent-mail folder.
Do not put passwords, access tokens, private customer information, or personal addresses into the article, test notes, or commands.
3. Ask the agent to perform the task
Give the agent a precise target and ask it to report the identifiers it received or created. Examples include a page URL, message ID, ticket number, commit hash, or record ID.
Those identifiers are useful for investigation, but they are not final proof. Keep them as pointers to the external system that you will inspect next.
4. Verify through an independent surface
Use a surface that reflects the result from the user’s point of view. Prefer a live page, a recipient-visible mailbox, a public profile, or a read-only API query over the agent’s own summary.
Case A: verify a live website
Open the exact production or public URL in a new session. If the page is meant to be public, test it while logged out or in a private browsing window.
curl -L --fail --silent --show-error https://example.test/status \
| grep -F "Maintenance ends at 18:00 UTC"
A successful command here means the expected text appeared in the downloaded response. It does not prove that every browser sees the same cached or rendered result. For JavaScript-heavy pages, also inspect the page in a browser and check the visible text.
Record:
- the URL checked;
- whether authentication was enabled;
- the observed text or element;
- the time of the check;
- any cache, redirect, or rendering issue.
Case B: verify sent mail
Open the sending account’s Sent folder and confirm the message by recipient, subject, and a distinctive body phrase. If possible, confirm delivery from the recipient’s mailbox or a controlled test inbox as well.
Do not treat “the send API returned successfully” as equivalent to delivery. A provider may accept a message for processing, while delivery can later fail, be delayed, or be filtered.
A minimal verification record might look like this:
Expected recipient: test-inbox@example.test
Expected subject: Verification test
Expected marker: AGENT-CHECK-2026-11-16
Observed: message found in Sent folder
Delivery check: not performed
The last line matters. It clearly separates what was checked from what remains unknown.
Case C: verify a public page or profile
Use the public URL, not only the editor or administration screen. Confirm that the content is published, visible without special permissions, and associated with the intended account or site.
If the platform has separate draft, preview, scheduled, and published states, check the state shown to an ordinary visitor. A preview link is not the same as a public page.
5. Compare the observation with the original acceptance condition
Mark each condition as observed, not observed, or unknown. Do not convert an unknown into a pass.
| Condition | Evidence | Status |
|---|---|---|
| Public URL opens | Browser and HTTP check | Observed / not observed |
| Expected text is visible | Rendered page or response body | Observed / not observed |
| Message exists in Sent | Mailbox entry with matching marker | Observed / not observed |
| Recipient received message | Recipient-side mailbox check | Observed / unknown |
6. Preserve enough evidence to repeat the check
Save the URL, query, timestamp, account or environment used, and the observed result. Screenshots can help with visual state; text or API responses can help with exact values.
Evidence should answer three questions:
- What was supposed to change?
- Where did you look?
- What exactly did you observe?
What counts as strong evidence?
Evidence strength depends on how close the check is to the real outcome.
- Strong: the intended public page shows the expected content while logged out.
- Strong: the recipient’s mailbox contains the expected message.
- Useful but incomplete: the sending account’s Sent folder contains the message.
- Useful but incomplete: an API returns a successful request or object ID.
- Weak: the agent says it clicked a button or finished a plan.
- Not evidence of outcome: a local screenshot of an interface before the final save or publish step.
The right level of evidence depends on the consequence of failure. A low-risk personal draft may need only a quick visual check. A customer-facing publication, financial action, or production change needs a stronger read-back and often a second independent check.
Common failure cases
The agent changed a staging environment
The page may look correct, but the public site is unchanged. Verify the hostname, deployment environment, account, and publication status. Avoid relying on a URL copied from the agent if the task specified a different public address.
The page is cached
A browser may show old content even after publication, or one session may show new content while another shows old content. Check from a fresh session, inspect response headers when relevant, and document the cache limitation instead of declaring universal success.
The agent saved a draft
Administration interfaces often make drafts look complete. Verify the public URL while logged out. If no public result exists, the correct status is “draft saved,” not “published.”
The message was accepted but not delivered
A Sent-folder entry verifies that the sending account recorded the message. It does not by itself verify delivery, inbox placement, or that the recipient read it. Use a controlled recipient mailbox or provider delivery status when that distinction matters.
The agent used the wrong target
An agent can successfully update a similarly named page, workspace, or record. Match the observed result to a stable identifier, exact URL, account name, or record ID—not only to a title.
The result disappeared later
A passing check is time-bound. Scheduled jobs, synchronization, moderation, or another deployment can change the result afterward. For important workflows, repeat the check after a defined interval or monitor the target system.
Limitations of external verification
Checking the live system is stronger than trusting a report, but it is not magic. A public page can be visible while an internal workflow is broken. A Sent-folder message can exist while delivery fails. A successful read-back can also be stale if the system has replicas or caches.
State exactly what the check proves. For example:
Verified: public page returned the expected text at 14:32 UTC.
Not verified: search indexing, mobile rendering, and long-term availability.
This wording is more useful than a broad claim that “everything worked.” It gives the next person a clear boundary around the evidence.
A compact checklist
- Define the result a normal user should observe.
- Capture the starting state.
- Run the agent task with a precise target.
- Check the live website, recipient mailbox, public page, or read-only record.
- Compare the observation with every acceptance condition.
- Label each condition observed, not observed, or unknown.
- Record the URL, timestamp, environment, and evidence.
- State what remains outside the check.
Final principle
An agent’s report can tell you what the agent intended, attempted, or inferred. Only an appropriate read-back from the target system can show that the requested result is actually present.
When the task matters, verify the outcome where users will encounter it: the live website, the sent-mail folder and—when necessary—the recipient’s mailbox, or the public page itself.
For related terminology and workflow patterns, see the guides and the glossary.