The Best Monkey Testing Tools in 2026 (Free, Open Source and AI)

Search for monkey testing tools and you get a mess: Android SDK utilities from 2010, a JavaScript library that unleashes cartoon gremlins on your page, a Netflix project that kills servers and has nothing to do with UI testing, and a dozen AI testing startups that use the word “monkey” nowhere on their site.

They are all solving different problems. This is a map of the actual landscape, organised by what you are trying to test, with an honest note on what each tool will and will not find.

For the underlying concepts — dumb vs smart vs brilliant monkeys, and how monkey testing differs from fuzzing — start with our guide to monkey testing. This page is about the tools.

Quick comparison

Tool	Target	Tier	Licence / cost	Best at
MonkeyTest Core	Web	Brilliant	Free, AGPL-3.0	Finding broken user journeys on any site
Gremlins.js	Web	Smart	Free, MIT	Cheap in-browser stress testing
Playwright / Puppeteer (DIY)	Web	Dumb → smart	Free	Full control, if you’ll maintain it
Android Exerciser Monkey	Android	Dumb	Free, in the SDK	Crashes and ANRs under input storms
Firebase Test Lab Robo	Android / iOS	Smart	Free tier, then paid	Automated UI crawl on real devices
Appium (DIY)	Mobile	Dumb → smart	Free, Apache-2.0	Cross-platform random walks
AFL++ / libFuzzer	Native code	Fuzzing	Free	Memory-safety bugs in parsers
Schemathesis	APIs	Fuzzing	Free	Contract violations from an OpenAPI spec
Chaos Monkey / LitmusChaos	Infrastructure	Chaos	Free	Resilience, not UI testing

Web monkey testing tools

MonkeyTest Core

Ours, so treat the enthusiasm accordingly — but it is genuinely free and genuinely open source, so you can check the claims yourself.

MonkeyTest Core is a brilliant-tier agent: it drives a real Chromium browser through your site, uses an LLM to work out what a user would actually try on each page, executes those flows, and reports the bugs with per-step screenshots. There are no fixtures, selectors, page objects or recorders to write.

npm install -g @mtai/monkeytest-core
npx playwright install chromium
export GEMINI_API_KEY=...
monkeytest run https://example.com

The distinguishing feature is that it closes the loop rather than stopping at discovery. Each run writes a stable plan.json you can commit to git; monkeytest rerun re-executes that exact plan after you ship a fix, with no LLM cost for re-planning; and monkeytest diff tells you what was fixed, what is new, and what regressed. Bug fingerprints are stable across runs, which is what makes the comparison meaningful.

• Finds: broken forms, checkout failures, dead-end navigation, JavaScript exceptions, failed network calls, flows that silently do nothing.
• Misses: it is not a load tester, an accessibility auditor, or a security scanner. It also will not beat a hand-written test on a critical path you already know about.
• Cost: free under AGPL-3.0. You pay your own LLM provider for tokens — typically cents per run on a small site. There is also a hosted free tier if you would rather not install anything.
• Where: github.com/monkeytestai/monkeytest-core, docs at docs.monkeytest.ai, or the full overview.

Gremlins.js

The classic browser monkey. You drop it into a page and it releases “gremlins” that click, scroll, type and move the mouse, while “mogwais” watch for errors and slow frames. MIT licensed, no build step, and you can run it straight from a bookmarklet.

It is a smart monkey rather than a dumb one — it targets real DOM elements rather than raw coordinates — but it has no idea what your app is for, so it will not fill a form with valid data or complete a purchase.

• Finds: JavaScript exceptions under load, UI that breaks with rapid interaction, memory pressure.
• Misses: anything behind a login or a form. It will not reach your product.
• Best for: a five-minute smoke test on a page you are actively working on.

Playwright or Puppeteer, hand-rolled

Write a script that enumerates clickable elements, picks one, clicks it, repeats. An afternoon of work gets you a functioning smart monkey with total control over what it does.

The catch is the part nobody budgets for: deciding what counts as a bug. Without goal-directed behaviour you get a stream of “the page changed” events and no way to tell a broken flow from a working one. Most teams that build this end up either adding heuristics until it becomes a maintenance project, or quietly abandoning it.

• Best for: teams with a very specific requirement no off-the-shelf tool covers.
• Worst for: anyone hoping to save time.

Mobile monkey testing tools

Android UI/Application Exerciser Monkey

The original, and still shipped with the Android SDK:

adb shell monkey -p com.your.app -v 500

Five hundred pseudo-random events at your app. It is a pure dumb monkey — random taps, swipes and system events at random coordinates — and it is genuinely useful for exactly one thing: proving your app does not crash under an input storm. Free, zero setup, and reasonable to run in CI on every build.

• Finds: crashes, ANRs, race conditions from rapid input.
• Misses: everything that requires reaching a meaningful state.
• Tip: always pass -p to constrain it to your package, and set a seed with -s so a crash is at least somewhat reproducible.

monkeyrunner

Also from the Android SDK, but scriptable in Jython — you write out an explicit sequence of taps and screenshots. Despite the name it is not really a monkey; it is a low-level scripted automation tool, and it has been superseded by Espresso and UI Automator for most purposes. Worth knowing it exists so you can rule it out.

Firebase Test Lab Robo test

Google’s Robo test crawls your app’s UI automatically on real devices, building a model of the screens as it goes and producing a crawl graph with screenshots and any crashes it hit. It sits squarely in the smart-monkey tier and requires no scripting.

• Finds: crashes, unreachable screens, obvious UI breakage across a device matrix.
• Misses: flows requiring domain-specific input, though you can supply login credentials and seed values.
• Cost: free quota, then per-device-hour pricing.

Appium, hand-rolled

Same trade-off as the Playwright approach, applied to mobile. Appium gives you a cross-platform driver; the random walk and the bug detection are yours to write.

Fuzzing tools (adjacent, often conflated)

Fuzzers push malformed data into a program’s inputs rather than interacting with a UI. Different layer, different bugs, frequently grouped under the same search term.

• AFL++ — the standard coverage-guided fuzzer for native code. Mutates inputs, watches which code paths they reach, and steers toward new coverage. Excellent at finding memory-safety failures in parsers and decoders.
• libFuzzer — in-process, coverage-guided, part of LLVM. You write a small harness function and it does the rest.
• Atheris (Python) and Jazzer (JVM) — the same idea in memory-safe languages, where you are hunting unhandled exceptions and logic errors rather than buffer overflows.
• OSS-Fuzz — Google’s continuous fuzzing service for open-source projects. If you maintain a widely used library, apply.
• Schemathesis and RESTler — API fuzzers that generate requests from an OpenAPI or Swagger spec and check the responses against the contract. The closest thing to monkey testing for a backend, and the fastest win on this list if you have a spec.

Chaos engineering tools (not monkey testing)

Netflix’s Chaos Monkey kills production instances at random to prove the system survives. Simian Army, LitmusChaos, Chaos Mesh and the commercial Gremlin platform extend that to network faults, latency injection, resource exhaustion and zone failures.

These are excellent tools for resilience work and share exactly nothing with UI monkey testing except the primate. If you arrived here looking for chaos engineering, this is your section and you can stop reading.

AI test automation platforms

Worth naming because they crowd the same search results: Mabl, Testim, Functionize, Applitools, QA Wolf, Rainforest QA and similar tools use machine learning to make traditional end-to-end testing less brittle — self-healing selectors, visual diffing, AI-authored test steps.

That is a different job. They make the tests you write more durable; monkey testing finds the bugs on paths you never wrote a test for. Most teams that get serious about quality end up wanting both, and the two do not compete for the same slot in your pipeline.

How to choose

Testing a website and you want results today. Start with an AI agent — it is the only tier that gets past a login and completes a real flow. Our free CLI quickstart takes about sixty seconds, or use the hosted free tier if you would rather not install anything.

Testing a website and you want zero dependencies. Gremlins.js from a bookmarklet. It takes two minutes and will find your unhandled exceptions.

Testing an Android app. adb shell monkey in CI on every build, plus Firebase Robo tests before a release.

Testing a library, parser or protocol. A coverage-guided fuzzer — AFL++ for native code, Atheris or Jazzer otherwise.

Testing an HTTP API with a spec. Schemathesis. Highest ratio of bugs found to effort spent on this entire page.

Testing whether your infrastructure survives failure. Chaos engineering, not monkey testing.

One thing worth saying plainly

Monkey testing at any tier is a complement, not a replacement. It covers the surface area your test suite does not, which is usually most of the application — but it will never give you the guarantee that a deliberate, deterministic test on a critical path gives you.

The right setup for most teams is a handful of solid end-to-end tests on the flows that make money, plus something sweeping continuously across everything else. The tools above are how you get the second half without hiring for it.

If you want to see what the brilliant tier looks like on your own site, MonkeyTest Core is free, open source, and two commands away.