Everyone Has the Same AI Models. Here's What Sets Agents Apart

Richmond Alake, Oracle25:47 · Oct 2026 · 11K views
Thumbnail for Everyone Has the Same AI Models. Here's What Sets Agents Apart Watch on YouTube
TL;DR
  1. 1

    An intelligence plane gives agents structured knowledge, memory, governance, and continual learning across the agent stack.

  2. 2

    An ontology and semantic layer helped the governed demo agent answer questions more accurately while using 32,000 tokens instead of 200,000 for the naive agent.

  3. 3

    Teams should treat memory as data, capture memory traces, and use small decision models for tasks such as memory routing.

Summary

Richmond Alake argues that access to the same models and information does not give agents the same intelligence. He uses the World War II example of codebreakers identifying AF as Midway to distinguish centralized control from the ability to interpret fragmented information. His proposed intelligence plane cuts across the agent stack and brings together knowledge, memory, data access, governance, inference, fine-tuning, and continual learning. In his demo, a governed analyst with ontology and semantic layers answered more accurately than a naive analyst. It got answers right 99% of the time while using 32,000 tokens, compared with 200,000 for the naive agent. Alake then connects agent memory to Oracle products, including an agent memory Python package, deep data security, private inference, and the Oracle AI database. He also shows how fine-tuned decision models can route memories into the right stores. His practical advice is to own memory, capture traces, and build systems that can learn from them.

Key ideas
00:51

Agent memory retains, reuses, recalls, and refines information

Alake defines agent memory through what he calls the four Rs: retain, reuse, recall, and refine. He places memory into several taxonomies. Short-term and long-term memory describe duration, while semantic, episodic, procedural, and working memory describe cognitive functions. He also points to implementation concerns that become important when building agents. His argument is that memory needs to be structured and modeled inside the agent rather than treated as an afterthought. He says he was discussing this several years earlier, when few people in his audience had heard of agent memory.

01:49

The control plane governs what agents can do

Alake describes the control plane as a centralized management system for agent governance. It controls the tools an agent can access, the actions it can take, and the actions it cannot take. Its components include agent identity, policies and guardrails, orchestration, permissions, and auditing. He accepts that these systems are needed, but says they do not address how an agent learns from data and memory. The control plane organizes and constrains the agent. It does not by itself give the agent a better interpretation of information.

03:54

The intelligence plane adds knowledge, memory, access, and learning

Alake proposes an intelligence plane that cuts across the entire agent stack. It gives engineers a way to build agents that learn from data and memory while remaining governed. He defines its contents as what the agent should know, what it should remember, what it is allowed to see, and how it gets better over time. That means knowledge, memory, governance and data access, and continual learning. He places related work across the stack, including context assembly, ontology and semantic layers, databases, inference, fine-tuning, and continuous learning.

04:38

Shared information does not produce shared intelligence

Alake uses the World War II code word AF to explain the difference between control and intelligence. Codebreakers in Washington and Pearl Harbor had the same intercepted information, but the Pearl Harbor group stored fragmented messages over months and interpreted AF as Midway. Washington had centralization, resources, and organization, yet reached a different interpretation. Alake connects this example to current AI systems. Engineers may have access to the same models and information, but their agents can still differ because their memory, knowledge structures, and interpretation systems differ.

11:33

An agent combines a model with a harness, then adds intelligence

Alake gives a compact description of the architecture: an agent equals a model plus a harness. Adding control means adding governance and security. Adding intelligence means adding knowledge, memory, and learning. He describes an agent runtime connected to memory and knowledge systems, with a memory manager over a data platform. The runtime can record memory traces, send them into a continual learning loop, and use the resulting model changes in later agent execution. This architecture places data, control, and intelligence planes alongside one another.

14:01

Ontology and semantic layers improve answers while reducing token use

In Alake's demo, a governed analyst uses an intelligence plane with ontology and semantic layers, while a naive analyst does not. The governed agent answers correctly 99% of the time and uses 32,000 tokens, compared with 200,000 for the naive agent. Alake also shows a question about a counterparty where the ontology supplies information that keyword search cannot. In another example, the naive agent gets the meaning of concentration wrong, while the semantic-layer agent gets it right. He says the remaining margin of error is 5%, which matters in financial and other mission-critical workloads.

17:07

Teams should treat memory as data and capture its traces

Alake's advice to engineering teams is to treat memory as data. Teams should write down their entities and definitions, push entitlements into the data layer, and capture memory traces. He calls memory a moat and says teams need to own their own memory. Oracle's agent memory package turns memory engineering into a Python package and generates a context card. The traces then become data that can be used for fine-tuning. This connects context engineering and memory engineering to a system that can improve as the agent runs.

20:52

Small decision models can route memories cheaply

Alake demonstrates memory routing with an open-source tool called Memories. The system uses a decision model, an embedding model, and a re-ranker. A decision model can route information from the context layer or language model into the appropriate store, such as conversation memory or workflow memory. He fine-tunes a model using examples from his agent conversations, classifying what type of memory each example represents. He presents memory routing, embeddings, and re-ranking as accessible places to start using decision models, especially when teams capture and format memory traces for retraining.

"Developers and engineers of these systems, we need to actually own our own memory, engineer the capturing of traces, and actually build it into a system that allows for continual learning to be possible."24:57
Who should watch
  • You are building agents that can call tools and need a system for memory, permissions, and continual learning.
  • Your agent gives plausible answers but struggles with domain terms, entity relationships, or mission-critical data.
  • You want practical starting points for using decision models, embeddings, or re-rankers inside an agent memory system.