1. What Is Copilot Cowork?

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 is explicitly powered by Anthropic’s Claude models as a subprocessor.

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.

What makes it distinct from Copilot Chat

• Execution horizon. Chat runs in seconds. Cowork tasks can run for minutes or hours, survive a closed laptop, and auto-reconnect to pick up where they left off.
• Persistent task state. A Tasks view (List / Board / Scheduled) shows what Cowork has done, what’s in progress, and what’s waiting on you with a status of Needs User Input.
• Write actions with approval gates. Every send-email, post-to-Teams, create-meeting, or edit-file action presents a preview before executing. “Don’t ask again” collapses repeat approvals inside a single conversation.
• Custom skills. Drop SKILL.md files into OneDrive to codify your team’s playbooks. Cowork auto-discovers them at the start of each conversation.
• Scheduled recurrence. Natural-language scheduled prompts replace Power Automate for simple recurring work: “Every morning at 9 AM send me a briefing of overnight email priorities and my first three meetings.”

2. The Big Idea: Cowork Delegates, Chat Answers

The single most important mindset shift for a new Cowork user is to stop thinking of it as a chatbot.

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.

3. How It Works — The Mechanic That Changes Everything

If you learn only one thing from this guide, make it this. It explains 90% of the “my AI got dumb” experiences users report.

“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)

Four consequences that follow from that one fact

1. Cost grows super-linearly with length. Every new message re-prices every previous message.
2. Latency tracks cost. The model re-processes the whole prefix each call. Prompt caching cuts the re-processing bill by 90% on cached prefixes, but the tokens still ride along.
3. Quality degrades — “context rot.” Anthropic’s own term: “model performance degrades as context grows because attention gets spread across more tokens, and older, irrelevant content starts to distract from the current task.”
4. Longer threads are worse on every axis. Cost, speed, and output quality — despite the intuition that “keeping everything in one chat helps the agent remember.”

The cost curve, made concrete

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):

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).

4. The Models Under the Hood

Microsoft and Anthropic have both confirmed on the record that Anthropic Claude models power Cowork and the broader Microsoft 365 Copilot experience. You don’t have to pick a model — Microsoft routes to the right one for the task — but it helps to know what’s running.

Mollick’s question is unresolved. Microsoft has not published a model-routing telemetry view. Treat Cowork as “Claude-family powered, with Microsoft’s discretion to downshift.” If absolute model transparency matters for a use case (regulated drafting, legal review), document the output and the date and revalidate periodically.

5. The Power User Habit Loop

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.

6. Your First Week: A Starter Plan

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.

Day 1 — Your morning briefing

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.”

Check Tasks → Scheduled. You now have a durable recurring agent. This alone is worth the license.

Day 2 — Meeting prep

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.”

Day 3 — Calendar cleanup

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.”

Day 4 — Your first SKILL.md

Pick 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.

Day 5 — Deep Research pass

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.”

7. Cowork vs the Claude Family — What You Actually Get

The comparison most people have in their head — “Cowork vs Claude.ai” — is already out of date. As of April 2026, Anthropic ships five distinct products bundled into one desktop install, and Microsoft 365 Copilot Cowork is a sixth, separately licensed surface. Before you can decide which one to use, you have to know they all exist.

The six-way landscape

Sources: Anthropic — Download Claude; Anthropic — Claude Cowork product page; TechCrunch — Anthropic launches Claude Design, Apr 17 2026; 9to5Mac — Claude Code Routines, Apr 14 2026; Anthropic — Claude for Excel; Microsoft Learn — Cowork FAQ.

What changed in the last 90 days (and why it matters)

• Feb 10, 2026 — Claude Cowork hit Windows GA. Anthropic now has a mature non-coding desktop agent that competes directly with Copilot Cowork on the local-file side.
• March 2026 — 1M-token context went GA on Opus 4.6 and Sonnet 4.6 in Claude Code, no beta header, no long-context premium.
• April 14, 2026 — Claude Code desktop was redesigned for parallel sessions, integrated terminal, HTML/PDF preview, and shipped Routines — scheduled cloud-run automations (Pro 5/day, Max 15/day, Team/Enterprise 25/day). This is the Anthropic equivalent of Cowork’s Scheduled Prompts, aimed at developers.
• April 16, 2026 — Claude Opus 4.7 landed in Copilot Cowork’s model selector. Microsoft’s framing: Opus 4.7 is tuned to “follow instructions more closely and route requests to the right capabilities and Work IQ data.”
• April 17, 2026 — Claude Design launched as a research preview. Opus 4.7–powered. Five days old at the time of writing.

Source: Microsoft Tech Community — Opus 4.7 in M365 Copilot, Apr 16 2026.

The critical capability comparison

Pick the right tool — A through E

8. Same Prompt, Different Answer — Why

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.

The seven mechanisms of divergence

A worked example: “Write me a Python script that reads my inbox and summarizes this morning’s unread emails.”

Same 17 words. Four radically different deliverables.

Sources: Anthropic — System Prompts; Anthropic — Modifying system prompts; Anthropic — Prompt caching; Anthropic Messages API (temperature); Microsoft Learn — Cowork FAQ; Microsoft Tech Community — Opus 4.7, Apr 16 2026; GeekWire — Mollick on silent downshifts, Mar 9 2026.

9. Cowork and Code — An Honest Look

“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.

What Cowork actually does with code

The Microsoft dev-tool landscape — where Cowork sits

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.

Can Cowork help a developer at all? Yes — just not by writing code.

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.

Conceptual demo: a developer’s week, split across tools

The “engineering manager’s Monday morning” demo script

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.

Sources: Microsoft Learn — Cowork FAQ; Microsoft Learn — Use Cowork; buckleyPLANET — Christian Buckley (MVP), Apr 2026; GitHub — GitHub Copilot docs; Microsoft Learn — Copilot Studio code interpreter FAQ.

10. For the Existing Claude Power User

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.

Portability is low. Don’t expect your prompts to transfer.

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.

What you gain by moving specific workflows into Cowork

What you lose — be honest about it

The “both” pattern — the right answer for most hardcore Claude users

You don’t pick one. You split the workload along the tenant boundary.

Migration checklist for a Claude power user’s first Cowork week

1. Don’t port your Projects. Re-express the three Projects you use most as SKILL.md files in OneDrive (Section 12). System prompts don’t transfer; the intent does.
2. Identify your top three “only in the tenant” use cases. Meeting prep, weekly status from Graph data, customer briefings pulling from CRM + email — these are Cowork’s native advantage. Start there.
3. Replicate one Claude Code Routine as a Cowork Scheduled Prompt. See which UX you prefer for recurring work. Routines are developer-oriented; Scheduled Prompts are business-oriented.
4. Accept that the output will feel different. Different system prompt, different context, different refusal boundaries. You’ll re-tune your prompts. Budget a couple of hours.
5. Don’t give up your Claude Code subscription. Cowork will not replace it. If anything, owning both makes you faster in both.

Mollick’s concern is real and unresolved. For a heavy Claude user, that’s another argument for the “both” pattern: Anthropic ships fast, Microsoft ships enterprise — and until the pacing question resolves, holding both keeps you on the frontier of each.

11. Six Signs You Should Restart

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.

1. It repeats itself. Same suggestions, same phrasing, across different turns.
2. It forgets a constraint you set earlier. Classic example: you said “formal tone” on turn 3; by turn 18 it’s drafting like LinkedIn influencer copy.
3. It re-reads files it already read. You’ll see it say “let me check [doc]” again after you watched it read the same doc five minutes ago.
4. It hallucinates a file path, a name, or a link. Confidently wrong citations are a late-session tell.
5. It contradicts a decision from earlier in the session. The summary at turn 20 quietly disagrees with the decision you both made at turn 5.
6. The responses feel sluggish. Per-turn latency scales with conversation length; a slow turn is a crowded turn.

The summary-and-restart template

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.

12. SKILL.md — Your Durable Memory

A 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 conversation and applies them when relevant.

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.

A starter skill: weekly status report

---
name: weekly-status
description: Produces my weekly status update in the exact format my team expects.
triggers:
  - "weekly status"
  - "weekly update"
  - "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

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.

13. Scheduled Prompts — Recurring Work on Autopilot

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).

What they’re great for

• Daily morning briefings (see Day 1 of your starter plan)
• Weekly reports that pull from predictable data sources
• Monday “what’s the state of my pipeline” digests
• End-of-month customer health summaries
• Reminders that need data (“Fridays at 4 PM, remind me of any unsent follow-ups from the week, with drafts”)

The cardinal rule: each run is stateless

How to make the output diff-able

Because every run produces an artifact, you’ll want to compare runs week-over-week. Ask for:

• A fixed section order
• A fixed bullet count per section
• Word limits
• A single headline metric at the top

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.

Editing and pausing

Tasks → Scheduled shows everything. You can edit, pause, resume, or delete any scheduled prompt. Microsoft does not publish a maximum number of concurrent scheduled prompts per user, but a reasonable guideline: fewer, higher-quality prompts beat a cluttered list.

14. Deep Research — Your Built-In Sub-Agent

Deep Research is one of Cowork’s 13 built-in skills and it is structurally identical to a Claude Code subagent: it runs in its own fresh context, consumes its own tool noise privately, and returns a final summary to the parent Task.

This matters more than it sounds. When you delegate something to Deep Research, the intermediate web fetches, document reads, note-taking, and verification passes never enter your main Task’s context. The parent Task gets only the conclusion.

Good jobs for Deep Research

• Company / competitive briefs grounded in web + SharePoint
• “Fact-check and cite this claim” passes
• “Summarize this folder of 12 PDFs into one 2-page memo”
• “Find every email from [person] mentioning [topic] in the last 6 months and synthesize”
• Verification passes before a deliverable goes out the door

Include everything the sub-agent needs in the prompt

Because the sub-agent doesn’t see the parent conversation, 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.

15. Approvals and Trust

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 approval dialog, in one picture

1. Cowork shows you exactly what it’s about to do: recipient, subject, body, channel, calendar change — whatever the action is.
2. You approve, edit, or reject.
3. A dropdown lets you say “don’t ask again for this conversation” — useful when Cowork is about to do 11 similar actions and you’ve already blessed the first.

Things you should always approve carefully

• Emails to customers or executives
• Calendar changes that affect other people
• Teams posts in channels with >20 members
• Any action that modifies a shared SharePoint file
• Anything invoking a custom skill you didn’t write yourself

Things where “Don’t ask again” is usually fine

• Drafting emails to yourself
• Saving files into your own OneDrive
• Bulk-labeling or categorizing your inbox
• Reading from SharePoint libraries (already gated by your ACLs)

16. What Cowork Can’t Do (Yet)

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.

Access and geography

• Frontier preview today. Broad availability is gated on M365 E7 ($99/user/month), GA May 1, 2026.
• Anthropic opt-in in EU / EFTA / UK. Your admin must enable the Anthropic subprocessor; it’s off by default.
• Unavailable in GCC, GCC High, DoD, and sovereign clouds.

Things Microsoft hasn’t documented

• No vendor-published or third-party benchmark exists for hallucination rate, task completion rate, or permission-escalation error rate in Cowork specifically.
• No documented ceiling on concurrent scheduled prompts per user (custom skills are capped at 20).
• How long-chat degradation manifests inside Cowork specifically (a problem well-documented in LLMs generally) hasn’t been written up by any practitioner. Treat it as a likely-but-unquantified risk — and apply the habit loop from Section 5.

17. The 22-Tactic Reference Card

Condensed from Claude Code best practices, named practitioners, and the Cowork docs. Use these as a checklist when you want to improve a workflow.

Context hygiene

Stable-context architecture

Caching-aware prompting

Sub-agent delegation

Approvals & tool discipline

Externalize state

Scheduled-prompt discipline

18. Troubleshooting — “It Got Weird” Field Guide

Symptom → likely cause → fix. Print this page and tape it to your monitor.

The universal reset, in order

1. Ask for a handoff brief (Section 11 template)
2. Open a new Task
3. Paste the brief as the first message
4. Attach any files the brief references
5. Proceed

19. Further Reading & Sources

Every claim in this guide traces to one of the sources below. Grouped by evidence tier.

Microsoft & Anthropic primary

1. Microsoft 365 Blog — Copilot Cowork: a new way of getting work done (Lamanna, Mar 9 2026)
2. Microsoft 365 Blog — Copilot Cowork now available in Frontier (Spataro, Mar 30 2026)
3. Microsoft Learn — Cowork common questions (Frontier) FAQ
4. Microsoft Learn — Manage Scheduled Prompts
5. Microsoft 365 Blog — Expanding model choice in Microsoft 365 Copilot (Lamanna, Sep 24 2025)
6. Microsoft Tech Community — Claude Opus 4.7 in M365 Copilot (Apr 16 2026)
7. Anthropic — Claude now available in Microsoft 365 Copilot (Sep 24 2025)
8. Anthropic — Using Claude Code: session management and 1M context (Apr 15 2026)
9. Anthropic — Using the Messages API (statelessness)
10. Anthropic — Prompt caching
11. Anthropic — Claude Code subagents
12. Anthropic — System Prompts release notes
13. Anthropic — Modifying system prompts (Claude Code Agent SDK)
14. Anthropic — Messages API (temperature defaults)
15. Anthropic — Download Claude (desktop bundle)
16. Anthropic — Claude Cowork product page
17. Anthropic — Cowork: Claude Code power for knowledge work
18. Anthropic — Claude for Excel
19. Microsoft Learn — Use Cowork
20. Microsoft Learn — Microsoft 365 Copilot architecture

Claude product family & April 2026 launches

22. TechCrunch — Anthropic launches Claude Design (Apr 17 2026)
23. 9to5Mac — Claude Code Routines (Apr 14 2026)
24. VentureBeat — Claude Cowork lands on Windows (Feb 11 2026)
25. VentureBeat — Redesigned Claude Code desktop & Routines (Apr 15 2026)
26. GitHub — GitHub Copilot docs
27. Microsoft Learn — Copilot Studio code interpreter FAQ
28. Microsoft Learn — Copilot in Power Automate overview
29. Microsoft Tech Community — Copilot support for Python in Excel

Peer-reviewed research (context rot, multi-turn degradation)

30. Vaswani et al., “Attention Is All You Need,” NeurIPS 2017
31. Dao et al., “FlashAttention,” NeurIPS 2022
32. Liu et al., “Lost in the Middle,” TACL 2024
33. Modarressi et al., “NoLiMa: Long-Context Evaluation Beyond Literal Matching,” ICML 2025
34. Laban et al., “LLMs Get Lost In Multi-Turn Conversation,” 2025 (Microsoft Research + Salesforce)
35. Sharma et al., “Towards Understanding Sycophancy in Language Models,” ICLR 2024 (Anthropic)
36. Hong et al., “Context Rot,” Chroma Research 2025

Named practitioners

37. GeekWire — Microsoft’s new Copilot Cowork integrates Anthropic’s Claude (Bishop, Mar 9 2026)
38. IDM Magazine — Claude now inside your M365 tenant: mind the data-residency gap (Mar 26 2026)
39. Pascal Brunner-Nikolla (MVP) — Copilot Cowork: Your Day 107
40. Ami Diamond (MVP) — Cowork: 2 use cases for daily scheduled tasks
41. Christian Buckley (MVP) — 5 things you need to know about Copilot Cowork
42. Forbes — Janakiram MSV on the digital coworker
43. SitePoint — Context Management for Long-Running Claude Code Sessions (Mickiewicz, Mar 20 2026)
44. Morph LLM — Claude Code Compact (Mar 13 2026)
45. Medium: Mubashar — Clear vs Compact (Feb 23 2026)
46. bruniaux.com — M04 Compact vs Clear cheat sheet
47. The Science Talk — Claude Code Context Window Explained (Apr 15 2026)
48. Jpranav (Medium) — Stop Wasting Tokens (Nov 2025)
49. CostLens.dev — Anthropic’s Prompt Caching (Nov 3 2025)
50. Simon Willison — LLMs are stateless functions
51. James Howard — Context Degradation Syndrome
52. Cameron Fuller (Quisitive) — Scheduling Copilot Prompts: The Good, the Bad, the Ugly

Glossary

• Stateless API — The backend has no memory; every turn re-sends the full conversation.
• Context rot — Quality decay as the conversation grows. Anthropic’s own term.
• Prompt caching — Server-side reuse of a request prefix; ~90% read discount; 5-minute default TTL.
• Auto-compact — Summarizes the conversation in place when context fills; lossy; fires around 75-80%.
• Sub-agent (in Cowork: Deep Research) — A fresh-context child agent that returns only its final report.
• SKILL.md — A markdown file in OneDrive with YAML frontmatter that Cowork auto-discovers per session; the durable, cheap context layer.
• Task — Cowork’s unit of work: persistent, pausable, re-connectable, auditable, and ideally short-lived per objective.