You're on Securiti: Securiti Maps the Sensitive Data and Enforces the Controls. Data Workers Owns Whether Your Pipelines Follow Through
On Veeam's Securiti AI for DSPM, DSR automation and data access controls? Keep it. Data Workers owns whether the pipelines carrying that data stay right and proposes the fixes, behind approvals.
Your security and privacy teams run on Securiti, part of Veeam since Veeam completed its acquisition of Securiti AI on December 11, 2025. The DataAI Command Platform discovers and classifies sensitive data across clouds, SaaS apps, Snowflake, Databricks and BigQuery through 1,000+ integrations, and the DataAI Command Graph links each finding to the identities, entitlements, controls, AI models and regulations around it. DSPM ranks the exposure. Data Access Intelligence & Governance monitors who can reach what, enforces least privilege and masks sensitive data by policy. On the privacy side, DSR Automation takes a request from intake to fulfilment, its People Data Graph finds an individual's data across hundreds of systems, and the DSR workbench keeps the audit log. Gencore AI builds safe copilots over enterprise data, and Agent Commander, announced February 24, 2026 and in early access, promises to "undo AI agent mistakes with precise rollbacks." Securiti maps the sensitive data and enforces the controls. Data Workers owns whether the pipelines downstream follow through on every decision Securiti makes: it traces a finding to the model, snapshot or export that keeps the data alive, and puts each fix in front of the person who owns it, behind approvals.
Key takeaways
- •Securiti keeps its job. DSPM, discovery, DSR Automation, access governance, consent and Gencore AI stay where they are.
- •Securiti stays the record. It connects over its API today. Data Workers changes nothing in Securiti and never fulfils a request.
- •Every copy gets traced. When Securiti finds personal data where it should not be, Data Workers follows the table through the dbt manifest to every model and snapshot built from it, and adds the dashboards and exports your team has recorded in its context graph.
- •Fixes arrive as proposals. The dbt diff, the cleanup statement, the export hold and the scope change go to their named owners. Data Workers queues the approved rerun, checks the rebuilt table and writes a receipt the privacy team can file with the request.
- •Nothing is deleted by an agent. Data cleanups are proposed for the owner to approve and run, with the undo written down first.
- •Start with a pilot on one regulated data flow, read-only first.
Securiti maps the sensitive data and enforces the controls. Data Workers owns whether the pipelines downstream follow through.
Securiti answers the security and privacy questions: where does personal data sit, who can reach it, what policy applies, and has this request been fulfilled? Data Workers answers the operations questions behind them: which pipeline put the data there, what copies it on, and what has to change, in which system, to make the decision stick?
Here is a week at a home-goods marketplace selling in the EU and California. The privacy team runs data subject requests in Securiti, with the erasure workflow wired to the systems of record: Zendesk, Salesforce and the app's database. Fivetran syncs Zendesk into BigQuery raw_zendesk every hour. Airflow 2 runs dbt_nightly at 02:00: dbt Core builds stg_zendesk__users, the incremental model dim_support_users, the snapshot snap_support_users that keeps each user's history, and mart_csat_by_customer. A Looker Explore, Support CSAT, reads the mart, and a second Airflow DAG, vendor_survey_export, sends a file of recent support users to a survey vendor's SFTP drop every Thursday at 06:00. The team has recorded both readers as notes in the Context Wizard graph. The warehouse was left out of the erasure workflow on purpose: the team expected deletions to flow downstream. This is an illustrative example.
| Time | System | What happens |
|---|---|---|
| Mon 09:00 | Securiti | The privacy lead approves a batch of 640 verified erasure requests in the DSR workbench. Securiti's automation runs the erasure tasks in Zendesk, Salesforce and the app database, and each system reports done |
| Mon 10:00 | Zendesk and Fivetran | The hourly sync lands the change. As Fivetran's docs describe, a row deleted in the source stays in raw_zendesk.users with _fivetran_deleted set to true |
| Tue 02:00 | Airflow and dbt Core | dbt_nightly runs green. stg_zendesk__users carries every row, flagged or not. The incremental merge in dim_support_users updates the flagged users in place, and snap_support_users records a new version of each, with name, email and phone |
| Wed 11:00 | Securiti | Before closing the batch, the privacy analyst searches Securiti for the batch's subjects across connected systems, BigQuery included. Securiti finds 611 of the 640 still present in raw_zendesk.users, analytics.dim_support_users and snapshots.snap_support_users. The analyst assigns the task to the data platform team and posts in #privacy-ops |
| 11:20 | Claude Code | The on-call data engineer asks Data Workers what builds and reads those three tables |
| 11:24 | Data Workers | trace_cross_platform_lineage follows the dbt manifest from the Zendesk source through stg_zendesk__users to the dimension, the snapshot and mart_csat_by_customer; blast_radius_analysis lists every model downstream. The context-graph notes add the Support CSAT Explore and the Thursday export |
| 11:30 | Airflow and Claude Code | Data Workers reads the dbt_nightly DAG runs and task instances since Monday: every run succeeded. The engineer opens the staging model: it never filters _fivetran_deleted, so a user erased at the source stays a live row in every model and snapshot built from it |
| 11:40 | Slack and Spellbook | One change set goes to four named owners. Analytics engineer: a dbt diff that drops flagged rows in stg_zendesk__users, a test that fails the build if a flagged user reaches dim_support_users, a post-load step that records the dimension's flagged-user count with monitor_metrics, and a full refresh of the dimension. Platform owner: drafted statements that delete the snapshot and raw rows of users flagged _fivetran_deleted, to approve and run under the retention policy. CX analytics owner: hold Thursday's export. Privacy lead: add the BigQuery datasets to the erasure scope in Securiti, plus a review opened with request_governance_review on whether the survey file needs email addresses at all |
| 12:10 | Airflow | The CX analytics owner pauses vendor_survey_export |
| 13:05 | GitHub | The engineer opens the pull request. Data Workers' review posts the blast radius across the dbt project: the dimension, the snapshot and the mart, with no column changes. The engineer merges |
| 13:20 | Spellbook and Airflow | The data owner approves the run. Data Workers queues dbt_nightly through Airflow with the approved full refresh of dim_support_users and reads its status until it succeeds at 13:48 |
| 14:05 | BigQuery | The platform owner reviews the cleanup statements and runs them on the snapshot and the raw table |
| 14:20 | Data Workers | run_quality_check confirms dim_support_users has no null or duplicate user_id and clears the minimum row count. monitor_metrics records zero flagged users in the dimension |
| 15:00 | Securiti | The privacy analyst reruns the search: no matches for the batch in BigQuery. She closes the batch and links Data Workers' receipt to the request record |
| 15:10 | Spellbook | Data Workers writes the receipt: the finding, the lineage, the diff and its review, the cleanup statements and who ran them, the runs before and after, the checks, every approver and the undo path. It notes that BigQuery time travel holds earlier table versions until its window expires |
| Thu 06:00 | Airflow | The CX analytics owner resumes the export. The file goes out without the erased customers |
Securiti did its job twice: it ran the erasure everywhere it was pointed, and its search found the copies nobody had pointed it at. Fivetran kept deleted rows flagged, by design. The gap sat in a staging model written years earlier, a snapshot that keeps history by definition and an export two hops downstream, each with its own owner. It closed in one afternoon, with four people approving four changes and Data Workers carrying the work between them.
| Job | What Securiti does | What Data Workers does |
|---|---|---|
| Finding the data | Discovers and classifies sensitive data across clouds and SaaS; its People Data Graph finds one person's data across systems | Traces each finding through the dbt manifest to every model and snapshot built from it, plus the readers recorded in the context graph |
| The privacy decision | DSR Automation takes a request from intake to fulfilment, with tasks and an audit log | Leaves every request and every decision to Securiti and the privacy team |
| Carrying it out | Runs erasure and access tasks in the systems its workflow connects to | Proposes the pipeline changes that make each decision hold downstream: the dbt diff, the test, the cleanup for the owner, the export hold |
| Access | Maps entitlements, enforces least privilege and masks data by policy | Drafts the access change a fix needs for its owner; applies Unity Catalog grants only after approval |
| Reruns | Not its job | Reads the orchestrator's runs, queues the approved rerun and checks the rebuilt table |
| Agents | Security for AI Agents and Copilots; Agent Commander (early access) restores what an agent got wrong without rolling back whole systems | Runs its own agents behind per-domain guardrails, approvals and receipts |
| The proof | The DSR workbench record and audit log | A receipt per fix, linked from the request record |
Why doesn't Securiti just do this itself?
Because Securiti's job is to see sensitive data everywhere and hold the controls on it, for a security and privacy buyer. That is a big product, and Securiti keeps it on one knowledge graph. Its actions follow the same line. An erasure task runs in a connected system. A masking policy applies at access time. Agent Commander, drawing on Veeam's data resilience, restores only the files an agent got wrong instead of rolling back whole systems. Each acts on the data through Securiti's own controls, and each is right for its job.
Changing why the data keeps arriving is a different product with a different liability. It means editing the team's dbt models, reading Airflow runs, rebuilding incremental tables, removing history only through the owner, and holding exports other teams run. It needs context about every system between source and reader, blast radius, a named approver per change, a rollback path and proof the fix held. A privacy platform that rewrote pipelines would carry the risk of every model it touched. Data Workers is built for that side of the line, and it hands every privacy and security decision back to Securiti.
Every tool owns a slice. Data Workers covers the whole lifecycle
Securiti owns its slice: mapping sensitive data and enforcing privacy and security controls. 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 what you keep in Securiti.
| Stage | Data Workers | Securiti | Why we scored it this way |
|---|---|---|---|
| Catalog & Context | 9 | 6 | The DataAI Command Graph links data objects, sensitive information, entitlements, controls and AI models, with a Data Catalog on top. Data Workers joins context to lineage, runs, schema changes and usage in one graph. |
| Analytics & Insights | 8 | 2 | Securiti reports risk, posture and privacy operations. Data Workers answers questions about the data itself from governed context and checks the numbers behind them. |
| Data Quality | 8 | 4 | Securiti lists a Data Quality product for checks and validation. Data Workers checks nulls, keys and row counts after runs and takes failures to the cause. |
| Observability & Incidents | 8.5 | 3 | Securiti raises security and privacy findings. Data Workers detects, diagnoses and verifies data incidents across systems, with a receipt for each. |
| Pipelines & Ingestion | 8.5 | 2 | Gencore AI ingests unstructured files for AI; Securiti does not run your warehouse pipelines. Data Workers reads orchestrator runs and queues reruns after approval. |
| Schema & Migration | 8 | 1 | Securiti leaves warehouse schemas to the data team. Data Workers assesses the impact of a schema change and drafts migrations with rollback SQL for the owner. |
| Governance & Access | 8.5 | 8.5 | Data Access Intelligence & Governance maps entitlements, enforces least privilege and masks sensitive data by policy. Data Workers proposes the access change a fix needs and applies Unity Catalog grants after approval. |
| Security & Privacy | 8 | 9.5 | Securiti's home stage: DSPM, discovery and classification across 1,000+ integrations, DSR automation with its People Data Graph, consent and breach management. Data Workers makes sure the pipelines downstream follow each decision. |
| Cost / FinOps | 8 | 2 | Data Minimization finds redundant, obsolete and trivial data. Data Workers traces Snowflake credits to the dbt model behind them and reads AWS Cost Explorer. |
| MLOps & Models | 7.5 | 5 | AI Governance and Security for AI Agents cover models, copilots and agents; Agent Commander is in early access. Data Workers keeps the training and feature data under models healthy. |
How Securiti and Data Workers work together
Your people stay where they are: security and privacy in Securiti, analysts in Looker, engineers in Claude, Cursor or GitHub Copilot. Spellbook Data Catalog (in preview) is where the data team looks: each finding, proposed change, blast radius, approver 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 end to end (detect, diagnose, fix, review, verify, remember) behind per-domain guardrails.
Where Securiti fits. Securiti connects over its API today and stays the system of record for findings, requests and policies. Its findings reach Data Workers the way they reach your team: as an assigned task, a Slack post or a question in your assistant. Data Workers' agents work from what they read natively, among 50+ connectors: BigQuery and Snowflake checks, the dbt manifest, Airflow, Prefect and Dagster runs, OpenLineage events and the Context Wizard graph. Agents get one governed view through explain_table, trace_cross_platform_lineage and blast_radius_analysis, and for open incidents, get_incident_history.
What Data Workers writes, and where. To Securiti, nothing. Code and dbt fixes go to the owner as a diff to merge. Reruns are queued through your orchestrator after approval. Data cleanups, such as removing erased subjects from a snapshot, are proposed for the owner to approve and run. Owners hold and resume exports. Access changes are drafted for the owner; on Unity Catalog, Data Workers applies the grant or revoke once a named person approves. Masking arrives as a dry run that no agent can promote to run on its own. request_governance_review opens a trackable review when a change needs the privacy team's decision, and generate_audit_report gathers the receipts for an audit.
Setup today. For your assistant, 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.
// Example: .mcp.json for Claude Code
{
"mcpServers": {
"dw-context-catalog": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-context-catalog"]
},
"dw-quality": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-quality"]
},
"dw-governance": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-governance"]
}
}
}List the tools with your client's own command (/mcp in Claude Code), then ask "what builds analytics.dim_support_users, and what reads it?"
One request, L0 to L4. The autonomy ladder is set per domain, so the customer-data domain can sit at a different level from Finance.
- •L0 manual. Connected, not acting.
- •L1 observe. Each Securiti finding gets its lineage, readers and owners; Data Workers logs what each action would have needed.
- •L2 propose. Data Workers drafts the dbt diff, the cleanup statements and the export hold. Owners approve before anything runs.
- •L3 act reversibly. For proven classes, such as queuing the rebuild of a model after its fix merges, Data Workers acts, verifies and records it.
- •L4 autonomous. For a scoped, trusted class, Data Workers runs the loop end to end and posts the receipt. Deletes and masking always need a person.
Read more on safety, how approvals work, the autonomy levels, where your data goes and how Data Workers handles PII. The same pattern holds for BigID, Cyera and OneTrust; the pipeline side is in You're on Fivetran and You're on Airflow, every connector in Data Workers integrations.
What changes for your team
Security, privacy and data teams lose much of their week to the seam between them: the finding with no owner for the fix, the request closed in one system and alive in five. With Data Workers, these jobs run on autopilot at the level you set.
- •Incidents. A privacy finding in a pipeline arrives traced to the model, the cause and every reader.
- •Data quality. Keys, nulls and row counts on customer tables are checked after each run, and the counts your loads record are flagged when they leave their baseline.
- •Cloud spend. Snowflake credits are traced to the dbt model behind them, and the fix goes to that model's owner.
- •Access. A finding's access change arrives drafted for its owner, and Unity Catalog changes are applied after approval.
- •Audits. Each fix links the finding, the diff, the approvers, the checks 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.
The security team keeps its week for the decisions only people make. See the guide for CISOs, who owns the agents, SOX, HIPAA, GDPR and the EU AI Act for the evidence, and Immuta vs Cyera, and where the Data Security agent fits.
Keep Securiti, or consolidate?
Keep Securiti if you love it; Data Workers works with it from day one. Many teams consolidate once Data Workers runs that slice too.
Most programs keep Securiti as the map of sensitive data and the record of every request, especially now that Veeam ties it to backup and recovery. What they consolidate is the tooling around it: the scripts that hunt for copies after each erasure batch, the spreadsheet of tables holding personal data, and the ticket queue between privacy analysts and pipeline owners. Teams also running Microsoft Purview keep the same split. For the agent side, read audit trail requirements for data agents. Building this yourself? Read build it ourselves with Claude Code and MCP servers: calling Securiti's API is easy; approvals, rollback and receipts are the work.
The case for your CFO
The outcome: when Securiti carries out a privacy decision, every pipeline downstream follows it, and when Securiti finds personal data where it should not be, the cause is fixed at the source.
The risk story is plain. Data Workers changes nothing in Securiti and never fulfils a request. It proposes every change to a named owner. Reruns are queued only after approval, code fixes land through your Git review, and the owner runs every delete. 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. Autonomy is set per domain from L0 manual to L4 autonomous, 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: personal data feeds dashboards, exports and AI agents within a day of landing, so a decision that stops at the system of record leaks further, faster, and regulators ask for proof it held. The first win: one regulated flow, read-only, answering every Securiti finding on it with its lineage, readers and owners. What stays the same: your Securiti licence, policies, workflows and security team. Data Workers produces the evidence; your privacy and legal teams make the compliance calls. For the numbers, see the ROI of agentic data operations, and for the category, what an agentic data platform is.
The sentence to repeat upstairs: "Securiti tells us where our sensitive data is and enforces the rules; Data Workers makes sure our pipelines follow through, and every fix comes with an approval and a receipt."
Getting started
Start with a pilot. Pick the regulated flow your privacy office cares about most, connect Data Workers read-only to the tables, dbt project and orchestrator runs behind it, route that flow's Securiti findings to the data team, and let it report for a few weeks before turning on the first fix class. 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 fulfil data subject requests? No. Requests stay in Securiti with the privacy team. Data Workers traces which models and snapshots carry a subject's data downstream, adds the exports recorded in its context graph, and proposes the pipeline fix and any cleanup for the owner to approve and run.
Will Data Workers delete data in our warehouse? No agent deletes data. Cleanups, such as removing erased subjects from a snapshot, arrive as statements for the platform owner to review and run under your retention policy, with the undo written down first.
How does Data Workers connect to Securiti? Over Securiti's API today. Findings reach Data Workers as assigned tasks, Slack posts or questions in your assistant. Its own checks rest on what its connectors read natively: warehouse checks, the dbt manifest, orchestrator runs and the context graph.
How is this different from Agent Commander? Agent Commander (early access) detects AI risk and undoes an agent's mistake by restoring the affected data. Data Workers fixes the pipeline logic behind a problem, each change proposed as a diff, approved by a named owner and recorded with its undo path. The two fit together.
Securiti has data lineage too. Why trace again? Securiti's lineage serves privacy and governance questions about where sensitive data flows. Data Workers traces lineage to act on it: the dbt model to change, the snapshot to clean, the run to queue and the export to hold, each with an owner and a receipt.
Does Data Workers make us GDPR or CPRA compliant? No tool does that alone. Your privacy and legal teams make compliance decisions. Data Workers produces evidence they can use: receipts, the audit log and reports that show what changed, who approved it and when.
Sources
- •Veeam, Veeam Completes Acquisition of Securiti AI to Create the Industry's First Trusted Data Platform for Accelerating Safe AI at Scale (Dec 11, 2025), https://www.veeam.com/company/press-release/veeam-acquires-securiti-ai.html (checked Oct 3, 2026)
- •Securiti, Veeam Introduces Agent Commander to Confront Agentic AI Risk at Enterprise Scale (Feb 24, 2026), https://securiti.ai/press-release/veeam-introduces-agent-commander-to-confront-agentic-ai-risk-at-enterprise-scale/ (checked Oct 3, 2026)
- •Securiti, Agent Commander (early access), https://securiti.ai/agent-commander/ (checked Oct 3, 2026)
- •Securiti, DataAI Command Platform (home), https://securiti.ai/ (checked Oct 3, 2026)
- •Securiti, Data Security Posture Management, https://securiti.ai/dspm/ (checked Oct 3, 2026)
- •Securiti, Data Subject Request Automation, https://securiti.ai/products/data-subject-request-automation/ (checked Oct 3, 2026)
- •Securiti, Data Lineage, https://securiti.ai/products/data-lineage/ (checked Oct 3, 2026)
- •Securiti, Gencore AI, https://securiti.ai/gencore/ (checked Oct 3, 2026)
- •Securiti, Press releases, https://securiti.ai/press-release/ (checked Oct 3, 2026)
- •Fivetran, System columns and tables (
_fivetran_deleted), https://fivetran.com/docs/core-concepts/syncoverview/system-columns-and-tables (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)