4 min readfeature
The browser autonomy round: dogfooding the browser until it taught us back
One hostile checkout page, five blind runs, two real defects found and fixed in-round, and the first receipts of a browser tool that remembers what broke.
- #browser
- #benchmarks
- #memory
We just spent a round using Unown's browser tool the way we tell everyone else to: as a first-class operating environment. Not E2E tests — real product work. The browser audited our own landing page like a first-time visitor, filed GitHub issues, read MDN to learn an API it had never touched, monitored three competitors' release feeds, and fought a checkout page specifically designed to derail it. Every fallback, failure and recovery is receipted. This post is what the round taught us.
The hostile checkout page
We built a fixture with nine planted failure classes: a buy button whose id
changes on every page load, a newsletter modal that interrupts 1.5 seconds
in (and re-opens if you fall for the discount), a cookie banner, an
arm-race that punishes fast clicks by resetting the cart, content that
arrives two seconds late, a variant picker sealed inside an open shadow
root, an address form inside a same-origin iframe, and a native confirm()
dialog guarding the final click.
The agent completed it blind — goal stated, trap list withheld — in 32 seconds on its first try, and five for five across the round. The native dialog was the only trap that ever landed: it auto-dismissed and silently cancelled the order, and the agent recovered by arming a dialog answer and re-clicking. Every run. Which is the interesting part: the lesson went into project memory via AutoDream, the next run recalled it (the recovery got directer — no exploration, just re-arm and click) but still did not pre-arm. Knowing is not applying. That gap is now issue #45: browser lessons belong at the tool call, not just in the session-start memory dump.
The two real defects
Dogfooding against our own demo app found better bugs than the fixture did.
The /demo kanban's "+" button was dead — for the agent, for a second
browser stack, for anyone. Forty agent-turns of investigation, an
independent reproduction, and a localhost-versus-IP-literal diff later, the
dev log confessed: Next 16 blocks "cross-origin" dev resources from origins
it doesn't recognize, and 127.0.0.1 — the address every agent and curl
reaches for first — wasn't in allowedDevOrigins. The page rendered, no
console error surfaced, and client hydration silently never happened.
Production was never affected; our e2e lane boots a production build, which
is exactly why CI could never catch it. The fix is one line, pinned by two
unit tests and a troubleshooting row with the real log line.
The second one was worse because it was silent: fill_form against a
same-origin iframe reported success while the values evaporated — the fill
landed in a frame document that was still loading, and when the frame
finished, the values went with it. We reproduced it standalone, root-caused
it (the readiness gate only checked the top document), and fixed it with
two layers: navigate now waits for same-origin frames — including the
about:blank window before a frame's real document commits — and every fill
is verified after it lands, re-filled once on mismatch, and fails loudly
instead of lying. The live test suite pins both layers against a real
Chromium with a fixture that wipes its own value exactly once, 120 ms after
your first keystroke. (Issue #43
has the full story; #44 covers the smaller jpeg-under-a-.png-name quirk.)
The part where the agent remembered
The round's best receipt isn't a bug — it's the learning loop closing on browser work by itself. Three session notes went to the engine; AutoDream consolidated them into project memory within the hour, unprompted, and it even caught the jpeg-extension quirk from the transcripts alone. A dream later carried the exact dialog procedure. When a dream render then pruned a line our own landing page quotes — reddening a CI gate — the repo's precedent (a hand-restored manual note from an earlier round) was already there, waiting. The memory file is a living document now, with receipts in both directions: what it learned from us, what it taught us.
Nobody in the browser-agent category persists a memory of failed actions between sessions — we checked all eight major systems, and the closest anyone comes is caching what succeeded. That axis is open. Our round's verdict on it: recall works, proactive application is the next mile.
Receipts
- The session log — every checkpoint, finding and fix, resumable.
- The competitor research — eight systems on the round's axes, every claim URL-cited.
- The benchmark receipts — cold/warm numbers, five stress runs, zero interventions, honest nulls.
- The CHANGELOG's
[Unreleased]section — the two in-round fixes.
Spotted something wrong or worth adding? The record is the repo — open an issue.