Skip to main content
COOKIE NOTICECOOKIE CHOICE

We use cookies for analytics (Google Analytics) and ad measurement (Google Ads, including remarketing, and ChatGPT Ads by OpenAI). Strictly necessary cookies keep the site working. See our Cookie Policy for what each one does and how to opt out.

We’d like to use cookies for analytics (Google Analytics) and ad measurement (Google Ads, including remarketing, and ChatGPT Ads by OpenAI), and none of them is set unless you accept. Cookie Policy

Learn · AI Governance

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.

10connector classes, tiered by what they reach
5identity models a connector can run on
20+frameworks TCSA advises across

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.
The sentence everyone stops at

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.

Proportionate assessment

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 classWhat it actually reachesUsual identity modelAssessment tierDecide before approval
Calendar and free/busyMeeting 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 tierWhether 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 mailboxEverything 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 checkList 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 assessmentWhether 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 assessmentHow 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 assessmentWhether 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 assessmentWhether 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 assessmentWhether 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 repositoriesCoding 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 assessmentRepository 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 assessmentA 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 assessmentTool-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 vendorThe 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 providerThis 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, namedThe field that decides whether permission inheritance is real. Leave it blank and every downstream control is unverifiable.
Granted scopes, quoted verbatim from the consent grantParaphrasing 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, tablesThe 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 reachableDrives the assessment tier, the impact assessment, and whether the DPA and subprocessor questions arise at all.
Actions permitted — read, write, delete, administerFour 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-levelThe 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 queryDecides whether you have one permission model or two, and whether a staleness window exists at all.
Refresh interval, and the measured staleness window in hoursMeasured, not stated. This is the number that gets compared against the revocation commitment in your access-management control.
Retrieval log location and retention periodThe 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 ownerEach 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 ownerThe person the change triggers notify. A team name is not an owner.
Enablement date in the admin audit logApproval dated after enablement is a routine exception. This field is what an examiner compares the approval date against.
Date of next monthly reconciliationTurns 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.

Retrieval

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.

LayerWhat it holdsWhose permission model appliesWhat revocation at source does to it
Source systemThe 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 storeChunked 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 cacheRecently 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 transcriptThe 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 monitoringPrompts 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 datasetsSampled 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.

Worked example

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.

Approval14 January 2026The 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.
Pilot2–27 FebruaryTwenty-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 change9 MarchRollout 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 exposure24 March, 11:40A 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.
Containment24 March, 14:05–18:30The 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.
Answer25–27 MarchThe 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.
Assessment26 MarchThe 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 change31 MarchThe 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.
— the rule this example exists to produce
A different case entirely

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.

Change management

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 eventWhy the previous approval no longer covers itWhat to re-checkWho is watching for it
A scope is added to the OAuth applicationThe 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 changesThis 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 connectorThe 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 sourceA 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 connectorRead-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 extendedA 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 changesMoving 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 changeA 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 changesRetrieval 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.

Evidence

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 requestWhat satisfies itWhat gets rejected
The complete population of enabled connectorsA 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 connectorA 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 describedA 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 periodAn 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 propagatesA 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 periodTickets 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.

ControlFrequencyPopulation over a 12-month periodTypical sampleThe artifact for each item
Connector approvalPer connector — event-basedEvery 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 reconciliationMonthly122 to 5The signed reconciliation with the console export attached, showing the filter and record count on the face of the export.
Negative permission testQuarterly, plus on any identity-model change4, plus one per change eventAll 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 reviewPer query — continuousThe 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-assessmentEvent-based, driven by the platform audit logEvery 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.

From the other side of the table

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?
Three things. Whether the permission model being inherited is correct, which for most estates of any age is an open question until someone runs a broad-sharing report. Whether entitlement to reach content amounts to authorisation to use it for this purpose, which is a separate governance decision with a separate owner and separate legal anchors in purpose limitation. And which of the several possible identity models the connector actually runs on, because an application identity does not inherit user permissions at all — it replaces them with whatever the application was granted. A vendor statement about inheritance answers none of these.
Do we have to assess every connector individually?
No, and trying to is how AI programmes stall. Approve the platform once for the durable questions — hosting region, tenancy and isolation, contractual terms on retention and training, administrative controls, audit logging and retention, subprocessors, authentication — then send a connector to individual assessment only when it trips a written trigger. Our triggers are regulated or special-category personal data, content under customer confidentiality obligations, security or privileged systems, write or action capability, an application rather than delegated identity, an undescribed source permission model, an index rather than a live query, and constrained cross-border movement. A calendar connector needs none of that. A document tenant or a data warehouse needs all of the attention you can give it.
What is the difference between delegated and application identity, in practice?
With delegated identity the connector acts on behalf of the signed-in user, every request is evaluated by the source system against that person’s rights, and the downstream log records the person. With an application identity the connector authenticates as itself, has no user context, and is authorised by whatever grant the application holds — so the user’s own permissions are never consulted. Application identity is common for background indexing because per-user authorisation does not scale, and it is acceptable only where the platform re-applies the user’s rights at query time. Record which model each connector uses. It is the field that decides whether inheritance is real.
How stale can a retrieval index be after we revoke someone’s access?
That depends on whether permissions are evaluated at query time or copied into the index at index time, and on the refresh interval — and it is a number you should measure rather than assume. Run a timed test: remove rights at source, note the time, run a query as the affected account, and record the elapsed interval before the content stops being returned. On a live-query connector the window is bounded by access-token lifetime — minutes where the source re-evaluates authorisation on every request, and commonly up to about an hour where it does not. On a cached index with a nightly refresh, expect 24 to 48 hours once queueing is counted, and days for a full re-index of a large corpus. Whatever the number is, it is your staleness window, and it should appear in the risk record alongside any commitment your access-management control makes about revocation timing.
Is a vector database sensitive if it only contains numbers?
Yes. Embeddings are derived from the source text, and published research on embedding inversion shows that meaningful content can be recovered from them, so a vector store is not an obfuscation layer. Retrieval indexes also typically hold plain-text chunks, titles, paths and access-control metadata alongside the vectors. The working rule is that the index inherits the classification of the highest-classified content it contains and receives the same encryption, access control, logging, backup and retention treatment as the source system. The OWASP Top 10 for LLM Applications covers this area in its Vector and Embedding Weaknesses entry. Cite it by name and state the edition, because the 2026 edition published on 4 August 2026 renumbered several entries against the 2025 list.
How do we stop one customer’s data reaching another in a RAG system?
Make tenancy a boundary rather than a filter. A separate index, collection or namespace per tenant fails closed if something is misconfigured. A tenant identifier applied as a metadata filter in the query fails open if any code path omits it — and there is always another code path, whether a re-ranking job, an internal support tool or a migration script. Enforce the boundary as early in the request path as possible, before retrieval rather than after generation, and prove it with an automated negative test in the build pipeline showing that a query authenticated as one tenant cannot retrieve another’s content. Design intent is an assertion. A failing build is a control.
What changes when we call a model API directly instead of using a connector?
Everything about inheritance, because there is nothing to inherit. There is no connector framework and no end-user content entitlement in the request. The cloud platforms still authenticate the caller — Azure OpenAI in Microsoft Foundry through Entra ID and Azure RBAC, Bedrock through an IAM principal, Vertex AI through Google Cloud IAM — but that identity is the workload, not the person asking, so whatever your application places into the prompt is what the model receives and your code is the content permission model. Four things then need governing separately. First, the architecture and where the tenant boundary is enforced. Second, credentials, where the order of preference is a managed or federated workload identity first and a stored bearer key only where the endpoint offers nothing better, with secrets-manager storage, per-environment separation and rotation. Third, retention and training terms, confirmed in the executed agreement and current documentation with the date you captured them. Fourth, lifecycle, meaning version pinning, deprecation notices, an evaluation set, and prompt changes under change control.
When does adding an AI connector require telling our customers?
When it changes something you have told them or committed to. Connecting an AI platform to a system holding customer data may add a subprocessor under your data processing agreements, which typically triggers list updates, notification and sometimes an objection window. It may also change the hosting region, the retention of their content, or the answers you gave in their security questionnaires. Where the affected product sits inside a SOC 2 system description, adding a retrieval pipeline and a model provider is a change to the description as well as to the software. This is a contractual and reporting question rather than a security one, which is why a security review alone will not catch it — route AI connector approvals past whoever maintains the subprocessor list.
What evidence should we be keeping from day one?
Five artefacts, all of them cheap while they are current and expensive to reconstruct. A connector inventory generated from the admin console rather than typed, recording the identity model, corpus and data classes for each. A dated approval record for every connector, dated before enablement. A documented negative test showing a restricted location is not returned to an account without rights, repeated on a cadence and after any identity-model change. Retrieval logs that record which sources were returned to which user, retained longer than your observation period plus the lag before anyone asks. And change records tied to the platform audit log entries for connector changes, because the log is the population an examiner will test against.
Who owns connector approval — security, privacy, or the business?
Security owns the identity and access questions, privacy owns the purpose and lawful-basis questions, and the business owner of the source system owns whether the content may be exposed to a new class of reader at all. The mistake is letting any one of them decide alone: security approvals tend to stop at whether permissions are enforced, privacy approvals at whether a basis exists, and business approvals at whether the feature is useful. Give the record one approver per axis and a single named owner for the connector as a whole, and put it in the AI system inventory rather than a separate spreadsheet — that owner is who the change triggers notify.

Written By Expert Auditors

Surendra Pal SinghChief Information Security Officer & Data Protection OfficerCISODPOCISAMCSEITILISO 27001 Lead AuditorISO 27701 Lead AuditorISO 42001 Lead Auditor
Saundhi ChauhanLead AuditorISO 27001 Lead AuditorISO 27701 Lead AuditorISO 42001 Lead Auditor
Last reviewed: August 2026 • Content verified by certified lead auditors

Get in touch

Book a free consultation or send us your requirements. We respond within 24 hours.

Send us your requirement.

01Your details
02What is it about?
ISO 42001 (AI)
03Send
Asking about: ISO 42001 (AI)