construction Alpha

Local-first · Embeddable · Evidence-first

Say what should be tested. Brisk turns it into checked, executable tests.

Brisk discovers the application, creates a structured test plan, validates it before execution, routes each scenario to the right engine, and returns clean evidence your product can use.

Use it inside your product, from the CLI, or in CI. No proprietary hosted dashboard is required.

lock_open Open source MIT Alpha home Local first PRs welcome
psychology

Human testing goal

arrow_forward
travel_explore

Discovery

arrow_forward
description

Checked JSON plan

arrow_forward
precision_manufacturing

UI / API / Contract engines

arrow_forward
verified

Evidence result

The Promise

chat

Say what should be tested

travel_explore

Brisk discovers what exists

alt_route

It chooses the right test path

checklist

It creates a checked plan

play_arrow

It runs the right engines

verified

It returns evidence your product can use

Software creation is accelerating. Verification is still fragmented.

AI-assisted development increases the speed and volume of change; it does not remove the need to verify behaviour. Testing remains expensive, spread across manual interpretation, separate tools, inconsistent evidence, and repeated engineering effort.

$54.44B

Software testing market

2026

$99.94B

Projected

by 2031

$20.60B

Automation testing market

2025

$84.22B

Projected

by 2034

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

Software Testing Market

Source: Mordor Intelligence. Line between 2026 and 2031 is linear interpolation.

$54.44B

2026

$72B est.

2028*

$99.94B

2031

* Intermediate values are linear interpolation between known source endpoints.

View data table
YearValueNote
2026$54.44BSource: Mordor Intelligence
2028$72B est.Linear interpolation
2031$99.94BProjected (Mordor Intelligence)

Automation Testing Market

Source: Fortune Business Insights. Line between 2025 and 2034 is linear interpolation.

$20.60B

2025

$48.88B est.

2029*

$84.22B

2034

* Intermediate values are linear interpolation between known source endpoints.

View data table
YearValueNote
2025$20.60BSource: Fortune Business Insights
2029$48.88B est.Linear interpolation
2034$84.22BProjected (Fortune Business Insights)

Why now

rocket_launch

Faster software creation

AI-assisted development accelerates code production and change volume

trending_up

Expanding testing demand

$54B+ market growing toward $100B as software surfaces multiply

broken_image

Fragmented verification

Separate tools, manual translation, inconsistent evidence, repeated engineering

enterprise

Enterprise evidence gap

Enterprises need controlled, reusable evidence they own and can integrate

"AI could write 90% of code in a short time window and eventually nearly all code."

"More than a quarter of new Google code was already AI-generated and then reviewed by engineers."

"A very large share of code will be AI-generated within five years."

Two workflows, one difference

history Traditional workflow

  1. 1

    Product teams explain what should be tested

    Human language, no machine structure

  2. 2

    Testers translate into manual UAT steps

    Manual interpretation, no automation

  3. 3

    Automation engineers write scripts

    Playwright, API, contract, or custom scripts—separately

  4. 4

    Different tools produce different reports

    Inconsistent evidence across systems

  5. 5

    Developers investigate failures

    Time spent finding what failed and why

  6. 6

    Teams rebuild the pipeline

    Repeat for every product, every cycle

bolt Brisk workflow

  1. 1

    State the goal in human language

    Natural language, structured output

  2. 2

    Discover the application surfaces

    Automated repo, UI, API, and contract inspection

  3. 3

    Create a structured JSON plan

    AI proposes; Brisk checks before execution

  4. 4

    Validate and repair the plan

    Schema gate + execution checks + repair loop

  5. 5

    Ground UI actions in evidence

    Real page evidence, not invented selectors

  6. 6

    Route to the right engines

    UI, API, Contract—one pipeline, one result

  7. 7

    Return one stable handover object

    Versioned JSON for CI, dashboards, databases

  1. 1Product teams explain what should be tested
  2. 2Testers translate into manual UAT steps
  3. 3Automation engineers write multiple scripts
  4. 4Different tools produce different reports
  5. 5Developers investigate failures
  6. 6Teams rebuild the pipeline

Compare

Established platforms have customers, support teams, integrations, market history, and commercial trust. Most testing products sell you a testing platform. Brisk gives you a testing engine you can embed into your own platform. Brisk is built for a different role: a local, embeddable testing control layer.

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, and executes through engines. Unsafe plans are blocked before execution.

data_object

One evidence shape

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

ProductSinceCustomer baseRevenuePositioning
BriskNew open-source productEarly-stage public packageNot revenue-generating yetLocal, embeddable AI testing control layer
mablFounded 2017Public customer stories across SaaS, retail, travel, mediaEst. ~$34.5M (Growjo estimate)AI-native low-code test automation, self-healing
KatalonFounded 201630,000+ teams (per Katalon)Est. ~$62.2M (Growjo estimate)Broad quality platform: web, API, mobile, desktop
Tricentis ToscaTricentis founded 20073,000+ customers (per Tricentis)ARR above $500M (reported)Enterprise model-based automation, SAP testing
testRigorFounded 2015Enterprise and digital product teamsEst. ~$15M ARR (GetLatka estimate)Plain-English test automation, web, mobile, API
FunctionizeFounded 2014Enterprise and large digital teamsEst. ~$38.6M (Growjo estimate)AI testing agents for authoring, execution, diagnosis

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

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

How It Works

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

  1. 1

    Understand the application

    Read configuration, determine what surfaces to inspect, and set up the discovery scope.

  2. 2

    Discover pages, APIs, routes, contracts, and schemas

    Inspect the repository, UI routes, API routes, and OpenAPI files. Identify framework signals and correlate implementation with contracts.

  3. 3

    Create a structured test plan

    AI returns a JSON plan shaped as brisk-aitesting.plan.v1. A built-in planner also generates contract scenarios from OpenAPI operations.

  4. 4

    Normalize and validate the plan

    Apply the public JSON Schema gate with AJV, then run Brisk-specific executability checks. Reject anything unsafe.

  5. 5

    Repair invalid plans when possible

    Feed validation issues back to the AI planner for structured repair. Plans that cannot be repaired are blocked from execution.

  6. 6

    Ground UI steps using observed page evidence

    Capture real page elements (roles, labels, text, test IDs, stable selectors) and let AI enrich UI actions from observed evidence only.

  7. 7

    Route scenarios to the correct engine

    Each scenario type is dispatched to the appropriate built-in engine: Playwright for UI, API engine for HTTP checks, Contract engine for OpenAPI.

  8. 8

    Execute the scenarios

    Engines run the validated scenarios. Browser workflows through Playwright, HTTP checks through the API engine, contract summaries through the contract engine.

  9. 9

    Collect evidence

    Gather logs, traces, screenshots, request/response data, and contract evidence from every engine execution.

  10. 10

    Return one final result envelope

    Package everything into brisk-aitesting.result.v1—one stable object for CI, dashboards, databases, or internal platforms.

Business intent becomes executable evidence

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

Given a booking date after vessel departure,
when a booking is created,
then the API must reject it with VESSEL_ALREADY_DEPARTED.

contextual_token

Context

Booking date after vessel departure

play_arrow

Action

Booking is created

gavel

Expected outcome

API rejects with error code

verified

Evidence

Request, response, status, schema check

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

Capabilities

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

Report matched, undocumented, and missing routes

Built-in engines

stadia_controller

Playwright Engine

BuiltinPlaywrightEngine

Runs browser workflows and grounded UI actions. Captures screenshots, traces, and page evidence.

check Built-in
http

API Engine

BuiltinApiEngine

Runs HTTP checks, validates response schemas when OpenAPI schemas exist. Captures request/response evidence.

check Built-in
contract

Contract Engine

BuiltinContractEngine

Reads OpenAPI JSON/YAML and emits operation summaries. Connects contracts with runtime execution.

check Built-in

Checked Plan

brisk-aitesting.plan.v1

Engine Router

stadia_controller

UI Scenarios

http

API Scenarios

contract

Contract Scenarios

Result Envelope

brisk-aitesting.result.v1

Capabilities need control. Here is where AI suggestions meet Brisk validation.

AI Control

AI proposes. Brisk decides what is allowed to run.

1

Extract JSON

Extract structured plan from AI response

2

Normalize aliases

Resolve safe shorthand references

3

Inject routes

Add discovered routes when needed

4

Validate structure

Schema gate + executability checks

5

Repair

Feedback loop fixes invalid plans

6

Ground UI

Real page evidence only

7

Route to engines

Dispatch validated scenarios to the correct built-in engine

check_circle

Allowed

  • checkAI can suggest what should be tested
  • checkAI can classify scenarios by supported execution path
  • checkAI can enrich UI actions from captured page evidence
block

Blocked

  • closeInvented selectors being forced into execution
  • closeBypassing plan validation
  • closeExecuting malformed or unsupported plans
verified

Required by contract

  • shieldExecutable results carry evidence produced by engines

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

Evidence & Integration

One result your product can store, render, compare, or send to CI.

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"]
  }
}

Evidence branches

analytics

Summary

Total, passed, failed, skipped, errors, pass rate, and duration. The top-level status for CI gates.

checklist

Tests

Each scenario with its type, status, assertions, and linked evidence artifacts.

folder

Artifacts

Screenshots, traces, logs, request/response data, and contract evidence.

move_to_inbox

Handover

Metadata about which systems can consume this result: CI, dashboards, databases, and more.

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

Example integrations described in the README include BigQuery, Cloud Storage, GitHub Actions, internal test portals, release approval workflows, incident-management systems, and host-owned dashboards. These are examples, not prebuilt or certified integrations.

Host application config bridge

Host Application

Your source of truth

productName

urls.staging

paths.repo

testing.auth

ai.*

defineConfigFromHost

Maps host config → Brisk config

Brisk Testing Config

Only the values needed

View code example
import { defineConfigFromHost, mergeConfig } from 'brisk-aitesting';

const testingConfig = defineConfigFromHost(
  hostConfig,
  (host) => ({
    app: {
      name: host.productName,
      baseUrl: host.urls.staging,
      repoPath: host.paths.repo,
    },
    auth: host.testing.auth,
    ai: {
      provider: host.ai.provider,
      endpoint: host.ai.endpoint,
      model: host.ai.model,
      apiKey: host.ai.apiKey,
    },
  })
);

export default mergeConfig(testingConfig, {
  runtime: {
    artifactsDir: '.brisk-aitesting/artifacts',
    timeoutMs: 120000,
    retries: 1,
    headless: true,
  },
});

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

info

Brisk is an early-stage open-source project.

Current capability and future work are deliberately separated. Alpha status means the product works but is still maturing.

Product Status

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

check_circle

UI testing

Browser workflows through Playwright

Built-in
check_circle

API testing

HTTP checks, status, body, headers

Built-in
check_circle

OpenAPI testing

JSON/YAML parsing, response schema validation

Built-in
check_circle

Contract drift reporting

OpenAPI vs. implementation comparison

Built-in
check_circle

Checked AI planning

AI returns JSON; Brisk validates before execution

Built-in
check_circle

Result handover

Versioned JSON for CI, dashboards, databases

Built-in
check_circle

Local SDK and CLI

Use inside your app or from command line

Built-in
science

Schemathesis engine

Optional Python-based OpenAPI deep checking

Optional adapter
check_circle

Serious SaaS proof app

Real product for testing auth, roles, UI, API

Built-in
check_circle

Engine quality checks

Built-in and external engine conformance

Built-in
check_circle

Public plan contract gate

AJV-backed JSON Schema validation

Built-in
check_circle

Golden expected outputs

Known-good plans and results for regression

Built-in
check_circle

Adapter readiness gate

Checklist for adapters marked "built"

Built-in
check_circle

Built-in schema fuzzing

Fast malformed-request checks from OpenAPI schemas

Built-in
check_circle

Built-in replay engine

Rerun declared HTTP interactions for regression

Built-in
check_circle

JUnit & HTML reports

Report artifacts for every run

Built-in
check_circle

Non-engine extension QC

Checks discoverers, planners, validators, UI grounders, and AI providers

Built-in
check_circle

More proof apps

API-only, Todo, and multi-tenant proof apps

Built-in
check_circle

Release readiness

Release check and versioned changelog

Built-in

Get Started

From install to first run without searching the README.

Install

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

terminal
$ npm install brisk-aitesting

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: string): string {
  const value = process.env[name];
  if (value === undefined || value.trim().length === 0) {
    throw new Error(name + ' is required');
  }
  return value;
}

Run a test goal

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

Machine-readable output

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

CLI exit codes

0

Run completed and passed

1

Run completed but failed, errored, or skipped

2

Usage, config, provider, or runtime setup error

Roadmap

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

precision_manufacturing

Broader test engines

  • arrow_rightAsyncAPI / Pact / message-contract adapters
  • arrow_rightSpecmatic / Keploy adapters
monitoring

Reporting and analytics

  • arrow_rightMulti-provider benchmark scoring
  • arrow_rightBuilt-in analytics module
science

Product proof

  • arrow_rightFull proof app collection
  • arrow_rightFramework-specific examples
rocket_launch

Release maturity

  • arrow_rightnpm publish workflow automation
extension

Extension quality

  • arrow_rightDeeper behavior checks for future extension types
gavel

Business-rule coverage

  • arrow_rightScenario/rule coverage and contradiction checks

PRs welcome

Brisk is open source under the MIT licence. Review the current status, pick an area, and contribute.

MIT © Hasmukh Jain — Main contributor & product visionary