EPPC26 Session Recap — Chris O’Brien

European Power Platform Conference, Copenhagen | Thursday, July 2, 2026 | Track: Copilot Studio | Level 300

Chris O’Brien opened with a joke that became the session’s running gag: humanity put someone on the moon sixty years ago in a spacecraft with walls “as thick as a coat cap,” yet creating a Word document from an automated process in Microsoft 365 in 2026 is still a fight. That gap between what feels like it should be easy and what actually is — was the throughline of a session built almost entirely around one live experiment: take a real client-facing agent, watch it fail, and fix it in front of the room.

The Experiment: Give an Agent a Vague Job

The starting agent had one job: work through a Microsoft licensing recommendation for a client, using knowledge sources for the client’s environment and Microsoft’s licensing catalogue, then log the result to a SharePoint list and generate a Word document from a template. The instructions describing this were reasonable-sounding prose — the kind most people would write on a first pass.

It failed on both actions. No SharePoint entry. No document. The chat output cheerfully suggested that someone should now go create the proposal document — as if the agent had delegated its own task back to a human.

The lesson wasn’t about a broken feature. It was that loose, prose-style instructions don’t survive contact with a real workflow, on either the classic Copilot Studio experience or the new orchestrator with skills. Autonomy without structure just produces an agent that talks convincingly about doing work instead of doing it.

Fix One: Numbered Steps Change the Model’s Behaviour

The first iteration replaced prose with an explicit numbered sequence of steps. Same model, same orchestrator, same knowledge sources — but the depth of reasoning the agent applied changed dramatically. Side by side, the numbered-instruction version produced visibly richer, more thorough output than the prose version, even though neither one, at that stage, had fixed the underlying action problem yet.

This opened a genuinely interesting design question rather than a simple “always number your steps” rule: how deterministic should an agent actually be? A fully declarative, step-by-step workflow can be the wrong pattern if the task genuinely benefits from the agent reasoning through how to achieve a goal rather than executing a fixed sequence. O’Brien’s own answer, watching his test results: a numbered list of intents — “this is what I’m trying to achieve” — rather than a rigid workflow, gave the best balance of structure and flexibility. Microsoft’s own guidance has also quietly shifted here: the once-recommended “reason” keyword that used to trigger deeper processing in older models is no longer necessary.

The second, equally important fix had nothing to do with instructions at all: the titles and descriptions on knowledge sources. Auto-generated descriptions from connected data sources are, in his words, generally terrible — they tell the agent nothing about what’s actually inside a file or when to use it. Writing a proper description — what’s in this Excel file, what columns it has, what it’s for — before the agent ever opens it turned out to matter as much as the instruction structure itself.

Fix Two: Actions Need Tools, Not Just Instructions

Numbered instructions alone still didn’t produce a working SharePoint log entry or a real document. That required a different category of fix: defining actual tools — in this case, Copilot Studio agent flows — for anything that touches another system. Referencing a tool directly by name in the instructions (using the / syntax to point at a specific action) was what actually got the agent to log to SharePoint and generate documents reliably, where descriptive prose alone never would.

On document generation specifically, O’Brien walked through the two viable approaches he’s found in production: the Word Online connector (usable only inside an agent flow, not directly from agent instructions — a distinction that trips people up) using placeholder-based templates, and the newer “modern template” / content assembly approach via SharePoint columns, which produces noticeably richer formatting. Neither is perfect. Both work well enough to be useful audit trails and drafts for a human to refine — which, in his framing, is exactly the point: these outputs are meant to reach an architect who improves them, not a client inbox directly.

Human in the Loop: Control, Not Just Approval

The session’s clearest architectural point was about autonomy and where humans belong in it. Copilot Studio’s human-in-the-loop action (in preview) is built specifically for the moments where an agent needs approval, validation, or simply a steer — not just a yes/no gate. Mechanically, today, it’s entirely email-based through Outlook: no Teams messages, no tasks, no planner integration, just a defined recipient and a “Request for Information” email.

O’Brien contrasted this directly with Copilot’s own “co-work” autonomy model, where the AI itself decides when to ask a human — an approach he called powerful but uncontrollable, sliding between a frustrating “ask about everything” mode and a “just do anything, YOLO” mode with nothing in between. Building the human checkpoint explicitly into the agent’s process, rather than leaving that judgment to the model, was framed as the difference that actually lets an organisation trust an autonomous process at scale.

The live demo made this concrete: a weekly competitor-research agent built for Advania’s leadership team pauses to email O’Brien its draft before anything reaches the wider team. In the demo, he used the reply not just to approve, but to instruct the agent to strip out an irrelevant section on a specific competitor — and the agent complied, reworked the output, and only then distributed it. That’s the pattern: not approval as a gate, but a genuine mid-process steer.

The Cost Conversation Nobody Wants to Have

The session closed on economics, and it was blunt. A show of hands revealed only around 10–15% of the room worked at organisations with full Microsoft 365 Copilot licensing across all employees — meaning the rest need to think carefully about Copilot Studio’s credit-based consumption cost, separate from that license.

The practical checklist for keeping an agent’s cost sane:
– Question the pattern first — not everything needs to be an autonomous agent; a passive topic or a plain Power Automate flow is sometimes the cheaper, better answer.
– Automated triggers cost more than human-initiated conversations — an agent watching a busy inbox or SharePoint library for every new item adds up fast.
– Computer use is expensive by design — every field filled on a form carries its own cost, and a ten-field form processed automatically can rack up real money even at modest volume.
– Model choice matters — not every agent needs a frontier model.
– Evaluations are free — run thousands of eval passes before publishing rather than discovering cost and reliability problems in production.

O’Brien’s illustrative worst case: an agent combining an automated high-volume trigger, an expensive model, computer use, and heavy dynamic re-planning could plausibly burn ten to twenty thousand euros a month without much effort. The Power Platform admin center’s cost dashboards, he noted, have gotten meaningfully better at surfacing exactly where that spend goes — but the design decisions that create it happen upstream, in the architecture choices covered in the rest of the session.

What to Take Away

  • Prose instructions are a starting draft, not a finished agent. Move to explicit numbered steps once you need reliability.
  • Knowledge source titles and descriptions deserve as much attention as the instructions themselves.
  • Any action touching another system needs a defined tool — referenced explicitly, not just described.
  • Human-in-the-loop should be an architectural decision you make, not a behaviour you hope the model arrives at.
  • Cost is a design output. Trigger type, model choice, and computer use are the biggest levers — and they’re all decisions made before the agent ever runs.

Session: “Techniques for Autonomous Agents (Copilot Studio) in 2026” — EPPC26, Copenhagen, July 2, 2026
Presenter: Chris O’Brien (Advania United Kingdom)