Skip to content
ARTAARTA

ARTA — AI test automation that understands your software

Open source · Apache-2.0

Test automation that understands your software.

ARTA reads your requirements, source code, API specs, and live application behavior — then generates grounded tests, executes them across six runtimes, and reports what your system actually does. AI writes the code now. ARTA is the independent layer that verifies it.

Get startedView on GitHubSee it in action
requirementsJira · OpenAPI · docs
source coderoutes · DTOs · selectors
live behaviorDOM catalog · captured endpoints
arta engine
  1. risk scoring
  2. ATDD design
  3. grounded generation
  4. validation
Playwright UI tests
API tests Newman
k6 · ZAP · Axe · Pytest
Traceability graph
PASSFAILBLOCKED

Why ARTA

Testing that interacts with software is not the same as testing that understands it.

Traditional automation encodes what a human knew about the system on the day the test was written. ARTA regenerates that knowledge from the system itself — and refuses to ship a test it cannot ground in evidence.

Traditional automation

  • Every test is designed and coded by hand
  • Requirements and tests drift apart silently
  • Coverage is whatever got written, not what was needed
  • Selectors and endpoints rot as the app changes
  • QA and development run in separate workflows
  • A red build means “someone go investigate”

With ARTA

  • AI reads requirements and scores risk (probability × impact)
  • AI analyzes source code, API specs, and live app behavior
  • Tests are generated — and validated against what discovery actually found
  • Hallucinated selectors and endpoints are rejected before they ship
  • Every test stays traceable: requirement → scenario → script → result
  • Every failure is classified: sut_regression (your bug) vstest_gen_bug (our bug) vs grounding_blocked

Capabilities

The whole verification loop, not a test-case generator.

generate

AI test generation

Meaningful tests from requirements, source code, API specifications, and discovered application behavior — risk-scored and ATDD-designed, not prompt-and-pray.

ground

Grounding validators

Every generated test is checked against the discovered DOM catalog, captured endpoints, and OpenAPI spec. What can't be grounded is retried with hints, then honestly BLOCKED — never silently shipped.

trace

Requirement traceability

Requirement → acceptance criterion → test → execution → defect, stored as a graph you can query. Audit questions get answers, not archaeology.

ui

Playwright

Generates and executes Playwright UI tests with resilient selector strategies, network-first waits, and self-healing on failure.

api

API testing

Newman collections generated from OpenAPI specs and captured live endpoints — the fastest first win for most teams.

beyond

Perf, security, a11y

k6 performance, OWASP ZAP security, Axe accessibility, and Pytest analytics runtimes round out six execution engines under one report.

agents

AI agents

Specialized agents for strategy, risk, ATDD design, automation engineering, defect intelligence, and self-healing — each owning one layer of the pipeline.

run

CI/CD & local AI

Runs in GitHub Actions, GitLab CI, or Jenkins. Default LLM is Ollama on your own hardware — no API keys, no cloud, air-gap friendly.

From requirement to automated test

Follow one requirement through the pipeline.

 pipeline — illustrative artifacts
REQ-101  Password reset must expire links after 30 minutes
source: jira · status: imported
REQ-101  risk = probability 3 × impact 3 = 9  (P0)
auth flow · irreversible user impact
discovery: 42 routes · 118 endpoints captured · DOM catalog built
✓ POST /api/auth/reset-request   ✓ GET /reset?token=…
Scenario: expired reset link is rejected
  Given a reset link issued 31 minutes ago
  When the user opens the link
  Then the app shows “link expired” and no session is created
req-101.spec.ts        grounded ✓  selectors verified vs DOM catalog
req-101.collection     grounded ✓  endpoints verified vs capture
playwright  3 passed  newman  5 passed  1 failed
retry with healing hint… still failing
FAIL  POST /api/auth/reset-request → 500
classification: sut_regression   ← your bug, filed with evidence
trace: REQ-101 → AC-2 → req-101.collection → run 0142

Up and running

One compose file. Your own LLM.

These are the real commands — no cloud account, no API key. The default provider is Ollama running on your machine.

 quickstart
# prerequisite: Ollama (ollama pull qwen2.5:32b) — or a cloud-LLM key
git clone https://github.com/AmeyaAI/OPEN-ARTA.git
cd OPEN-ARTA
cp .env.example .env
docker compose up -d

UI  → http://localhost:38088
API → http://localhost:38087
 a run report — illustrative
run 0142 · 6 runtimes · 38 tests
✓ 31 passed
✗ 4 failed   3 sut_regression · 1 test_gen_bug
■ 3 blocked  grounding_blocked — not silently shipped

traceability: 38/38 linked to requirements
quality gate: FAIL (P0 regression on auth flow)
a red report means something.

Built for developers

Your tests are yours.

ARTA generates standard artifacts — Playwright specs, Postman collections, k6 scripts — that live in ordinary files and run anywhere. There is no proprietary test format and no hosted lock-in: the whole single-team loop is Apache-2.0, self-hosted, and works with a local LLM.

Open source

Apache-2.0. The validator suite is the product — inspect it.

Self-hosted

One docker compose file. Postgres, Neo4j, Redis, Chroma included.

Local LLM by default

Ollama out of the box; Anthropic, OpenAI, Gemini optional per project.

API-first

A FastAPI backend drives everything the UI can do.

CI/CD native

Trigger generation and runs from GitHub Actions, GitLab CI, or Jenkins.

Standard outputs

Playwright · Postman · k6 · ZAP · Axe · Pytest. Take them with you.

Non-mutating

Discovery and testing never mutate your system by default — enforced at three independent layers.

Honest telemetry

Anonymous, bucketed, fully documented — and ARTA_TELEMETRY=0 means zero network calls.

Architecture

Evidence in, verdicts out.

A FastAPI engine orchestrates specialized agents over shared stores, dispatches six execution runtimes, and reports through a quality gate. Every box below is in the repo.

Requirements
Jira · OpenAPI · docs
Source code
GitHub
Live behavior
discovery probe
ARTA engine FastAPI · Python
strategy · risk · ATDD design · automation engineering · grounding validation · defect intelligence · self-healing
PostgresNeo4j traceabilityRedisChroma
Playwright
Newman
k6
ZAP
Axe
Pytest
Truthful report
pass/fail attribution
Traceability graph
req → result
Quality gate
CI/CD

Read the architecture docs →

Open source · developer first

Developed in the open. Free forever.

The entire single-team loop — generation for all six runtimes, execution, grounding validation, self-healing, truthful reports, single-project traceability, local LLMs — is Apache-2.0 and will never be metered or crippled. That boundary is written down and enforced in review.

Repository

Read the code. The validators are the pitch.

Contributing

Ground rules, dev setup, good first contributions.

Issues

Bugs and feature requests, in the open.

Discussions

Questions, ideas, and show-and-tell.

Roadmap

Now, next, later — honestly labeled.

Releases

Versioned changelog; v0.1.0 is the first public cut.

★ Star ARTA on GitHubJoin the community