Web Scout for Affordable Witness

Recently, I was working to develop AI Tooling for my own AI Projects. I like the way how Claude-in-chrome works to automate testing activity on the browser, but the usage cost is real. So, its natural for me as an economic agent to study how it works, what is the undiscovered alternative that more cost efficient and ambitiously could bring more value for AI tooling. Here is the Web Scout, the representation for Affordable Witness. In, simplified version web-scout is a local browser-instrumentation relay for AI coding agents and operators.

https://github.com/gungunfebrianza/web-scout

Web Scout Git Diagram per 21-09-2026

The Load-bearing Triad

Here is the 3 main components :

Live Control (relay.mjs, inject.js)

A hand-rolled WebSocket bridge that dispatches real dom./idb. commands into a live page and returns real results. The agent has actual hands on a real running app, not a simulation of one.

Causal Evidence (session-viz.mjs)

Every action is logged with params/result/ok, then rebuilt into a causality tree (retry chains to the failure it followed, verify chains to the write it checked), a route/page FSM, and a failure heatmap. The system can answer "why" after the fact.

Economized Reads (read-pipeline.mjs, token-estimate.mjs, calibration)

Every read is shaped, "guard, peek, pointer, delta" against a calibrated token budget instead of returned in full, so a caller can re-read state repeatedly without the cost exploding.

Thesis

A browser agent can sustain a long, causally-auditable session only when it can act on a live page, afford to keep re-checking what it just did, and reconstruct why a given check happened, pull any one of those three away and the other two become either unaffordable, unverifiable, or fictional.

The System

Web-scout's real capability is not "an agent can click things" or "an agent's actions are logged" in isolation, it is sustained interactive audit where an agent runs for hundreds of actions against a live app, checks its own work after nearly every write (the causality tree's verifies edges exist because this actually happens), and can still be handed to a human afterward as a reconstruct able causal chain, not a wall of raw JSON. That capability is the product of three systems interlocking. Live Control supplies the actions and their raw results. Economized Reads makes the habit of re-checking affordable, a caller can ask idb.dump again after every write and get a shaped delta instead of the full store, which is what makes constant verification economically sane instead of something an agent is trained to avoid. Causal Evidence takes exactly that stream of cheap, repeated actions and turns it into the retry/verify/route structure that a failure heatmap or a session report can bisect. None of the three is downstream of the other two, each is the precondition the other two are built to exploit.

Interdependence proof

• Remove A (Live Control): there is nothing left to shape or explain. read-pipeline.mjs has no real result to compress, and session-viz.mjs has no real action stream to reconstruct causality from, the system degrades to a static log viewer for actions that never happened.
• Remove B (Causal Evidence): Live Control and Economized Reads still execute and still shape bytes, but the audit collapses into an undifferentiated action list. A retry looks identical to an unrelated failure; a verify-after-write looks identical to an unrelated read. The system still runs, but it can no longer answer "why," which is the entire research claim.
• Remove C (Economized Reads): every idb.dump/dom.query returns in full. The behavior the causality tree depends on, an agent that re-reads state after nearly every write to build verifies edges becomes the single most expensive habit an agent can have, so agents stop doing it under normal token discipline, and the causal graph starves of exactly the edges that made it useful.

Failure mode

Live Control trusts the page's own mutating classification, an unclassified or misclassified command breaks the audit silently, not loudly. An attacker who controls page content can feed a shaped-read caller confident, cheap, wrong deltas, and because the caller never re-fetches the full body (the whole point of C), the error propagates uncaught into the causal record B presents as ground truth.

Open question

Can a read-economy system detect, rather than merely tolerate, its own shaped answers going systematically wrong, i.e. can Economized Reads bound its own distrust rate, instead of leaving that entirely to whatever Causal Evidence happens to reconstruct afterward?