You vibe code.
We test everything.

The first wave of AI-powered QA tools inherited a pricing model from the era of hosted language models: every action an agent takes is a metered API call. That single design decision produces three structural problems no amount of product polish can fix.

Costs scale against coverage. Cloud AI-QA platforms commonly start around $500/month for roughly a thousand test executions, and bring-your-own-key tools simply move the same bill to your OpenAI or Anthropic account. Because each run has a marginal cost, the rational response is to test less — the opposite of what a fast-shipping team needs.

Test execution is stateless. Most tools begin each run with no memory of prior runs: which flows broke last month, which forms are fragile, what changed. Coverage never compounds.

And a single agent cannot find concurrency bugs at all. One agent acting sequentially cannot reproduce inventory oversell, double-booking, coupon reuse, race conditions or session-token bleed. These are not load problems — the server stays up. They are correctness failures in business logic under concurrency.

Open-weight vision-language models in the 7B–32B range now ground GUI elements accurately enough to drive a browser reliably. Feeding the accessibility tree instead of raw HTML keeps context small, which makes quantized models on consumer hardware a practical substrate rather than a compromise.

The hardware is already installed. A large share of developers own a discrete GPU or an Apple Silicon machine with substantial unified memory — bought for gaming, video work or local model experiments — and it sits idle most of the day.

The consequence is a different cost structure, not merely a cheaper one. Inference on hardware the user already owns makes the marginal cost of a run zero, keeps test data on the machine, and leaves the vendor with no inference bill to pass through. A competitor whose cost base is hosted-LLM inference cannot match that without dismantling its own business model.

Whiskers explores methodically and surfaces UX friction. Shadow attacks edge cases — blank inputs, rapid clicks, back-button abuse. Paws fat-fingers interactions into double-submits. Tiger pushes parallelism until business logic cracks.

Behavioural diversity broadens the paths walked through an app, but the decisive argument for multiple agents is interaction. Running several cats at once creates cross-agent interference: two checkouts racing for the last unit of stock, two edits landing on the same row, two logins resolving against the same session store. That interference is the only reliable way to surface concurrency-class defects.

Speed is the second benefit: a pride finishes a full sweep in minutes rather than hours, which is what makes autonomous exploration viable as a CI gate instead of an overnight job.

Stateless testing throws away the most valuable artifact QA produces: knowledge about where a specific application tends to break.

The Brain persists a session log of what each agent did, a synthesized map of fragile zones ranked by historical failure density, and a record of how the app’s surface changed between runs. Later sessions bias exploration toward regions with a high prior probability of failure while still reserving effort for unexplored areas.

The tenth run is therefore materially better than the first, and accumulated history becomes a switching cost a stateless cloud tool cannot replicate by matching features.

Exposing Clikiti as a Model Context Protocol server lets the coding assistant already in the developer’s editor request a run and read back structured results. QA moves inside the authoring loop instead of sitting behind a separate dashboard.

Every finding ships with a short screen recording of the exact sequence that produced it, plus the agent’s stated intent at each step. A reproducible clip turns an ambiguous bug report into an actionable one — which is where most human time in QA is actually spent.