What Microsoft Copilot with Salesforce gives you today
Salesforce and Jira are each a distinct connector in Elaichi's catalog, reached through one endpoint. What a person may do comes from their own OAuth grant plus their role's restrictions. Microsoft Copilot with Salesforce and Jira takes a different shape: synced Copilot connectors index both apps into Microsoft Graph for search and grounding.
Your company runs on Microsoft 365. Sales works in Salesforce, engineering works in Jira, and somebody has asked whether Copilot can cover both. The indexed path is built for finding things, not for taking live action inside either app. A separate path, using MCP (Model Context Protocol) tools from clients like Claude, ChatGPT, Cursor or a Copilot Studio agent, covers the live-action case. This post lays out both, with a comparison table and the specific permission and audit behavior each one gives you.
Every Microsoft claim below links the Microsoft Learn page it came from, checked October 2026, and anything marked preview or planned had not shipped then.
The four paths at a glance
| Path | What it does | Freshness | Writes to Salesforce or Jira | Where the control sits |
|---|---|---|---|---|
| Synced Copilot connectors | Index Salesforce CRM and Jira Cloud into Microsoft Graph for search and grounding | Permission changes sync only on full crawls | No | Default mode honors source permissions; admins choose which fields are indexed |
| Federated (MCP) connectors | Fetch live as the signed-in user | Live | No: Salesforce and Jira are not on the list today | Published by Microsoft or approved partners |
| Copilot Studio agents | Add MCP servers as tools and call them | Live | Yes, where an MCP server exposes those tools | Power Platform data policies and advanced connector policies, per connector or whole MCP server |
| Elaichi | Serves Claude, ChatGPT, Cursor and Copilot Studio agents through one MCP endpoint, each call as the person | Live | Yes | Restrictions per role or user, down to one tool, and one audit trail |
The column that matters most is writes: a Copilot Studio agent writes to Salesforce or Jira only through an MCP server that exposes those tools, which is what Elaichi serves.
Who approves each path, and whose permissions apply
The three paths differ on one question: whose permissions decide what a call reaches. Here is each one side by side, with the admin step it needs.
| Synced Copilot connectors | Copilot Studio connectors | Elaichi's MCP endpoint, from a Copilot Studio agent | |
|---|---|---|---|
| Actions in Salesforce or Jira | No. Indexes both apps into Microsoft Graph for search and grounding (learn.microsoft.com, checked October 2026) | Through an MCP server the agent adds as a tool (learn.microsoft.com, checked October 2026) | Yes, as connected tools over MCP |
| Whose permissions apply | The source app's, in the default mode: Salesforce record ownership, sharing rules and role hierarchy, with field-level security not enforced on opted-in fields (learn.microsoft.com, checked October 2026) | The end user's by default, through end-user credentials; maker-provided credentials run as the maker for every user (learn.microsoft.com, checked October 2026) | Each person's own, through their own OAuth grant and their own Salesforce and Jira connections |
| Freshness of permissions | Permission changes sync only on full crawls (learn.microsoft.com, checked October 2026) | Evaluated at the call; a restriction change takes effect within about two minutes | |
| What an admin approves | Which fields are indexed, and the access setting on the connector (learn.microsoft.com, checked October 2026) | The connector, through Power Platform data policies or a default-deny advanced connector policy per environment or group (learn.microsoft.com, checked October 2026) | The whole MCP server, at the same Power Platform layer, plus Elaichi's own restrictions per role or per member |
| Finest unit of control | The indexed field | The connector; per-tool MCP control is not available in advanced connector policies (learn.microsoft.com, checked October 2026) | A single tool, in a restriction written on a role or a member |
The product team confirmed on 2026-10-21 that Microsoft Copilot reaches Elaichi through a Copilot Studio agent that adds the MCP endpoint as a tool, with OAuth set to Dynamic discovery. Sign-in and connected tools work. Microsoft Copilot is not a client Elaichi verifies, so its entry shows the name the client registered for itself.
Microsoft has renamed Microsoft 365 Copilot to Microsoft Copilot, and Graph connectors are now Copilot connectors. Synced Copilot connectors index Salesforce CRM and Jira Cloud into Microsoft Graph, and Copilot answers from that index (learn.microsoft.com, checked October 2026).
Federated connectors are Microsoft's live-read path. They fetch as the signed-in user at query time, and they are published by Microsoft or approved partners. Salesforce and Jira are not on that list today (learn.microsoft.com, checked October 2026).
The practical line falls here. "Find the renewal notes on the Acme account" is what the indexed path is for. "Create the renewal opportunity and link the Jira epic" is not. No Copilot connector, synced or federated, writes to either app today.
Why permission sync is not the same as live permissions
Synced Copilot connectors do honor the source app's permissions. The point to hold onto is that Microsoft Graph holds a copy, and a copy has a refresh schedule. It is not a window onto Salesforce or Jira, it is a snapshot of one.
Microsoft's own page for the Salesforce CRM connector states three specific behaviors. The default mode honors Salesforce record ownership, sharing rules and role hierarchy. Field-level security is not enforced if an admin opts in to index restricted fields. And permission changes sync only on full crawls, not incrementally (learn.microsoft.com, checked October 2026).
For an IT admin, that becomes two decisions, each made once and reviewed rarely: which fields get indexed, and how often a full crawl runs. A sharing change made in Salesforce on Monday reaches Copilot search only when the next full crawl runs. Check the connector's full-crawl schedule rather than assuming one.
A live call has no such lag, because it has no copy to go stale. Federated connectors and MCP-based tools evaluate permissions at the moment of the call, every time, against the source system directly. That gap is scheduled refresh versus per-call evaluation. It is the reason to pick one path for search and a different one for action, rather than forcing a single connector to do both.
Where do Copilot Studio and Agent 365 fit?
Copilot Studio is Microsoft's action path, and its governance is written per environment and per connector rather than per tool. Copilot Studio agents can add MCP servers as tools (learn.microsoft.com, checked October 2026). Each tool runs on end-user credentials by default, with maker-provided credentials as an option an admin can forbid per environment (learn.microsoft.com, checked October 2026).
Elaichi's endpoint is one such MCP server. A maker adds https://api.elaichi.ai/mcp at Tools, Add a tool, New tool, Model Context Protocol, picks OAuth 2.0 with Dynamic discovery, and publishes the agent to Microsoft Copilot. On end-user credentials, each person signs in to Elaichi with their own account, so the calls run as them.
Governance rides on Power Platform, through two separate mechanisms that don't talk to each other:
- Data loss prevention (DLP) policies sort connectors into Business, Non-business and Blocked. Changes usually apply within an hour, and Microsoft's documented upper bound is 24 hours (learn.microsoft.com, checked October 2026).
- Advanced connector policies are a default-deny allowlist per environment or group. They can block a whole MCP server, but Microsoft states explicitly that per-tool MCP control is not available at this layer (learn.microsoft.com, checked October 2026).
The practical effect: one MCP server may expose both a read tool and a delete tool. The policy layer allows or blocks the server as one unit. A maker can switch off single tools inside one agent. That is a build choice per agent, not an admin policy (learn.microsoft.com, checked October 2026). When the agent's MCP server is Elaichi, the per-tool rule moves to Elaichi's restrictions, written per role or per person.
Agent 365 has been generally available since 1 May 2026. It is priced at $15 per user per month, or bundled into Microsoft 365 E7 (microsoft.com, checked October 2026). Its tooling gateway for registered MCP servers is in preview. Admins can approve or block servers at runtime today. Microsoft has stated tool-level blocking for those servers is planned but not shipped (learn.microsoft.com, checked October 2026). The side-by-side of Copilot Studio and an MCP gateway goes through that surface in more detail.
How Claude, ChatGPT and Cursor reach Salesforce and Jira live
The second path puts the live call in the AI client people already have open, with no indexed copy in between. That includes Microsoft Copilot, through a Copilot Studio agent that adds Elaichi's endpoint as a tool; Power Platform still decides whether that agent may use the server. MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps.
Elaichi serves one organization-wide MCP endpoint, POST https://api.elaichi.ai/mcp, behind OAuth (the sign-in standard that hands an app limited access without a shared password). There are no per-user URLs and no embedded tokens to manage or rotate. An admin adds the one address to each client where the client allows it. Each member then connects and signs in with their own grant. Clients register themselves through dynamic client registration, so there is no client ID or secret to distribute by hand.
Salesforce and Jira are both connectors Elaichi wrote, in its catalog of 900+ connectors. Elaichi authors and serves them, rather than proxying them through a third-party integration platform. A rep connects their own Salesforce account; an engineer connects their own Jira account. Every read and every write then reaches the app as that person, evaluated live by Salesforce or Jira's own permission system. There is no index in between to go stale. A connection shared with a team runs on its owner's credential. Share one only where every person using it should be able to act as that single account.
Tool discovery works differently from a plain, flat server list, which matters once you connect more than one app to the same client. In Elaichi, connected tools are never listed one by one, however few there are. The model finds what it needs and calls it. That keeps a two-app rollout from filling the context window with every available tool on the first message. When a tool somebody expected is missing, the checks run in a fixed order.
One trade-off to state plainly, because it affects what "read-only" means in practice. On Elaichi's consent screen, the single permission "Use your connected apps" covers a connected app's reads, writes and deletes alike. The "Delete things" box covers only Elaichi's own deletes, and it is never pre-ticked. There is no checkbox for "read-only" at connection time. Read-only access to Salesforce or Jira is something you write as a restriction afterward. It is not something a user selects when they first connect.
What does per-app and per-tool control look like?
Per-app and per-tool control is written as restrictions: restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. Keeping a team off a tool means writing the rule on their role, or on each member. One rule can name whole connectors, single tools, or both, so Salesforce and Jira can sit in the same rule or in separate ones.
Three behaviors decide what a rule actually does:
- A block always beats an allow within a layer. A broader allow never quietly reopens a blocked tool.
- An allow rule that names nothing blocks every connector and tool for its target. An empty placeholder rule is a lockout, not a harmless draft.
- A rule aimed at a member can only narrow what their role allows, and never replaces or loosens a role rule.
Timing matters when you defend the setup to security or an auditor. A restriction change takes effect within about two minutes, on the MCP endpoint and in the console alike. Removal is faster. In Elaichi, removing or suspending a member revokes every live grant in the same transaction as the membership change.
Writing restrictions for two apps at once
The trap with two apps is the allow rule. An allow rule is the target's entire allowlist, across every connector the target can see, not only the app it names. Write an allow rule to hold Jira to its read tools, and the role loses Salesforce entirely. The fix is a second allow rule naming Salesforce too. Allow rules on the same target union together, so one allow rule per app is the correct pattern once you know this. Holding a single app to reads while leaving every other connector untouched is done differently. Use blocks on that one app's write tools, not an allow rule at all. The per-tool against per-app decision covers the six cases where each shape is the right one.
What the audit trail records for both apps
Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none). That holds across Salesforce and Jira alike. The recorded connection is the account actually reached, taken from the execution rather than the intent. That answers "which Jira site did it write to" without reconstructing it from context.
Each entry carries the operation and tool name, plus the surface and the OAuth client the call came through. It also carries whether it was approved, the outcome, and an error code. It carries the one path argument that names the object as the target id, and no other argument value. A call made from Claude or Cursor is recorded as a user action, attributed to the person who made it, not to "the assistant."
One more distinction: the error text returned to the caller is derived from the third party's response, Salesforce's or Jira's own error message. The error written to the audit trail is not the same string. Audit records are org-visible and may fan out to a customer's own logging destination. So what is written there is an error code, never derived from Salesforce's or Jira's response.
On plans: the audit trail is on Elaichi's Gold plan. Beyond that, export to your own Datadog comes with the Black plan.
When the Microsoft path is the right answer
Say your people work in Teams, Outlook and Word, and what they want is to find things. Then the synced Copilot connectors are the complete and correct setup. The index honors source permissions in its default mode, you control which fields are indexed, and there is no second vendor in the call path. Adding anything else buys you nothing for a pure-search use case.
The Microsoft path is also right when the action you want is a Copilot Studio agent running inside Power Platform. Those agents are built and governed by the admins who already run environments and DLP policies. That fits especially well if your makers are already building there. The same agent can still add Elaichi as an MCP tool when you want per-tool rules and one audit trail across clients.
The second path earns its place when three things are true at once. People act from more than one client, such as Claude, ChatGPT or Cursor beside Microsoft Copilot. They need live reads and writes in Salesforce and Jira, as themselves, not through a shared service account. And you want the permission decision written once, per role, down to a single tool. One audit trail then covers both apps, instead of two separate connector logs.
Elaichi has three plans: Personal, which is free, then Gold and Black. Gold lists at $15 per user per month in USD, or $10 per user per month billed annually; pricing shows the local figure. 14-day Black trial, no credit card to start. Buying Gold or Black during the trial keeps its remaining days rather than granting a fresh 14, so it is one continuous trial, and the seats are first charged when it ends. A workspace that buys nothing moves to the free Personal plan. Disclosure: Elaichi, the MCP control plane described as the second path above, publishes this blog. The comparison table and Microsoft-side claims are sourced independently from Microsoft's own documentation, linked throughout.
For the wider shape of this category, read what an MCP control plane is. For the team-level walkthroughs behind this post, see giving each rep their own Salesforce access in ChatGPT. There is also rolling Cursor out to an engineering team on Jira. The full connector catalog lists what else is reachable from the same address.