Oracle AI Database · AI agent memory · Continual learning

Memories Are the Magic: Build Governed AI Agent Memory with Oracle AI Database

Develop agents with working, episodic, semantic, and procedural memory; Retain, Recall, Reuse, and Refine; lifecycle controls; Deep Data Security; and human-approved learning on Oracle AI Database.

By Paul Parkinson · Updated August 10, 2026

An AI agent does not become stateful because its model has a long context window. It becomes stateful when useful experience is deliberately captured, scoped, recalled, corrected, expired, and reused. This demo makes that external memory loop visible: read before the turn, write after the turn, and keep Oracle AI Database as the durable, transactional governance boundary.

The included concierge for the fictional Flynn's Theme Park remembers visitor Ava's accessibility needs and preferences, builds a scoped context card, corrects a bad extracted fact, expires a temporary route closure, and turns repeated successful traces into a human-approved reusable skill. Oracle Deep Data Security gives Ava and Leo different database data roles, so Leo can use the approved shared skill while Oracle AI Database filters Ava's private rows and raw traces. A separate Memory Quest lane then combines those memory principles with SQL Property Graph, Oracle Spatial, AI Vector Search, and transactional gamification.

All source code, SQL, configuration, and browser demo files are available in the repository. For a product-by-product view, see the separate AI agent memory platform comparison.

Flynn's Theme Park Scenario at a Glance

This sequence is the complete application flow. Steps 0 through 7 exercise Oracle Agent Memory lifecycle operations and the Ava-versus-Leo Deep Data Security proof on MAGIC_PY_MEMORY. Steps 8 through 12 add the AIM_PARK_* graph, Spatial, vector, quest, and reward lane. Steps 13 through 16 add the optional Lens Studio and Spectacles AR flow. Every action produces an inspectable application or database transition.

How the Two Flows Form One Gamified Learning Loop

The walkthrough keeps the governed-memory and Memory Quest controls separate so each concept is easy to teach. A production concierge can combine them in one continuous experience:

1. Recall: Ava asks for a rainy-evening activity. Her scoped memory supplies the minimal-stair, quiet-space, and lantern-show preferences.
2. Plan and play: graph and Spatial queries turn those preferences into route constraints. The app starts Covered Constellations and commits each checkpoint, point award, and badge transactionally.
3. Retain the outcome: completion, route choice, timing, and Ava's feedback become a scoped episode. The badge is evidence of task completion, not proof that every guest should receive the same plan.
4. Learn under controls: repeated successful, minimized outcomes can induce a candidate rainy-route procedure. Privacy checks and human approval govern the general lesson, while Deep Data Security keeps Ava's private facts and raw traces from Leo.
5. Reuse: Leo can receive the approved procedure and a quest adapted to his own memory. His points, route, and rewards remain separate from Ava's.

The same pattern also supports family party quests that preserve individual accessibility needs, seasonal operations quests that reward safe reroutes, and discovery quests that use GraphRAG to reveal location-aware lore.

Add an Optional Lens Studio and Spectacles AR Experience

The AR client is a presentation layer over the same governed services, not a second memory system. Lens Studio 5.15.4 can preview route arrows, clues, checkpoint state, privacy status, and HTTPS calls. On Spectacles hardware, the ASR Module can transcribe a guest saying “remember this,” while the Internet Module sends the confirmed text to the Oracle Agent Memory service.

The implementation keeps four boundaries visible:

• Sensing is not recording: the status overlay reports AR camera sensing even when media recording is off.
• Durability requires confirmation: speech or perception remains transient until the guest confirms the memory write.
• Media is minimized: the default path embeds an opted-in transcript or caption. Raw video storage is optional and represented only by an HTTPS object URI.
• Scope precedes similarity: guest identity, consent status, session expiration, and record TTL are applied before semantic ranking.

AIM_AR_SESSIONS stores separate camera-sensing, media-recording, location-sharing, and retention choices. AIM_AR_MEDIA stores consented descriptions, optional object references, native vectors, and expiration. AIM_AR_AUDIT records session, memory, media, and search events. Private “remember this” observations are stored through Oracle Agent Memory with exact guest, concierge-agent, and AR-thread scope.

The browser simulator and database/API paths work without hardware. Lens Studio Preview can model the overlay and HTTPS contract, while ASR, camera frames, permission prompts, tracking, outdoor visibility, comfort, battery, heat, and venue rules require actual Spectacles and park testing. The responsive browser map remains the non-AR accessibility fallback.

The prior rainy-visit episode is a seeded demonstration record, not evidence of an earlier live session. Retain stores that simulated episode plus three separate synthetic, generalized rainy-route outcomes for skill induction. These unscoped outcomes pass the demo's privacy gate and remain reviewable evidence rather than automatically anonymous data.

From Prompt Engineering to Context Engineering to Memory Engineering

Agent memory combines models, extraction, embeddings, retrieval, and persistent storage so an agent can retain, recall, update, and forget information while maintaining continuity across long-horizon tasks. Memory engineering is the discipline of designing and operating that lifecycle so retained experience remains useful, scoped, current, and governable over time.

The application pattern has evolved from single-turn LLM chatbots, through RAG, to automated or human-in-the-loop multistep workflows with limited autonomy, and finally to agentic applications that combine four capabilities: memory, actions or tools, perception of inputs such as text, video, or audio, and model-based reasoning.

1. Prompt engineering addresses instruction sensitivity by shaping linguistic patterns for one turn.
2. Context engineering works within bounded, position-sensitive context windows by retrieving, organizing, summarizing, compacting, or offloading the right information for one inference. Stable project facts and conventions may resemble AGENTS.md or CLAUDE.md, while reusable procedures may resemble SKILL.md.
3. Memory engineering overcomes statelessness by governing what persists across interactions, how it is recalled, and when it is corrected, consolidated, expired, or forgotten.

The memory lifecycle is easiest to remember as the four Rs:

• Retain: extract and store useful facts, episodes, and operational state.
• Recall: search inside the correct user, agent, tenant, status, and time scope.
• Reuse: assemble a compact context card for the next turn.
• Refine: correct, consolidate, version, expire, or delete state.

Map the Four Rs to Oracle Agent Memory Source Methods

OracleAgentMemory configures the shared store, schema, extraction, embedding, and search services and creates scoped OracleThread instances; OracleThread binds user, agent, and thread identity to message, memory, search, and context-card operations.

The API maps the first three Rs directly to OracleThread. Refinement uses the library's delete and add primitives when a stored memory must be replaced.

OracleThread thread = memory.getThread(threadId);

thread.addMemory(memory);                              // OracleThread: Retain
List<OracleSearchResult> hits =
    thread.search(query, 8, recordTypes);              // OracleThread: Recall
OracleContextCard card = thread.getContextCard();      // OracleThread: Reuse
thread.deleteMemory(oldMemoryId);                      // OracleThread: Refine
thread.addMemory(correctedMemory);                     // OracleThread: Refine

Refine uses delete followed by add because this implementation does not expose a single updateMemory(...) method. RAG retrieves existing knowledge; agent memory adds the write-back and lifecycle needed to change what the system knows from later interactions.

Why Agents Forget

A stateless agent repeatedly re-onboards users, repeats failed approaches, and forgets what produced a good outcome. Trust cannot compound because experience disappears at the end of the call. A large prompt can postpone the problem, but it does not provide identity scope, correction, deletion, expiration, transaction boundaries, or a durable audit history.

An agent is still a loop: observe, plan, act, and evaluate. The model supplies reasoning inside that loop. External memory acts as a computational exocortex across loops, preserving selected facts and outcomes after the model invocation ends. The distinction matters because context-window contents are transient, while database records can have owners, versions, policies, and an audit trail.

The durable advantage is not one clever prompt. It is accumulated, governed experience that the right agent can recall at the right time.

The Four Memory Types

These are conceptual analogies rather than storage rules. A file such as CLAUDE.md or AGENTS.md can contain both semantic facts and procedural instructions, so each entry should be classified by what it communicates and how the agent uses it.

These categories prevent a common design failure: treating every transcript fragment as equally durable. A live closure should expire; a confirmed accessibility preference can live longer; a reusable operational skill should contain the general lesson, not the original guest's private data.

What the Demo Actually Implements

What Enters the Model Context?

The context assembler selects memory for each turn rather than sending the entire memory store to the model:

• Working memory: the current request, recent conversation, and active task state provide immediate context.
• Semantic memory: relevant visitor facts and preferences are recalled within the authorized identity scope. Frequently useful facts may appear often, but semantic memory is not automatically sent in full on every turn.
• Procedural memory: an applicable approved guideline or skill is included only when the current task needs that procedure.
• Episodic memory: relevant prior experiences and outcomes are selected, commonly through scoped vector search, when they can improve the current decision.

The resulting context card must also fit the model's token budget. Structured authorization and lifecycle filters decide what the agent may consider before vector similarity and task relevance decide what is useful.

The seven-step teaching path uses fixed inputs and explicit application and SQL transitions so a live talk remains repeatable. The live memory library path uses Ollama for extraction and Oracle AI Database for vector generation and similarity ranking. Neither claims that the model retrained itself. The library calls, database behavior, search, transactions, identity scope, TTL, trace persistence, pooling, and human approval are real.

Memory Library Configuration

The builder receives the UCP data source, selects isolated table names, enables message persistence and memory extraction, and supplies the database embedder and Ollama adapter.

this.memory = OracleAgentMemory.builder()
    .dataSource(dataSource)
    .tablePrefix("OAMJ_CONCIERGE_")
    .autoCreateSchema(true)
    .persistMessages(true)
    .extractMemories(true)
    .embedder(new DatabaseEmbedder(dataSource, "allminilm"))
    .llm(new OllamaLlm(
        "http://localhost:11434",
        "llama3.2:latest",
        0.0d))
    .build();

The demo calls createThread(), addMessages(), addMemory(), search(), and getContextCard(). Exact user, agent, and thread values make the private recall boundary visible.

Agent Framework Integrations

Oracle Agent Memory sits around the agent loop: recall scoped context before execution, then retain selected messages, memories, and outcomes afterward. Integration options include LangGraph, the Claude Agent SDK, the OpenAI Agents SDK, LangChain4j, Spring AI, Oracle WayFlow, Semantic Kernel, MCP clients or servers, and custom harnesses. Each integration uses framework lifecycle hooks, tools, services, or direct library calls; the framework orchestrates the agent while Oracle Agent Memory provides durable, scoped memory.

Database Tables and Objects Used by Oracle Agent Memory and Agent

There are three intentionally separate object groups. Oracle Agent Memory uses the message and durable-record tables. The agent lifecycle lane uses AIM_DEMO_* tables for history, expiry, traces, approval, and audit. The Memory Quest lane uses AIM_PARK_* tables for graph, spatial, vector, and transactional game state. The scenario table above links directly to the memory tables below.

ACTIVE, SUPERSEDED, and EXPIRED are application-defined values in AIM_DEMO_MEMORIES.STATUS. Oracle Agent Memory managed tables use their own lifecycle model for messages and typed records.

OAMJ_CONCIERGE_MESSAGE: Persistent Conversation History

The library creates OAMJ_CONCIERGE_MESSAGE_SCOPE_IX over user, agent, thread, sequence, and creation time for scoped, ordered retrieval.

OAMJ_CONCIERGE_RECORDS: Durable Memories and Embeddings

The library creates OAMJ_CONCIERGE_RECORDS_SCOPE_IX over user, agent, thread, record type, and creation time. The demo generates each embedding with the database-resident ALLMINILM model.

How RECORD_TYPE Maps to Memory Types

Oracle Agent Memory and the conceptual memory model use related but different taxonomies. The four durable values written to OAMJ_CONCIERGE_RECORDS.RECORD_TYPE are preference, fact, guideline, and memory. They describe what the extractor persisted. Working, episodic, semantic, and procedural describe how the application uses and governs remembered information.

The extractor prefers preference, fact, or guideline over generic memory. The demo searches all four durable types together; message appears only when the API presents recent conversation and durable records together.

Working memory is not a durable RECORD_TYPE. The approved shared procedure in AIM_DEMO_SKILLS is application-governed procedural memory, not a library-extracted guideline. The application-specific OPERATIONAL value in AIM_DEMO_MEMORIES.MEMORY_TYPE is not an Oracle Agent Memory record type.

The remaining application-owned database objects are:

The application also creates sequences for lifecycle, path, quest-progress, badge, and reward identifiers. The ALLMINILM ONNX model is loaded once into the database, but it is a database model rather than an application table. The library does not create separate user, agent, or thread tables; those identities are stored as scope columns on messages and records.

Memory Quest: Graph, Spatial, Gamification, and GraphRAG

The extension deliberately assigns one job to each database capability:

This is not a 3D simulation. The app renders a responsive 2D SVG map from the same X_M and Y_M coordinates stored with each spatial place. A 3D or game-engine client could consume the APIs later, but it is unnecessary for demonstrating the data and agent patterns.

The party graph models consented guest relationships without weakening memory isolation. GraphRAG begins with semantically relevant park knowledge, then follows place and quest relationships to add grounded context. The same graph technology serves distinct policy and retrieval purposes.

Why Oracle AI Database Fits the Memory Substrate

• Atomic correction: the app inserts a new fact version and supersedes the old one in the same transaction.
• Structured scope before similarity: guest, agent, status, and expiration predicates are applied before context is built. At larger scale, Oracle AI Vector Search can add semantic or hybrid ranking alongside relational filters.
• Relational plus JSON: enforceable lifecycle columns coexist with JSON metadata and skill instructions.
• Converged graph, spatial, and vector operations: relationship traversal, physical distance, and semantic retrieval stay near the transactional source of truth instead of requiring three independently synchronized stores.
• Operational governance: Oracle Deep Data Security applies row, column, and cell-level data grants using the active end-user identity, while Unified Auditing and fine-grained auditing can retain access evidence.

Make the Shared-Learning Boundary Enforceable with Deep Data Security

The sentence “three successful de-identified traces produced a generalized guideline” is possible only if those traces have already been minimized and generalized. In this demo they are synthetic, contain no user identifier, carry an explicit de-identification result, pass a small direct-identifier check, and must reach a three-trace threshold. The generated guideline remains pending until Ava approves it.

An application-supplied privacy_safe=true value cannot establish anonymity. Rare combinations can reidentify a person, vector embeddings preserve meaning, and malicious or low-quality traces can poison a learned procedure. De-identified means identifiers were reduced under a defined process; it does not mean the record is anonymous or safe for every reuse.

The app now demonstrates the database boundary on the real FINANCIAL.MAGIC_PY_MEMORY table:

• Ava, trip organizer: MEMORY_TRIP_ORGANIZER can read Ava's own rows plus shared traces and guidelines, and can update approval metadata on eligible rows.
• Leo, trip participant: MEMORY_TRIP_PARTICIPANT can read Leo's own rows and approved shared guidelines. It cannot read Ava's private rows, raw traces, pending guidelines, or the excluded metadata column.
• Negative proof: the app executes a direct query for USER_ID='AVA' as Leo. Oracle AI Database returns zero rows because the data-grant predicate is evaluated in the database.

CREATE OR REPLACE DATA GRANT FINANCIAL.MEMORY_PARTICIPANT_ACCESS
  AS SELECT (RECORD_ID, USER_ID, AGENT_ID, MEMORY_TYPE,
             CONTENT, EXPIRES_AT, CREATED_AT)
  ON FINANCIAL.MAGIC_PY_MEMORY
  WHERE UPPER(USER_ID) = UPPER(ORA_END_USER_CONTEXT.username)
     OR (USER_ID IS NULL
         AND MEMORY_TYPE = 'guideline'
         AND JSON_VALUE(METADATA, '$.status') = 'approved')
  TO memory_trip_participant;

A browser filter or application WHERE clause can be omitted by a bug or an AI-generated query. Deep Data Security replaces the pooled session's broad domain with the end user's identity and data roles, so every SQL operation on the protected object is evaluated against the data grants.

The local comparison service binds to 127.0.0.1 and runs both demonstration identities on one screen. A production endpoint must authenticate one caller, attach only that caller's end-user security context, and never expose an impersonation or cross-identity comparison API. Cross-origin access is disabled by default; configure one explicit AR_ALLOWED_ORIGIN only when the AR client requires it.

Set Up and Run the Demo

The demo uses an Oracle Database user and can reuse the repository's financial database wallet. The verified run shown below connected as FINANCIAL. Keep credentials and the wallet outside source control.

1. Configure the Database Connection

If financial/setup/.env already works, the runner reuses it. Otherwise:

cd memory
cp .env.example .env
# Edit .env with DB_USERNAME, DB_PASSWORD, DB_SERVICE, and TNS_ADMIN.
# Do not commit the populated file or wallet.

2. Configure the Live Deep Data Security Proof

Start the app once so the memory table exists. Then run the one-time bootstrap as the financial database ADMIN user. It creates local end users AVA and LEO, maps their two data roles, and creates row, column, and update grants on MAGIC_PY_MEMORY:

cd memory/deep-data-security
export DDS_ADMIN_PASSWORD='<financial database ADMIN password>'
./run.sh

The local demo defaults both end-user passwords to the existing DB_PASSWORD. For separate demo credentials, configure DDS_AVA_PASSWORD and DDS_LEO_PASSWORD before both bootstrap and app startup. Production should use individually managed identities or IAM tokens. See memory/deep-data-security/README.md and the equivalent setup_local_dds.sql.

3. Optional: Prepare Ollama and the Database Embedding Model

Skip this step for the primary browser walkthrough, which uses the public memory package and requires no external model key. Use it only when demonstrating the separate extraction-focused reference lane. That lane uses Ollama for typed-memory extraction and the database-resident ALLMINILM ONNX model for 384-dimensional embeddings:

brew install ollama
brew services start ollama
ollama pull llama3.2

Load ALLMINILM once for the connected database user, then verify the full library examples if desired:

cd memory/test-utils
./load-allminilm.sh
./run-local.sh

The ojdbc-agent-memory dependency used here is a proof-of-concept snapshot rather than a public package artifact. The runner expects a local library clone and accepts its location through OAM_LIBRARY_DIR.

4. Run the Complete Browser App

The top-level runner starts the complete memory, graph, Spatial, vector, transaction, gamification, and AR demonstration. It creates only missing objects and never drops the schema. From the repository root, open one terminal and run:

cd memory
./test.sh
./run.sh

Wait for the listening message, then open http://127.0.0.1:8092. Keep the first terminal running. In a second terminal, optionally execute the automated end-to-end proof:

cd memory
./smoke-test.sh

In the browser, use the numbered controls in this order: memory steps 0 through 7, Memory Quest steps 1 through 4, and AR steps 1 through 4. After Retain, Dream, Approve, and Next Guest, click Run identity comparison in the Deep Data Security panel. Ava should see her authorized review material; Leo should show zero Ava-private rows and only the approved shared guideline.

To inspect the lifecycle path's versions, recall audit, traces, and approval record from SQLcl, run memory/database/inspect_demo.sql after the browser walkthrough. The app now also shows all table contents at the bottom of the page and highlights changes after every action or manual refresh. Query the two library-managed tables only for presentation and troubleshooting; application code should use the library APIs instead of depending on their internal schema.

Open the Optional Spectacles experience section and follow its four numbered steps. First choose consent and retention, then start a private session. Second, retain the confirmed Lantern Garden observation. Third, enable recording consent in a new session and index the supplied media description. Fourth, search for the accessible constellation artwork. The result card explains each outcome without exposing credentials or raw protocol data. Refresh the database inspector to see the managed memory row plus AIM_AR_SESSIONS, AIM_AR_MEDIA, and AIM_AR_AUDIT.

5. Optional: Import the Lens Studio 5.15.4 Source Kit

Open memory/spectacles-lens and follow its project setup. Mark the project Made for Spectacles, import the TypeScript controllers, add the Internet and ASR modules, bind the overlay text components, and replace the placeholder API address with an approved public HTTPS tunnel to port 8092. Restrict AR_ALLOWED_ORIGIN and replace the demonstration token with production authentication before sharing the Lens.

The repository provides a source kit rather than a hardware-tested Lens Studio project. The Internet API can work in Preview when the device override is Spectacles; ASR and camera frames require Spectacles hardware.

Live Memory Library Walkthrough

Use this three-action lane first when presenting the app. It connects the memory concepts directly to the library calls and the visible database result.

1. Reset library lane: clears only the isolated OAMJ_CONCIERGE_* records. Point out that browser refreshes do not recreate memory because Oracle AI Database is the state source.
2. Retain Ava's conversation: addMessages() persists the user and assistant messages. Ollama extracts durable memory, preference, and guideline records. Oracle Agent Memory asks Oracle AI Database to create an embedding for each record with VECTOR_EMBEDDING.
3. Recall and build context: search() embeds the request in the database, applies Ava's exact identity scope, and ranks records by vector distance. The generated context card combines durable records with recent messages. A separate exact Leo search returns zero Ava records.

Memory is not merely saved chat. The write path extracts typed, durable state. The read path applies authorization scope before semantic ranking, then returns compact context for the next model turn. Continual learning begins when governed experience changes future context.

Demo Walkthrough

After the live library lane, use the UI's numbered buttons in order to explain the broader governed lifecycle. Each screen displays a short cue; the following script provides the narration, action, implementation detail, and visible proof.

Memory Quest Walkthrough

Use this separate lane after the governed-memory walkthrough. It turns remembered needs into a safe, playful experience without changing the original two memory paths. The fictional quest takes inspiration from the Play Disney Parks app, where location-aware activities, achievements, and themed interactions enrich a physical visit. The goal here is not to copy a specific game. It is to show how an agent can personalize a quest while Oracle AI Database keeps relationships, geometry, knowledge, and rewards consistent.

Semantic memory supplies Ava's durable accessibility and quiet-morning needs; episodic memory can retain whether a route or quest worked; procedural memory can hold an approved recovery workflow; operational memory carries temporary path status. The quest does not reward private facts or expose them to another guest.

Continual Learning: Token Space Before Weight Space

The Monday–Tuesday–Wednesday progression is simple: on Monday an agent explores and makes a recoverable mistake; on Tuesday a stateless agent repeats it; by Wednesday an agent with governed memory recalls the trap or approved procedure and avoids it. The fastest safe improvement is often external:

• store a corrected fact;
• retrieve a better example or context card;
• induce a structured skill from successful episodes;
• approve the skill and use it on the next run.

Fine-tuning, RLHF, or other weight-space changes can be valuable when the learned behavior must be compressed into the model or applied where retrieval is unavailable. They are slower to validate and harder to reverse, so they should follow evidence that external memory and skill retrieval are insufficient.

What an Experience Trace Must Preserve

A transcript alone does not say whether a choice worked. A useful trace connects four fields so later induction has evidence instead of anecdotes:

The Awake Loop and the Dream Loop

During the awake loop, the agent serves the current request and records a minimized trace after the outcome is known. A trace is not declared safe merely because a flag says so. In this demo, the dream operation starts synchronously; in production, a separate asynchronous process could group successful traces, propose a generalized guideline, evaluate whether private details survived the abstraction, and submit it for human review. Approval activates the procedure; rejection or later rollback keeps the learning reversible.

Taking the Pattern to Production

1. Replace the fixed demonstration extraction rules with schema-constrained model extraction and validation.
2. Use Oracle AI Agent Memory for managed threads, messages, memories, context cards, metadata filters, hybrid retrieval, updates, and TTL where its API fits the application.
3. Add embeddings and Oracle AI Vector Search when exact and relational retrieval no longer provide sufficient semantic recall.
4. Propagate the authenticated end user to Oracle Deep Data Security, test every data role with positive and negative queries, and audit reads as well as writes.
5. Run skill induction asynchronously, discover and remove sensitive details before generalization, require minimum evidence and human approval, and retain provenance plus rollback history.
6. Define deletion semantics carefully. Deleting a thread may need to remove or re-derive memories and summaries created from it.
7. Keep gamification abuse-resistant: authorize checkpoint evidence, make reward writes idempotent, cap point issuance, and monitor anomalous completion patterns.
8. For AR, separate camera sensing from recording consent, minimize retained media, enforce identity and expiration before vector ranking, keep visible capture indicators, and retain a non-AR accessibility fallback.

Background extraction is generally eventually visible rather than immediately available. Applications that require read-your-write consistency should use an inline path or explicitly wait for the extraction job before relying on the new memory.

The Database Is the Memory System of Record

The model supplies reasoning; memory engineering supplies continuity. When identities, facts, episodes, traces, and procedures live in a governed database layer, an agent can improve without turning every prior interaction into an unbounded prompt or every private experience into a shared lesson.

The practical sequence is straightforward: retain deliberately, recall within scope, reuse compactly, refine continuously, and approve what becomes shared procedural memory. Graph, Spatial, vectors, and transactions can then turn that governed context into experiences that are connected, physically feasible, grounded, and auditable. That is how experience compounds without giving up correction, lifecycle, or trust.

Frequently Asked Questions

Is AI agent memory just a vector database?

No. Vectors help semantic recall, but production memory also needs identity and tenant scope, record types, versioning, correction, TTL, deletion, transactions, and audit. This demo begins with relational predicates and JSON; Oracle AI Vector Search is an optional ranking layer.

Does continual learning mean this demo retrains a model?

No. It learns in token space by updating external state and proposing a reusable structured skill. That skill is not a context card: the context card is turn-specific recalled evidence, while the skill is generalized procedural memory held for human approval. Model-weight training is a separate, later decision.

How does the demo prevent Ava's memory from leaking to Leo?

Private memories carry guest and agent scope, and recall filters that scope before building context. Oracle Deep Data Security independently enforces MEMORY_TRIP_ORGANIZER and MEMORY_TRIP_PARTICIPANT data grants on the memory table. Leo can read only his records and approved shared guidelines; a direct query for Ava's rows returns zero in the database.

Does Deep Data Security make the shared traces anonymous?

No. DDS controls who can read rows, columns, and cells and who may update approval metadata. It does not perform free-text de-identification or guarantee anonymity. This demo uses synthetic generalized traces, direct-identifier checks, a three-record threshold, and human review. Production also needs sensitive-data discovery, consent, retention, provenance, poisoning defenses, and reidentification analysis.

What is the difference between the party graph and GraphRAG?

The party graph answers an authorization-sensitive relationship question: which guests have consented to share this experience? GraphRAG answers a retrieval question: which places and quests connect to semantically relevant park knowledge? Oracle Spatial separately evaluates physical geometry and proximity. The responsive 2D map exposes all three forms of evidence without requiring a 3D client.

Does the AR demonstration require Snap Spectacles?

No. The browser simulator validates consent, API, Oracle Agent Memory, TTL, vector-search, and audit behavior. Lens Studio Preview can model the overlay and HTTPS contract. Spectacles hardware is required to validate ASR, camera frames, permissions, tracking, outdoor visibility, comfort, battery, and heat.

References and Further Reading

• Memories Are the Magic source, app, SQL, and configuration
• Top AI Agent Memory Platforms in 2026: technical comparison
• Oracle AI Agent Memory product overview
• Get started with Oracle AI Agent Memory
• Oracle AI Agent Memory 26.6: What's New
• Oracle AI Agent Memory API: extraction, updates, TTL, and deletion
• Keyword, vector, and hybrid search with Oracle AI Agent Memory
• Time-to-live for Oracle AI Agent Memory records
• Customize Oracle AI Agent Memory context cards
• Oracle AI Agent Memory security considerations
• Oracle Deep Data Security: end-user security context
• Oracle Deep Data Security: create data grants
• python-oracledb: Deep Data Security
• Oracle Data Safe Data Discovery
• Oracle AI Vector Search User's Guide
• SQL Property Graphs in Oracle AI Database
• Oracle Spatial relationships and filtering
• Snap Spectacles ASR Module
• Snap Spectacles Internet access
• Snap Spectacles transparent permission system
• Play Disney Parks app overview
• Star Wars: Batuu Bounty Hunters location-linked experience