Shadow AI: How to Stop Company Information Leaking Into External AI Systems
A finance manager needs to explain an unexpected expense. A developer wants help debugging production code. A procurement team wants to compare contracts before a meeting. Instead of working through the material manually, they open an AI assistant, attach a file and ask a question. Minutes later, they have a useful answer. There is a second question that often goes unasked: where did the information go? The spreadsheet may contain salaries and account details. The code may contain credentials, infrastructure information or proprietary business logic. The contract may disclose confidential supplier pricing.
The employee wanted to do their job faster, not disclose company information. But an otherwise ordinary AI interaction can become an unauthorised data transfer the moment that content crosses into an external processing environment. We use AI data egress to describe this problem: organisational information leaving an approved security boundary through AI prompts, uploads, retrieval pipelines, agents, integrations and supporting infrastructure. Shadow AI is the unapproved or insufficiently governed use of AI tools.
The two overlap, but they are not identical. A company can eliminate shadow AI by approving one enterprise assistant and still have an AI data egress problem if that assistant can access too much information or sends it to the wrong place. At Sulta Tech, we see the solution as an engineering and governance problem rather than a campaign to stop employees from using AI. The objective is to give people capable AI tools while making sensitive data handling deliberate, enforceable and auditable.
Why this matters now
AI has entered everyday workflows faster than most organisations have adapted their data controls. In a 2025 global study involving more than 48,000 people across 47 countries, 48% of employees surveyed reported uploading company information into public AI tools. Research into enterprise AI activity in 2026 found sensitive information in 39.7% of observed AI interactions across a monitored group of 222 companies. Research into breaches also found shadow AI linked to one in five breached organisations surveyed in 2025.
The pattern is straightforward. Employees discover a tool that saves them hours, then move business material into it without necessarily understanding the processing arrangement. Meanwhile, organisations introduce coding assistants, AI-enabled SaaS products and internal agents, creating more routes for data to travel than the traditional browser-chatbot example suggests. A blanket ban rarely addresses the underlying demand. When an approved option is slower, less useful or difficult to access, employees have an incentive to work around it. We believe the more sustainable answer is to build an approved AI environment that is genuinely useful. Unsafe data transfers should also be difficult at the infrastructure level.
The data leak is not always in the prompt
The obvious exposure is someone pasting confidential text into a public assistant. We are more concerned about the less visible data flows that appear as enterprises begin integrating AI into real operations.
| Where data leaves | Example | What may be exposed |
|---|---|---|
| Employee prompts and file uploads | An analyst uploads a payroll workbook | Employee details, salaries, banking information |
| Coding assistants | A developer shares source files or a production traceback | Proprietary code, tokens, internal endpoints, system design |
| Retrieval-augmented generation (RAG) | An assistant retrieves full documents to answer a narrow question | Confidential passages the user or model did not need |
| AI agents and connectors | An agent reads inboxes, CRM records and contract repositories | Email, customer records, attachments and tool responses |
| Logs and observability | A team enables verbose agent tracing to diagnose errors | Full prompts, retrieved documents, responses and credentials |
| AI features inside other SaaS products | A familiar business app sends a document to its AI backend | Content disclosed to additional processors or services |
A modern AI request is often assembled from much more than the sentence an employee types. The system may attach retrieved passages, conversation history, memory, internal tool output and records gathered from several applications. All of that becomes part of the model's context. If the model runs outside the organisation's approved boundary, the full constructed request matters, not just the visible prompt. Agents make the problem more serious because they can act. Consider an agent allowed to search internal email and send messages. It encounters an incoming email containing malicious instructions disguised as a business request.
If the agent treats those instructions as authority, it may retrieve unrelated internal information and send it to an external address. Prompt injection becomes a data-egress risk when untrusted content can influence access to sensitive data or outbound actions. We therefore treat prompts, retrieved content, tool calls, model responses, traces and network destinations as parts of one security system. Securing the model alone leaves the rest of the path exposed.
What does “private AI” actually mean?
One of the biggest sources of confusion in enterprise AI procurement is the word private. It can refer to a contractual promise, a network connection, a dedicated deployment, a geographic region or a fully controlled runtime. Those are different properties. Before approving a model or provider, we separate five questions:
- Training: Can customer prompts, files or responses be used to improve a model?
- Retention: What is stored for logging, monitoring, abuse detection, product features or backups, and for how long?
- Processing: Where does inference take place, and can a request be routed into other regions?
- Access: Who can access the data, including provider staff, subprocessors and connected tools?
- Enforcement: Can we apply our own identity, classification, permissions, retention and egress policies?
No model training does not mean no data retention. A private endpoint does not mean a private model runtime. Regional data storage does not necessarily mean regional inference. These distinctions affect the architecture and the contract, so we evaluate them separately. Take an enterprise API that does not use customer input for model training. That is useful, but prompts may still be processed by the provider and, depending on the service and configuration, retained for monitoring or application features.
A dedicated network connection may prevent traffic from travelling over the public internet while the inference infrastructure remains managed and operated by the provider. Neither arrangement is inherently unsuitable. The important point is to know exactly what security boundary has been established. We look at the specific deployment and data path, not simply the name of the AI model. The same model family can be available through a consumer application, an enterprise API, a managed cloud environment and a privately operated runtime, each with different handling of organisational information.
The five architectures we consider
There is no reason to place a public marketing draft and a confidential legal investigation on the same AI processing path. Different workloads justify different controls. We normally assess five architectural options, and often combine them.
1. An approved enterprise AI workspace
This is usually the fastest place to begin. Give employees a managed AI environment with single sign-on, corporate identities, clear usage rules, documented data handling and administrative visibility. The organisation can establish which information classes are permitted, disable unsuitable integrations and provide practical training around uploads and prompts. The immediate benefit is replacing uncontrolled personal accounts with an approved environment. It also makes governance easier because employees no longer need to choose between getting work done and following policy. The limitation is that approved does not mean unrestricted. Even a well-contracted enterprise service should not receive credentials, unrestricted payroll exports or documents an employee is not entitled to share. Enterprise procurement reduces uncertainty about a provider; it does not replace internal authorisation controls. We would typically use this route for general drafting, research against public material and low-risk internal productivity tasks where a vetted external processor is acceptable.
2. A central AI gateway with data-loss prevention
An AI gateway sits between applications or employees and the inference services they use. Instead of every department integrating directly with its own provider, approved AI traffic moves through one control point where policy is enforced. The gateway authenticates the caller, identifies the workload, checks data sensitivity, inspects attachments and tool arguments, and decides whether to allow, redact, transform, block or reroute the request. It can also apply output checks and capture security metadata without indiscriminately storing the entire prompt.
For example, an HR analyst might ask for a summary of pay trends. Our preferred design would not upload the complete payroll file and hope the model ignores the personal information. An internal service could calculate the relevant aggregates first. The model receives only the values needed to prepare the explanation. If the task genuinely requires employee-level records, it is routed to an explicitly approved environment with appropriately restricted access. This is a stronger approach than relying on prompt instructions because the decision is enforced before information reaches a model. A gateway still has limitations. Redacting names may not anonymise a person when job titles, dates, locations and compensation values remain. Employees may also bypass the gateway using personal devices, browser sessions or applications that invoke external models behind the scenes. Gateway controls therefore need endpoint management, approved integrations, network rules and employee education around them.
For organisations planning to use several models, a central gateway is often the most important investment because it provides one place to apply governance while keeping model choices flexible.
3. Private managed inference
This is one of the approaches we have been exploring at Sulta Tech. It sits between a conventional enterprise API and operating a model entirely ourselves.
Private managed inference can involve a tightly governed cloud deployment, a private network route to an approved inference service, or dedicated model-serving infrastructure managed under contract. The enterprise retains more control over how the model is reached, which identities can use it and, in some configurations, how the infrastructure is isolated.
The engineering decision is to separate network isolation from runtime isolation. A private endpoint reduces exposure of the connection, but it does not establish exclusive control over the GPU, operating environment or provider access.
A dedicated deployment may offer stronger separation. Its actual properties still depend on the product and contract. We examine infrastructure tenancy, administrative access, region and failover behaviour, logging, encryption, private routing, subprocessors and deletion. The whole chain must fit the organisation's data classification requirements.
South African organisations have an additional practical consideration: regional support for cloud services and model features is not uniform. A provider operating cloud infrastructure in South Africa does not automatically mean every model or supporting service processes data locally. We design around the specific region, model and endpoint combination available. A generic statement about having a local cloud region is not enough.
We see private managed inference as a useful option for enterprises that need tighter control without building a full model-serving operation. It can also make a hybrid platform viable: sensitive workloads use private inference while less sensitive tasks use contracted enterprise APIs.
4. Self-hosted open-weight models
When control over the inference environment is a hard requirement, self-hosting can be the clearest architectural answer. An organisation runs open-weight model files in its own cloud tenancy, private Kubernetes cluster or on-premises infrastructure and keeps the inference service behind its own authentication and network policies.
That gives the organisation far more direct control over where prompts are processed. It can keep model requests inside a designated environment and avoid sending raw inference content to an external model API. For some use cases, it also makes model customisation and high-volume economics more attractive.
But self-hosting is not synonymous with a private AI system. An application that runs the LLM internally but sends embeddings, OCR jobs, telemetry or agent traces to other services still exports information.
A private model connected to an over-permissioned document index may expose records across departments. A model server left on an open network port creates a new point of attack. A production deployment generally needs these components:
- Model serving: a tested inference runtime such as vLLM or SGLang, appropriate GPU capacity, batching and concurrency management.
- Application security: SSO, service identities, authorisation, request limits, authenticated gateways and secrets management.
- Private retrieval: internal ingestion, permission-aware document access, approved embedding models and encrypted vector storage.
- Network restrictions: private subnets, limited egress, firewall rules and approved service-to-service connections.
- Operational controls: patching, image scanning, model versioning, backups, recovery and monitoring without unnecessary prompt retention.
- Evaluation: repeatable tests for accuracy, latency, prompt injection, data disclosure and regression after model changes.
We would not expose a model-serving API directly to employees or the public internet. The serving runtime belongs behind an application layer that handles authentication, authorisation and security checks. An API key supported by an inference server is not necessarily a complete security perimeter for every endpoint.
The other trade-off is economic. GPU capacity must cover peak demand, not only average usage. Long contexts, high concurrency, multimodal workloads and large models can make self-hosting expensive or operationally complex. On the other hand, stable high-volume tasks can make dedicated infrastructure cost-effective, especially when smaller models perform well enough. Our preferred benchmark is cost per successfully completed, policy-compliant task. Token prices alone ignore hardware utilisation, engineering effort, model accuracy, retries and the business cost of incorrect results.
We start by testing representative tasks such as contract analysis, policy Q&A, extraction, classification and code assistance. We then choose a model size and serving strategy based on measured results.
Open-weight should also not be confused with unrestricted open-source licensing. Commercial use rights, distribution rules and model terms vary, and those conditions belong in the review before deployment.
5. Confidential inference
For workloads where even the infrastructure operator's access is a major concern, confidential computing adds another layer. Trusted execution environments, supported confidential GPUs and remote attestation can help protect data during processing and verify the software environment before sensitive material is released.
This approach is valuable for a specific threat model, particularly when an organisation needs to reduce the trust it places in cloud infrastructure operators. It does not fix excessive application permissions or malicious tool instructions. Nor does it fix unsafe logging or a vulnerable workload running inside the protected environment. We treat confidential inference as an additional protection, not an alternative to the rest of the architecture.
The architecture we recommend: classify first, then route
Our preferred enterprise design is a policy-routed AI platform. The organisation does not commit every task to one model or one provider. It defines approved data classes and processing environments, then routes each request accordingly.
textEmployees / Internal applications / AI agents | Corporate identity | Enterprise AI gateway +-----------+-----------+ | | | Classification DLP Tool permissions +-----------+-----------+ | Policy decision | +----------+----------+ | | | Enterprise Private Self-hosted API managed open-weight inference inference | | | +----------+----------+ | Output and egress controls | Authorised user
A simple routing policy might look like this:
| Data class | Examples | Default route |
|---|---|---|
| Public | Published product information, public articles, marketing ideas | Approved enterprise AI |
| Internal | Routine working notes without sensitive content | Approved enterprise AI or private managed inference |
| Confidential | Client proposals, internal strategy, non-public source code | Private managed inference or self-hosted environment with access checks |
| Restricted | Credentials, raw payroll, identity records, protected investigations | Block direct uploads; permit only specifically designed internal workflows |
The key is that the policy engine makes the permission decision, not the language model. A system prompt asking an assistant to keep information private is not an access-control mechanism. In a RAG workflow, access to each document should be checked against the requesting user's permissions before retrieved content is sent to the model. In an agent workflow, every tool should receive the minimum permissions and outbound destinations it needs.
High-impact actions deserve separate approval. An agent that can read information should not automatically be able to email it externally, change bank details, publish documents or execute payments. We would require explicit authorisation for those actions and record enough evidence to reconstruct what occurred.
How we would implement this in an enterprise
A secure AI environment should be delivered in stages. Trying to replace every AI service with self-hosted infrastructure on day one tends to create unnecessary complexity while leaving existing shadow usage untouched.
Start with visibility
First, establish which AI tools are actually being used. Look beyond chatbots: include IDE extensions, browser tools, internal APIs, CRM and productivity platforms, agent connectors and observability services. Map the categories of information each workflow sends and which services receive it.
The goal is not to monitor every employee conversation indiscriminately. It is to understand the paths through which company data can leave, identify unsafe defaults and build useful alternatives.
Classify the task and minimise the data
Next, decide what the model genuinely needs. A finance summary may require totals, not customer identifiers. A contract comparison may need selected clauses, not an entire folder of agreements. A troubleshooting task may need a sanitised trace rather than the full production environment. Data minimisation reduces risk regardless of which provider eventually handles the request. The safest sensitive field is often the one never placed in model context.
Give employees an approved tool worth using
Security controls that destroy productivity will not achieve lasting adoption. We would introduce an approved assistant or internal interface with the models employees need, straightforward access and clear examples of what information is allowed. Internal training should cover real situations. Those include code with secrets, supplier documents, client records, spreadsheets, emails and AI-enabled browser extensions. A secure path needs to be the easy path.
Enforce policies outside the model
Then deploy central access, request classification, DLP and routing. Restrict direct connections to unapproved inference endpoints where possible. Keep agent credentials scoped, apply document-level RAG permissions and separate read-only capabilities from write or send permissions. Configure retention across all systems: application database, model provider, caching, retrieval, tracing, monitoring and backup services.
Test for leakage, not only response quality
We would test the complete data flow with synthetic identities, canary secrets and representative documents. Can a user retrieve another team's files? Can a prompt injection inside an email trigger an external send? Do blocked requests still appear in observability logs? Can an employee reach the same model through an unmanaged route? Does a model update change how the agent handles confidential instructions? This is where AI evaluation becomes part of security engineering. A successful pilot should demonstrate both task quality and reliable containment of information.
Measure adoption and control effectiveness
Finally, measure what matters: use of approved tools, attempted transfers of restricted information, prevented policy violations, false positives, access-control failures, security-test findings, user satisfaction and cost per successful task. These measures reveal whether the architecture is improving both safety and productivity. For an initial 90-day programme, we would typically use the first month to map exposure and classify workflows, the second to introduce approved access and central controls, and the third to pilot private-model routing and run end-to-end security tests. The pace will vary with procurement and infrastructure readiness.
A South African consideration: POPIA and cross-border inference
For South African organisations, privacy engineering needs to account for the Protection of Personal Information Act (POPIA). When an AI prompt, document or retrieved passage contains identifiable personal information, processing it through an external model can create operator, security and cross-border transfer obligations. Four provisions shape our approach:
- Section 10: minimise personal information to what is adequate, relevant and necessary for the purpose.
- Section 19: establish reasonable technical and organisational security safeguards.
- Sections 20–21: control how operators process personal information and put appropriate security obligations in writing.
- Section 72: ensure cross-border transfers of personal information satisfy an applicable statutory condition. POPIA does not categorically prohibit foreign AI processing, and deploying a model in South Africa does not automatically establish compliance. What matters is whether the particular processing activity has a lawful basis, appropriate safeguards, contractual arrangements and compliant transfer mechanisms. We recommend tracing personal information through its entire lifecycle: original data source, retrieval, prompt construction, inference, output, logs, backups and deletion. That gives the information officer and legal team something concrete to review, and it lets engineers implement measurable controls rather than broad policy statements.
Not all confidential company information is personal information under POPIA. Proprietary code, unpublished pricing and commercial strategy may instead be protected through contracts, intellectual property rights, confidentiality obligations or sector-specific rules. Those assets still need an appropriate security boundary. Governance standards and risk frameworks can help organisations formalise these decisions, but no governance certificate compensates for an application that allows unauthorised retrieval or uncontrolled outbound tool calls.
What we would demand from an inference provider
Before connecting confidential enterprise workflows to a provider, we need answers that can be verified technically and contractually. We focus on the actual deployment, not broad claims about an AI brand.
- Is our content used for training or service improvement, including optional features?
- What information is retained across inference, logs, caches, monitoring and backups, and for how long?
- Where are prompts and outputs processed? Can inference, failover or monitoring cross regions?
- Is infrastructure shared, logically isolated or dedicated? Who has administrative access?
- What protections exist against direct network exposure and unauthorised internal access?
- Which subprocessors, tools and telemetry services receive data?
- Can we enforce identity, customer-managed keys where supported, retention and deletion?
- Can the provider support security review, incident response and verifiable deletion? These are not procurement formalities. They determine which classes of information the deployment should be permitted to process.
Our conclusion: private models are only one part of private AI
We have been investigating privately deployed inference providers and self-hosted open-weight models because both can give enterprises more control over their AI workloads. But our conclusion is broader than choosing between cloud and on-premises GPUs.
The organisation must control the entire route from the employee's request to the model, retrieval systems, tools, logs and outbound actions. A self-hosted model cannot protect a secret copied into a third-party tracing service.
A private endpoint cannot prevent an over-permissioned agent from emailing internal records. An enterprise licence cannot correct a retrieval system that ignores document permissions. For most organisations, the strongest practical design is a hybrid: give employees a managed AI experience, enforce policy through a central gateway, use contracted external inference where appropriate, and route sensitive work into more tightly controlled environments. Reserve fully self-hosted or confidential inference for workloads that justify those controls and their operational cost.
Employees should not have to choose between the productivity of AI and the confidentiality of their organisation's information. Our job as AI engineers is to make the secure option the natural one.