How Oracle Cloud Secures AI Applications and Data Privacy

Building an AI application that can answer questions from company documents is relatively straightforward compared with making sure it never reveals information to the wrong person.

Consider an organization developing an internal AI assistant. Employees should be able to search approved company policies, while finance managers need access to confidential financial reports. Both groups may use the same AI application, but they must not receive the same information.

What happens if an employee asks the assistant for a confidential report? What if a document contains instructions intended to manipulate the AI model? And how can the organization control where its data is processed?

Oracle Cloud Infrastructure (OCI) addresses these AI security and privacy challenges through identity management, private networking, data encryption, AI guardrails, database-level authorization, and security monitoring.

Oracle services such as OCI Generative AI, Oracle Data Safe, OCI Vault, Cloud Guard, and Oracle Deep Data Security help organizations implement different layers of protection.

However, using these services does not automatically make an AI application secure. Developers still need to configure appropriate permissions, evaluate data-handling requirements, validate AI responses, and test security controls.

This article explains eight important ways Oracle Cloud supports AI security and data privacy. It also includes an example AI application architecture, a simple Python access-control exercise, and practical steps for testing a secure AI workflow.

What Are AI Security and Data Privacy Challenges?

AI security focuses on protecting artificial intelligence systems, their supporting infrastructure, and their connections to business information.

Data privacy focuses on how personal and sensitive information is collected, accessed, processed, stored, retained, and shared.

These areas overlap, but they are not identical.

An application may use encrypted network connections and still expose confidential information if its access permissions are incorrect.

Similarly, an AI model might generate an apparently harmless response that contains information retrieved from an unauthorized document.

Common AI Security Risks

Organizations deploying AI applications need to consider:

Unauthorized access to business data
Prompt injection attacks
Sensitive information exposure
Excessive permissions assigned to AI agents
Insecure application APIs
Misconfigured cloud infrastructure
Inappropriate data retention
Unverified AI-generated responses
Weak monitoring of automated actions

Why Traditional Security Controls Are Not Enough

Traditional security measures remain essential, but AI applications introduce additional ways for information to move through a system.

For example, a retrieval-augmented generation (RAG) application might retrieve documents from a database before passing selected content to a language model.

The security challenge is not only protecting the database connection.

The application must also make sure the requesting user is authorized to receive the retrieved information.

The fundamental principle is that AI-generated instructions and responses must never replace trusted authorization controls.

1. OCI Generative AI Provides Documented Data-Handling Protections

Oracle Cloud Infrastructure Generative AI is a managed service for accessing supported large language models and building AI-powered applications.

One important privacy consideration is what happens to customer information during model inference.

Inference refers to the process in which a model receives input and generates a response.

Does Oracle Retain AI Prompts and Responses?

According to Oracle's OCI Generative AI data-handling documentation, the service does not retain prompts and responses as part of normal model inference.

Oracle also states that model providers do not use customer prompts and responses for their own independent model training or improvement under the documented service arrangements.

However, there is an important distinction.

Applications can use supported OCI features to save responses, conversations, uploaded files, or memory.

When these features are enabled, the application deliberately retains selected content according to its configured storage and retention settings.

What Happens When Using Third-Party Models?

Different models can have different processing arrangements.

Some supported models are hosted directly within OCI infrastructure.

Other supported models, including Google Gemini and xAI Grok, involve sending inference requests to an external provider for processing.

Oracle documents contractual Zero Data Retention agreements governing those external model requests.

However, the geographic processing location can vary depending on the selected model, OCI region, and routing configuration.

Practical Example: An Internal Document Assistant

A company wants employees to ask questions about internal policies.

Before deployment, the development team should identify:

Which model will process the request.
Whether the request uses OCI-hosted or external processing.
Which application features store conversation content.
How long retained information will remain available.
Whether the selected processing arrangement meets organizational requirements.

Why This Matters

Data privacy depends on the complete application configuration, not only the model provider's default inference behavior.

Key takeaway: Review model-specific processing, application retention settings, and data location requirements before sending sensitive information through an AI service.

2. Private Endpoints Reduce Unnecessary AI Network Exposure

AI applications often communicate with models through network endpoints.

These connections need suitable authentication, routing, and network security controls.

OCI Generative AI supports private endpoints for supported model access.

What Is an OCI Generative AI Private Endpoint?

A private endpoint provides a private IP address within an OCI Virtual Cloud Network (VCN).

It allows appropriately connected applications to access supported model services through a private network path.

For example, an organization may host an internal application in a private subnet and configure access to a supported AI model through a private endpoint.

How Private Networking Supports Security

The architecture can use:

Private subnets
Network Security Groups
Security lists
Routing rules
Approved private network connectivity
IAM permissions

The available configuration depends on the model and endpoint type.

OCI supports private access for applicable on-demand models and models hosted on dedicated AI clusters, subject to the documented requirements.

Practical Example: A Financial Reporting Application

A financial company develops an internal AI application that summarizes approved business reports.

Rather than making model access unnecessarily available through a public endpoint, the company configures a supported private access path.

Only appropriately authorized application resources with network connectivity can reach the endpoint.

An Important Limitation

Private networking and data residency are different concerns.

A private endpoint controls how an application reaches the service. It does not independently guarantee that every supported model processes requests in the same geographic region.

The organization must review model-specific processing documentation separately.

Key takeaway: Private endpoints can reduce network exposure, but they must be combined with identity management, access controls, encryption, and appropriate model selection.

3. OCI Generative AI Guardrails Help Manage Unsafe Inputs and Outputs

Generative AI applications can receive unexpected or deliberately manipulated instructions.

A user might submit harmful content, or an attacker might place instructions inside a document that the application later retrieves.

These are important security concerns for AI systems.

Oracle provides configurable OCI Generative AI Guardrails capabilities to evaluate selected input and output risks.

What Are AI Guardrails?

AI guardrails are controls that analyze content against defined safety and compliance criteria.

OCI Generative AI Guardrails supports several capabilities.

Guardrail Capability	Main Purpose
Prompt injection detection	Identify potentially manipulative instructions
PII detection	Identify selected types of personal information
Content moderation	Evaluate certain policy-restricted content
Topic management	Classify text against application-defined topics

The supported features depend on the guardrails version and configuration.

Prompt Injection Detection

Prompt injection occurs when untrusted content attempts to influence an AI application's behavior in ways that conflict with its intended instructions.

For example, a retrieved document might contain instructions asking the assistant to disregard its normal operating rules.

Prompt injection detection can help identify this type of suspicious content.

However, it cannot guarantee that every attempt will be recognized.

PII Detection

Personally Identifiable Information (PII) detection can help identify information such as names, email addresses, and telephone numbers.

Organizations may use the results to decide whether content requires additional handling.

According to Oracle's current documentation, PII detection supports English, so applications handling other languages should evaluate their protection requirements carefully.

Content Moderation and Topic Management

Content moderation helps evaluate selected categories of harmful or policy-restricted content.

Topic management allows applications to classify text against topics defined by the developer.

For example, a business assistant might be configured to recognize requests relating to internal HR policies.

A topic match is not automatically a security violation. The application must decide what to do with the classification result.

Inform Mode vs. Block Mode

For supported endpoints, Oracle documents different guardrail response modes.

Inform mode evaluates content and provides results for the application to review.

Block mode can reject requests when configured violations are detected.

For on-demand models using the ApplyGuardrails API, the API returns evaluation results, and the application must enforce any required decision itself.

This distinction matters because detection is not always the same as enforcement.

Practical Example

Suppose an AI assistant receives a message containing personal information and an instruction attempting to override the assistant's rules.

Guardrails may flag relevant concerns.

The application can then follow its configured policy, such as rejecting the request, requesting clarification, or sending the event for review.

Key takeaway: Guardrails provide an additional security layer, but they must not replace application authorization, restricted tool access, and security testing.

4. OCI IAM Helps Control AI Application Permissions

Identity and Access Management (IAM) is fundamental to secure cloud architecture.

AI applications and agents may need to retrieve documents, access databases, invoke models, or interact with other services.

Without appropriate access restrictions, these systems may gain more privileges than necessary.

How OCI IAM Works

OCI IAM policies control which principals can perform supported actions on cloud resources.

Policies can be organized according to the organization's resource structure and security requirements.

For example, a development team may need permission to use an approved AI model without receiving permission to manage production databases.

Understanding Least Privilege

Least privilege means granting only the access required to complete an authorized task.

Consider an AI assistant used to answer employee questions.

The application might need access to approved support documents.

It should not automatically receive access to payroll records, financial reports, or unrelated databases.

Why AI Agents Require Additional Attention

Some AI agents can use tools and perform actions, not just generate text.

If an agent has excessive privileges, unexpected behavior or manipulated instructions may lead to unauthorized operations.

Organizations should therefore evaluate:

Which identity the agent uses
Which services it can access
Which actions it may perform
Whether permissions are limited appropriately
How user authorization is preserved
Which actions require approval or auditing

Practical Lesson

An AI model should not be trusted to decide its own permissions.

Access restrictions need to be enforced through trusted application, IAM, and database security controls.

Key takeaway: AI agents should operate with clearly defined identities, limited permissions, and appropriate authorization checks.

5. Oracle Data Safe Helps Protect Sensitive Database Information

Many enterprise AI applications rely on databases containing customer, employee, financial, and operational records.

These databases require careful protection because their information may be valuable or sensitive.

Oracle Data Safe provides security capabilities for supported Oracle databases.

Important Oracle Data Safe Features

Sensitive Data Discovery

Helps identify potentially sensitive information stored in database columns.

Data Masking

Transforms sensitive values into suitable replacement data for nonproduction use cases.

Security Assessment

Helps identify database configuration weaknesses.

User Assessment

Supports reviewing database users and their privileges.

Activity Auditing

Provides visibility into selected database activity.

Oracle Data Safe also provides additional supported security capabilities, including security policies and SQL Firewall functionality.

Practical Example: Testing an HR AI Assistant

A company wants to evaluate an AI application using employee-related records.

The development team does not need actual employee identity information during early testing.

Oracle Data Safe can support discovering sensitive information and preparing appropriately masked data for a nonproduction environment.

This can reduce unnecessary exposure.

Why Data Masking Matters

AI applications often need realistic testing conditions.

However, copying a production database into a development environment without suitable safeguards can create serious privacy risks.

Masking can help preserve useful data characteristics while reducing exposure of selected sensitive values.

The result must still be evaluated for privacy and testing suitability.

Key takeaway: Protecting AI data begins with knowing where sensitive information exists and ensuring that nonproduction environments do not receive unnecessary access to real personal data.

6. Oracle Deep Data Security Adds Database-Level Authorization

One of Oracle's significant 2026 developments is Deep Data Security in Oracle AI Database 26ai.

It addresses an important problem involving AI agents and dynamically generated database queries.

The Problem With Application-Only Authorization

Traditional applications commonly implement access restrictions within application logic.

For example, an HR application might display only the employee records a manager is permitted to access.

An AI agent introduces additional complexity because it may generate queries dynamically.

If the agent operates through an overly privileged database connection, a poorly designed application could expose information outside the user's authorized scope.

How Deep Data Security Helps

Oracle Deep Data Security provides fine-grained authorization controls enforced directly within the database.

Supported policies can apply restrictions at the:

Row level
Column level
Individual cell level

These controls can use verified identity information and runtime context.

Practical Example: Employee Information

Imagine an organization with three types of users.

User	Authorized Information
Employee	Their own employment information
Manager	Approved information about their team
HR administrator	Information permitted by their HR responsibilities

All three users might ask questions through the same AI assistant.

However, they should not receive the same database records.

Database-enforced authorization can help maintain these differences even when an AI agent generates the underlying query.

Why Database-Level Authorization Matters

An AI model can misunderstand instructions or generate unexpected queries.

Placing authorization at the data layer introduces an additional enforcement boundary.

However, this protection still requires correct policy design, identity integration, and testing.

Key takeaway: Secure AI applications should enforce data access through trusted database controls rather than relying only on model instructions.

7. Encryption and OCI Vault Help Protect Data and Credentials

Encryption is another essential component of AI security.

It protects information by transforming readable data into an encrypted form.

Oracle Cloud provides encryption capabilities for supported data storage and network communication.

Encryption at Rest

Encryption at rest protects stored information.

For example, OCI Object Storage supports encryption of stored objects.

Encryption in Transit

Encryption in transit protects information during communication between systems.

OCI Generative AI documents encryption protections for supported training and inference workflows.

What Is OCI Vault?

OCI Vault provides centralized capabilities for managing encryption keys and secrets.

Secrets may include application credentials, authentication tokens, and other sensitive configuration values.

Practical Example

An organization builds an AI application that retrieves information from a database.

The application requires credentials or another authorized authentication mechanism.

Embedding database passwords directly in source code creates unnecessary exposure.

A suitable secrets-management approach can help avoid storing sensitive credentials in repositories or unprotected configuration files.

Why Encryption Alone Is Not Enough

Encryption protects data under particular conditions, but it does not determine whether every authorized identity should be allowed to use that data.

An application with excessive permissions may still retrieve sensitive information.

This is why encryption must be combined with IAM, database authorization, and monitoring.

Key takeaway: Encryption protects information, while access control determines which identities are allowed to use it.

8. OCI Cloud Guard Helps Identify Cloud Security Risks

AI applications depend on infrastructure such as virtual machines, storage resources, networks, and identities.

Security weaknesses in these components can affect the AI application, even if the model itself is configured correctly.

OCI Cloud Guard helps identify supported security issues involving cloud resource configuration and activity.

How Cloud Guard Works

Cloud Guard uses targets, detectors, and responders.

Targets define which OCI resources and compartments are monitored.

Detectors evaluate resource configurations and activities according to configured rules.

Responders can support corrective actions when security issues are identified.

Practical Example: An Exposed Storage Bucket

A company uses OCI Object Storage to hold internal documents for an AI application.

An administrator accidentally changes a configuration in a way that exposes a bucket more broadly than intended.

If the relevant Cloud Guard detection rule is enabled and the resource is within the monitored scope, the system may identify the problem.

The security team can investigate the finding and correct the configuration.

Does Cloud Guard Fix Problems Automatically?

Cloud Guard can support automated response actions, depending on the configured responder recipes and rules.

However, not every finding is automatically remediated.

Organizations should carefully review the possible effects of automated security changes.

Key takeaway: Securing AI systems also means maintaining the security of the cloud infrastructure supporting them.

Oracle Cloud AI Security Services Compared

The eight security areas address different parts of an AI application.

Oracle Service or Feature	Primary Security Purpose
OCI Generative AI	Managed model access and documented inference data handling
OCI Private Endpoints	Private network access to supported AI services
OCI Generative AI Guardrails	Evaluate selected prompt, content, and privacy risks
OCI IAM	Control identity permissions
Oracle Data Safe	Database assessment, discovery, masking, and auditing
Oracle Deep Data Security	Fine-grained database authorization
OCI Vault	Manage encryption keys and secrets
OCI Cloud Guard	Identify cloud configuration and activity risks

These services are complementary.

No single security product can guarantee complete protection across every part of an AI application.

Practical Architecture: Building a Secure AI Knowledge Assistant

Let's combine the security concepts through a practical design.

A company wants to build an AI assistant that answers employee questions using approved internal documents.

The system should support legitimate business questions while protecting confidential information.

A Simplified Oracle Cloud AI Architecture

               EMPLOYEE
                  |
                  v
         APPLICATION LOGIN
                  |
                  v
        IDENTITY VERIFICATION
                  |
                  v
       APPLICATION AUTHORIZATION
                  |
                  v
         APPROVED DATA ACCESS
                  |
          +-------+-------+
          |               |
          v               v
     DOCUMENTS        DATABASE
                      POLICIES
          |               |
          +-------+-------+
                  |
                  v
         FILTERED CONTEXT
                  |
                  v
          OCI AI GUARDRAILS
                  |
                  v
       OCI GENERATIVE AI MODEL
                  |
                  v
        OUTPUT POLICY CHECKS
                  |
                  v
             EMPLOYEE


     SUPPORTING SECURITY CONTROLS
     IAM | Vault | Private Networking
     Data Safe | Cloud Guard | Auditing

Figure 1: A conceptual layered security architecture for an internal AI assistant. Actual service integration and guardrail enforcement depend on the application design and available OCI capabilities.

Step 1: Verify the User

The application authenticates the employee using an approved identity system.

Step 2: Check Access Permissions

The application determines which documents the authenticated user is permitted to access.

Step 3: Retrieve Only Approved Information

The retrieval layer filters documents using trusted authorization information.

Unapproved records should not be sent to the model.

Step 4: Evaluate AI Inputs

Supported guardrails can help identify selected prompt injection, content, and PII concerns.

Step 5: Generate the Response

The application invokes the appropriate supported model using an approved inference configuration.

Step 6: Review Outputs

The application applies relevant output checks and decides whether the response can be shown.

Step 7: Monitor Activity

The organization collects appropriate operational and security evidence to investigate incidents and improve controls.

Why This Design Matters

Security controls should operate before, during, and after model inference.

A prompt instructing the model to keep information confidential is not a substitute for ensuring the information was never retrieved without authorization.

The most important architectural rule is to enforce permissions before confidential data reaches the model.

Hands-On Python Exercise: Filter Documents Before AI Retrieval

You can practice a key AI security principle without deploying a cloud service.

This example demonstrates how an application can filter fictional documents according to an authenticated user's authorized groups.

The exercise uses Python's standard library and does not access OCI or a real model.

Step 1: Create Sample Documents

documents = [
    {
        "id": "travel-policy",
        "title": "Employee Travel Policy",
        "allowed_groups": {"employees"}
    },
    {
        "id": "finance-report",
        "title": "Quarterly Finance Report",
        "allowed_groups": {"finance"}
    },
    {
        "id": "hr-policy",
        "title": "Confidential HR Procedures",
        "allowed_groups": {"hr"}
    }
]

These are fictional records representing documents that an AI application might retrieve.

Step 2: Define a Test User

authenticated_groups = {"employees"}

For this exercise, the test user belongs only to the employees group.

In a production application, group membership must come from a trusted and verified identity system, not from a value the end user can freely change.

Step 3: Filter Authorized Documents

visible_documents = [
    document
    for document in documents
    if document["allowed_groups"]
    & authenticated_groups
]

for document in visible_documents:
    print(document["title"])

Expected output:

Employee Travel Policy

The Finance Report and HR Procedures are excluded because the test user does not have the required group membership.

Step 4: Verify Unauthorized Content Is Excluded

Add a basic automated test:

visible_ids = {
    document["id"]
    for document in visible_documents
}

assert "travel-policy" in visible_ids
assert "finance-report" not in visible_ids
assert "hr-policy" not in visible_ids

print("Access filter checks passed.")

This validates the expected filtering behavior for the sample data.

What Does This Exercise Demonstrate?

The exercise shows why access restrictions should be applied before documents are passed to an AI model.

However, this is only a small educational example.

It does not provide production-ready authentication, database enforcement, tenant isolation, logging, or protection against every application security risk.

In a real OCI implementation, authorization should be enforced using suitable trusted identity and data-layer controls.

What Should You Test Next?

Extend the exercise by creating additional fictional users with different authorized groups.

Verify that employees, managers, and HR staff receive only the documents permitted by your example policy.

Record which tests pass and which requirements still need implementation.

Practical takeaway: AI application security begins with controlling what information the model is allowed to receive.

Testing an Oracle Cloud AI Application Before Deployment

A security architecture should be evaluated through specific test scenarios.

The following table provides a starting point.

Test Scenario	Expected Security Behavior
Authorized user requests an approved document	Requested information is accessible
Unauthorized user requests a confidential document	Access is denied
Retrieved content contains suspicious instructions	Relevant checks flag or handle the content according to policy
User submits sensitive personal information	Applicable privacy controls evaluate the content
Application identity requests an unnecessary permission	Access is denied
A storage resource becomes unintentionally exposed	Relevant monitoring identifies the risk if correctly configured
The model generates an incorrect claim	Application or reviewer identifies the need for verification
Application stores conversation content	Retention follows the configured organizational policy

These are expected outcomes, not test results from a deployed Oracle environment.

The team should test each applicable control with non-sensitive sample data and document the actual results.

What AI Security Challenges Still Remain?

Oracle provides security technologies for different application layers, but several challenges require ongoing attention.

Prompt Injection

Automated guardrails may not detect every malicious instruction.

Use access controls, restricted tools, output validation, and regular testing alongside prompt evaluation.

Data Processing Location

Different models and configurations may use different processing locations.

Review data residency and external provider processing requirements before deploying sensitive workloads.

Incorrect AI Responses

Generative models can produce inaccurate information.

Applications handling important business processes should include appropriate verification mechanisms and human review.

Excessive Permissions

Overly privileged AI applications can expose data or perform unintended actions.

Enforce least privilege through trusted IAM, application, and database controls.

Data Retention

An inference service's default data-handling policy does not necessarily describe every storage feature in the application.

Review conversation storage, uploaded files, memory, application logs, and retention settings.

Privacy Compliance

Security products can support organizational compliance efforts, but they do not automatically satisfy every privacy law or contractual requirement.

Organizations remain responsible for understanding applicable obligations.

A Four-Week Oracle Cloud AI Security Learning Roadmap

Beginners can build foundational knowledge through a structured plan.

Week	Learning Focus	Practical Activity
Week 1	OCI and cloud security fundamentals	Study tenancies, compartments, IAM, VCNs, and Object Storage
Week 2	Data privacy and database security	Explore Vault, Data Safe, masking, and encryption
Week 3	Generative AI security	Learn model data handling, private endpoints, and AI guardrails
Week 4	Security architecture and testing	Design a secure AI assistant and test authorization logic

Beginner Project: Design a Secure AI Assistant

Create a fictional company scenario involving an AI assistant that answers questions using internal documents.

Document the following:

Which users should access the assistant?
Which documents should each user group access?
Where will documents be stored?
Which model and inference configuration would be appropriate?
How will permissions be enforced?
Which guardrail checks will be used?
Which information will be retained?
How will security incidents be identified?
Which security behaviors need testing?

You can complete the initial design without creating cloud resources or uploading confidential information.

If you later deploy a test application in OCI, review current service availability, permissions, and pricing before proceeding.

Frequently Asked Questions

How Does Oracle Cloud Protect AI Data?

Oracle Cloud provides several security capabilities, including encryption, IAM, private network access, database protection, AI guardrails, and security monitoring.

The protections available to an application depend on its services and configuration.

Does OCI Generative AI Store Prompts and Responses?

Oracle documents that OCI Generative AI does not retain prompts and responses as part of normal inference.

However, applications can use features that deliberately store responses, conversations, files, or memory under separately managed settings.

What Are OCI Generative AI Guardrails?

OCI Generative AI Guardrails are configurable controls for evaluating selected content moderation, prompt injection, PII, and topic-related risks.

They provide additional safeguards but do not replace application security controls.

Can Oracle Guardrails Prevent Every Prompt Injection Attack?

No. Prompt injection detection can identify certain risks, but automated detection is not guaranteed to recognize every attack.

Applications still need strong authorization, controlled tool access, and security testing.

What Is Oracle Data Safe Used For?

Oracle Data Safe provides capabilities such as sensitive data discovery, data masking, database security assessment, user assessment, and activity auditing.

What Is Oracle Deep Data Security?

Oracle Deep Data Security is a database authorization capability in Oracle AI Database 26ai.

It helps enforce fine-grained access controls based on identity and runtime context, including supported AI agent interactions.

Is a Private Endpoint Enough to Secure an AI Application?

No. Private endpoints address network connectivity.

Applications also need authentication, authorization, encryption, data protection, monitoring, and appropriate model security controls.

Are OCI AI Services Automatically Compliant With Privacy Laws?

No. Oracle security features can support compliance activities, but customers must evaluate their applicable privacy, retention, processing, and organizational requirements.

Can Beginners Learn OCI AI Security?

Yes. Beginners should start with OCI fundamentals, identity management, networking, encryption, and data protection before progressing to advanced AI security architecture.

Conclusion: How Should Developers Approach Oracle Cloud AI Security?

Oracle Cloud is addressing AI security and data privacy challenges through multiple complementary technologies.

OCI Generative AI provides documented data-handling arrangements, while private endpoints support private access to suitable model services.

OCI Generative AI Guardrails can evaluate selected prompt injection, content, and personal information risks.

OCI IAM, Oracle Data Safe, Deep Data Security, and Vault help protect identities, databases, and sensitive information. Cloud Guard contributes infrastructure security monitoring and supported response capabilities.

However, secure AI development cannot depend on any single service.

Developers must understand where application data originates, which identities can access it, how information reaches the model, and what happens to the generated response.

For beginners, a useful starting point is to design a small AI knowledge assistant using fictional documents.

Begin with identity verification and access control. Then determine how approved data will be retrieved and which safeguards should be applied to the model interaction.

Finally, test the system with authorized and unauthorized requests and document any gaps.

The most important principle of secure AI architecture is that authorization should be enforced by trusted systems, not by expecting the AI model to decide which information is confidential.

As organizations develop more AI-powered applications, combining infrastructure security, data-level authorization, privacy controls, and responsible AI development will remain essential.

Your next step is to complete the document authorization exercise in this guide and design a simple Oracle Cloud AI architecture that applies those controls at each stage of the information flow.