Skip to main content
Mirrors rebuilds the systems your AI agents call, then replays real sessions against each prompt, tool, or model change before it reaches production. Nothing real gets touched. Your agent takes real actions on real systems, so testing changes against live production is slow, risky, and irreproducible. Mirrors turns traces, agent code, tool code, or docs into a runnable staging environment: a seeded database plus bound tools that behave like the systems your agent calls. Agents replay against that environment, never live systems, so even destructive flows such as refunds, deletes, and sends are safe to test.

​
When should I use Mirrors?

Use Mirrors when your agent acts: calls tools, hits APIs, or touches data, and a change can break behavior your unit tests never see. The thing it gives you is somewhere safe to run that change first, against a copy of the systems the agent calls rather than the systems themselves. Reach for it when:
  • Your agent calls tools against real systems, and testing a change against production is slow, risky, or impossible to reproduce.
  • You want every prompt, model, or code change checked against real recorded sessions before it merges.
  • You need to replay destructive flows (refunds, deletes, sends) safely and repeatedly.
  • You want a reproducible environment: the same seed produces the same world for every run.
If your agent only produces text (no tools, no side effects), a plain script over model outputs is probably sufficient. Mirrors earns its keep when there is an environment to get right.

​
How does Mirrors work?

Mirrors takes what you already have (traces, agent code, tool code, or docs) and builds a runnable copy of the systems your agent calls: a seeded database plus bound tools. You then replay recorded sessions against any version of the agent and compare the outcome. Three stages:
1

Provide what you already have

Start from traces, agent code, tool code, or docs. The optional mirrorkit collector keeps the environment current from live sessions.
2

Mirrors builds the environment

Schema, fabricated seed data, and tool behavior become a runnable copy of the systems your agent calls, with fidelity measured against real traces.
3

Replay any session against any change

Your agent stays on your machine and calls the twin’s tools instead of production. Same session, two versions of the agent, one caught regression. Production is never touched.

​
Where should I start?

If you want the shortest path to a result, work through the Quickstart: it takes you from connecting an MCP client to your agent’s first call against a twin. If you would rather understand the model first, read How it works.

Quickstart

Connect your agent and gate merges in CI in a few minutes.

How it works

Environments, fidelity scoring, stable seeding, and sessions.

MCP server

Drive Mirrors from Claude Code, Cursor, VS Code, ChatGPT, and more.

API reference

The versioned /v1 API, authenticated by workspace keys.

​
What can I do with Mirrors?

Anything that needs your agent to actually run: catching regressions, reproducing a specific incident, exercising flows too destructive to test for real, and scoring whether a change made the agent better. All of it works the same way, against a copy of the agent’s world rather than the real one.
  • Catch regressions before they ship: replay real sessions against every change and see exactly what would have broken.
  • Reproduce the bug that paged you on demand in a stable, seeded environment.
  • Test risky and destructive flows (refunds, deletes, sends) safely against the environment instead of live systems.
  • Gate CI on replays so every change is checked before it merges.
  • Measure whether an agent change is actually better with per-tool coverage and accuracy scores.
  • Drive environments from your own code over a versioned /v1 API authenticated by workspace keys.
Privacy by construction: the environment keeps only the shape of which entities exist and how they connect. Every actual value is fabricated, so redacted sessions work fine.

​
Next steps

  • Work through the Quickstart: MCP client to your agent’s first call in four steps.
  • Understand the model in How it works.
  • Reading with an AI assistant? These docs are built for that: every page has a raw-markdown twin, an llms.txt index, and one-click handoff to Claude or ChatGPT.