5 Ways Autonomous Agents Can Run Your Domo Instance

A BI director at one Domo customer spent five hours every week clicking through connector screens, mapping fields, and waiting for rows to land, all just to create datasets as new clients came onboard. That was the story Riley Stahura told during the latest Domo AI livestream, “The Headless Domo Revolution: Orchestrating BI and Custom Apps with AI Agents.”

Riley Stahura, a product expert at Domo, showed what happens when autonomous AI agents handle that kind of work instead. The agents interact with Domo as a headless platform built on open application programming interfaces (APIs) through MCP (Model Context Protocol) and specialized agent skills. The host guided the conversation through five live demos, each one showing a different way agents can handle tasks that normally eat hours out of a data professional's week.

What follows is a practical, five-part guide drawn directly from those demos. Each section covers a specific agent capability, grounded in what Riley showed and the time savings he quantified on screen.

Key takeaways

Here is what the livestream covered at a glance:

• Autonomous agents can create datasets, build ETL pipelines, generate apps, and deploy Code Engine packages through Domo's MCP and agent skills.
• Riley demonstrated time savings ranging from 15 minutes on a simple Code Engine function to multiple hours on dataflow prototypes.
• Domo's governance layer gives IT teams control over what agents can access, who sees the output, and which rows appear for each person.
• These capabilities work across agent platforms (Claude Code, Gemini Enterprise, Cursor) because the skills and MCP toolkits are platform-agnostic.

1. Create datasets through natural language prompts

The first demo started in Gemini Enterprise, where Riley used Domo's MCP to create a Box dataset containing 10,000 rows of churn data. The entire process took three prompts: specify the connector type and name the file, then confirm credentials through Domo's secure credential manager.

"In just three messages, I've managed to pull data from Box into my warehouse of choice and I can start building apps on it," Riley said. The dataset landed in both Domo and BigQuery simultaneously, ready for downstream use.

The time savings become obvious at scale. Riley described a customer whose BI director spent a minimum of five hours per week just creating datasets during client onboarding. That same work, repeated across dozens of connector types with different configuration options each time, collapses into a few conversational prompts. For teams that create multiple datasets daily or weekly, this capability removes one of the most repetitive bottlenecks in the data pipeline.

2. Query and explore data without leaving your agent

Riley's second demo moved into Claude Code, where an agent queried the same churn dataset, identified its schema (10,000 rows, 40 columns), and described the column groupings. But the more practical application came next: querying Domo's data flow history dataset to surface failed pipelines.

This is where diagnostic work gets interesting. The agent can explore error histories, identify which dataflows failed, and drill into specific tiles to find root causes, whether that means a renamed column upstream or a changed data type elsewhere in the pipeline. Instead of clicking through multiple screens in the Domo interface to track down a pipeline failure, you ask the agent to investigate and it returns the diagnosis.

Data engineers managing dozens of active pipelines can diagnose failures through a simple conversation with the agent rather than navigating multiple screens in the interface.

3. Build Magic ETL (extract, transform, load) pipelines from a markdown file

Riley handed Claude Code a markdown file containing four Shopify dataset URLs with a simple instruction: Join them together. About two and a half minutes later, the agent had created a working Magic ETL data flow called "Shopify Joined" with 5,000 output rows.

"We have people on our team that have used these skills to create data flows that have 50 tiles," Riley noted. "And surprisingly, a lot of the time, we haven't really had to even troubleshoot the formulas. They worked out of the box."

Riley estimated this capability saves him two to three hours per prototype. His typical workflow involved blocking off calendar time just to join and clean data before he could start building the application that was the actual deliverable.  

"When I wake up to make that data flow, all I have to really do is identify the datasets I need," he said. "And then I can start building the prototype on it within like 10 minutes as opposed to block off my calendar for two hours."

Even for teams that prefer to hand-tune production pipelines, agent-generated ETL works as a rapid prototyping tool that gets you to a working data foundation fast.

4. Generate App Studio apps with sub-agents and skills

The fourth demo introduced a more complex pattern. Riley invoked a sub-agent that orchestrated multiple skills in parallel, building cards and page layouts until a complete App Studio application took shape. The instruction was straightforward: use a specified dataset, create one page with 10 cards.

The result landed as a real App Studio app (Riley showed the matching app ID on screen), with cards wired to live Domo datasets that open in Analyzer for theming, property adjustments, and continued editing through the standard interface.

"It's very common now for customers to say, okay, now that I've vibe-coded an app and pushed it to Domo, can I edit it in the interface?" Riley said. "And the good news is Domo already has this amazing visualization tool." The agent handles the scaffolding; human refinement happens through the same drag-and-drop tools teams already know.

Riley also pointed out that these demos ran on Sonnet, not Opus. Cheaper, faster models produce strong results here, which keeps the cost of agent-driven app generation low.

5. Write and deploy Code Engine packages automatically

The final demo targeted Code Engine, Domo's serverless function layer. Riley prompted Claude Code to create a package with simple math functions. The agent wrote the code and mapped all the input parameter data types. It then deployed the finished package without Riley touching the Code Engine interface.

"If I was doing this by hand," Riley said, "even something this simple would probably take me 15 minutes just to make sure it's all working with AI having written all the code." For more complex packages with seven or more input parameters and multiple functions, he estimated saving up to an hour per package.

The pain point here is specific: Code Engine requires you to define data types for every parameter so that workflows can consume the functions. Doing that manually through the Code Engine interface, especially when building tools that the agent tile itself needs to use, stacks up fast. The agent handles the mapping automatically, and the same MCP tools that create packages can also update them when you need to iterate.

Go deeper with the full session

These five capabilities scratch the surface of what Riley covered. The full livestream also covers the governance angle, including why "vibe governance will get you fired," and the security model around data training when using external AI providers.  

Riley also explains how Domo's consumption-based pricing removes friction for agent-driven workflows. Riley also previewed multi-platform migration demos and the upcoming plugin system that will package these skills for easy installation.

Watch the full livestream.