You're on Domo: Your Business Teams Run on Cards, Dataflows and Agents. Data Workers Owns Whether the Data Feeding Them Is Right
Already on Domo, now part of Progress Software? Data Workers watches the warehouse tables and pipelines feeding your cards, dataflows and Agent Catalyst agents, traces a wrong number to its cause and fixes it behind a named approval.
Your business teams live in Domo. Cards on Cloud Integrations DataSets read Snowflake or Databricks in place, Magic ETL dataflows push their transforms down to the warehouse as SQL, and Beast Mode calculations turn columns into the numbers people act on. More of the work now runs through Domo AI: AI Chat answers questions, and agents built in Agent Catalyst draft the next step for a person to review. On September 22, 2026, Progress Software completed its acquisition of substantially all the assets of Domo's AI and data platform business, and Progress now sells it as Progress Domo. Domo brings data, apps and dashboards together for business teams. Data Workers owns whether the data feeding them is right: it watches the tables and pipelines under each card and agent, traces a wrong number to the load or model that caused it, proposes the fix behind a named approval and verifies it with a receipt.
Key takeaways
- •Domo keeps its job. Cards, dashboards, App Studio apps, dataflows, Beast Modes, AI Chat and Agent Catalyst agents stay with the people who own them today.
- •The cause usually sits under Domo. A source API, an Azure Data Factory pipeline or a dbt model on Databricks changes, and Domo faithfully shows the result. Data Workers works natively on those systems.
- •The fix lands where the cause is. Data Workers proposes the change as a diff for its owner, routes it to a named approver and queues the approved rerun through the orchestrator. Domo's owners rerun their dataflows and agents.
- •Data Workers changes nothing in Domo. It connects to Domo over its APIs or MCP server today, and your team's own client can use Domo MCP (beta) next to Data Workers.
- •Start with one dashboard or agent people act on, watch every table under it, and climb from L0 manual to L4 autonomous per domain.
Domo brings data, apps and dashboards together for business teams. Data Workers owns whether the data feeding them is right.
Domo's pitch to IT is simple and good: your data stays in Snowflake, Databricks, BigQuery, AWS or Azure, and Domo works with it where it lives. Cloud Integrations read and write Snowflake and Databricks on AWS and Azure, and dataflows run as pushdown SQL on the warehouse. When an upstream pipeline delivers less than it should, every card, dataflow and agent downstream reads the shortfall as fact.
Here is a Tuesday morning at a 160-clinic veterinary group with Domo on Azure Databricks. This is an illustrative example. Times are Eastern.
| Time | System | What happens |
|---|---|---|
| Mon Sep 28, 14:00 | Practice-management platform | The vendor's planned cutover moves the appointments endpoint to cursor pagination: at most 1,000 records per call, plus a cursor to the next page. The notice went to an admin mailbox in August. |
| 14:00 to 19:59 | Azure Data Factory, Azure Databricks | The hourly pipeline pl_pm_appointments runs its copy activity, whose pagination rule still asks for page numbers. Each run lands the first 1,000 changes of the hour in raw_pm.appointments and succeeds. 3,870 bookings, reschedules and cancellations never land. |
| Tue 01:30 | Azure Data Factory, dbt Core, Azure Databricks | pl_nightly_dbt runs dbt build as a Databricks job. fct_appointments and fct_clinic_day rebuild in Unity Catalog. The project's tests check keys and nulls, and they pass. |
| 01:58 | Data Workers | The pipeline's last step records Monday's hourly appointment-change counts with monitor_metrics. From 14:00 to 19:00 every hour reads exactly 1,000, against a Monday-afternoon baseline of 1,200 to 2,050. Six anomalies; Data Workers opens an incident. |
| 02:01 | Data Workers, Azure Data Factory | diagnose_incident: six busy hours at exactly 1,000 look like a page-size ceiling, not demand. trace_cross_platform_lineage follows fct_appointments through stg_pm__appointments to raw_pm.appointments in the dbt manifest; a context-graph note names pl_pm_appointments as the pipeline that lands it. get_incident_history finds no earlier case. |
| 02:04 | Data Workers, Microsoft Teams, email | blast_radius_analysis lists two dbt models and three Domo consumers the team recorded in the context graph: the Clinic Performance and Weekly Flash dashboards and the dataflow Recall Prep. A graph note adds the Agent Catalyst agent Recall Assistant, which drafts reminder texts at 06:00 from Recall Prep's output for client-care review. Data Workers posts the finding card to the Clinic data channel in Teams and emails the approval request to the analytics engineering lead. |
| 03:00 | Domo | Recall Prep runs on schedule, pushed down to Databricks, and writes recall_candidates. 2,310 pets whose visits were booked on Monday afternoon now look overdue. |
| 06:00 | Domo, Agent Catalyst | Recall Assistant drafts 11,800 reminder texts and holds them at its review step, as the team built it. 2,310 would go to owners who booked yesterday. |
| 06:40 | Microsoft Teams, Domo | The client-care lead reads the card in the Teams channel and leaves the drafts unapproved. The BI lead adds a note to the Clinic Performance dashboard: next-14-days bookings read 5.8% low until the fix lands. |
| 07:15 | Practice-management platform, Azure Data Factory | The platform engineer finds the vendor's notice, switches the copy activity's pagination rule to follow the cursor and reruns pl_pm_appointments for Monday from 14:00. The 3,870 missing changes land by 07:50. Data Workers never starts ingestion runs; the pipeline's owner does. |
| 07:55 | Data Workers, Spellbook | Data Workers proposes the plan: rebuild stg_pm__appointments and everything downstream through pl_nightly_dbt, then re-record Monday's hourly counts. For prevention, a diff for the owner to merge: a dbt test that fails the build when any hour holds exactly the API's page size. The blast radius and the undo travel with it. For Domo's owners: rerun Recall Prep, then Recall Assistant. |
| 08:05 | Spellbook, GitHub | The analytics engineering lead approves in Spellbook; the dbt owner merges the test. |
| 08:07 | Azure Data Factory | Data Workers queues the approved pl_nightly_dbt run and reads the pipeline and activity runs until it succeeds at 08:38. |
| 08:40 | Data Workers | The re-recorded counts for Monday 14:00 to 19:00 read 1,340 to 1,980, inside the baseline. Data Workers closes the incident and writes the receipt: cause, approver, diff, rerun, the counts before and after, and the undo. |
| 08:50 | Domo | The BI lead reruns Recall Prep. The execution heat map shows where the 2,310 booked pets now drop out; recall_candidates holds 9,620 pets. The Clinic Performance cards read the rebuilt tables. |
| 09:10 | Domo, Agent Catalyst | The client-care lead reruns Recall Assistant, reviews the 9,620 drafts and approves them. No owner gets a reminder for a visit they booked the day before. |
Every system did what it was told. The break lived in a gap no single tool owns: a run that succeeds while delivering three fifths of the rows. Data Workers caught it hours before anyone opened a dashboard, a named person approved the fix, and Domo's own review step held the agent's drafts until the data was right.
| Job | What Domo does | What Data Workers does |
|---|---|---|
| The view | Cards, dashboards and App Studio apps on Cloud Integrations DataSets, read in place on Snowflake or Databricks | Keeps the warehouse tables and dbt models under those cards complete and right |
| The prep | Dataflows pushed down as SQL, with row-out previews and an execution heat map | Watches the pipelines and models that feed each dataflow's inputs, run by run |
| The agents | Agent Catalyst agents and AI Chat act on DataSets, with human review steps the team designs | Lists every agent a bad table reaches, so its owner can hold a review before anything goes out |
| The break | Shows whatever the tables return, faithfully | Flags the counts and totals that leave their baseline, traces them to the load or model and lists the Domo content they reach |
| The fix | Owners rerun dataflows, update Beast Modes and rerun agents | Proposes the upstream fix as a diff for its owner, routes it to a named approver and queues the approved rerun |
| The proof | Cards and agents read the rebuilt tables | Re-records the values, compares them with the baseline and writes a receipt with cause, approver, diff and undo |
Why doesn't Domo just do this itself?
Domo made a clear, sensible bet: give business teams one place to connect, prepare, see and act on data, and do it on the cloud platform IT already runs. Its guardrails fit that job. Cloud Integrations inherit per-user access policies from your cloud. Domo MCP calls run with the permissions of the person connecting. Agent Catalyst builds human touchpoints into agentic workflows for review, input and action. Domo's engineers update its 1,000+ prebuilt connectors when a source API changes, and the execution heat map shows where rows were added, dropped or changed inside a dataflow.
All of that protects Domo's own surface. In the example, the rows were missing before Domo ever read them, and the fix took a pipeline change, a dbt test, an approval and an orchestrator rerun. Owning that loop means context about systems Domo reads but does not run, blast-radius scoping across them, approvals, rollback, receipts and liability for changes in other vendors' tools. That is a different product, and it is the product Data Workers is.
Every tool owns a slice. Data Workers covers the whole lifecycle
Domo owns one slice outright: bringing data, apps and dashboards together for business teams, with agents that act on them. 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.
| Stage | Data Workers | Domo | Why we scored it this way |
|---|---|---|---|
| Catalog & Context | 9 | 5 | DataSet schemas and the AI Dictionary describe Domo's data, and Snowflake Semantic Views can be registered through Cloud Integrations (Beta, Sep 2026). Data Workers keeps one governed context graph across every platform, joined to lineage, quality and owners. |
| Analytics & Insights | 8 | 9 | Domo's home stage: cards, dashboards, App Studio apps, AI Chat, Agent Catalyst agents and embedded analytics, reading Snowflake or Databricks in place through Cloud Integrations. Data Workers makes sure the tables under them are right. |
| Data Quality | 8 | 4 | Magic ETL shows row-out previews on each tile and an execution heat map of where rows were added, dropped or changed. Data Workers holds the counts and totals your team records to a baseline and flags what leaves it. |
| Observability & Incidents | 8.5 | 5 | Domo alerts flag anomalies and failures as data refreshes, DomoStats tracks pipeline performance and usage, and schema-change alerts for DataSets are planned. Data Workers traces a wrong card to the load, pipeline or model that caused it, proposes the fix and verifies it. |
| Pipelines & Ingestion | 8.5 | 7 | 1,000+ connectors, the Connector IDE and Magic ETL pushed down to Snowflake or Databricks as SQL. Data Workers queues approved reruns through the orchestrator for the pipelines under Domo. |
| Schema & Migration | 8 | 4 | Sandbox moves dashboards, apps and dataflows toward production, and past DataFlow versions can be inspected. Data Workers reviews dbt changes and scopes the blast radius across the models and declared Domo content they reach. |
| Governance & Access | 8.5 | 6 | Domo inherits per-user access policies from your cloud, and Domo MCP calls run with the connecting person's permissions. Data Workers routes every data change to a named approver. |
| Security & Privacy | 8 | 6 | DomoGPT runs private models inside the Domo cloud, and Domo monitors for PII in ingested data. Data Workers leaves a receipt on every data change and proposes masking for the owner to apply. |
| Cost / FinOps | 8 | 3 | Admin connectors bring Anthropic, Cursor and OpenAI billing into Domo dashboards. Data Workers attributes Snowflake spend per query and per dbt model through query tags. |
| MLOps & Models | 7.5 | 5 | Jupyter Workspaces, AutoML, prebuilt forecasting and AI Services inference run on your cloud data. Data Workers keeps the data under models and agents healthy. |
How Domo and Data Workers work together
Your people stay where they are: business teams in Domo, builders in Claude Code or Cursor with a Domo MCP toolkit, Microsoft Teams for alerts and email for approval requests. Spellbook Data Catalog (in preview) is where the data team looks: each proposed fix, its blast radius, approver and rollback. Underneath, Data Context Wizard keeps one governed context graph, the Data-Agents Swarm (20+ specialist agents) does the work, and the Autonomous Data-Conductor runs each fix end to end behind per-domain guardrails.
How Data Workers connects. Data Workers connects to Domo over its APIs or MCP server today and does its own work natively on what sits under Domo: the dbt project, the orchestrator (Azure Data Factory, Airflow, Dagster or Prefect) and the warehouse checks it runs on Snowflake, BigQuery and Postgres. Domo cards, dataflows and agents enter the blast radius when your team records them in the context graph; when a fix goes through a pull request, change review's lineage diff also reads the dbt exposures your project declares. Data Workers writes nothing to Domo: no dataflow runs, Beast Mode edits, card changes or agent runs.
What Data Workers runs under each card. monitor_metrics holds the values your team records after each run, such as hourly appointment changes, against a baseline with seasonality, and flags what leaves it. trace_cross_platform_lineage and blast_radius_analysis follow a table back to its source and forward to every model and declared Domo consumer; explain_table returns a table's definition, lineage, freshness, documentation and trust score. diagnose_incident, remediate and get_incident_history run and record the incident. On Snowflake and Postgres (and BigQuery with a service-account key), run_quality_check adds null, key uniqueness and minimum row count checks. Your data stays in your systems: the agents, warehouse credentials and model key run in your infrastructure, and the hosted Conductor sees workflow metadata only.
Setup over MCP today. Clone the open-source repository and add start-agent.sh entries to your client's MCP config, as the client setup docs show. A Domo MCP toolkit can sit next to Data Workers in the same client for your own questions: choose "Use MCP" from the toolkit's menu in Domo's AI Library to get its connection details. Domo calls run with your own permissions, so give question-askers a toolkit with read tools only; the toolkits that create cards, Workspaces, Sandbox repositories and workflows belong with builders. Data Workers' agents never call the Domo MCP server.
// Example: .mcp.json in the project root for Claude Code. The domo entry is your
// team's own connection, with details from the toolkit's "Use MCP" menu in Domo;
// Data Workers does not call it.
{
"mcpServers": {
"domo": {
"type": "http",
"url": "DOMO_TOOLKIT_MCP_URL"
},
"dw-context-catalog": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-context-catalog"]
},
"dw-incidents": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-incidents"]
},
"dw-quality": {
"command": "/path/to/dataworkers-claw-community/start-agent.sh",
"args": ["dw-quality"]
}
}
}List the tools with your client's own command (/mcp in Claude Code). A builder can then ask "is everything feeding the Clinic Performance dashboard healthy?" and get the DataSets from Domo's toolkit and the lineage, baselines and open incidents from Data Workers in one answer.
Where fixes go. Data Workers proposes the change as a diff for the owner to merge, usually a dbt model, test or source mapping, with its blast radius and undo step. It opens the pull request itself when your team turns on the dbt GitHub pull-request target. After approval it queues the orchestrator rerun and reads it to the end. Ingestion runs, such as an Azure Data Factory copy, stay with their owner, and Domo's owners decide when dataflows and agents rerun.
One request, L0 to L4. The autonomy ladder is set per domain.
- •L0 manual. Data Workers is connected and not acting.
- •L1 observe. Data Workers watches the tables under your key dashboards and agents and logs what it would do.
- •L2 propose. Data Workers drafts the upstream fix with its blast radius. A named owner approves in Spellbook before anything runs.
- •L3 act reversibly. For proven classes, such as queuing the rebuild after an owner recopies missing rows, Data Workers acts, verifies and records the undo.
- •L4 autonomous. For a narrow class in one domain, Data Workers fixes and verifies on its own and posts the receipt.
Approvals go to a named person; a request nobody answers expires and escalates, and never grants itself. No agent can promote its own work. See who owns the agents; the safety model is in is it safe to let AI agents change production data, how approvals work, the autonomy levels from L0 to L4 and where does our data go.
For the stack in this example, see You're on Azure Data Factory and Data Workers on Databricks. The same loop runs under Power BI, Sigma and Snowflake Semantic Views.
What changes for your team
Domo teams lose hours to one question: did the card move because of the Beast Mode, the dataflow, the pipeline or the source? With Data Workers under Domo, the six jobs above run on autopilot at the level you set: a card that moved overnight arrives with its cause and a fix ready to approve, and every data change behind a card carries the approver, the diff, the checks and the undo step.
The BI team stops being the first line for "this card looks wrong". Data engineers get a cause and a ready diff instead of a screenshot. Client-facing teams keep their agents and know whether the data under each review step is clean.
Keep Domo, or consolidate?
Keep Domo if you love it; Data Workers works with it from day one. Many teams consolidate once Data Workers runs that slice too.
Domo stays: the dashboards business teams trust, App Studio apps, embedded analytics and the agents they built belong there. What teams consolidate is the tooling around it: a separate data observability tool on the warehouse, row-count scripts someone checks each morning, and a spreadsheet of which dataflow depends on which dbt model. Weighing a build on Domo MCP yourself? Read build it ourselves with Claude Code and MCP servers: connecting servers is the easy part; cross-system context, approvals and rollback are the work. See also Data Workers vs data observability, Data Workers integrations and what is an agentic data platform.
The case for your CFO
The outcome: the dashboards your business teams read in Domo, and the agents that act on them, run on complete and correct data. When something breaks upstream, the fix arrives before the morning, with a named approver.
The risk story: Data Workers changes nothing in Domo. It proposes upstream fixes as diffs and queues reruns, and nothing runs until the named owner approves. Every change is verified and leaves a receipt: what broke, what changed, who approved it and how to undo it. Autonomy is set per domain from L0 manual to L4 autonomous, and an org-wide stop halts all autonomous dispatch. There is zero migration.
Why now: Domo agents now act on DataSets, and Domo MCP (beta) lets outside AI clients query them and create cards, Workspaces and workflows. A short load used to mean an odd chart; now it can mean 2,310 wrong customer messages waiting for a busy reviewer. Domo's move to Progress is also a natural moment to give your BI an operating layer that does not depend on any one BI vendor.
The first win: one dashboard or agent people act on, such as a weekly flash or an outreach agent, with every table under it watched after each run. Start with a pilot (pricing); it is credited in full against the first year. What stays the same: your Domo cards, dataflows, agents and permissions, your warehouse, dbt, orchestrator and review process. For the numbers, see the ROI of agentic data operations.
The sentence to repeat upstairs: "Domo keeps putting data in front of our business teams and their agents; Data Workers makes sure what feeds it is right, and a named owner approves every fix with a receipt."
Getting started
Start with a pilot. Pick the Domo dashboard or agent behind a decision people make every week, connect Data Workers read-only to the warehouse, dbt project and orchestrator under it, record the counts and totals that matter, and let it watch every run 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 change anything in Domo? No. Cards, Beast Modes, dataflows, App Studio apps and Agent Catalyst agents stay with their Domo owners. Data Workers queues the approved rerun of the pipeline or dbt job under Domo through your orchestrator; when a dataflow or agent needs a rerun after that, it says which and why, and the owner or the dataflow schedule runs it.
Do Data Workers' agents use the Domo MCP server? No. Your team can connect a Domo MCP toolkit in the same client, where calls run with your own Domo permissions. Data Workers relies on its own dbt, orchestrator and warehouse connections.
What if some of our data lives in Domo's own storage, not our warehouse? Data Workers covers the warehouse, pipelines and models it reaches natively. DataSets that only exist inside Domo stay with Domo's tools, such as alerts and the execution heat map. The natural place to start is the Cloud Integrations DataSets, where the tables under each card sit in your own Snowflake or Databricks.
Domo is now part of Progress Software. Does that change anything here? Not for this setup. Progress completed its acquisition of substantially all the assets of Domo's AI and data platform business on September 22, 2026, for $400M, and sells it as Progress Domo. Data Workers works on the warehouse and pipelines under Domo, so it works the same way whatever your BI roadmap.
Can Data Workers stop an Agent Catalyst agent from acting on bad data? It does not run or pause Domo agents. It lists every agent a bad table reaches and tells the agent's owner in Teams or Slack, so the owner can hold the review step built into the agent's workflow.
Sources
- •Domo, Progress Software Completes Acquisition of Domo's AI and Data Platform Business (Sep 22, 2026), https://www.domo.com/news/press/progress-software-completes-acquisition-of-domos-ai-and-data-platform-business (checked Oct 3, 2026)
- •Progress, Domo product page (Progress Domo, Data Platform), https://www.progress.com/domo (checked Oct 3, 2026)
- •Domo, Domo AI (Agent Catalyst, AI Chat, Beast Mode assistant, FileSets, DomoGPT, Jupyter Workspaces, AutoML), https://www.domo.com/ai (checked Oct 3, 2026)
- •Domo, Agent Catalyst (build, test and deploy agents; human touchpoints; tools; Domo Workflows), https://www.domo.com/agentcatalyst (checked Oct 3, 2026)
- •Domo, Cloud Integrations (read, write, OAuth and Magic ETL pushdown on Snowflake and Databricks; per-user access policies), https://www.domo.com/platform/leverage-the-cloud (checked Oct 3, 2026)
- •Domo, Connection and Integration (1,000+ connectors, Connector IDE, connector maintenance, DomoStats, alerts, PII risk detection), https://www.domo.com/data-integration (checked Oct 3, 2026)
- •Domo blog, How to Get More Done in Domo Magic ETL With the September Release (Sep 29, 2026), https://www.domo.com/blog/magic-etl-september-release (checked Oct 3, 2026)
- •Domo blog, New Product Features and AI Announcements Shared at Domo Connections 2026 (Sep 18, 2026; AI Library and MCP toolkits Beta, execution heat maps Live, Snowflake Semantic Views Beta, AI billing connectors Live), https://www.domo.com/blog/product-announcements-from-domo-connections-2026-recap (checked Oct 3, 2026)
- •Domo blog, An Inside Look at How Domo's Data Team Builds with Domo MCP (Oct 1, 2026), https://www.domo.com/blog/an-inside-look-at-how-domos-data-team-builds-with-domo-mcp (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)