# No Memory, No Harness: Why the Database Is the Last Line of Defense — Kay Malcolm, Oracle

Kay Malcolm, Oracle

[Talk page](https://ai.engineer/talks/jA_x7F8caHI-no-memory-no-harness-why-database-is) · [Video](https://www.youtube.com/watch?v=jA_x7F8caHI)

## No Memory, No Harness: Why the Database Is the Last Line of Defense

Kay Malcolm connects a missing overnight coding handoff to a broader agent architecture: models need a harness that preserves, retrieves, and shares decision context—not just code.

### Faster code created a slower handoff

[1:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=62s)

Kay Malcolm runs an outbound database product management team at Oracle, split across platform development, LiveLabs content, QA, and front-end work. AI made each person faster, but the team did not become correspondingly more productive. The bottleneck had moved: code generation accelerated while coordination still ran at human speed.

![Recording frame at 276 seconds](https://ai.engineer/api/talk-essay-media/3252d6f05877a5240652d0f75606d60a9ab878e1d4ff3b3356e1bb02e784477c)

Recording frame at 276 seconds

The concrete failure appeared during an overnight handoff. Developers in the Netherlands committed code around 4:00 a.m. Malcolm’s time. When the United States team woke up, it received the changed files but not the context from the AI-assisted session that produced them. The artifact survived; the reasoning did not.

That missing context had observable consequences: repositories diverged, managers could not explain why overall work was not moving faster, and testing and validation continued to consume time despite increased spending on models and tokens. Git could show which lines changed, but, in Malcolm’s phrase, “Git records the code and not human intent.”

The team therefore needed a collaboration layer that could preserve progress, next steps, and the rationale behind agent decisions while helping people resolve questions and conflicts. AI had effectively become another team member, but one whose working context disappeared at the end of a session.

### The harness connects reasoning to action

[4:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=288s)

To identify the missing layer, Malcolm expands the definition of an enterprise agent beyond a model and workflow. **Tools** let the system act. **Context** is the information currently placed in the prompt or context window. **Memory** preserves information for later use. **Retrieval** chooses which retained information should return, rather than dumping everything into the next prompt. Security and guardrails constrain what the resulting system may do.

![Recording frame at 412 seconds](https://ai.engineer/api/talk-essay-media/2def810f8b803af496694edbfeeeba50353cb2175c62d189f0f972cc1e9b2412)

Recording frame at 412 seconds

Her anatomical analogy separates these responsibilities cleanly. The model is a “little brain floating in a glass jar.” The harness is the body that gives it tools and lets it act. Memory is the central nervous system carrying context between reasoning and action. A model can generate code without this connective tissue, but it cannot preserve continuity for the next person or session.

The five memory categories answer different questions:

- **Short-term memory — what is active now?** It holds information within the current session.
- **Long-term memory — what should survive?** It persists across sessions.
- **Episodic memory — what happened last time?** It records a prior interaction or event.
- **Procedural memory — how was the work done?** It retains tools and steps.
- **Semantic memory.** Malcolm names this fifth category but does not develop its definition in the talk.

The first two categories emphasize duration, while episodic and procedural memory distinguish kinds of retained content. The taxonomy does not specify schemas, retention rules, or retrieval methods.

This taxonomy reframes the original Git problem. The next team did not merely need yesterday’s chat transcript. It needed durable decisions, an account of what happened, and the steps associated with the resulting code. That immediately raises the next architectural question: where should these different forms of memory live?

An enterprise agent is more than a model
The model reasons, the harness enables and constrains action, and memory carries context across actions and sessions. Retrieval decides which retained information returns to the active context.
- Model — The reasoning component—the brain in Malcolm’s analogy.
- Active context — Information currently present in the prompt or context window.
- Memory — Preserves context across actions and sessions.
- Retrieval — Selects relevant retained information instead of returning everything.
- Tools, security, and guardrails — Enable action while constraining what the system may do.
- Memory → Retrieval (supplies retained information)
- Retrieval → Active context (returns relevant information)
- Active context → Model (informs reasoning)
- Model → Tools, security, and guardrails (acts through the harness)

### Specialized databases multiply operational cost

[8:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=530s)

Malcolm answers the storage question through her earlier work as a performance tuner at Southern Company. The original environment centered on rows, columns, and SQL. When a developer needed unstructured storage and did not get a timely answer, the developer installed a specialized database instead.

![Recording frame at 754 seconds](https://ai.engineer/api/talk-essay-media/b44e1356fbdb555364db7f155c1cbe92ed96dfab7619621439e338f555a66f51)

Recording frame at 754 seconds

Every database system created two recurring obligations for its DBA: a weekly security meeting and a weekly patching meeting. One relational system meant two meetings. Adding the unstructured store raised the count to four. A specialized database solved a data-model problem, but it also introduced another system to secure, patch, understand, and operate.

A safety-critical power-restoration application then needed relationship analysis. False positives or negatives could misdirect workers repairing damaged infrastructure, so the team wanted to compare nearby poles. Malcolm implemented the relationship traversal as a five-level nested `UNION ALL` query. She remembers it fondly—“some of my best work”—but says it could take about 20 minutes. The team then installed Neo4j, raising her recurring meeting count to six.

This is the tradeoff behind polyglot persistence. A specialized store may be introduced for a particular data requirement or workload, but every new system adds operational work. Once agents need relational records, JSON documents, graph relationships, and vectors together, the cost also moves into the agent: it must decide which store is authoritative and reconcile conflicting or duplicated information.

Malcolm says that reconciliation can waste tokens and often produce the wrong answer. The talk provides no error rate or controlled comparison, so the supported architectural concern is narrower: distributing related memory across independently governed stores creates an additional authority and coordination problem for the agent.

### Four stores still need one authority

[13:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=809s)

Four audience volunteers make that coordination problem physical. One represents a relational database, another an unstructured store, another a graph database, and the last a vector database. Malcolm gives them one sentence—“The cow jumped over the moon”—and asks them to decide how to store it and who owns the single source of truth. They must stay apart and whisper; louder communication incurs a fictional fivefold token cost.

![Recording frame at 993 seconds](https://ai.engineer/api/talk-essay-media/ec74fd8b20b002986fddb619f772544be5be7b3feea3fec5f9ce1b64820a183f)

Recording frame at 993 seconds

The exercise is an analogy, not an interoperability test. Its question is: **where does reconciliation happen when several specialized systems hold different representations of the same memory?** If the stores remain separate, the burden moves to an agent or another coordination layer. The volunteers cannot establish authority under the imposed communication limits, which makes the hidden coordination work visible.

Malcolm’s proposed alternative is to keep multiple representations in one database. She describes Oracle AI Database as supporting JSON, graph, vector, spatial, and blockchain-related capabilities together, including storage in the same table and partition, with deployment across several clouds and on-premises environments. These are product capabilities presented in the talk rather than demonstrated configurations or performance results.

Different representations still serve different jobs. Malcolm maps relational and JSON structures to retained session and long-term context, graph structures to procedural relationships and steps, and vectors alongside text to episodic and semantic memory. The precise mapping is presented at a high level rather than as a strict schema. Consolidation does not make the representations identical; it places them under one persistence system so the harness does less cross-database reconciliation.

Where does memory reconciliation happen?
Separate stores push authority and reconciliation into the agent. A shared multimodel database keeps distinct representations under one persistence layer, which can then supply the harness.
- One memory event — The same underlying event may need several representations.
- Relational store — Structured records and retained context.
- JSON store — Session and long-term context in document form.
- Graph store — Relationships and procedural steps.
- Vector store — Episodic and semantic retrieval alongside text.
- Agent reconciliation — Must infer authority across separate systems.
- One memory event — Stored through several representations in one persistence system.
- Oracle AI Database — Relational, JSON, graph, vector, and other representations share a database.
- Harness memory — The shared store supplies durable context to the agent harness.
- One memory event → Relational store (structured form)
- One memory event → JSON store (document form)
- One memory event → Graph store (relationship form)
- One memory event → Vector store (embedding form)
- Relational store → Agent reconciliation (claim to inspect)
- JSON store → Agent reconciliation (claim to inspect)
- Graph store → Agent reconciliation (claim to inspect)
- Vector store → Agent reconciliation (claim to inspect)
- One memory event → Oracle AI Database (multiple native representations)
- Oracle AI Database → Harness memory (powers durable agent memory)

### Poly attaches context to code history

[16:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=999s)

The talk now returns to the overnight handoff. The team’s memory broker, **Poly**, preserves more than the committed code. It captures context from the working session—including procedural, episodic, and long-term information—and makes it available to other team members across forks.

![Recording frame at 1016 seconds](https://ai.engineer/api/talk-essay-media/8cce2b237e32f9399a2123c85b46b76ab0699a9b7214bf9c392daaf75077878a)

Recording frame at 1016 seconds

The important mechanism is association, not merely storage. Poly determines which fork, branch, and commit the context belongs to. That metadata turns a free-floating conversation into context attached to a concrete point in code history. The United States developer can therefore continue from the relevant reasoning instead of reconstructing it from the diff alone, while developers remain in control of the work.

What must survive the handoff? The diagram follows the observable change: before Poly, the receiving developer gets only code; with Poly, the code arrives with session context anchored to its Git coordinates. The database supplies persistence, while the broker performs capture and association.

Malcolm describes the implementation as using Oracle’s agent memory SDK with storage in an Oracle Autonomous Database. The SDK holds live conversations, memories, and facts and decides what is worth retaining. The surrounding design remains model-independent: the team can use an LLM of its choice or a local model through an Oracle private AI services container.

The architecture is concrete, but its reported outcome remains qualitative. The recording does not specify Poly’s retention criteria, access-control model, conflict-resolution protocol, retrieval accuracy, or measured team-speed improvement. It establishes how shared context is attached and transferred, not how much productivity the system adds under controlled conditions.

How Poly turns a code commit into a contextual handoff
The broker captures session memory, associates it with Git coordinates, persists it, and supplies the relevant context to the next collaborator.
- EMEA coding session — A developer and coding agent produce code plus decision context.
- Fork, branch, and commit — Git records the code location and history.
- Session memory — Procedural, episodic, and long-term information from the context window.
- Poly memory broker — Creates context and associates it with the relevant code history.
- Oracle Autonomous Database — Persists shared agent memory through the Oracle agent memory SDK.
- US collaborator — Receives code together with the relevant retained context.
- EMEA coding session → Fork, branch, and commit (commits code)
- EMEA coding session → Session memory (produces reasoning context)
- Session memory → Poly memory broker (captured for sharing)
- Fork, branch, and commit → Poly memory broker (supplies fork, branch, and commit identity)
- Poly memory broker → Oracle Autonomous Database (persists retained memory)
- Oracle Autonomous Database → Poly memory broker (returns shared memory)
- Poly memory broker → US collaborator (delivers context tied to the code)

### Shared memory is the team-level multiplier

[17:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1060s)

Malcolm extends the team example into a broader claim: memory becomes non-negotiable when an agent must operate across people and sessions. She points to an account of an in-house data agent that used memory to filter correctly rather than relying only on string matching, and to Harrison Chase’s framing that ownership of the harness determines ownership of memory.

A local memory file can work for one agent or one user, but shared enterprise work introduces identity, concurrency, authority, and access questions. The talk does not prove that file-backed memory cannot scale; its practical point is that a team memory system must coordinate multiple participants rather than preserve context for only one session.

The closing distinction is between individual and organizational speed. AI can shorten one person’s implementation loop. Shared memory aims to keep that work useful after the session ends, across a time-zone handoff, a new branch, or another collaborator. That is why the database is presented as the “last line of defense”: it is the persistent layer that remains after context windows close and models change.

For experimentation, Malcolm points attendees toward the Oracle AI Developer Hub for coding materials and applications and toward LiveLabs for temporary hands-on workshops. She also describes an OCI Always Free offering with a free Oracle Database, free compute, 3,000 emails per month, and 200 gigabytes of storage. Those quantities describe the offering presented in the recording, not verified current terms or eligibility. She closes by inviting attendees to build something and tell her what they made.

## Key takeaways

- AI-assisted coding can move the bottleneck from implementation to coordination: a commit preserves changed code but not necessarily the intent, alternatives, or next steps behind it.
- An enterprise agent combines a model with tools, active context, memory, retrieval, security, and guardrails. Memory retains information; retrieval selects what returns to the context window.
- Memory has several useful dimensions: session versus cross-session duration, plus episodic and procedural content. Malcolm also names semantic memory but does not define it further in the talk.
- Specialized stores can address different data needs while multiplying security, patching, governance, and reconciliation work. Consolidating representations reduces that coordination burden without making every representation the same.
- Poly’s key mechanism is attaching retained session context to the relevant fork, branch, and commit so another collaborator can continue from the same reasoning. The talk describes this architecture but does not quantify its productivity gain.

## Resources

- [Official AI Engineer talk page and corrected transcript](https://ai.engineer/talks/jA_x7F8caHI-no-memory-no-harness-why-database-is) — Read the complete timestamped transcript, jump among chapters, and watch the recording alongside the article.

## Related talks

- [A Genius With Amnesia](https://ai.engineer/talks/jVjt-2g8NMY-genius-amnesia) — A closely related account of preserving organizational and cross-repository context for coding agents across sessions.
- [Architecting Agent Memory: Principles, Patterns, and Best Practices](https://ai.engineer/talks/W2HVdB4Jbjs-architecting-agent-memory-principles-patterns-best) — Expands the memory taxonomy into persistent storage and retrieval patterns for agentic systems.
- [12-Factor Agents: Patterns of reliable LLM applications](https://ai.engineer/talks/8kMaTybvDUw-12-factor-agents) — Provides a complementary production model for owning agent control flow, context, tools, and deterministic surrounding software.

## Slides

### No Memory, No Harness

Kay Malcolm introduces agent harnesses and frames the database as the last line of defense for production agents.

[0:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=12s) [Title slide for Kay Malcolm’s talk on databases and production agents.](https://assets.ai.engineer/sites/aiecode2025/sha256/51e14c43fd6a5a4349c06df3b25da891605130871a691fb27a262bf4d595af81.webp)

No Memory, No Harness
The database: the last line of defense for production agents

Kay Malcolm
Vice President
Oracle AI Database

ORACLE

### AI Makes Everyone Faster. So Why Isn’t the Team Faster?

Malcolm’s Netherlands team checked in code without its Codex context. When the US team woke up, they had the code but not the information behind it—one example of context siloed across her team.

[2:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=139s) [Team members grouped by function; the slide says faster individuals do not make a faster team when context remains siloed.](https://assets.ai.engineer/sites/aiecode2025/sha256/2c04416942efea999ab68a47a8d04cb3a7adba34a38d7e83e8555e2b6ba879cb.webp)

AI Makes Everyone Faster. So Why Isn’t the Team Faster?

Platform Development
David, William
Brianna, Teo

LiveLabs LiveStacks Development
Pat, Eugenio, Matt
Linda, Marco, Teodor

Demo/Workshop QA Documentation
Marco, Lucian
Valentina, Sanda

LiveLabs Frontend Development
Kevin, Pat, Eugenio
Carmen, Hope, Mary

Github
Ramona, Hope
Linda, William

AI makes the individuals on my team faster...
...faster developers do not make a faster team when context remains siloed.

2
Copyright © 2026, Oracle and/or its affiliates

### AI Assisted Coding Accelerates Individuals, but Can Slow the Team

Prompts and decisions stay in individual sessions, leaving developers and Codex sessions with different working context across 30+ repositories. Git records code, but not human intent.

[3:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=187s) [Two columns explain that context stays personal and repositories multiply divergence.](https://assets.ai.engineer/sites/aiecode2025/sha256/9ad9e5057fc51d16790858842b480c5985ddc5c2c101e214653b1f2a646d9928.webp)

AI assisted coding accelerates individuals, but can slow the team

Context stays personal

Prompts, assumptions, and decisions remain inside each developer’s session.

30+ repositories multiply divergence

Each developer and Codex session carrying a different working context

3
Copyright © 2026, Oracle and/or its affiliates

### AI Assisted Coding Accelerates Individuals, but Can Slow the Team

Prompts, assumptions, and decisions stay in individual sessions. Malcolm’s US team received the code but lacked the context needed to understand it.

[3:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=191s) [A single column explains that prompts, assumptions, and decisions remain in individual developer sessions.](https://assets.ai.engineer/sites/aiecode2025/sha256/0fcf4b49ee3f6eca1de35616fcf8c730faff324d6e85e966f38a162f3f9ba6fc.webp)

AI assisted coding accelerates individuals, but can slow the team

Context stays personal

Prompts, assumptions, and decisions remain inside each developer’s session.

3
Copyright © 2026, Oracle and/or its affiliates

### AI Assisted Coding Accelerates Individuals, but Can Slow the Team

Across 30+ repositories, developers and Codex sessions carry different contexts. Git records code rather than intent, leaving handoffs and reviews to reconstruct rationale, ownership, and unfinished work.

[3:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=223s) [Three columns describe personal context, repository divergence, and Git recording code rather than intent; the conclusion identifies context transfer as the bottleneck.](https://assets.ai.engineer/sites/aiecode2025/sha256/1a28595a5306a34f39eaf38eb58edb578e2f6189e1f5d082c6a99e57b1fa57f9.webp)

AI assisted coding accelerates individuals, but can slow the team

Context stays personal
Prompts, assumptions, and decisions remain inside each developer’s session.

30+ repositories multiply divergence
Each developer and Codex session carrying a different working context

Git records code, not intent
Handoffs and reviews must reconstruct rationale, ownership, and unfinished work after the fact.

Code creation is no longer our primary bottleneck. Context transfer is our new problem.

3
Copyright © 2026, Oracle and/or its affiliates

### Agent Memory Turns Personal Context Into Team Knowledge

Malcolm proposes a collaboration layer to capture decisions, progress, unresolved questions and Git provenance, so the team can reuse context as AI joins the work.

[3:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=232s) [A collaboration layer captures decisions, constraints, progress, unresolved questions, and contributor and Git provenance.](https://assets.ai.engineer/sites/aiecode2025/sha256/45ab869ec68388d548f4705f8578505f48de407823ccd0800cbeefb37643b913.webp)

Agent Memory Turns Personal Context Into Team Knowledge
Governed project knowledge, retrieved when it is relevant.

We need a collaboration layer
• Decisions and rationale
• Constraints and assumptions
• Progress and next steps
• Unresolved questions and conflicts
• Contributor and Git provenance

Turn the context of one developer into useful knowledge the team can continue using.

4
Copyright © 2026, Oracle and/or its affiliates

### What is a real enterprise agent?

An enterprise agent combines a model with a harness for tools, context, memory, retrieval, guardrails, and workflow. Short-term memory covers a session; long-term memory persists across sessions.

[7:22](https://www.youtube.com/watch?v=jA_x7F8caHI&t=442s) [An agent combines a model with a harness; memory types shown are short term, long term, episodic, procedural, and semantic.](https://assets.ai.engineer/sites/aiecode2025/sha256/96392d2b79ef651b9447b784f3e59819f4ad42d38a34423dd75ba1e0d1a844d3.webp)

What is a real enterprise agent?

Agent = Model + Harness

Harness:
Tools
Context
Memory
Retrieval
Guardrails
Workflow

Memory Types:
Short Term
Long Term
Episodic
Procedural
Semantic

5
Copyright © 2026, Oracle and/or its affiliates

### The world of data was once simple

The slide adds JSON and graph beside relational data. Malcolm recalls that specialized databases multiplied her weekly security and patching meetings from two to six.

[9:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=583s) [Traditional OLTP and analytics lead to a relational model using SQL and a database.](https://assets.ai.engineer/sites/aiecode2025/sha256/fe8bd1081ce011e577eee74c694504ec8eb40b405c5df30fd362181fef00bbf5.webp)

The world of data was once simple

Traditional OLTP
On relational databases

Traditional Analytics
On relational databases

Relational
SQL

THEN

6
Copyright © 2026, Oracle and/or its affiliates

[9:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=593s) [Traditional relational workloads lead to relational, JSON, and graph data.](https://assets.ai.engineer/sites/aiecode2025/sha256/b1f6e6064063897a7a366e3c9375cbb39a9c8786d46e0c26b915c6222b4d9bf6.webp)

The world of data was once simple

Traditional OLTP
On relational databases

Traditional Analytics
On relational databases

Relational
SQL

JSON

Graph

THEN

6
Copyright © 2026, Oracle and/or its affiliates

### The world of data was once simple

Traditional OLTP and analytics ran on relational databases. The slide contrasts that with relational, JSON, graph, and vector data; Malcolm says agents now need access to all of it.

[12:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=735s) [Traditional relational workloads lead to relational, JSON, graph, and vector data.](https://assets.ai.engineer/sites/aiecode2025/sha256/d8d0caf3205e01e4774a8c8a4b0f812b0e19530e619e28e4cb8d451f82236c1a.webp)

The world of data was once simple

Traditional OLTP
On relational databases

Traditional Analytics
On relational databases

Relational
SQL

JSON

Graph

Vector

THEN
NOW

6
Copyright © 2026, Oracle and/or its affiliates

### The world of data was once simple

Traditional OLTP and analytics both run on relational databases. The diagram then separates data into relational, JSON, and graph structures.

[12:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=738s) [Traditional relational workloads lead to relational, JSON, and graph data.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0cbbefb3c90eca8d4d9fc8e76894f14a84cc7977efeef33f1bc7eb8ae270f83.webp)

The world of data was once simple

Traditional OLTP
On relational databases

Traditional Analytics
On relational databases

Relational
SQL

JSON

Graph

THEN

6
Copyright © 2026, Oracle and/or its affiliates

### The world of data was once simple

Traditional workloads used relational databases; agents now need access to relational, JSON, graph, and vector data. Malcolm asks how an agent finds a single source of truth across them.

[12:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=763s) [A then, now, and next diagram shows data types expanding and agents needing access to them.](https://assets.ai.engineer/sites/aiecode2025/sha256/3f79b2b13283989a2616f7a2152b67e9be5a546eb26847a1e3f4172d48146739.webp)

The world of data was once simple

Traditional OLTP
On relational databases

Traditional Analytics
On relational databases

Relational
SQL

JSON

Graph

Vector

Agents need access to all this data.

THEN
NOW
NEXT

6
Copyright © 2026, Oracle and/or its affiliates

### Let’s play a game

Malcolm asks four volunteers to play relational, unstructured, graph and vector databases. They must decide how to store a sentence and who holds the single source of truth, while staying seated and whispering.

[13:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=808s) [A slide asks for four volunteers.](https://assets.ai.engineer/sites/aiecode2025/sha256/fdf5055be53195162f6fe4b371ab9cc11095c3a04bcd1ea4948acf8d7b640aaa.webp)

Let’s play a game

I need 4 volunteers

7
Copyright © 2026, Oracle and/or its affiliates

### Oracle AI Database 26ai

Kay Malcolm says JSON, graph, vector and spatial data can share a table and partition. The slide also maps workloads, developer tools and deployment options around Oracle AI Database 26ai.

[14:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=896s) [An overview of supported data types, workloads, tools, developer interfaces, and deployment options.](https://assets.ai.engineer/sites/aiecode2025/sha256/897663894a135be3bc79bd23a46ef1ba535da6c9c3af08debf9e2dd45aa83bc9.webp)

ORACLE AI Database 26ai

Any Data Type
Vector [1,4,8,2]
Spatial
JSON {JSON}
Text
XML
Relational

Any Workload
AI / ML
IoT
Analytical
Streaming
OLTP
Graph
Blockchain
Distributed

Tools
APEX
ORDS
SQLcl
AutoML
Enterprise Manager
SQL Developer VS Code

Dev Interfaces
REST {REST}
SQL First
MongoDB API
Language Support: PL, Java, RUST, NODE.JS, .NET, JS, C++, RUBY, C, PL/SQL, PHP, GO

Runs Anywhere
On-Premises
Engineered Systems
Containers
Autonomous Database
Base DB Service
Cloud@ Customer
@Azure / @AWS / @GCP

8
Copyright © 2026, Oracle and/or its affiliates

### Managed agents and context

Anthropic separates the session from Claude’s context window: the harness receives events and can retrieve them. The speaker describes file-based memory as a scaling challenge for enterprises.

[18:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1106s) [An Anthropic article on managed agents alongside an excerpt and a session-to-harness diagram.](https://assets.ai.engineer/sites/aiecode2025/sha256/763b83f03661dda1e5eb2a03c5a0a83f79a96614d86c258b8b81a90bb00b6270.webp)

Engineering at Anthropic

Scaling Managed Agents: Decoupling the brain from the hands

Published Apr 08, 2026

Harnesses encode assumptions that go stale as models improve. Managed Agents—our hosted service for long-horizon agent work—is built around interfaces that stay stable as harnesses change.

The session is not Claude’s context window

Long-horizon tasks often exceed the length of Claude’s context window, and the standard ways to address this all involve irreversible decisions about what to keep. We’ve explored these techniques in prior work on context engineering. For example, compaction lets Claude save a summary of its context window and the memory tool lets Claude write context to files, enabling learning across sessions. This can be paired with context trimming, which selectively removes tokens such as old tool results or thinking blocks.

But irreversible decisions to selectively retain or discard context can lead to failures. It is difficult to know which tokens the future turns will need. If messages are transformed by a compaction step, the harness removes compacted messages from Claude’s context window, and these are recoverable only if they are stored. Prior work has explored ways to address this by storing context as an object that lives outside the context window. For example, context can be an object in a REPL that the LLM programmatically accesses by writing code to filter or slice it.

Session
Harness
Events
getEvents

### OracleAgentMemory

OracleAgentMemory separates live conversation threads from longer-term memories and structured facts. An LLM-driven extractor turns thread messages into typed records; each type uses a different retrieval method.

[18:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1123s) [Diagram showing threads, memories and facts connected to an application through OracleAgentMemory.](https://assets.ai.engineer/sites/aiecode2025/sha256/502917f733563f9f117ecdb629a84b827a2bd7de027a358bf28e04c883c7cc20.webp)

OracleAgentMemory

Agent / Application
OracleAgentMemory

all three scoped by (user_id, agent_id, thread_id) — same SDK, different lifetime

THREADS short-term
one live conversation
messages · rolling summary · context card
retrieved by recency + ranking

MEMORIES long-term · semantic
prose-shaped observations
“Priya prefers conservative buy volumes.”
retrieved by semantic search

FACTS long-term · structured
atomic durable truths
“Priya works in EU region, timezone CET.”
retrieved by exact match or search

Memory Extractor  LLM-driven bridge: thread messages → typed records

Three building blocks behind one SDK. Threads hold the live conversation; Memories and Facts persist what's worth keeping; all three live on Oracle.

### Governed team memory

Kevin and Linda exchange context through a memory broker connected to the Oracle Agent Memory SDK and Autonomous Database. The SDK also connects to Oracle Private AI Services.

[19:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1176s) [Two developers share context through a memory broker connected to Oracle services; a closing statement emphasizes shared memory for teams.](https://assets.ai.engineer/sites/aiecode2025/sha256/c99af78a8a6c9240007d39c6c9f13def1eae94edc854567c8d9d013133248720.webp)

Two developers. One governed team memory.

Kevin
Share Context
Shared Context

Memory Broker
Share Context
Shared Context
Linda

Oracle Agent Memory SDK
pip install oracleagentmemory

Oracle Private AI Services
Autonomous Database

Short Term
Long Term
Episodic
Procedural
Semantic

AI makes individuals faster.
Shared memory on Oracle AI Database makes teams faster.

15
Copyright © 2026, Oracle and/or its affiliates

Interface text:
OpenAI Codex [illegible]
OpenAI Codex [illegible]

### Choose both

Oracle presents AI Database 26ai as combining filesystem and database memory, JSON and relational models, vector and lexical retrieval, and cloud and on-prem deployment, while pairing fast innovation with enterprise security.

[19:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1185s) [A table pairs filesystem and database, JSON and relational, innovation and security, vector and lexical retrieval, and cloud and on-premises deployment.](https://assets.ai.engineer/sites/aiecode2025/sha256/44d0ddf09078a616e3af2bfd3e62993d5a8f8f85b000d594bf67d79e0a4b6a6b.webp)

Don’t compromise in the age of AI
CHOOSE BOTH

NO COMPROMISE

ORACLE AI Database 26ai

AGENT MEMORY: Filesystem + Database
DATA MODELLING: JSON + Relational
VELOCITY: Fast innovation + Enterprise security
RETRIEVAL: Vector + Lexical
DEPLOYMENT: Cloud + On-prem

## Full transcript

[0:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=12s) Everyone, are we having fun?

[0:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=15s) >> Oh, you've got to give me way more than

[0:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=18s) that. So, let me tell you, um, my name

[0:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=20s) is Kay Malcolm. I am a retired hiphop

[0:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=23s) instructor. So, if I don't get more

[0:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=25s) energy than that, we will start. We'll

[0:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=28s) start. Are you having fun? [cheering]

[0:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=32s) >> Okay. All right. So, here's what we're

[0:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=34s) going to talk about today. Now, you guys

[0:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=36s) have heard a lot about two letters. Does

[0:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=39s) anyone want to guess what those two

[0:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=41s) letters are that I'm going to talk about

[0:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=42s) today?

[0:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=46s) >> Data. That was pretty good. DB. I'm

[0:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=48s) going to talk about AI, but I'm

[0:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=50s) specifically going to talk about agent

[0:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=53s) harnesses. But before I do that, I want

[0:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=56s) to introduce you all to a few people. Is

[0:57](https://www.youtube.com/watch?v=jA_x7F8caHI&t=57s) that okay?

[0:59](https://www.youtube.com/watch?v=jA_x7F8caHI&t=59s) Yes or yes. Is that okay?

[1:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=62s) >> I gave choices. Yes. Anyway. All right.

[1:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=65s) Okay. All right. This is my team.

[1:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=69s) I run an outbound database product

[1:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=72s) management team at Oracle. I've been at

[1:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=74s) Oracle a really long time, 20 years.

[1:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=78s) Funny story, I started when I was 12.

[1:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=80s) So, don't do the math and don't start

[1:22](https://www.youtube.com/watch?v=jA_x7F8caHI&t=82s) start adding in your head. Um, and we've

[1:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=85s) got a problem. That problem is I've got

[1:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=89s) one group

[1:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=91s) that does platform development and then

[1:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=94s) I have another group that does content

[1:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=96s) development for live labs, a platform

[1:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=98s) that I wrote myself. So yeah, I'm an

[1:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=101s) engineer but I'm kind of a developer

[1:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=103s) poser too. And then I've got another

[1:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=105s) group who does QA

[1:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=108s) and then I have another group who does

[1:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=109s) my front-end development

[1:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=112s) with AI. Here's what I found out as a

[1:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=116s) leader. Because in the token maxing era

[2:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=120s) of 2025, because you know, we're not

[2:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=122s) token maxing anymore, right?

[2:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=125s) We are responsible AI now. But in the

[2:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=128s) token maxing era, the thing that I found

[2:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=130s) out was while AI was making the

[2:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=134s) individuals on my team faster, there was

[2:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=138s) another problem it was creating.

[2:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=143s) It wasn't making my team more

[2:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=146s) productive.

[2:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=148s) And the reason was when one team from

[2:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=152s) the Netherlands checked in code at my

[2:35](https://www.youtube.com/watch?v=jA_x7F8caHI&t=155s) 4:00 a.m. in the morning because I've

[2:37](https://www.youtube.com/watch?v=jA_x7F8caHI&t=157s) got half of my team that's in AMIA and I

[2:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=159s) have half of my team who that are here

[2:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=161s) in the United States. They checked in

[2:44](https://www.youtube.com/watch?v=jA_x7F8caHI&t=164s) the code but they didn't check in their

[2:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=167s) context from Codeex. We use Codeex at

[2:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=170s) Oracle.

[2:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=171s) So then when the US team woke up,

[2:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=176s) they got the code but no information

[2:59](https://www.youtube.com/watch?v=jA_x7F8caHI&t=179s) about the context. So we used AI to

[3:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=183s) solve a problem that AI created. And

[3:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=187s) here's what we did. Oh well, let me talk

[3:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=189s) about this first. So some of the issues,

[3:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=192s) the context, like I said, wasn't shared.

[3:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=195s) GitHub wasn't tracking that. I had

[3:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=199s) repositories that were diverging and I

[3:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=201s) was asking the managers who work for me,

[3:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=204s) what's happening to your teams? Why why

[3:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=207s) are we not going faster? We're spending

[3:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=210s) all of this money on tokens. We're

[3:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=211s) spending all this money on AI, yet

[3:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=213s) something is missing because we're still

[3:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=216s) spending time doing testing and

[3:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=219s) validation. So our netn net wasn't

[3:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=221s) really wasn't really working for us

[3:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=225s) because git records the code and not

[3:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=227s) human intent.

[3:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=229s) So it's a problem

[3:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=232s) and

[3:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=233s) even though code creation

[3:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=238s) was no longer our problem

[4:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=240s) still had a bottleneck.

[4:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=243s) We needed a collaboration layer. Now, I

[4:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=247s) do have members of my team in the

[4:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=249s) audience, so don't judge me, and you

[4:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=252s) know who you are. I'm not saying that

[4:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=254s) you all didn't collaborate. But now,

[4:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=258s) we've got a new team member, and that

[4:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=260s) new team member is AI.

[4:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=263s) So,

[4:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=265s) we needed to figure out how to track our

[4:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=267s) progress in our next steps. how to

[4:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=271s) rationalize decisions

[4:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=273s) that the

[4:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=276s) agent was making.

[4:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=279s) We needed to figure out how to resolve

[4:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=283s) questions in conflicts.

[4:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=285s) Okay,

[4:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=288s) hold my problem. Will you all hold my

[4:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=290s) problem for me right here? We're going

[4:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=291s) to just tuck that in a little box. Let

[4:54](https://www.youtube.com/watch?v=jA_x7F8caHI&t=294s) me define what a enterprise agent

[4:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=298s) actually is. Now, most people think that

[5:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=300s) an enterprise agent is the model and

[5:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=304s) workflow. How many people agree with me?

[5:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=308s) Man, this tough crowd you. Okay, one

[5:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=311s) person. Okay, the rest of you think it's

[5:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=314s) a little bit more. Okay, let's see what

[5:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=318s) could it be that a real enterprise agent

[5:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=324s) has tools.

[5:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=326s) Tools are how it does things.

[5:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=330s) Context.

[5:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=333s) The context. That's a context window.

[5:35](https://www.youtube.com/watch?v=jA_x7F8caHI&t=335s) That's what's in the actual prompt.

[5:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=339s) Memory.

[5:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=340s) Huh?

[5:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=343s) And if you're thinking, "But wait, K,

[5:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=346s) memory, you just said that the model is

[5:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=348s) kind of like the brain of the

[5:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=350s) operation." Hold tight. We're going to

[5:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=352s) talk a little bit more about memory

[5:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=356s) retrieval because you don't want to get

[5:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=358s) everything back. So that's being able to

[6:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=360s) to retrieve the right information back.

[6:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=364s) And then I know that there are a lot of

[6:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=366s) developers here and you all don't care

[6:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=368s) about security.

[6:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=371s) I care about security because I work for

[6:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=374s) the most secure database company and I

[6:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=377s) used to work for um agency that has no

[6:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=381s) name. But guard rails is also important.

[6:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=385s) This is the harness. I speak in

[6:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=388s) analogies and I and I speak in stories

[6:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=391s) because if I tell you this and Marvel,

[6:35](https://www.youtube.com/watch?v=jA_x7F8caHI&t=395s) you know exactly what I'm talking about.

[6:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=398s) So the agent, think of it as the model,

[6:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=402s) little brain floating a in a glass jar

[6:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=406s) plus this harness. This harness is the

[6:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=410s) body.

[6:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=412s) So it's how the agent can actually do

[6:55](https://www.youtube.com/watch?v=jA_x7F8caHI&t=415s) things and get things done. That memory,

[7:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=420s) that's the part of the central nervous

[7:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=423s) system. And you remember the central

[7:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=424s) nervous system connects the brain to the

[7:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=427s) rest of the body, legs, arms. That's the

[7:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=431s) part of the central nervous system that

[7:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=434s) carries context. So you remember my

[7:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=437s) problem with Git.

[7:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=440s) What I needed was memory. Okay, so there

[7:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=444s) are a number of memory types. I chose

[7:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=447s) five, the five most common ones that

[7:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=449s) people talk about and these are the ones

[7:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=450s) that I want you to remember. The first

[7:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=452s) one is short-term memory. That's the

[7:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=454s) session, right? And so if you're storing

[7:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=458s) memory of an AI uh process, that is the

[7:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=462s) short-term memory is if you're with

[7:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=465s) chat, cloud code, right? Codeex, pick

[7:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=468s) your poison. The long-term memory is

[7:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=471s) what persists across sessions.

[7:55](https://www.youtube.com/watch?v=jA_x7F8caHI&t=475s) Episodic memory. Hm.

[7:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=478s) What happened the last time

[8:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=483s) I interacted with fill in the blank?

[8:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=486s) That's your episodic memory. Procedural

[8:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=489s) memory

[8:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=491s) tools, steps that were taken.

[8:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=495s) And then finally, semantic memory. And

[8:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=498s) semantic memory because we're talking

[8:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=499s) enterprise agents. We're not talking the

[8:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=503s) agent that I built, Sasha Fierce,

[8:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=505s) because remember I told you guys that I

[8:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=506s) was a I'm a a dancer. So, of course, my

[8:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=510s) my chief of staff is going to be called

[8:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=512s) Sasha Fierce because that was Beyonce.

[8:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=514s) Any Beyonce fans?

[8:37](https://www.youtube.com/watch?v=jA_x7F8caHI&t=517s) Okay, I'm sorry. All right, we got to

[8:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=519s) focus. Okay, so these are the memory

[8:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=522s) types. Now, when you're defining this

[8:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=525s) real enterprise agent in this memory,

[8:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=530s) there's something you need to consider

[8:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=531s) where to store it. And so, I'm going to

[8:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=533s) tell you guys a story. But when I tell

[8:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=536s) you the story, you have to promise me

[8:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=538s) that you're not going to judge me. Do

[9:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=540s) you promise?

[9:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=546s) Do you promise

[9:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=548s) >> you're not recording me, right? Because

[9:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=550s) this doesn't paint me in a good light.

[9:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=552s) Okay. All right. The world of data was

[9:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=554s) one simple. I've been at Oracle a long

[9:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=556s) time, but I came from a customer. That

[9:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=558s) customer's name was Southern Company. It

[9:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=559s) was a power company. I'm based out of

[9:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=561s) Atlanta. And I was hired at Southern

[9:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=564s) Company because I was a rockar

[9:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=567s) performance tuner. You had a SQL query.

[9:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=569s) I mean, I'm dating myself, but whatever.

[9:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=571s) You had a SQL query. I knew all of the

[9:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=573s) innit.org parameters. Even the ones when

[9:35](https://www.youtube.com/watch?v=jA_x7F8caHI&t=575s) you called support and they said, "Don't

[9:37](https://www.youtube.com/watch?v=jA_x7F8caHI&t=577s) remember these. Don't write them down."

[9:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=578s) I wrote them down in my little notebook.

[9:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=580s) I could tune a query within one inch of

[9:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=582s) its life. Then one of you came to my

[9:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=587s) desk because I mean the world the world

[9:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=589s) was rows and columns. It was a great

[9:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=591s) time back in my Albundy days um and said

[9:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=596s) hey I need to store data unstructured.

[10:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=601s) Why I need to do that?

[10:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=604s) And so me being K the the diligent DBA,

[10:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=608s) I was like, "Let me figure it out and

[10:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=611s) get back to you."

[10:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=614s) Did I get back to him?

[10:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=616s) I didn't get back to him. Now, the thing

[10:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=619s) you have to know about Southern Company

[10:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=621s) was for every database system that a DBA

[10:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=624s) managed, I had to attend two meetings.

[10:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=626s) Today, when I hear Sarbain Oxley, I

[10:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=629s) still throw up a little bit in the back

[10:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=630s) of my throat. So I had to attend a

[10:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=632s) security meeting and a patching meeting

[10:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=634s) every week. Never failed. Now because

[10:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=638s) this developer installed a database that

[10:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=642s) was specialized for unstructured. Okay,

[10:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=645s) there are really smart people in the

[10:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=646s) room. How many meetings am I going to

[10:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=648s) now?

[10:54](https://www.youtube.com/watch?v=jA_x7F8caHI&t=654s) Four. Okay, I'm a little annoyed, but

[10:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=656s) I'm like, okay, we can we can we can do

[10:59](https://www.youtube.com/watch?v=jA_x7F8caHI&t=659s) this. Then they said, "Okay, since

[11:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=661s) you're such a good tuner,

[11:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=663s) I need you to figure out this

[11:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=665s) relationship." Now, the way that

[11:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=667s) Southern Company worked, there was this

[11:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=669s) people could die application, um, and it

[11:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=672s) was a it was like a Nokia phone that

[11:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=676s) people who were climbing the towers,

[11:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=678s) right? So, you guys have have been in a

[11:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=680s) storm and the power goes out, right? And

[11:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=683s) then you're pretty sure that within

[11:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=685s) maybe an hour or two the power will go

[11:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=687s) on. Well, that system that would tell

[11:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=691s) the people who were climbing those trees

[11:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=692s) and risking their lives to turn the

[11:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=694s) power back on sometimes would have false

[11:37](https://www.youtube.com/watch?v=jA_x7F8caHI&t=697s) positives or false negatives. So, they

[11:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=699s) wanted to look at all of the other um uh

[11:44](https://www.youtube.com/watch?v=jA_x7F8caHI&t=704s) polls in the area

[11:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=706s) to try to get away from the false

[11:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=708s) positive or the false negative. And so I

[11:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=710s) did that in a SQL query and it was it

[11:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=713s) was amazing. It was a five nested union

[11:57](https://www.youtube.com/watch?v=jA_x7F8caHI&t=717s) all statement. It was some of my best

[11:59](https://www.youtube.com/watch?v=jA_x7F8caHI&t=719s) work. Now it might have taken like 20

[12:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=721s) minutes to work but it was like a

[12:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=723s) predecessor to graph.

[12:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=726s) Yeah, they they install Neo4j.

[12:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=730s) So now how many meetings am I going to?

[12:13](https://www.youtube.com/watch?v=jA_x7F8caHI&t=733s) Six. That's a problem.

[12:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=737s) So I um Oh, let me I got ahead of

[12:19](https://www.youtube.com/watch?v=jA_x7F8caHI&t=739s) myself. So you know what I did? I quit.

[12:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=743s) I left and I came to Oracle because I

[12:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=744s) was like this is a problem and maybe I

[12:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=746s) can go to Oracle to help solve it. So

[12:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=747s) then Joe Mundy called me and he said hey

[12:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=750s) um we are installing Reddus. Oracle is

[12:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=754s) late to the game. We've got a vector

[12:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=756s) database.

[12:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=758s) Okay.

[12:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=760s) But here's your problem, Joe.

[12:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=765s) Agents now need access to all of this

[12:48](https://www.youtube.com/watch?v=jA_x7F8caHI&t=768s) data. So if data is in an Oracle

[12:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=771s) database, if then it's also in an

[12:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=773s) unstructured JSON database, if it's in a

[12:55](https://www.youtube.com/watch?v=jA_x7F8caHI&t=775s) graph database and it's in a vector

[12:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=778s) database, where is your single source of

[13:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=781s) the truth?

[13:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=783s) The agent has to figure that out.

[13:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=785s) Sometimes it'll get it right.

[13:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=788s) Most times it'll get it wrong and it's

[13:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=790s) going to burn up a whole bunch of

[13:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=791s) tokens. And so now if you want to store

[13:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=795s) your memory somewhere, you can store it

[13:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=797s) in a file system.

[13:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=800s) You can store it in

[13:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=803s) clawed or chatgpt because we all know

[13:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=805s) about the memory.md file.

[13:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=809s) But that's going to be a problem. Now I

[13:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=811s) want to illustrate this. I need four

[13:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=812s) volunteers. I can see you raise your

[13:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=814s) hand. One, two. Okay, I can't. Maybe I

[13:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=818s) can. Three.

[13:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=820s) I need a fourth. Ah, fourth in the back.

[13:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=823s) Okay. Fourth in the back. You are going

[13:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=825s) to be our old reliable. You're going to

[13:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=827s) be a relational database. Yes or yes.

[13:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=830s) You got your So, you have your

[13:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=831s) assignment. Okay. And then there was

[13:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=833s) someone here. You're going to be my

[13:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=836s) unstructured database. Okay. And then

[13:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=838s) where was my other? Ah, very good.

[14:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=840s) You're going to be my graph database.

[14:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=842s) You good? Relationship guy. You look

[14:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=844s) like a relationship guy. All right. Very

[14:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=846s) good. Fourth. Where was my fourth?

[14:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=849s) Was it you? Yes. Yeah. You are my vector

[14:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=854s) database. Okay. Now, everybody be

[14:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=858s) really, really quiet.

[14:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=860s) For my four volunteers, I need you all.

[14:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=864s) I'm going to say something to you. And I

[14:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=868s) need you all to decide how you're going

[14:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=870s) to store it and who's going to have the

[14:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=872s) single source of the truth. You can't

[14:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=874s) get up from your seats and you have to

[14:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=876s) whisper because if you talk loud that's

[14:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=878s) 5x the tokens for you. Yes.

[14:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=881s) Okay. Are we ready? All right.

[14:44](https://www.youtube.com/watch?v=jA_x7F8caHI&t=884s) The cow jumped over the moon.

[14:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=889s) Go.

[14:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=893s) Doesn't really work, does it? That's a

[14:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=896s) problem. Okay,

[14:59](https://www.youtube.com/watch?v=jA_x7F8caHI&t=899s) Oracle. And if you don't forget one, if

[15:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=902s) you forget everything I say and you

[15:04](https://www.youtube.com/watch?v=jA_x7F8caHI&t=904s) remember one thing,

[15:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=906s) Oracle is not the Oracle that you think

[15:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=909s) that is why I am here today. How many of

[15:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=912s) you knew that Oracle could natively in

[15:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=916s) the same table down to the same

[15:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=918s) partition store JSON graph vector my

[15:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=923s) vector friend over there my JSON friend

[15:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=926s) spatial

[15:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=928s) you want your memory to be immutable

[15:30](https://www.youtube.com/watch?v=jA_x7F8caHI&t=930s) blockchain in the same database raise

[15:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=933s) your hand yeah

[15:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=936s) we have a marketing problem

[15:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=939s) so any data type can be stored in a 26AI

[15:44](https://www.youtube.com/watch?v=jA_x7F8caHI&t=944s) database any workload anywhere AWS GCP

[15:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=949s) Azure OCI on prem choice and flexibility

[15:54](https://www.youtube.com/watch?v=jA_x7F8caHI&t=954s) so now when we take this and we talk

[15:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=956s) about the agent I want to be able to

[15:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=958s) store my long-term and procedural memory

[16:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=960s) in relational on in JSON I want to store

[16:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=963s) my short-term and my long-term memory

[16:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=965s) graph I want to store procedural because

[16:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=967s) procedural that's how I figure out the

[16:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=969s) relationships right the steps

[16:11](https://www.youtube.com/watch?v=jA_x7F8caHI&t=971s) my episodic and semantic memory. I need

[16:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=974s) to do some vector and then store it also

[16:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=977s) as text. Now, if I have four different

[16:22](https://www.youtube.com/watch?v=jA_x7F8caHI&t=982s) databases, you all saw they can't talk

[16:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=984s) to each other. It's going to be a

[16:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=986s) problem. And so, what I'm saying to you

[16:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=989s) today is the Oracle AI database is the

[16:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=993s) best place to store this agent memory

[16:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=996s) that's going to power your harness.

[16:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=998s) Remember your harness is your body

[16:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1000s) [music] and that memory is your central

[16:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1002s) nervous system. Okay, back to PY. So the

[16:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1007s) problem that I had, we solved it with a

[16:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1009s) memory broker named Py. We used agent

[16:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1013s) memory. We got out of that automatic

[16:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1016s) continuity.

[16:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1018s) So with my team, they were able to share

[17:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1021s) not just their code, but PY also kept

[17:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1025s) track of the context. So if one context

[17:09](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1029s) window was had procedural memory,

[17:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1032s) episodic memory, information about the

[17:14](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1034s) long-term memory, that was then shared

[17:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1037s) with the other folks on the team. You

[17:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1040s) could call them agents, if you will.

[17:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1041s) They're just human agents shared across

[17:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1044s) forks.

[17:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1046s) The developers on the team remained in

[17:28](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1048s) control while Polly was able to create

[17:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1054s) the context, figure out which fork and

[17:37](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1057s) branch it belonged to and which commit

[17:40](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1060s) it belonged to. Now this is a very

[17:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1062s) simplistic example but when you take

[17:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1065s) this to the enterprise here's what

[17:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1067s) happens.

[17:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1069s) Memory is the thing that becomes

[17:51](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1071s) non-negotiable in an agent's harness.

[17:54](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1074s) Now these are three papers that that I

[17:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1076s) read um on the airplane. This first one

[18:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1080s) is from open AI and it's about its

[18:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1081s) in-house data agent and the thing that

[18:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1083s) it says is it is saying that its

[18:07](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1087s) in-house data agent actually needs

[18:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1090s) memory. Memory was crucially important

[18:13](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1093s) to ensure that its agent was able to

[18:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1096s) filter correctly instead of trying to

[18:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1098s) string match.

[18:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1100s) Harrison Chase said, "Your harness, your

[18:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1103s) memory. And if you don't own your

[18:24](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1104s) harness, you don't own your memory."

[18:26](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1106s) Which is key. And then I'm sure you all

[18:29](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1109s) are wondering, "Well, Claude has memory.

[18:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1111s) Why can't I use that?" Well, it's kind

[18:32](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1112s) of like file system memory and it works

[18:35](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1115s) with one, but just like in my example,

[18:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1118s) when you scale past one, and you're

[18:41](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1121s) going to scale past one in the

[18:43](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1123s) enterprise, it creates a problem. So

[18:46](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1126s) Oracle has a Oracle agent memory pap

[18:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1130s) package. PIP install Oracle agent

[18:53](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1133s) memory. You get access to it. And this

[18:56](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1136s) memory is this SDK that we have is the

[19:01](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1141s) thing that will hold your live

[19:02](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1142s) conversations, your memories, your facts

[19:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1145s) and figure out what is worth keeping. So

[19:08](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1148s) if we look at Py now, Kevin

[19:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1152s) can share his context with Py, our

[19:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1155s) memory broker. We use the Oracle agent

[19:17](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1157s) memory SDK. It's stored in an Oracle

[19:20](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1160s) autonomous database.

[19:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1163s) We can use the LLM of our choice or we

[19:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1165s) can use a local model through the Oracle

[19:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1167s) private AI services container.

[19:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1171s) And then Linda, who's actually sitting

[19:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1173s) right here, can interact and work with

[19:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1176s) Kevin, no issues.

[19:38](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1178s) So yes, AI makes individuals faster.

[19:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1182s) Shared memory on an Oracle AI database

[19:44](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1184s) makes teams faster. So I don't want you

[19:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1187s) all to compromise. In the age of AI,

[19:50](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1190s) what 26AI does is you can choose

[19:55](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1195s) and pick what's best for agent memory

[19:58](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1198s) file system stored in a database file

[20:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1200s) system or in the database. If you need

[20:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1203s) to do data modeling, you've got JSON,

[20:05](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1205s) you've got relational. We've got choice.

[20:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1210s) Okay, I've got some goodies for you. The

[20:12](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1212s) Oracle AI developer hub. That's where

[20:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1215s) you can guys you guys can get coding

[20:16](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1216s) materials, the applications, what I

[20:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1218s) talked about today. Livelabs.oracle.com.

[20:21](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1221s) If you've done any of our workshops

[20:23](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1223s) today, that happens to be something that

[20:25](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1225s) I wrote myself about six years ago and

[20:27](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1227s) 40 million users um ago. Spend my OCI

[20:31](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1231s) tenency money.

[20:33](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1233s) kick the tires on any Oracle technology

[20:36](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1236s) um for six hours, 12 hours, however long

[20:39](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1239s) you need. Um and then I'm giving you all

[20:42](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1242s) all a Mac Mini. No, I'm just kidding.

[20:45](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1245s) I'm giving you an OCI Mini. So, I don't

[20:47](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1247s) know if you knew, but there is an always

[20:49](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1249s) free OCI. It is the most generous of any

[20:52](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1252s) of the hyperscalers where you can get a

[20:54](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1254s) free Oracle database, free compute, you

[20:57](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1257s) can send 3,000 emails a month, 200 gig

[21:00](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1260s) in storage, and if you click on that,

[21:03](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1263s) you can get access to it. Or just search

[21:06](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1266s) Google for Oracle Cloud, always free.

[21:10](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1270s) Connect with me. If you build something,

[21:13](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1273s) will you all message me and let me know?

[21:15](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1275s) Yes or yes?

[21:18](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1278s) >> Thank you.

[21:34](https://www.youtube.com/watch?v=jA_x7F8caHI&t=1294s) >> [music]
