Free CLI. Runs on your laptop.

Record your traffic. Replay it against your change.

Your service already produces the best test data you will ever have. Capture it, run without your dependencies, and see exactly what your change broke.

brew install speedscale/tap/proxymock

Also available via curl, and for Java, .NET, Node.js, Go, and Python.

Start with proxymock See it on Kubernetes

01 Record real traffic

proxymock record --app-port 8080

capturing on :8080 -> 4919 requests
  POST /api/checkout          1204
  GET  /api/cart/{id}          892
  postgres://orders            2823
written to ./proxymock/recorded

02 Run without the dependencies

proxymock mock --in-dir ./proxymock/recorded

mock server listening on :4143
  postgres://orders        matched
  https://api.stripe.com   matched
  https://auth.internal    matched
no live dependencies required

03 Replay it against your change

proxymock replay --in-dir ./proxymock/recorded \
  --test-against http://localhost:8080

4919 requests replayed
  4917 identical
     2 changed

  POST /api/checkout
  - "tax": 4.20
  + "tax": 4.2000000001

That last diff is a real regression. Nobody wrote an assertion to catch it.

The same recordings run in CI.

Promote a local recording into a CI job and every pull request replays real traffic before merge.
Response diffs are computed against what production actually returned, so there are no assertions to write or maintain.
Sensitive fields are masked at capture time, so recordings are safe to commit and share.
Latency is reported per endpoint at P50 through P99, so performance regressions surface in the same run.

Speedscale replay report showing response diffs against recorded production traffic

What you get

Real traffic, captured once, reused everywhere.

No Kubernetes required

proxymock runs on your laptop against a local process. No cluster, no operator, no sidecar. The same recordings run in CI when you are ready.

More than HTTP

Postgres, MySQL, Redis, and gRPC are captured and mocked at the protocol level, so the dependencies your service actually talks to are covered.

Diffs, not assertions

Replay compares every response against what production actually returned. You do not write the assertions, and you do not maintain them.

A sandbox your agent cannot fake

Coding agents get a deterministic environment and a pass/fail signal from real traffic, instead of grading their own work against tests they wrote.

Your traffic is already there. Start using it.

Install proxymock and get to a first record, mock, or replay in about ten minutes.

Install proxymock Schedule a Demo

Verification for AI-generated code

AI wrote the code.
Real traffic decides if it ships.

Capture production traffic, turn dependencies into mocks, and replay every change before it reaches production. Your coding agent gets an independent check based on how the service actually behaves.

See AI code verification Test it on your service

Agent change #184

checkout-service

BLOCKED

Requests

4,919

Identical

4,917

Changed

POST /api/checkout

response status

expected: 200 OK

actual: 500 Internal Server Error

Fix the change and replay the same 4,919 requests.

Teams use production traffic to check what changed

Capture real application behavior once, then reuse it across development, CI, debugging, and performance testing.

The quality loop

Give every change the same reality check.

One captured snapshot becomes the repeatable environment and the expected behavior. The agent can keep working until the replay passes.

01

Capture production context

Record the requests, responses, protocols, and timing your service already handles.
02

Build an isolated sandbox

Turn downstream APIs and databases into protocol-aware mocks your agent can run anywhere.
03

Replay every change

Run the same production-shaped traffic against the new build in local development or CI.
04

Act on the difference

Compare behavior and latency, fix what changed, and rerun the exact same verification.

One replay, four checks

The test comes from the application.

Production traffic supplies the inputs, dependency behavior, and expected responses. Speedscale turns that context into a check your team can rerun after every code change.

Run the loop locally with proxymock

Behavior

Response bodies, status codes, and schemas compared with captured production behavior.

Performance

P50 through P99 latency measured per service and endpoint during the same replay.

Dependencies

HTTP, gRPC, Postgres, MySQL, and Redis available without a shared test environment.

Regression gate

A repeatable CI result based on traffic the application actually served.

Put production traffic in the review loop.

Start locally with proxymock, or connect a Kubernetes service and replay traffic at scale.

Start for free with proxymock Schedule a Demo