One hub for the whole Dynamics 365 delivery
Disclaimer: all the data shown (customers, environments, people) has been anonymised.
A Dynamics 365 Finance and Operations project lives in at least six places: the ERP environments, Azure DevOps (work items, repositories, pipelines), the Power Platform admin center, Lifecycle Services, Microsoft Learn, and the heads of the people who know the customer. Every real question needs two or three of them. "Is UAT really the same as production?" "What went out last night, and which requests were in it?" "Is this requirement standard or a gap?" Someone opens the tabs, copies, compares, and writes the answer by hand.
AI assistants such as Copilot Cowork or an agent built in Copilot Studio are very good at conversation. On their own, they see none of this. They do not know which customer you are working for, what is deployed where, or what the customer’s own code already does.
This article is about an individual experiment: a hub that I designed and developed on my own to give them exactly that context, with the guardrails a delivery team needs. The goal is to improve the everyday experience of every member of a Dynamics 365 Finance and Operations project team, whether the project is in build (the implementation) or in run (application management services). It is not about how it was built. It is about what it changes in a week of project life, and why now is the moment to do it.
The architecture in one pictureIn the rest of this article I simply call the hub my experimentation. It tries to be, for a project team, the context layer between the agents people talk to and the systems that hold the truth. People stay where they work: Copilot Cowork, a Copilot Studio agent published in Teams, or GitHub Copilot for those who already develop. Their agent reaches it through MCP, with each person’s own sign-in. It brings back the right context (fleet, deliveries, work items, code, fit-gap, service, telemetry) within guardrails, from sources that remain the source of truth: Dynamics 365 itself, the Power Platform admin center, Azure DevOps, Application Insights, Microsoft Learn and the customer’s documents.
Figure 1. My experimentation in the architecture: agents above, sources of truth below, context, skills and guardrails in between.
Why now: two shifts that make a single view necessaryLifecycle Services is giving way to the Power Platform admin center
Microsoft froze the creation of new LCS cloud implementation projects for Finance, Supply Chain Management and Project Operations on 16 February 2026. Since September 2026, existing customers can move environments, one at a time, to the Power Platform admin center (PPAC) with a self-service migration that is in public preview. See the project creation freeze and the migration guide.
That is good news for governance and a practical headache for delivery. In LCS, one project gave you the environments, their versions and their servicing state. After the move, environments live in the admin center, tenant by tenant, and some of them will stay in LCS for a while. During the transition, nobody has one place that answers: which version does each environment run, which update can be applied, when is its maintenance window, what failed last night?
The Power Platform API now exposes the Finance and Operations side of an environment: its properties, its maintenance settings, the versions that can be applied and the recent operation errors. A hub that reads it with each person’s own sign-in turns the transition from a risk into a 360° view.
Assistants are moving from chat to action, and Microsoft is building the plumbing
At Microsoft Ignite 2026, the message was consistent: work is becoming multiplayer, with people and agents sharing context. Microsoft IQ brings together the context of Work IQ, Fabric IQ, Foundry IQ and Web IQ, and business plugins and skills let an organization define once how a task is done and reuse it across agents (announcement). For Dynamics 365, the ERP MCP server is now part of Work IQ, with built-in business skills for source-to-pay, project-to-profit and order-to-cash, announced in public preview (Dynamics 365 blog). The earlier static ERP MCP server with its fixed list of tools was retired on 1 October 2026 in favour of a dynamic one (documentation).
Agents are therefore getting the keys to the ERP. What a delivery team still needs is the layer around one environment: the customer, its other environments, its pipelines, its code, its fit-gap, its service and its rules. That is the layer this hub provides.
The idea in one minuteThe hub is a single server that speaks MCP, the open standard that lets an assistant call tools. You connect your assistant once. From then on, whatever the assistant (Copilot Cowork, a Copilot Studio agent, another one), it reaches the same governed set of tools for the customer in front of it.
Four principles shaped everything that follows:
• Read first. The default is to look, compare and explain. Anything that changes something shows a preview and waits for a person’s agreement.
• Per person. Each person works with their own sign-in and their own profile: a developer, a functional consultant, a project manager and a director do not see the same tools.
• Per customer. One conversation is about one customer, its environments, its Azure DevOps project, its documents and its code. Nothing leaks from one customer to another.
• Everything is traceable. Who asked what, on which customer, with what result, is kept. Never the content of the answer.
Connect in minutes: Copilot Cowork, Copilot Studio and TeamsIn Copilot Cowork: import a plug-in
The hub ships a plug-in for Copilot Cowork: the connection to the server plus a set of skills that tell the assistant how to do a job (compare environments, do a fit-gap, work with Azure DevOps, diagnose a difference). You import it once, sign in with your work account, and open a new conversation.
Figure 2. The plug-in in Copilot Cowork: the connection to the hub and the skills it brings.
At the first use, the server asks you to allow the assistant to act as you. It makes the boundary explicit: the tools of your profile, with your access, reading and comparing, and changes only after you confirm them.
Figure 3. The consent screen: the assistant acts as the signed-in person, with that person’s profile.
From then on you work in plain language. Here, Cowork compares the tax groups of two environments for one company and answers with a table: how many groups on each side, how many identical, how many only on one side, how many different.
Figure 4. A question in everyday language, answered from the real data of two environments.
In Copilot Studio: build an agent, then publish it to Teams
The same server can be the tool source of a Copilot Studio agent, so that a whole team can use it without installing anything. You add the server as an MCP tool, attach the skills, choose the model, and keep only the tools the agent should have.
Figure 5. In Copilot Studio, the hub as an MCP tool: every tool can be allowed or not for this agent.
Figure 6. The agent in the test panel, calling the hub to list the environments the person may use.
Publishing is then a channel choice: Microsoft Teams, so that consultants ask the question where they already talk to each other, or Microsoft 365 Copilot. Step by step:
1. In Copilot Studio, open the agent, then Channels, then Microsoft Teams and Microsoft 365 Copilot.
2. Turn the channel on and choose who can find the agent (people of the tenant, or a list).
3. Submit it for approval if your tenant requires an administrator to approve agents, then pin it in Teams.
What you can ask, in your own wordsYou never need to know a tool’s name: the assistant picks the right one from your sentence, and the profile of each person decides what it may use. Behind a handful of everyday sentences there are fifty-two tools, grouped here by what people actually do with them. Anything that changes something shows a preview first and waits for agreement.
Look at your environments and their data
• "Which environments can I use for this customer, and are they all reachable?"
• "Compare the payment terms and customer groups of UAT and PROD for company FRFR."
• "What changed in UAT since Thursday?" (the assistant compares two saved pictures of the environment)
• "Open the Vendors form in UAT and tell me what it shows." (the environment’s own ERP tools, with your rights)
• "Load these customer groups into the sandbox." (a preview, a check against the metadata, your agreement, and an undo)
Follow the delivery in Azure DevOps
• "List my open work items", "Show work item 8555 with its parent, its children and its branch."
• "What was developed for this request? List the tasks, the developers, the pull requests and the objects delivered."
• "Create the test plan for story 1234 and show me the preview first."
• "Check how the project is governed before the go-live" (branch policies, reviewers, build validation).
Know the customer
• "What do we hold for this customer: environments, code, documents, fit-gap?"
• "Search the specification for the paragraph about serial numbers and tell me what is asked."
• "Find the Microsoft business process ‘Trace a specific batch or serial number’ and say whether it is standard."
Read the code, the standard and the customer’s own
• "Which standard objects handle the invoice journal, and who calls this method?"
• "Search the customer’s code for the classes that extend SalesLine, read one and explain it."
Understand how the application behaves
• "Did the errors increase on UAT since Thursday’s update?"
• "Which requests fail most this week, and for which form?" (the assistant writes the query and shows it)
Steer the estate
• "Which environments need attention?", "What does this customer use of its licences and capacity?", "Who holds the system administrator role?"
1. See the whole fleet on one pageI described this part in detail in a previous article, A 360° view of your Finance and Operations fleet with the Power Platform API: environments of a customer’s tenant with their version, health, maintenance window and installed applications, read with each person’s own Microsoft sign-in, which matters while environments move from Lifecycle Services to the admin center.
Figure 7. The fleet: where each environment sits by version, the page to have open when you plan an update wave.
What the hub adds on top is the review and the history: a governance review that counts what deserves a look (no maintenance window, recent operation errors, behind the newest version), raised only from facts the platform gave, and for each environment a timeline of what was done to it (copies, restores, updates) with who asked, how long it took and why it failed when it did. And because listing everyone’s role assignments is an administrator’s right, the page shows everybody else the roles they hold in the environment itself.
2. Compare environments, by data and by codeThe data and the setup
"Why does this posting work in UAT and not in production?" is a question about differences nobody has listed. The assistant reads both environments through the same tools and answers in plain words, company by company (see the Cowork answer above). Every difference can be kept, judged (expected, to align, to ignore) and watched: a scheduled watch compares the same pair every night and tells the team when something drifts.
The code, without the cherry-pick trap
Any team that promotes by cherry-pick or squash knows the problem: the same change gets a new commit hash on every branch, so the repository says the branches differ when the code is identical. "Ahead by 14, behind by 9" tells you nothing.
The hub compares what the code contains, not its history. It reads which commit each environment was last deployed from (every environment of the project, whatever the pipeline that deploys to it) and answers the question you actually asked:
• "The code is the same", even if the hashes differ.
• Or the files and objects that really differ, and for each commit that exists on one side only, whether its content is already on the other side under another hash.
• And the work items concerned: present, partly present or missing on the other side.
Figure 8. Azure DevOps keeps the list of the project’s environments and the last run of each: the hub reads it dynamically, so a new environment appears by itself.
Figure 8. Two environments, the commit each runs, and what truly differs between them.
3. Know what went out, and whyThe release view reads the customer’s pipelines with the person’s own Azure DevOps connection: which run is on which environment, whether it succeeded, how long each stage took. A red cell is one glance away.
Figure 9. The environments against the last runs of a pipeline.
Figure 10. The flow and the timeline of one run: where the time went.
Going the other way, from a request to its code: give any work item and the hub walks down its children and related items, as deep as you choose, and lists the branches, commits and pull requests found, whatever the level they are linked at. A functional consultant can answer "what was developed for this request?" without opening a repository.
Figure 11. The development behind a request: tasks, branches, pull requests and commits found by walking down its children.
Then the question every project manager asks after a deployment: what was in it? Open a run and the hub lists the work items that went out: the children and related items of the release item, the items tied to the build by its commits, and the requests they belong to, each with the reason it is listed.
Figure 11. What a deployment contained, grouped by request.
On demand, an assistant explains a work item, a pull request or a release in plain words: what it changes, what is risky, what to check next. It is off until an administrator turns it on, it sends nothing by itself, and what it sends is limited to what the person could already see.
Figure 11. A closed task explained in plain words: the fix in brief, status and code, and what to watch (for example a parent still marked active).
4. Read the standard code and the customer’s code, without Visual StudioTo understand what the standard product does, or what a customization changes, a person has traditionally needed a development environment, a Visual Studio licence, the application metadata on disk and enough X++ and AOT knowledge to find their way. So the answer to a simple functional question often waits for a developer. The hub puts both bodies of code behind the assistant, so that anybody with access can ask.
The Microsoft standard code
The hub holds an index of the standard application for the release in use (more than 194,000 objects across 178 models), and the assistant can search it by name, by part of a name, by the words of a name, by a phrase found in the code or by meaning, and narrow it by type: class, table, form, extended data type, enum, view, query, menu item, security privilege, duty or role.
Figure 12. The standard code index: a name, part of a name, the words of a name or a phrase of the code.
• Read an object. Its description (members, relations, the data source of a form) or the source of one method, a part at a time, with labels turned into their text in any language.
• Follow the links. Who points to an object and what it points to, and from a menu item up the security chain to the privileges, duties and roles that open it: the question "who can open this form?" without the security designer.
• Ask in business words. "Which tables hold the customer invoice journal?" is a question the assistant turns into the right searches.
The customer’s own code
The customer’s repository is imported into the hub and kept up to date by a job that follows the branch. The assistant searches and reads it the same way: the extensions of a standard class, the objects delivered for a request, what a customization does and which standard feature it overlaps. Because the standard and the customer’s code are in the same conversation, it can answer the question that matters in a fit-gap or an upgrade: what is standard, what did we change, and where.
Figure 13. In Copilot Cowork: "can you see the code developed for this request?" answered with the tasks, the developers, the pull requests and the objects delivered.
Explained in plain words, on demand
A person who is not a developer does not want X++, they want to know what an object is for, how it behaves and what to check before changing it. On demand, the hub asks the AI assistant to explain an object in sections with the technical names in parentheses: what it is for, how it is built, the extension points and the risks, and a checklist before a change. It is off until an administrator turns it on, it sends the object and nothing else, and every explanation is kept so that the same question is not paid twice.
Figure 13. A class of the customer’s code with its explanation in plain words: what it does, what to watch and what to check before changing it.
Why this matters
No Visual Studio licence, no development environment, no metadata to install: a consultant, a project manager or a tester asks, from Copilot Cowork or a Copilot Studio agent published in Teams.
Every reading is audited, the code is read only, and a customer’s code is open only to the people who have access to that customer.
5. From a specification to a fit-gap and a test plan
A fit-gap is where projects are won or lost, and where time disappears: reading the specification, finding what the standard product does, checking what the customer already has in its own code, classifying each requirement and defending the classification. With the customer’s documents and code loaded in the hub, the assistant does the legwork and shows its evidence:
• It extracts the requirements from the specification, with where each comes from.
• It places each one in Microsoft’s business process catalog and checks the standard behaviour on Microsoft Learn, quoting the page.
• It looks in the customer’s own code for what already exists, so a requirement already covered, or overlapping a standard feature, is spotted.
• It classifies: fit, fit with configuration, gap, third party, out of scope, to confirm, and never without evidence.
Figure 13. The fit-gap saved in the hub: each requirement with its process, class, evidence and estimated effort.
The result is a map, not a list: where the gaps concentrate by process area, what each is estimated at, and the areas of the flows you touch that no requirement mentions, a scope that may have been forgotten before the estimate is signed. Once the team agrees, the assistant creates the test plan in Azure DevOps with a test case per requirement, whose steps come from the catalog, and says which cases still need real steps and why.
Figure 13. Where the gaps are, with the estimated effort.
6. Steer the service and the projectA dashboard of counters does not help a manager decide. The service and project views start from a sentence and a colour: where we stand and why, then the facts behind it. A ticket that waits for the customer, or that is resolved and waiting to be accepted, is not late and needs no action: the service view separates what the team must do now from what waits for others, puts the tickets past a service target first and names the person who carries most of them. The project view draws the progress, projects the end date at the pace of the last four weeks and puts the go-live date on the same chart. Every chart opens the tickets it counts.
Figure 13. The AMS flow, created and resolved by week: each bar opens the tickets it counts.
Figure 13. Where the project stands, and where it is heading at its current pace.
In numbers (anonymised)
A service backlog where 8 of the 10 late tickets belonged to one person: visible in one line, invisible in a table.
A project of about 1,700 work items, 78% done, with its forecast end next to the go-live date.
On demand, a Recommendations card reads the priorities and the latest comments of the tickets that need attention and proposes what to do first, what each blocked ticket is waiting for, who to relieve and what to escalate. It advises; the team decides.
7. Ask the telemetry in plain wordsBehind every environment, Application Insights holds what really happens: errors, slow requests, failed batch jobs, the forms people open. Reading it means the Azure portal and KQL, the Kusto query language, which most functional consultants, testers and service managers do not use. The hub already collects the daily usage of a customer’s application from Application Insights (who is active, which forms are opened, which licences sit idle). It now goes further: the assistant turns a sentence into a query and the hub runs it. Two tools do it, one that shows what the customer’s telemetry holds and one that runs the question. For example:
• "Did the errors increase on UAT since Thursday’s update?"
• "Which batch jobs failed last night, and how often this month?"
• "Is the posting form slower than last week for the finance team?"
In an earlier experiment I queried Application Insights from GitHub Copilot, and it worked. But it required VS Code, or Visual Studio with a licence, and a GitHub Copilot licence, which today is dedicated to developers. From Copilot Cowork or a Copilot Studio agent, the same question comes from a consultant or a service manager, without the Azure portal and without knowing KQL. It works like this: the assistant writes the query and shows it, the hub checks that it only reads (no command, no plugin that reaches outside, no other resource), runs it on the customer’s own Application Insights, within a time range of at most 90 days and 500 rows, hides the names of people where the customer asks for it, and records the query in the audit trail. The answer comes back in words, with the query for those who want to check it. It uses the application already set up for the usage collection, and only the profiles that need it (developer, technical and functional architects) are given it.
Why it matters
No Azure portal, no KQL, no Visual Studio licence and no developer licence: the question comes from a consultant, a tester or a service manager, in Copilot Cowork or in Teams.
Read only, one customer at a time, audited, and the query is always shown.
How each profile uses it
The same experimentation serves the whole team, but nobody sees the same thing. A profile decides the tools, and each role has its own way in. For each of them, this is the flow: what they ask, what is understood, what is read, and what they get.
Technical: solution architect and developer
A technical architect or a developer asks about code and environments and gets facts: the differences by content, who can open a form, the errors by day.
Figure 14. The flow of a technical person: from a question about code or environments to differences, objects and errors.
Functional: consultant
A functional consultant starts from a specification or a user story: the fit-gap first, then the test plan, each created only after a preview and an agreement.
Figure 15. The flow of a functional consultant: from a specification to a fit-gap and a test plan.
Key user and tester
A key user or a tester does not need to know where anything is: they ask why something behaves as it does, or what a release contained, and get a plain answer.
Figure 16. The flow of a key user or tester: from "why can’t I" to the setting that explains it.
Program and project manager
A program or project manager, a PMO or a director asks for a position, not a list: a verdict with its reasons first, the facts behind it after.
Figure 17. The flow of a manager: from "where do we stand" to a verdict, a forecast and what to do.
Application management: service manager
In run, a service manager asks how the service is doing, and what the telemetry of the application says, in the same conversation.
Figure 18. The flow of a service manager: from "how is the service" to a verdict, a to-do list and an error trend.
Trust: profiles, read-only and an audit trailA hub that touches environments has to be boring about security. Each person is given a profile, and the profile decides the tools: a reader looks and compares, a developer reads code and work items, a functional consultant also prepares fit-gaps and test plans, a project manager sees progress and releases, a director sees the portfolio. Even if a person’s own token could do more, the profile keeps it read-only: a reader stays a reader through the assistant. Changes show what they will do, wait for agreement and are written to the audit log, with the person, the customer and the result. The content of an answer is never kept.
Figure 18. A developer, a functional consultant, a project manager and a director do not get the same tools.
What it is worthI measure usage because "does it help?" deserves a figure, and I say plainly that the figure is an estimate: for each tool, the minutes a person would spend doing the same thing by hand, multiplied by the calls that worked. Administrators set those assumptions, and the page shows the unit used for every tool so that nobody has to trust a total they cannot follow.
Figure 18. The estimate and its calculation: calls that worked × minutes per call.
In numbers (30 days, one deployment)
491 calls that worked, an estimated 48.5 hours saved (about 5.9 minutes per call).
The biggest savings: comparing environments (13.0 h), reading work items (11.2 h), reading the customer’s code (7.9 h) and the standard code (6.1 h).
The same figures can be read by customer, to see where the assistants are used and whether they work.
Before and after

Where this is going
The message of Microsoft Ignite 2026 is clear: the value moves to the context. Microsoft IQ, Work IQ and the business plugins exist so that an agent starts every task with the right knowledge of the business, and the Dynamics 365 ERP plugin brings finance and operations into Copilot Cowork and Excel.
It changes what an application is. With Dynamics 365 Finance and Supply Chain Management delivered as a service and updated continuously by Microsoft, the application becomes the back office: the place where the data lives and the rules run. Work is started and followed from agents in Copilot or Cowork, which bring the right context to the person who asks, whether that person configures, tests, develops, runs a service or sponsors the project. This experiment goes the same way: give the model the right context, with the right permissions, and the experience for every member of the team changes.
What Ignite announced, and the status that matters
Announcements travel faster than their status. Reading the Ignite 2026 Book of News line by line, here is what concerns a Dynamics 365 delivery team, and where a label deserves a second look.

Azure AI Gateway: what it brings and how it fits
Microsoft presented Azure AI Gateway at Ignite as the managed front door for AI traffic in an organization. Its value is in what it centralizes for everything that calls a model, an agent or an MCP server:
• Identity and access. Microsoft Entra ID decides who may call which model, MCP server or API.
• Budgets and quotas. Limits of tokens and calls per team, per agent or per customer, so that a runaway agent cannot run up a bill.
• Routing and failover. Calls are spread across model providers and deployments, and move to another when one fails.
• MCP federation. Several MCP servers are published behind one governed address.
• Usage and cost tracking. Who used what and what it cost, sent to Azure Monitor, Application Insights or any OTLP endpoint.
• Content guardrails and policies. Azure AI Content Safety and rules applied on the way in and on the way out.
• Private networking. The traffic stays on the organization’s private network.
In the context of Dynamics 365 delivery the picture is simple. Agents in Copilot Cowork, Copilot Studio or a coding assistant call several MCP servers: the Dynamics 365 ERP MCP server, this experimentation, others. A gateway gives them one front door, one identity check, one set of budgets and one trace of what was called. The experimentation would sit behind it as one more MCP server, and keep what only it knows: which tools each profile may use and which customer a conversation is about. It does not need a gateway to work today, and it is designed so that one can be added in front of it.
Figure 19. Where an AI gateway would sit: the experimentation behind it, as one MCP server among others (the layout follows Microsoft’s own description of the gateway).
Two related items we deliberately did not count on: the Book of News says nothing about the move from Lifecycle Services to the Power Platform admin center or about X++ developer tooling, so the 360° view and the code reading described above stand on their own.
ConclusionThe best test of a tool for a delivery team is whether people stop opening the other tabs. When an assistant can compare two environments, say what went out, place a requirement in the standard processes and tell you how the service is doing, with a person’s own rights and a trace of everything, the conversation moves from "where do I find this?" to "what do we decide?". With LCS giving way to the admin center and agents getting the keys to the ERP, that single place has never been more useful.
A last word on direction. Everything Microsoft announced this month points the same way: for a model to be useful, it must be given the right context, the customer, the environments, the code, the process and the rules, and given it with the right permissions. That is what this experiment tries to do for a Dynamics 365 delivery team, and it converges with what Microsoft is building with Microsoft IQ and Work IQ. What I experiment with today may well be built by Microsoft one day, perhaps under the name Dynamics IQ 🙂. Until then, it is a practical way to learn what a project team really asks for. [contact line to add]
References
• Lifecycle Services project creation freeze
• Power Platform API reference
• Introducing the new Microsoft IQ (Azure blog, 17 November 2026)
• Dynamics 365 ERP with Work IQ and business skills (Dynamics 365 blog, 19 November 2026)
• Microsoft Ignite 2026 Book of News
• Use Model Context Protocol for finance and operations apps
Comments (0)