Mirrors vs LangSmith

What LangSmith is good at

• Production monitoring at real volume: dashboards, alerts, and cost and token tracking across model providers, which is the part of this problem Mirrors does not touch at all.
• Tracing that reaches past Python and TypeScript. Go and Java SDKs plus OpenTelemetry support are rare in this category.
• A complete evaluation surface: offline and online evals, LLM-as-judge, datasets, annotation queues, a prompt hub, a playground, and CI through pytest and Vitest.
• Enterprise depth: SSO, RBAC and ABAC, SCIM, and the only tier here that will run self-hosted or hybrid inside your own VPC.
• Gravity. If your agent is built on LangChain or LangGraph, turning tracing on is close to free, and 2026 added Sandboxes, Fleet, Engine, SmithDB, and Agent Builder around it.

Side by side

Prices and limits checked against langchain.com on 2 August 2026. We quote the LSU unit rather than a dollars-per-1,000-traces figure because that conversion depends on your plan and your trace shape.

The actual difference

LangSmith is instrumentation. It wraps a run that is happening anyway, keeps the record of it, and lets you score that record offline or online. Throughout, the agent under test is talking to your real database, your real payment API, and your real ticketing system.

Mirrors is the other half of that sentence. It reads your traces, your code, or your API docs and stands up the counterpart: a running service per tool, each with a schema, seeded records that are invented rather than copied from production, and state that persists through a session and resets between runs. Your agent calls it exactly the way it calls the real thing.

The nuance worth stating plainly is that LangSmith does ship simulation and it is real. create_llm_simulated_user drives a multi-turn conversation so you can evaluate an exchange rather than a single reply. What it simulates is the person on the other side. The application, and everything the application touches, still runs.

LangChain says as much in their own material. Their tutorial for evaluating a complex agent has you hand-write the stand-in, switching on an environment flag read out of config: mock = config.get("configurable", {}).get("env", "prod") == "test". Their engineers have also written about using VCR cassettes and a fetch proxy to keep their own tests off the network. Neither is a product. That hand-written layer is the thing Mirrors builds for you, from artifacts you already have.

One word worth disambiguating, because this category overloads it. When these products say sandbox they usually mean a microVM where an agent runs code, and the proxy in front of it injects real credentials so that the code reaches real services. That is the opposite of a fake backend, and it is useful for what it is built for. Nothing on this page claims a competitor lacks one, and the environment Mirrors builds is not one of them.

When to use LangSmith instead

If the question is what is happening in production right now, use LangSmith. Mirrors has no answer for live traffic, and that is not a close call.

Use it also if you need Go or Java tracing, if your observability has to run inside your own VPC, if attributing cost and tokens across model providers is the thing you are trying to control, or if your stack is already LangChain and LangGraph and the marginal cost of turning tracing on is one environment variable. A team that has neither observability nor a test environment should start with observability, because you cannot rebuild what you have never recorded.

Most teams run both

The two layers compose without overlapping, and the trace is the seam. LangSmith records what production did; those traces are exactly what Mirrors reads to build an environment; the replay of a change against that environment produces a new run, which LangSmith records and scores like any other.

A practical split: LangSmith for what happened, Mirrors for what the next prompt would do to it, with LangSmith judges grading the outputs the Mirrors run produced.

What this page compares, and what it does not

These five are the observability and evaluation platforms a team already has open when it asks how to test an agent, which is why they are the pages we wrote. They are not the whole field. Tools that do stand something in for an agent's counterpart, LangWatch's Scenario and Laminar's agent rollouts among them, are outside this comparison, and nothing here is a claim about them.

Standing in for a live dependency is also not a new idea. Record-and-replay HTTP mocking, VCR-style cassettes, predates LLM agents by about fifteen years and is free. What Mirrors adds is the construction and the state: the environment is built from your traces, code, or docs instead of hand-written, and it is a seeded, stateful backend you can reset between runs instead of a fixed transcript of responses.