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.
Human testing goal
Discovery
Checked JSON plan
UI / API / Contract engines
Evidence result
The Promise
Say what should be tested
Brisk discovers what exists
It chooses the right test path
It creates a checked plan
It runs the right engines
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.
2026
2028*
2031
* Intermediate values are linear interpolation between known source endpoints.
View data table
| Year | Value | Note |
|---|---|---|
| 2026 | $54.44B | Source: Mordor Intelligence |
| 2028 | $72B est. | Linear interpolation |
| 2031 | $99.94B | Projected (Mordor Intelligence) |
Automation Testing Market
Source: Fortune Business Insights. Line between 2025 and 2034 is linear interpolation.
2025
2029*
2034
* Intermediate values are linear interpolation between known source endpoints.
View data table
| Year | Value | Note |
|---|---|---|
| 2025 | $20.60B | Source: Fortune Business Insights |
| 2029 | $48.88B est. | Linear interpolation |
| 2034 | $84.22B | Projected (Fortune Business Insights) |
Why now
Faster software creation
AI-assisted development accelerates code production and change volume
Expanding testing demand
$54B+ market growing toward $100B as software surfaces multiply
Fragmented verification
Separate tools, manual translation, inconsistent evidence, repeated engineering
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
Product teams explain what should be tested
Human language, no machine structure
- 2
Testers translate into manual UAT steps
Manual interpretation, no automation
- 3
Automation engineers write scripts
Playwright, API, contract, or custom scripts—separately
- 4
Different tools produce different reports
Inconsistent evidence across systems
- 5
Developers investigate failures
Time spent finding what failed and why
- 6
Teams rebuild the pipeline
Repeat for every product, every cycle
bolt Brisk workflow
- 1
State the goal in human language
Natural language, structured output
- 2
Discover the application surfaces
Automated repo, UI, API, and contract inspection
- 3
Create a structured JSON plan
AI proposes; Brisk checks before execution
- 4
Validate and repair the plan
Schema gate + execution checks + repair loop
- 5
Ground UI actions in evidence
Real page evidence, not invented selectors
- 6
Route to the right engines
UI, API, Contract—one pipeline, one result
- 7
Return one stable handover object
Versioned JSON for CI, dashboards, databases
- 1Product teams explain what should be tested
- 2Testers translate into manual UAT steps
- 3Automation engineers write multiple scripts
- 4Different tools produce different reports
- 5Developers investigate failures
- 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.
Embeddable by design
Brisk can sit inside a SaaS product, internal platform, developer portal, or CI pipeline. The host owns storage and presentation.
AI with control
AI proposes the plan. Brisk validates, normalizes, routes, and executes through engines. Unsafe plans are blocked before execution.
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 | Public customer stories across SaaS, retail, travel, media | Est. ~$34.5M (Growjo estimate) | AI-native low-code test automation, self-healing |
| Katalon | Founded 2016 | 30,000+ teams (per Katalon) | Est. ~$62.2M (Growjo estimate) | Broad quality platform: web, API, mobile, desktop |
| Tricentis Tosca | Tricentis founded 2007 | 3,000+ customers (per Tricentis) | ARR above $500M (reported) | Enterprise model-based automation, SAP testing |
| testRigor | Founded 2015 | Enterprise and digital product teams | Est. ~$15M ARR (GetLatka estimate) | Plain-English test automation, web, mobile, API |
| Functionize | Founded 2014 | Enterprise and large digital teams | Est. ~$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.
-
11
Understand the application
Read configuration, determine what surfaces to inspect, and set up the discovery scope.
-
22
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.
-
33
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. -
44
Normalize and validate the plan
Apply the public JSON Schema gate with AJV, then run Brisk-specific executability checks. Reject anything unsafe.
-
55
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.
-
66
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.
-
77
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.
-
88
Execute the scenarios
Engines run the validated scenarios. Browser workflows through Playwright, HTTP checks through the API engine, contract summaries through the contract engine.
-
99
Collect evidence
Gather logs, traces, screenshots, request/response data, and contract evidence from every engine execution.
-
1010
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.
Context
Booking date after vessel departure
Action
Booking is created
Expected outcome
API rejects with error code
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.
Inspect a repository
Identify framework signals and package metadata
Identify application structure
Supported JS/TS backend framework detection
Discover backend routes
Express, nested routers, route chains, Nest decorators
Discover UI routes
Separate from backend route discovery
Locate OpenAPI files
JSON and YAML contract discovery
Correlate routes & contracts
Report matched, undocumented, and missing routes
Built-in engines
Playwright Engine
BuiltinPlaywrightEngine
Runs browser workflows and grounded UI actions. Captures screenshots, traces, and page evidence.
API Engine
BuiltinApiEngine
Runs HTTP checks, validates response schemas when OpenAPI schemas exist. Captures request/response evidence.
Contract Engine
BuiltinContractEngine
Reads OpenAPI JSON/YAML and emits operation summaries. Connects contracts with runtime execution.
Checked Plan
brisk-aitesting.plan.v1
Engine Router
UI Scenarios
API Scenarios
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.
Extract JSON
Extract structured plan from AI response
Normalize aliases
Resolve safe shorthand references
Inject routes
Add discovered routes when needed
Validate structure
Schema gate + executability checks
Repair
Feedback loop fixes invalid plans
Ground UI
Real page evidence only
Route to engines
Dispatch validated scenarios to the correct built-in engine
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
Blocked
- closeInvented selectors being forced into execution
- closeBypassing plan validation
- closeExecuting malformed or unsupported plans
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.
{
"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
Summary
Total, passed, failed, skipped, errors, pass rate, and duration. The top-level status for CI gates.
Tests
Each scenario with its type, status, assertions, and linked evidence artifacts.
Artifacts
Screenshots, traces, logs, request/response data, and contract evidence.
Handover
Metadata about which systems can consume this result: CI, dashboards, databases, and more.
Your product can use this result for
CI pass/fail gates
Dashboard cards
Test history
Database persistence
Audit logs
Traces & screenshots
Analytics
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.
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.
UI testing
Browser workflows through Playwright
API testing
HTTP checks, status, body, headers
OpenAPI testing
JSON/YAML parsing, response schema validation
Contract drift reporting
OpenAPI vs. implementation comparison
Checked AI planning
AI returns JSON; Brisk validates before execution
Result handover
Versioned JSON for CI, dashboards, databases
Local SDK and CLI
Use inside your app or from command line
Schemathesis engine
Optional Python-based OpenAPI deep checking
Serious SaaS proof app
Real product for testing auth, roles, UI, API
Engine quality checks
Built-in and external engine conformance
Public plan contract gate
AJV-backed JSON Schema validation
Golden expected outputs
Known-good plans and results for regression
Adapter readiness gate
Checklist for adapters marked "built"
Built-in schema fuzzing
Fast malformed-request checks from OpenAPI schemas
Built-in replay engine
Rerun declared HTTP interactions for regression
JUnit & HTML reports
Report artifacts for every run
Non-engine extension QC
Checks discoverers, planners, validators, UI grounders, and AI providers
More proof apps
API-only, Todo, and multi-tenant proof apps
Release readiness
Release check and versioned changelog
Get Started
From install to first run without searching the README.
Install
After installing, create your config with npx brisk-aitesting init.
$ npm install brisk-aitesting
Configuration
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
$ 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
$ 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.
Broader test engines
- arrow_rightAsyncAPI / Pact / message-contract adapters
- arrow_rightSpecmatic / Keploy adapters
Reporting and analytics
- arrow_rightMulti-provider benchmark scoring
- arrow_rightBuilt-in analytics module
Product proof
- arrow_rightFull proof app collection
- arrow_rightFramework-specific examples
Release maturity
- arrow_rightnpm publish workflow automation
Extension quality
- arrow_rightDeeper behavior checks for future extension types
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