You are the person asked to make AI useful here, and the pile on your desk is other people's workarounds. Sales pastes pipeline notes into ChatGPT. An engineer runs a Jira server on a laptop for Cursor. HR asks whether Claude can read Rippling. MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps. To roll out Claude and ChatGPT to employees, you replace that pile with one path the company owns, and IT is a partner in that work rather than its sole owner.
How do you roll out Claude and ChatGPT to employees without a server per person?
Connect each approved app once, behind one organization-wide endpoint, and let each person sign in to it from their own client. Then decide reach with team sharing, roles and restrictions, and check the result in the audit log.
Elaichi is built for that path. Claude, ChatGPT, Cursor, Microsoft Copilot and any other MCP client all reach the same address, https://api.elaichi.ai/mcp. There are no per-person URLs, tokens or servers. Each member still connects once and signs in with their own OAuth grant, the revocable permission a client receives at sign-in. For the engineering case, see what happens when engineers already have ChatGPT.
How do you stop employees pasting company data into ChatGPT and Claude?
Give them a governed way to reach the same apps. Connect each approved app once in Elaichi, and point ChatGPT and Claude at the one organization endpoint. Employees then reach the app through their own sign-in, so they have no reason to paste exports into a chat. Each call runs as the person who approved the grant, roles and restrictions decide which connectors and tools it may reach, and the audit log writes an entry for each call that runs. Each person's own permissions in the app still apply to their own connection. Why people paste in the first place shows what to replace first.
What should an employee AI usage policy cover when staff already pay for ChatGPT and Copilot?
A usage policy should cover six things: which AI accounts count as company tools, what may be typed into a chat, which apps AI may reach, who approves a new app, what is recorded, and what happens at exit. Elaichi can enforce the last four. The first two are rules for people, since Elaichi sees neither staff-paid accounts nor chat text.
- Company accounts. Say whether a staff-paid ChatGPT or Copilot account may touch company data, and name the company route that replaces it. A ban with no alternative sends the use out of sight.
- What goes in a chat. Name the data that stays out, such as customer lists and credentials. Stopping credential pastes covers the device control that checks the paste.
- Which apps AI may reach. In Elaichi, write an allow rule for each role that names the approved connectors. A connector the rule does not name is refused.
- Who approves a new app. A member who needs a restricted app can file an access request, and an admin decides. Creating a custom connector needs the connector:create permission, held by Org Owner and Org Admin.
- What is recorded. Elaichi writes one audit entry for each connected-tool call that runs, and keeps 90 days.
- When someone leaves. Removing or suspending a member stops their clients on the next call.
A thread on r/ITManagers asks what such a policy should say. If nobody connects AI to company apps, two lines on accounts and data may be the whole policy.
What order should the rollout run in?
Five steps, in this order: pick the apps, connect the accounts, build a toolbox per team, set the restrictions on each role, then point people at one endpoint. Run them out of order and you hand out reach before anyone has decided it.
- Pick the apps. Name the apps each team actually works in, and mark each one approved for everyone, approved for one department, or not yet. This is the enablement lead's call, made with the team that uses the app.
- Connect the accounts. Connect each approved app once in Elaichi. Keep a company account private where only one person should act as it, and share it at
useonly when the whole team is meant to act as that account. - Build a toolbox per team. Pin the tools a team needs into a toolbox, or build a template the team stamps against each person's own account. Give the tools the team's own names.
- Set the restrictions on each role. Allow the approved connectors for each role, and block the destructive tools that role does not need.
- Point people at one endpoint. Give everyone
https://api.elaichi.ai/mcp. Claude, ChatGPT, Cursor and Microsoft Copilot all sign into that one address. Each person connects their own client once and approves their own grant, so nobody pastes a token or runs a server.
Two timings to plan around. A role or restriction change takes effect within about two minutes, so test a new rule a couple of minutes after saving it. Removing or suspending a member is faster: their clients stop on the next call.
How do you and IT agree which apps employees may connect to Claude?
Write an allow rule for each role that names the approved connectors. In Elaichi, a connector the rule does not name is then refused at every place a member can reach a connector or tool, including listing, connecting, advertising, executing, the final outbound-request check and opening a stored tool file. A member cannot connect it or call it, from any client.
The enablement lead brings the list of apps each team needs; IT holds the permission that writes the rule. Mark each app approved for everyone, approved for one department, or not yet. The connector catalog holds 650+ connectors, most authored by Elaichi and some run by the app's own vendor.
Then turn the list into restrictions. A restriction decides 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. That default matters here. The Member role holds connection:create, so with no rule a member can connect any app in the catalog with their own account.
One trap: the allowlist stage engages on the presence of an allow rule, not its contents, so an allow rule that names nothing denies everything. Save the allow rule with its connectors already in it.
A member who meets a restricted connector can file an access request. Approving a request opens that connector or tool for that one person only, and the role's other rules keep binding them. An administrator cannot decide their own request, so a second person signs off.
Which IT admin controls do Claude, ChatGPT and Cursor give you for MCP?
Each client controls how a server reaches its own users. Elaichi controls what is behind the server. You add the one address in each client, and the rules on roles, apps and tools live in one place behind it.
Here is what each vendor documents:
- Claude. On Team plans, only Owners and Primary Owners add a custom connector, under Organization settings > Connectors > Add > Custom > Web. Members then connect it themselves under Customize > Connectors (Anthropic's help center, checked October 2026).
- ChatGPT. Full MCP support, including write actions, is available on Business, Enterprise and Edu. An admin creates the app under Workspace settings > Apps > Create and publishes it. It then appears in users' Apps settings labeled custom, and OpenAI says functionality, UI and permissions may change (OpenAI's help center, checked October 2026).
- Cursor. Enterprise admins can allowlist MCP servers, but the allowlist does not push a server to anyone's machine. Team admins can instead distribute a server through a team marketplace, where teammates install and configure it themselves (Cursor's enterprise docs and MCP docs, checked October 2026).
Those are distribution controls, one per client. Elaichi's restrictions sit behind the endpoint, so one rule holds for every client. The per-client steps are in the Claude setup guide, the ChatGPT walkthrough and Cursor for a whole team.
How does a platform team centrally manage MCP servers for the whole company?
By not running any. Elaichi runs the connectors it authors and governs vendors' own MCP servers for the rest, so the platform team manages connections, sharing and rules instead of servers, versions and tokens.
Connect each company account once. Connector credentials do not live in Elaichi. A separate credential service holds them, encrypted at rest with AES-256-GCM, and owns token refresh. A failed refresh marks the connection Needs sign-in rather than failing silently.
Ownership is the next decision. A connection can stay private to one person, or be shared at use with a team or the whole organization. A shared connection runs on its owner's credential, so every call through it reaches the app as that account. Share one team-wide only when the whole team is meant to act as that account. For per-person access, share a template and let each person stamp it against their own account. A member sees only what they own or what was shared with them, admins included. Treat connector:create as high trust, because a custom connector can be pointed at any destination.
How do you give sales, engineering and HR different AI tool access?
Use teams for what each department uses, and roles with restrictions for what each department may reach. In Elaichi, a team is a named group you share connections, toolboxes and templates with.
A toolbox is a saved set of tool entries, each pairing one tool with one connected account. A template is the same tool list with no accounts in it, carrying tool renames, defaults and frozen arguments. Teammates with use on a template stamp their own toolbox from it and pick their own connections. Stamping copies the template once, so a later edit leaves stamped toolboxes alone.
A workable split for three departments:
- Sales. Build a Salesforce template and share it with Sales at
use. Each rep stamps a toolbox against their own Salesforce account, so Salesforce's own permissions still apply per rep. The sales playbook covers which tools to restrict. - Engineering. Build a Jira template with the issue tools engineers use, renamed in the team's own words. Share it with Engineering, and each engineer stamps a toolbox against their own Jira account.
- HR. Connect Rippling as a private connection, pin it into a toolbox with frozen arguments, and share only the toolbox with HR. Every call runs on the owner's Rippling account, so choose an owner whose access fits the whole team and who will stay. One condition: a freeze binds only calls made through its toolbox entry, so share the toolbox with the people it governs, not the connection itself. The HR team's setup works through it.
Teams carry shares, not rules. Restrictions target roles and users, never teams. Where two departments need different restrictions, give each its own custom role. Each person can also narrow a client at consent, from the default Everything I can use to Only the ones I pick, up to 50 toolboxes.
Which roles and restrictions should each department start with?
Start every working seat on Member, and add a custom role only where a department's restrictions must differ. Each member holds exactly one role, so a department role has to describe a whole job.
Member is the working seat. Team Admin adds managing teams, and People Admin adds managing members. Guest, Billing Admin and Auditor lack tool:execute, so they cannot call a tool at all. Auditor is a free, read-only seat. Designing one role per person covers the reasoning.
If your directory is the source of truth, map groups to roles. SCIM is how a directory pushes users and groups into an app, and in Elaichi each group mapping can confer at most one role. The Sales group lands on the sales role, Engineering on the engineering role. Where SCIM provisioning stops explains what a group cannot express.
Then write the rules for each role. Allow the approved connectors, and restrict the destructive tools a role does not need. A rule aimed at a member can only narrow what their role allows, and never replaces or loosens a role rule. Within each layer, blocks always beat allows. Tool rules versus app rules works through six cases.
A role or restriction change takes effect within about two minutes, on MCP, the console and REST alike.
What should a one-team pilot prove before the company-wide rollout?
It should prove that the rules match the calls people actually make. Pick one team with a clear need, run it for two weeks, and read the audit log instead of collecting opinions. If the pilot keeps stalling, read why AI pilots fail.
Sales makes a good pilot, with one main app and clear read and write tools. Before day one, give one reviewer the Auditor seat, so the record has a reader who cannot act.
The audit log is the chronological record of who did what. Elaichi writes one entry for each connected-tool call that reaches execution (a call refused earlier writes none), and each entry names the account the call actually reached. A call from Claude, ChatGPT or Cursor is recorded under the employee who signed in, with the client it came through. The trail logs the one path argument that names the object, as the target id, and nothing else about the arguments.
Read the log for three things. Tools nobody called can leave the toolbox. Access requests show a rule that is too tight. Calls to an unexpected account show a sharing gap. What an AI audit log must capture lists the fields to check.
How do you onboard a new hire so their AI assistant gets the right app access automatically?
Give the new hire a role on day one and let sharing carry the rest. Elaichi has four ways in, and each one sets a role on arrival.
| Path | Role on arrival | Teams on arrival |
|---|---|---|
| Emailed single-use invite | Preset by the inviter | Preset by the inviter |
| Verified-domain join (the person accepts) | The domain's default role | Added afterward |
| Just-in-time SSO | The SSO connection's default role | Added afterward |
| SCIM provisioning | The role mapped to the person's group | Added afterward |
Where no default role is configured, an automatic join lands on Member. Anything shared with the whole organization reaches the new hire at once. A team share reaches them within about two minutes of being added to the team. SCIM and group mapping set the role, not team membership, so a Team Admin or above adds the person to their team. Keep that step in the joiner checklist.
The new hire then connects each client once and signs in. The default consent choice, Everything I can use, also picks up connections shared with the person later, so team shares arrive without reconnecting.
How do you close AI access when an employee leaves?
Suspend or remove the member, and their very next call is refused. In Elaichi, removing or suspending a member revokes every live grant in the same transaction as the membership change, and the grant is re-read on every call with no cache.
A SCIM deprovision suspends the member and never removes them. Removal is a separate step in Elaichi, and it runs a preflight. A shared connection can go to one colleague, or be deleted if the admin asks. Nothing transfers to the organization or a team. At offboarding, a private connection that nothing beyond the member depends on cannot be transferred and is deleted with them. A private connection that a shared toolbox depends on blocks removal until an administrator transfers it to a member. So the person who connects HR's private Rippling account should be someone who will stay.
Removal ends access through Elaichi, nothing more. The person's account inside each app still exists, and it is closed there or through the identity provider. The offboarding runbook walks through a contractor case. Then check the audit log, where a removed member's past calls stay, labeled Former member.
When do you not need a control plane for this rollout?
When one team uses one app and that app's own MCP server already does the job. Several vendors now host one, and it runs under the app's own permissions with no second vendor.
Notion is a fair example. Notion describes its server as "a remote MCP server hosted by Notion", where the client can read and update content the person can access. Workspace owners manage client access under Settings > Connections (Notion's docs, checked October 2026). For a product team living in Notion alone, that may be enough.
The case changes at the second app or the second team. Then you want one address across vendors, rules written once per role, and one audit trail. If no assistant can write to a company system yet, read the case for waiting first. Know one limit as well. The prompt-injection write gate lives in the Elaichi agent window and does not apply to a raw tool call.
As of October 2026, SSO, SCIM, group-to-role mapping and custom roles are on Gold, and the 14-day trial unlocks all of them. Gold lists at $15 per user per month in USD, or $10 per user per month billed annually, and pricing shows your local price and the trial terms. More governance posts sit under governance, and team-by-team starting points are on the use cases page.