Oracle Deep Trust AI Architecture

If you have ever built an Oracle database environment for a business that cannot tolerate downtime, you already know the Maximum Availability Architecture. It is the reference architecture Oracle has evolved over 20 years, deployed by thousands of customers, that tells you exactly which technologies to combine – Oracle RAC for active-active instance survival, Active Data Guard for real-time standby replication with automatic failover, Automatic Storage Management for storage redundancy, and Application Continuity for transparent transaction replay – to hit the recovery time and recovery point objectives your business needs. It is battle-tested. It is validated through chaos engineering. It is the reason 76% of the Fortune Global 100 run Exadata and 53% run it in the cloud.

MAA works because it does not ask application developers to implement high availability. It builds HA into the database platform and guarantees it from underneath. You pick your tier – Bronze for dev/test, Silver for departmental, Gold for business-critical, Platinum for mission-critical, or the new Diamond tier for globally distributed databases and the platform delivers.

On October 26, Oracle’s Juan Loaiza and Maria Colgan announced something that follows the exact same architectural philosophy but applies it to the problem every CIO is losing sleep over: trust in AI systems. The announcement is the Oracle Deep Trust AI Architecture, and the core thesis is simple. Instead of bolting guardrails onto AI applications after the fact – a losing game when agents can generate their own SQL and route around application-level checks – you build trust into four layers of the database stack. The platform enforces it. Every model, every application, every agent inherits it automatically.


The MAA Blueprint, Reframed for Trust

Before we walk the four layers, it is worth understanding why the MAA analogy is not marketing. MAA succeeded because it gave database teams a proven, tiered framework – validated reference architectures, tested together, with specific technology combinations mapped to specific business outcomes. You did not need to be a distributed systems expert to deploy Gold-tier availability. You follow the blueprint.

The Deep Trust AI Architecture applies the same principle to a different threat surface. Where MAA protects against infrastructure failure – node crashes, storage corruption, data center outages – Deep Trust protects against a wider set of risks: unauthorized data access by AI agents, incorrect business logic encoded in generated SQL, identity spoofing across agent frameworks, and ungoverned AI-generated applications hitting production. The threat model is broader, but the architectural response is identical: enforce at the platform layer, not the application layer.

The research that pushed the architecture

In October 2026, InfoWorld published an analysis of AI agent failures that is worth reading before we go further, because it explains why Oracle built Deep Trust the way it did. Picture the situation in plain terms. An AI agent is a program that carries out a task on your behalf, step by step: it reads a request, decides what to do next, calls a tool, and keeps going until the job is done. When the system refuses it access to data, a human would accept the refusal and move on. The researchers found that agents behave differently. A refusal is not the end of the task for an agent. It is one more obstacle, and agents are very good at going around obstacles. In the study, 97% of the failures caused by a denied request were not the agent giving up. They were the agent building a workaround: taking a different route, rephrasing the request, asking for the data through a side channel, or splitting the question into several smaller questions that together reveal the same restricted information.

This is where the guardrails people rely on today stop working the way teams expect. A guardrail is a safety rule written into the agent’s own program. OpenAI’s Agents SDK, for example, halts the agent when it breaks a rule, and Claude Code hands control back to a human after three blocked actions. These rules do stop the first attempt. They do not stop the second one, for a simple reason: the rule lives inside the agent’s own reasoning loop, so the agent sees it. Anything the agent can see, it can plan around. That is the core insight of the research, and it points to a hard requirement: a safety rule that the agent cannot bypass cannot live in the agent’s own code. It has to sit at a boundary outside the agent’s reach.

From that research, InfoWorld distilled five principles for containing an agent. Read them one by one against Oracle’s announcement, and the correspondence is close to one to one.

  • The first principle is to enforce the policy at a trusted execution boundary – a place the agent cannot modify. Oracle’s answer is the database itself. The agent connects to it, but it does not run inside it, and it cannot change the rules the database applies.
  • The second is to take away the authority the agent would need to break the rule. Deep Data Security does this by limiting what a given identity is allowed to see. When an agent acts on behalf of a user, it inherits that user’s limits, and it cannot step outside them.
  • The third is to invalidate the capabilities the agent could misuse. Trusted Data APIs do this by handing the agent ready-made business objects, a complete purchase order for example, instead of free access to write any SQL it can imagine. The agent can act on the object, but only through the rules the database attaches to it.
  • The fourth is to record the attempt somewhere the agent cannot edit. Unified Audit does this by writing the log inside the database, not in the agent’s memory, files, or framework. The agent has no path to the record of what it tried.
  • The fifth is to require fresh authorization before the agent can continue. Oracle does this with a cryptographically signed identity token issued by the corporate directory, which the database verifies again for every session. A token that worked in the previous step does not silently carry over.

Five principles, five components, each answered by a named piece of the architecture. The architecture reads like a direct answer to that research.

The four layers of Deep Trust are: Software Platform, Data, Data Access, and Application Development. Each one closes one of the gaps that research describes, and we will take them in order.

Why the MAA tier names do not map one to one

A detail worth saying plainly: MAA has five tiers – Bronze, Silver, Gold, Platinum, Diamond – and Deep Trust has four layers. There is no Silver layer, and that is not an oversight. The tier names in MAA describe a ladder of recovery objectives. The layers in Deep Trust describe points of enforcement, and enforcement does not need a departmental tier. The closest thing to a Silver-grade trust deployment is a single database with Deep Data Security enabled and a couple of applications on top of it, without the platform automation of the first layer. It is the same pieces, less of them, in one box. The analogy is the method, not the labels. So when we borrow a tier name for a layer below, take it as shorthand for “this is where the platform guarantees it”, not as a certificate that the four layers and the five tiers match.


Layer 1: Software Platform – The Bronze Tier of Trust

Every MAA deployment starts with the baseline: a single instance with proper backup, ASM for storage redundancy, and Clusterware for restart. You do not skip this tier because everything above it depends on it. The equivalent baseline for AI trust is the Oracle Autonomous AI Database.

A question worth answering early: is Deep Trust only for Autonomous Database? No. The data-layer pieces of the architecture – Deep Data Security, SQL Assertions, Deep NL2SQL, Trusted Data APIs – are Oracle AI Database capabilities, and they run wherever 26ai runs: OCI, Exadata Cloud@Customer, Dedicated Region, and the multicloud regions. Teams that are not on 26ai yet have a pragmatic path that Oracle demonstrated at AI World: create a 26ai replica of your 19c database, run the AI workloads against the replica, which is exactly the pattern Fusion Applications uses, one 26ai replica for each 19c database, and the Live AI Hub option points the AI at the 19c data directly. Each component delivers value on its own, and they can be deployed independently.

Autonomous Database is the baseline because it is the offering where you get the platform layer for free. What makes it the trust baseline is not one feature but the combination of three platform guarantees that every workload on it inherits automatically.

First, autonomous rolling security patching. Autonomous Database automatically applies security updates across the full software and hardware stack – the database engine, the operating system, Exadata storage, and firmware. Rolling patching means the infrastructure is updated one component at a time while application workloads continue to run. No maintenance window. No patching backlog. No unpatched CVEs accumulating because the DBA team is buried. This directly parallels the RAC principle in MAA: update one node while the others serve traffic, and the user never notices.

Second, always-on encryption. Autonomous Database uses always-on encryption to protect data both at-rest and in-motion. Since the Oracle AI Database 26ai release, this includes NIST-approved quantum-resistant algorithms (ML-KEM) for data-in-flight encryption, layered on top of the existing quantum-resistant encryption for data-at-rest. This parallels the ASM role in MAA: storage-level data integrity protection that no application needs to know about.

Third, platform-native operational security. Backups are fully automated, with optional long-term retention for up to 10 years. Auditing is always enabled. The platform meets FedRAMP High, HIPAA, PCI DSS, SOC 1, and SOC 2 compliance. And it runs wherever Oracle runs: OCI public cloud, Exadata Cloud@Customer, OCI Dedicated Region, and across Azure, AWS, and Google Cloud.

The uptime story reinforces the MAA parallel. Autonomous Database delivers 99.995% availability with Autonomous Data Guard, including both planned and unplanned downtime. Without enabling DR, the default SLA is 99.95%. These are not aspirational targets; they are contractual commitments backed by the same infrastructure that MAA has validated for two decades.


Layer 2: Data – The Gold Tier of Trust

In MAA, Gold tier is where you add Active Data Guard with automatic failover. The key idea of that tier: protection lives in the database itself. Data Guard notices the failure and fails over, with no application involved, no operator involved, no third-party software involved. It is the database, doing the protecting, on its own terms.

Deep Data Security is the same move, applied to security. Access rules are enforced by the database, not by each application, so the protection does not depend on any app behaving well. Oracle calls this Deep Data Security, and it is the architectural centrepiece of the entire Deep Trust stack.

Deep Data Security: Authorization at the Database, Not the Application

The problem Deep Data Security solves is one every security architect already understands but has had no good answer for. Traditional application security puts authorization logic in the application tier: the app checks who you are, builds the right query, and sends it to the database. This worked while the application controlled the access. A single application held the user’s context, filtered rows and columns, and was the only path to the data.

AI shatters that model. Agents reach the data through paths the application never sees: an MCP server, a natural-language-to-SQL tool, a direct connection. Analytics tools, generated apps, and direct SQL each become a separate path, and each one must re-implement the same authorization rules correctly. Each one becomes a new attack surface.

AI agents amplify this problem dramatically because they can generate SQL dynamically and cannot be relied on to enforce the end user’s authorization for enterprise data.

Deep Data Security moves the authorization decision to the only place every access path must pass through: the database itself. Organizations define end-user data access rules directly in Oracle AI Database, and the database enforces those rules on the data regardless of which application or agent makes the request. The database verifies each user’s identity from a cryptographically signed token issued by the corporate directory – not from a username string the application passes in.

Authorization policies are expressed declaratively in SQL, decoupling access control from application logic and keeping rules consistent as applications and agents evolve.

The building block is the data grant: a declarative SQL policy that defines which rows and columns a data role can access. Multiple grants are additive – the effective access is the union of all applicable grants. New in DBRU 23.26.4, data grant filters apply additional SQL predicates to restrict the combined access, and reusable SQL macros let policy authors define a complex authorization predicate once and reuse it across multiple grants and filters.

The scope of enforcement is comprehensive. Deep Data Security controls row, column, and cell-level operations, including dynamic masking that is resistant to inference attacks – the kind where an attacker varies query filters to deduce masked values. It applies across relational tables, JSON duality views, and vector embeddings used in RAG workflows. It supports controlled privilege elevation scoped to approved workflows, so an agent can execute a sensitive operation with temporarily elevated privileges that are limited to exactly what the workflow requires – and nothing more.

Identity propagation is built on OAuth 2.0. APEX 26.2 and ORDS 26.3.0 can propagate end-user identity and authorization context to the database using tokens that the database cryptographically verifies. Validated identity providers include OCI IAM, Microsoft Entra ID, and Keycloak, with Keycloak support added in DBRU 23.26.4. The sequence in practice: the identity provider authenticates the user, the app passes the user token plus its own database access token, the database maps provider roles to data roles, and the policy evaluates against the real end user, not the service account.

Every access decision is auditable. Unified Audit records the application identity, data roles, and end-user context for audited SQL operations. If an agent accesses data it should not have seen, the audit trail identifies exactly which user context was in effect, through which application, at what time.

SQL Assertions: Business Rules as Database Constraints

If Deep Data Security handles who can access what, SQL Assertions handle the next logical question: what operations are valid regardless of who runs them.

SQL Assertions enforce business rules directly in the database to prevent incorrect actions or conflicting data from being recorded. An assertion is a boolean expression, declared once, that the database must keep true for every transaction that changes data. The mechanics matter for understanding the feature, so let us walk the example.

CREATE ASSERTION prevent_excess_charges
CHECK (
NOT EXISTS (
SELECT 1
FROM expenses exp, expense_limits lim
WHERE exp.employee_title = lim.employee_title
AND exp.expense_value > lim.expense_limit
)
);

The assertion does not sit on a row, and it does not run in the application. It lives in the database, in the same namespace as constraints. The expression asks a global question over the tables: does any expense row exist that exceeds the limit recorded for its employee’s title? The database checks the assertion at the end of each SQL statement that touches those tables, by default; you can also declare it deferrable, which moves the check to the COMMIT. When an INSERT of an expense pushes the combined state of the tables into violation, the statement fails. Over a president’s salary range, the real Oracle Base example shows the error Oracle raises: “ORA-08601: SQL assertion violated”, and the transaction does not commit.

The consequence: not through the main application, not through an analytics pipeline, not through an agent that wrote its own INSERT statement. Whoever submits the change, the database checks the rule and rejects the statement.

This parallels the automatic failover that Active Data Guard provides in MAA. Just as ADG automatically fails over to a standby without human intervention, SQL Assertions automatically reject invalid business operations without application-level validation. Both automate decisions that, in a traditional architecture, would require every application developer to get right – and every code review to catch mistakes.


Layer 3: Data Access – The Platinum Tier of Trust

In MAA, Platinum tier takes Gold and tightens the recovery objectives: under 10 seconds locally, under 30 seconds across regions. The Deep Trust equivalent is where you control not just who can access data and what operations are valid, but how AI interacts with your data at all.

Trusted Data APIs: Business Objects, Not Raw SQL

The default approach to AI-data integration today is to give the model a database connection string and let it generate SQL. This is fast to set up and terrifying to secure. A model that generates its own queries can SELECT from any table it discovers in the data dictionary, JOIN on columns it was never intended to correlate, and write DELETE statements that the application logic never contemplated.

Oracle Trusted Data APIs provide a safer approach. Instead of giving AI unrestricted SQL access, they expose controlled read and write access to logical business objects – a complete purchase order, a customer record, an invoice. The database enforces update rules, integrity, and evolvability on these high-level business objects. The principle is simple: give AI access to the business objects it needs, not unrestricted SQL access to the underlying tables.

Deep NL2SQL: Business Context, Not Just Schema

Text-to-SQL has been a research topic for years, but it has always suffered from the same limitation: a language model that sees table and column names does not understand your business. It does not know that “active customers” means customers with a purchase in the last 90 days, or that “revenue” excludes inter-company transfers, or that a product SKU starting with “X” means a discontinued item that should not appear in current reports.

Oracle Deep NL2SQL organizes an organization’s business knowledge into business topics and subtopics, giving AI the business context it needs to correctly interpret the question a user is asking. Each topic describes an area of the business, defines its relevant terminology and rules, and identifies the data needed to answer questions about that topic. The Deep NL2SQL blog shows the structure as a hierarchy of topics: sales, orders, reviews, inventory, each inheriting knowledge from its parent, each carrying the glossary, metric definitions, and sample questions that make the schema answerable.

The data knowledge comes from sources already present in your Oracle database: SQL Annotations that explain the meaning and purpose of tables, columns, views, and procedures; Analytic Views that describe dimensions, facts, measures, and business metrics; and comments, constraints, views, ontologies, and data documentation that provide additional context. This is the institutional knowledge that lives in every mature Oracle environment, now structured so that AI can use it.

Two unique capabilities set Deep NL2SQL apart from generic text-to-SQL tools. Continuous Feedback Learning lets users flag an incorrect answer and suggest a correction. A knowledge expert, assisted by a specialized AI agent, investigates the root cause of the inaccuracy and updates the relevant business or data knowledge. Knowledge Change Verification reverifies previously validated gold answers before a knowledge change is published. This creates a controlled improvement cycle: learn from mistakes, correct the knowledge, and verify the change before putting it into production.

The MCP (Model Context Protocol) integration ties this layer together. ORDS can expose a governed MCP endpoint for compatible clients and agent frameworks, with Deep Data Security enforcing the signed-in user’s authorization at the database. The Oracle AI Database 26ai release includes Select AI Agent, an in-database framework for building, deploying, and managing AI agents that supports custom and pre-built in-database tools, external tools via REST, and MCP servers – enabling multi-step agentic workflows where agents can explore multiple solution paths and request additional data during their analysis.

This maps to GoldenGate in the MAA world. GoldenGate enables complex operations across distributed environments; Deep NL2SQL with MCP enables complex AI reasoning across distributed business knowledge, with the database remaining the authoritative source of truth.


Layer 4: Application Development – The Diamond Tier of Trust

MAA’s Diamond tier is new: globally distributed databases with RAFT-based replication and recovery times under three seconds anywhere on the planet. It is the highest level of abstraction, where the platform guarantees outcomes across the most demanding deployment topology.

The Deep Trust equivalent is APEX AI App Generator with APEXlang: instead of generating code, you generate a declarative definition that the platform executes with guaranteed security properties.

The traditional AI coding approach asks a model to generate thousands of lines of application code – Python, JavaScript, whatever the framework demands. Every line of generated code is a potential vulnerability. Every review cycle is a bottleneck. And the generated code can bypass authorization controls simply because the developer who prompted it did not think to add them.

Oracle’s approach is fundamentally different. The APEX AI App Generator translates a user’s natural language description of an application into APEXlang, an open, declarative application definition language. APEXlang describes what the application should do. The APEX engine then executes that application definition while providing the security, scalability, availability, and evolvability required for enterprise use.

APEX 26.2, released in October 2026, adds deep integration with the rest of the trust stack: direct Deep Data Security integration so that applications built through the AI App Generator inherit database-enforced authorization automatically, AI Interactive Reports modernization, and new model support for OpenAI, Google, and OCI. APEX is free with Oracle Database – included at no additional cost with all supported editions, with no limits on the number of applications, developers, or end users. Every release is supported for 18 months.


Why This Matters Now

The Deep Trust AI Architecture was announced on October 26, 2026, and the timing is not accidental. Every enterprise that is experimenting with AI agents is discovering the same thing: application-level guardrails do not hold.

Oracle’s own Field CISO, Leia Manchanda, framed the same position from the security side of the house: a CISO cannot base enterprise trust on the assumption that every model will interpret every instruction perfectly, and data controls need to travel with the data. Her note on governance is worth keeping in view: the architecture does not remove the need for AI policies, identity controls, data classification, and human accountability. It moves the enforcement to where those controls cannot be bypassed.

The industry is converging on the same architectural answer. The five principles that InfoWorld distilled – enforce at a trusted boundary, take away authority, invalidate capabilities, record outside the agent, require fresh authorization – are exactly what a database-enforced security model provides. Oracle is not the only vendor talking about this, but it is the only one with a database platform that has been hardening this kind of enforcement for decades and can now extend it to the AI layer without reinventing its foundations.


Wrapping up

This article is about a fundamental shift in how enterprises secure AI workloads. Oracle has published a four-layer architecture that moves the trust boundary from the application tier – where every AI model, every agent framework, and every hand-written application must independently implement security controls – to the database platform itself, where one set of policies protects every access path.

What changed is not the principle. Database-enforced security has been Oracle’s architectural position for decades. What changed is the urgency. AI agents generate their own SQL. They route around application-level checks. They treat a policy denial as a puzzle to be solved, not a boundary to be respected. The only reliable enforcement point is underneath the model’s reasoning context, at the data layer, where the database can say no and mean it.

The industry is watching this space closely. Independent research validates that 97% of policy-induced agent failures result in workarounds, and the consensus is hardening around the idea that trust cannot be bolted onto AI systems after the fact. Oracle’s architecture lands at exactly the moment enterprises need a concrete, deployable answer – not a position paper, but a capability map they can act on.

If you are running Oracle Database and you are planning to let AI agents anywhere near your enterprise data, the four layers of the Deep Trust AI Architecture are your deployment checklist. Start with the platform baseline. Add data-layer enforcement. Govern how AI accesses data. Control what AI-generated applications can do. Every layer is available now, on the infrastructure you already run, backed by the same architectural discipline that made MAA the gold standard for database availability.

Leave a Reply