brisk-aitesting

Fast, Efficient & No-nonsense — build faster, ship even faster!

The control layer between AI and your production code.

The world's most unique AI driven software testing control plane —

Deploy locally, embed in your repo, or run via CLI — your stack, your terms.

science Alpha · Industry Agnostic · Embeddable

Say what should be tested.
Brisk tests UI, APIs, contracts & logic — checked, end-to-end.

Brisk discovers your application and backend, builds a structured test plan, validates it before anything runs, routes each scenario to the right brisk engine, and returns clean test results your product can use. UI, API, OpenAPI — one pipeline.

rocket_launch Get started in 5 minutes View on GitHub arrow_forward

verified_user No hosted dashboard. No vendor lock-in. Your data, your storage, your control.

lockLocal-first extensionEmbeddable SDK verifiedEvidence-first shieldAI with control hubMulti-engine

chat

Your Goal

Plain-English intent

arrow_forward

travel_explore

Discovery

Repo, UI, API, OpenAPI

arrow_forward

checklist

Checked Plan

Validated JSON Schema

arrow_forward

play_arrow

Engines

UI, API, OpenAPI, Replay

arrow_forward

description

Evidence

Versioned handover

trending_upMarket Potential

A $54B market that is doubling.

Software testing and automation are two of the fastest-growing slices of enterprise spend. Brisk sits at the intersection — local, embeddable, AI-native.

$54.4B

Software testing market

2026 baseline

$99.9B

Projected

by 2031

$20.6B

Automation testing market

2025 baseline

$84.2B

Projected

by 2034

Sources: Mordor Intelligence · Fortune Business Insights. Projections are sourced forecasts, not present-day revenue.

monitoring

Software testing market growth

2026$54.4B

2028$66.2B

2031$99.9B

+83% growth in 5 years. CAGR ≈ 12.5%.

memory

Automation testing market growth

2025$20.6B

2030$45.3B

2034$84.2B

+309% growth in 9 years. CAGR ≈ 17% — the AI-led testing wave.

flag

Where Brisk plays

Other tools in the market are UI-only, API-only, or cloud-locked.
Brisk is all of it, in your repo.

Real-world challenges for enterprises and developers — click any item to learn more.

Brisk is the engine inside your product. Local. Embedded. Open source. No per-seat fees. No cloud lock-in.

TAM

Total addressable

$130B+

Global software + automation testing market by 2031-34

Mordor Intelligence · Fortune Business Insights

SAM

Serviceable

~$20B

SaaS teams needing embedded testing (est. 15% of TAM)

Estimate: Katalon 30k teams + Tricentis 3k enterprise + others

SOM

5-yr obtainable

$500M-2B

Brisk's realistic capture (2-10% of SAM)

Conservative: 1% OSS conversion + enterprise licenses

Why no incumbent ships this

mabl

Cloud-only, closed

Katalon

Dashboard-first

Tricentis

Enterprise license

testRigor

Closed, per-seat

Functionize

Cloud, no embed

Brisk

Local + OSS + embed

Every competitor is locked to their cloud, their pricing, their roadmap. Brisk is the only open-source, embeddable, local-first option.

arrow_forward That's the opportunity. Now see the outcomes.

insightsBusiness Outcomes

Quantified benefits, by audience.

What changes for the people actually using Brisk — measured in hours, dollars, and release velocity.

domain

Enterprise

$5M+ ARR · Regulated

B2B SaaS, healthcare, finance, government

trending_up

4×

more releases per quarter (monthly → weekly)
bolt

10×

faster per-release (3-6 weeks → days)
checklist

95%+

business-rule coverage (vs ~60% manual)
verified

-50%

bug escape rate in production
shield

SOC2 / HIPAA / GDPR

local-first = data never leaves your infra
payments

$200k-$1M/yr

saved per $10M ARR (QA headcount avoided)

trending_up

SME

<$5M ARR · Startups

Early-stage B2B SaaS, growth-mode teams

savings

$0

test infrastructure cost (vs $20-50k/yr for TestRail, mabl)
schedule

1 hour

to first automated test (vs 2 weeks)
rocket_launch

4-8 / mo

releases per month (vs 1-2 without)
speed

+30-50%

faster time-to-market for new features
build

-50%

bug fix time (caught earlier, fixed faster)
person_off

$60-120k/yr

QA engineer hire avoided (0.5-1 FTE)

person

Individual

Developer · Freelancer

Solo devs, contractors, open-source maintainers

timer

8× faster

test plan creation (30 min vs 4 hours)
code

-70%

test code to write manually
build_circle

-75%

test maintenance time after changes
rocket

2-3× more

features shipped per quarter
psychology

3× confidence

in refactoring without breaking things
auto_awesome

"I can ship on Friday"

peace of mind on every deploy

Estimates based on Brisk's published benchmarks (57 cases, 14 suites, 6 engines, 5 reference apps), industry comparables (TestRail State of QA 2024, Stack Overflow 2024, Mordor Intelligence), and the UAT cycle time reduction demonstrated in the case study above. Exact numbers vary by team size, product complexity, and current testing maturity.

arrow_forward These outcomes are real — but the current way to get them is broken. Here's the problem.

warningThe Problem Everyone Has

Software creation is accelerating.
Software testing is still fragmented.

AI ships code faster than ever. It does not remove the need to verify it. Testing stays expensive, manual, and spread across tools that don't talk to each other.

edit_note

Tests written by hand

Every team rebuilds the same boilerplate. Every new feature means another cycle of writing, debugging, maintaining.

scatter_plot

Tools that don't talk

UI tools here, API tools there, contract tools somewhere else. Evidence is scattered. Releases need glue code.

smart_toy

AI you can't trust

AI-generated Playwright breaks. AI selectors lie. AI code is silently unsafe. Most teams can't put it in CI.

cloud_off

Vendor lock-in

Hosted platforms hold your tests, your data, your CI gates — and your roadmap hostage.

search_off

Inconsistent evidence

What did the test actually prove? Where's the screenshot? Why did CI fail? Three teams, three answers.

schedule

Slow release cycles

Manual QA bottlenecks. Test maintenance debt. Months between shipping a feature and trusting it.

arrow_forward The shift arrow_forward

Brisk replaces hand-written tests, scattered tools, and unsafe AI generation
with one controlled pipeline that returns evidence you can actually trust.

verified The Promise — In Six Lines

chat

You say what should be tested — in plain English.

travel_explore

Brisk discovers what already exists in your app.

alt_route

It picks the right test path — UI, API, or contract.

checklist

It creates a checked, validated plan before anything runs.

play_arrow

It runs the right engines — Playwright, API, OpenAPI, more.

verified

It returns evidence your product can store, render, ship.

lightbulbWhy Brisk

AI ships code faster.
Software testing is still the bottleneck.

Brisk is the control layer that turns business intent into evidence — without trusting AI to write code that runs blindly.

smart_toy

AI proposes.
Brisk decides.

AI returns structured plans. Brisk validates, normalizes, routes. Unsafe or malformed plans are blocked before any engine runs.

hub

One pipeline.
Every engine.

UI, API, OpenAPI, Replay, Message, Schema-fuzz — orchestrated together. No glue code. No context-switching.

dns

You own the data.
You own the gate.

Local-first, embeddable SDK. Your database, your dashboard, your CI. No hosted platform. No vendor lock-in. Your rules, your scale, your future.

bolt

Why now

trending_up

AI code volume is exploding

More code, more changes, more to verify — with the same headcount.

fact_check

Trust is the new currency

Teams need evidence, not promises. Brisk returns versioned, schema-validated proof.

lan

Embeddable wins over hosted

SaaS platforms need their own testing layer. Brisk runs inside your product.

Two workflows, one difference

Same release cycle. Different cost, different risk, different outcome.

Without Brisk

Manual testing nightmare

removeEngineer writes a test for every new feature
removeAI tool writes flaky Playwright — breaks on next UI tweak
removeContract drifts from implementation, nobody notices
removeQA bottleneck grows with every release
removeEvidence scattered across 4 tools, no single source of truth
removeVendor lock-in raises prices 3× at renewal

Time per release 3–6 weeks

check

With Brisk

Automated, validated, evidence-backed

check_circleDescribe the goal in one sentence
check_circleBrisk discovers app, builds a checked plan
check_circleAI plan is validated — no surprise code execution
check_circleMultiple engines run in parallel
check_circleOne versioned result — JSON, JUnit, HTML, screenshots
check_circleYour dashboard, your database, your decision

Time per release Minutes

Manual testing nightmare

removeEngineer writes a test for every new feature
removeAI tool writes flaky Playwright
removeContract drifts, nobody notices
removeQA bottleneck grows
removeEvidence scattered across tools
removeVendor lock-in

groupKills the UAT Bottleneck

End of the UAT bottleneck.

User Acceptance Testing is where releases go to die. Visual testers click through workflows, validate business rules, eyeball edge cases, and file screenshots in Slack. Brisk automates all of it — with evidence, not opinions.

group

Today

Manual UAT

closeVisual testers click through every flow by hand
closeBusiness rules verified manually — edge cases missed
close"Did the right thing happen?" depends on the tester's mood
closeTwo weeks of feedback → one more week of re-tests
closeRelease slips — every time
closeEvidence is screenshots in someone's inbox

Avg UAT window 2–3 weeks

auto_awesome

With Brisk

Automated UAT

check_circleReal users' business rules → executable scenarios
check_circleUI workflows via Playwright — actual user paths
check_circleRejected-action state proof — "the right thing didn't happen"
check_circleEvidence: screenshots, traces, before/after snapshots
check_circleUAT runs in minutes, on every commit, in CI
check_circleEvidence is structured JSON, JUnit, and HTML reports

UAT per commit Minutes

fact_check What Brisk tests in UAT — automatically

Every category a human visual tester checks, executed as a deterministic scenario with versioned evidence.

task_alt

Business rules

"Admin can refund; everyone else gets 403"

touch_app

User flows

Click through the same paths real users take

calculate

Calculated values

Discounts, totals, taxes, balances — exact

block

Negative paths

"What if a user shouldn't be allowed to do X?"

compare

State changes

Before/after API snapshots, UI state proof

screenshot

Visual evidence

Screenshots, traces, full page state

handshake

Cross-tenant

Tenant A cannot see tenant B's data

schedule

On every commit

UAT no longer waits for a "UAT window"

workspace_premium

The outcome

UAT stops being a phase. It becomes a check.

No "QA environment." No "UAT window." No "we'll test it next sprint." Business acceptance criteria run alongside the build — every commit, every PR, every release candidate. The visual testers who used to click through screens become the people who approve the report.

timer

95%

UAT cycle time saved

visibility

"It works on my machine"

event_available

100%

Acceptance coverage

reviews

1×

Single source of truth

compareProduct Comparison

compare How Brisk compares

Established platforms have customers, support, integrations, and market history. Most testing products sell you a testing platform. Brisk gives you a testing engine you can embed into your own platform.

integration_instructions

Embeddable by design

Brisk can sit inside a SaaS product, internal platform, developer portal, or CI pipeline. The host owns storage and presentation.

shield

AI with control

AI proposes the plan. Brisk validates, normalizes, routes, executes. Unsafe plans are blocked before they run.

data_object

One evidence shape

UI, API, OpenAPI, adapters, artifacts, assertions, diagnostics, and final results return through a stable versioned contract.

Product	Since	Customer base	Revenue	Positioning
Brisk	New open-source product	Early-stage public package	Not revenue-generating yet	Local, embeddable AI testing control layer
mabl	Founded 2017	SaaS, retail, travel, media, enterprise	~$34.5M (Growjo est.)	AI-native low-code, self-healing
Katalon	Founded 2016	30,000+ teams	~$62.2M (Growjo est.)	Broad web/API/mobile/desktop platform
Tricentis Tosca	Tricentis founded 2007	3,000+ customers	ARR > $500M (reported)	Enterprise model-based, SAP testing
testRigor	Founded 2015	Enterprise and digital product teams	~$15M ARR (GetLatka est.)	Plain-English test automation
Functionize	Founded 2014	Enterprise and large digital teams	~$38.6M (Growjo est.)	AI testing agents for authoring + diagnosis

Private-company revenue is third-party estimates where stated. Competitor capabilities are based on public evidence.

✅ Native 🔧 Extensible ❌ Unsupported ⚫ Not benchmarked

Capability	Brisk	mabl	Katalon	Tosca	testRigor	Functionize

Editorial public-capability score (0–10)

Comparative scores are editorial assessments from public capability evidence. Not vendor-certified.

#	Mandatory benchmark scenario	Brisk	mabl	Katalon	Tosca	testRigor	Functionize

Editorial benchmark-readiness score (0–10)

Not shared-lab results. Competitor cells are public-capability mapping.

arrow_forward That's the competitive picture. Here is how Brisk actually works.

account_treeHow It Works

account_tree 10 stages, one verified result.

AI suggests the plan. Brisk checks the plan. Engines run the tests. Evidence shows what happened.

1

chat
You say what you want

You write one sentence about what to test. Brisk turns it into a simple plan.
2

folder_open
Brisk looks around your app

Brisk finds your pages, your code paths, and your rules — all by itself.
3

data_object
Brisk remembers what it learned

Everything Brisk found is saved in one place it can use later.
4

psychology
Brisk plans the tests

Brisk figures out what each test needs to do, and in what order.
5

account_tree
Brisk breaks it into small steps

Each test becomes a list of small, safe steps. Nothing big runs at once.
6

build
Brisk picks the right helper

Each step gets the right tool for the job — one helper does one thing well.
7

verified
Brisk double-checks the plan

If anything looks wrong, Brisk stops here. Nothing runs until the plan is safe.
8

play_arrow
The helpers do the work

Clicking buttons, calling APIs, sending messages — all at once if needed.
9

description
Brisk saves what happened

Pictures, videos, and notes are saved so you can see what really happened.
10

handshake
Brisk writes a report card

One simple report your tools can read — with a yes/no answer at the top.

lightbulb Business intent becomes executable evidence

Here is how a real business rule flows through the Brisk pipeline:

chat Goal:

"A user with the finance-admin role can refund any order; everyone else is rejected."

psychology

Intent

2 scenarios

route

Routes

POST /orders/:id/refund

checklist

Plan

2 scenarios, validated

verified

Evidence

2 passed, 1 rejected

arrow_forward The pipeline is controlled. Now see what each stage can actually do.

boltCapabilities

bolt What Brisk actually does

What the current product can do, organized by pipeline stage.

folder_open

Inspect a repository

Identify framework signals and package metadata

account_tree

Identify application structure

Supported JS/TS backend framework detection

alt_route

Discover backend routes

Express, nested routers, route chains, Nest decorators

web

Discover UI routes

Separate from backend route discovery

description

Locate OpenAPI files

JSON and YAML contract discovery

compare_arrows

Correlate routes & contracts

Matched, undocumented, and missing routes

psychology

Business intent to scenarios

Turn user intent into executable scenarios

data_object

Structured JSON plans

AI returns brisk-aitesting.plan.v1

verified

Validate against contract

AJV-backed public JSON Schema gate

build

Repair invalid plans

Validation feedback loop with AI planner

track_changes

Preserve objectives

Business meaning stays visible in the result

gps_fixed

Ground UI actions

Observed page evidence, not invented selectors

block

Block unsafe execution

Invalid or unsafe plans are rejected before any engine runs

stadia_controller

Browser workflows

Through Playwright engine

http

HTTP and API checks

Status, body, headers, schema validation

contract

OpenAPI parsing

JSON/YAML contracts with response-schema validation

add_circle

Positive API scenarios

Generated from OpenAPI request schemas

remove_circle

Negative API scenarios

Generated from OpenAPI request schemas

hub

Multi-engine routing

Scenarios dispatched to the right engine

science

Schemathesis (optional)

Optional deep OpenAPI checking via Python adapter

extension

Custom engine extension

Plug in engines for databases, messaging, mobile, desktop, enterprise systems

vpn_key

Auth headers on API requests

Bearer token or static headers applied to API, replay, schema-fuzz, and live-message engines

Browser login via credentials

Playwright login flow when auth.loginUrl is provided

tune

Custom auth via metadata

Host provides auth logic (e.g. refresh tokens, SSO) via SDK metadata

visibility_off

Auth secrets redacted in evidence

Authorization, cookie, token, password, secret headers are stripped before evidence is written

data_object

One versioned result

Machine-readable brisk-aitesting.result.v1

screenshot

Screenshots

Browser evidence from UI workflows

timeline

Traces

Playwright trace evidence

article

Logs

Execution logs from every engine

swap_horiz

Request/response evidence

API call data preserved

contract_edit

Contract evidence

OpenAPI operation summaries and validation

check_circle

CI-compatible status

Exit codes and machine-readable summary

dns

Host-owned persistence

Your database, dashboard, CI, or observability pipeline

memory Built-in engines

stadia_controller

Playwright UI

Grounded actions, healing, traces, screenshots — the real browser, observed.

http

API & OpenAPI

Positive/negative scenarios, schema validation, contract drift reports.

lan

Message & replay

AsyncAPI inspection, live message flows, declared HTTP interaction replay.

checklist Checked plan

brisk-aitesting.plan.v1

arrow_forward

hub Router

by scenario type

arrow_forward

stadia_controller

api

API

contract

Contract

arrow_forward

inventory_2 One result

brisk-aitesting.result.v1

arrow_forward Capabilities lead to proof. Here is the real run data behind every claim.

lab_profileInternal Benchmarks

lab_profile Real numbers. Not marketing.

Fresh run data from the package — not promises, not projections.

Every number below came from an actual npm run command that finished clean.

check_circle

100%

Pass rate

17 / 17 commands

fact_check

Benchmark cases

All passing

apps

Proof apps

33 scenarios

deployed_code

Engines verified

UI · API · Schema · Replay · Message · Contract

menu_book Read BENCHMARKS.md

verified Coverage areas verified

check_circleBreaking tests

We try to break Brisk on purpose. It doesn't break.

check_circlePoke everything

Every part of Brisk gets poked to make sure it works.

check_circleCheck every door

Every page and rule in your app is reachable.

check_circle6 little workers

All 6 helpers pass their own tests.

check_circleNo bad helpers

Mean add-ons get sent away at the door.

check_circleExtras are ready

Optional add-on tools pass their checks.

check_circlePractice on 5 real apps

We test on 5 real apps, not pretend ones.

check_circleRight answer stays right

The saved right answer doesn't change between runs.

check_circleCommand tool works

The text-command tool works right every time.

check_circleBrisk cleans up AI messes

If AI writes something silly, Brisk fixes it.

check_circleSmall clean download

The download is small, clean, and has everything.

check_circleReal AI, not a toy

We test with a real AI helper, not a pretend one.

monitoring Run breakdown

Benchmark 57 / 57 · 30.2s

Smoke 6 / 6 · 78.1s · 27 artifacts

Smoke:contracts 38 schemas · 6.0s

Engine conformance 6 / 6 · 11.1s

Plugin conformance 1 good · 3 bad blocked

Reference serious SaaS 13 / 13 · 43 artifacts

Reference proof apps 20 / 20 · 5 apps

Golden fixtures 13 / 13 · 18.0s

Pack:check 135 files · 1.55 MB

Real-AI smoke 2 / 2 · 14 artifacts

gavel What "100% passing" actually means

check_circleBenchmark suite deliberately injects bad inputs — broken setups, contract drift, schema mismatches, blocked networks, and CLI errors. All handled correctly.
check_circlePlugin conformance proves the 3 bad plugins were rejected and only the good one ran. Safety, not just coverage.
check_circleGolden fixtures confirm a known-good answer stays stable across runs — catches quiet degradation after AI repair.
check_circleReal-AI smoke proves the configured provider actually works in this environment — not a stub.
check_circlePack:check proves the npm package ships 135 files, 1.55 MB unpacked, no leaked secrets.
check_circle5 reference apps cover serious-SaaS, API-only, Todo, multi-tenant, e-commerce, and event/messaging shapes.

gavel Bottom line

trending_up

What it means for product teams

You can trust the result. Bad plans are blocked, bad plugins are rejected, broken setups are caught, and the package is clean.

schedule

Time to first green run

Five minutes from npm install to first passing run. The release gate is the same command CI uses.

arrow_forward Proof is established. Here is how AI proposals become controlled execution.

shieldAI Control

shield AI proposes. Brisk decides what is allowed to run.

Seven gates between an LLM response and your production code.

Find the good part

Pull the clean answer out of AI's reply

Fix the nicknames

If AI said "btn" but you call it "button"

Add your doors

Add the pages and paths from your app

Check it works

Make sure nothing is missing or silly

Try again if wrong

Ask AI to fix what it got wrong

Look at the real page

Click what the page actually shows

Send to the right helper

The right worker does the right job

check_circle

Brisk says yes to

check

"I want to test this"

Plain sentences about what to check.
check

Names of your pages

The pages Brisk found in your app.
check

Requests that match the rules

Only ones that fit the shape your app expects.
check

Nicknames that point right

"btn" and "button" mean the same thing here.
check

Buttons we really see

Only the buttons that are on the real page.

block

Brisk says no to

close

AI-written test code

AI can write silly code — we don't run it.
close

AI's guess of "click here"

AI might pick the wrong button. We look instead.
close

Changes to your data that weren't checked

No "delete everything" without a safety check.
close

Random computer commands

No surprise shell calls or internet pings.
close

Plans that don't make sense

Plans that don't fit the shape Brisk expects are stopped.

priority_high

Always required

arrow_right

A plan in the right shape

Always check that the plan is the shape Brisk expects.
arrow_right

Pages from your app, not made up

Only use page names that Brisk actually found.
arrow_right

Real buttons from the real page

Always look at the page before clicking.
arrow_right

Works with any AI helper

You pick the AI — Brisk adapts.
arrow_right

Talks only to your own computer

Doesn't phone home unless you say so.

arrow_forward Control leads to evidence. Evidence is what your product can actually use.

descriptionEvidence & Integration

description One result your product can use.

Store, render, compare, or send to CI. Same shape, every run.

data_object

brisk-aitesting.result.v1

{
  "schemaVersion": "brisk-aitesting.result.v1",
  "runId": "run_abc123...",
  "status": "passed",
  "summary": {
    "total": 12,
    "passed": 10,
    "failed": 1,
    "skipped": 1,
    "errors": 0,
    "passRate": 0.833,
    "durationMs": 45200
  },
  "plan": { /* structured test plan */ },
  "tests": [
    {
      "id": "scenario_01",
      "type": "ui",
      "status": "passed",
      "assertions": [ /* ... */ ],
      "evidence": { /* ... */ }
    }
  ],
  "artifacts": [
    { "type": "screenshot", "path": "..." },
    { "type": "trace", "path": "..." }
  ],
  "diagnosis": [],
  "handover": {
    "schemaVersion": "brisk-aitesting.handover.v1",
    "consumableBy": ["ci", "dashboard", "database"]
  }
}

account_tree Evidence branches

summary

rollup

Counts, pass rate, duration — ready for dashboards and CI gates.

plan

structured

The validated plan you actually ran — proves what was tested.

tests[]

per-scenario

Each scenario with status, assertions, and per-test evidence.

artifacts[]

files

Screenshots, traces, logs, request/response, contracts.

diagnosis

when failing

Actionable root-cause hints for failing scenarios.

handover

contract

Versioned envelope for downstream consumers.

hub Your product can use this result for

sync

CI pass/fail gates

dashboard

Dashboard cards

history

Test history

dns

Database persistence

receipt_long

Audit logs

screenshot

Traces & screenshots

trending_up

Analytics

task_alt

Release approval

Examples include BigQuery, Cloud Storage, GitHub Actions, internal test portals, release approval workflows, incident-management systems, and host-owned dashboards. These are examples, not prebuilt integrations.

handshake Add it to any host application

apps

Your host config

app name and URL

merge defineHostConfig

deployed_code

brisk-aitesting config

safe defaults included

code View config example expand_more

import { defineHostConfig } from 'brisk-aitesting';

export default defineHostConfig({
  app: {
    name: 'My application',
    baseUrl: 'http://localhost:3000',
  },
});

// Optional AI/auth values come from documented
// BRISK_AITESTING_* environment settings.

arrow_forward Control and evidence set the foundation. Here is exactly what is built today.

science

Alpha release — it runs real checks today.

AI can suggest what to test, but Brisk checks the plan before anything runs. Engines do the execution. Evidence records what happened.

infoProduct Status

info What is built, what is not.

What is built now versus what remains future work — clearly separated.

check

The tool, and a yes/no answer

A way to know if it worked or didn't.

check

Works with any AI helper

You pick the AI. Brisk works with all of them.

check

Fixes its own mistakes

If AI writes a bad plan, Brisk asks it to try again.

check

Finds your app on its own

You don't have to list your pages and rules — Brisk finds them.

check

Spots mismatches in your rules

If a rule says one thing but the app does another, Brisk waves a flag.

check

Tests "yes" and "no" answers

Checks the happy path AND the "this should fail" path.

check

Clicks real buttons

It sees the page, then clicks the real button — not a guess.

check

Adapts when pages change

If a button moves, Brisk finds it again — test keeps going.

check

5 helpers in one

5 different testing tools, run with one command.

check

Stamped report card

A version-stamped report your tools know how to read.

check

Common report files

Files other testing tools already know how to open.

check

Outside helpers must pass a test

Other people's tools have to prove they're safe first.

check

Add-ons are checked

Extra tools are tested before they can be used.

check

Practiced on 5 real apps

Tested on 5 real app shapes, not pretend ones.

check

The right answer stays right

Saved answers don't change between runs — quiet bugs get caught.

check

Real AI, not a toy

Tested with a real AI helper, not a pretend one.

check

Optional extras for fancy testing

Plug-in helpers for advanced tests if you want them.

check

Ready to install

Easy to install the usual way JavaScript tools are installed.

rocket_launchGet Started

rocket_launch From install to first run in 5 minutes.

No README digging. One install, one config, one command.

download Install

After installing, create your config with npx brisk-aitesting init.

terminal

$ npm install brisk-aitesting

terminal

$ pnpm add brisk-aitesting --filter @your-org/api

terminal

$ git clone https://github.com/oshjain/brisk-aitesting.git
$ cd brisk-aitesting
$ npm install
$ npm run build
$ npm link

# Inside your host app:
$ npm link brisk-aitesting

terminal

$ npm install github:oshjain/brisk-aitesting

tune Configuration

brisk-aitesting.config.ts

import { defineConfig } from 'brisk-aitesting';

export default defineConfig({
  app: {
    name: 'My SaaS',
    baseUrl: 'http://localhost:3000',
    repoPath: '.',
  },
  auth: { type: 'none' },
  ai: {
    provider: 'openai',
    model: requiredEnv('BRISK_AITESTING_AI_MODEL'),
    apiKeyEnv: 'BRISK_AITESTING_AI_API_KEY',
    repairAttempts: 2,
    maxTokens: 4096,
    temperature: 0.1,
  },
  runtime: {
    artifactsDir: '.brisk-aitesting/artifacts',
    timeoutMs: 120000,
    retries: 1,
    headless: true,
    dryRun: false,
  },
  discovery: {
    includeRepo: true,
    includeUi: true,
    includeApi: true,
    includeContracts: true,
  },
  security: {
    networkPolicy: 'localhost-only',
    allowedHosts: ['localhost', '127.0.0.1', '::1'],
    redactSecrets: true,
  },
});

function requiredEnv(name) {
  const v = process.env[name];
  if (!v) throw new Error(name + ' is required');
  return v;
}

vpn_key Auth types

Brisk ships four auth types. Pick one (or none).

block

none

No auth required. Use for public endpoints or local dev.

auth: { type: 'none' }

vpn_key

bearer

Bearer token attached to all API requests. Static, no refresh.

auth: { type: 'bearer', token: requiredEnv('API_TOKEN') }

credentials

Username/password with optional browser login via Playwright at loginUrl.

auth: { type: 'credentials', username: 'u', password: 'p', loginUrl: '/login' }

tune

custom

Host provides auth logic via SDK metadata (e.g. refresh tokens, SSO, mTLS).

auth: { type: 'custom', description: 'OAuth refresh on 401', metadata: { ... } }

Auth secrets (tokens, passwords, cookies) are auto-redacted from evidence before any result is written.

play_arrow Run a test goal

terminal

$ npx brisk-aitesting run \
  --goal "Test login, permissions, dashboard, API contracts" \
  --scenarios 15 \
  --mode automatic \
  --ui-action-feedback when-missing

terminal Machine-readable output for CI

terminal

$ npx brisk-aitesting run \
  --goal "Test OpenAPI contracts and critical API paths" \
  --scenarios 10 \
  --json \
  --output .brisk-aitesting/latest-result.json

numbers CLI exit codes

check_circle

All scenarios passed

error

Completed, non-passed

report

Setup or usage error

Star on GitHub arrow_forward menu_book Read the full guide

mapRoadmap

map Where Brisk is going.

Transparent direction. No delivery dates — the repository supplies none.

lan

Broker adapters

Kafka, RabbitMQ, and cloud queues — only when a real runtime is selected.

code

Multi-language discovery

Source-route discovery for Python, .NET, Go, Java, generated-route systems.

published_with_changes

Deeper Specmatic coverage

More proof-app cases for stub & service-virtualization behavior.

extension

Richer extension types

Stable output contracts for new discoverer, planner, validator, and grounder shapes.

compare_arrows

Replay depth

Richer response diff artifacts, multi-step session replay, privacy controls.

auto_awesome

UI healing depth

Repeated flake analysis, multi-page healing, stricter confidence scoring.

rule

Business-rule catalog

Reusable rule IDs, rule coverage, contradiction checks. Host teams approve and own the rules.

monitoring

Trend analytics

Richer trend analytics on top of structured summaries and benchmark reports.

verified_user

Multi-provider benchmarks

Compare real provider quality across AI models — not marketing claims.

handshake

Be part of building the control layer

Open issues, propose adapters, share proof apps, or star the repo. Every signal shapes what ships next.

bug_report Open an issue forum Join the discussion

Command	Result	Coverage	Key numbers	Time
npm run benchmark	Pass	57 cases	57 / 57 · 100%	30.2s
npm run smoke	Pass	6 scenarios	6 pass · 27 artifacts · 4 UI · 3 API	78.1s
npm run smoke:contracts	Pass	4 counters	39 exports · 36 types · 38 schemas · 22 scripts	6.0s
npm run smoke:engine-conformance	Pass	6 engines	api, contract, schema, replay, message, ui	11.1s
npm run smoke:plugin-conformance	Pass	4 plugin checks	1 good · 3 bad blocked	3.9s
npm run smoke:extension-conformance	Pass	10 ext checks	5 good · 5 bad rejected	4.6s
npm run smoke:adapter-readiness	Pass	3 adapters	Schemathesis · Specmatic · Pact	2.1s
npm run smoke:specmatic	Skip*	1 optional	skips unless Java/Specmatic; CI installs Java	4.9s
npm run smoke:reference-serious-saas	Pass	13 scenarios	13 pass · 4 negative · 43 artifacts	27.6s
npm run smoke:reference-proof-apps	Pass	20 scenarios	20 pass · 5 apps covered	21.6s
npm run smoke:golden-fixtures	Pass	13 scenarios	13 checked · 13 matched	18.0s
npm run smoke:cli	Pass	2 result types	exit `0` on success · exit `2` on bad input	6.3s
npm run smoke:ai-fixtures	Pass	6 fixtures	5 contract · repair 2/2 · 1 repair event	6.3s
npm run pack:check	Pass	135 packed files	unpacked 1,548,455 bytes	16.6s
npm run smoke:real-ai	Pass	2 scenarios	2 pass · UI + API · 14 artifacts	29.4s
npm run smoke:ci (roll-up chain)	All green	12 chained	every suite chained, none skipped	99.8s

Say what should be tested. Brisk tests UI, APIs, contracts & logic — checked, end-to-end.

A $54B market that is doubling.

Software testing market growth

Automation testing market growth

Other tools in the market are UI-only, API-only, or cloud-locked. Brisk is all of it, in your repo.

Quantified benefits, by audience.

$5M+ ARR · Regulated

<$5M ARR · Startups

Developer · Freelancer

Software creation is accelerating. Software testing is still fragmented.

Tests written by hand

Tools that don't talk

AI you can't trust

Vendor lock-in

Inconsistent evidence

Slow release cycles

verified The Promise — In Six Lines

AI ships code faster. Software testing is still the bottleneck.

AI proposes.Brisk decides.

One pipeline.Every engine.

You own the data.You own the gate.

Why now

Two workflows, one difference

End of the UAT bottleneck.

fact_check What Brisk tests in UAT — automatically

UAT stops being a phase. It becomes a check.

compare How Brisk compares

Embeddable by design

AI with control

One evidence shape

Editorial public-capability score (0–10)

Editorial benchmark-readiness score (0–10)

account_tree 10 stages, one verified result.

You say what you want

Brisk looks around your app

Brisk remembers what it learned

Brisk plans the tests

Brisk breaks it into small steps

Brisk picks the right helper

Brisk double-checks the plan

The helpers do the work

Brisk saves what happened

Brisk writes a report card

lightbulb Business intent becomes executable evidence

bolt What Brisk actually does

memory Built-in engines

Playwright UI

API & OpenAPI

Message & replay

lab_profile Real numbers. Not marketing.

verified Coverage areas verified

monitoring Run breakdown

gavel What "100% passing" actually means

gavel Bottom line

shield AI proposes. Brisk decides what is allowed to run.

Brisk says yes to

Brisk says no to

Always required

description One result your product can use.

account_tree Evidence branches

hub Your product can use this result for

handshake Add it to any host application

info What is built, what is not.

rocket_launch From install to first run in 5 minutes.

download Install

tune Configuration

vpn_key Auth types

play_arrow Run a test goal

terminal Machine-readable output for CI

numbers CLI exit codes

map Where Brisk is going.

Broker adapters

Multi-language discovery

Deeper Specmatic coverage

Richer extension types

Replay depth

UI healing depth

Business-rule catalog

Trend analytics

Multi-provider benchmarks

Say what should be tested.
Brisk tests UI, APIs, contracts & logic — checked, end-to-end.

Other tools in the market are UI-only, API-only, or cloud-locked.
Brisk is all of it, in your repo.

Software creation is accelerating.
Software testing is still fragmented.

AI ships code faster.
Software testing is still the bottleneck.

AI proposes.
Brisk decides.

One pipeline.
Every engine.

You own the data.
You own the gate.