LaVague
Open-source Python framework for building AI web agents that turn natural-language objectives into browser actions.
If you're a developer or QA engineer who is tired of re-writing Playwright selectors every time a page moves a button, LaVague is worth a serious trial. The World Model plus Action Engine split is the real feature here — you state the objective and it emits the Selenium or Playwright code — and LaVague QA turning Gherkin specs into integrated tests is a genuine time saver for test teams. Choose it over hand-coded Selenium or Playwright when your target pages change often; choose hand-coded scripts instead when the flow is fixed and you want zero token spend. Playwright remains the better pick if you want a stable, fully deterministic test suite with no LLM dependency.
Verified 21h ago · liveness 46/100 · cite: rightaichoice.com/tools/lavague
- Developers building custom AI web agents
- QA engineers converting Gherkin specs into tests
- Teams whose target pages change often and break selectors
- Prototyping complex multi-step web interactions
- Non-programmers wanting a no-code automation tool
- Simple single-page scraping that needs no reasoning
- Teams that cannot use Python or a CLI
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip LaVague if you want no-code browser automation or a deterministic test suite with zero LLM spend — it needs Python, an API key, and accepts that model-driven runs can fail on complex objectives.
Every default run calls an LLM API, so you pay per token on top of the free framework — the docs' own examples expect a valid OPENAI_API_KEY in your environment.
LaVague itself is a free, pip-installable open-source framework — there's no seat licence. Your real spend is model usage: a solo developer prototyping with OpenAI or Gemini pays cents per run, while a team benchmarking large test suites across many objectives should budget for token volume, since TokenCounter reports cost but doesn't cap it. Hand-coded Playwright is cheaper at scale precisely because it burns no tokens.
In short
LaVague — Open-source Python framework for building AI web agents that turn natural-language objectives into browser actions. Best for Developers building custom AI web agents, QA engineers converting Gherkin specs into tests, Teams whose target pages change often and break selectors. Free to use.
What people actually say about LaVague — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
1 mentions across 1 source (Hacker News) · researched Jul 3, 2026.
Average across the 1 source that answered — each source counts once, not each post.
- +Open-source and free with modular architecture for custom workflows.
- +Supports multiple LLM backends (OpenAI, Azure, Anthropic, Gemini, Fireworks).
- +World Model and Action Engine separate planning from execution.
- +LaVague QA converts Gherkin specs into automated tests seamlessly.
- +Gradio interface enables rapid prototyping and interactive demos.
- −Sparse community feedback makes reliability assessment difficult.
- −Requires Python knowledge and API key setup for core usage.
- −Early-stage project may have breaking changes or limited documentation.
- −No managed hosting or enterprise support for production use.
- −Default reliance on OpenAI models introduces per-call costs.
- • LLM API usage costs (OpenAI, etc.) for each inference
- • Compute and hosting infrastructure for running agents
Viability Score
How well maintained and how widely used is LaVague? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- World Model converts an objective plus current page state into step-by-step instructions
- Action Engine compiles instructions into executable Selenium or Playwright code
- Three drivers: Selenium Webdriver, Playwright webdriver, and Chrome extension driver
- Configurable LLM backends: OpenAI, Anthropic, Azure, Fireworks, Gemini
- LaVague QA turns Gherkin specs into easy-to-integrate automated tests
- Optional interactive Gradio interface, launched via agent.demo()
- TokenCounter for estimating token usage and costs per run
- Test runner for testing and benchmarking agent performance
- Logging tools and end-to-end debugging tools
- Custom actions to extend agent capabilities
- Built-in contexts for configuring agents easily
- Headless and headed browser execution (headless supported on Selenium and Playwright)
- Iframe handling (supported on Selenium and Playwright; not supported on Chrome extension)
- Multi-tab support (supported on Selenium; marked in progress for Playwright)
- Chrome Extension driver for interactive agent mode
About LaVague
LaVague is an open-source framework for developers who want to build AI Web Agents that automate browser processes for their end users. You give an agent a plain-English objective — the docs use examples like "Print installation steps for Hugging Face's Diffusers library" or "Go on the quicktour of PEFT" — and it generates and performs the browser actions needed to reach it. The architecture has two named pieces: a World Model, which takes your objective plus the current page state and outputs a set of step-by-step instructions, and an Action Engine, which compiles those instructions into executable Selenium or Playwright code. You install it with pip, import WorldModel, ActionEngine and WebAgent, attach a SeleniumDriver (headless or headed), and run agent.get(url) followed by agent.run("your objective"). Model backends are configurable across OpenAI, Anthropic, Azure, Fireworks and Gemini, and you choose from three drivers: a Selenium webdriver, a Playwright webdriver, or a Chrome extension driver. A companion project, LaVague QA, is built on the framework and targets QA engineers specifically, turning Gherkin specs into easy-to-integrate tests. There is an optional interactive Gradio interface, a TokenCounter for estimating token usage and costs, a test runner for benchmarking agents, logging and end-to-end debugging tools, and custom actions to extend what an agent can do. It suits developers and QA engineers who want adaptive automation that tolerates page changes instead of hand-maintained selectors. It is not for non-programmers: there is no no-code surface, and a default OpenAI configuration requires you to set OPENAI_API_KEY in your environment.
Behind the Verdict
LaVague earns its place by attacking the part of browser automation that actually breaks: the selectors. Instead of you maintaining XPath and CSS locators, a World Model reads your objective together with the current page state and emits instructions, and an Action Engine compiles those instructions into Selenium or Playwright code. That's a clean separation, and it's the sort of design you'd hope for from a framework rather than a black-box agent. The supporting tooling is unusually complete for an open-source project at this stage. There's a TokenCounter so you can see what a run costs before it surprises you, a test runner for benchmarking agent performance, logging, end-to-end debugging tools, an optional Gradio interface you can launch straight from a WebAgent with agent.demo(), and a Chrome extension driver for interactive agent mode. Custom actions let you extend what an agent can do beyond its defaults. The docs also publish a driver capability matrix, which is a refreshingly candid touch: headless agents and iframe handling work on Selenium and Playwright, the Chrome extension can't do iframes, and multi-tab support is marked as in-progress for Playwright and coming soon for Selenium. The honest weaknesses come with the design. Default usage relies on an LLM API — the docs' own examples need a valid OPENAI_API_KEY — so costs scale with model usage, and TokenCounter estimates spend but does not cap it. Quality of outcome tracks the underlying model, and complex multi-page objectives can fail. The project describes itself as evolving, and does not guarantee backward compatibility. The Chrome extension driver is also the weakest of the three on features, missing iframe handling entirely. Where it fits: prototyping complex multi-step flows, teams that need automation to survive site changes, and QA groups that want Gherkin specs compiled into tests. Where it doesn't: anything that can't tolerate Python and CLI setup, simple one-page scraping where intelligence is wasted overhead, and production deployments where you haven't budgeted time for monitoring and testing. Compared with hand-written Playwright, LaVague trades determinism and zero token cost for a much higher level of abstraction — a fair trade when the flows are volatile, a poor one when they aren't.
Researching LaVague? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas LaVague actually fits — and what changes day-one when you adopt it.
You pip install lavague, import WorldModel, ActionEngine and WebAgent, attach a SeleniumDriver(headless=False), point it at a docs site with agent.get(), and call agent.run("Go on the quicktour of PEFT") with your OPENAI_API_KEY set.
Outcome: The World Model emits step-by-step instructions and the Action Engine compiles them into Selenium code and executes them, giving you a working agent you can then inspect with the logging and debugging tools.
You use LaVague QA, the project built on the LaVague framework, to turn your existing Gherkin specs into easy-to-integrate tests instead of hand-writing selectors for each step.
Outcome: Your test suite is generated from the specs you already maintain, and the test runner lets you benchmark how reliably the agents perform across runs.
You replace brittle hand-written locators with LaVague agents and extend behaviour with custom actions where the defaults aren't enough, choosing between the Selenium, Playwright and Chrome extension drivers based on which features you need.
Outcome: Automation survives page layout changes without a rewrite, at the cost of per-run token spend you track with the TokenCounter.
Use Cases
- Build a web agent that extracts installation steps from a documentation page
- Automate filling out job application forms across multiple websites
- Navigate through Notion to retrieve a specific page
- Book medical appointments through a web portal
- Run bulk data-entry tasks from a spreadsheet into a web interface
- Translate Gherkin specs into runnable tests with LaVague QA
Models Under the Hood
as of 2026-09-29
Limitations
- Default usage runs on an LLM API, so you need an API key (the docs' examples use OpenAI and expect OPENAI_API_KEY in your environment) and you pay for token usage.
- Agent performance depends on the underlying model, and complex or multi-page objectives can fail.
- TokenCounter estimates token usage and cost but does not cap spending.
- The project describes itself as still evolving and does not guarantee backward compatibility.
- The Chrome extension driver is the least capable of the three: it cannot handle iframes and does not support multi-tab or headless operation, while Playwright's headless and multi-tab support are marked in progress.
as of 2026-09-15
Verification history
We have re-verified LaVague 8 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
- — re-checked, vendor evidence unchanged
Showing the 6 most recent of 8 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Where the pricing makes sense
The company stage and team size where LaVague's pricing actually pencils out — and where peers do it cheaper.
LaVague itself is a free, pip-installable open-source framework — there's no seat licence. Your real spend is model usage: a solo developer prototyping with OpenAI or Gemini pays cents per run, while a team benchmarking large test suites across many objectives should budget for token volume, since TokenCounter reports cost but doesn't cap it. Hand-coded Playwright is cheaper at scale precisely because it burns no tokens.
Setup time & first value
How long it actually takes to get something useful out of LaVague — broken out by persona, not the marketing-page minute.
A developer with Python experience can pip install lavague and run the docs' quick-tour example in well under an hour, most of that spent obtaining an API key and setting OPENAI_API_KEY. Getting a first agent working against your own target site is a longer session — expect a few hours once you factor in picking a driver, tuning the model backend, and debugging failed objectives with the logging
Switching to or from LaVague
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From hand-written Selenium scripts: replace selector-based steps with a World Model plus Action Engine agent that emits Selenium code from a natural-language objective.
- →From hand-written Playwright scripts: attach the Playwright webdriver as your driver and keep your existing JS/TS-adjacent flow in Python via the LaVague agent API.
- →From a no-code browser automation tool: rewrite your flows as Python objectives agents, accepting that you now need Python skills and an LLM API key.
- ↗To plain Playwright: capture the actions your agent generates, then freeze them as static scripts if you want deterministic, zero-token tests.
- ↗To plain Selenium: use the generated Selenium code as the basis of a hand-maintained suite once the target flow stops changing.
- ↗To a no-code automation platform: re-create your objectives as visual workflows if your team loses Python or API-key access.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 6 videos for “LaVague”, and we withheld 6: 6 could not be judged, because “LaVague” is a single word that other videos use for other things. We are showing none, because we could not prove any of them are about LaVague.
Official links
Tools that pair well with LaVague
Common stack mates teams adopt alongside LaVague, with the specific reason each pairing earns its keep.
AutoGen
Microsoft's open-source framework for building conversational and event-driven AI agents in Python and .NET.
Stagehand
Open-source SDK for building browser agents with AI primitives (Act, Extract, Observe, Agent) plus Playwright-style controls in TypeScript, Python, and Go.
Mastra
Open-source TypeScript framework for building durable AI agents and workflows, with a hosted platform for observability and cloud deployment.
Featured Head-to-Head Comparisons
Lavague vs Presto Voice
Choose Presto Voice if you're a QSR chain needing proven drive-thru automation with upselling and ROI metrics; it's enterprise-grade but requires sales contact. Choose LaVague if you're a developer wanting a free, open-source framework to build custom AI web agents for browser automation, but it demands coding skills and is not for non-programmers.
Lavague vs Locus Robotics
These tools solve entirely different problems: Locus Robotics optimizes physical warehouse fulfillment with robots, while LaVague automates browser tasks via AI agents. Choose Locus if you need to boost picking productivity 2-3x in a high-volume warehouse; choose LaVague if you're a developer building custom web automation scripts. No direct competition.
Lavague vs Truleo
Truleo and LaVague serve entirely different worlds: Truleo is a specialized, paid intelligence platform for law enforcement connecting siloed data (RMS, jail calls, BWC) to generate leads and reduce report writing time. LaVague is a free, open-source framework for developers to build AI web agents that automate browser tasks. Choose Truleo if you're a police agency needing operational intelligence; choose LaVague if you're a developer automating web interactions.
Alternatives to LaVague
View all
Frequently Asked Questions
Best-of guides
Used LaVague? Help shape our editorial sentiment research.