Connectors, Retrieval and the Permission Inheritance Problem
Every enterprise GenAI platform now connects to company data, and every vendor says the same reassuring thing about it: the assistant respects your existing permissions. That statement is usually true. It is also the beginning of the assessment rather than the end of it, because inheriting a permission model means inheriting whatever is wrong with it — at the speed of natural language, across the whole estate, for everyone at once.
Two questions, not one. Whether a person is entitled to reach content is an access question, and the platform may answer it faithfully. Whether that content may be used for this purpose, by this system, in this way is a separate authorisation with a separate owner. Entitlement is not authorisation, and only the first of the two is a permission.
Plain-English explainer · ISO/IEC 42001:2023 · SOC 2 trust services criteria (2017, rev. 2022) · Product behaviour verified at time of writing · Last reviewed August 2026
Assess the platform once, then assess connectors by what they reach — and treat the identity a connector runs on as the field that decides everything else. The governance question is the same across Microsoft 365 Copilot, Gemini for Google Workspace, ChatGPT Enterprise, Claude Enterprise, Glean and anything built on Copilot Studio or MCP, because it is not really a question about the AI. It is a question about whether your identity and content-permission model was ever good enough to be read out loud. Enterprises reach one of two failure modes here. Either the platform is approved once and every subsequent connector rides in on that approval, or every connector triggers a full assessment and the programme stalls arguing about the calendar integration. Neither is proportionate. What follows is the method we use instead: a platform-level approval that covers the durable questions, a short trigger list that decides which integrations get assessed individually, the five identity models a connector can run on and what each does to your logs, the retrieval-specific risks that permission inheritance does not touch at all, custom connectors and direct API deployments as a separate case, and what to re-review when any of it changes.
Key Takeaways
- “The platform respects existing permissions” is a claim about enforcement, not about correctness. AI inherits the strengths and the weaknesses of your identity and content-permission model, and it exercises both at a scale no human reader ever did.
- Data access entitlement and authorisation for a particular AI purpose are different grants with different owners. A person entitled to read a folder for a task has not thereby authorised a general-purpose assistant to read, summarise and persist it.
- Assess proportionately: approve the platform once for hosting, retention, tenancy, admin controls and logging, then assess individually only the connectors that trip a stated trigger — sensitive data class, write capability, an unknown permission model, or an application identity.
- For every connector, answer five questions in writing: whose credentials it uses, what the granted scope actually covers, which actions are permitted, what the downstream system independently authorises, and what happens on revocation.
- Retrieval creates a second copy of your content with a second permission model, and the two drift. Stale indexes, caches and conversation transcripts routinely outlive a revocation at source, and a vector store carries the classification of the text it was built from.
- A connector approved on delegated user identity and later switched to an application identity is a different connector. Re-assessment triggers belong to events in the platform audit log, not to an annual review cycle.
Why permission inheritance is not an answer
It is worth being precise about what the vendor is and is not telling you, because the sentence is doing four jobs at once and only one of them is a security control.
It is a claim about enforcement, not about correctness
The sentence promises the assistant will not exceed your permission model. It says nothing at all about whether that model is right. If a project site was opened to “everyone in the organisation” in 2022 so a contractor could read one file, the assistant is behaving exactly as documented when it surfaces the rest of that site to a salesperson. Inheritance is faithful in both directions, and most enterprises have never had their content permissions examined by something that reads everything it is entitled to read, tirelessly, in natural language.
Three separate claims are bundled inside it
That permissions are evaluated at the moment of the query rather than at the moment content was indexed, that they are evaluated against a current view of the source system rather than a copy that refreshes nightly, and that they are evaluated for the identity that actually asked rather than for a service principal running the pipeline. Each is a different engineering decision, each fails differently, and a vendor statement rarely distinguishes them. Ask which of the three you are being told.
Entitlement is not authorisation for a purpose
An HR business partner can open the redundancy consultation folder because a task requires it. Nothing in that grant authorises a general-purpose assistant to read the folder, summarise it and place the summary in a conversation transcript that persists. Access rights carry no purpose limitation with them. The lawful basis and the stated purpose that made the original processing legitimate are properties of the processing, not of the person. Purpose limitation under GDPR Article 5(1)(b), the notice-and-purpose scheme of India’s DPDP Act 2023, and the trust services criterion limiting use of personal information to identified purposes all sit on this axis rather than on the access-control one.
Aggregation produces something no single grant contemplated
Four hundred people can each read their own team’s channel. An assistant asked what the main complaints about a product are across the company exceeds nobody’s permission and still produces an artefact no individual could have produced. Read as an access question the answer is that nothing was breached. Read as a use question it is a new processing activity with a new impact, and that is the reading a regulator, a works council or a serious buyer will take.
None of this makes permission inheritance a bad design. It is the right design, and a platform that did not respect existing permissions would be unusable in an enterprise. The point is narrower and more useful: inheritance transfers a property you already had, so the assessment has to be of the thing being inherited. Where that model is known to be weak — and in most estates of any age it is — permission hygiene is the remediation programme that has to run alongside the deployment rather than after the first incident.
The purpose axis has its own anchors, and naming them shortens the argument with a privacy or legal reviewer. In the trust services criteria, the privacy criterion limiting use of personal information to the purposes identified in the entity’s objectives (P4.1) is the direct hook, with the confidentiality criterion on identifying and maintaining confidential information (C1.1) close behind. Both are in scope only if you selected the Privacy and Confidentiality categories — the majority of SOC 2 reports are Security-only, in which case the purpose question has no criterion to land on and has to be governed outside the report. Deciding that is part of choosing your trust services criteria. Under ISO/IEC 42001:2023 the equivalent work is the AI system impact assessment and the Annex A control objectives covering data for AI systems (A.7) and third-party and customer relationships (A.10). Whether a use is authorised is a governance decision recorded by a named owner, and it is exactly the decision an approved-use-case register exists to hold.
Approve the platform once, then tier the connectors
Platform-level approval covers the questions that are true of every integration: hosting region, tenancy and isolation, contractual terms including training and retention, administrative controls, audit logging and its retention, the subprocessor list, and authentication. Those are answered once and re-verified on a cadence. Everything below is the second layer — and the discipline is that a connector goes to individual assessment only when it trips a trigger, not because it is new.
| Connector class | What it actually reaches | Usual identity model | Assessment tier | Decide before approval |
|---|---|---|---|---|
| Calendar and free/busy | Meeting titles, attendee lists, locations, and often the body of invitations — which is where agendas and dial-in credentials live. | Delegated user identity in nearly all deployments. | Platform tier | Whether private-marked events are excluded, and whether attendee lists are treated as personal data in your own register. Approve with the platform. No individual assessment. |
| Individual mailbox | Everything the person can read, including delegated mailboxes and shared mailboxes they have been granted, which is the part people forget. | Delegated user identity. | Platform tier, with one check | List the shared and delegated mailboxes reachable through executive and support accounts before rollout. A support shared mailbox routinely contains customer personal data under a DPA. |
| Document tenant (SharePoint, Google Drive) | Every site, drive and file the identity can open, including sites shared by link, inherited-open sites, and anything a departed colleague left open. | Delegated at query time in most designs. An application identity often builds the index. | Individual assessment | Whether the permission model is described and current. Run a report of broadly-shared and link-shared locations first. This is the connector that produces the incidents. |
| Wiki and knowledge base (Confluence, Notion) | Spaces, pages and attachments — including page-level and space-level restrictions that are frequently implemented differently from the tenant’s main model. | Varies sharply by product and by how the index is built. | Individual assessment | How page-level restrictions are evaluated by the connector, and whether the index respects them or only the space-level grant. Test with a deliberately restricted page before rollout. |
| Chat history (Slack, Teams) | Public channels by default — an admin can scope the connector to an inclusion list of channels, and where that has not been done the default is everything public. Private channels and direct messages only where the identity model reaches them, which is a decision, not a default. | Delegated for the user’s own conversations, and an application identity for org-wide search. | Individual assessment | Whether direct messages are in scope at all. Employee expectations here are strong and the works-council or employee-representative question is real in several jurisdictions. |
| Ticketing and ITSM (Jira, ServiceNow, Zendesk) | Ticket bodies and attachments, which contain customer personal data, security findings, and — reliably, whatever the policy says — pasted credentials and tokens. | Frequently an application identity, because per-user indexing does not scale. | Individual assessment | Whether restricted queues (security, HR, legal) are excluded by project rather than trusted to a filter, and what secret-scanning runs over the corpus before it is indexed. |
| CRM (Salesforce, HubSpot) | Accounts, contacts, opportunities and notes. The notes field is where commercially sensitive and personal commentary accumulates. | Delegated where the platform supports row-level security, application identity otherwise. | Individual assessment | Whether the CRM’s own sharing rules and field-level security are evaluated by the connector or bypassed by an integration user with a broad profile. |
| Code repositories | Coding assistants — GitHub Copilot, Cursor, Claude Code and the agentic variants of each — reach source, history, issues and CI configuration, and history includes secrets that were removed from the head of the branch but never rotated. | Usually the developer’s own credentials, or an installed application with repository-scoped grants — verify which, because the two produce different logs. | Individual assessment | Repository allowlist rather than organisation-wide grant, and whether the grant is read-only. Write access turns a retrieval question into a change-management one, and agentic coding tools blur that line by design: the same product that answered questions last quarter now edits files, runs commands and opens pull requests. |
| Data warehouse and BI (Snowflake, BigQuery) | Whatever the connecting role can select, which in most warehouses is broader than any individual analyst’s intended view. | Almost always a service role — not because the engine cannot authenticate a user (Snowflake supports OAuth with the end-user identity and row access policies, and BigQuery supports end-user credentials with row-level security) but because per-user connections do not pool and row-level policy coverage is rarely complete enough to rely on. | Individual assessment | A purpose-built role with column masking and row-level policies, an export ceiling, and a written statement of which tables are reachable. Never reuse the ETL role. |
| Custom connector to an internal API (including MCP servers) | Exactly what you built, which is the point — and exactly what you built without noticing, which is the risk. | Your choice, which means it is your control and your evidence. | Individual assessment | Tool-by-tool review of the exposed operations, read/write separation, and a change process for when the tool surface changes. See MCP server governance for the specifics. |
The triggers that move a connector from platform tier to individual assessment are worth stating explicitly in your policy, because a written trigger list is what stops both failure modes. Ours are as follows. The connector reaches special-category or regulated personal data. It reaches content held under customer confidentiality obligations. It reaches a security or privileged system such as the identity provider, the secrets store or the security ticket queue. It can write, act or spend rather than only read. It runs on an application identity rather than a delegated one. The permission model of the source is not currently described. It creates an index rather than querying live. Or it moves content across a border that your agreements constrain. One trigger is enough.
In practice a platform-tier approval is a short record — half a page and a link to the contract. An individual assessment for a document tenant or a warehouse is a day of real work, most of it spent reading permission reports rather than writing the document. The whole point of tiering is to spend that day where it changes a decision. Both records belong in the AI system inventory, with the connector list as an attribute of the system rather than a separate spreadsheet.
The connector approval record
This is the artefact everything else on this page refers back to — the thing the change triggers test against, the thing an examiner samples, and the thing a buyer’s security team is really asking to see when they ask how you govern AI access. Fifteen fields, none of them optional, and two of them load-bearing above the rest.
| Connector name and vendor | The label everyone will search for. It is not an identifier — two products ship connectors of the same name. |
| The integration’s application or client identifier in the identity provider | This is the identifier, and it is what the consent-grant list and the audit log actually key on. An approval that names only the vendor cannot be reconciled to anything. |
| Identity model — one of the five, named | The field that decides whether permission inheritance is real. Leave it blank and every downstream control is unverifiable. |
| Granted scopes, quoted verbatim from the consent grant | Paraphrasing a scope hides its breadth. Quoted text is what you compare against next month’s grant when a scope is added. |
| Corpus inclusion list — sites, spaces, projects, repositories, tables | The approval is against a described corpus, not against a product. Without the list there is nothing for a new location to fall outside of. |
| Data classes reachable | Drives the assessment tier, the impact assessment, and whether the DPA and subprocessor questions arise at all. |
| Actions permitted — read, write, delete, administer | Four different approvals. Recording them separately is what makes a vendor-added write capability visible as a change rather than a default. |
| Does the source system independently authorise this caller, and by which mechanism — row-level, field-level, page-level | The difference between a control and a hope. Where the answer is no, the connector is the only thing standing between the caller and the corpus. |
| Index or live query | Decides whether you have one permission model or two, and whether a staleness window exists at all. |
| Refresh interval, and the measured staleness window in hours | Measured, not stated. This is the number that gets compared against the revocation commitment in your access-management control. |
| Retrieval log location and retention period | The only artefact that answers who saw what after an exposure. If its retention is shorter than your observation period, you have found a control gap in the approval itself. |
| Approvers — one per axis: security, privacy, source-system business owner | Each axis stops at a different place when it decides alone. Three named approvers is what makes the record a decision rather than a ticket. |
| Single named connector owner | The person the change triggers notify. A team name is not an owner. |
| Enablement date in the admin audit log | Approval dated after enablement is a routine exception. This field is what an examiner compares the approval date against. |
| Date of next monthly reconciliation | Turns the record from a document into a control with a next occurrence. |
The identity-model field and the enablement-date field are the two that the change-trigger list later in this page tests against. Every other field makes the record useful. Those two make it testable, and a record missing either of them cannot support the control it was written to evidence.
Whose credentials is it using
This is the single field that decides whether permission inheritance is real. Five models are in common use, and the difference between them is invisible in the user interface and decisive in the log. Record the model against every connector in your inventory, because it is also the field the change triggers later in this page test against.
| Identity model | How the request is authorised | What the log shows | Where it breaks | When to use it |
|---|---|---|---|---|
| Delegated user identity | The user completes an OAuth authorisation and the connector calls the downstream API on their behalf. Every request carries the user’s rights and is evaluated by the source system. | The downstream system records the user. Attribution to the assistant depends on the client identifier being logged and retained — check it before you rely on it. | Scope granularity. The consent screen offers what the API offers, which is usually “everything this user can read”, not “the four sites this assistant needs”. | Attended assistance, where the human is present and reaches nothing new. The default, and the right default. |
| Application identity (client credentials, app-only) | The connector authenticates as itself with no user context. The downstream system authorises the application, not a person, so the user’s own permissions are not consulted at all. | The downstream system records the application. Which human asked exists only in the AI platform’s log, if it keeps one — two logs must now be joined to answer one question. | Everything the phrase “respects existing permissions” implies. Permissions are not inherited here. They are replaced by whatever the application was granted. | Background indexing and org-wide search, and only where a query-time filter re-applies the user’s rights. On its own it is an entitlement grant to every user of the assistant. |
| Split model: application indexes, user filters | An application identity reads broadly to build the index. At query time the platform re-evaluates the asking user’s rights and returns only what they may see. | Two records: a bulk read by the application, and a per-user retrieval. The retrieval log is the one that answers who saw what, so its retention is the control. | The freshness of the permission snapshot, and the completeness of the filter on every path — answer text, citations, titles, snippets and follow-up questions each have to enforce it. | The common enterprise architecture. Workable, and the one that requires the most evidence to defend. |
| Shared connector account | A human account is repurposed as a robot. The downstream system sees a person, but the person is a spreadsheet entry nobody has interviewed. | A named employee, usually a former one. Investigations start by asking why a leaver read 40,000 documents last Tuesday. | Attribution, revocation and joiner-leaver hygiene simultaneously. It also survives access reviews, because the reviewer sees a plausible name. | Nothing. Where it exists, replace it and record the replacement — do not leave it in the inventory with an explanation. |
| Stored per-user tokens (token vault) | The platform holds long-lived refresh tokens for each user so it can act when the user is absent, including on a schedule. | The downstream system records the user, at a time the user was not working. Unattended action under a human identity is the pattern most likely to be mistaken for compromise. | Revocation timing and secret storage. Removing a user in the identity provider does not necessarily invalidate a refresh token held elsewhere — test this rather than assume it. | Scheduled or asynchronous work only, with an explicit delegation record. Treat it as agent identity, not as a connector setting. |
The five questions to answer per connector
Whose credentials. One of the five models above, named, with the account or application object identified. If the answer is a shared human account, stop and fix that before anything else, because it defeats attribution and revocation in one move.
What scope was granted, and what it covers. OAuth scope names are marketing for developers. The grant is whatever the downstream API defines. A scope that reads as “files” frequently means every file the identity can open across the tenant, because the API offers no narrower unit. Where the scope cannot be narrowed, the control has to live somewhere else — an inclusion list of sites and spaces, sensitivity labels or a data-loss-prevention policy that excludes content from the connector, or an intermediate service that mediates access. Record which of those you chose and why the others were not available. This is a plain application of least privilege under CC6.1 and CC6.3, and the ISO/IEC 27001:2022 Annex A controls on information access restriction (A.8.3) and access rights (A.5.18).
Which actions are permitted. Read, write, delete and administer are four different approvals. Read-only integrations acquire actions in product updates, so the answer has a date attached and belongs to the change triggers. The 2026 edition of the OWASP Top 10 for LLM Applications moved Excessive Agency from LLM06 to LLM03 — the largest upward move on the list, driven by production incidents in agentic systems. A read connector that quietly acquires actions is exactly that risk arriving through a release note. The moment a connector can act rather than only retrieve, it stops being a connector question and becomes a delegated authority question with a different approver.
What the downstream system independently authorises. The connector proposes and the source system disposes. Ask whether the source applies its own row-level, field-level or page-level rules to this caller, or whether the integration identity was given a broad profile precisely so that integrations would stop failing. In warehouses and CRMs the second is common and is usually the finding.
What happens on revocation. Removing a user or a grant has three different effects: on live queries, on an existing index, and on tokens already issued. Access tokens live until they expire. Refresh tokens held in a vault may survive a directory change. An index holds what it holds until it refreshes. Ask for the number of minutes, hours or days for each, and treat that number as your staleness window.
For calibration, and to be verified against your own deployment rather than taken from this page: on a live-query connector the window is usually bounded by access-token lifetime — commonly around an hour unless the source re-evaluates authorisation on every request. On a nightly-refresh index it is typically 24 to 48 hours once queueing is counted. And a full re-index of a large corpus can run into days. If your measured number is materially worse than these, the finding is the refresh architecture, not the connector.
An index is a second copy of your data
Almost every enterprise deployment of any size builds an index, because querying source systems live at conversational latency does not work at scale. The moment it does, your content exists in two places with two permission models, and the second one is a snapshot. Everything that follows in this section is a consequence of that single fact. The OWASP Top 10 for LLM Applications carries an entry for this — Vector and Embedding Weaknesses. Cite it by name: the 2026 edition, published 4 August 2026, renumbered several entries against the 2025 list.
| Layer | What it holds | Whose permission model applies | What revocation at source does to it |
|---|---|---|---|
| Source system | The authoritative content and the authoritative permissions. | Its own — this is the only layer where the permission model is native. | Immediate and complete. Everything downstream is a promise to catch up. |
| Index and embedding store | Chunked text, vectors, and metadata including titles, paths and access-control identifiers copied at index time. | A copy of the source model, as it stood when the chunk was written. Vectors are derived from the text and are not a security boundary — treat the store at the classification of the content it was built from. | Nothing, until the next refresh reaches that item. The gap is your refresh interval plus the queue, and it is rarely written down. |
| Retrieval and prompt cache | Recently retrieved chunks and assembled prompts, kept to reduce latency and cost. | Usually none — a cache is keyed for speed, and the key may not include the identity. | Nothing. Ask what the cache is keyed on and what its time-to-live is. Both are answers you must be given in writing. |
| Conversation transcript | The quoted content, in the user’s history, indefinitely by default. | The user’s own. The transcript belongs to the reader, not to the source document. | Nothing at all. Content deleted at source survives here, which is the single most common gap in an erasure or DSAR response. |
| Provider-side logs and abuse monitoring | Prompts and completions, for a retention period set by your plan and contract. | Theirs, under contract. | Governed by the agreement, not by your admin console. Get the retention period and the deletion mechanism from the documentation or the contract, with the date you captured it. |
| Evaluation, telemetry and quality datasets | Sampled prompts and retrieved context, often held by a different team in a different system. | Nobody’s, in practice, until you assign it. | Nothing. This layer is created by engineers solving a real quality problem and is almost never in the connector assessment. Put it there. |
Four failure modes that permission inheritance does not cover
Permissions evaluated at index time rather than query time. If access-control identifiers were copied into the index when the chunk was written, the index enforces the permissions of that moment. Every change since is invisible until the item is re-indexed. Ask which of the two your platform does. If the honest answer is a mixture — live for some sources, snapshot for others — that mixture is what you have to document, and the sources on snapshots are the ones that need shorter refresh intervals.
Filtering after retrieval rather than before. Pre-filtering restricts the candidate set to what the user may see. Post-filtering retrieves broadly and removes what they may not, which means the restricted text entered the pipeline and the protection depends on the filter being correct on every path out of it — the answer itself, the citation list, document titles and snippets, related-content suggestions, and follow-up questions in the same conversation. Post-filtering is not automatically wrong, but it makes the filter a security control and the paths a test plan.
Treating the vector store as unreadable. Embeddings are derived from the source text and are not an obfuscation mechanism. Published research on embedding inversion shows meaningful text can be recovered from them. The practical rule is simple and worth stating in the design record: the index inherits the classification of the highest-classified content it contains, and it gets the same encryption, access control, logging, backup and retention treatment as the source. A vector database standing outside your data-classification scheme because it holds numbers is the gap this rule closes.
Tenancy as a filter rather than a boundary. In a multi-tenant product, whether tenant separation is a separate index, collection or namespace or a metadata field applied in the query changes the failure mode entirely. A boundary fails closed. A filter fails open, and it only has to be omitted on one code path — a batch re-ranking job, an internal support tool, a migration script — to produce cross-tenant retrieval. Decide it deliberately, write it down, and prove it with an automated negative test rather than a design statement.
One more consequence deserves its own sentence, because it is the one privacy teams discover last: retrieval also enlarges the prompt-injection surface. Content pulled from a wiki page, a ticket or an email is untrusted input that reaches the model with your instructions, and where the assistant can also act, a maliciously crafted document becomes a way to steer it. Prompt Injection is LLM01 in the 2026 edition of the OWASP Top 10 for LLM Applications — first on the list in both editions, and the item retrieval makes reachable from outside your organisation. Retrieval and tool use are usually governed by different teams. The risk sits precisely between them.
One connector, one changed field
An illustrative composite, not a client. A 4,100-person software company deploying an enterprise assistant across its document tenant, its wiki and its mailboxes. Nothing in this sequence is exotic. The pivot is a single field in an approval record that nobody thought of as a security setting.
| Approval | 14 January 2026 | The platform is approved at tier one: tenant, hosting region, retention settings, admin controls, audit logging, subprocessor list. Three connectors are approved with it — calendar, mailbox, and the document tenant — each recorded as running on delegated user identity. |
| Pilot | 2–27 February | Twenty-five users. The wiki connector is added and behaves correctly: a deliberately restricted page is not returned to a test account without rights. The negative test is documented, dated and filed. Everything the assessment predicted is what happens. |
| The change | 9 March | Rollout to 4,100 staff. Per-user authorisation will not sustain a nightly index of the wiki, so an engineer re-authorises that connector using an application identity with a broad read grant. It is a sensible engineering decision, it is recorded in the platform audit log, and no assessment is re-opened. |
| The exposure | 24 March, 11:40 | A finance analyst asks about restructuring plans and receives a summary citing three pages from a space restricted to eleven executives. The space-level grant was respected, but the page-level restrictions inside it were evaluated by the delegated path and not by the application-identity indexer. |
| Containment | 24 March, 14:05–18:30 | The connector is disabled, the space excluded, and — before the index is rebuilt — the retrieval log for the period since 9 March is exported and preserved, together with the index manifest. That order is the whole lesson: rebuilding first would have destroyed the only record of what had been indexed and who had retrieved it. |
| Answer | 25–27 March | The retrieval log shows the restricted pages were returned to four users across nine queries in fifteen days. Four conversations are identified and their transcripts deleted, and the deletion is evidenced from the admin console rather than asserted by the users. |
| Assessment | 26 March | The incident is assessed as a personal-data breach rather than an internal confidentiality lapse, because the restricted pages named individuals and their proposed roles. The 72-hour clock is recorded as starting at the point of awareness on 24 March, not at the point of exposure on 9 March, and the reasoning for that start point is written down alongside the decision and its approver. Whether a supervisory authority is notified turns on the risk assessment, and the assessment is filed either way — the record that no notification was required is the artefact, not the absence of one. |
| Control change | 31 March | The wiki connector returns to delegated identity with query-time filtering. Page-level restriction handling becomes a standing item in the quarterly negative test. A monthly reconciliation of enabled connectors against approved connectors starts on 1 April, and the measured staleness window — 31 hours on the nightly index — is written into the risk record beside the four-hour revocation commitment in the access-management control, which it contradicts. |
Read the 9 March row against the 2 February row. The negative test in the pilot was valid, well designed and correctly filed — and it tested a configuration that no longer existed five weeks later. The assessment was not wrong. It expired, silently, in a change that was visible in the platform audit log the whole time and that nobody had a reason to read.
Note also what made the answer possible on 25 March. The retrieval log recorded which sources were returned to which user, not merely which prompts were typed, and it was preserved before the index was rebuilt. Had containment run in the other order — rebuild first, investigate after — the company would have been left telling four thousand employees and one regulator that it could not determine who had seen the material. The blast-radius question is answerable only from a log that records retrievals, and it is the reason that log’s retention is a governance decision rather than an engineering preference.
A connector is approved with an identity model. Change the identity model and you have a new connector, whatever the admin console calls it.
API deployments have no permissions to inherit
When your engineers call a model API directly — Azure OpenAI in Microsoft Foundry, Amazon Bedrock, Vertex AI, or a provider endpoint — none of the inheritance analysis above applies, because there is no connector framework and no end-user entitlement travelling with the request. Each of those platforms still has an account and still authenticates a caller: an Entra tenant with Azure RBAC, an AWS IAM principal, a Google Cloud project with IAM. What none of them carries is the asking user’s rights over your content. For content, the permission model is your application code. That is a heavier responsibility than a connector and a lighter set of unknowns, and it needs its own assessment template rather than a repurposed SaaS one.
Architecture — you are the permission model
There is no connector framework and no end-user entitlement travelling with the request. The cloud platform still governs who may call the model — Azure OpenAI through Entra ID and Azure RBAC, Bedrock through an IAM principal, Vertex AI through Google Cloud IAM — but none of that identity carries the asking user’s rights over your content. Whatever your retrieval code places into the prompt is what the model receives, and the only content access control that exists is the one you wrote. The practical consequences are that authorisation has to be enforced before retrieval rather than after generation, that the tenant or customer identifier must be a hard boundary in the query path rather than a filter applied late, and that a single unfiltered code path — an admin tool, a batch job, a debugging endpoint — is sufficient to defeat the correct paths. Write down where the boundary is enforced and test it negatively: a test that proves tenant A cannot retrieve tenant B’s content, running in CI, is worth more than a paragraph of design documentation.
Credentials — prefer an identity, not a stored secret
Lead with the credential that has no secret to store: a managed identity or workload-identity federation where the platform offers one — Entra ID for Azure OpenAI, an IAM role for Bedrock, service-account impersonation or Workload Identity Federation for Vertex AI. Those issue short-lived credentials tied to a workload, which removes both the storage problem and the rotation problem at once. Where a bearer key is unavoidable — most direct provider endpoints, and some tooling that expects one — treat it as a production database credential: separate keys per environment and per service, stored in a secrets manager rather than an environment file, rotated on a stated schedule and on personnel change, never shared between production and test, and never present in client-side code. Bearer keys are often long-lived on direct provider endpoints, where the cloud platforms issue short-lived credentials instead. Where the provider supports scoped or project-level keys, use them, and record which key belongs to which workload — because the first question in a cost or abuse incident is which service made the calls, and an account-wide key cannot answer it.
Retention and training — read the contract, not the page
Enterprise and consumer tiers generally differ in retention defaults, in contractual commitments about training, and in the availability of zero-retention or region-pinned options — that difference is structural and durable. The specifics are not. Confirm in current vendor documentation and in your executed agreement whether inputs and outputs are retained, for how long, for what purpose, whether any human review occurs, and whether your tier permits training on your data. Record the answer with the date you captured it and the URL or clause you took it from, and re-verify at a stated cadence. A screenshot of a marketing page is not a control, and a claim in a security questionnaire that you cannot trace to a clause is a liability.
Lifecycle — the model is a dependency
Model versions are deprecated, defaults move, and behaviour changes without your code changing. Pin the version you tested where the provider allows it, subscribe to deprecation notices, keep an evaluation set that runs before you accept a new version, and put prompt and system-message changes under the same change control as application code — they are configuration that alters behaviour, and they are frequently edited by people outside the release process. Rate limits and spend belong here too: unbounded consumption is a real availability and cost risk, and a per-service quota is the control.
There is a reporting consequence worth settling early. A retrieval pipeline you built is part of your system, so it sits inside your system boundary and its controls are yours to describe and to have tested. The model provider is a vendor managed under CC9.2, and depending on how you describe the system it may be a subservice organization, which brings carve-out or inclusive treatment and complementary controls into play. Decide that before the description is drafted rather than during fieldwork, and note that a SOC 2 report from the provider covers the provider’s controls — it says nothing about whether your retrieval layer filters correctly.
The same distinction governs what you can tell your own buyers. Vendor assurance about the model platform and assurance about your application are separate claims, and relying on a vendor’s report for the second is the substitution a careful reviewer will catch.
What to re-review when a connector changes
An annual review of AI connectors is the wrong instrument, because the changes that matter are events and they do not wait for the calendar. Wire the list below to the platform audit log and the vendor release notes, and treat each entry as a defined trigger with a named owner. This is the trust services criterion on identifying and assessing changes that could significantly affect internal control (CC3.4) applied to a system that changes underneath you.
| Change event | Why the previous approval no longer covers it | What to re-check | Who is watching for it |
|---|---|---|---|
| A scope is added to the OAuth application | The approval was for a set of permissions. A new scope is a new set, and scopes are coarse — one addition can move a connector from “read documents” to “read all sites in the tenant”. | The consent grant record in the identity provider, the reachable content under the new scope, and whether the tier of the connector has changed. | Consent-grant alerting in the identity provider, owned by IAM. |
| The identity model changes | This is the change that most often defeats a prior approval, and it usually happens for a good operational reason: delegated per-user authorisation would not scale to a nightly index, so someone switched to an application identity. | Everything. A connector approved on delegated identity and running on an application identity is a different connector with a different risk. Treat it as new. | The AI platform admin audit log, owned by the named connector owner. |
| A new site, space, project or repository is added inside an approved connector | The connector was approved against a described corpus. Corpora grow by default, and the new location arrives with whatever permissions its owner set. | The inclusion list, the permissions on the new location, and whether it holds a data class the original assessment excluded. | Nothing raises it. The connector’s own inclusion list, read at the monthly reconciliation. |
| Permissions change at source | A space made open to the organisation, a broad group added to a site, or a role redefined in the CRM changes what the connector reaches without anyone touching the connector. | The broad-sharing report, and whether the index refresh has picked the change up yet. Permission drift is the failure mode with no event in the AI platform’s own log. | The broad-sharing report over the indexed corpus, owned by the source-system business owner. |
| The vendor adds capability to an existing connector | Read-only integrations acquire actions. A connector that could summarise a ticket can now update one, and the release note is the only notice you get. | The action list, whether write is enabled by default, and whether your approval record still describes the product you are running. | Vendor release notes, read by a named person as a duty rather than a habit. No system will tell you. |
| The user population is extended | A pilot of 25 volunteers and a rollout to 4,000 staff and contractors are different assessments even with identical connectors, because the weakest permission in the estate now has 4,000 chances to be found. | Guest and contractor identities, the broad-sharing report at the new scale, and whether training and acceptable-use acknowledgement covers the new population. | The rollout change ticket, which exists — the risk is that nobody routes it to security. |
| The refresh cadence or index architecture changes | Moving from live query to a cached index, or lengthening the refresh interval, lengthens the window in which revoked access still returns content. | The stated staleness window, and whether it is now longer than the revocation commitment in your own access-management control. | The engineering change record, owned by whoever runs the retrieval pipeline. |
| Region, retention or subprocessor terms change | A hosting region or retention default that moves is a contractual and privacy change, not a security one — which is why security review will not catch it. | The DPA, the subprocessor list, your own customer notification obligations, and the record of what you told buyers in their questionnaires. | Whoever maintains the subprocessor list — legal or privacy, not security. Vendor notice arrives by email to a mailbox, not to a queue. |
| The model behind the connector changes | Retrieval behaviour, refusal behaviour and summarisation fidelity all shift with the model. Nothing about the permissions changed. What the system does with what it retrieved did. | Your evaluation set, any prompt or system-message dependencies, and whether the change was announced or discovered. | The evaluation set itself, owned by whoever maintains it — a regression is often the first notice you get. |
Read the fourth column on its own and the real problem appears: four of the nine produce no event in any system security currently watches. A new space inside an approved connector, a permission changed at source, a capability added by the vendor, and a subprocessor or retention term that moves all arrive silently, and three of the four are owned by somebody outside security. That is why the ownership column names a source of signal rather than a job title — an owner with no signal to watch is a name in a policy, not a control.
Two of these deserve a standing monthly job rather than a trigger, because they change without producing an event in any system you watch: the reconciliation of enabled connectors against approved connectors, and the broad-sharing report over the indexed corpus. Both take minutes when they are routine and days when they are archaeology. Where the deployment sits inside a SOC 2 observation period, a connector change that alters the control environment is a mid-period change with its own handling, and it is better raised by you than discovered in the walkthrough.
What an examiner actually requests
If the AI platform is inside your system description, these controls are tested like any other, by a licensed CPA firm under AT-C 205, and the first request is never a screenshot. It is a population — because a sample drawn from an incomplete list proves nothing about the list. The same artefacts serve an ISO/IEC 42001 certification audit, where the certification body reads them against your AI system inventory, your impact assessments and your third-party controls.
| The request | What satisfies it | What gets rejected |
|---|---|---|
| The complete population of enabled connectors | A system-generated export from the AI platform’s admin console at period start and at period end, with the filter and record count visible, reconciled to the enterprise-application and OAuth-grant list in the identity provider and to the procurement record. Three sources, one list. | A hand-maintained inventory sheet. A screenshot of the console taken during fieldwork. Any list that omits user-consented applications, which is where the connectors nobody approved actually appear. |
| Approval evidence for each connector | A dated approval record naming the connector, the identity model, the corpus, the data classes involved, the approver and the assessment tier — dated before the enablement date in the admin log. | An approval dated after enablement. An approval that names the vendor rather than the integration. A record with no identity model stated, because that is the field the change trigger tests against. |
| Evidence that permissions are enforced as described | A documented negative test: a control account without rights to a named location, a query that should return nothing, the result, the date and the tester. Repeated at a stated cadence and after any change to the identity model. | A vendor statement. A design diagram. A single test performed during the pilot and never repeated, offered as evidence for a twelve-month period. |
| Retrieval and access logs for the period | An export showing who asked, what was retrieved, from which connector and when, with the query, filter, date range and record count on the face of it. Retention longer than the observation period plus the lag before anyone asks for it. | A dashboard showing the last thirty days for a twelve-month period. Logs that record prompts but not retrieved sources, which cannot answer the only question that matters after an exposure. |
| Evidence that revocation propagates | A timed test: access removed at source, the elapsed time recorded, a query run, and the result documented — showing both the outcome and the staleness window in hours or days rather than in adjectives. | The access-review sign-off on its own. It evidences that rights were reviewed in the source system, not that the index and the caches followed. |
| The change record for connectors modified in the period | Tickets or change records for each of the trigger events, showing what changed, what was re-assessed, who approved and when — traceable to the admin audit log entry for the change. | A statement that no connectors changed, contradicted by the platform audit log. This is a routine and avoidable exception: the log is the population, not your recollection. |
Sample sizes for AI connector controls
A population is only half the answer. The other half is how much of it gets tested. The figures below are market and audit practice under AICPA sampling guidance rather than a requirement of any standard — the service auditor sets the sample, and a smaller population or a history of deviations moves it. The general sample sizes used across a SOC 2 examination apply here unchanged. What is unusual about AI connector controls is how small the populations are.
| Control | Frequency | Population over a 12-month period | Typical sample | The artifact for each item |
|---|---|---|---|---|
| Connector approval | Per connector — event-based | Every connector enabled in the period. Nine, in the illustration used on this page. | Tested at 100% where the population is under about 25. | The dated approval record with the identity-model field populated, dated before the enablement entry in the admin audit log. |
| Enabled-versus-approved reconciliation | Monthly | 12 | 2 to 5 | The signed reconciliation with the console export attached, showing the filter and record count on the face of the export. |
| Negative permission test | Quarterly, plus on any identity-model change | 4, plus one per change event | All of them — the population is too small to sample. | Control account without rights, the query run, the null result, the date and the tester named. A screenshot without a date is not this. |
| Retrieval log review | Per query — continuous | The full retrieval log for the period. | About 25 retrievals. | Each sampled retrieval traced back to the asking user’s entitlement in the source system at the time of the query, not at the time of testing. |
| Connector change re-assessment | Event-based, driven by the platform audit log | Every change entry in the admin audit log for the period. | 100% — the log is the population. | The change record for each entry, showing what changed, what was re-assessed, who approved it and when. |
The populations here are small, which makes them unforgiving. A twelve-month period at a company with nine connectors gives a population of nine approvals, twelve monthly reconciliations and perhaps three change events — small enough that the auditor tests all of them, so a single missing approval is a known deviation rather than an estimate, and there is no sampling risk to hide behind. Two adjacent populations are also frequently zero — AI incidents, and erasure requests touching AI copies — and a control with no occurrences cannot be tested for operating effectiveness at all. Prefer designs that operate anyway: the monthly reconciliation and the periodic negative test produce evidence every cycle whether or not anything went wrong, which is precisely why they are the two controls worth building first.
The vocabulary is the same as everywhere else in an examination. Anything you export is information produced by the entity, so the query, the filter, the date range and the record count have to be visible on the face of it — the rules for evidence do not soften because the subject is new. And retention is the detail that turns a tidy programme into a scramble: AI platform audit and retrieval logs frequently retain for a period set by your licence tier, which may be shorter than your observation period. List every log you cite in a control description, write its retention beside it, and export monthly to your own storage wherever it is shorter than the period plus ninety days.
On roles: Tranquility Cybersecurity designs and implements these controls, prepares the evidence and coordinates the examination. The report is issued by a licensed CPA firm and an ISO/IEC 42001 certificate by an accredited certification body — TCSA never certifies, attests, audits or signs, and a firm that designed your controls cannot then examine them.
The cases that produce the real arguments
The method above covers the ordinary eighty per cent. These are the situations where reasonable people inside the same company disagree, and where settling the position in writing before deployment saves a great deal of time later.
The connector the vendor turns on for you
Capabilities arrive in updates, sometimes enabled by default, sometimes as a preview that graduates. Your approval was for a product that no longer exists in exactly that form. Three defences, none of them technical: a contractual notice obligation for material changes where your leverage supports it, a named owner who reads release notes as a duty rather than a habit, and a standing monthly reconciliation of the enabled-connector list against the approved list. The reconciliation is what actually catches it, and it takes minutes.
User-consented applications — the shadow connector
An employee signs into a third-party AI tool with their work account and grants it read access to mail and files. No administrator saw the request, the tool is not in your inventory, and it is a connector in every sense that matters. The control is a tenant consent policy that requires administrative approval for applications requesting sensitive scopes, backed by a periodic review of granted applications. A policy document forbidding it is not a control. The consent setting is. This is the overlap between connector governance and shadow AI, and it is where most estates have their real exposure.
A permission model nobody can describe
Legacy file shares and long-lived wikis frequently have permissions that no current employee can explain. You cannot inherit a model you cannot describe, and the honest options are three: exclude the corpus and say so, remediate the permissions before indexing, or index a hard allowlist of locations whose permissions were verified. What does not work is indexing the estate and monitoring for surprises, because the surprise is delivered to a user in a natural-language answer before anyone reviews a log.
Guests, contractors and shared channels
Guest identities in a document or chat tenant were provisioned for a project and rarely reviewed afterwards. Add an assistant and a partner’s contractor holds a natural-language interface to whatever their guest account can still reach — which, in a shared channel that has been reused for three projects, may include another customer’s material. Where guest access exists, the connector assessment has to state whether external identities may use the assistant at all, and the answer should usually be that they may not until guest access has been reviewed.
Adding a subprocessor without noticing
Connecting an AI platform to a system holding customer data may make that platform a subprocessor under your customer agreements, triggering notification obligations, an updated subprocessor list, and in some contracts an objection window. This is a contractual failure rather than a security one, so it will pass a security review unchallenged and surface months later in a renewal. Check the DPA before enabling the connector, and route AI connector approvals past whoever maintains the subprocessor list.
Deleted at source, alive in a transcript
An erasure request, a mistakenly shared document, or a file withdrawn by legal is removed from the source system and remains in every conversation that quoted it. Answering an erasure request therefore requires a map of the copies — index, cache, transcript, provider logs, evaluation datasets — and an administrative route into each. Build that map during the assessment, when it takes an afternoon, rather than during the thirty-day response window.
Aggregation without any excess entitlement
The hardest case, because both sides are right. No permission was exceeded. Something new was nonetheless created. Our working position is that an assistant answering aggregate questions across a corpus is a distinct use requiring its own approval and its own impact assessment, separate from the connector that made the data reachable. Where the aggregate touches employees — performance signals, sentiment, activity patterns — treat it as a workforce-monitoring question with the consultation obligations that carries in your jurisdictions, not as a search feature. Where the aggregate feeds an employment decision — performance, promotion, allocation or termination — it may engage Annex III of the EU AI Act, Regulation (EU) 2024/1689. The Digital Omnibus on AI, Regulation (EU) 2026/1744, published in the Official Journal on 24 July 2026 and in force from 27 July 2026, deferred the application of obligations for stand-alone Annex III high-risk systems from 2 August 2026 to 2 December 2027. AI embedded in products already covered by EU product-safety law moved to 2 August 2028. Deferral is not exemption, and it does nothing to the works-council and employee-representative consultation duties that attach to workforce monitoring in several member states — those bite now.
Where employees have already connected tools you never approved, the problem is not really a connector problem — start with shadow AI governance and the consent policy that makes the inventory possible in the first place.
What buyers push back on and the answer
These six now appear in almost every enterprise security review where AI touches customer data. The difference between a good answer and a defensive one is, as always, whether it is traceable to something.
“Does your AI vendor train on our data?”
Answer with a tier, a clause and a date rather than an adjective. The defensible response names the plan or deployment tier you are on, quotes the contractual commitment or the documentation section that governs training and retention, states when you last verified it, and says what would tell you if it changed. Enterprise and consumer tiers generally differ here in a structural way, and it is fair to say so — but a buyer who has read a vendor’s marketing page already knows the marketing answer. What distinguishes a serious response is the traceability, and the willingness to say which parts you cannot control.
“Your assistant can read everything an employee can read.”
That is usually accurate, and arguing with it is a mistake. Answer with the four artefacts that make it a governed condition rather than an accident: the connector inventory with the identity model recorded against each, the exclusion list and how it is enforced, the negative test showing a restricted location is not returned, and the retrieval log with its retention period. Then say what you did about the underlying permission model — a broad-sharing remediation programme with dates does more for a buyer’s confidence than any statement about the AI platform itself.
“No customer data may enter an LLM.”
Ask what the sentence means before agreeing or refusing, because it usually conflates three different requirements: that data must not be used to train a model, that it must not be retained by the provider, and that it must not be processed by the provider at all. The first two are commonly satisfiable with an enterprise agreement and a documented configuration. The third is a genuine architectural constraint that points at self-hosted or in-tenant deployment. Establishing which one is meant converts an apparent blocker into a scoping conversation, and it frequently turns out that the requirement was drafted for consumer tools.
“How do you prevent one customer’s data reaching another?”
For a vendor who has built retrieval into a product, this is the question the assessment turns on. Describe the mechanism precisely — whether tenancy is a separate namespace, collection or index rather than a metadata filter applied at query time — state where in the request path it is enforced, and explain how it is tested. The strongest available answer is an automated negative test running in the build pipeline that proves a query authenticated as tenant A cannot retrieve tenant B’s content, plus the date it last ran. Design intent is an assertion. A failing build is a control.
“You added AI to a product we already assessed.”
Take the point seriously rather than treating it as a formality. An AI feature over data the customer already entrusted to you can still be a material change: new subprocessors, new retention, new data flows across regions, and a new failure mode in which their content is summarised into someone else’s answer. Where the product is inside a SOC 2 system description, adding a retrieval pipeline and a model provider is a change to the description, not merely to the software — which is a mid-period change question with its own handling. Notify, describe, and be ready with the connector inventory.
“Show me that revocation actually works.”
Do not answer this from the design. Answer it from a timed test: rights removed at source at a recorded time, a query run by the affected account, the result and the elapsed interval documented. The number you report is your staleness window, and it will be honest — typically inside the access-token lifetime on a live-query connector, and a day or two on a nightly index. Reporting a real window with a compensating control, such as a shorter refresh for sensitive locations, reads far better than a claim of immediacy that the architecture cannot support.
Frequently Asked Questions
If the AI platform respects existing permissions, what is left to assess?
Do we have to assess every connector individually?
What is the difference between delegated and application identity, in practice?
How stale can a retrieval index be after we revoke someone’s access?
Is a vector database sensitive if it only contains numbers?
How do we stop one customer’s data reaching another in a RAG system?
What changes when we call a model API directly instead of using a connector?
When does adding an AI connector require telling our customers?
What evidence should we be keeping from day one?
Who owns connector approval — security, privacy, or the business?
Related Reading
Copilot Oversharing and Permission Hygiene
AI collapses the effort to discover information, so latent over-permissioning becomes exploitable.
Read moreHow Much Should an AI Agent Be Allowed to Spend?
Per-transaction ceilings are the easy part. Velocity and aggregate limits are what actually bind.
Read moreWhat Counts as an AI Incident?
The classification test, the categories worth defining, and what an AI incident record must capture.
Read moreThe Ten Questions That Govern Any AI Agent
Scope, ownership, data, capability, identity, oversight, failure detection, evidence, reassessment and how to stop it.
Read moreISO 42001 Knowledge Hub
AIMS controls, EU AI Act mapping, risk assessment and guides.
Read moreISO 42001 (AI Management)
The world's first AI management system standard, for AI builders.
Read more