Recce Alternative: Data Workers Reviews the dbt PR, Then Fixes and Verifies What It Finds

If you're looking for a Recce alternative, you already know the riskiest moment in a dbt project is the merge. A one-line change to a join can double a revenue number, and reading the SQL won't show it. Recce was built for that moment. On a dbt pull request it shows the lineage diff and what the change did to the data: row counts, profiles, values, top-k and histograms against production. Since September 2026 its devloop plugin runs the same review on the working tree in Claude Code, before a PR exists.

Then the review finds a problem, and the next steps belong to someone else. Someone has to find the cause, rewrite the model, rerun the checks, rerun the pipeline after merge and confirm nothing downstream broke. Recce's MCP tools only diff, query and record checks. Its Claude plugin lets your coding agent fix what a developer asks for, but Recce doesn't verify the fix, rerun anything or check downstream. Problems that never arrive as a dbt change don't reach it at all.

Recce is the reviewer who writes the comment. Data Workers is the agentic data platform that reviews the code change and its reach, then runs the steps after the comment: fix, rerun, verify downstream and remember. Our Data Change Review agent reviews every dbt PR with a method adapted, with credit, from Recce's open-source work. The rest of the platform routes each finding to the agent that fixes it, verifies the result after merge and covers the whole data lifecycle around it, with one context, one approval flow and one audit trail.

Key takeaways

• •Recce reviews data changes in dbt. Its diffs, checklists and AI summary show reviewers what a change does to the data, from the coding-agent session through the PR. It does that job well, and our review agent adapts its method.
• •Data Workers runs the steps after the review. It routes each serious finding to the agent that proposes the fix, verifies reruns after merge and leaves a receipt on every change.
• •Blast radius goes past dbt. Recce's impact analysis is built from dbt artifacts. Data Workers walks one context graph to the Airflow DAGs and dashboards a change reaches.
• •Changes that never start as a PR are covered too: source renames, ingestion type changes, failed DAG runs.
• •One platform for the whole lifecycle. Incidents, access, cost, migrations and audit evidence run under the same approvals and receipts.
• •One flat fee for the whole loop. Data Workers' flat platform fee covers the review and everything after it: the fix, the rerun, the downstream check and the rest of the back office, with unlimited seats and no usage meter.

Going further. For the step-by-step path from reviewed PRs to agents that fix and verify, read From data engineering agents to an autonomous data platform. For the executive version, read the data leader's guide to data engineering agents. If you're also weighing an IDE-first tool, see Altimate vs Data Workers.

Six things Data Workers does after the review

1. Findings go to the agent that fixes them. When the Data Change Review agent rates a finding HIGH, it doesn't stop at a comment. It emits a structured handoff: a diagnosis to the Incident Debugging agent, a migration to the Schema Evolution agent, a standing rule to the Quality Monitoring agent, or a review to governance. Each proposed fix waits for approval.

2. Reruns verified after merge. A merged PR can still need a full refresh or a backfill. Data Workers proposes the rerun, and once approved it reruns and re-checks the quality and contract assertions until they pass.

3. Changes that never start in a dbt PR. Many incidents begin upstream: a source column renamed, an ingestion sync that changes a type, an Airflow task that fails at 6 a.m. The Schema Evolution and Incident Debugging agents handle those, with or without a pull request.

4. Blast radius across the estate. The Schema Evolution agent walks the Data Context Wizard graph from a changed model to the pipelines, models, dashboards and APIs downstream, so a reviewer sees what the change reaches outside dbt.

5. The rest of the lifecycle. Access requests, cost cleanup and warehouse migrations compete for the same engineers. Agents handle them behind the same approvals.

6. Receipts your auditors can read. Every change carries who or what made it, why, what it touched, who approved it and how to undo it, in Spellbook Data Catalog (in preview), backed by a tamper-evident audit log.

Behind all six are 20+ specialist agents in the Data-Agents Swarm, one context graph and the coding agent your team already uses (Claude Code, Codex or Cursor) as the way in.

One change, five systems

An illustration, not a customer case:

• •09:40. An analytics engineer opens a GitHub PR that joins order_items into fct_orders in dbt.
• •09:52. CI runs. Recce's review shows an 18% row-count increase on fct_orders in Snowflake and a shift in mean amount.
• •10:30. The engineer pre-aggregates order_items, the checks rerun green and a reviewer approves the merge.
• •Next morning, 06:00. The Airflow daily_finance full refresh fails on a source type change from the overnight Fivetran sync. No PR ever showed it, and the Looker average-order-value tile goes stale until someone notices.

Recce's part ends at 09:52, and it does that part well. Data Workers carries the finding to a verified fix and catches the failure that never reached a PR.

What Recce covers, as of October 2026

Recce calls itself "Your AI Data Review Agent." Its open-source core is Apache 2.0 and ships weekly. Here is what its documentation, changelog and repositories say.

Every row is about reviewing a change before it ships. The steps after that review, and the changes that never start as one, are where Data Workers works.

If you're also comparing Recce with Datafold. Datafold is the other long-standing name in PR-time data diffs and now describes itself as a data engineering automation platform. Whichever reviewer you pick, the question this page answers is the same: who owns the steps after the review?

Recce alternatives: one platform for the whole lifecycle

PR review is one stage of a data team's work. The same team also monitors production, works incidents, ships fixes, cuts spend, handles access, runs migrations and produces audit evidence. Each point tool adds another console, another contract and another handoff. Data Workers covers the whole lifecycle with one context, one approval flow and one audit trail.

We score the same ten lifecycle stages on every comparison page. Recce leads on Data Quality, its home stage, and runs close on Schema & Migration through its schema diffs. Data Workers covers every stage.

Recce vs Data Workers on the outcomes you buy

The lifecycle view shows breadth. This view scores seven outcomes around a data change. Recce leads on the review itself, in the PR and before commit. Data Workers leads on the five outcomes after it.

The scores measure scope (what each side covers), not answer quality. They're directional scores of scope, not benchmarks, and the reasoning for every line is in the table.

Where Recce stops

Each limit below comes from Recce's own documentation and repositories. Recce chose to be a reviewer that doesn't write to your code or data, and that choice keeps it safe to run on every PR.

Its tools diff, query and record checks. The MCP server's only writes are check management inside Recce. The query tool runs SQL against your warehouse, which stays safe because Recce asks for read-only credentials. The Claude plugin lets your coding agent make a fix the developer asks for, one session at a time. Recce's devloop skill says plainly that it doesn't check whether the fix landed.

It works from the dev loop to the PR. devloop reviews the working tree before commit, and CI reviews the PR. After merge, CD refreshes Recce's baseline. It doesn't monitor production, respond to incidents or verify anything that runs later.

It's built for dbt. Recce reads dbt's manifest.json and catalog.json. Its open-source repository has an undocumented SQLMesh adapter, and dbt Fusion isn't supported yet per its own open issue. Airflow logic, Spark jobs and ingestion changes sit outside its view.

Recce Cloud supports four warehouses. Snowflake, Databricks, BigQuery and Redshift. For anything else, the docs say to contact Recce.

Its history covers checks. Recce keeps an activity history per check; it isn't a cross-system audit trail of changes made to your data. SSO, RBAC and bring-your-own-cloud are Enterprise features.

Why doesn't Recce just do this itself?

Because Recce made a sensible product decision and stuck to it. It is a reviewer. A reviewer earns trust by never changing what it reviews, which is why its warehouse access is read-only, its MCP writes are limited to checks, and its devloop skill tells the coding agent it has "no standing to approve the commit." That focus is why teams can run it on every PR without a security review of its write path.

Taking the next step means building a different product. Fixing and rerunning across systems needs blast-radius scoping before any write, approvals by domain, a rollback path for every change, receipts an auditor can read, and context about every system the change touches: Airflow, Fivetran, Looker, grants, cost. It also means accepting liability for changes in tools Recce doesn't own. A diff tool that started writing to production would put its own safety story at risk.

That product is Data Workers. We built the write path, the approvals and the receipts first, and adapted the review method from Recce's open-source work so the two fit together.

Where the two overlap

Keep it or replace it

Consolidate onto Data Workers if you want one approval flow and one audit trail for everything agents do, or if much of your change risk starts outside dbt PRs. The Change Review agent covers PR review, and the rest of the platform fixes and verifies what it finds.

Keep Recce in CI and the dev loop if your reviewers rely on its diff view. Run Recce's MCP server in the same coding agent where Data Workers runs. The Change Review agent reads its findings next to its own, and Data Workers carries the serious ones to a fix and a verified rerun. It's a pattern you set up yourself over MCP today. For the dbt side of that wiring, see Data Workers + dbt.

Either way, your data stays where it is. Data Workers stores metadata and scrubbed facts about your data, not copies of your tables.

What it costs

Recce publishes its prices. Free includes 100 agent reviews and 10 customized preset checks a month. Team is $250 a month billed annually, or $300 billed monthly, with 1,000 agent reviews a month, unlimited preset checks and unlimited seats. Enterprise is custom and adds SSO, RBAC, bring-your-own-cloud and semantic layer support.

Data Workers' pricing: the Apache 2.0 core is free. A pilot is $7,500 one-time, credited in full against your first year. Scale starts at $1,000 a month and Enterprise at $3,000 a month (billed annually). Seats are unlimited, there's no usage meter, and there's no markup on model spend because you bring your own model.

If PR review is the whole job, Recce costs less. The Data Workers fee covers a different scope: the review, the fix, the verified rerun, incidents, access, cost and migrations, under one approval flow. See pricing for what each plan includes.

The case for your CFO

The outcome. Every review finding closed and verified. A bad join caught in a PR is good. A bad join caught, fixed, rerun and confirmed on the finance dashboard is the result the business pays for, and the failures that never appear in a PR get the same treatment.

The risk story. At L1 agents observe. At L2 they propose and a person approves every change. At L3 they act only where the change can be rolled back. Every write is scoped for blast radius first, no agent can approve its own work, and each change leaves a receipt: who or what acted, why, what it touched, who approved it and how to undo it. There's no migration. dbt, Git, the warehouse and Recce stay where they are.

Why now. Review is moving into the coding agent. Recce's devloop plugin already runs it before commit. Once an agent can read the finding and edit the model, somebody has to own what it does next, across systems, with approvals and a record.

The first win. A shadow run on the next 20 dbt PRs: every HIGH finding routed to a proposed fix, with the downstream reach shown.

What stays the same. Recce, if reviewers like it. dbt, your Git host, your warehouse, and the coding agent as the way in.

The pilot path. Start with a pilot (see pricing). The pilot is credited in full against the first year.

The sentence to repeat upstairs: "Recce tells us what a change will do; Data Workers makes sure what we find gets fixed, verified and recorded."

The fastest first win: a shadow run on 20 PRs

Start where the review already tells you something is wrong. Connect Data Workers to your dbt repo, warehouse and Airflow, and run the Change Review agent alongside Recce on your next 20 dbt PRs in propose mode. For every HIGH finding, look at the routed handoff (a diagnosis, a quality rule or a migration) and the downstream assets the impact walk finds outside dbt. Measure one number: findings closed with a verified rerun versus findings left at the comment. When your team has approved the proposals as-is for a few weeks, move that domain up a level while merge stays with a human. The playbook covers the full sequence in From data engineering agents to an autonomous data platform.

What each Data Workers product adds

Autonomous Data-Conductor. The orchestrator that owns an outcome rather than a step: detect, diagnose, fix, review, verify and remember. It scopes the blast radius before acting, proposes each change for approval and leaves a receipt on every one.

Data-Agents Swarm. 20+ specialist agents that do the work a review points to. For a Recce team the ones that matter most are the Data Change Review agent, the Schema Evolution agent, the Incident Debugging agent, the Pipeline Building agent and the Quality Monitoring agent, which turns a recurring review finding into a standing rule.

Data Context Wizard. One governed graph across warehouses, dbt, orchestration and BI, over 50+ connectors, so the next change starts with what the last review taught.

Spellbook Data Catalog. The control plane for agent work, in preview. Every proposed change lands in one inbox (approve, steer, send back or roll back), asset pages cover the whole estate, and an authority guard enforced in code stops any agent from approving its own work.

Autonomy guardrails and security

Recce handles agent risk by keeping its own tools from writing. Data Workers lets agents change things under graded, reversible control.

• •Autonomy is set per domain. Quality rules can run at L3 (act, reversibly) while production reruns stay at L2 (propose).
• •New deployments start observe-only. You extend autonomy one domain at a time as the receipts earn trust.
• •Every write is scoped before it runs, with blast radius computed across platforms.
• •HIGH review findings can't be self-approved. Approval has to reference a governance review.
• •Every change leaves a tamper-evident receipt with a rollback path.
• •Least privilege. Data Workers acts with the grants you give it, through each platform's own permission system.

"Recce has an MCP server and a Claude plugin. Doesn't that close the gap?"

Recce's MCP server is free in open source and available on Cloud, and its Claude plugin runs the review inside Claude Code, now before commit too. An engineer can pull a change's diffs and ask the coding agent to fix the model in the same session. That's useful, and we'd keep it.

What it leaves open is everything after the edit. It's one developer, one session and one fix, and Recce doesn't verify the fix landed. Nobody scopes the blast radius beyond dbt, gates the change by domain, reruns the pipeline after merge, re-checks the assertions or records the outcome in a shared graph. Data Workers is that operating model, and its agents are MCP servers the same coding agent can call.

How it fits together

Getting started takes no migration. Connect Data Workers to your warehouses, dbt project, Git host and orchestrator, plus Recce's MCP server if you keep it. Every agent starts observe-only, and the first thing you see is what each recent review finding's fix would have been.

When Recce alone is enough

If your stack is a single dbt project, your team fixes review findings quickly once it sees them, and incidents outside PRs are rare, a PR reviewer covers it, and Recce is a good one. Data Workers earns its place when you also own what happens after the merge and the changes that never arrive as a PR.

FAQ

What's the main Recce alternative if we want findings fixed and verified? Data Workers. Its Change Review agent reviews every dbt PR with a method adapted from Recce's open-source work, then routes each HIGH finding to the agent that proposes the fix and verifies reruns after merge.

How does Data Workers pricing compare with Recce? They buy different scopes. Recce prices PR review. Data Workers is one flat platform fee for the whole loop and the rest of the back office: Scale from $1,000 a month and Enterprise from $3,000 a month (billed annually), unlimited seats, no usage meter and no markup on model spend. The $7,500 pilot is credited in full against your first year. See pricing.

Does Recce's Claude plugin fix code? Recce's own tools don't edit code or data. Its devloop plugin lets the coding agent make a fix the developer asks for, and it says it doesn't check whether the fix landed. Data Workers proposes fixes behind approval and verifies the result.

Does Recce work after merge? Its CD setup refreshes the Recce baseline from the latest production artifacts. It doesn't monitor or verify production data.

Recce vs Datafold: which should I compare against Data Workers? Both are reviewers of data changes. Data Workers is the choice when you want the review, the fix and the verification under one approval flow, whichever reviewer you keep in CI.

Can Data Workers read Recce's diffs? Yes, over MCP today. Run Recce's MCP server and Data Workers' agents in the same coding agent. It's a pattern you set up yourself.

What happens if an agent gets a fix wrong? Data Workers scopes every write before it runs and sends it to review at the autonomy level you've set for that domain. Every change leaves a tamper-evident receipt and a rollback path, and no agent can approve its own work.

Sources

Sources for Recce capabilities, statuses and pricing are current as of October 2, 2026: the homepage, pricing, changelog, MCP server docs, warehouse setup, CD setup, CI setup, Cloud vs OSS, Claude plugin docs, check activity, the open-source repository and its releases, the adapter directory, issue #1053 and the Claude plugin repository. Datafold positioning: datafold.com. Data Workers pricing: dataworkers.io/pricing. Product names and statuses change quickly; if we've got something wrong, tell us and we'll fix it.