Bug0 QA Agent: Open-Source AI Browser Tests — With a Two-Year License Catch

On October 29, 2026, coverage from InfoQ — picked up by Wisevoter and the AI agent trackers — put a name on a new entry in the agentic testing race: Bug0 QA Agent, an open-source Playwright library from Linearbytes (the company behind bug0.com) that turns plain-English test steps into browser tests. The pitch is simple: describe a user flow in natural language, and AI models execute it through Playwright, re-verify every assertion with a three-model consensus, and heal the test when the UI changes underneath it.

The code is real — I read the README in full, and the repo at github.com/bug0inc/qa-agent is public and active. But the two catches that matter are in the fine print. The library is free under the Functional Source License 1.1, which forbids competing with Linearbytes' own products until the license converts to Apache 2.0 on its second anniversary. And the README's Quick Start points at an npm package, @bug0/ai, that was not on the npm registry when I checked. Here is what the library actually does, what it costs to run, and where the honest limits are.

Quick answer

• What: Bug0 QA Agent is an open-source Playwright library that executes natural-language browser steps — "add the Acme Circles T-Shirt to the cart" — and verifies every assertion through a consensus of Claude, Gemini, and an arbiter model.
• Cost: The library is free under FSL-1.1, but you supply your own model keys: at least one Anthropic and one Google key for consensus, plus OpenAI if you want the visual CUA mode. Model spend lands on your bill.
• Catch: The license bars "Competing Use" — you may not use the code to build a product that substitutes for Bug0 or its Bug0 Studio service. That restriction lifts on the second anniversary, when the license converts to Apache 2.0.
• Status: 1,293 GitHub stars as of October 30, last commit September 25. The October 29 date is the coverage date per InfoQ/Wisevoter, not a code release — treat it as an announcement milestone, not a version launch.

What Bug0 QA Agent actually is

Most browser test suites die the same way: a selector breaks, a locator goes stale, and someone spends a morning rewriting steps that describe the same flow. Bug0 AI attacks that failure mode directly. Instead of selectors, you write steps as plain-English descriptions inside a Playwright test file. The README's own framing is telling: when a background coding agent works your backlog, a Bug0 AI suite "slots in as exactly that check" before a human reviews the pull request — the same pre-merge verification gap covered in our roundup of the 7 best AI coding agents in 2026.

await runSteps({
  page,
  userFlow: "Add product to cart",
  steps: [
    { description: "Navigate to https://demo.vercel.store" },
    { description: "Click Acme Circles T-Shirt" },
    { description: "Select color", data: { value: "White" } },
    { description: "Add to cart", waitUntil: "My Cart is visible" },
  ],
  assertions: [{ assertion: "You can see My Cart with Acme Circles T-Shirt" }],
  test,
  expect
});

The library maps each description onto the page using ARIA accessibility snapshots by default, executes the action through Playwright, and then does the part that separates it from a thin wrapper: every assertion is checked by two models in parallel — Claude as primary, Gemini as secondary — and if they disagree, a third model (Gemini 3.1 Pro) arbitrates. The default consensus policy calls the arbiter on disagreement; a stricter fail-on-disagreement policy is one configuration line away. That three-model design is the source of Wisevoter's "consensus from three LLMs" line, and the README documents it explicitly — this is the library's own architecture, not marketing gloss.

The second engine underneath is Redis-based step caching: compiled browser operations are cached so routine re-runs don't pay model costs for steps the library has already learned, with AI fallback and automatic self-healing when a cached step fails. There is also a pluggable email extraction interface with a built-in provider, aimed at flows that need OTP codes or magic links — the kind of adapter that usually forces teams to hand-roll their own test infrastructure.

The visual mode: CUA for when snapshots aren't enough

ARIA snapshots break on canvas-heavy or highly dynamic interfaces. For those, Bug0 AI ships a CUA mode that opts into OpenAI's computer-use agent (the README names gpt-5.5 plus the built-in computer tool) for screenshot-driven automation. Three honest caveats from the README itself: the CUA model is currently locked and not user-configurable, Redis step caching is skipped in CUA mode because coordinate actions don't port across viewport sizes, and gateway routing (Vercel, OpenRouter, Cloudflare) is incompatible — CUA requires direct OpenAI access. That last point matters for cost planning: CUA runs bill to your OpenAI key with no gateway discount in the middle.

There is also a video-assertion mode for ephemeral UI — toasts and snackbars a single screenshot can miss. It records the full step run and evaluates the assertion against the whole video, but it runs only through Gemini (Claude doesn't accept video), so you must hold a Google API key even if the rest of your stack runs through a gateway.

The license: free, until you compete

This is the section to read twice. Bug0 AI is licensed under FSL-1.1-ALv2 — Functional Source License version 1.1, with Apache 2.0 as the future license. The license grant covers use, modification, and redistribution for any "Permitted Purpose," which the text defines as any purpose other than a Competing Use: making the software available to others in a commercial product or service that substitutes for the software, substitutes for another Linearbytes product built on it, or offers the same or substantially similar functionality.

The license notice names the protected product explicitly: "LinearBytes Inc. offers Bug0 Studio, a commercial product and service that uses this Software. Bug0 Studio and any successor products or services are covered under the Competing Use restrictions of this license." And the restriction is time-boxed, not permanent: the license "irrevocably" grants an Apache 2.0 license effective on the second anniversary of the date the software is made available. After that date, the competing-use restriction is gone.

Two clarifications worth making, because the launch coverage blurred them. First, this is not a "non-compete" on you as a developer — it restricts redistributing the software in a competing commercial product or service. Internal use, non-commercial research, and education are explicitly permitted purposes. Second, the practical effect: you can run Bug0 AI against your own product's test suite today without paying Linearbytes anything, but you cannot take their engine and sell a rival managed-testing service with it. That is a deliberate funnel into their paid product, which is exactly what the next section covers.

Pricing: the free library vs the $2,500 service

Linearbytes sells the same engine two ways. The library costs nothing to download, but the operating costs are yours: at minimum one Anthropic and one Google API key for consensus (the README requires both), an OpenAI key if you want CUA mode, and whatever Redis and CI infrastructure you run. There is no published per-run cost — your model bill is whatever your providers charge. Gateways can simplify the key management: Vercel AI Gateway, OpenRouter, and OpenCode Zen act as resellers (you pay the gateway), while Cloudflare AI Gateway is a proxy (you still need your own provider keys alongside it).

The managed tier's fine print, from bug0.com's own pages: the $2,500 covers the dedicated engineer and up to 500 user flows; beyond 500, pricing scales pro rata under the same flat model. The company claims 90% self-healing when the UI changes and "100% critical flow coverage" within the first week or two — both are company-reported figures with no independent evaluation published, so treat them as the vendor's case, not verified benchmarks. What is verifiable is the billing structure: one flat subscription, explicitly not per test run, per AI credit, per browser minute, or per human hour.

Pros and cons

Pros: the consensus-assertion design is a genuinely different answer to flaky AI assertions — two models plus an arbiter is harder to fool than a single screenshot check; Redis caching attacks the real cost center (repeated model calls on stable flows); the email-extraction interface covers OTP/magic-link flows most frameworks leave to you; the source is public, so the test logic is auditable rather than a black box; and the managed tier's flat pricing is refreshingly simple next to per-seat, per-run testing tools.

Cons: the FSL-1.1 competing-use restriction is a real constraint for anyone who might productize on top of it — read the license before you build; the README's npm install @bug0/ai pointed at a package that was not on the npm registry when I checked (the registry has @bug0/sdk and @bug0/cli from April, not @bug0/ai), so install from the GitHub repo and verify the package name; multi-model consensus means multi-vendor bills by design; and 1,293 stars is attention, not evidence — no independent benchmark of the agent's accuracy exists yet.

How it stacks up

The honest comparison is not against other libraries but against the two ways of buying the same engine — plus the DIY baseline most teams actually have:

Where Bug0 AI earns its place is the middle ground: teams that want AI-driven regression testing without hiring a vendor's engineer, and without hand-rolling consensus, caching, and email adapters themselves. Where it doesn't fit: teams that need a fully permissive license today (the FSL competing-use clause rules out productizing on it), and teams whose flows are simple enough that plain Playwright already holds.

What we couldn't verify

Three things to keep on the watch list. First, the install path: the README's Quick Start says npm install @bug0/ai, but the npm registry returned "not found" for that package name on October 30 — only the older @bug0/sdk and @bug0/cli packages exist under the @bug0 scope. Clone the repo and check for install instructions there rather than trusting the npm command blindly. Second, the timeline: the repository's last commit was September 25, 2026, so the "October 29 release" in the coverage is an announcement milestone per InfoQ and Wisevoter, not a code drop — don't read a version launch into it. Third, performance: every accuracy and cost figure attached to this library is either the vendor's own design documentation or launch coverage. No independent lab has benchmarked its consensus accuracy, its cache hit rates, or its real per-run cost. Until someone does, the honest position is that the architecture is sound on paper and unproven in the field.

FAQ

Is Bug0 QA Agent really free? The library is free to download and use under the Functional Source License 1.1. The costs you actually pay are your own: Anthropic and Google API keys at minimum, plus infrastructure. There is no license fee and no per-seat charge for the library itself.

Can I use it commercially? Yes for internal commercial use — testing your own product's flows is an explicitly permitted purpose. What you may not do is use the code in a commercial product or service that competes with Bug0's offerings (notably Bug0 Studio), until the license converts to Apache 2.0 on its second anniversary.

How is this different from Bug0's managed service? Same engine, different operator. The library runs in your CI on your bills; Bug0 Managed puts a dedicated Linearbytes QA engineer on your account from $2,500 a month with unlimited runs and up to 500 user flows, on a flat month-to-month subscription.

Does it work with my existing Playwright tests? It is a Playwright library, not a replacement for Playwright — you install it inside a Playwright project (the README starts from npm init playwright@latest) and call runSteps from your spec files. Existing selector-based tests keep working alongside it.

Which models do I need? At least one Anthropic and one Google model for the multi-model consensus. OpenAI's computer-use model is needed only for CUA mode, and video assertions need a Google key regardless of your gateway setup.

Key takeaways

• Bug0 QA Agent is Linearbytes' open-source Playwright library for AI regression testing: natural-language steps, Redis-cached execution, and assertions verified by Claude-plus-Gemini consensus with an arbiter on disagreement.
• The library is free under FSL-1.1, but the license bars competing commercial use until it converts to Apache 2.0 on its second anniversary — and names Bug0 Studio as the protected product.
• Real running costs are your own model bills: Anthropic + Google keys are required, OpenAI for CUA mode, and there is no published per-run price.
• The README's npm install @bug0/ai pointed at a package missing from the npm registry on October 30 — install from the GitHub repo and verify before you script it into CI.
• The same engine is sold as a managed service from $2,500 a month flat — no per-test, per-credit, or per-hour billing — with a dedicated engineer in the loop.

As of October 30, 2026, Bug0 QA Agent is one of the more architecturally serious open-source entries in agentic testing: the consensus design and the cache-first execution model address the two reasons AI test suites usually fail — wrong verdicts and runaway model bills. The license is the real price of admission, and it is time-boxed. Watch for an independent benchmark and a working npm package before you bet a release pipeline on it.