TL;DR
Playwright is a great tool for its job: testing known pages.
Agents work on unknown pages. That's a different job. Structurally different.
Six places where Playwright breaks for agents - and what E2LLM does in each.
Not "Playwright is bad." It has a different purpose.
Playwright is everywhere. Every agent stack stands on it. You hear about it from every direction. In short: if you want agents, you have no choice.
We'll show that you do.
And the pattern is always the same: the agent falls on understanding where to click. The click itself works fine.
Thesis: Playwright answers "how to perform an action" instead of "what is on the page right now." For agents, the second one is what hurts.
Limitation 1: Selectors as a contract with a known page
Playwright: a developer wrote the selector in advance. The page is known. The DOM is stable between runs.
Reality: the page is unknown. CSS-in-JS hashes in class names (.css-1x2b3). A/B tests. Redesigns. The agent has to find the element, not address it.
E2LLM: not addressing. It's reading. A SiFR snapshot of the rendered DOM with salience ranking: the agent sees a list of what's there ([clickable], [fillable], [hoverable]) and picks by meaning, not by a pre-written path. Take any site with cookie banners as an example.
Limitation 2: A11y tree as a page "built to be read"
Playwright (via aria-snapshot/MCP): the page is semantically marked up. Roles, labels, structure.
Reality: the legacy web is not marked up and never will be. Government sites, fintech, retail, manufacturing, any intranet. The vendor is gone, there's no budget, "it works - don't touch it." And div number 72 will happily confirm it is not readable through the tree.
E2LLM: derives perception from the live rendered page - computed styles, real visibility, positions. The page was built to be rendered, and that's enough. What the user sees is what the model sees.
Limitation 3: Snapshot ≠what's on screen
Playwright: DOM/AXTree structures are enough to understand the page.
Reality: a modal covers the button and in the tree both are "clickable." Spinners. Overlays. z-index. Occlusion. AXTree doesn't know what covers what. Benchmarks give a pretty number. But take reality. Tier-2 sites? Tier-3? You get the idea.
E2LLM: z-index, bbox, spatial relations ("X overlaps Y", "X above Y"). The model knows the button is under the modal and closes it first - or just acts in the right layer right away.
Limitation 4: Cost of snapshot and session
Playwright MCP: a full text snapshot after every action. Plus the MCP protocol loads all tool descriptions at session start.
Reality: tens of thousands of tokens of overhead before the first action. Every re-snapshot - thousands more. A long task = context eaten by snapshots, not by work.
E2LLM: 5–15 KB per state instead of 200–400 KB. Session overhead: one compact toolset, then you pay only for what you read.
Limitation 5: Staleness - the world changes between "saw" and "clicked"
Playwright: between snapshot and action the page is the same. The ref is valid. The test is deterministic.
Reality: the page is alive. Lazy loading, a counter that hasn't updated, an element that re-rendered. Element not found - and the agent either dies or starts an expensive loop of blind re-snapshots.
E2LLM: re-reading is cheap, so re-reading is normal. Stale state becomes weather, not failure. Session log from a real run: costco-pantry-run.session.log
Limitation 6: Failure model - "throw an exception to the tester"
Playwright: if something is wrong, the test should fail. A human will read the stack trace.
Reality: an agent doesn't need a stack trace, it needs recovery. What's on the page now, what changed, what's the next step. Playwright doesn't report that - it's not its job.
E2LLM: state diffs, re-read as first class. An error is a reason to re-read, not a reason to die.
Honest boundary
E2LLM does not replace Playwright. For CI tests of your own code, Playwright is the right tool.
E2LLM with SiFR is browser perception for machines that nobody described the page to.
Perception ≠agent. Brains are replaceable. The layer under them is not.
All the agent pain you read in threads ("got stuck", "wrong element", "too expensive") is not click pain. It's reading pain.
Everyone can click. Almost nobody can read.
e2llm
/
e2llm-sifr
Structured browser perception for AI — SiFR turns any live web page into a compact, structured, LLM-readable model.
E2LLM — structured browser perception for AI
E2LLM turns a live web page into SiFR: a compact, structured LLM-readable model of what's on the page, what it means, and what can be done with it. Perception is the product. Action is available when you need it — always explicit, always gated.
Works as a hosted remote MCP server with the AI you already use. There's no local server to run — a browser extension pairs your live browser to the server, so perception and action happen in the real browser you're already signed into.
E2LLM is not an agent
This matters, so it comes first.
An agent decides and acts on its own — it plans, loops, and takes steps toward a goal without you in the path. That autonomy is also its attack surface: an agent runtime that can do anything can be steered into doing anything.
E2LLM…
Top comments (0)