You're on BigID: BigID Finds and Classifies Sensitive Data Everywhere. Data Workers Keeps the Pipelines Carrying It Right
On BigID? Keep it for discovery, classification, DSPM and AgentIQ. Data Workers traces each finding to the pipeline change behind it and proposes the fix to its owners, behind approvals.
Your sensitive data map lives in BigID. Scans run against BigQuery, Cloud Storage, Snowflake, Databricks, file shares and SaaS apps, at metadata, sample or full depth per source. More than 2,000 pretrained categories and LLM classification label what they find, and data owners review and attest the findings. DSPM ranks the risk on sensitivity, exposure and activity, including the AI models and agents that reach the data. Since September 29, AgentIQ (generally available, per BigID's page) lets your team run that program from a prompt in Claude, Copilot, GPT or Gemini, with four agents at launch: Remediate Sensitive Data, AI Governance Enforcement, Access Exposure Analysis and Privacy Operations. BigID finds and classifies sensitive data everywhere. Data Workers keeps the pipelines carrying it right: when a finding traces back to a dbt model, a load or an export, it finds the change behind it and proposes the fix to the people who own each part, behind approvals.
Key takeaways
- •BigID keeps its job. Discovery, classification, DSPM, access governance, retention and AgentIQ stay where they are. Data Workers works with BigID from day one.
- •BigID connects over its API or MCP server today. Your engineer's assistant holds BigID's MCP server and Data Workers' MCP servers side by side, so a finding moves from one to the other in one conversation.
- •A finding becomes a traced cause. Data Workers follows the flagged column through dbt lineage and the team's context-graph notes to the change that introduced it and to everything that reads it.
- •Each owner approves their own part. The dbt fix arrives as a diff; access and masking arrive as proposals the owners apply; cleanup arrives as a list; the rebuild is queued through your orchestrator after approval.
- •Every fix leaves a receipt with the finding, the trace, the diff, the approvers and the rebuild run, and BigID's rescan result linked by your privacy team.
BigID finds and classifies sensitive data everywhere. Data Workers keeps the pipelines carrying it right.
BigID answers where sensitive data sits, how risky it is and who or what can reach it. Data Workers answers the questions a data team gets next: how did it get there, what else did the pipeline copy it into, and what has to change, in which system and by whom, so it stops arriving.
Here is a week at a subscription software company. A Prefect deployment, intercom_load, runs a dlt pipeline every night that loads Intercom conversations into the BigQuery dataset intercom_raw. A second deployment, support_kb_build, runs dbt Core to build analytics.fct_support_threads and an embeddings model that a Vertex AI support agent retrieves from, then exports the mart as Parquet to a Cloud Storage bucket for an outsourced quality-review vendor. The team recorded notes in Data Workers' context graph naming the support agent as the reader of the embeddings table and the export task as a reader of the mart. BigID scans BigQuery and Cloud Storage on a schedule. This is an illustrative example.
| Time | System | What happens |
|---|---|---|
| Thu 15:40 | GitHub and dbt | Pull request #412 merges: fct_support_threads gains body_text, the full conversation text, so the support agent can answer from past threads |
| Fri 01:00 | Prefect and dlt | intercom_load loads the night's conversation parts into intercom_raw, as it always has |
| 01:25 | Prefect and BigQuery | support_kb_build runs dbt. The mart and the embeddings now carry full chat text, including about 1,900 messages where customers typed a card number, and many phone numbers |
| 01:50 | Cloud Storage | The export task writes the mart as Parquet to the quality-review bucket |
| Mon 06:00 | BigID | The scheduled scan classifies card and phone numbers in body_text, the embeddings table and the Parquet files, and raises a high-risk finding: the dataset is readable by the support-all group and feeds an AI agent |
| 06:05 | Slack | The finding posts to #data-security. The privacy lead assigns it to the data platform on-call |
| 08:10 | Claude | The on-call engineer opens the finding through BigID's MCP server and asks Data Workers, in the same session, where body_text comes from and what reads it |
| 08:14 | Data Workers | The dbt manifest lineage traces body_text to intercom_raw.conversation_parts.body through stg_intercom__conversation_parts, and Data Workers' review of pull request #412 shows the lineage diff that added it. blast_radius_analysis lists the readers: the embeddings model, the support agent from the team's note, and the export task from the team's notes |
| 08:25 | Slack and Spellbook | One change set goes to four named owners: a dbt diff, with its blast radius, that redacts card and phone patterns in staging and carries only body_redacted into the mart; a proposed BigQuery access change, drafted from BigID's finding, that drops support-all and keeps the agent's service account; a policy tag and masking proposal for the column, as a dry run; and the export path to clear |
| 08:40 | Vertex AI | The support agent's owner points it at its previous data store while the fix lands |
| 09:05 | GitHub | The engineer reviews the diff, approves and merges |
| 09:15 | BigQuery and Cloud Storage | The platform owner applies the access change. The export owner deletes the three files and asks the vendor to purge its copies |
| 09:30 | Prefect | After approval, Data Workers queues a full-refresh run of support_kb_build and reads the flow run state until it completes at 10:02 |
| 11:00 | BigID | A change-based rescan finds no card or phone numbers in the mart, the embeddings or the new export. The privacy lead closes the finding and links the rescan result to the record |
| 11:10 | Spellbook | The receipt holds the finding reference, the trace, the #412 lineage diff and the fix, the access change and who applied it, all four approvers, the Prefect run and the linked rescan. The exposure window, Fri 01:25 to Mon 09:15, goes to the privacy team |
BigID did its job: it classified the values correctly, saw the AI agent in the path and ranked the risk. The cause was a pull request, and the copies sat in three systems with three owners. Each approved their own part, and the support agent went back on clean data before lunch. The approved fact that body carries customer-typed card numbers now sits in the Context Wizard graph, so the next person who asks about that column gets the answer with its source.
| Job | What BigID does | What Data Workers does |
|---|---|---|
| The map | Discovers and classifies sensitive data across structured and unstructured sources | Joins the finding your assistant brings to lineage, runs and owners |
| The risk | DSPM ranks findings by sensitivity, exposure, activity and the AI that reaches them | Leaves the risk call to BigID and its owners |
| The cause | Shows where the sensitive data sits now | Traces the column through dbt lineage to the change that introduced it |
| The spread | Finds each copy it scans | Lists every model, export and agent that reads the column, from lineage and team notes |
| The fix | AgentIQ agents revoke access, remediate exposure, apply retention, quarantine and enforce policy | Proposes the dbt diff, the access change and the masking for their owners, then queues the rebuild after approval |
| The proof | A rescan confirms the data is gone; every agent action is logged to a person | Writes a receipt that links the finding, the fix, the approvers and the run |
Why doesn't BigID just do this itself?
Because BigID is built to be the neutral map and enforcement point for sensitive data across an entire estate, and its actions follow that job. AgentIQ is a real step forward: its agents investigate a finding and act on it, and BigID lists what that means: revoke access, remediate exposure, apply retention, quarantine, enforce policy, fulfil requests. The agents inherit the requesting person's permissions at BigID's API and MCP layer and log every action to a name. That is the right design for a data security platform.
Changing the dbt model that keeps producing the problem is a different product with a different liability. It needs context about Intercom, dlt, Prefect, dbt, BigQuery, Cloud Storage and the agent that reads the result; blast radius across all of them; a named owner's approval for each change; a rebuild in the right order; and proof the fix held. A security platform that rewrote pipelines would be classifying data it had just changed. Data Workers is the product on the other side of that line, and it hands every BigID decision back to BigID.
Every tool owns a slice. Data Workers covers the whole lifecycle
BigID owns its slice: finding and classifying sensitive data everywhere, and managing the risk around it. Each point tool adds another console, contract and handoff. Data Workers covers the whole lifecycle with one context, one approval flow and one audit trail, and builds on the map you keep in BigID.
| Stage | Data Workers | BigID | Why we scored it this way |
|---|---|---|---|
| Catalog & Context | 9 | 7 | BigID's catalog holds what it discovered and classified, and its MCP server hands that context to agents. Data Workers joins its context graph to lineage, runs, schema changes and usage. |
| Analytics & Insights | 8 | 3 | AgentIQ answers questions about risk and exposure and builds reports. Data Workers answers questions about the data itself from governed context. |
| Data Quality | 8 | 4 | BigID's minimization work serves privacy and AI readiness. Data Workers checks nulls, keys and minimum row counts after runs and proposes the fix at the cause. |
| Observability & Incidents | 8.5 | 3 | BigID raises findings on sensitive data and access risk. Data Workers detects, diagnoses, fixes and verifies data incidents across systems, with a receipt. |
| Pipelines & Ingestion | 8.5 | 2 | BigID scans what pipelines land. Data Workers traces columns through dbt lineage and queues reruns through your orchestrator after approval. |
| Schema & Migration | 8 | 2 | Change-based scans pick up new data for classification. Data Workers reviews the change that adds a column, assesses impact and plans migrations in approved waves. |
| Governance & Access | 8.5 | 8.5 | Access governance for people and AI agents, plus native tagging and masking on Snowflake and Unity Catalog. Data Workers proposes the access change a fix needs and applies Unity Catalog grants after approval. |
| Security & Privacy | 8 | 9.5 | BigID's home stage: 2,000+ pretrained categories, LLM classification, DSPM and remediation, now operable by agents through AgentIQ. Data Workers proposes the masking and the pipeline fix for the owners. |
| Cost / FinOps | 8 | 2 | BigID does not manage warehouse spend. Data Workers traces Snowflake credits to the dbt model, reads BigQuery spend as an account total and reads AWS Cost Explorer. |
| MLOps & Models | 7.5 | 4 | AI governance covers the models, agents and training data BigID can see. Data Workers keeps the data feeding features and retrieval healthy upstream. |
How BigID and Data Workers work together
Your people stay where they are: Claude, Copilot or Gemini for questions and code, BigID for the sensitive data map and its agents, BigQuery and dbt for the data. Spellbook Data Catalog (in preview) is where the data team looks: each finding Data Workers is working, the proposed changes, blast radius, approvers and rollback, with approval requests reaching people in Slack or email. Underneath, Data Context Wizard keeps one governed context graph, the Data-Agents Swarm does the work with more than 20 specialist agents, and the Autonomous Data-Conductor runs each fix (detect, diagnose, fix, review, verify, remember) behind per-domain guardrails.
Where BigID fits. BigID connects over its API or MCP server today and stays the system of record for discovery, classification, findings and retention. Data Workers' agents never call BigID's MCP server; your engineer's assistant holds both, and the person moves the finding across. Data Workers reads natively what sits around BigID: the dbt manifest, pull requests on GitHub, Prefect flow runs, and BigQuery, Snowflake and Databricks, among 50+ connectors. Cloud Storage, Vertex AI and dlt connect over their APIs today; dlt runs inside your Prefect flows, and Data Workers never starts a load itself. Agents get one governed view through explain_table, trace_cross_platform_lineage and blast_radius_analysis.
What Data Workers writes, and where. To BigID, nothing. dbt fixes go to the owner as a diff to merge. BigQuery and Snowflake access changes are proposed for the platform owner to apply; on Databricks, Data Workers applies Unity Catalog grants and revokes only with an approved request. Masking is always a dry-run proposal that a person approves and applies, and no agent can promote it to run on its own. File and row cleanups go to their owner as a list. Rebuilds are queued through Prefect, Airflow or Dagster after approval. Between BigID scans, Data Workers' pull request review flags new columns whose names or annotations look sensitive; it reads names, not values.
Setup today. Data Workers' agents come from the open-source repository: clone it and add start-agent.sh entries to your client config, as the client setup docs show. Add BigID's MCP server next to them using BigID's own instructions and token.
// Example: .mcp.json for Claude Code (Data Workers servers; add BigID's MCP server per BigID's docs)
{
"mcpServers": {
"dw-context-catalog": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-context-catalog"]
},
"dw-governance": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-governance"]
},
"dw-schema": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-schema"]
}
}
}List the tools with your client's own command (/mcp in Claude Code), then ask "BigID flagged analytics.fct_support_threads.body_text: which model introduced it, and what reads it downstream?"
One finding, L0 to L4. The autonomy ladder is set per domain, so support data can sit at a different level from payments.
- •L0 manual. Connected, not acting. Engineers trace each BigID finding by hand.
- •L1 observe. Data Workers reports the cause, the spread and the owners for each finding you hand it, and logs what each action would have needed. Nothing changes.
- •L2 propose. Data Workers drafts the dbt diff with its blast radius, plus the access proposal, the masking dry run and the cleanup list. Owners approve before anything runs.
- •L3 act reversibly. For proven change classes, such as queuing the rebuild after a fix merges, Data Workers acts, reads the run state and records it. Code still arrives as diffs.
- •L4 autonomous. For a scoped, trusted class in one domain, Data Workers runs the loop end to end and posts the receipt for review. Masking always needs a person, and BigID decisions stay with BigID's owners.
Read more on safety, how approvals work, where your data goes and how Data Workers handles PII. The same build-on pattern holds for Cyera, Varonis and Immuta, and the Immuta vs Cyera guide covers posture versus policy.
What changes for your team
BigID programs rarely struggle to find things. They struggle with the queue of findings whose fix belongs to someone else: a model owned by analytics engineering, an export owned by a vendor manager, a dataset grant owned by the platform team. With Data Workers, the data side of that queue runs on autopilot at the level you set.
- •Incidents. A BigID finding arrives traced to the model and the change that caused it, with every reader listed.
- •Data quality. Keys, nulls and row counts are checked after each run, and failures go to the cause.
- •Cloud spend. Snowflake credits are traced to the dbt model behind them, and the fix goes to that model's owner.
- •Access. The access change a fix needs is drafted for its owner; Unity Catalog grants apply after approval.
- •Audits. Each fix links the finding, the diff, the approvers, the rebuild and the undo path.
- •Migrations. When a platform moves, each wave is planned with its parity checks, and the owner signs off before it closes.
Security and privacy teams keep their week for the calls only they make: what counts as sensitive, how much risk is acceptable, what to retain. The CISO guide covers that role.
Keep BigID, or consolidate?
Keep BigID if you love it; Data Workers works with it from day one. Many teams consolidate once Data Workers runs that slice too.
Most BigID customers keep it as the map of sensitive data, especially across unstructured stores, SaaS apps and several clouds, where classification depth and coverage are the whole point. What they consolidate is the tooling around it: the spreadsheet that maps findings to pipeline owners, the scripts that grep dbt projects for a column name, and the tickets that bounce between security and data engineering. For warehouse-side detection basics, see automated PII detection in data warehouses. Building the fix layer yourself? Read build it ourselves with Claude Code and MCP servers: calling BigID's MCP server is the easy part; lineage across six systems, approvals, rollback and receipts are the work.
The case for your CFO
The outcome: every BigID finding that starts in a pipeline gets fixed at its source, by its owner, with proof. The same sensitive column stops reappearing next month because the model that produced it has changed.
The risk story is plain. Data Workers changes nothing in BigID. It never applies a masking policy and deletes no files or rows; those go to their owners. Code lands through your Git review, access changes go to the platform owner, and Unity Catalog grants change only after a named approver says yes. Each change leaves a receipt with the trigger, diff, approver, checks and undo path. Unanswered requests expire and escalate; they never auto-grant. No agent can promote its own work, and an org-wide stop halts all autonomous dispatch. The agents run in your infrastructure; your data stays in your systems, and the hosted Conductor sees workflow metadata only. Zero migration.
Why now: BigID's agents now act on findings continuously, and AI agents inside the business read more data every week. Each finding that traces to a pipeline still needs a data engineer's fix. The first win is one sensitive domain, read-only, with every open BigID finding on a warehouse table traced to its model, its change and its owner. What stays the same: your BigID licence, scans, classifiers, policies and the people who run them. Start with a pilot; the path is on the pricing page, and the pilot is credited in full against the first year. For the numbers, see the ROI of agentic data operations.
The sentence to repeat upstairs: "BigID tells us where our sensitive data is; Data Workers fixes the pipelines that put it there, and every fix comes with an approval and a receipt."
Getting started
Start with a pilot. Pick the domain where BigID findings pile up, such as support, payments or HR data, connect Data Workers read-only to the dbt project, orchestrator and warehouse behind it, and hand it a few weeks of findings to trace before turning on the first fix class. It is the quickest way to see an agentic data platform next to the security stack you already run. The pilot path and plans are on the pricing page, and the pilot is credited in full against the first year.
FAQ
Does Data Workers connect to BigID? BigID connects over its API or MCP server today. Your engineer's assistant holds BigID's MCP server and Data Workers' MCP servers side by side and moves a finding from one to the other. Data Workers changes nothing in BigID.
AgentIQ can already remediate. Why add Data Workers? AgentIQ acts on the data and access BigID governs: revoke access, apply retention, quarantine, enforce policy. When the cause is a dbt model, a load or an export job, the fix is a pipeline change with its own owners, review and rebuild. That is the part Data Workers runs.
Does Data Workers classify sensitive data instead of BigID? No. BigID stays your classifier and your record. Data Workers' pull request review only flags new column names that look sensitive; it reads no values, tags nothing and masks nothing.
Will Data Workers mask columns or delete the exposed copies? No. Masking arrives as a dry-run proposal for the governance owner, and cleanups arrive as a list for the owner of each system. Data Workers queues the rebuild after approval and records what each person did.
Does Data Workers see the sensitive values? The agents run in your infrastructure and hold the credentials, so your data stays in your systems. The hosted Conductor sees workflow metadata only, such as table names, proposals and approvals, never rows, credentials or model keys.
Who approves what? Each change goes to a named owner: the analytics engineer for the dbt diff, the platform owner for access, the governance owner for masking. Requests reach them in Slack or email, and they decide in Spellbook, signed in through your identity provider.
Sources
- •BigID, AgentIQ solution page (agents at launch, actions, guardrails, "Generally available"), https://bigid.com/solutions/agentiq/ (checked Oct 3, 2026)
- •BigID, "BigID Launches AgentIQ: The Agentic Automation Layer for Data & AI Security and Compliance" (Sep 29, 2026), https://bigid.com/news/cision-bigid-launches-agentiq-the-agentic-automation-layer-for-data-ai-security-and-compliance/ (checked Oct 3, 2026)
- •BigID, MCP Server for Data Catalog, https://bigid.com/mcp-server/ (checked Oct 3, 2026)
- •BigID, Discovery & Classification, https://bigid.com/solutions/discovery-classification/ (checked Oct 3, 2026)
- •BigID, DSPM, AI SPM, Agentic SPM, https://bigid.com/solutions/dspm-ai-spm-agentic-spm/ (checked Oct 3, 2026)
- •BigID, Google Cloud data discovery and classification (BigQuery, Cloud Storage), https://bigid.com/data-coverage/google-cloud-platform/ (checked Oct 3, 2026)
- •BigID, Databricks, https://bigid.com/products/databricks/ (checked Oct 3, 2026)
- •BigID, Snowflake, https://bigid.com/products/snowflake/ (checked Oct 3, 2026)
- •BigID, "BigID Unveils BigID Next" (Feb 25, 2025), https://bigid.com/news/cision-bigid-unveils-bigid-next-its-next-gen-ai-powered-data-security-compliance-privacy-platform/ (checked Oct 3, 2026)
- •Data Workers, Client setup (open-source docs), https://dataworkers.io/opensource-docs/client-setup/ (checked Oct 3, 2026)
- •Data Workers open-source repository, agent tools and start-agent.sh, https://github.com/DataWorkersProject/dataworkers-claw-community (checked Oct 3, 2026)