What Is Computer Use Infrastructure for AI Agents?
EVIDIQ Operator is EVIDIQ's computer use for AI agents stack: an MCP server that turns natural-language goals into real browser actions — navigate, click, type, login, fill forms, extract data — running on a real headless browser instead of faking a DOM or relying on a screenshot-only loop, paid per call over x402 on X Layer.
Most "computer use" demos you've seen are messy. The agent takes a screenshot, asks a vision model what to do, clicks somewhere wrong, screenshots again, retries. Sometimes it works. Often it doesn't. And almost none of it is attestable — there's no signed receipt for what the agent actually did on the page.
We built Operator to be different. It's an MCP service at EVIDIQ Operator docs that exposes real browser actions — the kind you'd script in Playwright, except you tell it what you want in natural language and it plans the steps. Each call is metered on x402 (USDT0 on X Layer), every trace is signed, and the same plan produces the same result every time you re-run it.
The short version: when an agent needs computer use for AI agents — log into a vendor portal, pull an invoice, scrape a table behind a login wall — it pays Operator per task instead of building its own Playwright wrapper, managing cookies, and debugging headless chrome in a container.
Seven Paid Tools That Cover a Real Workflow
Operator exposes seven paid tools plus a few free helpers. The free helpers do exactly what an agent needs before it commits to a paid call: figure out whether the target is even reachable, what capabilities the service has, what the call will cost, and whether the service is healthy. Cheap asks first. Pay only when you're actually going to drive something. This split is what makes computer use for AI agents practical at scale — an agent can scout a target, price a run, then commit.
The seven paid tools:
- browser_task — the broad one. Pass a natural-language goal ("download last month's invoice from the portal") and Operator plans and executes a multi-step run.
- login_and_extract — handle credentials and a target URL, get structured data back without the agent ever touching the cookies or session state.
- fill_form — drives a real form with real submissions. Useful for KYC flows, support tickets, vendor onboarding.
- download_document — pulls a specific file (PDF, CSV, XLSX) and returns it as a hash-linked reference. Notary proof lands automatically.
- navigate — primitive. Go to a URL, get a snapshot back (DOM, console, network). The agent decides what to do next.
- screenshot — yes, screenshots are still a tool. But they're one tool, not the whole loop.
- multi_step_workflow — composed of the above, with retry rules and explicit checkpoints. Logs into each step.
A typical call flow looks like this: the agent hits health, then estimate_cost, then browser_task (or one of the more specific tools), and the receipt comes back via EVIDIQ Notary docs — signed, hash-anchored, ready to log into your own audit trail.
The four free helpers — capabilities, supported_targets, estimate_cost, and health — are list-free at the MCP layer and exist specifically to be called before a paid run.
Who Plans Each Action — and Where It Runs
Here's where it gets interesting. Planning happens off the agent's own loop. Operator's planner is GPT-5.6-Terra, running on 0G Compute — and that choice matters for two reasons.
First, the agent isn't guessing. Every step in a multi-step workflow is proposed by the model with a structured reasoning trace, then executed deterministically in a real headless browser. The trace is part of the receipt. If the agent told you "I logged in, opened Settings, clicked Billing, exported the CSV," you can re-fetch the trace and verify the DOM transitions that actually happened. That's not a screenshot-only story — it's an attested story.
Second, the compute side is auditable. 0G Compute records the provider address and request id, which means the planner itself can be checked: did the same model serve this request? was it inside a TEE? EVIDIQ exposes those signals so a downstream agent can reason about the planner it just trusted.
We chose GPT-5.6-Terra after benchmarking three plausible planners on a 47-step workflow suite. Anything weaker hallucinated clicks on table headers. Anything dumber couldn't hold the page state across a login. Terra shipped with the cleanest failure modes — which, for an autonomy tool, is what you actually care about.
The split between "planner proposes, executor drives" also lets us cache page semantics. If your agent ran navigate("https://vendor.example/dashboard") an hour ago, the next call doesn't have to reload the world. Computer use for AI agents only gets reliable when the planning side is itself verifiable — that's why the recipe is what it is. The result: cheaper estimates, faster retries, and a real audit trail of the page states the agent visited.
Operator Next to the Rest of the EVIDIQ Fleet
Operator is the muscle. It's not the whole family. The four EVIDIQ services sit under one identity, one x402 meter, one reputation trail:
- Sentinel — run EVIDIQ Sentinel docs before you drive a site. It probes the target for reachability, TLS, and whether it serves a machine-readable skill or MCP surface. If Sentinel says the site is sketchy, Operator can refuse to drive it. That's the gate.
- Operator — what you're reading now. Plans and executes browser work. Records a Notary receipt for every run.
- Notary — every Operator run produces a signed receipt pointing back to EVIDIQ Notary docs. Hash, timestamp, evidence. You don't need Operator to verify Notary output — anyone can re-fetch and re-hash.
- Redact — the tool most people forget they need. If
login_and_extractreturns a chunk of vendor data, Redact strips PII before it leaves. Same x402 meter. Same family.
All four are paid per call over the same x402 meter (USDT0 on X Layer). The deterministic scoring formula in Sentinel (identity*0.3 + capability*0.3 + reputation*0.2 + (100-risk)*0.2) is the same one you'd feed Operator results back into, so the operator's own behavior over time becomes a reputation signal for the calling agent.
Worth noting: the same trace format that makes Operator attestable also feeds Redact's redaction decisions and Sentinel's reputation scoring. We're building the trust layer as data plumbing, not as marketing — if you've read the EVIDIQ docs, you've seen how each piece hands off evidence to the next.
