Tag: Copilot

The First Client Problem Isn’t What You Think It Is

image

I’ve watched a lot of people sit on the edge of starting something — a side practice, a Copilot consultancy, a niche advisory offer — and almost none of them are stuck for the reasons they tell themselves. They’ll say they need another certification, one more course, a tighter offer, a better website. What they actually need is to be seen doing the work before the work feels finished.

This is the quieter truth about building anything online, and I think it’s worth saying out loud. The distance between where you are right now and your first paying client is almost never a knowledge gap. Most people reading this already know enough to genuinely help someone tomorrow morning. What’s missing is the willingness to stand up in public as someone building a thing before they feel they’ve earned the right to be seen that way.

The Permission You’re Waiting For Isn’t Coming

Nobody hands out the badge. There is no moment where the industry quietly agrees you’re now ready to charge for advice. I waited a long time for that feeling early on, and I can tell you it doesn’t arrive — you just start, and the evidence catches up.

The strange part is that the evidence is usually already there. If you’ve spent the last few years inside Microsoft 365 — wrangling Conditional Access, untangling SharePoint permissions, helping a team actually adopt Copilot in Outlook instead of just licensing it — you already know more than the SMB owner who is googling at 9pm trying to work out why their Teams meetings won’t record. You don’t need another module. You need to write the post, record the short video, send the email to the contact who half-asked about it last month.

Make Yourself Findable Before You Feel Ready

The practical move is to put something out into the world that someone could trip over. A LinkedIn post about a real Copilot rollout you ran last week. A short Loop page you can share with prospects that walks through how you set up Copilot governance for an SMB. A simple SharePoint site with three case write-ups on it. None of this needs to be polished. It needs to exist.

I use Copilot in Word to take rough voice-memo thoughts and shape them into a draft I can edit down — not to write the post for me, but to break the inertia of the blank page. Then I’ll ask Copilot in Outlook to help me re-thread an email to a warm contact I’ve been meaning to nudge for a fortnight. The tool isn’t doing the courage part. It’s removing the friction so the courage has somewhere to go.

Your First Client Is Watching, They Just Haven’t Said Anything Yet

Here’s what I’ve noticed across years of MSP work: the person who eventually becomes your first paying client is almost always already in your network. They’ve seen a comment of yours, half-read a post, remembered something you said at an event. They are waiting for a small signal that you are open for business. That signal is you — visible, building in public, named as the person who does this thing.

You don’t have to declare yourself an expert. You only have to be specific about what you’re working on right now and who it’s for. The credibility compounds from there.

If you’re sitting on enough knowledge to help someone, the next step isn’t more learning. It’s letting yourself be seen mid-build. The evidence really does catch up. You just have to take the step before it does.

What is Microsoft Agent 365, really?

image

Most folks I talk to think agents are just Copilot with extra steps. They’re not.

A Copilot prompt is a single user, asking a single question, in a single session. An agent keeps running. It has tools, it has access, it makes decisions, and it does all of that whether you’re watching or not.

Agents don’t sleep. They also don’t ask permission.

That’s the part nobody seems ready for. Last year your tenant had users. This year it has users and agents. Some you bought, some your developers built, some your staff spun up in Copilot Studio over the weekend and forgot about.

So here’s the question I keep asking MSPs: do you actually know how many agents are running in your client’s tenant right now? If the answer is “probably some”, that’s not governance. That’s hope.

Microsoft Agent 365 is the control plane for agents. That’s it. It’s not a new agent. It’s not a new Copilot. It’s the place you go to see every agent in the tenant, decide what each one is allowed to do, and shut down the ones that shouldn’t be there.

Think of it like the Microsoft 365 admin centre, but for non-human accounts. The agents your team built. The agents your vendors sold you. The agent embedded inside that SaaS app marketing signed up for last quarter. All of them, in one registry, with one set of policies.

It went generally available on 1 May 2026 at USD$15 per user per month, and it pulls Microsoft Entra Agent ID(opens in new window), Microsoft Purview, and Microsoft Defender into a single agent lifecycle story. The official overview lives on Microsoft Learn(opens in new window).

Notice what’s missing? You. The user. Agent 365 isn’t an end-user tool. It’s for admins, MSPs, and security folks. It’s the dashboard your clients don’t see — and the one that keeps them out of trouble.

Step-by-Step: Finding the agents already in your tenant

The first thing I’d do in any tenant is just look. You’ll be surprised.

Sign in to the Microsoft 365 admin centre

Go to admin.microsoft.com as a Global Admin or AI Administrator.

Open the Agents workload

In the left navigation, expand Agents and select Overview. That’s the Agent 365 dashboard. If the tenant has a qualifying licence, you’ll see Agent 365 branding. If it doesn’t, you still get the baseline agent management view.

Review the registry

Select All agents. This lists every agent the tenant knows about — Copilot Studio agents, declarative agents, SharePoint agents, third-party agents, and anything registered via the new Agent 365 API. Each one shows its owner, source, and current status. The admin centre docs(opens in new window) walk through the columns.

Hunt for ownerless agents

Filter by owner. Anything marked ownerless is a red flag — that’s an agent doing things in the tenant with no human accountable for it. Assign an owner or block it. Don’t leave it.

Apply a policy

From an agent card, set access policies — who can run it, what data it can touch, whether it needs review before it publishes. Use the policy templates rather than rolling your own.

Before Agent 365, the question was “what agents are we using?” After Agent 365, the question is “what agents are we allowing?” Different question, different answer.

Why this actually changes the game

Here’s the real win. Agents inherit risk in a way users don’t. A user clicks a phishing link and one mailbox is compromised. An agent with delegated access and a bad prompt can touch SharePoint, send mail, and rewrite records — at machine speed, across hundreds of users — before anyone notices.

That’s why Agent 365 leans on Entra Agent ID to give every agent a first-class identity. No more agents hiding behind a generic service account. Each one shows up in sign-in logs, audit logs, Conditional Access, and Defender. You can revoke an agent the same way you’d revoke a user.

That’s not a feature. That’s a fundamental shift in how you secure a tenant.

My recommendation?

If you’re an MSP, start the conversation with your clients this quarter. Open the admin centre. Show them the agent list. Most of them have no idea what’s in there, and the longer they don’t know, the bigger the eventual cleanup.

If you’re not showing your clients this, somebody else will — and they’ll be the ones writing the agent governance policy on your client’s tenant.

Agent 365 isn’t there to add another dashboard to your day. It’s there to stop the shadow AI mess before it starts.

The Lie Your Planning Workbook Tells You

image

I’ve watched people spend a year getting ready to start something. New service line, new niche, new offer to clients. Workbooks filled out. Whiteboard sessions. A document called “strategy v7” sitting in OneDrive. Twelve months in, nothing has shipped. No client has been pitched. No post has gone live. And the strangest part is they don’t feel lazy — they feel busy. That’s the trap. The feeling of preparing is almost identical to the feeling of progress, and you can run on that feeling for a very long time before you notice the bank balance hasn’t moved.

Why preparation feels like the work

Preparing is comfortable because it’s measurable in ways that don’t expose you. You can finish a chapter of a workbook. You can refine a niche statement for the eleventh time. You can sit through another planning session in Teams and walk away feeling like the day mattered. Nobody pushes back. Nobody says no. There’s no awkward silence on a call, no email that doesn’t get replied to, no proposal that gets ghosted. It’s all upside, no risk, and it produces just enough output — notes, frameworks, lists — to convince you that you’re moving forward.

The honest test is simple. After all that preparing, can a stranger pay you for it? If the answer is no, you haven’t built anything yet. You’ve built a feeling.

What actually moves the needle

The thing that breaks this loop is uncomfortable, and it always looks the same: do the scary version of the work while it’s still scary. Send the email to the prospect before the offer is perfect. Post on LinkedIn before the niche is fully refined. Quote the client before you’ve memorised every line of the service catalogue. Real signal only comes from real exposure — somebody’s response, or the silence where a response should have been.

This is where Copilot quietly takes the excuse away. You don’t need another month of preparation to draft a cold outreach email — open Copilot in Outlook, give it the rough idea, and you’ve got a working draft in under a minute. You don’t need a workbook to scope a new managed service offer — Copilot in Word can spin up a first-pass outline from a few bullet points. The friction that used to justify months of “getting ready” has mostly been removed. What’s left is the only thing that ever actually mattered: the willingness to put it in front of someone real.

Doing it scared

I’d rather work with someone who has sent ten ugly proposals than someone who has perfected their elevator pitch in a Loop document for half a year. The ugly ten teach you something the workbook never will — what people actually push back on, what they don’t care about, what they’re willing to pay for. You can fold all of that back into a Planner board the next morning and refine in public, while the work is live, instead of refining in private while nothing exists.

The quiet cost

The cost of staying in preparation isn’t just lost revenue. It’s the slow erosion of belief that you’ll ever ship at all. Every month you spend tidying the runway is a month the plane doesn’t take off, and the longer it sits there the heavier it feels to move. The fix isn’t more clarity. It’s a smaller, scarier version of the thing — done today, in public, with whatever you’ve got.

Why Being Small Is Your Real Advantage With AI

image

I had a conversation last week with the owner of a twelve-person business who spent the first ten minutes telling me how far behind they were. The big firms in their industry have AI strategies, AI committees, AI roadmaps. He didn’t have any of that. He thought it was a problem.

I told him it was the opposite. The thing he saw as a weakness — being small — is actually the only real advantage he has right now. And he was wasting it by feeling sheepish about it.

The giants are not as far ahead as they look

When you read the announcements from large enterprises about their AI programs, it sounds impressive. The reality on the ground is messier. Inside those organisations there are governance committees, procurement cycles, security reviews, change boards, and three different vendors pitching competing platforms. By the time they finish arguing about which group owns the rollout, eighteen months have gone past.

A small business doesn’t carry that weight. There is no internal committee. There is the owner, the team, and the work. That’s it. Decisions get made on a Tuesday afternoon and acted on by Wednesday morning.

You can turn Copilot on this week

This is where the gap becomes obvious. A small business can switch on Microsoft 365 Copilot for ten people on a Monday and by Friday have someone using it inside Outlook to triage their inbox before lunch, someone else using it in Excel to clean up a messy supplier list that’s been sitting there for two years, and another person catching up on a Teams meeting they missed without watching the recording. None of that requires a steering group. It requires a licence, half an hour of curiosity, and a willingness to have a go.

The big firm down the road is still drafting their pilot scope document. You’re already past the awkward learning phase and into actual benefit.

Pivoting is cheap when there’s nothing in the way

The other thing being small lets you do is change your mind. When a better way of doing something comes along — a new agent in Copilot Studio that automates an approval, a Power Automate flow that handles client onboarding, a smarter way to use SharePoint as a knowledge base — you can swap it in without unwinding a tangle of legacy processes. There’s no 200-page change management plan. There’s a conversation, a test on Thursday, and a rollout next week if it works.

Bigger organisations can’t move like that. Every change touches another change, which touches a third. There’s a process owner who needs to be consulted, a training team that needs to be briefed, an integration that needs to be re-tested. The cost of pivoting goes up sharply the larger you get. For you, that cost is almost nothing — and you should be spending it freely.

Stop trying to look like them

The mistake I see SMB owners making is trying to copy the way big businesses adopt technology. They want a strategy document, a steering committee, a phased rollout plan. They think that’s what serious looks like.

It isn’t. That’s what slow looks like.

Serious, for a small business, is being three steps ahead because you didn’t waste six months talking about it. The bigger players will catch up eventually — they always do. Your job between now and then is to use the head start, not apologise for it. Get Copilot in front of your team, let them break things, and bank the lead while you’ve got it.

What Copilot Chat Developer Mode Actually Shows You

image

I spent a solid hour last month watching a declarative agent ignore an API plugin I’d wired up. The instructions were clear, the manifest looked right, the OpenAPI spec was valid. Every prompt came back with a confident answer that had nothing to do with my data. Copilot was making things up rather than calling my endpoint, and I had no idea why.

Then I typed -developer on into Copilot Chat, and the mystery evaporated in about thirty seconds.

Seeing the Orchestrator Think

Developer mode is a built-in debugging tool in Microsoft 365 Copilot Chat. Type that command and every response from your agent comes back with a debug card — a detailed breakdown of what the orchestrator did behind the scenes to produce its answer.

The card shows three things that matter. First, agent metadata and capabilities: which knowledge sources are active, whether web search is enabled, and the identifiers you need for tracking a specific conversation. Second, function matching: did the orchestrator consider your API plugin’s functions relevant to the user’s prompt? Third, execution details: if a function was selected, what HTTP request did Copilot actually send, what response came back, and how long did it take?

That last section is where most of the debugging value lives. You can see the endpoint that was called, the request headers with auth tokens redacted, and the full response body. When something fails, you’re reading the receipt — not guessing.

The Problem It Actually Solves

Before developer mode, troubleshooting a misbehaving agent in Copilot meant staring at manifest files trying to work out what went sideways. Your agent returned a wrong answer and you couldn’t tell where the chain broke. Was the orchestrator not matching your function? Matching but failing on auth? Getting bad data back from the API? The orchestration layer was a black box.

Now you see exactly where it breaks. In my case, the debug card showed “No matched functions” — meaning the orchestrator never even considered calling my API. The problem wasn’t auth or endpoints or response formatting. It was my description_for_model field. The description said “Returns project data” but my prompt asked “What’s the status of the Henderson build?” The orchestrator couldn’t bridge that semantic gap.

I rewrote the description to cover the ways people actually ask about project status, and the next prompt hit the API cleanly.

Where It Fits in Your Workflow

Developer mode works directly in the browser. Open Copilot Chat, select your agent, type -developer on, and start testing prompts. If you’re using the Microsoft 365 Agents Toolkit in Visual Studio Code, press F5 to launch your agent and the same command activates in the chat window. The debug panel in the toolkit gives you a matching view with downloadable diagnostic logs.

A couple of patterns worth knowing: when the debug card shows “No functions selected for execution,” your function descriptions likely aren’t semantically close enough to the prompt. When it shows a function was selected but execution failed, the HTTP status code in the card usually tells you what went wrong — a 401 means your OAuth registration doesn’t match, a timeout means your API needs to respond faster.

What I’m Watching

Microsoft keeps expanding what the debug card reveals, and the Quick Copy feature now lets you export the full debugging JSON to share with a colleague or attach to a support ticket. For anyone building agents that connect to external APIs through Copilot, this is the single most useful diagnostic tool in the stack. It turns “something’s broken” into “here’s exactly what happened, and here’s why.”

If you haven’t typed -developer on yet, start there.

  1. Microsoft Learn — Test and debug agents using Developer Mode https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/debugging-agents-copilot-studio(opens in new window) The primary documentation page. Covers enabling/disabling developer mode, the debug info card fields, troubleshooting common failures, and how to report issues.

  2. Microsoft Learn — Test and debug agents in Microsoft 365 Agents Toolkit using developer mode https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/debugging-agents-vscode(opens in new window) Focuses on using developer mode alongside the Agents Toolkit in VS Code (F5 launch, debug panel, diagnostic logs).

  3. Microsoft 365 Developer Blog — Introducing the agent debugging experience in Microsoft 365 Copilot (April 9, 2025) https://devblogs.microsoft.com/microsoft365dev/introducing-the-agent-debugging-experience-in-microsoft-365-copilot/(opens in new window) The GA announcement post by Carol Mbasinge Kigoonya. Covers new features including agent configuration insights, execution monitoring, latency tracking, and Quick Copy Debugging JSON.

  4. Microsoft 365 Roadmap — Feature ID 474450 https://www.microsoft.com/microsoft-365/roadmap?featureid=474450(opens in new window) The original roadmap entry for Copilot Chat developer mode, listed as GA from January 2025.

  5. Microsoft Learn — Set up your development environment for Microsoft 365 Copilot https://learn.microsoft.com/en-us/microsoft-365/copilot/extensibility/prerequisites(opens in new window) Broader context on the Copilot development environment, licensing, and extensibility options that developer mode supports.

Why developers don’t own this one

image

I keep hearing the same thing from MSPs and IT pros when GitHub Copilot CLI comes up.

“That’s a developer tool, right? Not for me.”

No.

That’s the assumption I want to push back on. If you spend any time at a terminal — running PowerShell against a tenant, poking at logs, scripting an onboarding — Copilot CLI belongs on your machine.

And once you bolt Work IQ onto it, your terminal stops being a code playground and starts being something genuinely useful for the M365 work you already do.

What is GitHub Copilot CLI, really?

It’s an AI assistant that lives in your shell.

You install it, run copilot, and start typing in plain English. It proposes commands, runs them with your approval, edits files, reads repositories — and it holds context across the whole session. Every action waits for your tick before it executes, which I appreciate. Nothing happens to your machine without you saying yes.

Think of it less as a coding tool and more as a terminal pair who never gets bored and never forgets the exact git syntax you can never remember.

Step-by-Step: Getting Copilot CLI on your machine

You’ll need an active GitHub Copilot subscription (Pro, Pro+, Business, or Enterprise) and Node.js v22 or higher. On Windows, PowerShell 6 or higher.

Install the package

Screenshot 2026-04-26 075341

Run:

winget install Github.Copilot

as an administrator that the command prompt

Launch it

copilot

Sign in

At the prompt, type login and follow the browser flow. That’s the whole authentication dance.

The full walkthrough — including winget, Homebrew, and the install script — sits on the official GitHub Copilot CLI installation docs.

That’s it. You’re talking to your terminal.

Step-by-Step: Connecting Work IQ inside Copilot CLI

Here’s where it gets interesting for anyone living in Microsoft 365.

Work IQ is a Microsoft MCP server that pipes your M365 tenant data — emails, meetings, documents, Teams messages, people — straight into Copilot CLI. It’s in public preview, and your tenant admin needs to grant consent the first time.

Open Copilot CLI

copilot

Add the plugin marketplace

copilot-plugins

Install the plugin

plugin install workiq@copilot-plugins

Restart and ask

Screenshot 2026-04-26 075859

Quit Copilot CLI, relaunch it, then try something like:

What did my client say last week about the Intune rollout?

Notice what’s missing? You never opened Outlook. You never opened Teams. You never alt-tabbed.

The official walkthrough — including admin consent and the EULA acceptance you’ll deal with once — sits on Microsoft Learn’s Work IQ overview. The broader plugin and MCP picture for the CLI is on the GitHub Copilot CLI docs.

Why this actually changes how you work

Most of my day, like yours, is spent jumping between windows. Email. Teams. SharePoint. A browser with seven tabs of Microsoft Learn open.

“But I already have Copilot in Microsoft 365 — why bother with the CLI?”

Because the CLI is where you do the work. Drafting an email is fine inside Outlook. But when you’re scripting tenant changes, comparing config exports, or poking at a stubborn migration log, you don’t want to leave the terminal to ask a question about the client. With Work IQ, you don’t.

That’s not a productivity tweak. That’s collapsing two tools into one place.

Here’s the real win for MSPs. Your engineers can ask once — “summarise the last five tickets from this client and show me the related Teams chat” — without context-switching, without copy-paste, without losing their thread. Same hour billed, more thinking inside it.

If you’re not showing your clients what their own terminal can already do for them, you’re leaving value on the table.

Copilot CLI doesn’t get tired. Use that.

GitHub Copilot CLI plus Work IQ isn’t there to make you faster at the terminal. It’s there to make the terminal stop being an island.

The Command Line Is Quietly Coming Back

image

I had a quiet moment last week that made me stop and think. I was watching a younger colleague get something done in about thirty seconds — no mouse, no menus, no four browser tabs open. Just typed a sentence into a terminal, hit enter, and the work was done. It looked exactly like the way I used to work in the late nineties, except the thing on the other side of the prompt was now an AI.

That’s the part I keep turning over. For more than two decades we have been told the future is graphical. Click, drag, drop, swipe. Every product wanted to be more visual, more “intuitive”, more pointy and clicky than the last one. And now, very quietly, the command line is walking back into the room — with a tool like GitHub Copilot CLI under its arm.

Typing is faster than clicking, again

The reason this shift is happening isn’t nostalgia. It’s pace. When you can describe what you want in plain English and have a tool translate that into the right command, the whole “where is that menu again” tax disappears. I’ve watched people who genuinely could not tell you what grep does happily ask Copilot CLI to find every file on their machine that mentions a particular client, and get a clean answer in seconds.

That same pattern is now showing up everywhere I look in Microsoft 365. Copilot in Outlook is, in effect, a command line for your inbox. You type “find the email from the supplier about pricing last month and draft a reply” and you’re done. No folder hunting, no scrolling. Copilot in Excel does the same thing for data — you describe the pivot you want, the chart you want, the trend you want highlighted, and it happens. The mouse becomes optional.

The interface is becoming language

What I think we’re really watching is not a return to green text on black screens. It’s the recognition that human language is itself a pretty good interface. For years we tried to dumb computers down for people. Now we’re meeting in the middle. People type or speak what they want. The machine figures out the click path.

Look at Microsoft Teams. The new way to drive it isn’t to click through tabs and channels — it’s to ask Copilot what was decided in yesterday’s project meeting, who owes who an action item, and what changed in the shared OneNote since Friday. The chat box has quietly become the most powerful button in the application.

What it means for how we work

For business leaders this matters more than it might first appear. The people who get good at “talking” to their tools — whether that’s Copilot CLI on a developer’s laptop, Copilot in Word turning rough notes into a board paper, or Copilot in SharePoint pulling the right policy out of a thousand documents — are going to be visibly faster than the people still hunting through ribbons and right-click menus.

I’m telling clients to start treating prompt-writing as a normal workplace skill, the same way we once treated email etiquette. It is the new shortcut key.

What I’m watching next

The interesting question is whether this collapses the distinction between “technical” and “non-technical” users altogether. If everyone’s interface is a sentence, the playing field flattens fast. The command line never really left. It just learned to listen.