From Prompting to Partnering: What Agent Mode Changes About AI Readiness

A director in one of our business units needed fast validation on our Copilot adoption metrics. Not a summary, not a vibe check. Hard numbers across the organization, visualized in ways that Viva Insights doesn’t surface natively. The raw data was over 700,000 rows of Copilot analytics. If you’ve ever exported the full Viva Insights Copilot adoption dump, you know the feeling: a spreadsheet that makes your laptop pause and consider its life choices.

Normally, this is a half-day exercise for a totally new report we haven’t tailored before. Export, filter, pivot, clean, format, hand off. I’ve done it enough times to know exactly where the data gets weird: where the column headers don’t mean what you think they mean, where inactive users inflate the counts, where the date ranges need trimming before anything makes sense. But this time, I opened the file in Excel and turned on Agent Mode.

I described what I needed: clean the dataset, isolate active Copilot users, break down usage by feature category and business unit, flag anomalies, and format the output so a director could read it without squinting. Agent Mode didn’t ask me to clarify. It started working. I watched it plan its approach: deciding which columns to filter first, which calculations to run, how to structure the output sheets. It built pivot tables, applied conditional formatting, and caught a date range inconsistency I hadn’t mentioned. When it finished, it walked me through what it had done and why.

The whole thing took minutes. Something I usually measured in fractions of an hour at best just ran itself in a tab in the background in minutes.

And as I sat there looking at a clean, validated workbook that would have eaten my morning, I realized something exciting: the way my team has been teaching 10,000 people to use Copilot is about to need a serious expansion.

The Mental Model We Built (and Why It Worked)

For nearly two years, our entire AI training program has been built on a core interaction pattern. Think of a question or goal. Write a prompt. Review the output. Refine if needed. That loop is the foundation of our four tier training curriculum, our champion network talking points, our office hours demos, our leadership sessions. It works because it’s simple, it’s low-risk, and it maps to something people already understand: dialogue with a colleague for help.

The training progression we built at Huron follows this pattern at every level. At the 101 level, you learn to ask Copilot a clear question. At 201, you learn to ask it in the right embedded app so it has the most relevant specialized tools. At 301, you learn to build agents that encode your questions into repeatable workflows. Even at 401, where we get into Studio and automation, the mental model is still fundamentally about defining what you want and reviewing what you get back until you get deep into fully Agentic building.

This model drove (and keeps) our adoption above 95% active monthly usage. It gave people a comfortable on-ramp. It let them build confidence one interaction at a time. And I’d defend it as the right approach for where Copilot still operates fundamentally.

But Agent Mode just opened a whole new door of simplicity and complexity.

What Agent Mode Actually Changes

If you haven’t used it yet, here’s the short version: Agent Mode, now rolling out across Word, Excel, and PowerPoint, shifts Copilot from a single-prompt-single-output tool to a multi-step reasoning partner. Instead of asking a question and getting an answer, you describe a goal and watch Copilot plan an approach, execute it, validate its own work, and present the results — all while showing you what it’s doing and letting you steer.

In Excel, Agent Mode landed on web general release in January. In Word, it’s been available since November. PowerPoint is rolling out through February. Anthropic is One of the options to drive the tool for M365 Copilot licensed users. One more multi-model opportunity I initiallywrote about when Claude first arrived in the ecosystem, and one that matters even more now that the model is powering multi-step work rather than single responses.

The difference sounds incremental on paper. In practice, it’s a categorical shift.

With the old model, I’d open a massive dataset and think: “What’s my first prompt?” I’d start small (filter this column, create that pivot) and iterate my way toward something useful. Each step was mine to plan. Copilot executed, I orchestrated. In total transparency, few of our Excel-capable employees thought much of it except as a brainstorming partner for method planning. It didn’t reliably do much they couldn’t already at similar speed.

With Agent Mode, the orchestration leaps forward. I described the end state: “Clean this data and prepare it for a director who needs adoption validation by business unit”. Copilot handled the sequencing. It decided to remove inactive users before calculating percentages. It chose to create summary sheets rather than cramming everything into one view. It applied formatting conventions that made the output readable without me specifying font sizes or header colors.

The word for that is delegating.

And if you’ve ever managed a team, you know: delegating is a fundamentally different skill than asking good questions. It requires trust, clarity about outcomes rather than steps, and a willingness to let someone else choose the path even when you’d have chosen differently.

The Skill Gap Nobody’s Training For

Here’s what I keep thinking about. When I watched Agent Mode work through that Viva Insights data, my instinct was to interrupt. I wanted to tell it which columns to filter first. I wanted to specify the pivot table layout. I had to actively resist the urge to micro-manage a process that was, frankly, doing fine without my step-by-step direction.

I’ve been working with AI tools daily for years. I’ve trained hundreds of sessions. I literally built the curriculum. And my first instinct was still to over-prompt.

Now imagine the person in your organization who just got comfortable with “summarize this email thread.” Imagine the manager who finally learned to use Copilot in Teams meetings last quarter. Imagine the analyst who’s been writing careful, specific prompts in Copilot Chat and just getting their head wrapped around their team’s big picture.

Agent Mode asks something different of all of them. It asks them to describe outcomes instead of steps. To trust a multi-step process they didn’t design. To evaluate results without having controlled the method. To know when to steer and when to let it run.

Call it a delegation literacy gap. Most enterprise training programs (including, honestly, ours) aren’t built for it yet with AI in mind.

The closest analogy I can find comes from management, not technology. The hardest transition most individual contributors face when they become managers is learning to define outcomes without dictating methods. You go from “I’ll build this spreadsheet” to “I need this analysis by Thursday, here’s what it needs to show, use your judgment on the approach.” Some people make that transition naturally. A lot of people struggle with it, either micromanaging every step or abdicating so completely that the output misses the mark.

Agent Mode creates the same tension… compressed into a two-minute interaction with a piece of software.

What I’m Testing Now

We’re not overhauling our entire training program overnight. But I am running Agent Mode through real workflows with several teams to see where it lands and where it stumbles.

The Viva Insights scenario is the one I know best, and it’s become my go-to demo. Nearly 700,000 rows, a specific audience with specific needs, and a time constraint that makes the speed difference visceral. When I show people the before-and-after, the reaction isn’t “that’s cool.” It’s closer to “wait, why am I still doing this the old way?”

The pattern I’m seeing: people who are good at managing other people tend to be the quickest to click with Agent Mode. They know how to set direction, check progress, and adjust from the first version of a deliverable to what they really wanted. People who are used to doing everything themselves - often your highest individual performers - can struggle the most.

That’s worth paying attention to, because your best prompt engineers might not be your best Agent Mode users. Different skill, different instinct on day one.

Where This Is Still Rough

I’d be doing you a disservice if I painted Agent Mode as the finished product. It’s not.

It sometimes over-builds. I’ve asked for a simple summary table and gotten a workbook with four sheets, three charts, and conditional formatting I didn’t request. Useful, maybe. But it makes validation harder because now you’re checking work you didn’t ask for.

And the biggest caveat: Agent Mode is at its best with structured, well-defined tasks — data cleanup, document formatting, report generation. For ambiguous, judgment-heavy work, the old prompt-and-refine model can still be more reliable. Agent Mode doesn’t replace your critical thinking. It replaces your repetitive execution. Knowing the difference is the real skill.

The Question That Changed

For two years, the question my users asked most was: “What should I type into Copilot?”

It was a prompting question. A syntax question, almost. And we got good at answering it: with templates, with examples, with workshops that built prompt-writing confidence one session at a time.

The question I’m hearing now, from the people who’ve tried Agent Mode on real work, is different: “How do I know how to point it in the right direction and then verify it didn’t swerve?”

A judgment question. And judgment questions don’t get answered with templates. They get answered with practice, with examples of what good delegation looks like, and with enough trust in the tool to let go of the steering wheel when the road is straight.

We’re early. Agent Mode is weeks old in most apps, and the majority of users haven’t tried it yet. But the shift from “what do I type” to “when do I intervene” is real, it’s happening in my organization right now, and it’s going to reshape how every adoption program thinks about AI readiness in Copilot and beyond.

If you’re running AI training at any scale, try this: take a real task you do weekly, something with clear inputs and a defined output, and hand it to Agent Mode with nothing but a description of what you need at the end. Don’t tell it how. Just tell it what. Then pay attention to your own instincts. Where did you want to jump in? Where did you trust it? Where did it surprise you?

That’s the new curriculum. Learning to partner.