%402x.svg)
A practical map of how AI moves through a data team, from copilots to autonomous agents. Where most teams are today, and what the next 12 to 18 months actually look like.
The reason most AI transformation programs underperform is that they price themselves on Wave 1 numbers and ship Wave 1 outcomes. Developers get a Copilot subscription, the org claims AI adoption, productivity moves 5 to 15 percent, and the operating model stays exactly what it was. That is the floor of what is possible, and most teams stop there.
Wave 2 is the territory where agents do the work and humans approve. The components exist today: MCP-capable agents like Claude Code, Cursor, and Cline; enterprise ticket systems like Azure DevOps, Jira, and Linear; spec sources like SharePoint, Confluence, and Notion. Most data teams already own all of them. The blocker is process design and approval discipline, not only technology.
Wave 3 is real but further out. The technology is in place; governance maturity is not, and that is the actual work between Wave 2 and Wave 3. Per-repo service principals, audit trails for agent actions, cost controls on autonomous loops: build them, and Wave 3 follows. The realistic horizon is 18 months.
Wave 1 is where most organizations sit today: individual copilots, no change to the team or the lifecycle. Wave 5 is research. The work between Wave 2 and Wave 3 is where the next 12 to 18 months of real productivity gains happen, and that is where this guide spends most of its pages.
Today, everything stays inside the client tenant. No AI in the workflow. The numbers below describe a high-complexity data engineering task, the kind that comes up several times a month in any serious data team.
End-to-end time per high-complexity task: 11 person-days.
Developer effort: 8 person-days (~73% of total). Five days to analyze, discuss, implement. Two and a half days of sandbox testing. Half a day for PR and peer review.
Joint-team validation: 3 person-days (~27% of total). UAT, deployment, manual data reload. Unchanged across all waves. Joint responsibility of project manager, key user, and the data and analytics team.
The same lifecycle as Wave 1, but the agent reads the team's tickets, specs, and code, then proposes and executes work. The developer keeps two clear approval gates: one before any code is written, one before the PR is merged.
Developer triggers the agent, accepts the proposed solution, runs sandbox tests, and approves the PR. Two clear approval gates: before code is written and before merge.
Sample high-complexity task: 0.5 to 2 person-days vs. 8 person-days baseline. End-to-end 4 to 5 person-days per task, dominated by 3 person-days of joint validation that does not change.
DevOps task and comments, linked epics, SharePoint mappings. The agent reads them all before proposing a solution. Context is built from existing sources of truth, no parallel knowledge base.
Developer accepts the proposed solution before any code is written, then approves the PR before merge. Between those gates, the agent does the work and the developer reviews artefacts.
Wave 3 changes who initiates the work. The agent polls Azure DevOps on a schedule, proposes a solution as a task comment, implements on "do it" approval, and opens a draft PR. Two human checkpoints remain: comment approval and PR review.
Most Wave 1 to Wave 2 attempts stall because the team tries to transform too much at once. The pattern that works is bounded: one workflow, one ticket system, one developer team. Measure the baseline before you change anything. The 90 days below assume that scope, and they assume you start on Monday.
Identify one repeating, high-volume, low-risk task type. Measure the actual person-days per task today across three people, three tasks each. This is the number Wave 2 has to beat.
Set up MCP for your ticket system. Set up a per-developer sandbox. Codify the CLAUDE.md for that one workflow. Run with the agent on 5 to 10 tasks and measure new person-days per task.
Compare new effort to baseline. Calculate uplift honestly. Document what works and what does not. Add a second workflow. Repeat the setup pattern.
Context discipline. Without a curated CLAUDE.md and knowledge base, the agent produces plausible-looking work that does not match your conventions. Treat context as the product.
Approval fatigue. Developers stop reading the agent's proposals carefully after the first week. Build in spot-check audits.
Governance ambiguity. "Who owns this?" is the question that stalls more Wave 2 rollouts than any technical issue. Decide before you start.
Everything on this page, plus the deeper material: Jira ticket agent vision, self-assessment grid, objection handling for Genie / Cortex / Copilot for Fabric, and a longer walk-through of the 90-day path with worked numbers.
The Five Waves describe how AI moves through a data team. Wave 1 is Humans with Copilots (individual IDE assistants, around 10 percent productivity uplift). Wave 2 is Humans with Agents (AI agents execute tasks, humans approve at two checkpoints, up to 30 percent). Wave 3 is Agents with Humans (agents own the loop, humans own the checkpoints, 30 to 50 percent). Wave 4 (Agents) and Wave 5 (Autopoietic Agents) are research, TBC at production scale.
Most data teams are in Wave 1. Developers use copilots in their IDE, the organization claims AI adoption, productivity moves 5 to 15 percent, and the operating model stays unchanged. This is the floor of what is possible with current technology, and most teams stop there.
Wave 1 has copilots inside the IDE only, with no change to the team or the lifecycle. Wave 2 has agents reading the team's tickets, specs, and code, then proposing and executing work while humans approve at two checkpoints per task. The lifecycle changes; team composition does not.
Most organizations are 12 to 18 months from Wave 3. The technology is already in place. The work between Wave 2 and Wave 3 is governance maturity. This work cannot be shortcut.
Genie, Cortex, and Copilot for Fabric are natural-language interfaces sitting inside the data platform. They are complementary, not competitive. The agent pattern in the Five Waves framework sits across the full toolchain (tickets, specs, code, tests, PR), in the layer where dbt code, dbt tests, and merged PRs are produced.
Eight to twelve weeks for one bounded workflow on existing infrastructure. The 90-day path: Days 1 to 30 pick one workflow and measure the baseline. Days 31 to 60 wire one agent to one source of truth. Days 61 to 90 measure, expand, and codify into a playbook.
Most data teams already own everything they need. The components are: an MCP-capable agent (Claude Code, Cursor agent, Cline), an enterprise ticket system (Azure DevOps, Jira, Linear), and a spec source (SharePoint, Confluence, Notion). The blocker is process design and approval discipline, not tooling.
Two clear human approval gates per task: one before code is written (developer accepts the proposed solution) and one before merge (developer approves the PR). The agent has read-only access to the team's sources of truth. For Wave 3, governance maturity extends to per-repo service principals, agent action audit trails, and cost controls on autonomous loops.
The one-day workshop is the same framework, applied to your stack, with your team in the room. We measure your baseline, design one Wave 2 workflow live, and ship a working setup by 16:30.
See the workshop