Why does every team reach the whole catalog until you write a rule?
Because the absence of a rule means allow-all. A head of IT connects Elaichi and points Claude, ChatGPT and Cursor at one address. Sales, support, engineering and finance all sign in to the same place. With no restriction written, a member can connect any catalog app with their own account. Approved AI tools per team is therefore something you write down, not something you inherit.
MCP (Model Context Protocol) is the standard way an AI assistant calls tools in other apps. Elaichi serves every connected account through one organization-wide MCP endpoint, and each member signs in there with their own OAuth grant. OAuth is the browser sign-in that issues a scoped token instead of handing over a password. The catalog behind that endpoint holds 650+ connectors. No team needs all of them. Four teams typically need four different slices. Sales needs CRM and email. Finance needs the accounting suite and nothing with write access to it. Engineering needs the issue tracker and source control. Support needs the helpdesk and nothing else.
The problem is not specific to Elaichi. Any shared endpoint that several teams sign in to needs a written rule before those teams reach different things. The rest of this post gives the four steps, then the trade-offs in each one.
How are companies handling AI access: block it, allow approved tools, or gate by role?
Three postures exist: block AI tools outright, allow a list of approved tools, or gate access by role. Elaichi supports the last two. With no rule written, every member can connect any catalog app. An allow rule per role names the approved apps, and every app the rule does not name stays unreachable for that role.
A thread on r/ciso asks which posture other companies pick. Gating by role is the one that keeps a team's work possible while the list stays short. Each team gets a role, and each role gets its own approved apps. An allow rule that names nothing blocks everything for its target, which is the strictest rule you can write.
Elaichi's rules decide which connected-app tools each role reaches through its endpoint. Device and sign-in controls for the AI clients themselves stay with your own tooling.
How do you scope agent tool access with tool groups?
Use toolboxes, which are Elaichi's tool groups. A toolbox is a named list of connector tools. At sign-in, a person can pick "Only the ones I pick", and the client then reaches exactly those toolboxes and nothing else, re-checked on every call. A restriction on the role is what enforces the limit for the person.
Pick up to 50 toolboxes the person can use. If one is deleted, or the person loses use of it, the client reaches less, never everything. A consent choice does not make a connected app read-only. To hold an agent to reads, pick toolboxes made of read tools, but do not trust labels alone: Gmail's "Send a draft" is labeled Read only. Or add a restriction that blocks the write and delete tools.
What are the two jobs behind approved AI tools per team?
Enforcement and curation, and they are set in different places. This distinction holds whichever platform you are on:
- Enforcement is a restriction bound to an identity (a role or one member). It decides what is reachable at all.
- Curation is what a person picks from whatever enforcement left reachable. It decides what is convenient, not what is possible.
A restriction decides which connectors and which individual tools a target may reach. In Elaichi it is checked against the same resolver 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 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. That holds whichever client the person is using: Claude, ChatGPT, Cursor, Microsoft Copilot, or a custom agent.
Curation is softer by design. A template is a tool list someone assembled for a team. The consent-screen choice between "Everything I can use" and "Only the ones I pick" is the person's own scoping. Neither stops anybody from reaching something else they are already allowed to reach. Treat a curated toolbox as a control and the approved-apps plan stops being one. A toolbox changes what shows up in a menu, not what the model can call.
Step 1: how do you map each team to a role?
Create one role per team persona, then map that team's identity-provider group to that role. The reason is the shape of restrictions: restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. So the team you are governing has to exist as a role before any rule can bind it.
A SCIM group mapping can confer at most one role, and a member holds exactly one role, enforced by a unique index. SCIM (System for Cross-domain Identity Management) is the provisioning standard your identity provider uses to push users and groups into an application. So the shape is a sales role, a support role, an engineering role, a finance role. Each is a complete persona rather than a bolt-on, which is the point of the one-role-per-member rule. It is also the main design constraint to plan around. Custom roles are a Gold-tier feature, so check pricing before planning a role structure that depends on them.
Verified domains and SSO connections each carry a configurable default role, and domain, SSO and SCIM joins fall back to Member when none is set.
Team membership is set separately from role. SCIM and group mapping never set team membership. People who join by SCIM, domain or SSO are added to teams afterward, and invites can preset teams. Teams matter for sharing templates and connections, not for enforcement. A SCIM deprovision suspends the member rather than removing them, which revokes every live grant on the next call. Removal is a separate step an admin takes in Elaichi afterward. SCIM and AI agents covers where provisioning stops and manual admin action starts.
Step 2: how do you write the approved-apps list as allow rules?
Write one allow rule per approved app on that role, each naming the whole connector. Allow rules on the same role merge into one allowlist, so three rules naming three connectors are the role's complete list. An allow rule naming a connector whole admits every tool on it.
The trap is what happens to everything you did not name. In Elaichi, once a role carries any allow rule, every connector and tool none of its allow rules names is blocked for that role, across the whole catalog. The rule is not an incremental grant on top of a baseline. So the role needs an allow rule for every other app it uses, not only the app you were thinking about when you wrote the first rule. Miss one and the team loses it quietly, because "not listed" and "blocked" are the same state.
Worked example. Say the sales role needs Salesforce, Gmail and Slack, and nothing else:
| Rule on sales role | Effect |
|---|---|
| Allow: Salesforce (whole connector) | Sales reaches every Salesforce tool |
| Allow: Gmail (whole connector) | Sales reaches every Gmail tool |
| Allow: Slack (whole connector) | Sales reaches every Slack tool |
| (no rule for QuickBooks, Jira, and the rest) | Sales reaches nothing in any unlisted connector |
Three allow rules form the complete list. Add a fourth app later and sales gains it within about two minutes of the rule being saved. That is the timing to plan around for every restriction change, and for a role or team membership change too. Forget to add the app and sales never sees it, with no visible error on either side.
Two more mechanics decide how the first rule behaves:
- An allow rule naming connector X whole, plus some of X's tools, reaches all of X. The tool entries grant nothing extra. The API refuses that overlap on new rules, so you cannot accidentally write a rule that looks more specific than it is.
- An allow rule naming nothing blocks everything for its target. It is the strictest rule you can express, and it is the usual way an approved-apps list goes wrong on the first attempt.
Step 3: how do you hold one approved app to its read tools?
Keep the whole-connector allow rule and add block rules naming that app's write tools on the same role. Blocks merge with each other, and a block always beats an allow, whichever rule was written first.
A second allow rule does not narrow anything. If finance's allow rules name QuickBooks whole, an allow rule naming only its read tools changes nothing, because the role's allow rules merge and the merged list still reaches all of QuickBooks. The alternative to blocks is to name QuickBooks' read tools in place of the whole connector. That works, as long as the role still has whole-connector allow rules for every other app it uses. Which writes to block is a question a pilot's own call record answers, and narrowing to the tools people actually used keeps that list honest.
The two rule types also match differently. A block matches on the tool name or on the operation pinned against the catalog at write time. An allow matches on the pinned operation only. Whoever edits a connector's documentation can change an advertised tool name, so allows bind the operation rather than the label, and a rename cannot widen what an allow reaches. Why blocks match tool names but allows do not covers that asymmetry, and restricting one tool against restricting the whole app works through six cases.
A rule aimed at a member can only narrow what their role allows, and never replaces or loosens a role rule.
How do you give sales, engineering and HR different AI tool access?
Give each department its own role. Then write that role's allow rules for the apps it uses.
In Elaichi, restriction targets are role or user only; the organization default is the absence of a rule, which means allow everything. So each department has to exist as a role before a rule can reach it. Map the sales group, the engineering group and the HR group to three roles, then write the three lists side by side.
| Sales role | Engineering role | HR role | |
|---|---|---|---|
| Allow rules | Salesforce, HubSpot, Gmail, each whole | Jira, Linear, Sentry, PagerDuty, each whole | BambooHR read tools only |
| Block rules | The delete tools on Salesforce, HubSpot and Gmail | None needed | None needed |
| Everything else | Unlisted apps are unreachable | Unlisted apps are unreachable | Unlisted apps are unreachable |
| BambooHR elsewhere | Blocked on the sales role | Blocked on the engineering role | Reachable, read tools only |
Each row of allow rules merges into that role's whole allowlist. Name every app the department uses, because anything unlisted is blocked. Sales keeps its three apps and loses the deletes, since a block always beats an allow.
The BambooHR block on the other roles is belt and braces. Those roles already reach nothing unlisted. The block keeps HR data out of reach even if someone later adds BambooHR to the sales allowlist by mistake. Each rule takes effect within about two minutes.
Step 4: how do you give each person a curated list on their own accounts?
Build a template holding the tool list and share it with the team at use, so each member stamps their own toolbox. Stamping creates that person's own toolbox. Each entry is bound to a connection that person can use, with them recorded as the delegator. An entry with no usable connection is left as "needs connection" rather than failing silently.
Worked example. The sales lead builds a template called "Sales Outreach" with five Salesforce tools, three Gmail tools and two Slack tools, each with sensible defaults. The lead shares it with the Sales team. Each rep stamps it:
- Rep A has already connected their own Salesforce and Gmail accounts, so all ten entries bind to Rep A's own connections.
- Rep B has connected Gmail but not Salesforce yet, so the five Salesforce entries sit as "needs connection" until Rep B connects.
- The template itself never holds a connection; only each stamped copy does.
A template holds a tool list with renames, defaults and frozen parameters. Stamping copies the list once, so editing the template later does not change a toolbox already stamped. Re-share and re-stamp when the list changes.
Do not pair "each person connects their own account" with "share one toolbox." A toolbox shared at use is the opposite arrangement. Every grantee's call runs on the connection pinned in its entries, which is the owner's account, not the grantee's. That is correct when one account should serve a whole team, such as a shared support inbox. It is wrong when each rep should reach only their own records.
A frozen argument inside a stamped toolbox is not a control over the person who stamped it. A freeze holds only on the path that runs through that entry. Anyone holding direct use on the underlying connection can call the same tool unfrozen. Locking an argument for a team requires an unshared connection, pinned into a toolbox by its owner and shared at use. Locking AI agent tool arguments sets out the mechanism, such as freezing a wire-transfer receiver account number so no rep can redirect funds.
On the consent screen, a member who ticks "Use your connected apps" gets a "Toolboxes" row that opens a sheet. "Everything I can use" is the default. It covers their own toolboxes and the automatic ones for every connected app. It picks up accounts they connect later and connections shared with them later, so it is a live, expanding grant rather than a snapshot. "Only the ones I pick" narrows the grant to chosen toolboxes, up to 50. If none of those toolboxes resolves any more, say because the underlying connection was revoked, the client sees no connected tools. There is never a silent fallback to everything.
The consent checkboxes do not make a connected app read-only. For a connected app's tools, "Use your connected apps" covers reads, writes and deletes alike, and the destructive scope covers only Elaichi's own deletes. Read-only access to an app comes from a restriction, not from a consent-screen choice. Starting read-only and widening later is the order a rollout aimed at teams that do not write code follows.
How does someone get an app that is not on their team's list?
They file an access request, and an admin resolves it in the console under Governance, then Access requests. Any member can file one, with no permission needed. Resolving one needs member:manage, the permission that covers managing people, and the admin re-confirms their identity first.
Approving a request creates an access grant for that one requester only. The grant lifts exactly the approved connector or tool out of their role rules. The role's other rules still bind them, including rules added to the role later, and the rest of the team is unaffected. No restriction rule is written, and the role is not edited. The grant lasts until the member is removed or an admin approves a replacement. An admin cannot approve their own request. The Elaichi Agent and MCP clients can neither approve nor deny one, by design: it is a person's decision made in the console.
Time it accordingly. An approval, like any restriction change, takes effect within about two minutes. Removal is faster. In Elaichi, removing or suspending a member revokes every live grant in the same transaction as the membership change. Human approval for AI agent actions sets out the other approval layers, which are independent of access requests.
When are Claude and ChatGPT approval lists enough on their own?
When you run exactly one AI client and its own approval settings give the granularity you need. Both vendors ship that natively, and it is less setup than a separate control plane. The trade-off is granularity and cross-client consistency.
| Claude (Team/Enterprise) | ChatGPT (Enterprise/Edu) | Elaichi | |
|---|---|---|---|
| Granularity | Per-connector or per-tool: Always allow / Needs approval / Blocked | Per-app on/off; per-app read vs. write actions | Per-connector or per-tool, per role or per member |
| Per-team policy | Enterprise custom roles narrow tool permissions further | Yes, via custom roles (Enterprise/Edu only) | Yes, one role per team persona |
| Multi-client consistency | Applies only within Claude | Applies only within ChatGPT | Same rule applies across Claude, ChatGPT, Cursor, Microsoft Copilot, and any MCP client |
| Who configures it | Owners and Primary Owners | Workspace admin | An admin holding restriction:manage |
Sources: Claude tool permissions (support.claude.com, checked October 2026); ChatGPT role-based access control (help.openai.com, checked October 2026); ChatGPT per-app read and write actions (help.openai.com, checked October 2026).
Two things change the moment a second AI client appears in the organization. First, approvals do not transfer. The same person reaches the same underlying data under two independently configured lists, one per client, and keeping them in sync is manual. Second, to ChatGPT a control plane like Elaichi looks like one custom app. Its tools are search_tools, execute_tool and its own operations. So ChatGPT's per-action switches can toggle the control plane on or off as a whole. They cannot tell which catalog app behind it a call is targeting. Per-app and per-tool approval for the apps behind that single connector has to be written in the control plane itself.
For the client-side path on its own, without a control plane, there are standalone guides for approving apps in Claude and restricting ChatGPT Enterprise connectors.
The honest part: the role binds, not the team
Restrictions bind a role or one member. They never bind a team, and there is no organization-wide rule. A team is a sharing construct, which is why templates go to teams and allow rules go to roles.
That split has a practical consequence. If two people sit on the same team but hold different roles, they reach different apps. A shared template then stamps differently for each. One person's stamped entries might resolve to real connections, while the other's sit at "needs connection" because their role never granted that app. If one person needs a wider list than their role allows, the clean answer is an approved access request, which creates an access grant for that one person. A rule aimed at that person cannot help, because it can only narrow what their role allows. A second role is not an option, since a member holds exactly one role. Design the four roles first and the four teams second. Retrofitting roles after teams are already full of mixed-permission members is the harder order to untangle.
From here: the MCP control plane overview explains the endpoint these rules sit on. Designing roles for AI agents covers the one-role constraint in depth. The connector catalog is where you check that the apps a team wants are ones Elaichi already serves.