Copilot Studio Bring Your Own Model: Microsoft Foundry Governance and Security

Copilot Studio Bring Your Own Model: Microsoft Foundry Governance and Security

TL;DR

Copilot Studio can use a model you host in Microsoft Foundry in a prompt through bring your own model (BYOM) on the standard harness. That doesn’t replace the agent’s primary orchestration model, and the Microsoft Copilot harness doesn’t support the prompt tool.

BYOM gives your platform team control over the deployment and its applicable guardrails, quota, diagnostics and Azure costs. Agent orchestration, identity and sharing remain with Copilot Studio and the wider Microsoft governance tools.

The documented connector uses an API key. A dedicated Foundry resource contains the risk of a resource-wide key better than a project in a shared resource.

In a hurry? Jump to the resource decision or the nine go-live checks, then come back for the detail.

A question I keep getting from AI platform teams goes like this: makers are building agents in Copilot Studio, our models live in Foundry behind our guardrails, so if Copilot Studio used our Foundry models, could we govern it like everything else?

It’s a fair question, and the answer is “partly”. Copilot Studio calls a Foundry model mainly from inside a prompt, and that one connection decides a lot about what the platform team controls and where the Foundry should sit. In this post I’ll walk through where Foundry models plug in, what that puts in the platform team’s hands, what it leaves with the Copilot Studio and Microsoft 365 admins, and why I’d give it a dedicated Foundry resource.

The product details below were checked against Microsoft Learn on 20 November 2026, after this year’s Ignite announcements.

Two control planes, one bridge

Copilot Studio runs on Power Platform. Foundry runs on Azure. Each has its own control plane, and neither governs the other. A Copilot Studio agent can reach Foundry in four ways, and two of them put your Foundry model inside Copilot Studio:

  • A prompt with bring your own model. The prompt uses your selected Foundry deployment every time it runs.
  • A generative answers node on Azure OpenAI on your data (preview). A classic data option inside a topic, on the standard harness. It’s the older route, and I’d keep it out of new designs.
  • A connected Foundry agent (preview). The Copilot Studio agent hands a task to a Foundry agent, which does the work on its own model, under Foundry’s controls, and returns a result.
  • A connector or HTTP call. The same pattern: a tool call that returns data.

With generative orchestration, the agent’s primary model, picked from Copilot Studio’s list, decides what to do with the result and can write the answer the user reads. A topic, or a prompt set to send a specific response, can pass the prompt’s output straight to the user, so your Foundry model can have the last word. Microsoft’s model selection guidance separates primary model selection from prompt builder models. The connected-agent preview requires the Foundry agent’s Activity protocol endpoint to be enabled.

flowchart TB
    accTitle: Where Microsoft Foundry plugs into a Copilot Studio agent
    accDescr: A user reaches a Copilot Studio agent whose primary model comes from Copilot Studio's list. It can call a prompt using bring your own model, a connected Foundry agent or a connector. The response may be generated by the agent or passed through from a prompt.
    U["User or trigger"]:::user
    subgraph CS["Copilot Studio · Power Platform control plane"]
      PM["Primary model from Copilot Studio's list
orchestrates the agent"]:::cs PT["Prompt with bring your own model"]:::bridge CA["Connected Foundry agent, preview
a tool call"]:::tool TL["Connectors and HTTP
tool calls"]:::tool end subgraph AZ["Microsoft Foundry · Azure control plane"] DEP["Your model deployment
your guardrails, quota and logs"]:::az FA["Foundry agent
its own model and controls"]:::az end U --> PM PM --> PT PM --> CA PM --> TL PT -- "chat completions with an API key" --> DEP CA -- "Activity protocol call" --> FA classDef user fill:#f1f5f9,stroke:#334155,color:#000 classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000 classDef bridge fill:#cce5ff,stroke:#1f6feb,color:#000 classDef tool fill:#fef9c3,stroke:#a16207,color:#000 classDef az fill:#e0f2fe,stroke:#0369a1,color:#000

One bridge for new designs. Your Foundry deployment can act as a model in two places, but the older generative answers route is a preview I’d leave alone, so the prompt is the bridge to design around. A connected Foundry agent is a tool call: Foundry does its part under its own controls, and Copilot Studio’s primary model decides what happens next.

The documented BYOM bridge uses the standard harness

Copilot Studio now runs agents on three harnesses: the standard harness, the Microsoft Copilot harness and the Customer Conversation harness, which went GA at Ignite. The BYOM documentation is scoped to the standard harness. The Microsoft Copilot harness has no prompt tool at all: Learn marks prompts there as replaced by skills, and upgrading an agent to that harness creates a copy of the agent rather than converting it in place.

The primary model lists differ by harness too. The standard harness defaults to GPT Chat Latest, while the newest models, such as Claude Fable 5.2, appear on the Microsoft Copilot harness list.

flowchart TB
    accTitle: Which Copilot Studio harness has the prompt tool
    accDescr: On the standard harness an agent has the prompt tool, so bring your own model to Foundry is available, and the primary model comes from the standard harness list. On the Microsoft Copilot harness prompts are replaced by skills, so there is no bring your own model route, and the primary model comes from that harness's list, which includes Claude Fable 5.2.
    A["Copilot Studio agent"]:::cs --> H{"Which harness?"}:::q
    H -- "Standard harness" --> S1["Prompt tool available
bring your own model: yes"]:::yes H -- "Microsoft Copilot harness" --> M1["Prompts replaced by skills
bring your own model: no"]:::no S1 --> S2["Primary model from the standard list
GPT Chat Latest by default"]:::cs M1 --> M2["Primary model from the harness list
including Claude Fable 5.2"]:::cs classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000 classDef q fill:#f1f5f9,stroke:#334155,color:#000 classDef yes fill:#dcfce7,stroke:#15803d,color:#000 classDef no fill:#fee2e2,stroke:#b91c1c,color:#000

Check the harness before you design the bridge. A BYOM plan only makes sense for agents that stay on the standard harness. If an agent is heading to the Microsoft Copilot harness, its prompts need a new home first.

What the bridge accepts

BYOM is narrower than most people expect. Here’s what Microsoft documents today:

  • Where it lives. In the prompt tool, a maker selects + in the model list and connects a Foundry model. The prompt then uses that deployment every time it runs.
  • The connector. The connection runs on a Power Platform connector. Its fields match the Azure AI Foundry Inference connector reference, and Learn says to govern it in data policies under the name “Azure AI Foundry”.
  • The API. Chat completions only. The endpoint must end in /chat/completions, and a Responses API URL fails.
  • The models. The GPT-5 family and later models aren’t currently supported. Claude models in Foundry use the Messages API, so a Claude deployment doesn’t fit the connector either.
  • Authentication. An API key, alongside the endpoint, deployment name and base model name. The connector documents no Entra ID or managed identity option.
  • Safety. The prompt’s content moderation setting isn’t available for Foundry models, and Microsoft recommends applying Responsible AI policies in Foundry. Confirm which controls actually apply to the model and API; coverage and behaviour vary.
  • Cost. Foundry charges for BYOM processing separately. Microsoft’s AI Builder billing guidance treats invoking a BYOM prompt as an agent action, without an extra text and generative AI tool processing charge. Other agent activities and licensing or test-panel exceptions can affect Copilot Credit charges.
flowchart TB
    accTitle: Which Foundry models fit bring your own model in Copilot Studio prompts
    accDescr: A model must serve the chat completions API, so Claude on the Messages API doesn't fit. GPT-5 and later models aren't supported. A model that passes both checks fits, but its retirement date should sit beyond your next review.
    M["Candidate Foundry model"]:::cs --> Q1{"Serves the chat
completions API?"}:::q Q1 -- "No, for example Claude
on the Messages API" --> N1["Doesn't fit the connector"]:::no Q1 -- "Yes" --> Q2{"GPT-5 family
or later?"}:::q Q2 -- "Yes" --> N2["Not supported
for prompts"]:::no Q2 -- "No" --> Q3{"Retires after
your next review?"}:::q Q3 -- "No" --> W1["Plan the replacement first
check the Foundry retirement date"]:::warn Q3 -- "Yes" --> Y1["Candidate for BYOM
verify support and test"]:::yes classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000 classDef q fill:#f1f5f9,stroke:#334155,color:#000 classDef yes fill:#dcfce7,stroke:#15803d,color:#000 classDef no fill:#fee2e2,stroke:#b91c1c,color:#000 classDef warn fill:#fef9c3,stroke:#a16207,color:#000

A narrow door. Foundry’s retirement schedule lists o1, o3, o3-mini and o4-mini for retirement on 19 November, and GPT-5 and later are excluded from BYOM prompts. GPT-4.1 and GPT-4o are candidates, but availability varies by version, deployment type and region. Their listed base-model retirement dates range from January to April 2027, so check and test the specific deployment before building on one.

Base modelVersionListed retirement
GPT-4o2024-05-1314 January 2027
GPT-4o2024-08-0614 April 2027
GPT-4.12025-04-1414 April 2027

These are Azure public cloud base-model dates, not a guarantee that every deployment type remains available until then.

Five owners, and where the platform team fits

On 11 November Microsoft published a governance map on the Copilot Studio blog, “Where do I govern my Copilot Studio agents?”, built around five outcomes, each led by a different admin in a different product:

  • Enable makers safely and at scale. The Power Platform admin, in the Power Platform admin center: environment strategy, environment routing, environment groups and rules, connector policies and sharing controls.
  • Configure agent identity and resource access. The identity and access admin, in Microsoft Entra: Entra Agent ID and Conditional Access for agents.
  • Protect information. The compliance admin and data security team, in Microsoft Purview: DSPM, sensitivity labels, DLP and audit.
  • Observability and business value. The AI admin, in Microsoft Agent 365: the registry, the agent map, tool governance and Copilot Credit cost management.
  • Detect and respond. The security admin and SOC, in Microsoft Defender: agent security posture and threat investigation.
flowchart TB
    accTitle: Who governs a Copilot Studio agent, and where the Foundry platform team fits
    accDescr: A Copilot Studio agent has five governance owners: the Power Platform admin, the identity admin in Entra, the compliance admin in Purview, the AI admin in Agent 365 and the security team in Defender. The AI platform team in Azure only joins for prompts that call its Foundry deployments.
    A["Copilot Studio agent"]:::agent
    A --> P["Enable makers safely
Power Platform admin"]:::m365 A --> E["Identity and access
Microsoft Entra"]:::m365 A --> PV["Protect information
Microsoft Purview"]:::m365 A --> AG["Observability and value
Microsoft Agent 365"]:::m365 A --> D["Detect and respond
Microsoft Defender"]:::m365 A -. "only for BYOM prompts" .-> F["Model calls in your Foundry
AI platform team in Azure"]:::az classDef agent fill:#cce5ff,stroke:#1f6feb,color:#000 classDef m365 fill:#ede9fe,stroke:#6d28d9,color:#000 classDef az fill:#e0f2fe,stroke:#0369a1,color:#000

The map has no Azure row. Microsoft’s five owners cover the agent itself. The platform team joins only for the prompts that call its deployments, which is the gap this post is about.

What moves to the platform team, and what doesn’t

With BYOM in place, the platform team can govern the deployment and the call that reaches it. That doesn’t give it control over the whole agent or conversation.

flowchart TB
    accTitle: What bring your own model moves to the platform team and what stays native
    accDescr: For prompt calls that reach Foundry, the platform team controls approved models and versions, where inference runs, guardrails, quota, logs, token cost, key rotation and retirements. Copilot Studio and Microsoft 365 admins keep the primary model, external model access, cross-region data movement, connectors and data policies, environments and sharing, agent identity, audit, registry and threat response.
    subgraph PLAT["Moves to the platform team, for BYOM calls only"]
      P1["Approved models and versions"]:::az
      P2["Where inference runs
deployment type and data zone"]:::az P3["Guardrails on each deployment"]:::az P4["Quota and rate limits"]:::az P5["Diagnostic logs and token metrics"]:::az P6["Token cost on your Azure bill"]:::az P7["Key rotation and model retirement"]:::az end subgraph NAT["Stays with Copilot Studio and Microsoft 365 admins"] N1["The primary model and orchestration"]:::cs N2["External models and
cross-region data movement"]:::cs N3["Connectors, knowledge and data policies
including the Azure AI Foundry connector"]:::cs N4["Environments, routing and sharing limits"]:::cs N5["Agent identity and Conditional Access"]:::cs N6["Audit, DSPM, registry and threat response"]:::cs end classDef az fill:#e0f2fe,stroke:#0369a1,color:#000 classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000

You govern the call, not the agent. BYOM gives the platform team real control over one model call. Everything a maker can change about the agent stays in Copilot Studio.

One lever on the native side is worth knowing. The Power Platform admin decides whether BYOM is allowed at all, because the connector is governed by data policies under the name “Azure AI Foundry”. I’d use that: allow the connector only in the environments where the platform team has agreed to host the model, and block it everywhere else.

Follow one prompt call

Here’s what happens when an agent uses a BYOM prompt, and where the evidence for each step lands.

sequenceDiagram
    accTitle: One prompt call from Copilot Studio to a Foundry deployment
    accDescr: A user asks the agent a question. The agent can call the prompt tool, which sends a chat completions request with an API key to the Foundry resource. Applicable guardrails act around the deployment. The result returns to the agent and may be passed through or used to form an answer. Available Copilot Studio and Azure evidence depends on configuration.
    autonumber
    actor U as User
    participant A as Copilot Studio agent
    participant P as Prompt with BYOM
    participant F as Foundry resource
    participant D as Your deployment
    rect rgb(237, 233, 254)
    U->>A: Asks a question
    A->>P: Primary model picks the prompt tool
    end
    rect rgb(224, 242, 254)
    P->>F: Chat completions request with the API key
    F->>F: Applicable input controls
    F->>D: Runs the model
    D-->>F: Completion
    F->>F: Applicable output controls
    F-->>P: Result and token usage
    end
    rect rgb(237, 233, 254)
    P-->>A: Prompt output
    A-->>U: Answer or prompt output
    end
    Note over U,A: Copilot Studio evidence: transcripts, analytics,
Purview audit, Agent 365, Copilot Credits Note over F,D: Azure evidence: diagnostic logs,
token metrics, Azure consumption

Two sets of evidence, one conversation. Foundry receives whatever the prompt sends, which can include a user’s question or other context. It doesn’t automatically see the entire conversation or orchestration. Available logs depend on diagnostic settings and supported model features, so an investigation may need evidence from both sides.

Where should that Foundry live?

Platform teams usually put two options on the table:

  • Option 1: a dedicated Foundry resource for Copilot Studio, in its own subscription.
  • Option 2: a project inside the shared AI platform’s Foundry resource.

Option 2 looks like the natural fit. Foundry projects give teams isolated workspaces that share model deployments under central governance, and Microsoft describes exactly that pattern. But BYOM changes the maths in three ways:

  1. The key is resource-wide. Learn puts it plainly: “Keys are all-or-nothing per resource.” A key that works for the Copilot Studio deployment works for every deployment in the resource, across every project, with no role restrictions.
  2. Key authentication has to stay on. BYOM only offers an API key, so the resource can’t set disableLocalAuth to true, and Learn describes API keys as “Generally not accepted by enterprise production workloads and not recommended by Microsoft.” On a shared platform resource, the whole platform goes back to accepting keys, the opposite of the keyless pattern I wrote about earlier this month.
  3. The endpoint has to stay reachable. The connector isn’t on Power Platform’s published virtual network support list. For this documented connector, plan for a reachable public endpoint and test network restrictions. That absence doesn’t prove that every possible private integration is impossible.

There’s more. The built-in Foundry User role includes permission to list keys when assigned at a scope covering the resource, as do some broader roles. Check effective assignments and inheritance rather than assuming every project user can list them. Guardrails can be attached per deployment, diagnostic settings are set per resource, and model router’s instant access (preview) is configured for the whole resource. Microsoft’s rollout guidance also recommends treating isolation as the production default.

flowchart TB
    accTitle: What the bring your own model key opens in each option
    accDescr: In option 2 a resource key can reach shared deployments and the documented connector needs a reachable network path. In option 1 the key is contained in a dedicated resource while the shared platform can keep its own keyless and private network configuration.
    subgraph O2["Option 2: project in the shared platform resource"]
      K2["BYOM API key"]:::key --> R2["Shared Foundry resource
key auth on, reachable endpoint"]:::bad R2 --> D2A["Copilot Studio project deployments"]:::az R2 --> D2B["Team A project deployments"]:::bad R2 --> D2C["Team B project deployments"]:::bad end subgraph O1["Option 1: dedicated resource"] K1["BYOM API key"]:::key --> R1["Copilot Studio Foundry resource
key auth on, reachable endpoint"]:::warn R1 --> D1A["Copilot Studio deployments only"]:::az S1["Shared platform resource
Entra ID only, private endpoints"]:::good end classDef key fill:#fee2e2,stroke:#b91c1c,color:#000 classDef bad fill:#fee2e2,stroke:#b91c1c,color:#000 classDef warn fill:#fef9c3,stroke:#a16207,color:#000 classDef az fill:#e0f2fe,stroke:#0369a1,color:#000 classDef good fill:#dcfce7,stroke:#15803d,color:#000

A key is a resource-wide pass. In a shared resource, the Copilot Studio key can reach other teams’ deployments and requires key authentication for that resource. A dedicated resource contains the exception.

The resource decision

Option 1, a dedicated resource: the BYOM key can reach that resource’s deployments, so keep only the intended workloads there. Key authentication and the required network exception are contained to that resource. Limit who can list keys, attach and test the applicable guardrails, and use resource-level costs for simpler attribution. A separate subscription gives it a separate quota pool, subject to availability and approval.

Option 2, a project in a shared resource: the key can reach other deployments in the resource, while key authentication and the reachable endpoint affect the shared resource. Review effective key-listing permissions, including resource-scoped Foundry User and Contributor assignments. Guardrails are configured per deployment, and quota is shared by subscription, region, model and deployment type. Cost attribution depends on available dimensions; the shared key doesn’t identify the caller.

For most organisations I’d pick Option 1. Option 2 needs a deliberate security review of key scope and network exposure, even if the shared resource already accepts keys.

Do you need the bridge at all?

Before either option, ask whether a prompt needs your model in the first place. Copilot Studio offers managed prompt models, and Microsoft has announced automatic migration for the prompt models retiring in December.

flowchart TB
    accTitle: Deciding whether a Copilot Studio prompt needs bring your own model and where to host it
    accDescr: If a managed prompt model does the job, use it with no Foundry. If the prompt needs a specific model that fits bring your own model, host it in a dedicated Foundry resource deployed from the platform template with a time-bound key authentication exemption. If the model doesn't fit, call it as a tool through a connected Foundry agent or an API.
    S["A prompt needs a model"]:::cs --> Q1{"Does a Copilot Studio managed
prompt model do the job?"}:::q Q1 -- "Yes" --> A1["Use it, no Foundry needed"]:::good Q1 -- "No, it needs a specific model
such as an open-weight one" --> Q2{"Does that model
fit BYOM?"}:::q Q2 -- "No" --> A2["Call it as a tool
connected Foundry agent or an API"]:::warn Q2 -- "Yes" --> A3["Dedicated Foundry resource
from the platform template"]:::good A3 --> A4["Platform policies apply
key auth exemption with an owner and an end date"]:::good classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000 classDef q fill:#f1f5f9,stroke:#334155,color:#000 classDef good fill:#dcfce7,stroke:#15803d,color:#000 classDef warn fill:#fef9c3,stroke:#a16207,color:#000

Use the bridge only when you need it. BYOM earns its place when a prompt needs a model Copilot Studio doesn’t offer, such as an open-weight or industry model. Managed models can reduce deployment work, although you still need to test migrations. The Foundry agent service uses Entra ID rather than API keys; a connected agent is a different integration, with its own identity and permission configuration.

Who runs the dedicated Foundry

Dedicated doesn’t mean ungoverned. I’d place the resource in the AI landing zone, deploy it from the platform team’s template and apply the relevant management group policies, including the built-in policy for approved model deployments. The documented connection requires key authentication, so a policy that disables local authentication needs a reviewed exception. If the tested network path requires public access, review that exception too. Give each exception an owner and expiry, and track renewal alongside key rotation.

The AI platform team owns the template and its guardrails, using infrastructure as code, approved-model policies and central diagnostics.

The Copilot Studio platform team owns the subscription, deployments and connection. It requests models through the platform’s approval path and manages key rotation and connector data policy.

The security team reviews exceptions and monitors key listing and unusual token use.

Approving and retiring models on two calendars

Copilot Studio and Foundry retire models on different calendars, and BYOM puts you on both.

On the Copilot Studio side, Microsoft runs the calendar. Its standard harness documentation lists 12 November retirement dates for GPT-4.1, GPT-4.1 Mini, GPT-5 Chat, GPT-5 Auto and GPT-5 Reasoning as primary models, with extensions of up to 30 days and GPT Chat Latest as the replacement. FedRAMP tenants, and environments outside the US that restrict cross-region data movement, have an exception for GPT-4.1 and GPT-5, so check your environment’s setting. On the Microsoft Copilot harness, the EU and EFTA exception for GPT-5 Chat ends on 30 November. Affected managed prompt models move automatically by 2 December to GPT-6 Luna, ChatGPT-latest or GPT-6 Reasoning, depending on their tier.

On the Foundry side, you run the calendar. A BYOM prompt points at a named deployment and base model, so swapping the model should be a change you make and test. Plan it before the retirement date: Foundry can upgrade some deployments automatically at retirement, and gpt-4o version 2024-05-13 on Global Standard and Data Zone Standard moves to gpt-5.1, which BYOM doesn’t support. Foundry retired the o-series on 19 November and has GPT-4o and GPT-4.1 on its retirement schedule for January to April 2027.

This month’s headline model shows why the line matters. Claude Fable 5.2 started rolling out in Copilot Studio on 11 November, through Microsoft’s own model list. It appears on the Microsoft Copilot harness list behind the “Anthropic models with data retention” provider setting, which is off by default. A Microsoft 365 admin turns that on, and a Power Platform admin still has to allow the provider’s models for each environment or environment group. Deploying Fable 5.2 in your own Foundry doesn’t change that. BYOM can’t call a Claude deployment directly, because Claude in Foundry uses the Messages API, and Foundry doesn’t apply built-in content filtering to Claude models anyway. “Govern it through our Foundry” simply doesn’t apply to the model everyone’s asking about this month. The decision sits with the Microsoft 365 admin, the Power Platform admin and your model approval board.

flowchart TB
    accTitle: Two meters for one Copilot Studio agent
    accDescr: An agent conversation creates Copilot Credit usage, tracked in Power Platform and in Agent 365 Cost Management in preview, and BYOM prompt tokens billed as Azure consumption to the Foundry resource's subscription and tracked in Azure Cost Management. Both feed a showback to the business unit.
    C["Agent conversation"]:::cs --> CC["Copilot Credits
agent messages and actions"]:::cs C --> AZ["Azure consumption
BYOM prompt tokens"]:::az CC --> V["Agent 365 Cost Management, preview
spending policies, limits and alerts"]:::cs AZ --> CM["Azure Cost Management
budgets on the dedicated resource"]:::az V --> SB["Showback to the business unit"]:::good CM --> SB classDef cs fill:#ede9fe,stroke:#6d28d9,color:#000 classDef az fill:#e0f2fe,stroke:#0369a1,color:#000 classDef good fill:#dcfce7,stroke:#15803d,color:#000

Two meters for one agent. Foundry model processing and eligible Copilot Studio activity are accounted for separately. A dedicated resource makes the Azure half easier to attribute; check the current licensing rules and your actual usage for the Copilot Studio half.

What Ignite changed

The Ignite announcements also cover governance and operational capabilities relevant to this design:

  • Agent 365 Cost Management (preview) covers usage-based services including Copilot Studio, with spending policies, limits, alerts and chargeback.
  • Agent 365 usage and activity insights are generally available, without an Agent 365 licence, for agents built on Microsoft platforms.
  • Dynamic Agent Risk (preview) sits alongside the agent registry, visible across the Microsoft 365 admin center, Defender, Entra, Intune and Purview.
  • Conditional Access policy plans (preview) arrive in Entra to simplify policy management at scale.
  • Model router support in AI Gateway lands on the Foundry side.

Nine go-live checks

  1. The agent stays on the standard harness. Any move to the Microsoft Copilot harness has a plan for the prompt first, because that harness has no prompt tool.
  2. The model fits. It serves chat completions, it isn’t GPT-5 or later, and its Foundry retirement date sits beyond your next review, with the replacement planned before Foundry can upgrade the deployment for you.
  3. The resource is dedicated. Its key opens only Copilot Studio’s deployments, and its policy exemptions have an owner and an end date.
  4. Roles are tight and keys rotate. Only the people who manage the connection can list keys. Regenerate the key the connection isn’t using, move the connection to it, then regenerate the other one.
  5. Instant access is reviewed. Model router’s Auto option (preview) is set per resource. Microsoft’s router reference says an empty properties.instant.modelAllowList turns off instant access, including Auto. Check the effect on other instant-access models and test this preview setting; deployed models and other access paths still need governance.
  6. Guardrails are assigned and tested. The prompt’s own moderation setting doesn’t apply to Foundry models. Check the controls supported by the selected model and API rather than assuming uniform coverage. For supported text calls, a request can override the deployment guardrail using x-policy-id; Microsoft’s guardrail guidance notes that this override isn’t available for image input. Review the policies available in the resource.
  7. The connector is allowed only where it should be. The data policy allows “Azure AI Foundry” in the environments that host approved BYOM prompts and blocks it elsewhere, and the connection holding the key is shared only with the makers who own those prompts.
  8. The network path is a decision. Test whether the documented connector can reach the endpoint with your network rules and Power Platform’s current outbound IP ranges. An API Management URL or private path is a lab test, not a design assumption, because the connector is documented for Foundry endpoints.
  9. Both meters and both logs are wired. Azure budgets and diagnostic logs on the Foundry resource, and Copilot Credit tracking and Purview audit on the Copilot Studio side.

My take

I like BYOM for what it is: a way to put a specific model, such as an open-weight or industry model, behind a single prompt, with applicable platform controls on that call. What it isn’t is a way to govern the whole Copilot Studio agent. Its orchestration, identity and sharing still need the controls in Microsoft’s governance map.

Where I push back is the reflex to drop Copilot Studio into a project on the shared platform because it looks tidy on a diagram. The documented BYOM connector needs a key, and a key turns a project boundary into a resource-wide pass. I’d rather run a dedicated Foundry resource with a reviewed key and network exception than reopen the whole platform. It’s the keyless argument from earlier this month applied the other way round: when you can’t remove an exception, contain it.

Two caveats. First, the bridge is narrow and it’s narrowing: no GPT-5 or later, no Claude, no Entra ID, and the GPT-4.1 and GPT-4o models that fit retire in 2027, while new models such as Fable 5.2 arrive on a harness with no prompt tool. Second, the connector is documented for Foundry endpoints only, so an AI gateway in this path is something to prove in a lab before you promise it to anyone.

If I were setting this up today, I’d keep BYOM for the few prompts that genuinely need a model of our own, govern everything else where Copilot Studio governs it, and look again after the next round of harness and model updates.

Key takeaways

  • Copilot Studio can call Foundry models from a BYOM prompt on the standard harness. Its primary orchestration model is selected separately.
  • BYOM gives the platform team control of the call: model version, region, guardrails, quota, logs and token cost.
  • Agent governance and evidence span Power Platform, Microsoft 365, Entra, Purview and Defender. Prompt data sent to Foundry also reaches the deployment.
  • The connection is chat completions with an API key: no GPT-5 or later, no Claude and no Entra ID.
  • Foundry keys are resource-wide, so a project in a shared resource exposes every deployment. Use a dedicated resource with time-bound policy exemptions.
  • Plan for two calendars and two meters: check Copilot Studio model migrations, manage Foundry deployments, and account for Azure processing and eligible Copilot Credit activity separately.

References

Image Credits

  • Cover image generated by Copilot
Author

Ricky Gummadi

Posted on

2026-11-18

Updated on

2026-11-22

Licensed under

Comments

Choose your design

Only the look changes. Your posts, ads, comments and other integrations stay in place, with the same light/dark and cookie preferences.

Choose the look you prefer