Scenario 1 - The Digital Twin

🚧 Work in progress

This scenario is drafted and being tested. Details may change before the event.

The problem

Copilot already knows a lot about how you work. Its memory and Work IQ read across your mail, calendar, and Teams, so most drafts start close to right.

What it can't do is show you the picture it's formed of you, let you fix where it's wrong, or carry it into another tool. The calls you actually make - which priority wins when two collide, what you never send without checking, whose sign-off you wait for - it just re-guesses, session after session. So you re-brief it from scratch each time, and rewrite most of what it hands back.

In this scenario you build a digital twin: one small, portable file that holds how you work in plain language you can read, correct, and reuse. You point it at your own work, fix what it gets wrong, and add the things your history can't show - until the draft comes back sounding like you, for reasons you can name.

What 'done' looks like

A twin is a SKILL.md plus a references/ folder - the Agent Skills open standard, so the same files run in Cowork, VS Code Copilot, and the GitHub Copilot CLI unmodified.

Inside references/:

• persona.md - who you are and how you work. Rules, boundaries, what's live, what gives in a bad week.
• voice.md - real sent-message samples and the style rules they imply.

The twin writes those two itself, from what Work IQ can see in your mail, Teams and calendar. The rest of the hack is yours: you correct what it got wrong, then add the files it has no way to know - the people you deal with, what you've already committed to, what's already been decided.

The Scout altitude turns the twin into whatever you want built on top of it - a dashboard, a command, a scheduled briefing, an MCP server. The Code altitude calls it from a program instead of a chat window: a git hook, a service, a daemon, a tool other agents can reach.

Done means the twin drafts in a way you'd recognize as yours, and you can point to the rule that produced it.

The proof is a real thread

Name something unresolved from your own inbox. The twin retrieves it and answers. If the answer isn't yours, you've found the missing rule.

The data

Cowork and Scout build the twin from your own Microsoft 365 data - sent mail, calendar, Teams. It only ever sees what you can already see, and the files stay in your tenant, on your screen.

Code ships a fictional twin instead. The starter arrives pre-populated with a made-up engineer at a made-up company, so the session is spent building rather than writing a persona, and nothing personal goes near a shared exercise. Making it yours is something you do afterwards, with a Copilot surface that can see your work.

Build paths

🧬 Scenario 1 · The Digital Twin

A portable spec of how you work

• 🟢 Cowork – Microsoft 365 Copilot + Cowork🚧
• 🔵 Scout – Microsoft Scout🚧
• 🟣 Code – VS Code + GitHub Copilot🚧

Assembly maps

Use the building blocks for your altitude.

• 🟢 Cowork:

  1. Connect Cowork to a data source
  2. Write a reusable Cowork skill
  3. Produce a formatted output
  4. Re-run a skill on new inputs

• 🔵 Scout:

  1. Set up Microsoft Scout
  2. Use Work IQ
  3. Build an app with Scout
  4. Run it on a schedule

• 🟣 Code:

  1. Set up VS Code + GitHub Copilot
  2. Build an MCP connector
  3. Use Work IQ
  4. Add a guardrail

Team model

In Cowork, everyone builds their own twin and the table converges on shape - compare rules, steal good tiebreakers.

In Scout, everyone installs their own twin, then the table picks one thing to build on it and splits the work - one on the build, one on what it reads, one on the rules that shape it, one on how it's triggered. You share prompts and files, never anything from your inbox.

In Code, everyone gets their twin answering from a program, then the table picks one thing to build and splits it by the seams that already exist - the trigger, the input, the call, the output. Each piece is testable against a stub, so nobody waits to start.