Why connect Outlook to Claude one mailbox per person?
A mailbox holds every private thread a person has, so Claude should open only the mailbox of whoever is asking. Jake Morgan runs IT at a 300-person company that is rolling out Claude. The first request comes from finance: can Claude read Outlook and draft replies? Priya Shah should see Priya's mail, and never the CFO's. Jake also has to decide whether Claude may send mail at all, or only draft it. To connect Outlook to Claude for a whole company, settle those two questions first. Whose mailbox does each call reach, and which mail actions does each role keep?
MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps. Elaichi gives Claude, ChatGPT, Cursor and Microsoft Copilot one MCP address, https://api.elaichi.ai/mcp. Behind it, Elaichi's Outlook Mail connector calls Microsoft Graph, Microsoft's API for mail and other Microsoft 365 data. The connector signs in one of two ways: OAuth as a person, or OAuth client credentials as an app. That choice decides whose mail a call can reach.
Delegated or application access: what Microsoft Graph decides
Microsoft Graph sets the outer wall. With delegated access, an app acts for a signed-in user and cannot reach anything that user could not reach. With app-only access, the app uses its own identity and no user signs in (Microsoft Learn: permissions overview, checked November 2026). Microsoft's client credentials page says an app signing in as itself must use application permissions (Microsoft Learn: client credentials flow, checked November 2026).
The mail permissions show how far apart the two are. This table follows the Graph permissions reference (checked November 2026).
| Permission | Delegated reach | Application reach | Admin consent required |
|---|---|---|---|
| Mail.ReadBasic | The signed-in user's mail, without body, preview or attachments | The same fields in all mailboxes | Application only |
| Mail.Read | The signed-in user's mailbox | All mailboxes | Application only |
| Mail.ReadWrite | Create, read, update and delete mail, without sending | The same in all mailboxes | Application only |
| Mail.Send | Send mail as a user | Send mail as any user | Application only |
Read and send are separate grants. The permissions reference notes that Mail.Send can send and save a copy to Sent Items without Mail.ReadWrite (checked November 2026). Microsoft's list-messages reference names two cases: the app holds application permissions, or the other person shared a folder or gave delegate access (Microsoft Learn: list messages, checked November 2026).
One Outlook connection per person, or one shared connection?
Per person is the shape for "only their own mailbox". Each employee connects the outlook connector with their own Microsoft sign-in and leaves it unshared. Every call through a connection uses that connection's credential, so Priya's calls run as Priya in Graph. She reaches her mailbox and anything already delegated to her, and nothing else.
To save setup, share a template at use. A template is a named list of tool entries that stores no connection. Each employee stamps their own toolbox from it and picks their own Outlook connection. A single toolbox shared with the team cannot do this, because its entries run only on the connection pinned in them.
The message tools take a required user_id, and the model fills it in. To keep it on the caller's own mailbox, lock user_id in the template's entries to the caller's email, the per-person value caller.email. Each stamped toolbox copies the lock. Graph names a mailbox by user id or user principal name (Microsoft Learn: list messages, checked November 2026). So the lock works where each person's email matches their sign-in name.
Two shared shapes go wrong in different ways. A shared OAuth connection runs on its owner's sign-in for everyone. If Jake connects Outlook and shares it at use, every teammate reads Jake's inbox and sends as Jake. A shared client-credentials connection uses application permissions. With application Mail.Read and Mail.Send, it can read every mailbox and send as any user (Microsoft Learn: permissions reference, checked November 2026). Most of the connector's message tools take a required user_id, so the model picks whose mailbox to open.
If a company still wants the app route, two controls narrow it. The same caller.email lock goes on a toolbox entry, and in Elaichi, a freeze binds only calls made through its toolbox entry, so share the toolbox with the people it governs, not the connection itself. A caller with no value is refused before anything reaches Microsoft. Leave out tools with no user_id, such as outlook_messages_forward, because nothing locks their mailbox. The lock also binds only calls made through that toolbox entry. The connection's owner still reaches every mailbox, unlocked, through their own All tools toolbox.
Microsoft does not see that lock: to Graph, every call is the app. Exchange RBAC for Applications can limit the app to a set of mailboxes on Microsoft's side. Microsoft warns that a scoped grant adds to any unscoped Entra grant, so remove the Entra grant. Changes there take 30 minutes to 2 hours (Microsoft Learn: RBAC for Applications, checked November 2026).
Which Outlook tools read, and which ones act
The connector's mail reads cover messages, folders, search and attachments. The tools that draft, send, reply, forward, move or delete change a mailbox or reach people outside it. Elaichi tiers each tool as read, write or destructive.
| What it does | Example tools | Elaichi tier |
|---|---|---|
| Read mail and folders | list_all_outlook_messages, get_single_outlook_message_by_id, list_all_outlook_folder_messages, list_all_outlook_mail_folders, list_all_outlook_search |
Read |
| Read attachments | list_all_outlook_attachments, outlook_attachments_download |
Read |
| Draft | create_a_outlook_message, update_a_outlook_message_by_id |
Write |
| Send | outlook_messages_send_mail, outlook_messages_send_draft |
Write |
| Reply and forward | outlook_messages_reply, outlook_messages_reply_all, outlook_messages_forward, outlook_messages_forward_as_user |
Write |
| File mail | outlook_messages_move, create_a_outlook_mail_folder |
Write |
| Delete | delete_a_outlook_message_by_id, delete_a_outlook_mail_folder_by_id, delete_a_outlook_child_folder_by_id |
Destructive |
| Notifications | create_a_outlook_subscription |
Write |
A reply is not a safer send. The reply tool, outlook_messages_reply, accepts recipients that add to or override the original ones, so a reply can go anywhere. The draft tool, create_a_outlook_message, only creates a draft, and outlook_messages_send_draft sends it. The subscription tool posts change notifications to a URL the caller supplies, so restrict it for every mail role. The directory tool, list_all_outlook_users, lists the company's users rather than any mailbox.
Mail is text from outside the company, and a message can carry instructions aimed at the model. Elaichi's MCP endpoint is not protected against injected instructions. What the rules control is what a poisoned email could trigger. With send, reply and forward restricted, reading a message cannot become an outbound Outlook message through Elaichi.
How does IT choose read, draft or send for each role?
IT writes the choice as restrictions on roles. A restriction is a rule naming which connectors and which individual tools a target may reach. In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. Each member holds exactly one role, so the mail tier follows the role.
Read only. Write an allow rule naming the read tools above. In Elaichi, once a role carries any allow rule, every connector and tool none of its allow rules names is blocked for that role. So the same rule, or a second allow rule on the role, must name every other app the team uses as whole connectors.
Draft. Add create_a_outlook_message and update_a_outlook_message_by_id to the allow rule, and nothing that sends.
Send. Allow the send, reply and forward tools as well, outlook_messages_forward included. Keep block rules on the delete tools and create_a_outlook_subscription. Within a layer, a block always beats an allow, so a later widening of the allow rule leaves them restricted.
Block rules alone work differently. In Elaichi, a layer with only block rules has no allowlist, so everything it does not block passes it. A block-only read tier must name every Outlook tool that is not a read. Any role or restriction change takes effect within about two minutes. Per-tool versus per-app rules compares the two shapes.
When Priya later needs to send, she files an access request. An admin approves it in the console under Governance, then Access requests. The grant lifts that one tool for her alone, and her role is not edited.
Who approves the Microsoft consent?
For per-person sign-in, the tenant's consent settings decide. Microsoft says users can, by default, consent to permissions that need no administrator, such as access to their own mailbox (Microsoft Learn: configure user consent, checked November 2026). Tenant consent policies can still restrict that (Microsoft Learn: permissions overview, checked November 2026).
Where users cannot consent, an Entra admin grants tenant-wide consent. A Privileged Role Administrator can do it for any permission. A Cloud Application Administrator, AI Administrator or Application Administrator can too, except for Graph application permissions. Tenant-wide consent opens the app to all users, unless the admin requires user assignment and assigns chosen users or groups (Microsoft Learn: grant admin consent, checked November 2026).
The app route always needs an admin. Only a Privileged Role Administrator or Global Administrator can consent to application permissions (Microsoft Learn: permissions overview, checked November 2026). Which permissions the connector's own sign-in asks for is shown on the consent screen, so have the Entra admin read it there. When Claude says admin approval is required covers what to send that admin.
Test the rollout from one employee's account
Test from a member account on each role before announcing anything. Add the endpoint in Claude by following the Elaichi setup guide for Claude. Each person signs in with their own OAuth grant, the browser approval that ties their Elaichi identity to that client. Then, as a read-only member, ask for this morning's unread mail.
Next, search for "send" and "forward". A restricted tool is left out of the tools Elaichi offers a client and cannot be called. Search still names it, flagged restricted, with no schema. Then ask for a colleague's mailbox by address. Through a stamped toolbox, the lock keeps user_id on the caller's own mailbox. Through the All tools toolbox, Graph should refuse unless that colleague shared a folder or gave delegate access (Microsoft Learn: list messages, checked November 2026).
Then read the audit trail. Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none). In Elaichi, a call from an MCP client is recorded under the person who signed in, with surface mcp and the OAuth client named. Each entry also keeps the one path argument that names the object, as the target id, and nothing else about the arguments.
Offboarding stays simple with per-person connections. In Elaichi, a private connection that nothing beyond the member depends on cannot be transferred and is deleted with them. Also in Elaichi, removing or suspending a member revokes every live grant in the same transaction as the membership change. The person's Claude then fails on its next call.
When Claude's own Microsoft 365 connector is enough
If Claude is the only AI client and Outlook is the main app, Anthropic's own connector may be enough. Its Microsoft 365 connector covers Outlook, SharePoint, OneDrive and Teams on every Claude plan. It uses delegated permissions and is read-only by default. Its write tools send email and manage drafts. They use an updated permission set that includes Mail.Send and Mail.ReadWrite. An admin sets each one to Always allow, Needs approval or Blocked (Anthropic: set up the Microsoft 365 connector, checked November 2026).
Elaichi earns its place when the answer must hold across clients and apps. One endpoint serves Claude, ChatGPT, Cursor and Microsoft Copilot. One set of role rules covers Outlook beside the CRM and the help desk, and one audit trail shows who asked what. The same per-person pattern for Google mail is in Gmail and Calendar for ChatGPT. For one person trying a few prompts, a control plane can wait. Browse the 900+ connectors for the rest of the stack.