SpecTestEngineVerification workspace
Explore workspace
Spec-driven testing for AI-assisted development

Keep intended behavior in control.

SpecTestEngine turns expected behavior into executable specifications and connects every run, diff, browser journey, snapshot, and production check to evidence you can inspect.

Explore the workspace See how it works
Durable verification for agentic engineering using spec-driven developmentIntent. Implementation. Confidence that AI-built changes don’t break what already works.
The SpecTestEngine platform

One platform. Four connected layers.

Contracts become executable journeys, every run retains evidence, and delivery stays tied to the same intent.

01

Contracts

Define behavior across every protocol.

Protocols
  • REST
  • SOAP
  • GraphQL
  • WebSocket
  • SSE
  • gRPC
  • MQTT
Authoring
  • Craftsman
  • Automation Assembler
  • Reusable fragments
  • Runtime variables
Generation
  • Craftsman · Generate Spec
  • OpenAPI TestGen
  • Positive + negative generation
  • Flow generation
Lifecycle
  • API Contract RegistryIn development
  • Immutable contract releasesIn development
  • Managed TDD campaignsIn development
02

Journeys

Connect complete behavior across system boundaries.

Compose
  • Flow canvas
  • Mixed Execution Flows
  • API + browser journeys
Browser
  • Browser Recorder
  • UI Macros
  • Visual exclusions
  • Network validation
Execute
  • Shared context
  • Draft runs
  • Saved runs
  • End-to-end outcomes
03

Evidence

Make every change inspectable.

Runs
  • Run results
  • Compare runs
  • Structured behavior diffs
Visual
  • Run visual diffs
  • Document Visual
  • Exclusion regions
Regression
  • Snapshot regression control
  • Release history
  • Definition + behavior history
Operations
  • Dashboard
  • Observability
  • Incident notifications
04

Delivery

Bring portable verification wherever teams build and ship.

Automation
  • ATF Export
  • Portable test code
  • Environment profiles
  • CI/CD templates
  • Compile validation
Interfaces
  • MCP connection
  • Public API
  • SDK access
Documentation
  • Product Docs
  • Contract-driven API documentationIn development
  • Customer Integration PortalIn development
One continuous verification journey

From the first live request to confidence in every release.

The same intent moves through authoring, execution, browser automation, regression control, observability, and delivery. Nothing important is flattened into a disconnected test result.

01
Craftsman

Capture intent from real behavior.

Start with the system as it behaves today. Send real requests, carry values between calls, preserve reusable fragments, and turn a proven response into an executable contract.

  • Chain live calls
  • Capture variables
  • Generate executable specifications
Live requestsVariablesFragmentsAI-assisted authoring
Open Craftsman
Product screens01 / 04
02
OpenAPI TestGen

Generate broad coverage from the contract.

Turn an OpenAPI contract into an executable starting point. Generate positive and negative specifications together with connected flow scenarios, then review coverage before the assets enter Automation.

  • Generate positive and negative contracts
  • Create multi-step flow drafts
  • Review operation coverage before saving
OpenAPIPositive + negativeFlow generationCoverage
Open OpenAPI TestGen
Product screens01 / 03
03
Automation · Assembler

Turn intent into contracts you can reuse.

Create specifications yourself or assemble them from durable building blocks. REST, SOAP, GraphQL, streaming, and UI assets stay organized in one automation workspace.

  • Author directly
  • Assemble from fragments
  • Reuse Craftsman output
RESTSOAPGraphQLStreaming
Explore Automation
Product screens01 / 04
04
Run · Result · Compare

See the change — and why it matters.

Execute a contract, inspect exactly what happened, then compare results without reducing the answer to a pass or fail badge. Definition drift and behavior drift remain distinguishable.

  • Inspect every assertion
  • Compare run against run
  • Keep request and response evidence
Structured diffTraceable evidenceRegression context
Review test evidence
Product screens01 / 02
05
Browser Recorder

Bring the browser into the same evidence model.

Record a real browser session as a reusable UI macro. Actions keep selectors and timing, image assertions keep explicit exclusions, and captured network calls can become status, content-type, header, and body expectations.

  • Drive a live browser
  • Validate images with exclusion regions
  • Turn recorded network calls into expectations
Live ChromeVisual exclusionsNetwork checksReusable macro
Open Browser Recorder
Product screens01 / 04
06
Document Visual

See document changes without hiding exceptions.

Compare rendered documents instead of treating a downloaded file as an opaque attachment. Changed pixels remain visible, intentional dynamic regions can be excluded, and changes inside an exclusion stay distinguishable.

  • Find rendered document changes
  • Exclude intentional dynamic regions
  • Keep masked fingerprints as durable assertions
PDF + imagesVisual diffExclusion regionsMasked evidence
Review document evidence
07
Mixed flows

Verify complete behavior, not isolated calls.

Combine protocol contracts and browser macros into a single journey. A flow verifies the user outcome across service boundaries instead of testing isolated endpoints in separate tools.

  • Connect protocols and UI
  • Share variables across steps
  • Run one end-to-end outcome
API + browserShared contextEnd-to-end
Build a flow
Product screens01 / 03
08
Snapshot timeline · Canvas

Make regression history understandable.

Freeze meaningful release evidence as a snapshot. The canvas shows how definitions and observed behavior evolved together, so regressions keep their historical context.

  • Preserve approved baselines
  • Compare releases visually
  • Track tests and results together
Release memoryDefinition historyBehavior history
Explore Snapshots
Product screens01 / 03
09
Observability

Observe whether the system is still correct.

Use the same specifications and mixed flows as recurring checks. Monitor availability, latency, and business behavior together, then route incidents through the channels your team already uses.

  • Schedule saved tests
  • Verify returned values
  • Route actionable incidents
Recovery trackingBehavior checksLatencyNotifications
Open Observability
Product screens01 / 03
10
Dashboard

Read system health without losing the evidence.

See the health of the whole project after checks have run. The dashboard and its checks adapt to each environment, connecting reliability, latency, regressions, source coverage, and the incidents that need a decision now.

  • Read environment health at a glance
  • Investigate regressions and latency
  • Move directly into retained evidence
Environment healthCoverageIncidentsEvidence
Open Dashboard
Product screens01 / 03
11
ATF Export · CI/CD

Take the verification layer with you.

When the project is ready to leave the platform, export it. Generate a readable, compile-validated package or save a reusable profile for repeatable checks in your own CI/CD pipeline.

  • Generate portable test code
  • Configure target environments
  • Validate before download
Portable codeEnvironment profilesCI templatesNo lock-in
Explore ATF Export
AI-native · MCP

Give AI agents real verification tools.

Connect Codex, Claude Code, or another MCP-capable agent to SpecTestEngine. With user-authorized, project-scoped access, an agent can discover tools, create specifications, run checks, inspect structured evidence, and report what changed.

Controlled by your project accessStreamable HTTP · OAuth · scoped tools
Explore MCP for AI agents
Agent verification loop MCP connected
MCPScoped connection
01Agent intentRequest a verified outcome

Describe the behavior to create, run, or inspect.

02SpecTestEngineExecute scoped tools

Apply project access across the verification workspace.

03Verified evidenceReturn a structured result

Outcomes, diffs, and retained artifacts stay inspectable.

A durable verification layer

Build faster with people and agents — without losing the contract.

Specifications can be authored, generated from live systems, or produced from OpenAPI contracts. Public APIs, SDKs, and MCP integrations bring the same verification loop into developer tools and CI.

Contact us

Let’s make confidence part of every release.

Reach out when you are evaluating SpecTestEngine, planning an integration, or need clarity on a workflow. You’ll receive practical guidance directly from the team behind the platform.

Product and architecture guidance Evaluation, onboarding, and integration support A direct reply from the team
Direct to our team

Tell us what you want to verify.

Your message goes to team@ste.software. We use your email only to reply.