Microsoft Learn has a new Copilot Studio guidance article, Design reliable agentic loops, last updated on 6 November 2026 and listed as the November 2026 addition on the Copilot Studio guidance hub what’s new page. It applies only to agents powered by the GitHub Copilot harness, and it reads like a design guide. The governance point sits in one sentence: “Instructions alone aren’t a guarantee that execution stops.” If an agent can retry, change route, or keep calling tools until it decides it is done, the boundaries that matter are the ones enforced in tools and the runtime, not the ones written in the agent’s instructions.
That moves the conversation from prompt quality to control design, and that is where admins and Centers of Excellence should get involved before these agents reach production.
What the article covers
| Item | What Learn says (as read 11 November 2026) |
|---|---|
| Article | Design reliable agentic loops (guidance, concept article) |
| Last updated | 6 November 2026 |
| Applies to | “Only applies to: GitHub Copilot harness” |
| What a loop is | A loop “lets an agent evaluate a result and decide whether to continue, correct an error, try another approach, or stop.” |
| Main risk named | “Without retry limits and stopping conditions, repeated model and tool calls can consume tokens and add latency without advancing the work.” |
| Enforcement mechanism referenced | Hooks: Pre tool use (can deny a call), After tool failure (adds guidance), Error (changes recovery behaviour). The Hooks page is labelled preview. |
| Human control | Irreversible actions require “user confirmation or an authorized human review”, including on retries. |
| Validation | Compare the activity trace and evaluation results before and after each change. |
| Status, limits, pricing | The article states no release status, no numeric limits, and no Copilot Credits figures. |
The article works through seven illustrative failure scenarios, from ambiguous tool results to structurally invalid inputs. Microsoft is careful to say these “describe example processing tools and execution environments, not requirements that apply to every Copilot Studio agent.” The value for governance teams is not the scenarios themselves but the pattern they share: every failure is an agent continuing when it should have stopped.
Instructions guide, the runtime enforces
The article repeats one instruction in several forms: “Where supported, enforce the attempt limit in the tool or runtime. Don’t rely on instructions alone.” For a governance team, that is a clear signal about where review effort belongs. Reviewing an agent’s instructions is still useful, but it does not prove the agent will stop. The controls that do are tool configuration, workflow return values, and hooks.
The linked Hooks (GitHub Copilot) (preview) page, last updated 12 October 2026, is precise about what each control can do. “Pre tool use is the only event that can block an action. All other events can add context or change values, but can’t stop the agent.” The Error hook can set errorHandling to retry, skip, or abort and supply a retryCount. The After tool failure hook can only pass guidance to the model, and its error input should be treated “as untrusted content.”

One line on the Hooks page deserves attention from anyone treating hooks as a security boundary: “Hooks don’t stop the agent when they fail.” If the hook workflow fails, times out, or returns something unreadable, the agent continues as though the hook returned nothing. In governance terms, hooks fail open. That does not make them unusable, but it does mean a denial rule needs the same testing and monitoring as any other production control, and the workflow behind it needs an owner. The page also notes that hooks reference workflows rather than copy them, so “Editing a workflow affects every hook that uses it.”
Least privilege now applies to tool operations
The guidance tells makers to “Enable only the tools and MCP server operations the task requires” and to use read-only tools when the task does not change data. It is blunt about the opposite habit: “Don’t expose every operation from an MCP server ‘in case it’s useful’.” This is the same least privilege principle admins already apply to connectors, applied one level down to individual tool operations. It also fits the review questions Power Platform Engineer raised when Copilot Studio skills became shareable across the organization: what an agent can reach should be decided deliberately, not inherited.
The article also says agents should not repair their own environment. “Don’t expect the agent to discover, install, bypass, or repair its execution environment,” and makers should prohibit changes to package sources, certificate or proxy settings, or library paths during processing. A denial is meant to end the attempt: “When an action is denied, require the agent to report it and stop rather than try another command, tool, or route.”
Irreversible actions need a named human
Before an agent “deletes or overwrites data, sends information, or performs another irreversible action,” the article requires user confirmation or an authorized human review, and it applies the same rule “when the agent retries or changes its approach.” That last clause is the important one. A confirmation captured on the first attempt does not cover a second attempt by a different route. Governance teams should ask makers to show where the confirmation sits and who the authorized reviewer is, especially for agents that write to the locations covered in the earlier piece on where agent-created files go.
Runaway loops are a cost problem
The article does not mention Copilot Credits, but the Hooks page carries the billing note: “The harness used to build this agent uses usage-based billing. Using, building, testing, and evaluating agents might consume Copilot Credits.” The Harnesses in Copilot Studio page says that on the GitHub Copilot harness “Agents and workflows on this harness use Copilot Credits.” Put that next to the article’s warning that costs “can continue to accumulate even when the task is no closer to completion” and retry limits become a budget control as much as a reliability one. Power Platform Engineer covered how harness choice drives cost in The Harness Is the Price Tag; this guidance adds a design reason for the same discipline.
Proving completion, not claiming it
“A tool reporting success alone might not confirm that the output meets the user’s request.” The article asks for completion criteria that both calling and connected agents share, workflows that return status, errors, and “an indication of whether it’s safe to retry,” and a rule that missing evidence means reporting the task as incomplete. It also asks makers not to let an agent “guess a missing value or silently change a result returned by the tool.” For release reviews, the practical test is the activity trace: look for repeated calls, route changes, and actions that continue after a stopping condition. The article warns that “Fewer actions or a shorter run alone aren’t proof of improvement.”

What the documentation does not cover yet (as of 11 November 2026)
- No numeric limits. The article says to “State the maximum number of attempts” but gives no platform maximum, timeout, or default retry count.
- No admin or tenant controls. Neither the article nor the Hooks page describes a Power Platform admin center setting, environment policy, or data policy for hooks or loop limits.
- No statement of who may author hooks. The Hooks page explains how to add one but not which roles can.
- No audit mechanism. The Hooks page mentions writing an audit record as a use case but describes no built-in logging for hook decisions; monitoring guidance stops at the activity trace and evaluations.
- No identity guidance. The article does not address which identity tools run under during a loop.
- Naming. The Learn pages read today still say “GitHub Copilot harness”, while Power Platform Engineer has covered the move to the Microsoft Copilot harness name. Expect the documentation wording to change.
Admin checklist
- Add the article to the release review checklist for every agent on the GitHub Copilot harness.
- Require makers to list the tools and MCP server operations each agent uses, with a reason for every operation that changes data.
- Require a documented maximum number of attempts per state-changing action, enforced in the tool or a Pre tool use hook rather than only in instructions.
- Identify every irreversible action and the user confirmation or authorized human review in front of it, including on retries.
- Assign an owner to each hook workflow, test what happens when it fails, and remember that hooks are preview and fail open.
- Ask for activity trace and evaluation results before and after changes as part of promotion between environments.
- Watch Copilot Credits consumption for agents with loops, and treat a sudden rise as a possible missing stopping condition.
Sources
- Design reliable agentic loops, Microsoft Learn, last updated 6 November 2026
- Hooks (GitHub Copilot) (preview), Microsoft Learn, last updated 12 October 2026
- Harnesses in Copilot Studio, Microsoft Learn, last updated 22 October 2026
- What’s new in the Copilot Studio guidance hub, Microsoft Learn, last updated 5 November 2026
