From chat to delegation — your A-to-Z field manual for Microsoft 365 Copilot Cowork.
Reselling Copilot Studio or Azure AI Foundry consumption alongside Cowork means your customer needs a working Azure billing account first — and most M365-only partners have never set one up. See Azure Billing Setup for CSP Partners: The Complete Field Guide for the exhaustive, screenshot-sourced walkthrough, including every fringe scenario (existing PAYG subscriptions, EA coexistence, partner-to-partner transfers, indirect reseller flows, and the common errors that block a purchase).
Copilot Cowork doesn’t chat with you — it goes off and does the work while you’re in a meeting, in a car, or asleep.
Copilot Cowork is a new Microsoft 365 Copilot surface, announced on March 9, 2026 by Charles Lamanna, that lets you delegate multi-step work to an AI agent instead of chatting with it turn-by-turn. It runs server-side inside your Microsoft 365 tenant, reads and writes across Outlook, Teams, Word, Excel, PowerPoint, SharePoint, and OneDrive through Microsoft Graph, and runs on a choice of models: Anthropic Claude as a Microsoft subprocessor for most reasoning and drafting, plus OpenAI GPT and xAI Grok models, with Auto picking for you by default.
It is not a rename of Copilot Chat. Chat answers one question at a time. Cowork takes a task like “review last week, clean up my calendar, draft regrets for conflicts, and block 3 hours of focus time Tuesday” and actually does it — with an approval preview before anything hits your inbox or calendar.
SKILL.md stored in OneDrive at /Documents/Cowork/skills/<name>/SKILL.md files into OneDrive to codify your team’s playbooks. Cowork auto-discovers them at the start of each session.Cowork runs in the browser at copilot.cloud.microsoft (the old m365.cloud.microsoft address still resolves), inside Outlook and Teams, in the Copilot desktop app for Windows and macOS, and — since May 5, 2026 — in the Copilot mobile app for iPhone and Android. There is no separate Cowork app.
During November 2026 Microsoft is rolling out a single Home screen in the Copilot app (Frontier tenants got it in October). On Home you type your request and choose Chat or Cowork with the toggle in the message box. Tenants that haven’t received it yet still see Cowork as a tab next to Chat.
Cowork for work and school accounts has been generally available worldwide since June 16, 2026. It needs a Microsoft 365 Copilot license plus usage-based billing that your admin sets up. Frontier is now the early-access channel for extras such as the App skill and Claude Fable 5.1. A personal-account version is in preview, and in education only faculty and staff are eligible.
The single most important mindset shift for a new Cowork user is to stop thinking of it as a chatbot.
You ask → it answers → you iterate.
You stay in the loop on every turn. The conversation is the work. When you close the window, the work stops.
Best for quick questions, drafting a paragraph, summarizing a single file, or explaining a concept.
You delegate → it works → you review.
You describe the outcome. Cowork plans, executes, asks for clarification only when it genuinely can’t proceed, and lands finished artifacts in OneDrive or your inbox.
Best for multi-step tasks: meeting prep, weekly reports, customer briefings, calendar cleanup, recurring briefings, research-then-draft jobs.
Cowork runs server-side — “it keeps working even when I close my laptop” — is the single biggest practical change vs chat-bound Copilot.
— Pascal Brunner-Nikolla, Microsoft MVP, Copilot Cowork first look
Practically, this means the unit of work is a Task, not a chat turn. You’ll get the best results by writing prompts the way you’d brief a colleague: state the goal, the constraints, the data sources, the deliverable, and where you want it saved.
If you learn only one thing from this guide, make it this. It explains 90% of the “my AI got dumb” experiences users report.
Every time you press Enter, Cowork (and every Claude-backed product) re-reads your entire conversation from turn one before answering your new message. The model has no memory between turns. What you perceive as “remembering” is actually the client app re-sending the whole transcript every single time.
“The Messages API is stateless, which means that you always send the full conversational history to the API.” — Anthropic, Using the Messages API (platform.claude.com)
A realistic 20-turn Sonnet 4.6 conversation (500-token system prompt, ~600 tokens of user input per turn, ~1,200 tokens of assistant output per turn, no caching):
| Turn | Cumulative input tokens | Input cost (no cache) | With 90% cache read after turn 1 | Savings |
|---|---|---|---|---|
| 1 | 1,100 | $0.0033 | $0.0033 | — |
| 5 | 10,100 | $0.0303 | $0.0044 | 85% |
| 10 | 22,600 | $0.0678 | $0.0083 | 88% |
| 15 | 35,100 | $0.1053 | $0.0122 | 88% |
| 20 | 47,600 | $0.1428 | $0.0162 | 89% |
Scaled to a marathon session: a single turn at 150k tokens costs roughly $0.45 in input alone versus $0.09 at 30k tokens — a 5× difference for the same one-line prompt (SitePoint, Mar 2026).
Cowork bills in Copilot Credits rather than tokens, but Microsoft lists context volume as one of the drivers of Cowork usage, so the shape of this curve carries over.
Every minute you spend piling more context into a single Task raises the cost, slows the response, and lowers the quality of what comes back. The fix is counter-intuitive but universal: new objective → new Task. Stable rules go in SKILL.md. Heavy data goes in an attached OneDrive file. Intermediate exploration goes to Deep Research. You don’t lose much by starting fresh: standing rules live in custom instructions and SKILL.md, shared background lives in a Project, and you can reference the old task with / instead of continuing it.
Cowork ships with a model picker set to Auto by default. Auto chooses from the models your organization allows, and you can pick one yourself from the Model dropdown in the chat box; Cowork keeps a manual choice on that device until you change it. A model badge in the conversation shows which model produced each response. Microsoft’s list as of November 3, 2026 is below. What you see depends on your tenant’s settings and region, and the list has changed several times since June, so check it before you quote it.
| Model | Microsoft’s description | Notes |
|---|---|---|
| Auto | For most day-to-day work | The default. Picks from the models your organization enables. |
| Claude Opus 5.5 | For complex, high-stakes work | Anthropic as a Microsoft subprocessor |
| Claude Sonnet 5.5 | Efficient for everyday tasks | Anthropic as a Microsoft subprocessor; use it for a shorter response cycle |
| Claude Fable 5.1 (Frontier) | Most advanced model for ambitious projects | Depending on your organization’s eligibility, it runs either with Anthropic as a Microsoft subprocessor and no retention, or as an “Anthropic model with Data Retention” that your admin must separately enable. Cowork shows a note in the picker and a banner when the selected model requires retention. |
| GPT 6.1 Sol | Intelligent and efficient for hard work | OpenAI as a Microsoft subprocessor |
| GPT 6 Astra | Latest model for tough problems | OpenAI as a Microsoft subprocessor |
| GPT 5.6 Terra | Balanced effort for common tasks | OpenAI as a Microsoft subprocessor |
| GPT 5.5 (Frontier) | Capable model for medium-effort work | Hosted in Azure AI Foundry |
| Grok 4.7 | Strong on long documents, coding, and multi-step tasks | xAI as an independent processor, not a Microsoft subprocessor |
Next to the model picker is a reasoning effort setting: Light, Medium (the default), High, Extra High or Max. Higher effort is more thorough but slower, and uses more Copilot Credits. Your choice sticks across tasks until you change it. Admins can turn off the Anthropic model family; that never blocks Cowork itself, and Auto chooses from the other allowed models.
EU Data Boundary tenants run Cowork on GPT models only. Microsoft’s Cowork model guide and FAQ (Nov 3, 2026) say only GPT models are supported inside the EU Data Boundary, and that Cowork access is limited to Anthropic-supported regions. The Copilot-wide Anthropic opt-in for EU, EFTA and UK tenants, where Anthropic is off by default, is a separate setting; Microsoft does not say it changes the Cowork picker inside the boundary. UK and EFTA tenants should check the picker with their admin.
U.S. government and sovereign clouds: Cowork is not documented as available. Microsoft says Cowork comes to its US Government clouds after Microsoft 365 G7, with no date, and Anthropic models are open only to non-federal GCC tenants. Check before you scope a public-sector deal.
“Will it continue to use lower-end models or older models without telling you the way Copilot does?”
— Ethan Mollick (Wharton), reacting to the Cowork launch. Reported by GeekWire, Mar 9 2026.
Microsoft has since added a per-response model badge, which answers the transparency half of Mollick’s question. Auto still chooses for you unless you override it, and Microsoft doesn’t publish how Auto chooses. If model transparency matters for a use case (regulated drafting, legal review), pick the model explicitly and record it, with the date, alongside the output.
Every power-user pattern across Claude Code, Claude.ai, and Copilot Cowork reduces to six moves. Internalize these and Cowork starts feeling like a colleague instead of a quirky chatbot.
If the goal changes, the Task changes. Don’t reuse yesterday’s Task for today’s question. Anthropic’s own rule for Claude Code applies exactly: “when you start a new task, you should also start a new session.”
SKILL.md, not chatTone, structure, never-do rules, section templates, output destinations — all belong in a SKILL.md file that Cowork auto-discovers. Instructions repeated in chat get lost during compaction; instructions in SKILL.md are re-loaded every session.
The 250k-character message limit is plenty for a pointer to state. Attach the spec/report/dashboard at the start of the Task — it sits in the stable prefix and caches well. Drip-feeding file content across messages scatters it across the growing messages tail and is the worst of both worlds.
If you just need a conclusion, not a transcript, delegate it. Microsoft doesn’t document how Deep Research manages context, but in practice it behaves like a sub-agent: give it a self-contained brief and ask for the conclusion, so the intermediate tool noise stays out of the parent Task.
When Cowork repeats itself, forgets a constraint you set, hallucinates a file path, or slows down noticeably — stop and restart. Paste a short hand-written summary of what you’d decided into the new Task. This is the single highest-leverage habit in the guide.
Every re-confirmation adds a turn to the conversation. If Cowork is going to send 11 similar emails, approve the first from More options with the narrowest scope that fits (one recipient, one domain, or always for this session), or use Approve All when several are queued, and let the rest flow. You retain oversight at the Task level.
This plan is aimed at the Microsoft 365 professional who has “used Copilot a few times.” Do these in order; each builds the muscle for the next.
Open Cowork and say (in plain English):
“Every morning at 8:30 AM, send me a daily briefing covering (1) unread email from the last 16 hours that looks important or from anyone who reports to me, (2) my first three meetings with a one-line context per meeting pulled from prior emails, and (3) anything marked follow-up from yesterday. Save the output to my Cowork conversations and send a Teams message to myself with the highlights.”
Open Automations → Manage schedules in the left navigation. You now have a durable recurring agent. This alone is worth the license.
Pick tomorrow’s most important meeting. Tell Cowork:
“For my [time] meeting with [attendees], put together a briefing packet: last six months of email with these people, any open opportunities from CRM if you have access, prior meeting notes, and three suggested talking points. Save as a Word doc in OneDrive at /Meetings/[date]-[name].docx.”
Try this on a messy week:
“Review my next 10 business days. Find any meetings I can decline or delegate without impact, protect at least three 90-minute focus blocks, and draft regrets (polite, in my voice) for meetings I’m declining. Show me the full plan as a preview before making any changes.”
SKILL.mdPick one thing you write the same way every time (a weekly status, a customer brief, a deal review). Write it as a skill (see Section 12 for the template). From that day forward, any Task that needs that format just works.
Pick a company, topic, or competitor you’d normally spend an afternoon researching. Delegate it:
“Use Deep Research to produce a 3-page brief on [topic]: key facts, recent developments, three strategic implications for us. Save to OneDrive at /Research/[topic].docx. Don’t ask me follow-ups unless you hit a genuine ambiguity.”
By Friday: one durable daily agent, one briefing template you trust, one decluttered calendar, one SKILL.md doing invisible work, and one research artifact you didn’t have to write. That’s the baseline. Everything else in this guide compounds from there.
The comparison most people have in their head — “Cowork vs Claude.ai” — is already out of date. As of November 2026, one Claude account spans Chat, Code, Cowork and Design, plus extensions for Office, Outlook, Google Workspace, Chrome and Slack, and Microsoft 365 Copilot Cowork is a separate, separately licensed surface. Before you can decide which one to use, you have to know they all exist.
A single Claude account gives you Claude Chat, Claude Code, Claude Cowork, Claude Design, and the Claude extensions (Excel, PowerPoint, Word, Outlook and Google Workspace in beta, Slack, plus Claude in Chrome) — all on one subscription. Copilot Cowork lives outside this bundle, inside your Microsoft 365 tenant. It needs a Microsoft 365 Copilot license (E7 includes one) plus usage-based Copilot Credits for every Cowork task.
| Product | What it’s for | Where it runs | Licensing |
|---|---|---|---|
| Claude Chat claude.ai · web, desktop, iOS, Android |
One-question-at-a-time assistant. Artifacts for interactive HTML/SVG/code. Projects, Memory, Research, Skills. | Anthropic cloud | Free · Pro $17/mo (billed yearly) · Max $100/mo · Ultra $200/mo · Team from $20/seat/mo · Enterprise $20/seat/mo plus usage at API rates (Anthropic list prices) |
| Claude Code CLI · VS Code · JetBrains · desktop · web · iOS |
Agentic coding tool: reads/writes files, runs shells, edits git repos, spawns subagents, runs plan-mode loops, runs scheduled tasks (formerly Routines). | Your machine + Anthropic cloud (scheduled tasks are cloud-run) | Included on Pro, Max, Ultra, Team, Enterprise |
| Claude Cowork desktop (macOS · Windows · Linux beta) · web · mobile app (beta on Team) · Chrome side panel |
Non-developer agentic desktop app for knowledge work: file organization, document prep, research synthesis, data extraction. “Claude Code power for knowledge work.” | Anthropic cloud; the desktop app adds local folders, browser use and computer use (research preview); plan-and-approve gates; connector directory | Included on all paid Claude plans |
| Claude Design launched April 17, 2026 |
Launched as a research preview. Prototypes, slides, one-pagers from a text prompt. Builds team design systems from your codebase + design files. Exports PDF, URL, PPTX, or push to Canva. | Anthropic cloud (desktop UI) | Listed on every Claude plan, including Free; Enterprise admins turn it on |
| Claude extensions Excel · PowerPoint · Word · Outlook (beta) · Google Workspace (beta) · Slack · plus Claude in Chrome |
Embed Claude directly in the Office file you’re editing. Claude for Excel writes formulas with cell-level citations and builds financial models. | Inside the Office app you already use | Included on Pro, Max, Team, Enterprise |
| Microsoft 365 Copilot Cowork copilot.cloud.microsoft · Outlook · Teams · Copilot desktop and mobile apps |
Agentic execution layer inside your M365 tenant. 14 built-in skills (Word, Excel, PowerPoint, PDF, Email, Scheduling, Calendar Management, Meetings, Daily Briefing, Enterprise Search, Deep Research and more, with App in Frontier), plus plugins. Scheduled and event-driven tasks. SKILL.md customization. | Server-side in your Microsoft 365 tenant (Graph + Purview) | Needs a Copilot license: E7 ($99/user/mo, GA May 1, 2026), the standalone Copilot license ($30/user/mo), or Copilot Business ($21/user/mo, $18 promotional price ends Dec 31, 2026; up to 300 users). Microsoft list prices, US, paid yearly · Cowork itself GA Jun 16, 2026; every task billed in Copilot Credits on top of the seat |
Sources: Anthropic — Download Claude; Anthropic — Claude Cowork product page; Anthropic — Claude pricing (retrieved Nov 4, 2026); Claude Help Center — Get started with Claude Cowork (retrieved Nov 4, 2026); Claude Code Docs — Scheduled tasks (retrieved Nov 4, 2026); Anthropic — Claude Design, Apr 17 2026; Anthropic — Claude for Microsoft 365; Microsoft Learn — Copilot Cowork common questions (Nov 3, 2026); Microsoft Learn — Use Copilot Cowork (Nov 3, 2026).
SKILL.md files per user, each up to 1 MB with up to 20 companion reference files (10 MB total) per skill, stored in lowercase /Documents/Cowork/skills/. GA also added event-driven tasks — triggered by an incoming email or a Teams message, not only by a schedule — and an effort-level selector next to the model picker to trade off quality, speed, and Copilot Credit cost.Sources: Microsoft Tech Community — Opus 4.7 in M365 Copilot, Apr 16 2026; Microsoft Tech Community — Opus 4.8, May 28 2026; Microsoft Tech Community — More models, one Copilot, Sep 22 2026; Microsoft Tech Community — GPT 6.1 Sol and Claude Sonnet 5.5, Sep 30 2026; Microsoft Copilot Blog — Evolution of the Copilot pricing model, Sep 25 2026; Microsoft Tech Community — What’s New in Microsoft Copilot, October 2026 (Oct 30 2026); Microsoft Learn — Use Copilot Cowork, Nov 3 2026; Microsoft Partner Center announcements — November 2026 (Nov 3 2026).
| Dimension | Copilot Cowork | Claude Chat | Claude Code | Claude Cowork | Claude Design |
|---|---|---|---|---|---|
| Reads your tenant email/calendar/SharePoint | Yes via Graph | No | Only via MCP connectors | Only via connectors | No |
| Respects Microsoft 365 ACLs | Yes by design | No | No | No | No |
| Reads your local files | No | File upload only | Yes full FS | Yes authorized folders | File upload only |
| Runs shell commands | No | No | Yes Bash | Via Computer Use (preview) | No |
| Native Word/Excel/PPT/Teams actions | Yes first-class | Via Artifacts (sandbox) | Via Skills (PPTX/DOCX/XLSX) | Writes real files | Exports PPTX/PDF |
| Scheduled recurring tasks | Yes native, up to 25 per user | No | Yes scheduled tasks, formerly Routines (research preview) | Yes cloud-run | No |
| Custom skills / playbooks | 50 × SKILL.md in OneDrive | Anthropic Skills | File-based skills + subagents | SKILL.md | Design systems |
| Who picks the model | You or Auto (the default); a badge shows which model answered | You pick | You pick per session | Per Anthropic plan (admin-set model list on Foundry, Bedrock or Vertex) | Multi-model since GA; Fable 5 opt-in in Frontier |
| Enterprise audit / Purview | Yes Purview | No | Enterprise: Compliance API | Enterprise: Compliance API | No |
| Mobile | Yes iOS/Android since May 5, 2026 | Yes | iOS companion | Yes mobile app (beta on Team; Enterprise when an owner enables it) | Not documented |
| Delete files / folders | Blocked by policy | N/A | Yes via Bash | Yes with approval | N/A |
The task reads or writes data inside your M365 tenant; enterprise audit is mandatory; the output has to respect existing SharePoint/OneDrive/Outlook ACLs; or you need a scheduled agent that your admin and Purview can see. This is the only product in the landscape that treats your tenant as a first-class operating environment.
You’re editing a git repository, running tests, debugging, refactoring, spawning subagents on a codebase, or need any form of shell access. Bash and a full local filesystem are what Claude Code has and nothing else in this table does.
The work lives outside your employer’s tenant — local folders, Dropbox, personal Gmail, research PDFs, a side project — and you want agentic plan-and-approve execution on Anthropic’s cloud without shipping any of it through your employer’s tenant. (Microsoft now previews Cowork for personal Microsoft accounts too; keep the workshop line simple: the work tenant gets Copilot Cowork under Purview, and anything personal is the user’s choice.)
You need a single-turn answer, a quick draft, an explanation, an interactive Artifact (HTML/SVG prototype), or a visual mock (Claude Design, if you have access). Works well on mobile. Not designed for multi-step agentic execution.
You want a fast in-tenant answer, no write actions, no scheduling, no cross-app orchestration — the question fits in one turn and you don’t need Cowork’s approval-gate overhead. This is the Work IQ–grounded chat you already know.
There is no “winner” in this table. Each product wins the slot it was designed for. The mistake to avoid: trying to do tenant work in Claude Code (no Graph, no ACLs, no audit) or trying to do code work in Copilot Cowork (no shell, no local files, no git). That’s the next two sections.
If you paste the same message into Claude Chat, Claude Code, Claude Cowork desktop, and Microsoft 365 Copilot Cowork, you will get four different answers. Not slightly different. Structurally different. This confuses new users — “aren’t they all Claude?” — and it shapes what each tool is actually good for.
The divergence is not a bug, and it is not randomness. Each product assembles a different prompt package around your text before the model sees it. Seven mechanisms stack up.
You don’t send a prompt to Claude. You send a prompt to a product, and the product assembles (system prompt) + (tool definitions) + (injected context) + (your message) before sending it to Claude. The four products assemble very different packages. That’s the whole ballgame.
Anthropic publishes claude.ai’s system prompt verbatim — it sets identity, formatting rules, the current date, and safety behaviors. Claude Code’s preset is documented in structure (“tool usage, code style, working directory, git status”) but not in full. Copilot Cowork’s is Microsoft-authored, and Microsoft does not publish it; Microsoft says only that system instructions guide Cowork’s behavior. Source: Anthropic — System Prompts release notes; Anthropic — Modifying system prompts; Microsoft Learn — Application card: Copilot Cowork (Sep 22, 2026).
Claude.ai has Artifacts, web search, and file upload — no shell. Claude Code has Read, Write, Edit, Bash, Grep, Glob, WebSearch, subagents. Copilot Cowork has 14 built-in Microsoft skills (one, App, is a Frontier preview), an image-generation skill, and whatever plugin skills your admin allows — no shell, no local filesystem, no arbitrary code execution. A prompt that requires a tool the product doesn’t have will either be refused, worked around with a script, or redirected to a native skill. That rewiring changes the output entirely.
Claude.ai injects the current date and not much else — it doesn’t know who you work for. Claude Code injects cwd, OS, git branch, platform, auto-memory paths. Copilot Cowork grounds every task in your Microsoft 365 data through Microsoft Graph and Work IQ, and adds any custom instructions you saved. In practice it behaves as if it knows your name, title, manager and time zone before you type; Microsoft doesn’t publish exactly what it injects. Same message, four very different effective context windows.
In Claude.ai and Claude Code you pick the model (Opus, Sonnet, Haiku). In Copilot Cowork the picker defaults to Auto, which chooses among the models your admin allows — Anthropic Claude, OpenAI GPT and xAI Grok, plus Microsoft-hosted models. You can pin a specific model instead, and each response carries a model badge that shows which model produced it.
Claude.ai runs Anthropic’s usage policy. Claude Code adds code-safety (don’t commit secrets, confirm destructive shell commands). Copilot Cowork stacks a Microsoft guardrail layer on top: no deleting files or folders in OneDrive or SharePoint (it can delete email when you ask it to manage your inbox), per-action approval gates with risk indicators, no encrypted-file reads, no local filesystem, ACL inheritance, Purview audit, and Microsoft’s responsible AI rules for consequential decisions such as employment, which claude.ai doesn’t share in the same form. Custom skills that rank people, for example, fail Microsoft’s safety scan unless they include guardrails. Expect Cowork to be the most conservative of the four on people decisions.
LLM sampling isn’t fully deterministic, even at low temperature. Each product picks its own default, and none publish it. Empirically Claude Code runs lower temperature (more consistent code), Cowork variants prioritize tool-call precision, and Claude.ai runs with enough variation that two retries on the same prompt aren’t identical.
Stack mechanisms 1 through 6 together and “the same prompt” reaches four very different runtime assemblies. Saying “Claude said X” without naming the product is incomplete. The product is the whole ballgame.
Same 17 words. Four radically different deliverables.
| Product | What you actually get | What you have to do next | Time to value |
|---|---|---|---|
| Claude.ai | A complete .py file in an Artifact. Uses Microsoft Graph SDK or imaplib. Placeholder auth — tenant_id, client_id, client_secret as env vars. TODO comments where you configure OAuth. |
Register an OAuth app, install deps, run the script locally, iterate on auth errors. | Hours |
| Claude Code | Claude Code writes main.py + requirements.txt + .env.example to disk, installs deps via Bash, prompts you once for an access token (via az login or device-code flow), then runs python main.py and prints the summary to your terminal. A working script on disk plus a live result. |
Paste a token once. Review output. | Minutes |
| Claude Cowork desktop | Proposes a plan: “(1) connect via Gmail/Outlook connector, (2) filter today’s unread, (3) produce inbox-summary-2026-04-22.docx in your folder.” Waits for approval. Executes. No Python involved — the connector path delivers the intent faster than a script would. |
Approve the plan. Read the doc. | Seconds |
| Copilot Cowork | Doesn’t write the script at all. Uses the Email skill directly — reads your inbox via Microsoft Graph (already authenticated as you), filters unread from this morning, produces the summary in chat or a Word doc in OneDrive. If you insist on a standalone script, it will likely redirect: “I can do this directly — would you like me to, or do you specifically need a standalone program?” | Read the summary. | Seconds |
1. Don’t generalize benchmarks. A prompt that shines in Claude.ai may flop in Copilot Cowork because the Email skill short-circuits the reasoning path you intended.
2. Match the tool to the task. Tenant data → Copilot Cowork. Local code and terminals → Claude Code. Creative/reasoning with no specific environment → Claude Chat. Local-but-not-tenant knowledge work → Claude Cowork desktop.
3. Read the system prompt where you can. Anthropic publishes claude.ai’s at platform.claude.com/docs/en/release-notes/system-prompts. Microsoft does not publish Copilot Cowork’s. That asymmetry is itself a signal.
Sources: Anthropic — System Prompts; Anthropic — Modifying system prompts; Anthropic — Prompt caching; Anthropic Messages API; Microsoft Learn — Copilot Cowork common questions (Nov 3, 2026); Microsoft Learn — Choose a model for Copilot Cowork (updated Nov 3, 2026); Microsoft Tech Community — Opus 4.7, Apr 16 2026; GeekWire — Mollick on silent downshifts, Mar 9 2026.
“Copilot writes code today, so does that mean Cowork is a coding tool?” is the single most common question from developers evaluating the product. The short answer is no, and Microsoft doesn’t claim it is. The long answer has useful nuance.
Cowork is not a coding product. It has no terminal, no git integration and no local filesystem. It can read code files, bundle scripts inside a skill and build small no-code apps (the App skill, in Frontier), but Microsoft put coding in a sibling tab, Copilot Code (Frontier preview).
| Capability | Status | Evidence |
|---|---|---|
| Reads code files you attach with syntax highlighting | Yes | Supports .py .js .ts .java .c .cpp .go .rb .rs, .ipynb, and the full config-file family. Source: Microsoft Learn — Use Copilot Cowork (Nov 3, 2026). |
| Emits code snippets as chat text | Informally | Cowork’s models will produce code if asked, and Microsoft describes one of them, Grok 4.7, as strong on coding. But Microsoft has not certified Cowork for code, not listed supported languages, and given code no place in Cowork’s marketed skills. |
Writes a .py or .ps1 file into OneDrive |
Plausible, not documented | Cowork saves outputs to OneDrive/Cowork. No primary source confirms code-file generation as a first-class destination. |
Authors a Python-in-Excel =PY() cell |
No | Python in Excel cell authoring is a Copilot in Excel feature, not a Cowork feature. Source: Microsoft Tech Community. |
| Builds a Power Automate flow | No | Power Automate has its own natural-language Copilot. Cowork does not invoke it. Source: Copilot in Power Automate overview. |
| Generates Office Scripts (TypeScript) for Excel Web | No | Office Scripts has its own editor and Copilot integration; no Cowork surface documented. |
Authors VBA macros into .xlsm |
No | Not documented. Secondary press occasionally conflates “Microsoft 365 Copilot” with Cowork; the actual VBA-authoring path lives inside Copilot in Excel. |
| Edits a local git repository | No | No local file access, no shell. Use Claude Code or GitHub Copilot. |
| Runs scripts server-side | Undefined | One opaque Microsoft Learn sentence: “Some background operations, like script execution, run without displaying individual steps.” Microsoft has not elaborated. Treat as an internal implementation detail, not a user feature. Custom skills can bundle scripts, which Cowork scans but doesn’t run when it evaluates the skill. Source: Use Copilot Cowork (Nov 3, 2026). |
| Tool | Primary audience | What it’s for |
|---|---|---|
| GitHub Copilot | Developers | IDE-embedded code completion, chat, agents, PR reviews. This is the dev tool. |
| Copilot in Excel | Analysts, business users | Authors formulas, Python cells, charts inside a workbook. |
| Copilot in Power Automate | Power users | Generates cloud flows from natural-language descriptions. |
| Copilot Studio | Makers, IT | Builds custom Copilot agents and has a Python code interpreter in a sandbox. |
| Copilot Code (Frontier) | Business builders, power users | The Code tab in Microsoft Copilot: builds apps, dashboards and scripts from a description, connects to GitHub, and bills in Copilot Credits. |
| Copilot Cowork | Knowledge workers | Agentic execution across Office + Graph. Not a code tool, by design. |
Same brand family, disjoint product surfaces. MVP Christian Buckley frames Cowork as “Claude Code for knowledge workers” — the analogy, not the substitute. The analogy lands because both are long-running, plan-and-execute agents; it misleads only if you read it as “Cowork replaces Claude Code.” It does not.
The honest fit for Cowork in a developer’s workflow is all the non-code work around a project. That’s where it genuinely subsidizes what Claude Code and GitHub Copilot already do.
Repo work on your laptop. Writing, testing, refactoring, running CI, generating migrations, reviewing PRs, spawning subagents for large refactors, scheduling Routines to run nightly code quality checks.
Sprint-review deck from the week’s commits. Weekly status to your skip. Stakeholder update email. Meeting prep for the architecture review. SharePoint write-ups of the design you already coded. Bug-triage digest from Teams and email. Scheduled Monday digest of last week’s releases.
This is a Cowork workflow a developer or engineering manager can run today, with no code written, that demonstrates the actual fit.
Every Monday at 8:00 AM, pull together my engineering team’s week-ahead brief: 1. READ last week’s releases by scanning my team’s Teams channel and the closed GitHub issues referenced in email notifications. 2. LIST open bugs assigned to my direct reports with priority labels from the last 14 days of email. 3. SUMMARIZE three blockers mentioned in my last 7 days of 1:1 meeting notes (saved in OneDrive at /1-1s). 4. DRAFT a short Teams post for my #eng-weekly channel with the top three priorities for this week. Show me a preview before posting; don’t send. 5. SAVE the full brief as /Reports/Weekly/eng-brief-YYYY-MM-DD.docx. Constraints: - Never include anything from private 1:1 meetings by name. - Use past tense for last week, future tense for this week. - If you can’t find data for a section, say so — don’t invent.
What makes this a good Cowork demo: zero lines of code, four Graph data sources, one scheduled recurrence, one approval gate (the Teams post), one durable artifact (the Word doc). A developer gets back 30–60 minutes every Monday and stays in Claude Code for the actual engineering work.
Keep your paid Claude for the code. Use Cowork for the meetings, decks, status updates, and stakeholder communication that surround the code. The two don’t compete — they stack.
Sources: Microsoft Learn — Copilot Cowork common questions (Nov 3, 2026); Microsoft Learn — Use Copilot Cowork (Nov 3, 2026); Microsoft Learn — Copilot Code (Frontier) (Oct 1, 2026); buckleyPLANET — Christian Buckley (MVP), Apr 2026; GitHub — GitHub Copilot docs; Microsoft Learn — Copilot Studio code interpreter FAQ.
If you already pay for Claude Pro or Max — you’ve used Projects, you live in Artifacts, you run Claude Code daily, maybe you’ve tried Claude Design this week — this section is the straight talk on what to expect moving some of your workflow into Copilot Cowork.
Section 8 is the mechanics. The shorthand: the system prompt, tools, context injection, model routing, and safety stack are all different in Cowork. A Project you love in Claude.ai will produce different output in Cowork, and not necessarily better or worse — just different-shaped. Plan to re-tune, not copy-paste.
| Gain | Why it matters |
|---|---|
| Tenant grounding via Microsoft Graph | Cowork already knows your calendar, email, direct reports, SharePoint files, and Teams activity. No connectors, no OAuth dance, no copy-paste. Claude Cowork reaches Microsoft 365 data only through a connector you set up, and none of that activity lands in your Purview audit or retention. |
| ACL inheritance | Every read and write runs with your M365 permissions. This is not a feature Claude has an equivalent for — it’s an architectural property of Cowork living inside the tenant. |
| Purview audit trail | Cowork prompts, responses, scheduled runs, browser tasks and created files are recorded in the unified audit log and searchable in Purview Audit and eDiscovery. Claude’s consumer plans have nothing comparable; Claude Enterprise keeps its trail in a separate Compliance API, a second audit system your compliance team has to pull, retain and search. |
| Native Office actions under the approval gate | Cowork sends real emails, posts real Teams messages, creates real calendar events — with a preview dialog. Claude Code can do this only through MCP connectors you wire yourself; Claude.ai can’t. |
| Scheduled Prompts as a native surface | Claude Code has scheduled tasks (formerly Routines; research preview) that run on Anthropic’s cloud against your repositories and connectors. Cowork’s scheduled prompts (up to 25 per user) and event-driven tasks run across email, calendar, Teams, and SharePoint without leaving the tenant. |
| Durable Task state | The My tasks view and the Automations page survive disconnects, laptop closes, and days off. Claude.ai conversations don’t, and local Claude Code sessions rely on your machine being on unless you use its cloud-run scheduled tasks. |
| Loss | Why you’ll notice |
|---|---|
| Artifacts (partly) | Cowork’s App skill (Frontier preview) builds small interactive apps you can publish and share inside your organization, and it previews HTML files, but there is no general-purpose side-panel sandbox like Claude.ai’s Artifacts. |
| Model choice by default | Smaller than it was. Cowork defaults to Auto, but you can pin any model your admin allows, and a badge shows which model answered. The lineup and its timing are Microsoft’s, not Anthropic’s. |
| Anthropic’s release cadence | Anthropic still ships faster on the consumer surface. Since GA, Microsoft has shipped Cowork changes roughly monthly: model choice with a visible badge, effort levels, event-driven tasks, plugins and the App skill. |
| Full computer use | Copilot Cowork can drive a Microsoft Edge tab on your device using your existing sign-ins (if your admin enables Cowork Browsing), but it does not control your desktop, files or other apps the way Claude’s computer-use preview does. |
| Shell and local filesystem | Obvious but worth naming. If your current Claude Code workflow depends on Bash and a repo, that workflow stays in Claude Code. |
| A dedicated mobile client | Cowork rides inside the Copilot mobile app (iOS/Android, since May 2026) rather than having its own app, and custom skills aren’t supported on mobile. Claude.ai has native mobile apps; Claude Code has an iOS companion. |
You don’t pick one. You split the workload along the tenant boundary.
Code. Local files. Side projects. Anything outside your work tenant. Artifacts and prototypes. Deep, open-ended reasoning sessions on Anthropic’s own model lineup. Claude Design for visuals. Claude Code scheduled tasks for developer automation.
Anything that reads or writes your tenant’s email, calendar, Teams, SharePoint, or OneDrive. Anything that needs the Purview audit trail. Scheduled recurring tasks that depend on Graph data. Meeting prep, customer briefings, stakeholder updates. SKILL.md encoding of your team’s playbooks.
Claude Ultra: $200/month, a personal subscription you pay for. Copilot Cowork needs a Microsoft Copilot license (included in E7 at $99, or the standalone Microsoft Copilot license at $30, or Copilot Business at $21 for up to 300 users) plus usage-based billing: every Cowork task is metered in Copilot Credits at $0.01 each, on top of the seat. Your employer pays both. These aren’t substitutes. For a hardcore coder the math usually favors keeping a paid Claude plan personally and using Cowork at work — because the employer pays the Copilot seat and the Cowork meter, and your Claude plan buys you Claude Code + Claude Cowork + Chat + Design for your own work.
SKILL.md files in OneDrive (Section 12), or upload an existing skill file on Cowork’s Customize page. System prompts don’t transfer; the intent does.“[Anthropic’s Cowork] was built in a couple of weeks using Claude Code and is being updated and evolving quickly. [Microsoft] has a tendency to launch a leading product and then let it sit for awhile. I’m curious about whether their pacing will change.”
— Ethan Mollick (Wharton), reacting to the Cowork launch. Reported by GeekWire, Mar 9 2026.
Mollick asked this when Cowork launched in March. Since GA, Cowork has shipped model choice with a visible model badge, effort levels, event-driven tasks, plugins and the App skill. Anthropic still ships faster on the consumer surface, and Microsoft now ships roughly monthly on the enterprise one. For a heavy Claude user, that’s another argument for the “both” pattern: holding both keeps you on the frontier of each.
These are all documented symptoms of “context rot” — the measured quality decay of long-running conversations. When you see two or more, stop iterating. Summarize. Open a new Task.
Before you hit New Task, paste this into the current Task:
Write a handoff brief for the next Cowork Task: GOAL: one sentence — what I’m trying to accomplish DECISIONS MADE SO FAR: bullet list of what we’ve locked in CURRENT DRAFT / STATE: the latest good version (link to OneDrive file if large) CONSTRAINTS: audience, tone, length, format, deadline OPEN QUESTIONS: what we still need to decide NEXT STEP: one specific thing to do next Return it as plain markdown so I can paste it into a new Task.
Open a new Task. Paste the brief as the first message. You now have a fresh, clean context with all the signal and none of the noise. If you want Cowork to read the old task’s decisions too, type / in the new task, choose Copilot, and select the old task; the reference adds context but doesn’t reopen the old task.
(a) It puts the stable decisions at the start of the new context, where primacy bias helps you. (b) It discards all the abandoned drafts the model was quietly using as sycophantic signal about “what the user wants.” (c) It resets the 39% multi-turn degradation curve back to turn one.
SKILL.md — Your Durable MemoryA SKILL.md is a small markdown file with YAML frontmatter that lives in OneDrive at /Documents/Cowork/skills/<skill-name>/SKILL.md. Cowork auto-discovers skills at the start of every session and applies them when relevant. You can have up to 50 custom skills; each SKILL.md can be up to 1 MB and carry up to 20 companion files (10 MB total). You can create one three ways: on the Customize page (Skills → Add), by asking Cowork in chat, or by adding the file to OneDrive yourself. Custom skills aren’t supported on mobile.
For standing tone and formatting rules that apply to every task, Cowork also has custom instructions on the Customize page (up to 20 KB). Use those for how you like things done, and skills for task-specific playbooks.
Think of it as a durable, cheap context layer. Unlike instructions in chat, skills are re-loaded from disk after every compaction and never lost to context rot.
--- name: weekly-status description: Produces my weekly status update in the exact format my team expects. Use when I ask for my "weekly status", "weekly update" or "weekly report". --- # Weekly Status Report Skill ## What this skill does When I say “make my weekly status,” produce a Word document at `/Reports/Weekly/YYYY-MM-DD-status.docx` following the rules below. ## Data sources (in priority order) 1. My calendar for the last 7 days (accepted meetings only) 2. Email I sent or replied to in the last 7 days (skip noise/newsletters) 3. Teams messages in channels I own 4. My /Projects folder in OneDrive for anything updated this week ## Required sections (in this order) 1. **Wins** — 3 bullets max, concrete outcomes only 2. **In Flight** — what I’m actively working on, with status 3. **Blockers** — what’s stuck and who I need from 4. **Next Week** — top 3 priorities 5. **Metrics** — any numeric KPIs I touched this week ## Tone and formatting rules - Crisp, professional, no marketing language - Numbers and dates, not vibes - Never use “synergy,” “leverage,” or “circle back” - Past tense for Wins, present tense for In Flight, future tense for Next Week ## Never do - Don’t invent metrics you can’t source from a file or message - Don’t include anything from private 1:1 meetings - Don’t send it — just save the file and tell me where it is
Cowork decides when to use a skill from its description, so put the phrases that should trigger it there, and keep the description short: Microsoft warns that a description with no trigger phrases never fires, and one over the character limit never loads.
Microsoft does not certify skills you or colleagues write. Cowork does run an automatic check when a skill is created, updated or uploaded — a 0–100 quality score plus prompt-injection and safety scans — but a passing score is not a review. If someone shares a skill with you, read it before you add it. A skill runs as instructions to the AI and can ask Cowork to send emails or post to Teams in your name — approval gates help but are not a substitute for reviewing the skill itself.
Good candidates for your first three skills: weekly-status, customer-brief, deal-review. Once those exist, you stop re-explaining structure every time — and Cowork starts feeling like a team member who knows how you work.
Scheduled prompts are Cowork’s answer to Power Automate for any recurring job that can be described in a paragraph. You say it in plain English; Cowork parses the schedule, registers the task, and runs it forever (or until you pause it).
Microsoft does not document a scheduled run carrying memory of the last run, so write the prompt as if Cowork has never seen it before: include the instruction, the data source, the output location, and any constraints, every time. Don’t say “continue from yesterday” — say “compare to the last 7 days of email and meetings.” Standing preferences belong in custom instructions or a skill; shared background for a body of work belongs in a Project.
Because every run produces an artifact, you’ll want to compare runs week-over-week. Ask for:
Then week 12 is meaningfully comparable to week 1 at a glance. Narrative scheduled outputs are hard to scan; structured scheduled outputs are a dashboard.
The Automations page in the left navigation shows every schedule. Manage schedules is where you edit, pause, resume or delete one; Runs shows each past and upcoming run. You can also manage a schedule from the Schedule section of the side panel inside its session. Each user can have up to 25 scheduled prompts; fewer, higher-quality prompts still beat a cluttered list.
Event-driven tasks sit on the same page. Instead of a time, they fire when something happens: a matching email arrives, or a Teams channel or chat message (optionally only when you’re @mentioned). Cowork proposes one in a Set up trigger? card with When, Run in (a new conversation each time, or the current one) and What it does. They default to draft-and-approve, and Microsoft rate-limits how often they can fire.
Deep Research is one of Cowork’s built-in skills: it researches across multiple sources and compiles a full analysis. Microsoft doesn’t document how it manages context internally, but in practice it behaves like a Claude Code subagent — so treat it as one: give it a self-contained brief and ask for the conclusion, not the transcript.
This matters more than it sounds. Treated that way, the intermediate web fetches, document reads, note-taking, and verification passes stay in the Deep Research run, and the parent Task works from the conclusion.
The single most useful question to ask before delegating: “Do I need this tool output again — or just the conclusion?”
Assume the sub-agent doesn’t see the parent conversation, so your Deep Research prompt has to be self-contained. File paths, constraints, prior decisions, tone rules, output destination — all go into the delegation prompt itself.
Use Deep Research to produce a 2-page executive brief on [topic]. Sources: - My /Research folder in OneDrive - /Clients/Acme folder in SharePoint (the last 18 months only) - Public web, restricted to sources dated in the last 9 months Constraints: - Cite every factual claim with a URL - Separate CONFIRMED from UNCERTAIN with a label - Do not speculate beyond the sources Deliverable: save as /Research/acme-competitive-brief.docx Do not email or post it anywhere. Just save the file.
Cowork will never silently send an email, post to Teams, create a calendar event, or modify a file without showing you a preview first. That’s the approval gate, and it’s the reason Cowork is safe to deploy to large populations. The exceptions are the ones you grant: a “don’t ask again” choice in the current session, an Always allow on a file edit, or actions you pre-authorize when you set up a scheduled or event-driven task. Those standing grants are exactly what to review.
“Don’t ask again” is not a safety downgrade — it’s a context saver. Every re-approval adds turns to the conversation, which inflates tokens, which increases the chance of context rot. Batch similar approvals and move on.
An honest list of today’s limits, all confirmed by Microsoft Learn or independent reporting. Know these going in and you’ll avoid the “why won’t it…” frustration.
No local file access. Cowork can’t browse or edit files on your laptop. You can upload a file into a session, but anything it creates or edits lives in OneDrive or SharePoint.
No deleting files. Cowork cannot delete files or folders in OneDrive or SharePoint. If you want something gone, you delete it yourself. This is intentional, for safety. (It can delete email when you ask it to manage your inbox.)
No encrypted file reads, even if you have the rights.
Attached files must be under 200 MB each.
No dedicated Cowork app. It runs in the browser, in Outlook and Teams, in the Copilot desktop app for Windows and macOS, and (since May 2026) in the Copilot mobile app on iOS/Android — there's no standalone Cowork mobile client.
Custom skills are not certified by Microsoft. Cowork runs an automatic quality and safety check when you create or upload one, but a passing score is not a review. Review any skill you didn’t author personally.
Since June 16, 2026 Cowork bills separately from the Copilot license, metered in Copilot Credits at $0.01 each (Microsoft list price). Microsoft’s planning estimates put a light task at 100–300 credits, a medium task at 300–700, and a heavy task above 700. At $0.01 a credit that is roughly $1–$3, $3–$7, and more than $7 (our arithmetic), with no published ceiling. Cost moves with the model, the runtime, how much organizational context the task draws on, and the tools it calls. The Frontier grace period expired July 1, 2026.
Cowork shares one tenant-wide credit pool with Copilot Studio agents, advanced SharePoint and OneDrive work, Copilot Code, the Work IQ API and Teams Phone Agent. Spending policies pick up new services automatically unless an admin turns off Auto-apply new services. Admins get spending limits, usage alerts, user-level controls, reporting, and prepaid plans — and as of August 2026, Copilot Credits visibility and overage handling in the Microsoft 365 admin center. For a managed practice this is the opening: an unbounded consumption line on a customer’s invoice is a governance engagement, not a license renewal.
Copilot Business through CSP: billing on by default from early 2027. Microsoft says usage-based billing will be on by default for new Microsoft 365 Copilot Business subscriptions bought through CSP, with rollout planned to begin during its FY27 Q3 (January–March 2027), moved from December 1, 2026; no exact day has been announced. Pay-as-you-go is the default billing configuration, which Microsoft says is there to help customers reach usage-based experiences, including Copilot Cowork. The default spending limit is 4,000 Copilot Credits per user per month (about $40 at the $0.01 list rate, our arithmetic). A new purchase also turns it on for the tenant’s existing Copilot Business licenses, and the change applies in all markets. For SMB customers on Copilot Business, that means the Cowork meter will already be running when they first try it.
Condensed from Claude Code best practices, named practitioners, and the Cowork docs. Use these as a checklist when you want to improve a workflow.
| # | Tactic | Why it works |
|---|---|---|
| T1 | New objective → new Task | Starts a fresh context; no stale prefix to reprocess |
| T2 | Watch for the six signs (Section 11) | Objective signals of context rot — stop iterating |
| T3 | Hand off with a written summary template | Primacy bias works for you on turn 1 of a fresh Task |
| T4 | Correct via a new Task, not another turn | Every correction adds two more turns to the history |
| T5 | Act at ~75% context, not at 95% | The summarizer is at its least smart when under pressure |
| T6 | Prefer a hand-written brief over relying on auto-compact | Two-minute investment; you choose what survives |
| # | Tactic | Why it works |
|---|---|---|
| T7 | Put stable rules in SKILL.md, not chat | Re-loaded every session; never lost to compaction |
| T8 | Tier your skills (always / on-demand / never-loaded) | Skill sprawl inflates the context budget |
| T9 | Don’t enable connectors you won’t use this session | Deferred tool definitions routinely eat 40%+ of the budget |
| # | Tactic | Why it works |
|---|---|---|
| T10 | Structure every prompt as stable-prefix + dynamic-tail | Automatic caching hits the 90%-discount path |
| T11 | Mind the cache-prefix minimums (4k tokens on Opus) | Prefixes under the minimum are never cached |
| T12 | Don’t toggle thinking/reasoning modes mid-conversation | Invalidates the message cache and re-prices everything |
| # | Tactic | Why it works |
|---|---|---|
| T13 | Use Deep Research when you need a conclusion, not a transcript | Intermediate tool noise stays out of your parent Task |
| T14 | Include everything the sub-agent needs in the prompt string | Assume the sub-agent can’t see the parent conversation |
| # | Tactic | Why it works |
|---|---|---|
| T15 | Batch approvals with “Don’t ask again” | Fewer approval turns = fewer tokens = more quality |
| T16 | Ask Cowork to plan first, act after you confirm | Prevents wasted context on wrong approaches |
| # | Tactic | Why it works |
|---|---|---|
| T17 | Put heavy state in OneDrive files, attach by reference | The file is a stable prefix; chat messages are a growing tail |
| T18 | Attach files at the start of the Task, not drip-fed | Keeps attachments in the cacheable prefix region |
| T19 | Break one long job into multiple Cowork Tasks | Research → draft → review, each with fresh context |
| T20 | Kill and restart without guilt | The cost of starting fresh is small; the cost of a 150k-token session is large |
| # | Tactic | Why it works |
|---|---|---|
| T21 | Write each scheduled prompt to stand on its own | Microsoft doesn’t document a run remembering the last one — don’t write “continue from yesterday” |
| T22 | Structure scheduled output for diff-ability, not narrative | Fixed sections + fixed length = a dashboard over time |
Symptom → likely cause → fix. Print this page and tape it to your monitor.
| Symptom you observe | What’s actually happening | Fix |
|---|---|---|
| Responses are getting slower | Context length has grown; per-turn attention work is quadratic | Summary-and-restart in a new Task (Section 11 template) |
| Forgot the tone/format you set earlier | Rule was given in chat; auto-compact dropped it | Move the rule into a SKILL.md (Section 12) and restart |
| Keeps re-reading the same file | Earlier read fell out of the compacted summary | Attach the file fresh at the start of a new Task |
| Hallucinated a file path, name, or link | Late-session context rot; primacy/recency bias breaking mid-context recall | Restart; ask it to verify every path/name/link against Graph before citing |
| Agreed with your pushback when it was actually right | Sycophancy — documented behavior in RLHF-trained models | In the restart, ask for reasoning before a verdict; resist saying “try again” |
| Task keeps asking clarifying questions | The brief was underspecified or the sub-agent didn’t get the full context | Rewrite the prompt with the goal, data sources, constraints, and output destination — see Section 14 template |
| Approval dialog fired 11 times in a row | You didn’t use “Don’t ask again” | On approval #1, open More options and pick the narrowest scope that fits (one recipient or one domain), or use Approve All when several are queued |
| Scheduled prompt stopped producing useful output | Data sources drifted, or the prompt assumed state from prior runs | Edit the scheduled prompt; make it self-contained; add fixed section structure (Section 13) |
| Cowork said it couldn’t access a file you clearly own | File is encrypted, or sits in a SharePoint library with ACLs that don’t cascade to Cowork | Move to an un-encrypted location; verify the ACL; re-try |
/, choose Copilot, and reference the old taskCowork has no memory between turns. Every message you press Enter on re-sends the whole conversation. Longer thread = more cost AND worse output. Start fresh often.
Every claim in this guide traces to one of the sources below. Grouped by evidence tier.
New objective → new Task.
Stable rules → SKILL.md.
Heavy data → OneDrive file, attached once.
Intermediate reasoning → Deep Research.
Confidence drops → summary-and-restart.
Approvals → batch with “Don’t ask again.”
Prepared by Ken Lince — Sr. Director, Cloud Engineering, TD SYNNEX · ken.lince@tdsynnex.com
Companion to the Give Me an Hour Today: Copilot Cowork workshop. Re-verify model IDs, pricing, and product gates before re-delivering — this space moves quickly.