Same Shape, Different Boundary

I spent three hours in a training session run by Microsoft’s Innovation Hub – Silicon Valley today — online, over Teams — and I came out impressed. What they demonstrated isn’t mine to share, so everything specific in this post comes from Microsoft’s public documentation instead. That turns out to be enough: the thing I’ve been chewing on since is something anyone can go read.

Afterward I opened the Scout docs and found my own setup staring back at me.

How I’d draw the stack

Microsoft has three things pointed at three different postures. The framing below is mine, not their marketing — it’s just how the distinction settled in my head afterward:

Experience	How I’d engage it
Microsoft 365 Copilot	“Help me do this.”
Copilot Cowork	“Take care of this outcome.”
Microsoft Scout	“Keep track of this and act when appropriate.”

Only the last is Microsoft’s own language: they launched Scout in June as “your always-on personal agent” — in practice a heartbeat mode that reruns a prompt on a background interval, under its own stricter permission policy for when you aren’t sitting there. Cowork reached general availability the same month.

I use the first two. Copilot is ambient at this point. Cowork I’ve handed genuinely multi-step work — the kind that spans Outlook, Teams, and a document nobody can find — and it does the thing. I’ve also built custom agents in Copilot Studio.

Scout I have not run. It’s prerelease, gated behind the Frontier preview program, and it requires a GitHub Copilot Business or Enterprise seat plus an org policy that permits the app. So what follows is reading, not experience — a line I want to keep bright, because the docs are specific enough to reason from and the specifics are the whole point.

Where I recognized it

Scout is a desktop application for Windows and macOS that reads and writes your files, runs shell commands, drives a browser, and queries Microsoft 365. Fine. That’s the category.

It’s the conventions that stopped me.

Custom skills are SKILL.md files with YAML frontmatter, dropped in a skills directory, discovered automatically at the start of each conversation. The directory is ~/.copilot/skills/. Shell commands run under a three-tier permission system — auto-approve, prompt, deny — with ls and git diff in the first tier and rm -rf / blocked outright. It keeps memory across conversations. It delegates to sub-agents named Explore, Task, Code review, Research, and General-purpose. It tags external content — emails, web pages, Teams messages — as untrusted, and treats it as data rather than instructions.

I did not have to learn any of that. I read it the way you read a translation of a book you already know.

Cowork does the same thing one layer up: custom skills as SKILL.md, stored at Documents/Cowork/skills/{name}/SKILL.md, up to fifty of them.

A year ago these were conventions belonging to one tool. They are now how agents are built, across vendors who are not cooperating. That’s not imitation so much as convergence — the shape was load-bearing, so everyone arrived at it.

The part nobody else can copy

One thing in the docs isn’t borrowed from anywhere: Co-Create, where you and Scout edit the same file at the same time and your changes merge, with the workspace backed by OneDrive or SharePoint. I don’t have an equivalent. Nobody outside Microsoft really can — it requires owning the file format, the sync layer, and the storage.

Notice that it isn’t a better agent loop. It’s integration, in a place Microsoft already owned.

The merge already happened

I’d assumed Microsoft 365 Copilot and GitHub Copilot were on a collision course and would eventually fuse into something like a Microsoft answer to Claude Code.

That’s not a prediction. It’s a description of a thing that already shipped, quietly, one layer below the branding. Scout processes prompts and content through GitHub Copilot. It inherits GitHub Copilot’s model catalog. Your GitHub Copilot administrator determines which models Scout is allowed to use, and the whole arrangement is governed by your organization’s GitHub Customer Agreement.

The convergence wasn’t announced. It was plumbed.

So what’s actually being sold

If the loop is the same everywhere, the loop isn’t the product.

What Microsoft has that nobody else does is the boundary the loop runs inside. Scout authenticates with your organization’s credentials. It reaches only the data your account is already permitted to reach. Administrators govern it through Group Policy and Intune, down to turning off background modes. It’s not available in GCC, GCC High, DoD, or sovereign clouds — which is a strange thing to advertise until you notice that publishing the list is the pitch. Somebody thought about your compliance boundary hard enough to draw its edges.

And if you want the argument stated outright, it’s in a different product entirely. Agent 365 is Microsoft’s control plane for agents, built on three pillars: observe, govern, secure. Not reason, not act, not generate. It gives agents first-class identities in Entra, keeps a registry that includes shadow agents it discovers in your tenant, binds each one to an accountable human owner, and wires the whole thing into Defender, Purview, and Intune.

Then there’s the detail that gave the whole day away: Agent 365 will sync agents built on Amazon Bedrock and Google Vertex AI into that registry, and ships an SDK so anything built anywhere can register itself.

Microsoft is not, at this layer, trying to win the agent. It is assuming you will have agents from everywhere and selling you the place they all have to check in. That’s a company that has read its own history correctly — this is the Active Directory move, run again on a new kind of object.

In April I wrote that I didn’t need OpenClaw anymore, and I ended it by saying the question “what can’t Claude Code do” kept getting harder to answer, and that I’d let you know when I found something.

This is the something. It isn’t a capability. It’s that Claude Code cannot be sanctioned by your employer’s tenant, cannot inherit permissions your organization spent a decade defining, and cannot be switched off by an administrator who is accountable for what it touches. For an individual, none of that sounds like a feature. For an enterprise, it’s the only part that was ever in question.

The same sentence that makes the enterprise case makes the personal one worse: your administrator determines which models are available to you. That’s a downside a CIO reads as the specification. The bill and the feature are the same line item, and which one you’re holding depends on who is accountable for the outcome.

What the CIO actually asks

Every version of this conversation ends in the same place: what’s the return, and are we delivering more than we were?

Microsoft has built for that question harder than anyone. Cowork is metered in Copilot Credits, and you can type /cost inside a task to see roughly what it consumed, how much of your monthly limit you’ve spent, and how much remains. Running it is free, and the docs are careful to say it’s an estimate rather than a billing record.

Behind it sits the apparatus a CIO actually uses: a Cost Management dashboard, spending policies per user and group, hard caps and budget alerts, a credit-request workflow, and consumption broken out by user, group, service, and agent. The Copilot Dashboard goes further and reports estimated financial savings up to leadership.

If /cost feels familiar, it should. It’s the same move as the usage meters in Claude Code and most other harnesses. The difference isn’t the command — it’s the chain behind it, running unbroken from one person’s session to a line item a CFO can read. Microsoft built that chain because Microsoft’s customer is the person who signs for it. That’s not a knock on anyone’s motives; it’s just whose problem each company woke up solving.

But I want to be careful about leaning on it, because cost is not value. Credits consumed is an input; are we delivering more is an output, and no dashboard measures it — including that estimated-savings figure, which is a model rather than a measurement. I’ve written before about mistaking generated output for throughput. A system that reports precisely what I spent while leaving delivery to inference is a better-instrumented version of the same trap.

So the number I need isn’t the one the dashboard hands me. It’s the one I have to go earn.

Where I landed is a question

I run Claude personally and at work, on an enterprise account. I also use GitHub Copilot and Microsoft Copilot at work, because that’s what’s in front of me. Today was the first time I seriously thought: if my employer approves the rest of this stack, I may not need Claude.ai at work anymore.

Not at home. At home the boundary is mine, I intend to keep it, and I’ll keep paying for the privilege of choosing my own models.

But at work the boundary was never mine to begin with — and that isn’t a complaint, it’s the correct arrangement. If the tooling inside that boundary has converged on the same shape as the tooling outside it, the argument for maintaining a second stack gets thin, and I’d rather find that out than defend it out of habit.

Which makes this a case I have to make, not an opinion I get to hold. So the next part is the unglamorous one: take real work, run it through both, and measure what actually shipped. I’ve been on the wrong end of enough confident migrations to want the evidence before the recommendation.

The interesting question stopped being which agent is better. It’s whose boundary you want to be standing inside when one of them is wrong — and the honest answer, for me, depends on which of my two lives you’re asking about.

---

How this post was made. It took 31 minutes in Claude Code and $7.51 — about 7.7 million tokens, though nearly all of that is cached context re-read each turn, against roughly 241,000 tokens of genuinely new input and output — and I’m disclosing it because a post arguing that cost isn’t value shouldn’t hide its own. The argument is mine, and so is nearly every correction that shaped it: I brought the training session, the notes, the Scout and Agent 365 material, the /cost detail, and the ending — including telling Claude that no, I had not actually been standing in Silicon Valley. Claude checked every product claim against Microsoft’s public documentation, caught that a table I’d pasted in was my own framing rather than Microsoft’s, talked me out of a paragraph speculating about Anthropic’s motives, and wrote most of the sentences you just read.

---

Related Reading

• I Don’t Need OpenClaw Anymore — The post this one answers
• Verification Is the Bottleneck — Why control of the loop is the thing that matters
• Choosing the Right AI Coding Tool — The wider landscape