github.com/Autonoma-AI/autonoma @main

End-to-end tests that write themselves, run themselves, and review your pull requests.

Connect a repository. Every PR gets a live preview environment, an AI agent that exercises your app in a real browser, and a review comment that says what broke - with a video, a screenshot, and the line of code that caused it.

Website · Docs · Discord · Local setup · Contributing

What is Autonoma?

Autonoma is an agentic end-to-end testing platform for web applications. You don't write test scripts and you don't maintain selectors. Autonoma reads your codebase, generates a suite of natural-language tests, and runs them against a fresh preview deployment of every pull request. An AI agent drives a real browser: it looks at the screen, decides what to click, asserts what it sees, and heals itself when your UI moves.

When something breaks, you get more than a red check. Autonoma reviews the run and opens an issue on the PR: what you expected, what actually happened, the screenshot and video of the moment it failed, and the code it suspects.

How it works

Every pull request runs the same loop:

1. Pull request - you open a PR, or push a commit to one.
2. Preview environment - Autonoma builds an isolated, full-stack preview of your app for that PR and gives it a live URL.
3. Seed data - the Environment Factory creates fresh, isolated test data, so every run starts from a known state.
4. Run tests - the agent exercises the app in a real browser, one natural-language test at a time.
5. Review - Autonoma reviews each run, separates real bugs from flaky infrastructure, and comments the result on the PR.

When the PR closes, the preview environment and its data are torn down automatically.

What you set up

Three pieces, in order. The first one alone gets you live.

# Generate a test suite for the repo you are standing in
AUTONOMA_API_TOKEN=<api-token> AUTONOMA_GENERATION_ID=<generation-id> npx @autonoma-ai/planner@latest

Tests are plain Markdown with YAML frontmatter. The agent works out how to run them:

---
title: "Checkout completes with a saved card"
description: "Verify a returning customer can place an order with a saved card"
intent: "Placing an order with a saved card creates the order and shows its number"
criticality: critical
scenario: standard
flow: "Checkout"
verification: "Open Order history, assert the new order number is listed"
---

Open the cart, go to checkout, pick the saved Visa ending in 4242,
place the order, and confirm the order number appears.

Running it locally

Prerequisites

• Node.js >= 24
• pnpm 10.x (corepack enable uses the version pinned in package.json)
• Docker, for PostgreSQL and Redis

Setup

git clone https://github.com/Autonoma-AI/autonoma.git
cd autonoma
pnpm install
docker compose up -d          # PostgreSQL :5432, Redis :6379, Temporal :7233 (UI :8233)
cp .env.example .env
pnpm db:generate && pnpm db:migrate
pnpm dev                      # API on :4000, UI on :3000

At minimum, .env needs:

See .env.example for the full list, grouped by service, and the development setup guide for the long version.

Commands

Repository layout

A pnpm + Turborepo monorepo, ESM-only, TypeScript on its strictest settings.

apps/
  api/           Hono + tRPC API server
  ui/            React 19 + Vite SPA
  cli/           @autonoma-ai/planner - the test-planner CLI
  previewkit/    Per-PR preview environment builder and deployer
  engine-web/    Playwright-based web test execution
  engine-mobile/ Appium-based mobile test execution
  workers/       Temporal workers (web, diffs, general)
  docs/          Astro Starlight documentation site

packages/
  engine/        Platform-agnostic execution agent and command system
  agent-core/    Agent loop primitives
  ai/            Model registry and structured generation (sharp-free)
  visual-ai/     Screenshot-driven checkers, point and object detection
  diffs/         PR diff analysis
  scenario/      Environment Factory protocol and test-data scenarios
  checkpoint/    Per-commit run state
  db/            Prisma schema and generated client
  types/         Shared Zod schemas and TypeScript types
  blacklight/    Shared UI component library
  workflow/      Temporal workflow definitions

Most packages carry their own README. packages/engine and packages/ai go deepest on the agent and the AI primitives, and the architecture overview explains how the pieces fit together.

Execution flow

Natural-language test
        |
   Execution agent (packages/engine)
        |
   Screenshot -> model decides an action -> execute -> record the step
        |                                        |
   Point detection (packages/visual-ai)    Platform drivers
        |                                   |          |
   Gemini / Moondream                  Playwright    Appium
                                         (web)      (mobile)

Tech stack

Runtime Node.js 24, ESM-only · Monorepo pnpm workspaces + Turborepo · Language TypeScript, strictest config · API Hono + tRPC · Frontend React 19, Vite, TanStack Router, Tailwind CSS v4 · Database PostgreSQL + Prisma · Cache and locking Redis · AI Gemini, Groq, OpenRouter via the Vercel AI SDK · Browser Playwright · Mobile Appium · Orchestration Temporal on Kubernetes · Observability Sentry + PostHog

Contributing

Bug reports, feature requests, and pull requests are all welcome - start with CONTRIBUTING.md and the Code of Conduct. To report a security issue, see SECURITY.md.

Come say hello on Discord.

License

Business Source License 1.1. Read it, modify it, self-host it, and run it in production - the one thing you may not do is sell it as a competing commercial service. It converts to Apache 2.0 on March 23, 2028. See LICENSE.md for the exact terms.