Comprehensive Guide: Creating and Using AI Agents in Oracle Integration Cloud (OIC)

# Comprehensive Guide: Creating and Using AI Agents in Oracle Integration Cloud (OIC)

Introduction

In the evolving landscape of enterprise automation, digital transformation has shifted from merely automating repetitive tasks to building systems that can think, adapt, and learn. Oracle Integration Cloud (OIC) has embraced this shift by introducing Agentic AI capabilities natively into its platform.

AI agents in OIC are autonomous, intelligent digital entities that can observe their environment, make decisions, and act without constant human intervention. Unlike traditional integrations that operate as static, rule-based flows, AI agents introduce flexibility, learning, and context-awareness. They act as real-time decision points that sit between systems, interpret context, and decide the next best action to achieve a specific goal.

This document provides a comprehensive, step-by-step guide on how to create, configure, and use an AI Agent within Oracle Integration Cloud.

Understanding Agentic AI in OIC

Before diving into the creation process, it is essential to understand the core components of Agentic AI in OIC. In OIC version 26.01 and later, a dedicated AI tab is available within OIC projects, allowing users to build and manage agentic artifacts.

### Core Components

| Artifact | Description | Enterprise Role |

|----------|-------------|-----------------|

| Integrations (Actions) | Tools that an agent can call. They define what can be done. | The enterprise "action layer" that exposes existing business logic securely. |

| Agents | Entities where objectives, goals, and behavioral guidelines are defined in natural language. | The orchestrator that uses an LLM brain to achieve goals using available tools. |

| Agent Patterns | Dictate how an agent should reason and act (e.g., the ReAct pattern). | Ensure predictable, repeatable outcomes by shaping the sequence of thoughts and actions. |

| Prompt Templates | Standardize how an agent is invoked with runtime parameters. | Operationalize execution for production use cases where inputs vary but behavior must remain consistent. |

Prerequisites

Before building an AI agent, ensure you have the following prerequisites in place:

1. Access to Oracle Integration Cloud 3: You must have an active OIC instance.

2. LLM Connection Information: You need the connection details for the Large Language Model (LLM) that will power your agent's reasoning:

- Base URL for the LLM (e.g., https://api.openai.com)

- Model name (e.g., gpt-4o-mini)

- API Key for authentication

Step-by-Step Guide to Creating an AI Agent

The process of building an AI agent in OIC involves several distinct phases, from planning to execution.

### Step 1: Plan Your AI Agent

The first step is to clearly define the purpose of your AI agent and identify the tools it will need to accomplish its goals. For example, if you are building an "Expense Approval Agent," its purpose is to evaluate expense claims and automatically approve those under a certain threshold while rejecting others. The tool it needs would be an integration that can process the approval in the backend system.

### Step 2: Create the Project

AI agents are created and managed within OIC Projects:

1. Navigate to the Projects section in the OIC navigation pane.

2. Create a new project or select an existing one where your agent will reside.

### Step 3: Create and Register an Agentic AI Tool

An AI agent relies on tools to interact with external systems. In OIC, these tools are standard integrations that have been optimized and registered for agentic use.

Requirements for the Integration:

- It must be part of a project and be Active.

- The first connection must be a REST trigger connection using the REST Adapter.

- The REST trigger must use OAuth authentication, accept a JSON payload, and use the POST verb.

Registration Process:

1. In your project, navigate to the Integrations section.

2. Ensure your target integration is Active.

3. Click the Actions menu for the integration and select "Create agentic AI tool".

4. Provide a descriptive Name and Identifier. The identifier is sent to the LLM as metadata, so it should clearly indicate the tool's purpose.

5. Provide a detailed Description. This is crucial as it helps the LLM decide when to use the tool.

6. (Optional) Add Guidelines to constrain the tool's behavior (e.g., "only use for expenses in USD").

7. Configure the Parameters. Select which input parameters should be visible to the LLM, mark required fields, and provide clear descriptions for each parameter to reduce hallucination risks.

8. Save the tool configuration.

Note: OIC automatically exposes these tools as Model Context Protocol (MCP) tools if the MCP server is enabled for the project, allowing them to be reused across different agent platforms.

### Step 4: Configure the Agentic AI Thinking Pattern

The thinking pattern defines how the AI agent will reason through problems. OIC supports patterns like ReAct (Reasoning and Action).

1. In your project, navigate to the AI Agents tab.

2. In the Agent patterns section, click Add.

3. Provide a Name and Identifier (e.g., REACTPATTERN_FOR_AGENTS).

4. Select the Pattern recipe (e.g., ReAct). The ReAct pattern instructs the agent to alternate between thinking (internal reasoning), acting (invoking tools), and observing (processing tool responses) until the goal is met.

5. Configure the Guidelines for the pattern. OIC provides default strict guidelines for the ReAct pattern to ensure the agent explains its rationale at each step and uses tools appropriately.

6. Under LLM Connections, configure your LLM by providing the Base URL, Model name, and API Key.

7. Test the connection and save. OIC will automatically generate necessary backend integrations (like ReAct Pattern Intg) to support this pattern.

8. Activate the thinking pattern from the Actions menu.

### Step 5: Add and Configure the AI Agent

With the tool and thinking pattern ready, you can now assemble the AI agent:

1. In the AI Agents section of your project, click Add in the Agents box.

2. Provide a Name and Description for the agent.

3. Select the Thinking pattern you activated in the previous step.

4. Configure the Role and Guidelines. These are sent to the LLM as the system prompt and are critical for defining behavior:

- Role: Define who the agent is (e.g., "You are an expense approval agent. Your role is to approve or reject expense claims.")

- Guidelines: Provide step-by-step instructions (e.g., "1. If the expense is <= $50, approve it. 2. If > $50, reject it.")

5. In the Tools section, click the + icon and add the agentic AI tool you registered earlier.

6. Save the configuration and then Activate the AI agent from the Actions menu.

### Step 6: Run, Test, and Monitor the AI Agent

Once activated, you can interact with your agent using natural language prompts:

1. In the AI Agents section, find your active agent, click Actions, and select Run.

2. The Test Agent page will appear. Enter a natural language prompt (e.g., "I bought a desk chair for $45 and would like to claim it as an expense.") and click "Send prompt to agent".

3. Observe the agent's execution process:

- System: Shows the system prompt (role, guidelines) sent to the LLM.

- User: Shows your input prompt.

- Assistant: Displays the agent's internal reasoning (Thought process).

- Tool: Shows the invocation of the tool and the response received.

4. The agent will conclude its reasoning based on the tool's output and provide a final response.

Monitoring: To monitor the underlying technical execution or troubleshoot errors, navigate back to the AI Agents page and select Observe. Here, you can view the execution instances of the integrations (including the tool and the system-generated pattern integrations) to ensure they completed successfully or to inspect error details.

Conclusion

Oracle Integration Cloud's Agentic AI capabilities represent a significant leap forward in enterprise automation. By combining the reasoning power of Large Language Models with the robust, secure execution capabilities of OIC integrations (acting as tools), organizations can build intelligent systems that handle complex, context-dependent processes autonomously.

Following the steps outlined in this guide ensures a structured approach to defining, building, and deploying these powerful AI agents. Whether you're building expense approval systems, customer service agents, or supply chain automation, OIC's agentic AI framework provides the foundation for intelligent, autonomous enterprise systems.