When should I use a single agent vs multi-agent system?

Stick with a single agent until you run into one of three problems: too many tools causing the model to pick the wrong one, conflicting instructions that cannot coexist in one system prompt, or parallel workstreams that need to run at the same time. If none of those apply, a single agent is the right choice.

How do I know if my agent has too many tools?

A good rule of thumb is to keep your tool count under eight to ten connectors. Beyond that, tool descriptions start competing with each other and the model's ability to select the right one drops noticeably, even if prompt tweaks do not seem to help.

Why does a single agent struggle with conflicting instructions?

When a system prompt asks the model to take on two opposing behaviours, such as acting as a strict policy checker and a friendly explainer, those personas create tension within a single instruction set. The model tends to compromise in ways that produce unreliable outputs rather than handling each mode correctly.

What are the main reasons to build a multi-agent system?

Multi-agent systems are worth the added complexity when you need genuinely parallel workstreams, have irreconcilable prompt conflicts, or are dealing with tool overload that cannot be resolved through better descriptions. Outside of those scenarios, the extra coordination overhead rarely pays off.

Tag: AI Agents

Power Platform June 2026 Update Shipped and the Power Apps MCP Server Closed-Loop Learning Is the Headline

The Power Platform June 2026 update MCP server announcement dropped on June 11 and the headline for me is not the usual feature list. It is the Power Apps MCP server and what Microsoft is calling closed-loop learning for enterprise agents. Source: What’s new in Power Platform: June 2026 feature update.

I read the post twice. The first read I filed it under “another MCP integration.” The second read I realised what they actually shipped. Agents can now learn from real usage signals inside Power Apps without you standing up a data science team to run training and evaluation cycles. That is a different category of thing.

What it actually does

The Power Apps MCP server exposes app context, user actions, and outcomes to an agent as structured signals. Until now, teaching an agent how your org works meant one of two paths. Either you fed it knowledge as documents and custom instructions, which is what most teams are doing today. Or you ran your own training, evaluation, and optimization loop, which almost nobody outside the big AI shops actually does.

Closed-loop learning sits in between. The agent observes what happens when a user takes its suggestion. Did the form get submitted. Did the approval get reversed two days later. Did the user override the recommendation. Those signals flow back through the MCP server and the agent’s behavior adjusts based on whether its suggestions actually worked.

The mechanism is the interesting part. It is not fine-tuning the underlying model. It is updating the agent’s grounding and skill selection based on outcome data that lives in Dataverse. Combine this with the business skills work Microsoft shipped earlier and the picture gets clearer. Skills are the policy layer. MCP server signals are the feedback layer.

Why it matters

Here is the architectural shift I think the release notes underplay. Agent knowledge stops being a build-time artifact and starts becoming a runtime asset.

Most agents I see today are frozen at deploy time. You write the instructions, attach the knowledge sources, ship it, and then it just sits there making the same mistakes for six months until someone files a complaint and a developer goes in to patch the prompt. That is the model we have been stuck with since Copilot Studio launched.

Closed-loop learning breaks that pattern. If the signal pipeline works the way the post describes, an agent that recommends the wrong approver three times in a row will stop doing that without anyone editing a prompt. The policy still lives in a business skill with a named owner. The behavior tunes itself based on what actually worked.

The risk is obvious and I want to name it. If you wire usage signals into agent learning without thinking about which signals count, you end up reinforcing the wrong behavior. A user clicking accept because they are tired is not the same signal as a user clicking accept because the suggestion was right. The MCP server gives you the plumbing. Picking the right outcome signals is still your job, and I expect the first wave of failures to come from teams treating every user action as positive feedback.

I also want to flag the governance angle. The Power Platform May 2026 update made me start thinking about agent constraints as versioned records. Runtime learning means version history now has to cover learned behavior too, not just authored skills. That is a real audit question and Microsoft has not fully answered it yet.

What I would do with it this week

I have an internal approval-routing workflow that I have been wanting to test something like this on. The agent currently picks an approver based on a static skill, and it gets the routing wrong roughly one in six times because the org chart does not reflect who actually owns what.

My plan for this week is simple. Wire the Power Apps MCP server to that app. Define two outcome signals. First, did the selected approver actually approve within 48 hours, or did they reassign. Second, did the requester come back and edit the routing manually after submission. Anything else I am ignoring on purpose, because I want a clean signal before I open the door wider.

Then I let it run for two weeks and compare the routing accuracy against the static baseline. If the closed loop moves the needle even five points on a workflow this messy, I will be writing about it. If it does not, I want to understand why before I trust it on anything that matters. If you are thinking about how to expose this kind of agent behavior through a proper UI layer, the guide on building custom Copilot UI widgets in Power Apps is worth reading alongside this.

The Power Platform docs will need to catch up on the MCP server specifics, and I expect the configuration story to get cleaner over the next few releases. For now, this is the most interesting thing shipped this month and I cannot wait to see what the signal quality looks like in a real workflow. More on this once I have run the experiment. You can follow along on LinkedIn if you want the results.

This post was inspired by What’s new in Power Platform: June 2026 feature update via Microsoft Power Platform Blog.

June 14, 2026
Anthropic Dropped Claude Fable 5 Mythos 5 and the Long-Form Narrative Angle Is What Caught Me

Anthropic just shipped the Claude Fable 5 Mythos 5 release, a variant tuned specifically for long-form narrative and worldbuilding. You can read the announcement on the Anthropic news page. This is not a flagship capability bump. It is another specialized lineup entry, and the pattern is what caught my attention.

Finance Agents. Creative. Now Fable and Mythos. Anthropic is not just shipping bigger models. They are shipping shaped ones.

What it actually does

Fable 5 Mythos 5 is a Claude variant tuned for long-form fiction, worldbuilding, and narrative consistency. The headline improvements are in three areas.

First, long-context coherence. Holding a character voice, world rules, and plot threads across tens of thousands of tokens without drift is the actual hard problem in long-form generation. The model is tuned to keep internal consistency, names spelled the same way, magic systems that do not contradict themselves three chapters later, characters that do not forget what they did in chapter two.

Second, persona stability. Once you give it a narrator voice or a character voice, it holds it. Most general-purpose models start regressing toward a neutral helpful tone after a few thousand tokens. This one is trained to resist that pull.

Third, structural awareness. It understands scenes, beats, chapter structure, and pacing in a way that is closer to how writers actually think about their work, not as a flat stream of tokens.

This is not a model for code. It is not a model for tool use. It is a model for people who write novels, run tabletop campaigns, or build interactive narrative experiences.

Why it matters even if you are not writing fiction

I am not writing a fantasy novel this week. Most people reading this are not either. So why does this release matter?

Because the underlying improvements are exactly what agentic systems need.

Persona stability is the same problem as agent persona stability. If you are building a Copilot Studio agent that needs to talk like an HR specialist or a finance approver, the failure mode is identical: after enough turns, the agent regresses to generic assistant tone. The work Anthropic did to keep a narrator’s voice locked across 50,000 tokens is the same work that keeps your internal procurement agent from drifting into ChatGPT mode by message twelve.

Long-context coherence is the same problem as multi-turn agent memory. An agent that loses track of what it told the user three turns ago, or contradicts a constraint it acknowledged at the start of the session, is failing the same test a novel writing model fails when it changes a character’s eye color in chapter seven.

The specialization play is the real signal here. Anthropic is not selling one Claude. They are segmenting by job. As I wrote when Anthropic launched Claude Finance Agents, this is a deliberate move away from raw capability tiers and toward fit-for-purpose variants. That changes how you pick a model. Not “which is smartest” but “which is shaped for my job.”

This is also a hint about what the next round of enterprise variants will look like. If Fable and Mythos work commercially, expect more shaped Claudes. Legal. Medical. Compliance. The lineup is going to get longer, not shorter. The Anthropic enterprise AI services arm launching to deploy Claude in production is the infrastructure that makes this segmentation commercially viable at scale.

What I would do with it this week

Three things, in order.

One, read Anthropic’s own writeup carefully, not for the fiction angle but for what they say about persona retention and long-context evaluation. The eval methodology is the interesting part. If you build agents, those metrics are closer to what you should be measuring than HumanEval scores.

Two, run a quick comparison test on Claude. Take an agent system prompt you already have, one that defines a specific persona, and run a long multi-turn conversation on a general Claude variant. Note where the persona breaks. That gives you a baseline. When Fable Mythos style tuning eventually filters into general or enterprise variants, you will know what to measure.

Three, stop storing persona definitions in 4000-token system prompts. I have written about this before, and it stays true. If Anthropic is doing the persona work at the model level, your job is to give the model a tight, focused instruction set and let the tuning do the rest. A 400-token persona definition with clear constraints beats a 4000-token character bible every time. The same principle applies when you are thinking about whether to build a multi-agent system instead of a single agent: tighter scope and cleaner constraints outperform bloated configurations every time.

Anthropic is shipping shaped models faster than most teams can decide which one to use. That is a good problem to have.

This post was inspired by Claude Fable 5 Mythos 5 via Anthropic.

June 9, 2026
Anthropic Shipped Claude Opus 4.8 and the Coding Numbers Are What Caught My Eye

Anthropic dropped the Claude Opus 4.8 release today. I read the post twice before writing anything because the coding and tool-use deltas are the part that actually matters for people building agents, not the headline number.

Most model bumps are easy to ignore. This one I am paying attention to, and not for the reason most posts will tell you.

What it actually does

Opus 4.8 is an incremental release on top of the Opus 4 line. The model card focuses on three areas: coding quality, tool-use reliability, and long-horizon agentic task completion. Anthropic reports gains on SWE-bench style coding tasks and improvements on multi-step tool sequences where the model has to plan, call a tool, read the result, and decide what to do next without losing the thread.

The pricing and context window stay in line with the Opus 4 family. It is available on the Anthropic API, on Claude.ai, on Amazon Bedrock, and on Google Vertex. Same deployment story as before.

The thing that jumped out at me was the reduction in tool-call errors on longer agent traces. Not the average. The tail. That is a different problem to fix and a different problem to feel in production.

Why it matters for agent builders

If you have built anything resembling a real agentic workflow, you know the failure mode. The agent runs fine for 4 or 5 steps. Then on step 8 it calls a tool with malformed JSON, or hallucinates an argument, or forgets which tool it already called. The whole trace dies and you are looking at logs trying to figure out where the drift started.

Coding quality and tool-use reliability are the same problem wearing two different hats. A model that writes better code is a model that produces better structured outputs, better function arguments, and better adherence to a schema. That is what makes a multi-step agent stop falling apart on turn 9.

I have written before about latency being the quiet killer of agentic workflows. Reliability is the louder one. A workflow that completes 70 percent of the time is not a workflow. It is a demo. And most teams I talk to are sitting at 70 percent and calling it production.

If Opus 4.8 actually pushes the tail of tool-call failures down, that is the difference between an agent you can schedule overnight and an agent that needs a human babysitting every run. That is the gap I care about.

The other piece worth naming: this is Anthropic doubling down on coding and agents as the wedge. Not consumer chat. Not creative writing. They are picking a lane and shipping into it. Anthropic has been consistent about this for months and Opus 4.8 fits that pattern cleanly. That same strategic focus is visible in moves like Anthropic acquiring Stainless, where the SDK layer itself became a competitive asset.

What I would do with it this week

One test. Not a benchmark. A real one.

Take the agent or automation in your stack that fails most often on long traces. The one where you keep adding retry logic and validation steps because the model keeps producing slightly wrong tool arguments. Run the same trace 20 times on whatever model you are using now. Log the failure points. Swap to Opus 4.8 with the exact same prompt and tools. Run it 20 more times.

If the tail failures drop noticeably, you have your answer. If they do not, you keep what you have and you saved yourself a migration.

I would also pay attention to cost per successful completion, not cost per token. A more expensive model that completes the workflow on the first try beats a cheaper model that needs three retries every time. That math is what people forget when they compare price sheets. It is the same logic that applies when you are deciding whether to build a multi-agent system instead of a single agent — the right architecture is the one that actually completes reliably, not the one that looks cleanest on a whiteboard.

One more thing. If you are running Claude through Bedrock or Vertex, give the model version a week or two to land cleanly in your region before you build anything critical on it. I learned the hard way that prototyping on the direct API and then lifting to Bedrock at the last minute will burn a sprint on region availability and version naming. And if you are watching the broader competitive picture on AI coding agents in enterprise environments, the OpenAI and Dell Codex on-premise partnership is worth reading alongside this release — the two moves are aimed at the same buyer.

Opus 4.8 is not a revolution. It is a sharpening. And for the kind of long-running agent work I keep seeing teams try to stand up, sharpening is exactly what is needed right now.

This post was inspired by Claude Opus 4 8 via Anthropic.

May 28, 2026
Dataverse Just Got Knowledge Sources and Agent Feedback Loops and I Want to Wire These Up Now

Microsoft published Dataverse Is Your Agent Data Platform: Here’s What’s New on May 5. I already wrote about the positioning shift, but the dataverse agent data platform new features in this post are the part I actually want to wire up this week. Knowledge sources you can attach to an agent. Agent feedback captured and stored back in Dataverse. Tighter coupling between business skills and the data model. That last bit is the one that changes my build order.

What it actually does

Three things stand out from the post.

First, knowledge sources on Dataverse. You can now attach SharePoint sites, websites, files, and Dataverse tables as knowledge an agent can reason over, governed at the Dataverse level rather than configured per agent. The point is that knowledge becomes a managed artifact in the data platform, not a per-agent setting buried in Copilot Studio.

Second, agent feedback stored in Dataverse. Thumbs up, thumbs down, and the conversation context land as rows you can query. That means feedback is not trapped in a separate analytics surface. You can write a flow on it. You can build a Power BI report on it. You can route a thumbs-down with a specific topic tag to the skill owner.

Third, business skills tied to the data model. The business skills I wrote about when they shipped now sit closer to the tables they operate on. Skill ownership, policy versioning, and the data the skill reads from are governed in one place.

For the official surface area, the Microsoft Learn docs are the right starting point once you have read the announcement.

Why it matters

I have built enough Copilot Studio agents to know where the pain actually sits, and it is never the model. It is the loop between what the agent does, what users think of what the agent did, and the policy owner who has to fix the thing that went wrong. That loop has been broken on Power Platform for a year.

Feedback used to live in conversation transcripts you had to export. Knowledge used to be attached per agent, which meant the same SharePoint site got wired up four different ways by four different makers. Business logic lived in a 4000-token system prompt or a hardcoded Power Automate flow nobody could find six months later.

Putting all three in Dataverse closes the loop. Feedback is a table. Knowledge is a managed artifact. Skills are versioned records with owners. You can finally write the query that says “show me every thumbs-down on the leave policy topic in the last 30 days, grouped by the skill that was invoked.” That query was not possible before. Now it is a view.

The thing I am cautious about is the same thing I flagged with business skills. Sprawl. If five teams attach overlapping knowledge sources to overlapping skills with no naming convention, the agent will misroute silently and the feedback table will just tell you users are unhappy without telling you why. Governance has to come before deployment, not as a month-six cleanup. The multi-agent orchestration patterns that are now GA in Copilot Studio make this even more important to get right before you scale.

What I would do with it this week

I have a small internal agent that answers process questions. The plan for the next few evenings looks like this.

Move knowledge out of the agent and into Dataverse. Right now the agent has three SharePoint sources wired up directly. I want one knowledge source registered in Dataverse, owned by the process owner, that any future agent on the same domain can reuse. That is the silo fix.

Turn on feedback capture and build the report. Thumbs-down without a report is just noise. I want a Power BI page that shows feedback rate per topic, with a drill-through to the conversation. If I cannot see which skill was invoked when the user said no, I cannot improve anything.

Pick one skill and version it properly. I am going to take the leave policy skill, rewrite it as a Dataverse business skill with an owner who is not me, and document the handoff. If the policy changes, the policy owner edits the skill. I do not get a ticket. That is the architectural shift I keep talking about, and it only works if I actually do it on something real. The error handling patterns that hold up in production become especially relevant once feedback loops are writing rows back into Dataverse and triggering flows downstream.

None of this needs a new model. It needs the data platform to do its job, and it finally can.

The interesting question now is what the second wave of agents looks like once knowledge and feedback stop being per-agent problems.

This post was inspired by Dataverse Is Your Agent Data Platform: Here’s What’s New via Microsoft Power Platform Blog.

May 21, 2026
Microsoft Just Reframed Dataverse as the Agent Data Platform and the Update List Is Worth Reading

Microsoft published a post on May 5 called Dataverse Is Your Agent Data Platform: Here’s What’s New. The framing is the part worth reading. Dataverse is no longer being sold as the database under your model-driven apps. It is being repositioned as the dataverse agent data platform, the layer that gives agents real business understanding instead of just rows and columns.

That is a meaningful shift in how Microsoft wants you to think about the stack. I have been waiting for this framing to land properly.

What it actually does

The update bundles several things that were previously scattered across announcements into one coherent story.

Knowledge sources let an agent ground itself in Dataverse tables, SharePoint sites, files, and external systems through a managed reference instead of a hand-rolled retrieval pipeline. The agent sees the data with its semantics: table relationships, choice columns, business rules. Not just a vector dump.

Business skills are now first-class records in Dataverse. I wrote about this in Microsoft Just Shipped Business Skills in Dataverse. Skills move policy and process logic out of system prompts and into a managed, owned, versioned artifact. The May 5 post confirms this is the intended pattern, not an experiment.

Deeper Fabric wiring means agents can reach analytical data through Dataverse without you stitching mirroring and shortcuts manually for every project. The semantic model carries through.

Copilot Studio integration is tighter on the agent side. Connected agents in Copilot Studio can pick up Dataverse knowledge sources and skills as native primitives instead of you wiring them through custom connectors and Power Automate flows.

None of these are individually new ideas. The point of the post is that they now line up as one platform story.

Why it matters

The hardest part of building an internal agent is not the model. It is getting the agent to behave like someone who actually works at your company. Org-specific policies, naming conventions, what counts as an active customer, which approval thresholds apply when. That tribal knowledge is where every agent project I have seen gets stuck.

If that knowledge lives in a 4000-token system prompt, the agent degrades. If it lives in hardcoded Power Automate flows, nobody can find it six months later. If it lives in a Word document on someone’s OneDrive, it might as well not exist.

The dataverse agent data platform framing says: put it in Dataverse as a typed, owned, versioned record, and let any agent on the stack consume it. That is an architectural decision, not a feature toggle. It changes who owns what. The policy owner updates the skill directly. The data steward owns the knowledge source. The agent builder stops guessing.

The risk I keep flagging is skill sprawl. The moment multiple teams start writing skills with overlapping scopes, the agent starts misrouting silently. Governance has to come before deployment, not as a cleanup project in month six. Microsoft is shipping the platform. The org design is still on you. That same principle applies to Power Platform governance that does not kill adoption — the structural decisions made early determine whether the whole thing scales or stalls.

I also want to see how this plays with multi-agent orchestration. I covered the patterns in multi-agent orchestration in Copilot Studio. If knowledge sources and skills become the shared substrate that connected agents draw from, the per-agent prompt size drops and routing gets more reliable. That is the part I find genuinely exciting.

What I would do with it this week

Three concrete things, in order.

First, pick one existing agent that has a bloated system prompt. Anything past 2000 tokens. Pull out the policy chunks and rewrite them as business skills in Dataverse. Measure the prompt size before and after, and run your behavioral tests on both. You will see the consistency change in the edge cases.

Second, take one knowledge source that today is glued together with a custom connector or a Power Automate flow doing retrieval. Replace it with a Dataverse knowledge source pointing at the same data. Compare the answers on questions that depend on relationships between tables. The native version handles joins the hand-rolled one fakes.

Third, draft a one-page skill ownership matrix for your tenant before anyone writes a third skill. Who owns customer policy, who owns finance approvals, who owns HR routing. Boring document. Saves you from the sprawl that kills these projects.

Read the Power Platform docs alongside the announcement. The framing finally matches what practitioners have been building toward. I am curious where it lands by the end of the quarter.

This post was inspired by Dataverse Is Your Agent Data Platform: Here’s What’s New via Microsoft Power Platform Blog.

May 6, 2026
Anthropic Raised Claude Rate Limits for SpaceX and That Tells You Where Enterprise AI Is Heading

Anthropic announced a deal with SpaceX that includes higher Claude rate limits as part of the engagement. The headline most people will read is the SpaceX logo. The actual signal is different. The anthropic spacex higher rate limits story tells you that capacity is now a negotiated enterprise lever, not a number on a pricing page.

If you are building agents seriously, this is the part to pay attention to.

What it actually does

The deal gives SpaceX elevated rate limits on Claude, alongside the usual enterprise engagement wrapping. Anthropic frames it as supporting frontier engineering work where teams need sustained throughput for code generation, document analysis, and agent loops at scale.

The published tiers on the Anthropic site still exist. Usage tier 1, tier 2, tier 3, tier 4 with their requests-per-minute and input-tokens-per-minute caps. What this announcement quietly confirms is that above those tiers, the conversation is bespoke. You sign a contract, you get a number that fits your workload.

That has been true behind the scenes for a while. Saying it out loud, with a customer name attached, is the new part.

Why it matters

Most teams I talk to still treat rate limits like an afterthought. They build a prototype on a developer key, the latency feels fine, the cost looks reasonable, and they move toward production. Then a real workload hits and the 429s start.

I wrote about this in a different shape when I covered Claude running on Amazon Trainium. The benchmark conversation distracts from the real production failure mode, which is capacity drift at peak hours. Rate limits are the same story from a different angle. Throughput is now part of the architecture, not a footnote.

Three things follow from this.

First, the gap between what a hobbyist API key can do and what a serious enterprise workload needs is widening fast. A single agent loop with tool calls, retries, and a few sub-agents can burn through a tier 2 limit in seconds. Multi-agent orchestration makes it worse. If you are running ten parallel agent invocations from a Power Automate flow, each with their own context window, you will hit the ceiling before you hit the budget. If you are thinking through whether your workload even needs that kind of parallelism, the honest answer on single-agent vs multi-agent design is worth reading before you scale out.

Second, procurement now needs to ask different questions. Not just price per million tokens. Sustained tokens per minute. Concurrency. Burst tolerance. Region. What happens when your traffic doubles next quarter. Most enterprise AI contracts I hear about from people at other organisations still get signed without these numbers nailed down. Anthropic is moving further in this direction across the board, and their enterprise AI services arm is exactly the context in which these bespoke capacity conversations are going to happen.

Third, the platform vendors are going to feel pressure here. If you are running Claude through Bedrock or through Copilot Studio, your effective rate limit is shaped by both Anthropic and the platform layer. The platform abstracts capacity, which is convenient until it is not. Knowing where the ceiling actually sits in your stack is going to matter more, not less.

What I would do with it this week

If you are running anything beyond a demo, instrument the throughput. Not just success and failure counts. Tokens per minute, requests per minute, p95 latency, and 429 rate, broken down by flow or agent. You cannot negotiate a number you have not measured.

Then look at your system prompts. Token bloat is the cheapest capacity win available. A prompt that drifted from 800 to 4000 tokens over a few sprints is not just costing you money, it is eating your throughput ceiling on every single call. I have seen this kill production agents at peak hours when nobody changed the model or the workload.

Then map your workload to a tier. If your steady state is comfortably inside a published tier, fine. If you are within forty percent of the ceiling on any axis, you are already in negotiation territory. Start the conversation before the incident, not after.

For teams building on Power Platform with Claude in the loop, the same logic applies through whatever connector or custom action you are using. Concurrency settings on a Power Automate flow can mask the real call pattern until it does not. Know what your worst minute looks like.

The SpaceX deal is a marker. Capacity has joined price and capability as a first-class procurement axis for enterprise AI, and the teams treating it that way now will have one less surprise next year. (My ongoing notes on this stuff live on my LinkedIn if you want to follow along.)

This post was inspired by Higher Limits Spacex via Anthropic.

May 6, 2026
Anthropic Just Launched Claude Finance Agents and the Specialization Trend Is Real

Anthropic shipped Claude Finance Agents this week. A set of Claude-powered agents built specifically for financial analysts, with native connectors to LSEG, Moody’s, S&P Global, and Morningstar. This is not a generic chat assistant pointed at a finance prompt. The Claude finance agents are a packaged product with the data plumbing already done.

I have been watching this trend build for months. This release makes it impossible to ignore.

What Anthropic actually shipped

Three agents wrapped around specific analyst workflows. One handles modeling. One handles due diligence. One handles comparable company analysis. Each one is a Claude agent with a defined scope, a system prompt tuned to that workflow, and direct connectors into the data providers analysts already pay for.

The connector list is the part that matters. LSEG for market data. Moody’s for credit. S&P Global for company financials. Morningstar for funds. These are not scraped sources. They are licensed enterprise feeds. Anthropic did the integration work that every internal team building a finance copilot would otherwise have to do themselves.

You can read the full announcement on Anthropic’s site. The pricing structure is enterprise. The target user is clear. This is not a consumer move.

Why this release matters beyond finance

For two years the pitch from foundation model vendors was: here is the model, build whatever you want. That is over.

Now the pitch is: here is the model, here is the agent, here are the connectors, here is the workflow. The vendor is moving up the stack into the application layer. Anthropic is doing it for finance. Microsoft is doing it for general enterprise productivity. OpenAI is doing it for coding and research. The pattern is consistent. Anthropic launching an enterprise AI services arm was an early signal of exactly this direction.

This changes the build-vs-buy math in a real way. If you are an enterprise team that was about to spend six months building a Claude-based comparable company analysis agent on top of a generic platform, you now have to ask whether your custom version will actually beat what Anthropic ships out of the box. Most of the time, in the specific domains where these vertical agents land, the answer will be no.

That does not mean custom builds are dead. It means the line moves. Custom builds make sense where the vendor product does not exist or does not match your specific data and policies. Generic finance modeling? Probably not worth building. Your firm’s specific deal screening logic with your proprietary scoring model? Still custom.

The other thing this release confirms is that tool design is product design. I have written before that agentic workflows live or die on the quality of their tool layer. Anthropic clearly figured this out. Wrapping LSEG and S&P data with proper structured outputs that Claude can reason about is the actual hard work. Anyone who has tried to build this on top of raw connectors knows.

This specialization pattern also raises a real architectural question: when the vendor ships a domain-specific agent, does your orchestration layer treat it as a peer, a sub-agent, or a replacement? That is the same question I work through in when to build a multi-agent system instead of a single agent.

What I would do with it this week

I do not work in finance, so I am not deploying this in production. But here is what I would do if I were on a finance team, and what I am doing in adjacent domains.

First, audit any internal agent project that overlaps with what Anthropic just shipped. If a team has been building a comparable company analysis tool for four months and Anthropic just released one, that conversation has to happen now, not in Q3.

Second, look at the connector list and ask which of those data sources your team already licenses. The value of Claude Finance Agents drops fast if you do not have LSEG or S&P feeds. Vendor lock through data integration is the real moat here.

Third, think about what the equivalent looks like in your domain. If Anthropic shipped finance agents in May 2026, what does an HR agent product look like? A legal one? A procurement one? Someone is building each of these. Probably more than one someone. In my experience, the teams that win the build-vs-buy decision are the ones that ask the question early, not the ones that finish their custom build and then discover the vendor product. The same specialization logic is visible in Microsoft Discovery as the first real glimpse of domain-specific agent platforms.

For Power Platform builders, this is also a useful signal. Copilot Studio is Microsoft’s answer to the same trend, and the business skills work in Dataverse is the integration layer equivalent. The shape of the market is clear.

The era of generic agent platforms competing on model quality alone is closing. The next round is about who owns the workflow.

This post was inspired by Finance Agents via Anthropic.

May 5, 2026
Microsoft Just Shipped Business Skills in Dataverse and This Is How You Teach Agents Your Org

Microsoft announced business skills in Dataverse on May 1, and this is the announcement I have been waiting for. Dataverse business skills for agents let you encode org processes, policies, and the tribal knowledge that lives in people’s heads as natural-language instructions. Agents discover them and follow them at runtime. No more cramming everything into a 4000-token system prompt and hoping the model remembers how your finance team handles approvals.

I have been reading the docs since Friday. Here is my honest take.

What business skills actually do

A business skill is a Dataverse record. It contains a natural-language description of when the skill applies, what the agent should do, and what data or actions it can use. Agents query Dataverse at runtime, find the skills that match the user’s intent, and follow the instructions inside.

The shape matters. You are not writing code. You are writing the kind of paragraph you would send to a new hire on day one. Things like: When someone asks about expense approvals over 5000 EUR, route to the regional finance lead, never to the team manager. The lookup table is in the Finance Approvers table. Always confirm the amount and the cost center before submitting.

That description is stored, versioned, and indexed. Multiple agents can use the same skill. You update the skill once and every agent that discovers it picks up the new behavior. There is also a permission layer, so a skill can be scoped to a security role, a team, or an environment.

Underneath, this is grounding. The agent does not memorize your org. It retrieves the relevant skill at runtime and follows it.

Why this changes how you build internal agents

The hardest part of deploying internal agents has never been the model. It has been getting the agent to behave like someone who actually works at your company. The model can reason. It cannot know that your procurement policy changed in March, or that the Madrid office handles APAC tickets on Wednesdays because of a coverage gap.

Until now, that context lived in three bad places. System prompts that grew until they hit the context window and started degrading. Power Automate flows with hardcoded business logic that nobody could find six months later. Or worse, it lived nowhere and the agent guessed.

I have written before that a focused 400-token instruction set produces more reliable behavior than a 4000-token one. Business skills make that practical. You stop stuffing the prompt and start composing skills. The agent picks the right ones for the job.

The other thing this fixes is ownership. A business skill in Dataverse has an owner, an audit trail, and a lifecycle. When the policy changes, the policy owner updates the skill. They do not need to find the agent maker, file a ticket, or wait for a release. That is a real architectural shift, not a feature flag. If your org is still working out who owns what when policies change, Power Platform governance that does not kill adoption covers how to structure that before it becomes a cleanup problem.

The risk I am watching: skill sprawl. If every team writes their own skills with overlapping scopes, the agent will face the same routing problem multi-agent setups face. Skill descriptions will start competing with each other and you will get silent misrouting. Governance has to come early, not as a cleanup project in month six.

What I would do with it this week

Pick one painful, well-bounded process. The kind where the answer is always it depends on who you ask. Approval routing is a good candidate. Onboarding checklists work too.

Write three to five business skills that capture the rules. Keep each one short and specific. Connect them to a Copilot Studio agent that already has the right Dataverse and Power Automate connectors. Test with the messy questions, not the clean ones. Watch which skills get picked and which do not.

The thing to measure is not whether the agent answers correctly. It is whether the right skill was selected for the right phrasing. If selection is unreliable, your skill descriptions are too similar or too vague. Rewrite them and try again. If you are also wiring up custom connectors to extend what the agent can reach, How to Build a Custom Connector for Copilot Studio Step by Step is worth keeping open in a tab.

I will be writing more about this once I have run a real internal pilot. Early signals are good. In my experience, the patterns that survive contact with production are the ones where context is stored where it belongs, not where it was convenient at build time.

This one belongs in Dataverse. Finally.

This post was inspired by Introducing business skills: Teach agents how your organization works via Microsoft Power Platform Blog.

May 5, 2026
When should I build a multi-agent system instead of a single agent?

Short answer: stay single-agent until you hit one of three specific failure modes. Tool overload past roughly 8 to 10 connectors. Conflicting system prompts that cannot be reconciled in one instruction set. Or genuinely parallel workstreams that need to run at the same time. If none of those apply, the single agent vs multi-agent question is already answered. Build one agent.

Most posts on this topic make multi-agent sound like the natural next step. It is not. It is a tax you pay when a single agent can no longer do the job, not an upgrade you take because it sounds more sophisticated.

The longer answer

I read a good piece on Towards Data Science walking through ReAct workflows and when scaling to multi-agent makes sense. The framing matched what I keep running into when I talk to people building on Copilot Studio and similar platforms.

A single agent is a loop. It reads, picks a tool, calls the tool, reads the result, picks again, until it decides it is done. That loop works well when the tool list is small enough for the model to reason over cleanly and the instructions do not pull the model in two directions.

It starts breaking in predictable places.

The first is tool overload. I have written before about how a model that hits 95 percent accuracy on tool selection with two connectors can drop to 70 percent with five, because tool descriptions start competing with each other. By the time you have ten or twelve tools, the agent picks the wrong one regularly and you cannot fix it with prompt tweaks.

The second is prompt conflict. If your agent needs to behave like a strict policy checker for one task and a friendly explainer for another, those two personas fight inside one system prompt. You can feel it in the outputs. The model compromises in the wrong direction.

The third is parallelism. A single agent loop is sequential by design. If you have three independent workstreams that must run at the same time, no amount of prompt engineering will make a single ReAct loop parallel. This is also where thinking through whether AI automation is even the right fit versus a simpler RPA approach becomes worth the time.

Everything else, latency, observability, prompt size, can usually be solved without splitting agents.

How to decide in practice

I use a short checklist when someone asks about single agent vs multi-agent for a Copilot Studio build.

Count the tools. If you are under eight connectors and the descriptions do not overlap, one agent is fine. Past ten with overlap, start thinking about splitting.

Read the system prompt out loud. If it contains contradictory instructions for different scenarios, that is a real signal. Splitting reduces prompt size per agent, and a focused 400-token instruction set produces more reliable behavior than a 4000-token one. I covered this in more detail in my post on multi-agent orchestration patterns in Copilot Studio.

Map the workstreams. Are they actually independent, or are they sequential steps you are calling parallel because it sounds nicer? Most automation work is sequential. Real parallelism is rarer than people think.

Budget the latency. Every hop between agents adds round-trip overhead. If you split a single agent into three, you have just added two more model calls and two more HTTP boundaries to every request. I have written about how accumulated round-trip overhead kills perceived performance long before any single call gets slow.

If the checklist points to multi-agent, default to a supervisor pattern. One parent agent routes to focused child agents. Skip the peer network where agents call each other freely. It looks elegant in diagrams and is painful to debug in production.

Microsoft has shipped real multi-agent orchestration in Copilot Studio, so the platform support is there. The question is whether your problem actually needs it.

Related gotchas

Routing in Copilot Studio multi-agent setups depends on the description you write for each connected agent, not on trigger phrases. A vague description causes silent misrouting that is harder to debug than a broken trigger. Write descriptions like API contracts, not marketing copy.

When a parent agent picks the wrong child confidently, you get the same failure mode as a single overloaded agent, just one layer deeper. Splitting agents does not eliminate misrouting. It moves it.

Token costs multiply faster than you expect. Each agent in the chain re-processes context. Three agents in a sequence is not three times the cost. It is often closer to five or six times once you count the context each one needs to reason properly.

If you are still on the fence, build single first. You can always split later. Going from multi-agent back to single, on the other hand, almost never happens once the architecture is in place. That is the trade-off worth keeping in mind. More on how I think about these trade-offs here.

Frequently Asked Questions

When should I use a single agent vs multi-agent system?

Stick with a single agent until you run into one of three problems: too many tools causing the model to pick the wrong one, conflicting instructions that cannot coexist in one system prompt, or parallel workstreams that need to run at the same time. If none of those apply, a single agent is the right choice.

How do I know if my agent has too many tools?

A good rule of thumb is to keep your tool count under eight to ten connectors. Beyond that, tool descriptions start competing with each other and the model’s ability to select the right one drops noticeably, even if prompt tweaks do not seem to help.

Why does a single agent struggle with conflicting instructions?

When a system prompt asks the model to take on two opposing behaviours, such as acting as a strict policy checker and a friendly explainer, those personas create tension within a single instruction set. The model tends to compromise in ways that produce unreliable outputs rather than handling each mode correctly.

What are the main reasons to build a multi-agent system?

Multi-agent systems are worth the added complexity when you need genuinely parallel workstreams, have irreconcilable prompt conflicts, or are dealing with tool overload that cannot be resolved through better descriptions. Outside of those scenarios, the extra coordination overhead rarely pays off.

This post was inspired by Single Agent vs Multi-Agent: When to Build a Multi-Agent System via Towards Data Science.

May 4, 2026
Power Pages Agentic Code Just Got Server-Side Skills and I Cannot Wait to Try Them

Microsoft just shipped three new skills for the Power Pages agentic code plugin that finally let GitHub Copilot and Claude Code CLI generate server-side logic, not just front-end markup. The announcement landed on the Power Platform blog and this is the gap-closer I have been waiting for. Power pages agentic code server-side generation is the part that was missing.

If you have built anything non-trivial on Power Pages you know the pattern. The studio handles the front-end fine. The moment you need a Web API call, a table permission rule, or a Liquid template that actually does work, you are out of the visual layer and into code that the AI tools could not see properly.

What it actually does

The plugin now ships three new skills focused on the server-side surface of a Power Pages site. From the post and what I have read so far, these cover generating and wiring up Liquid templates with the right context, scaffolding Web API calls against your actual Dataverse tables, and producing the configuration around table permissions and site settings that normally requires you to know exactly which knob to turn.

The important detail is grounding. The plugin pulls from your real site context: the tables you have, the columns on them, the page structure, the site settings already in place. So when GitHub Copilot or Claude Code CLI generate Liquid or a Web API snippet, it is generated against your actual environment, not a hypothetical portal.

I wrote about this grounding problem before in an earlier post on Power Pages and AI. Generic LLM output for Liquid looks correct and breaks immediately on deploy because the model has no idea what your tables are called or what permissions are wired up. Environmental grounding is the entire game here.

Why server-side AI generation is different leverage

Front-end scaffolding from AI is useful but cheap. Anyone can prompt a model to spit out HTML and CSS for a form. The hard part of Power Pages was never the markup. It was the layer underneath: Liquid templates, Web API permissions, plugin logic, the settings that decide whether a record is visible to an authenticated contact or not.

That layer is where sites break. That layer is where you used to bolt on a Power Automate flow because it felt easier than figuring out the right server-side pattern. And bolting on a flow for what should be a server-side query is exactly the kind of decision that creates a silo three months later when nobody remembers why the form posts to a flow instead of using the Web API directly. Understanding Power Automate error handling patterns helps when those flows do need to exist, but the goal should be keeping server-side work on the server side.

Generating server-side logic with proper grounding cuts that path off. You stay inside the site. You use the layer that was already designed for it. The trade-off is real though: you now have AI-generated Liquid and permissions in a place where mistakes are harder to spot than a broken button. Server-side bugs do not show up as the dreaded broken image icon. They show up as a record being visible to the wrong user, which is a much worse failure mode.

This is why I keep saying tool design for AI agents is an API design problem. The quality of the environmental signals fed to the model matters more than the model itself. Microsoft Learn for Power Pages is the reference I keep open when I am sanity-checking what these skills produce.

What I would do with it this week

I would pick a small internal-style site with two or three Dataverse tables, authenticated users, and one workflow that currently lives in a Power Automate flow it should not live in. Something where a list view filters by the logged-in contact, and a form writes back to a related table.

Then I would have Claude Code CLI do three things. First, generate the Liquid for the filtered list using the new skill, against the real tables. Second, generate the Web API call for the form submission with the right permissions, instead of the Power Automate detour. Third, write a small piece of logic that should obviously fail without context, like referencing a column that does not exist, just to see how the grounding holds up.

The point is not to ship anything. The point is to find where it breaks. In my experience, the only honest way to evaluate one of these releases is to push it until it produces something wrong, then look at why. If you are thinking about where this fits in a broader agentic architecture, most agentic workflows are just fancy if/then logic until the grounding is solid enough to trust the generated output in production.

If the grounding is as good as the announcement suggests, this changes how I would start any new Power Pages build going forward.

This post was inspired by Build your server-side logic with AI: new Power Pages Agentic Code skills via Microsoft Power Platform Blog.

April 28, 2026