Imagine a procurement employee discussing a supplier purchase order with an AI Agent. Later, the employee asks, “What delivery condition did I mention earlier?” A new execution must connect that question with the earlier discussion.
Oracle Integration 3, commonly called OIC Gen3, supports conversation continuity across agent runs. This article examines that capability, the generated ReAct integration, and asynchronous callbacks. It also explains which internal memory claims need tenant evidence.
Evidence boundary
Official pages were inspected on 10 November 2026. No tenant execution, generated integration export, or runtime trace was supplied. All prompts and expected results below are an experiment to perform, not recorded execution results. The retained introductory image could not be retrieved through the browser tool; its availability and technical content remain unverified.
1. What You Will Build
You will run a controlled procurement conversation with supplier Bharatpur Materials and purchase order PO-4821, then compare a follow-up with an independent conversation. Purchase orders describe requested purchases; this fictional example does not retrieve or change an actual order.
Practical outcome
Distinguish conversation identity, execution identity, current agent configuration, observable activity, and unverified internal state. The three-run exercise provides evidence of user-visible recall in those runs; it cannot prove every retention, isolation, or durability property.
2. In This Post
- Prerequisites and runtime boundaries
- Conversation identity and identifiers
- Generated ReAct integration and internal activities
- History and working context
- Completion, asynchronous suspension, and callbacks
- History-retrieval failures
- History versus the current tool catalog
- Hands-on conversation-continuity experiment
- Concurrency, retention, and production considerations
- Monitoring and troubleshooting
- Completion checklist
- Five useful FAQs
- Official references
- Finally — Summary
3. Before You Begin — Prerequisites and Runtime Boundaries
3.1 What you need
| Prerequisite | What to verify |
|---|---|
| Edition | Agentic AI is licensed in Enterprise and Healthcare editions. Standard edition can display features that its license does not entitle you to use. |
| Existing project and agent | Use a non-production project with an active agent whose role permits the synthetic procurement questions. Record project and agent identifiers and versions. |
| Thinking pattern and model connection | Use an active ReAct pattern and a successfully tested LLM connection. LLM means large language model: the model that processes instructions and generates responses. |
| Permissions and safe tools | Confirm access to the agent and relevant monitoring data. Use test resources without payment or other consequential write permissions. |
| Baseline | Record the deployed tenant release and pattern recipe. A documentation date does not establish the release running in your tenant. |
References: Oracle Integration Editions, Configure the Agentic AI Thinking Pattern, and Add and Configure the AI Agent. This exercise assumes those resources already exist; it is not a replacement for the complete provisioning and agent-creation tutorials.
The documented continuity procedure does not ask you to provision a database or OCI Cache cluster. A separately designed asynchronous callback can require its own correlation store, as explained in section 7.
3.2 Separate the capabilities
| Concept | Meaning |
|---|---|
| Conversation history | Earlier interactions associated with a continuing discussion. |
| Role and Guidelines | Configured instructions describing the agent’s purpose and intended behavior; instructions alone are not transaction enforcement. |
| Thinking pattern | The orchestration approach used to organize model processing and tool use. ReAct means reasoning and acting. |
| Tools | Configured capabilities, such as an integration that reads order status. |
| Knowledge base and RAG | Retrieval-Augmented Generation: retrieving relevant enterprise content to help ground an answer. This differs from recalling a prior conversation. |
| OCI Cache Adapter | A separate adapter for accessing OCI Cache clusters; its existence does not identify the backing store for agent conversations. |
| Internal activity | An implementation element whose meaning must be established from its actual definition and mappings. |
For the separate retrieval and cache capabilities, see Build a Knowledge Base and OCI Cache Adapter Capabilities. A knowledge base has its own prerequisites, including OpenSearch configuration; it is not required for this recall experiment.
4. Conversation Identity — The Address of a Conversation
A conversation ID associates requests with one discussion. OIC generates an ID when none is supplied; a caller can supply an ID to continue earlier runs. The documented history behavior is described in Run an AI Agent with Knowledge of Previous Runs.
Kid-friendly analogy
Imagine a teacher giving a student a notebook number. The student can return the next day and continue writing in the same notebook. A different notebook number identifies another discussion.
In this OIC AI Agent integration, this means: The conversation ID associates separate agent requests with the same conversational history. The integration instance ID identifies an execution, not the continuing discussion.
| Request | Integration instance | Conversation |
|---|---|---|
| Initial request | Instance-A | Conversation-X |
| Follow-up | Instance-B | Conversation-X |
| Independent request | Instance-C | Conversation-Y |
For this exercise, use the explicitly identified conversation ID in Test Agent’s Activity section.
4.1 Identity does not establish authorization or storage layout
Treat conversation IDs as opaque values: retain them exactly, and do not invent a format or infer ownership from their characters. An application should bind a conversation to its authorized user or business session before forwarding the ID.
projectId|agentId|conversationId
5. The Generated ReAct Integration and Internal Memory Activities
5.1 What Oracle documents
ReAct alternates model processing with actions and observations, choosing subsequent steps using available results. It does not promise an identical path on every run. Oracle’s pattern tutorial documents a generated integration named ReAct Pattern Intg, required by the agent and automatically activated when the connection is saved. See Configure the Agentic AI Thinking Pattern.
Kid-friendly analogy
Think of a school play. The teacher provides the script, and the stage manager coordinates when actors enter, speak, and leave. The stage manager coordinates the performance, although the actors can still respond differently.
In this OIC AI Agent integration, this means: ReAct Pattern Intg provides the generated execution flow implementing the reasoning-and-action pattern. Its activities and mappings help explain how that pattern is executed.
That tutorial now distinguishes ReAct from ReAct for OCI GenAI. Record the recipe actually selected; do not assume identical provider configuration or generated internals across recipes. This article follows the documented ReAct tutorial and does not prescribe OCI Generative AI connection fields.
5.2 Locate the generated integrations without editing them
- Open Projects and select the relevant project.
- In the project’s Design view, select Integrations and locate the generated pattern integration. Record its displayed version and status.
- For runtime evidence, return from Test Agent to the project, select Observe, and inspect Integrations.
Oracle’s monitoring tutorial lists ReAct Pattern Intg and Get Tool Data Intg;
See Run and Test the AI Agent. Do not edit the system-generated pattern integration for this investigation.
6. How Retrieved History Becomes Working Context
6.1 Earlier facts and a new question
Initial message:
Supplier: Bharatpur Materials
PO: PO-4821
Expected delivery: 14 November 2026
Condition: Do not recommend payment release until
receipt inspection is confirmed.
Later question:
What condition did I give for recommending payment release?
Kid-friendly analogy
Imagine your friend gives you the first three clues of a puzzle. Later, your friend asks you to solve the fourth clue. You need the earlier clues to understand the new question.
In this OIC AI Agent integration, this means: Previous conversational interactions provide context that can be used when the agent processes another request with the same conversation ID.
The condition is an example of user-provided context, not proof of the company’s payment policy or current inspection status. An operational integration must check those facts in authoritative systems.
6.2 Conceptual context flow
Conceptual sequence
- Receive the current prompt and any supplied conversation identifier.
- Associate the request with the conversation.
- Prepare model input using applicable instructions and available context.
- Process the request, using tools when needed.
- Produce an answer, or wait for an asynchronous result before continuing.
This explains the concept; it is not a trace of internal persistence operations. A waiting operation must be handled before another ordinary request is started for the same conversation.
6.3 Context is not the same as everything ever stored
Working context means the input available to a model for a particular processing step. A context window is the model’s finite token budget; tokens are units used to represent text and other supported inputs. Retained history, visible activity, and the model’s actual input are related but different.
Selection, truncation, and summarization are general context-management techniques. The inspected pages do not establish which such techniques a given generated pattern uses. Do not claim they occur, or that every earlier message is replayed verbatim, without corresponding evidence.
Test Agent exposes System, User, Tool, and Assistant activities. The System category includes role, agent guidelines, and pattern guidelines. An exposed rationale is not proof that every private model reasoning step is recorded.
7. Conversation Continuity, Completion, and Asynchronous Suspension
7.1 Completion and persistence
Here, persistence means retaining conversation information so a later request can use earlier interactions. It does not mean training the model, permanent user-profile learning, or indefinite retention.
Kid-friendly analogy
Imagine writing the results of a school project in a notebook. When the group returns the next day, they can refer to what was previously recorded instead of repeating the entire project.
In this OIC AI Agent integration, this means: A subsequent run can continue a previous conversation by using the same conversation ID.
A completed answer can be followed by a later request. The exact save point, transaction boundary, serialized state, and behavior after a failed write need implementation evidence. Do not invent a cache-write sequence from an activity name.
7.2 Asynchronous tools and waiting
An asynchronous operation completes later. Oracle documents that an agent invoking an asynchronous agentic AI tool pauses its reasoning in Waiting for tool to process and resumes after the callback response. The callback procedure below applies to tools that do not call Human in the Loop; that workflow capability implements its callback automatically. See Send a Response to an AI Agent with a Callback.
Kid-friendly analogy
Imagine a student asking a friend to collect information from the library. The student pauses the project while waiting. When the friend returns, the student receives the information and continues.
In this OIC AI Agent integration, this means: An asynchronous tool can suspend the ReAct execution. The agent resumes after receiving its callback response.
7.3 Correlate the completed work with the waiting agent
A callback is a later response tied to the earlier request. Preserve the conversation ID from the runtime x-agentic-callback-uri header and the asynchronous tool integration’s runtime Instance ID from Integration Metadata in the mapper. Persist their association before external processing loses that context. Do not substitute the callback integration’s own instance ID.
| Callback mapper field | Value |
|---|---|
| Project Id / Agent Id | Optional overrides of the configured target. |
| Conversation Id | Required conversation identifier. |
| Tool Flow Id | Required runtime instance ID of the asynchronous tool integration. |
| Tool Invoke Event Id | Required; use the same value as Tool Flow Id, as documented. |
| Payload | Required result; Oracle permits a custom stringified JSON payload. |
7.4 Configure and observe the callback
- In the callback integration canvas, click the add icon, type AI, and select AI Agent.
- In Configure Basic Info, give the endpoint a meaningful name and choose Callback AI agent for Action. Continue, select the project and active agent in Configuration, then continue to Summary and finish.
- Map the fields above in the generated map, validate, save, and activate the integration.
- After the external work completes, invoke your callback integration using its own configured contract. Verify the waiting state before sending the callback.
- Check for resumed activity, the tool result, final answer, and terminal agent status.
The worked example Use Case: Send a Callback to an AI Agent for an Asynchronous Tool shows the correlation values and resulting activity. The external job, completion event, callback integration trigger, authentication, correlation storage, retry policy, and duplicate handling must be designed for your system; this is not a complete deployable external callback solution.
8. What Happens When History Retrieval Fails?
8.1 Separate missing context from a proven technical failure
A new conversation has no earlier exchanges of its own. A follow-up that lacks a previous fact could instead reflect an incorrect identifier, expired data, incomplete model context, a model error, or an implementation problem. A disappointing answer alone does not diagnose a storage failure.
8.2 An empty-history fallback is a hypothesis to inspect
Illustrative pseudocode; not Oracle source:
try:
history = retrieve_previous_state()
except RetrievalError:
history = []
If an actual implementation replaces a retrieval error with an empty collection, later processing could lose earlier information while appearing to continue.
Kid-friendly analogy
Imagine a teacher asking for yesterday’s attendance register. The register is missing, so the teacher assumes nobody attended instead of reporting that the register could not be found.
In this OIC AI Agent integration, this means: If a genuine history-retrieval exception is converted into an empty history, the agent could continue without information from earlier interactions even though the original conversation ID has not changed.
- Check the exact supplied ID and the earlier run’s completion.
- Compare available activity before blaming the storage layer.
- If an accessible artifact exposes retrieval error handling, distinguish a legitimate absence from access denial, unavailable storage, or unprocessable state.
- Capture the actual error and branch taken; do not assign an undocumented OIC exception code.
Keep mandatory business checks outside conversational recall
Receipt inspection, payment approval, and transaction permissions must be checked through authoritative business logic. An earlier sentence in a conversation is not sufficient authorization to release funds.
9. Conversation History Is Not the Current Tool Catalog
A tool catalog is the set of capabilities associated with an agent. A prior tool result can explain an earlier answer; it does not grant the agent permanent access to that tool.
Kid-friendly analogy
Imagine a library’s current book catalogue and a notebook recording the books you borrowed yesterday. The notebook tells you what happened before. It does not determine which books the library offers today.
In this OIC AI Agent integration, this means: Conversation history describes previous interactions, while the currently configured tools determine the capabilities available for the next execution.
For example, GET_PURCHASE_ORDER_STATUS is an illustrative tool identifier in this article, Check the target agent’s configuration and the resources displayed for the run rather than inferring current capabilities from an old tool call.
9.1 What registration actually requires
For an integration registered as an agentic AI tool, Oracle documents an active integration in a project, with a REST Adapter trigger, OAuth authentication, and JSON payload. Tool identifiers, descriptions, optional guidelines, and parameter metadata help the model use the tool. Parameter visibility controls which parameters are sent to the LLM. See Register an Integration as an Agentic AI Tool.
These settings do not replace validation inside the integration. Validate identifiers, permitted actions, and source-system permissions before executing a business transaction. A tool description guides model behavior; it is not an access-control policy.
9.2 Earlier user instructions and configured instructions
“Do not recommend payment release until inspection is confirmed” may influence a follow-up when that earlier message is available. Keep that user statement separate from the agent’s configured Role and Guidelines, which Oracle documents as system-prompt inputs. See Add and Configure the AI Agent. Neither a remembered instruction nor an old tool result proves current business status.
10. Hands-On Prototype — Continue a Conversation Across Multiple Runs
10.1 Prepare a clean experiment
Use synthetic data, the same agent version, and a distinctive reference generated by you, such as CTX-9W4-K7Q-2816. Replace that published example with a fresh value for a stronger experiment. Keep it out of agent configuration, prompt templates, knowledge bases, and tools that could independently return it.
Test record
Record each prompt, time, conversation ID, displayed agent identifier, relevant integration instance IDs, status, response, and available tool activity. Label these observations separately from expected results. Do not perform payment actions.
10.2 Run 1 — Establish the baseline
- Open Projects, select the project, then select Design → AI Agents. In Agents, use the active agent’s Actions → Run.
- In Test Agent, choose New run, supply no existing conversation ID, enter the prompt below, and send it using the prompt control.
- Wait for completion. Copy the conversation ID from Activity and record it as X. Keep the actual value, not the placeholder letter.
This is synthetic test data.
Reference: CTX-9W4-K7Q-2816
Supplier: Bharatpur Materials
Purchase order: PO-4821
Expected delivery: 14 November 2026
Condition: Do not recommend payment release until
receipt inspection is confirmed.
Acknowledge these facts without invoking business actions.
The documented run controls are described in Run and Test the AI Agent. Check that the submitted message and response are visible. An acknowledgement alone is not proof of later recall.
10.3 Run 2 — Ask without repeating the facts
- After Run 1 finishes, click + in Test Agent, enter X in the conversation-ID dialog, and click Submit.
- Enter the follow-up below and click Run. Record the ID and new execution evidence.
What exact reference, supplier, purchase order,
delivery date, and payment-recommendation condition
did I provide earlier?
If a detail is unavailable, say so; do not guess.
Compare the answer with the baseline: exact reference, supplier, PO, date, and inspection condition. This is a proposed acceptance check, not guaranteed output. The explicit ID-reuse procedure is documented in Run an AI Agent with Knowledge of Previous Runs.
10.4 Run 3 — Independent control
Choose New run, provide no earlier ID, and submit the same follow-up without its answers. Record the generated ID as Y and verify Y differs from X. Examine available activity for contamination from another source.
A useful control response states that the facts are unavailable. A guess or hallucination remains possible. Even a successful control does not prove cross-user isolation or the complete absence of hidden state; repeat with fresh references if results are ambiguous.
| Run | Acceptance evidence |
|---|---|
| 1 | Recorded baseline, completed execution, and conversation X. |
| 2 | Same X, separate execution evidence, and accurate recall without re-supplying the answers. |
| 3 | Different Y, no baseline supplied, and no unexplained recovery of the fresh reference. |
10.5 Optional: demonstrate separate integration executions
The UI experiment shows agent runs. If your claim specifically concerns separate caller integration instances, add an AI Agent action in a test integration, select the active agent, and map Prompt plus the optional Conversation Id. Validate, save, and activate. Invoke once without an ID, obtain the resulting ID from agent monitoring, and invoke again with that ID. Record distinct caller integration instance IDs. See Invoke an AI Agent from an Integration.
Your wrapper’s REST path, HTTP method, security, and inbound field names are your own contract; no universal request body is assumed here. The prompt-template alternative uses Prompt Template Id and a stringified-JSON Payload; it is unnecessary for this experiment.
Execution status
No live tests were performed for this audit. Completing the proposed checks establishes only the observations you record; it does not independently reveal the cache schema or all model input.
11. Concurrency, Retention, and Production Considerations
11.1 Serialize ordinary requests for one conversation
Oracle documents an error when another request tries to start the same conversation while it is processing or in Waiting for tool to process. A callback is the documented way to return an asynchronous result; it is not another ordinary follow-up request.
Kid-friendly analogy
Imagine a classroom rule that lets only one student use a shared notebook at a time. A second student must wait until the first has finished, including any time spent waiting for a missing worksheet.
In this OIC AI Agent integration, this means: Avoid starting another request against a conversation that is already processing or waiting for its asynchronous tool.
Have the caller queue subsequent messages until the active work reaches an appropriate terminal status. This is an application design recommendation, not proof of atomic storage writes, exactly-once processing, or safe retries after an uncertain response.
11.2 Retention and its limits
Oracle ties AI Agent data retention to the service instance’s retention period. Its linked administration page explicitly describes production tracing data. Keep that documented relationship separate from any assumed internal cache expiration policy.
| Edition | Default retention | Configurable? |
|---|---|---|
| Standard | 32 days | No; Agentic AI is not licensed in this edition. |
| Enterprise | 32 days | Yes. |
| Healthcare | 184 days | No. |
The same administration page specifies 24 hours for debug tracing and 8 days for audit tracing. Decreasing a configurable retention setting deletes older data when saved. These figures do not establish when a particular stored message enters a model prompt. See Edit the Data Retention Period. TTL means time to live: an expiration duration.
11.3 Production evidence to collect
- Keep ownership checks and authorization at the caller and business-tool boundaries.
- Track release, agent version, pattern recipe, model, and relevant configuration when comparing results.
- Design tool idempotency so retrying a request does not accidentally repeat a business action.
- Investigate retention expiry and recovery using your actual environment; do not promise indefinite recall.
- Use explicit source-system validation for procurement conditions and approvals.
12. Monitoring, Testing, and Troubleshooting
12.1 Use both agent and integration evidence
In the project, select Observe → AI Agents to reach Agent instances. For the explicitly labeled ID, also inspect Test Agent’s Activity section. Separately use Observe → Integrations for generated and business integration executions. The monitoring tutorial documents drilling into the Errored count and selecting View Details on the resulting Instances page.
12.2 Retrieve activity from an integration
Add an AI Agent action using the canvas add control, type AI, and select the action. In Configure Basic Info, name the endpoint and choose Get AI agent activity stream. Continue to the summary, finish, map the conversation ID, and activate the integration. Inspect the returned activity and status rather than assuming the start request has finished. See Get the Activity Stream for an AI Agent. Do not invent response field paths absent the actual schema.
| Symptom | Targeted investigation |
|---|---|
| Follow-up omits a fact | Check the supplied ID, baseline completion, retention, context, and actual response. Do not infer a cache outage from the answer alone. |
| Independent control reveals the fresh reference | Check ID reuse and other sources of the fact; investigate before claiming a privacy boundary failed. |
| Second request errors | Check whether the conversation is still processing or waiting for a tool. |
| Callback does not resume work | Check waiting status, target agent, conversation, both tool-ID mappings, result payload, and callback integration errors. |
| Generated integration errors | Inspect its instance details and model connection; capture the actual error. |
13. Completion Checklist
- Record edition, tenant release, agent version, pattern recipe, and model connection.
- Capture all three proposed runs, their identifiers, prompts, responses, and statuses.
- If claiming separate caller executions, capture their distinct integration instance IDs.
- Distinguish documented generated integration labels from activities actually present in your artifact.
- Record actual mappings and error branches only when accessible; mark missing evidence.
- For callbacks, retain correlation values and observe the result after resumption.
- Check ownership, retention, concurrency, and business validations separately.
Internal storage engine, key schema, serialized history, atomicity, and durability guarantees remain outside what this article can prove. Do not mark an unavailable artifact inspection as completed.
14. Five Useful FAQs
Does each request need a different conversation ID?
No. Use a continuing conversation’s ID for a follow-up; omit it when a new conversation is intended. Verify the ID actually used.
Is a conversation ID an integration instance ID?
They serve different purposes. Keep the conversation identifier separate from each integration execution identifier, and interpret monitoring columns in their own page context.
Does an old tool call keep that tool available?
No such guarantee is established. Check the target agent’s associated tools and the configuration used for the current run.
Does one successful recall test prove durable memory?
No. It provides evidence for that test. Retention, context selection, authorization, concurrency, and failure recovery require separate evaluation.
15. Additional References
These live pages are the verification baseline, not evidence of a tenant deployment or executed test.
- Using Agentic AI in Oracle Integration 3
- Oracle Integration Editions
- Configure the Agentic AI Thinking Pattern
- Add and Configure the AI Agent
- Run and Test the AI Agent
- Run an AI Agent with Knowledge of Previous Runs
- Invoke an AI Agent from an Integration
- Get the Activity Stream for an AI Agent
- Register an Integration as an Agentic AI Tool
- Send a Response to an AI Agent with a Callback
- Use Case: Send a Callback to an AI Agent for an Asynchronous Tool
- AI Actions Category
- Build a Knowledge Base
- OCI Cache Adapter Capabilities
- Edit the Data Retention Period
- Agentic AI Issues
- September 2026 (26.10)
- Agentic AI in OIC — Overview and Introduction
- ReAct vs Plan & Execute: Choosing the Right Agent Thinking Pattern in Oracle Integration
16. Finally — Summary
Conversation continuity connects a later question with an earlier discussion. Keep conversation identity separate from execution identity, and evaluate the actual evidence returned by your test runs.
- Conversation history and current agent configuration answer different questions.
- An asynchronous callback must correlate its result with the waiting tool invocation.
- Retention, ownership, concurrency, and transaction enforcement need independent attention.
- A controlled recall test demonstrates observed behavior; it does not prove permanent memory or complete isolation.
Use the three-run comparison to investigate continuity, and record limitations honestly. Reliable procurement automation also checks current business facts in authoritative systems before taking consequential action.
Comments
Post a Comment