Changelog

Your agent can now take part in the review process. It inspects the diffs in a test run, works out which ones are real regressions, and leaves comments explaining what went wrong.

It also works the other way round: it can read the diffs you've rejected and the comments you've already left, then use that feedback to fix the issues for you.

Try it out today with the Meticulous CLI, Skills or the MCP server — see the agent swarm docs to get started.

Meticulous does a lot of dark magic under the hood — error detection, network patching, powering up the flux capacitor. Sometimes, though, the easiest way to understand how your app reached a particular state is to watch the before and after replays side by side. Now you can.

• 🛜 More automated built-in checks (Beta) — We can now catch more non-visual regressions automatically, from increases in network traffic to extra React component renders. See the built-in checks docs, and let us know if you'd like early access.
• 💨 Faster onboarding — Adding more internal projects to Meticulous? New automated tooling makes it much smoother. See the docs.
• 🔗 Open a diff in your app — Right-click a diff to jump straight to that URL in your local development branch or your preview environment, so you can fix it even quicker.

"Did Meticulous actually test my change?" is the first thing you ask when you open a test run. Now it's easier than ever to answer that.

You can see every line your PR touched, the user flows that ran (with hover previews), and exactly which routes produced diffs. It's available to everyone — no beta, just transparency.

Meticulous is only as good as the sessions you record. Our original approach to boosting coverage — session extension, mutated network requests, and feature flags — reaches new uncovered states in your existing sessions.

Now we're taking that further. When your PR touches code that no existing session covers, our agentic harness generates entirely new sessions: it reads your code diff and existing recordings, plans new test cases, drives your app, and shows you how your feature behaves across a variety of edge cases.

This makes new functionality much faster to review, and it feeds coverage into future test runs too. We're looking for design partners — reply if you want early access.

Let your agents interface with Meticulous directly, helping them ship fewer regressions with less oversight. Our MCP server lets them see test run diffs, replay details, coverage data, and more. See the docs to get started.

• ♿ Accessibility testing (Beta) — We run axe-core across every replay in a test run and flag any new accessibility violations on the PR that introduced them.
• 💬 Comments are GA — The screenshot-doodle-and-share era is over. Comment directly on the exact spot on a diff and tell your team exactly what needs to change.
• 💅 Redesigned documentation — Rewritten, searchable, and restructured so both you and your agents can find answers more easily. Our changelog lives there too now.
• 🖼️ Replay fidelity improvements — On complex apps, playback videos were sometimes rendered without styles, making CSS diffs painful to debug. Not anymore.

Claude, migrate all 1000 class components to hooks. Use Meticulous to test this PR locally: if you see visual diffs, fix and re-run till you eliminate all unexpected diffs. Don't change any components Meticulous doesn't have 100% coverage for.

Claude, review the Meticulous test for the current commit, fix any issues.

Meticulous has thousands of sessions recorded, each mapped to the lines of code in your codebase, and covering real user journeys, network mocks and data edge cases.

Meticulous skills let your agent leverage this: either by pulling the results of a Meticulous test run, or by proactively finding the relevant sessions impacted by the local changes and running them against them. Get started here.

We're actively expanding these skills. If you've got a workflow you wish you could hand to an agent but can't, let us know!

Meticulous simulates most code paths and edge cases in your application on every change. Custom checks let you piggyback on this to detect regressions in anything you can measure.

We have checks that flag if a PR significantly increases:

• React-component re-renders
• Number of network requests made
• Bytes of JS code loaded across many flows
• JS statement execution count (deterministic proxy of CPU time)

You can also write your own checks – covering anything from performance to accessibility. Meticulous's deterministic browser can help reduce noise in many performance measures. Let us know if you'd like early access.

Reviewing as a team usually means screenshotting a diff, pasting it into Slack, and writing "wait, is this expected?" We're fixing that. You're now able to drop a comment on a diff and have the conversation right inside Meticulous, where all the context already lives. This is rolling out in beta shortly, give us a shout if you want early access.

Meticulous has always been brilliant at detecting frontend changes. Now we're going down the stack.

We've started recording and replaying what your server does, eg. Postgres queries and outbound HTTP calls, and surfacing backend spans right in the network tab alongside frontend requests. If you run a server-side-rendered app and you've ever wanted Meticulous to see the whole picture, this is for you.

• 🔌 WebSocket traffic in the network panel – The session network panel now logs WebSocket messages, not just HTTP requests, so realtime apps are far easier to debug.
• ⚙️ Web Worker replay – Apps that offload work to Web Workers now replay faithfully instead of going quiet.
• 🪟 Same-origin iframes in screenshots – We now inline same-origin iframe DOM into the screenshot, so embedded content actually shows up in your diffs.
• 🆕 Onboarding Explanation – improved experience for new joiners with more educational content on how to use Meticulous in the UI.

When you use Debug with AI, you get a full diagnosis of the difference. We rebuilt it so you can run it directly from the test run page. It now lives as a tab in the modal after you click into a diff. The agent reads in context from your PR and the Meticulous replay so it knows what code changed as well as all the events leading up to the diff.

We've added new tabs to the session recording page, making it easier to debug the recorder on new projects. The context tab shows you the user identity, session context, and what feature flags were active during that session. The network tab gives you a full log of every HTTP request, WebSocket message, and streaming fetch from that recording.

We have made it simpler to explicitly record a session for Meticulous rather than relying on background recordings. You can now see the length of the current recorded session and pin and label it directly from your frontend. Read more on how to get started.

• 📺 Live test run statuses auto-update – The test runs overview page now updates in real time; no more manually refreshing to see if your run finished.
• ⏩ Timeline jumps to the right screenshot – Opening the Timeline tab now scrolls straight to the screenshot you're looking at instead of dropping you at the top. The selected event is also saved in the URL, so when you share a link, whoever opens it lands right on the event you were inspecting.
• 🕵️ User event timeline upgrade – Side-by-side details panel, screenshot previews, and a real DOM path-diff on each event so you can see exactly what changed in the tree, not just that something changed.
• 🦾 Agent CLI – We love how you have been weaving Meticulous into your agentic setups. You can now log in directly via OAuth in the CLI rather than having to rely on an API token. Check out our docs to get started with agents in Meticulous.

When looking at the before and after screenshots has you scratching your head, click on a diff to open up the new focused full-screen modal. You can see everything that happened leading up to that diff, and rapid access to all our more advanced debugging tools such as HTML DOM snapshots, replays, etc.

We've spent a lot of April making test runs quicker. A few of the bigger pieces:

• Parallel base & head execution – head replays no longer wait for the base run to finish. You'll notice this even more on stacked PRs
• Session slicing – a single long session used to slow down how quickly we could share test run results. They're now sliced into shorter, replayable chunks, which gets more of your real user flows into every test run without dragging runtime up
• Faster startup – replay workers have been rearchitected so less time is spent waiting for your test run to start executing
• Faster uploads – S3 transfer acceleration is on for recorder, asset, and container uploads
• More resilient runs – one bad chunk no longer fails the whole test run; we will automatically retry

Visual diffs are great, but "did this PR make the app slower?" is a question we keep hearing. Replays now capture real performance signals - memory usage, CPU pressure, TTI and more. Pair that with hardware-pinned benchmarking (so you're comparing apples to apples across instance generations) and you can start spotting perf regressions on the same PR-by-PR cadence as visual ones.

This is early and we're looking for design partners to shape it. If perf regressions are a thing your team cares about, let us know and we'll get you set up.

The HTML diff viewer now surfaces React component names (resolved through your source maps), so you can tell what component you're looking at without playing detective.

• 🔀 Session extension (Beta) – adds coverage to your project by intelligently mutating session data from network traffic, feature flags, etc. to hit uncovered paths. Let us know if you'd like us to enable this feature for your project.
• ✅ Describe Tested rolls out to everyone – The PR coverage callout that tells you whether Meticulous actually exercised the code your PR touched is now on for all projects, thank you to everyone who used the beta feature!
• 🪪 Reader role + project-scoped SSO claims – New read-only role and meticulous_role / meticulous_projects SSO token claims so you can give people access to specific projects without handing over the whole org.
• 📋 Copy as prompt – One-click copy of a diff (with screenshot URLs and React component-source metadata) as an LLM-ready prompt - paste into your Claude Code to give it context on what you want to fix.
• 🧰 Broader recorder coverage – Better fidelity for Rive animations, navigator.locks, SubtleCrypto.digest, PressureObserver, ReportingObserver, tRPC batched/streaming requests and batched GraphQL.
• 🗺️ Unminified Stack Traces – Error reports in your application now display exactly where in the application they occurred, not just that they occurred!
• 🤖 Agentic Skills – we're continuing to iterate on our agentic skills library. Let your agent execute Meticulous against its local changes and iterate on the results, e.g. "Upgrade React major version and then use Meticulous to iterate until you remove all unexpected visual differences".