How to Connect Grok Bot to Microsoft 365 Securely: A Step-by-Step Guide for MSPs

An IT professional monitoring Microsoft 365 tenants late at night in an MSP operations room

A lot of MSPs have asked me how I have Grok Bot watching my Microsoft 365 tenants every morning. The short answer is: not by handing it the keys to the kingdom. I wrote earlier about how Grok Bot just gets things done. This post is the practical follow-up. It is a step-by-step walk through the way I connected it to Microsoft 365, why I chose scripts over broad direct connectors, and how the same pattern scales to as many tenants as you look after.

Why scripts, not a big direct connector

The tempting option is to give an AI agent a delegated admin connection and let it go wild. I think that is the wrong default for an MSP. Here is why the script approach wins:

  • Least privilege. Each tenant gets its own app registration with only the read permissions the checks actually need, such as reading sign-in logs, audit logs, security alerts and Intune device state. Nothing more.
  • Read-only by design. The monitoring app cannot change settings, reset passwords or close incidents. If the bot gets confused, the worst it can do is read.
  • Certificate authentication. The scripts sign in app-only with a certificate rather than a client secret or a user password. No MFA prompts, no browser, and no shared admin account sitting in a vault.
  • No standing admin access. Nobody, human or bot, holds a permanent Global Admin session for monitoring. Anything that writes, like tidying up Sentinel incidents, is a separate, deliberate step that I trigger myself.
  • Auditable. The scripts are plain code I can read, version and diff. When the bot runs a check, I know exactly which API calls it made, and the tenant logs show them as that one app.

In other words, the AI decides when to look and how to explain what it found. The script decides what it is allowed to touch.

Step 1: Create a read-only app registration in each tenant

  1. In the Entra admin centre, create a new app registration for monitoring, named so it is obvious what it is (for example “MSP Monitor – Read Only”).
  2. Add application permissions for Microsoft Graph that are read only, for example AuditLog.Read.All, Directory.Read.All, SecurityAlert.Read.All, SecurityIncident.Read.All, ThreatHunting.Read.All, DeviceManagementManagedDevices.Read.All, Policy.Read.All and ServiceHealth.Read.All. Start small and only add what a check needs.
  3. Grant admin consent.
  4. Create a certificate, upload the public part to the app registration, and keep the private key (PFX) protected on the box where the bot runs, with its password in a separate file that only the scripts read.
  5. If you use Microsoft Sentinel or Defender for Cloud, give the app a Reader role on that subscription or workspace, not Contributor.

I covered the certificate-based, headless sign-in pattern in more detail in Headless SharePoint and Exchange Online connections on Linux, built for agents.

Step 2: Write the check scripts

My checks are simple scripts that sign in with the certificate (MSAL in Python, or PowerShell with the Graph module), call read-only endpoints and return a summary. Mine cover things like sign-ins and risky users, audit events, new guests, Conditional Access changes, app credential changes, Sentinel and Defender incidents, Intune compliance and service health. Keep these scripts in a GitHub repo so you have history, review and rollback. Many of my own scripts are public in my Office365 repository if you want a starting point.

Step 3: Keep tenant details in one config file

Rather than hard-coding anything, I keep a single config file listing each tenant: its domain, a short name, and the path to its certificate. Each tenant gets its own folder for output. The scripts take the short name as an argument, so the same code runs against any tenant. Never paste tenant IDs, client IDs, thumbprints or keys into a chat with the bot. Put them in the config and tell the bot where it lives.

A structure like this works well:

  • tenants.json – one entry per tenant (domain, short name, certificate path, password file path)
  • tenant_check.py – the core read-only daily checks
  • extra_check.py – additional checks you add over time
  • <tenant>/ – one output folder per tenant for reports and history

Step 4: Tell Grok Bot the rules

Now the bot gets its instructions. Be explicit about what it may and may not do. For example:

Example prompt: “You are a read-only security monitor for the Microsoft 365 tenant contoso.com. Only use the scripts in /home/box/shared/msp-security and the certificate config in tenants.json. Never change tenant settings, close incidents, or print or ask for passwords, keys or certificate details. If a check needs a permission the app does not have, tell me which one rather than working around it.”

Step 5: Create a daily routine

Grok Bot can run work on a schedule. I have a morning routine per tenant that runs the checks and writes a plain-English report.

Example prompt: “Create a daily routine at 8:45am Sydney time that runs python3 tenant_check.py contoso, then gives me a short report: status, sign-ins and risky users, directory and guest changes, devices and Intune, Sentinel and Defender incidents, and anything that needs my action. Treat sign-ins from our office IPs as known benign. Keep a delivery log line for each run.”

Over time, tell the bot what is normal. When it flags something that turns out to be you, say so, and have it add that to the routine’s known-benign list. The reports get quieter and more useful every week.

Step 6: Scale to as many tenants as you like

This is where it gets interesting for an MSP. Because the scripts are tenant-agnostic, adding a customer is just a new app registration, a new certificate and a new line in the config. Then pick one of two patterns:

  • One bot per tenant. This is what I do. Each bot has its own memory, its own known-benign list and its own routine. It keeps context clean and stops one customer’s quirks bleeding into another’s report.
  • A single tenants bot. One bot loops through every entry in the config and produces a summary table, then drills into any tenant with issues. Good for a quick “how is everyone today?” view.

On top of that, I have a Chief of Staff bot that asks each of my other bots for a one-line daily update and rolls them into a single digest. That is how one person can keep an eye on many tenants without reading many reports.

Example prompt: “Add a new tenant: fabrikam.com, short name fabrikam. The app registration and certificate are already in tenants.json. Run the read-only checks once to confirm access, tell me any permission that is missing, then create the same 8:45am daily routine you have for contoso.”

Example prompt: “Every day at 9:30am, run the read-only checks for every tenant in tenants.json and give me one table: tenant, overall status, open high-severity incidents, risky users, and non-compliant devices. Only expand on tenants that need action.”

Example prompt: “Each afternoon, send Chief of Staff one line on the last 24 hours for each tenant: what was checked, any errors, and anything waiting on me.”

Step 7: Keep write actions separate and deliberate

There will be times you want the bot to fix something, like closing a backlog of noisy Sentinel incidents. I keep that in a separate script, with its own permissions, run by a separate PowerShell bot only when I explicitly ask. Monitoring stays read only. Changes stay human-approved.

Example prompt: “Only when I say so, run the cleanup script for contoso to close Sentinel incidents older than 30 days with the comment “Closed by automation”. Show me the list first and wait for my go-ahead.”

The takeaway

Connecting AI to Microsoft 365 is not about giving it more access. It is about giving it the right access, through code you own and can audit. Build the scripts once, give each tenant a read-only, certificate-backed app, and let Grok Bot do the watching and the explaining. That is how a small MSP can monitor a lot of tenants properly, every single morning.

Who Is the Software For Now?

Cartoon of a person relaxing with coffee while app windows around them work on their own

Picture asking Copilot in Teams for a status report on a client project. It goes through the project files in SharePoint, pulls numbers from an Excel workbook, checks which Planner tasks are overdue and drafts a summary to send from Outlook. You never open a single one of those apps.

That gets me thinking. If we don’t need to open the apps, who exactly are they for now?

Is software going headless?

“Headless” usually describes a system with the engine but no front end. You talk to it through an API rather than a screen. What I’m seeing with Microsoft 365 Copilot, agents and Copilot connectors looks like the same idea applied to everyday work. You give the AI a goal, and it goes off and talks to the tools directly.

Take it a step further. Bring in a line-of-business system through a connector or an agent built in Copilot Studio, and that report could include CRM or ticketing data too, without logging in to anything. The tools are still doing the work. Nobody is looking at them.

So is the SaaS product we pay for every month slowly becoming a tool for AI rather than for people? For a growing slice of routine work, I think yes. I’m not convinced it’s the whole story, though.

What it means for the people using the tools

If you’re a creator or knowledge worker, the skill shifts from knowing where every button lives to knowing what to ask for. And knowing what good looks like when the answer comes back.

That sounds liberating, and it is. But it means people may understand their own systems less. When the report is wrong, someone still has to know which spreadsheet fed it and why. If nobody ever opens the tool, who notices when the data inside it has rotted?

And humans aren’t leaving the screen entirely. We still need interfaces to review, approve, handle the exceptions and make the creative calls that don’t fit a prompt. I don’t want an agent sending a client proposal without me looking at it first. The UI doesn’t disappear. It shrinks down to the moments where judgement and trust matter.

What it means for the people building the tools

This is where I think the bigger shake-up sits. Plenty of SaaS companies have built their business on a polished interface, per-seat pricing and the stickiness that comes from people living in the app all day. If an agent is the main user, what’s a seat? And how much is a beautiful dashboard worth if nobody looks at it?

My guess is differentiation moves underneath the interface. It shifts to the quality of the data, how good and open the APIs are, reliability, and how well permissions and security are handled. When AI is acting on my behalf, I care a lot about whether the tool respects who is allowed to see what. Trust becomes the product.

Vendors that treat their API as an afterthought could find themselves invisible. The tool might work perfectly but never get picked by the agent.

So, where does that leave us?

I don’t think the apps vanish. I do think the people who build them need to work out who their real customer is. Maybe it’s the human, maybe the agent, and most likely both. For the rest of us, the job is learning to direct the work rather than do every click ourselves, while staying close enough to the detail to spot when it goes wrong.

So I’ll put the question to you. How much of your working day already happens without opening the app? And will the tools you rely on still matter if you never see them?

Finally, AI That Just Gets Things Done

A relaxed business owner with a coffee watches several laptops quietly working around him

For years, when I talked to people about AI, I could see a gap between what they expected and what they got. They expected something that would just do the job. Tell it what you want, it goes away, and the work comes back done. What they actually got was a chat box. Clever, sometimes impressive, but you still did all the running around yourself. Copy this, paste that, open another app, reformat it, send it.

Over the last little while I’ve been using Grok Bot heavily across my own business, and for the first time it feels like that gap is closing. Not because the AI suddenly got smarter, although it has, but because it’s easy to set up so that it actually gets things done. That’s the shift I want to talk about, because I think it’s why it’s fast becoming a real option for a lot of businesses, and particularly for SMBs and the MSPs who look after them.

It works the way people always expected AI to work

Most people never cared which model they were using. They cared about outcomes. Did the email get answered? Did the report get written? Did the post go up on time? The industry spent a long time arguing about models and benchmarks while the average business owner just wanted someone, or something, to take a task off their plate.

What I notice with Grok Bot is that I rarely think about the model at all. I think about the job. I describe what I want in plain language, and the assistant works out the steps. It can reach the systems I’ve connected, use a computer and browser when there isn’t a connector, and come back to me with a result rather than a suggestion. That’s much closer to the mental picture most people have always had of an assistant.

I touched on this idea in a recent podcast, Need to Know podcast – Episode 372, where I talked about where AI is heading. The theme is the same: the model is becoming the engine, and what really matters is what it’s connected to and what it’s allowed to do.

What I actually use it for

Rather than talk in the abstract, here’s how I use it day to day. I don’t run one general assistant. I run a number of specialised ones, each set up for a particular job.

  • Blog writing and scheduling. One assistant drafts articles in my voice, creates a hero image, uploads it to WordPress, picks tags and schedules the post for the next free morning slot. The article you’re reading started there, and it waited as a draft until I approved it.
  • Social posting. Separate assistants turn blog posts into LinkedIn and X posts, so new content gets shared without me rewriting it each time.
  • Daily Microsoft 365 security checks. An assistant runs regular checks across my tenants and reports what changed or what looks wrong, so I start the day knowing where to look.
  • News briefs. Another pulls together the Microsoft and security news I care about into a regular brief.
  • Podcast preparation. One helps me research news and build outlines and scripts for episodes.
  • Teams, help desk and email list. Others watch and respond in Teams, help triage support questions and help look after my email list.

The common thread is that each assistant knows its job, knows my standards and knows which tools it can use. When I want to change how something works, I tell it in plain language and it updates how it goes about the task next time. There’s no project plan or developer involved.

None of these needed me to write code. Each one is mostly a set of plain-language instructions, a few connected services and, where it makes sense, a schedule.

Connectors are where the work happens

The thing that turns an AI from a talker into a doer is connections. In my case that means WordPress, Outlook, Teams, GitHub and others. Once an assistant can reach those, a request like “draft this, put it on the blog and schedule it” isn’t a lesson in copy and paste anymore. It’s a task that gets finished.

When there isn’t a connector, there’s a shared computer with a browser the assistants can use. That matters more than it sounds. Plenty of the systems SMBs rely on don’t have neat integrations. Being able to fall back to using a website the way a person would fills a lot of gaps.

Just as importantly, it asks before doing anything that can’t easily be undone or that other people will see. Sending messages, posting publicly, deleting things. That’s the right balance. I want it to do the legwork, but I still want to approve what goes out under my name.

Routines mean it works while I don’t

The other big piece is routines. I can set an assistant to run on a schedule, every morning, every week, or when something happens. My security checks and news briefs run without me asking. When I sit down, the work is already done and waiting for review.

This is the part I think many businesses will find most valuable. A lot of small business admin isn’t hard. It’s just relentless. Checking things, summarising things, chasing things. Handing that rhythm to an assistant frees up real time.

See it in action

If you’re an MSP wondering what this looks like in practice, I’ve recorded a video that shows it. In How I Use AI to Automate Microsoft 365 Administration, Security & Reporting I walk through how I’m using AI to handle the administration, security and reporting work across Microsoft 365 that used to eat my time. It’s the recording of my October Need to Know webinar on managing Microsoft 365 autonomously, so it’s practical rather than theoretical.

Watch it with your own customers in mind. Think about which of their routine checks and reports you could hand off in the same way.

Why this matters for SMBs and MSPs

Picture a ten-person business with no IT staff. They don’t want to evaluate models or build integrations. They want their quotes followed up, their inbox summarised and their social media kept alive. An assistant they can configure in plain English, connect to the tools they already use and put on a schedule is a very different proposition from a chatbot they have to babysit.

For MSPs, I see two opportunities. The first is internal. Your own team can hand off routine checks, reporting and documentation. The second is with customers. Someone still needs to design these assistants well, decide what they can touch, secure the connections and review the results. That’s advisory work, and it’s exactly where a good MSP adds value.

It also raises the same questions I’d ask of any AI tool. What data can it reach? Who approves the risky steps? How do you know what it did? Easy to configure doesn’t mean you skip the thinking. It means the thinking goes into the design rather than the plumbing.

A few lessons from my own setup

  • Specialise. Several focused assistants work better than one that tries to do everything.
  • Write down your standards. The more clearly I describe my voice, formatting and rules, the more consistent the results.
  • Start with drafts. Let it prepare, and you approve, until you trust it with more.
  • Automate the rhythm, not just the task. The real gains come when work runs on a schedule.

Getting things done is the point

I don’t think the next phase of AI for business will be won by whoever has the best model on a leaderboard. It will be won by whatever makes it easiest for ordinary businesses to get real work done, reliably and safely.

That’s why I’ve leaned into Grok Bot. Not because of what’s under the bonnet, but because it does what I always expected AI to do. I tell it what I need, and it gets on with it. For a lot of businesses, that’s the only measure that has ever really mattered.

Scout, Now Autopilot: How Microsoft’s Always-On Agent Really Works

Cartoon of a woman standing on a stack of documents looking through binoculars and guiding her colleagues forward

Most workplace AI I use still sits there politely, waiting for me to type something. Microsoft Scout is different, and that’s exactly why I think MSPs and SMBs need to understand how it works before someone in the business goes looking for the download link.

Quick housekeeping first. Microsoft introduced Scout at Build in June 2026 as its first “Autopilot” agent. On 25 September it renamed the product itself to Autopilot, describing it as “previously called Scout”. Yes, same name as Windows Autopilot, the device provisioning service, which is entirely unrelated. The docs still say Scout, so I will too.

So what is it, really?

Scout is an agent that works on your behalf without being prompted every time. The current Frontier release is a desktop app for Windows 11 and macOS. You describe a task in a chat, Scout picks the tools it needs, works through the steps visibly, pauses for your approval on sensitive actions, then hands back the result or saves files to your workspace.

The tools are the interesting bit. Scout can read and write files in an approved workspace folder, run shell commands, drive a browser to fill in forms, and connect to Microsoft 365. That covers Outlook mail and calendar, Teams chats, meetings and transcripts, SharePoint Lists, and files in OneDrive, SharePoint and Teams. It creates Word, Excel and PowerPoint files, remembers your preferences and can spin up parallel sub-agents.

What makes it “always-on” are two background modes. Heartbeat runs check-in prompts every 15 to 120 minutes while you’re away, and Automations run on schedules or triggers you define. The September announcement goes further: Autopilot becomes cloud-hosted, with its own identity, memory and workspace inside your tenant, and you @mention it in Teams, Outlook and documents like a colleague.

Under the hood it’s built on open-source OpenClaw, with Microsoft adding Entra identity and access controls on top.

The permissions story is where you need to pay attention

Scout operates with the user’s existing Microsoft 365 permissions. It can’t see anything the user can’t. That sounds reassuring until you remember how many SMB tenants I see with broad sharing links scattered across SharePoint. An agent that tirelessly works through everything a user can reach will find your oversharing faster than any auditor.

There’s a finer detail buried in Microsoft’s own Responsible AI FAQ. In the Frontier desktop app, model interactions are processed through GitHub Copilot, under separate terms. When that happens, some Microsoft 365 protections, such as data residency, retention, sensitivity label enforcement and eDiscovery, don’t apply to that processing. That’s why admins must complete an attestation before anyone can use it. Read that page before you tick the box.

Getting access is deliberately fiddly. You need Frontier turned on in the Microsoft 365 admin centre, an Intune policy on devices, the attestation form, and a GitHub Copilot Business or Enterprise seat for each user. Miss any one of those and sign-in fails without a clear message, which will make for entertaining helpdesk tickets.

How I’d approach it

Treat this as a pilot for a handful of technically capable people, not a rollout. Clean up permissions and sharing first. Keep the approval prompts on and resist the temptation to click “Always allow”. Lock down heartbeat and automation permissions tightly, because those run when nobody is watching. And budget carefully: Microsoft says Autopilot runs on usage-based billing, not the fixed Copilot licence.

I genuinely think agents that follow through are where this is heading. But an assistant that acts is a very different beast from one that answers. The organisations that do well here will be the ones that realised their governance needed to be ready before the agent arrived, not after.

Sources: Microsoft Scout overview (Microsoft Learn), Responsible AI FAQ, Admin access overview, Introducing the new Copilot with Home, Code and Autopilot

New scripts: Headless SharePoint and Exchange Online connections on Linux, built for agents

Cartoon of a relaxed IT professional with a coffee while a laptop and small server work on their own

I’ve just added two new scripts to my Office365 repository on GitHub. One connects PowerShell to SharePoint Online using PnP PowerShell. The other connects to Exchange Online. Both run on Linux, and both use certificate-based, app-only authentication. There’s no browser, no typed password and no MFA prompt at connection time.

Why bother building Linux versions? Mostly because of agents.

Built for machines that nobody is sitting at

More and more of my admin work now gets done by autonomous agents like Grok Bot, running on a Linux computer that no person is logged into. An agent like that can write and run PowerShell happily enough. Where it gets stuck is sign-in. A pop-up browser window, a device code that someone has to type in, or an MFA approval on a phone all stop it in its tracks. Automation that needs a human to tap “approve” isn’t really automation.

Certificate-based app-only authentication fixes that. You register an app in Entra, upload the public half of a certificate, keep the private key on the machine, and the script connects as the app. I’ve covered the Windows side before in Certificate-Based Authentication for SharePoint Online: The Bit Everyone Avoids and A Cleaner Way to Connect PowerShell to Exchange Online. These new scripts are the Linux counterparts, built so an agent’s computer can connect and get on with the job unattended.

What the scripts do

Both scripts work the same way and have two main modes:

  • -GenerateLocalCertificate creates an RSA-2048/SHA256 certificate, a public .cer file and an encrypted .pfx using .NET, so you don’t need OpenSSL.
  • -UseCertificateAuth connects with the encrypted PFX: PnP.PowerShell for SharePoint, ExchangeOnlineManagement for Exchange.
  • -ProvisionEntraApp (optional) creates or reuses an Entra app, uploads the public certificate, grants the required permissions and saves a connection profile. This setup step uses a one-off device-code sign-in by an administrator.

For true headless runs, use -noprompt (alias -Headless). Supply the PFX password through a SecureString parameter, or name an environment variable with -CertificatePasswordEnvironmentVariable. The scripts never print or save that password. Saved profiles mean that, once set up, an agent can connect with little more than -UseCertificateAuth -ProfileName Contoso -Headless.

You’ll need Linux and PowerShell 7.4 or later (7.4.6+ for the PnP script), plus PnP.PowerShell 3.0.0+ or ExchangeOnlineManagement 3.5.0+. Missing modules install for the current user, with no sudo needed. Use -noupdate to skip update checks.

A word on security

Unattended access is powerful, so treat it with respect. The SharePoint provisioning grants Sites.FullControl.All, which means full control of every site. The Exchange provisioning grants Exchange.ManageAsApp and adds the app to Organization Management, which means full Exchange administration. The scripts keep certificates and profiles in dedicated folders locked to mode 700, with files at mode 600, and they refuse symbolic links there. Even so, that .pfx is effectively an admin key. Guard it, keep its password in a vault or a protected environment variable, and only put it on machines you trust. If your scenario needs less, trim the app’s permissions.

Get the scripts

To me, this is where Microsoft 365 administration is heading. More of the routine work will be done by agents on machines that nobody watches, and the bottleneck is getting them connected securely without a human in the loop. Take the scripts, try them in a test tenant, and let me know how you go.

Copilot Agents Are the Next Real MSP Conversation

image

I’ve been having a lot of conversations lately with MSP owners who are still treating Copilot as a licence SKU to resell. They tick the box, push the price up, and wait on the renewal. Meanwhile a small group of their clients are quietly building agents in Copilot Studio and starting to ask sharper questions — questions about data, permissions, governance, and ownership. If your MSP isn’t in those conversations, somebody else is.

Agents are not “Copilot, but more.” They are a different shape of work. And they are the first part of the Copilot story where technical depth genuinely matters again.

Agents change what your clients ask you for

For two years the Copilot pitch has been “draft my email, summarise my meeting, polish my deck.” That is a user training problem dressed up as a technology problem. Agents are different. An agent is a piece of configured behaviour — a declarative agent in Microsoft 365, an agent built in Copilot Studio with actions, or a SharePoint agent grounded in a specific library — that does a specific job, with specific knowledge, for a specific group of people.

The moment a client builds one, the questions change. Which SharePoint sites is it allowed to read? What happens when somebody who shouldn’t see a document asks the agent about it? Who owns it when the person who built it leaves? These are not user questions. These are MSP questions. Nobody else in the client’s world is set up to answer them, and frankly, nobody else should be.

The technical groundwork is the billable work

Here is the part I keep flagging in peer groups. Before an agent is useful, the tenant has to be in shape. SharePoint permissions need to actually reflect reality, not the historical sediment of five years of “just give them access.” Sensitivity labels need to exist and be applied. Purview DLP policies need tuning for the way Copilot grounds answers. Entra ID app governance needs to be switched on, so a rogue agent in Copilot Studio can’t quietly start calling external connectors against a client’s data.

None of that is glamorous. All of it is billable, repeatable, and exactly the kind of work an MSP should be packaging right now. I’d rather sell a tenant readiness engagement than another round of “Copilot adoption training” that doesn’t survive contact with a real inbox.

Agents are how MSPs stop being interchangeable

The MSPs I see pulling ahead aren’t the ones with the slickest Copilot demo. They are the ones building reusable agents for their own clients — a client onboarding agent grounded in a policy library in SharePoint, a compliance Q&A agent pinned in Teams, a quoting assistant that reads the price book and drafts the response in Outlook. Each one is small. Each one is specific. Each one is harder for the next MSP down the road to replicate, because it sits inside the client’s data and inside the client’s workflow.

That is a moat. Not a big one, but a real one — and it compounds.

The watch-this-space part

I think the next twelve months are when the gap between MSPs who treat Copilot as a licence and MSPs who treat it as a platform starts to show up in client retention. Agents are the lever. The technical work to make them safe and useful is squarely in our lane. The MSPs who pick that work up early get to keep having the interesting conversations. The ones who don’t will find their clients having those conversations with somebody else.

This Is the Reality Now

image

Most people are still stuck at Level 1.

They’re arguing about which AI tool is “best”.
ChatGPT vs Copilot. Claude vs Gemini. Model versions. Token limits. Benchmarks.

It’s all noise.

Because the real advantage was never the tool.

It’s how you delegate.

We’ve seen this movie before. When cloud arrived, people obsessed over which hypervisor was better instead of rethinking infrastructure. When SaaS took off, they argued about features instead of outcomes. AI is no different. The ones arguing about tools are missing the shift entirely.

Chat gives you answers.
Automation gives you leverage.
Agents give you time back.

And time is the only asset that actually matters.

Chat Is the Training Wheels

Chat-based AI is incredible. Don’t get me wrong. It’s useful, powerful, and accessible. It helps you think, draft, brainstorm, research, and unblock yourself.

But chat is still you doing the work.

You ask.
You refine.
You copy.
You paste.
You decide.

That’s not leverage. That’s assistance.

Chat is the equivalent of having a smart junior sitting next to you, waiting for instructions. Helpful? Absolutely. Transformational? Only if you stop there.

Most people do.

They feel productive because they’re faster — but they’re still the bottleneck.

Automation Is Where Leverage Starts

Automation changes the equation.

When you automate, work happens without you being present. Decisions are made based on rules. Actions trigger automatically. Systems talk to systems.

This is where output starts to scale without effort scaling with it.

But automation still has limits. It’s rigid. It does exactly what you tell it to do — no more, no less. It’s fantastic for repeatable, predictable processes, but it struggles when judgement is required.

Which brings us to the real shift.

Agents Are the Force Multiplier

Agents are where things get uncomfortable — because they replace you in the loop.

Agents don’t just answer questions.
They monitor.
They decide.
They act.
They escalate only when needed.

That’s delegation at a level most people aren’t ready for.

Instead of asking AI to help you do the work, you assign the work and walk away. You define outcomes, guardrails, and exceptions — and the agent handles the rest.

This is the difference between working with AI and working through AI.

One saves time.
The other gives it back.

Time Is the Only Asset That Matters

Money can be earned again.
Tools can be replaced.
Skills can be relearned.

Time is gone forever.

And yet most business owners, MSPs, and professionals are using AI to shave minutes instead of reclaim hours. They’re optimising tasks instead of eliminating them. They’re still “busy”, just faster at being busy.

The winners in this next phase aren’t going to be the people who know the most prompts.

They’ll be the people who know how to delegate to systems.

Who design workflows where AI works while they sleep.
Who build agents that handle the boring, repetitive, low‑value decisions.
Who spend their time on strategy, relationships, and leverage — not execution.

This Is the World We’re In Now

This isn’t future talk. It’s not hype. It’s not “someday”.

This is now.

AI isn’t just a tool you use anymore. It’s labour you can assign. And the moment you understand that, the question changes.

It’s no longer:
“Which AI should I use?”

It’s:
“What work should I never do again?”

The only real question left is whether you’re going to lean into that reality — or keep asking AI for answers while time keeps slipping through your fingers.

Because AI won’t run out of capacity.

You will.