The Microsoft Copilot Execution Loop: A 4-Step Work System

Why single prompts fail inside Copilot

A single-turn prompt fails in Copilot for a specific reason: when you do not name your sources, Copilot picks them for you. It searches what it can reach, decides which documents look relevant, and writes from that guess. Sometimes the guess is right. Often it pulls a superseded draft from a SharePoint folder nobody has opened since March.

The output has a tell. Vague, balanced, faintly corporate — the voice of something summarising many documents shallowly rather than one document precisely.

The second version is barely longer. It is dramatically more reliable, because it removes the one decision Copilot is worst at making.

Most professionals respond to a weak first answer by writing a longer prompt — more adjectives, more instructions, more please-be-specific. That almost never helps, because the problem was never the wording. It was that Copilot was answering from a document you never chose. The Microsoft Copilot execution loop puts the choosing back where it belongs, which is with you, before anything is generated.

What Copilot already knows

Copilot reaches your work through the Microsoft 365 layer Microsoft calls Work IQ — the connective tissue between the language model and your emails, meetings, chats and documents. In Copilot Chat there is a Work IQ button at the top right of the page. Turn it off and Copilot can still reference files, but not people, meetings or email threads.

This matters more than any prompt-writing tip. The same instruction produces different output depending on whether that button is on and whether you hold a paid licence. If you are new to the tool, our guide to what Microsoft Copilot actually is covers the landscape before you start looping.

The Microsoft Copilot execution loop, defined

The Microsoft Copilot execution loop is a four-step working method — Point, Execute, Evaluate, Refine — for turning scattered work data into a finished deliverable. You name your sources before writing the instruction, run one prompt that states the deliverable, judge the draft against a standard you set in advance, then correct only the element that failed rather than starting again.

It is the same AI Execution Loop we teach at PromptPeakAI for every tool, with one step doing different work. In ChatGPT, the heavy lifting is describing context that the model has no access to. In Copilot, the context is already there — so the heavy lifting becomes selecting from it.

• In a blank-chat tool, you paste in the background, the constraints and the examples, because nothing is known about your organisation.
• In Copilot, all of that is already reachable. Your job is narrowing, not supplying.
• The failure modes invert too. A blank-chat tool fails by knowing too little. Copilot fails by reaching for the wrong thing it already knows.

We call that selection discipline the Point-Then-Prompt Method: name the exact sources first, write the instruction second. Never the other way round. It sounds almost too simple to matter, and it is the difference between a Microsoft Copilot execution loop that produces something you can send and one that produces filler.

Running the loop step by step

What follows is the full working method. Run it once slowly and it takes about twenty minutes. After that, three to five minutes is normal for a document you produce every week.

In the Copilot prompt box, type a forward slash. A references menu opens, and you pick from tabs covering files, people, meetings, emails, Teams chats and channels, and SharePoint sites. According to Microsoft’s own documentation on referencing specific files, you can also pull in third-party content through Graph Connectors if your organisation has enabled them.

Pick the sources first. Then write the sentence. Doing it the other way round means you have already asked Copilot to decide what matters before you told it what you were doing.

The anchor prompt names the deliverable, the reader and the shape. It is not a conversation opener. If you have used our Role, Goal, Context, Format method, this is the same structure with the context slot mostly replaced by your source references.

You are drafting for me as a [your role].

Using ONLY the sources I have referenced above, write a [deliverable, e.g. one-page project update] for [named reader, e.g. my department director].

Structure it as:
- [Section 1 heading] — [what belongs there]
- [Section 2 heading] — [what belongs there]
- [Section 3 heading] — [what belongs there]

Rules:
- Do not use any source I have not referenced.
- If a fact is not in the referenced sources, write "not in sources" rather than filling the gap.
- Maximum [word count] words. Plain English, no corporate filler.

The “not in sources” instruction is the single highest-value line in that prompt. It converts an invisible failure — a confidently invented detail — into a visible one you can act on.

Most people read the draft, decide whether they like it, and start editing. Reverse that. Check provenance first, quality second, because a beautifully written paragraph built on the wrong document is worse than a clumsy one built on the right document.

Copilot footnotes its claims with the sources it used. Almost nobody clicks them. Click them. In practice you are looking for two specific things: a source you did not name appearing in the list, and a source you did name being entirely absent — which usually means Copilot could not read it and carried on without saying so.

• Sources. Open the citations. Did it use the documents you named, or wander?
• Gaps. Search the draft for “not in sources” and decide what to do about each one.
• Numbers. Check every figure against the original. Every one.
• Only then, judge the writing.

This is where most Copilot sessions collapse. The draft is wrong, so people delete everything and write a longer prompt. That throws away the good 80 percent along with the bad 20 percent, and produces a different set of problems.

Diagnose instead. Each failure type has one component behind it, and our guide to refining AI output without starting over covers the general diagnostic. Inside Copilot the mapping is tighter, because one extra failure mode exists that no other tool has — the wrong source.

Keep everything else exactly as it is.

Change only this: [the one specific element that failed].

[If it was a source problem:] Use only /[correct file] for that section, and remove anything drawn from elsewhere.
[If it was a tone problem:] Rewrite that section for [named reader], who cares most about [their actual concern].

Do not restructure the parts I have not mentioned.

Two examples from actual work

The loop is the same everywhere. What changes is which sources you point at.

The Monday project update

You have a sync meeting from Tuesday, a status tracker, and an email thread where the client changed a date. Point at all three. The tracker holds the facts, the meeting holds the reasoning, and the email holds the thing that will embarrass you if you miss it.

Using ONLY /[weekly sync meeting], /[status tracker file] and /[client email thread]:

Write a one-page project update for my department director, who has not been in any of these conversations.

Sections:
- Where we are — 3 bullets, facts from the tracker only
- What changed this week — include the client's date change and who agreed it
- What I need a decision on — 2 bullets maximum, each with a named owner

Rules: 250 words maximum. If the sources disagree with each other, say so explicitly rather than picking one.

That last rule earns its place. Trackers and meetings contradict each other constantly, and a summary that silently resolves the contradiction is how a wrong date reaches a director.

The first draft will usually be close but too even in tone — every bullet weighted the same. That is a single-element failure, so it gets a single-element fix: “Keep the structure. In ‘What I need a decision on’, lead with the date change, and say plainly that it puts the launch at risk.” One sentence, one change, one rerun of that section.

The policy document in Word

Drafting inside a document works the same way, with one difference: the open document is itself a source, so you point at the other ones. Our walkthrough of using Copilot in Word for professional documents covers the mechanics; the loop is what makes the second draft good.

Using this document plus /[previous version] and /[the meeting where we agreed the changes]:

Rewrite it as a [document type] for [named audience, e.g. all staff, non-specialist].

Keep: [what must not change, e.g. the legal definitions in section 1]
Change: [what must change, e.g. the eligibility rules, per the meeting]
Add: [what is missing, e.g. a summary table of core hours]

Rules:
- Every substantive change must trace to one of the two referenced sources.
- Where the sources are silent, write "needs a decision" instead of drafting something plausible.
- Match the reading level of the previous version. No new jargon.

The same principle carries into Copilot in Outlook for email threads and Copilot in Microsoft Teams for meeting recaps. Different surface, identical four steps.

What Copilot can and cannot see

Copilot only surfaces organisational data you already have at least view permission to open. It does not widen your access. The permission model of your tenant is the boundary, and Microsoft’s Semantic Index respects that same identity-based boundary when it grounds an answer.

Per Microsoft’s data, privacy and security documentation for Microsoft 365 Copilot, prompts, responses and data retrieved through Microsoft Graph are not used to train the underlying models. Sensitivity labels and encryption applied through Purview are honoured too. Our full guide to what Copilot can see in your work data goes deeper on the admin side.

None of that removes your judgement about what belongs in a prompt in the first place.

When the loop goes wrong

Four failures account for most bad sessions, and none of them are about prompt wording.

The last one deserves emphasis. Long chats degrade. Most professionals treat a Copilot conversation like an email thread that runs all week, then wonder why turn thirty is worse than turn three. One task, one chat — and when you switch deliverables, switch chats.

The first row is worth a second look too, because it is the most common blocker and the least obvious. A file sitting in a folder on your laptop is invisible to Copilot no matter how precisely you name it. Move it to OneDrive or SharePoint and it becomes referenceable within a couple of minutes. If you upload a local file directly into the chat instead, a copy is saved to OneDrive anyway — which is worth knowing before you upload anything sensitive.

Do you need the paid licence?

Yes for the full loop, no for a usable version of it. Without a Microsoft 365 Copilot licence, or with Work IQ switched off, you can still reference files — which means Point, Execute, Evaluate and Refine all still work on documents. What you lose is the ability to point at people, meetings, emails and Teams conversations.

The paid add-on lists at 30 US dollars per user per month for business and enterprise plans, on top of an existing Microsoft 365 subscription. Small-business pricing has moved more than once during 2026, so check current rates rather than trusting any figure you read in an article — including this one.

Here is the honest advice if you are trying to justify the cost to someone. Run the free version for two weeks on document tasks and count how often you actually wanted to point at an email or a meeting and could not. That number is your business case. Most people find it is either close to zero, or several times a day — and the Microsoft Copilot execution loop is worth paying for only in the second group.

What the loop will not fix

Three limits are worth stating plainly, because the gap between what this method does and what people hope it does is where the disappointment lives.

Cowork is not the loop

One category question is worth settling early. Copilot Cowork, which became generally available in June 2026, runs long multi-step tasks on your behalf rather than drafting alongside you. It needs a paid licence plus usage-based billing that an administrator has to switch on, and it is a different thing from what this article describes. Delegation is not iteration.

Start with one document you produce every week. Run the four steps on it, keep the anchor prompt in a note somewhere, and reuse it next week with different sources pointed at it. The second run is where the time saving shows up, because the thinking is already done and only the sources change.

• You will know it is working when your refinement messages get shorter, not longer.
• You will know it is not when you catch yourself rewriting the whole prompt for the third time.
• The tell either way is the citation list — right sources means the rest is just editing.

The method transfers cleanly across tools. The same four steps applied to Claude and ChatGPT look almost identical, minus the pointing — which is the whole argument for learning a structure rather than a tool. What you are really building when you run the Microsoft Copilot execution loop is a habit that survives the next product update.