#1134 OIC Agentic Flows - Design Time and runtime structure

Introduction

Some customers have been asking me about this, which Agentic artefacts do we have and how do they behave at runtime. So let's go!

Agentic AI and OIC Projects

Agents live in projects, agents use tools to do the work, agents may also get human input via Human-in-the-Loop. 

Currently, our tools are integrations - 

One click exposure, it's that simple.

Agents have the following features available - 

Tools, we've already covered. 
Agents can also use Prompt templates, which make it easier for you to enter prompts. Here's an example of one - 

Note the use of {} - these are the variables entered at runtime e.g. 

You can associate 1+ prompt templates with an agent.

An Agent Pattern is the pre-requisite for creating an agent.

As the name suggests, this implements a pattern - currently, with the 26.01 release of OIC, you can select the following pattern - 

ReAct = Reason & Act.

You can add some guidelines - e.g.

You also need to complete an LLM collection. 

GenAI should be available as your LLM connection target soon, but, as you can see, I'm using OpenAI.

So I've created my pattern, so how does this manifest itself in my project? 

Via an integration - 

This is the component that handles the agent interactions with the LLM.

You can treat this as a blackbox, but, naturally, you can also take a peek - 

but don't get hung up on this; it's just an implementation detail.

Exposing Integrations as Tools

Now back to the Tools - Your app driven integrations can be exposed as tools, and easily consumed by your OIC agent. However, these tools can also be exposed via MCP to 3rd party agents. This is done at project level - 

As a sanity test, you can connect via Postman - 

Try out a tool - 

Validate the response - 

That's our tools exposed and tested. You can now give the MCP server url to your stakeholders, allowing them to invoke OIC tools from their agents.

Running Agents in OIC

Now to our agent - I will run the get future runs prompt - 

Don't worry about the result - 0 future runs found. This is because the schedule is paused - 

I'm interested in what has actually executed; let's check out Project Observability - 

The integration, Get Future Runs,  has been invoked. Note also, the ReAct Pattern integration has executed, as well as the agent.

All have individual instance ids. Let's check out the activity stream for the agent - 

Here I use the OIC Factory api -

https://design.integration.us-phoenix-1.ocp.oraclecloud.com/ic/api/integration/v1/monitoring/instances/yourInstanceId/activityStreamDetails?type=agent&timezone=Europe%2FBerlin&integrationInstance=yourOICInstance

Here are excerpts from the Postman response - 

Notice the array of content within items -

Finally, we see - status = COMPLETED.

This tells us the instance has completed, i.e. agent has done what it has been assigned to do.

OIC Agent Native Action 

One can invoke agents from an integration using the new native action - 

The configuration of the action is as follows - 

Just give it a name, then select your agent; that's all you need to do. 

This will implicitly invoke the start() operation of the agent. 

Note the Request sample - 

{ "payload" : "", "promptTemplateId" : "", "prompt" : "", "conversationId" : "" }

These fields are what you need to map - 

Project Id and Agent Id identify the agent we want invoked. Prompt is the prompt as per the Run test I did earlier.

So let's try this out - 

 

I check in Observability - 

I invoke the monitoring api in postman for the agent instance id - 

You may posit the question - if I can invoke an agent from an integration, how can I get the response? 

Currently the native action only supports start(), however, this will change with the next release. If you cannot wait until then, use the monitoring api call to retrieve the agent activity stream. You can do this in a WHILE loop, waiting for status to be set to COMPLETED.

What we're missing is the ability to retrieve the agent instance id - we can use the OIC monitoring api to do this - 

https://design.integration.us-phoenix-1.ocp.oraclecloud.com/ic/api/integration/v1/monitoring/instances?q={timewindow:'32d',projectCode:'AA_SCHEDULEJO_AGENT',agentic:'yes'}&integrationInstance=yourOICInstance&orderBy=lastupdateddate&fields=all

This may seem complicated, so maybe just vwait a couple of weeks for the next release. 

 

 

#1133 OIC Agent for Scheduled Integrations

Introduction

This is a customer ask - How could an agent simplify the management of OIC scheduled integrations?
I started thinking, very dangerous at my age, but sometimes it has to be done. What sort of management tasks are we talking about? I came up with the following, to begin with -

• Monitoring- how many runs of integration NN in the last day?
• how many successful?
• how many errored?
• has the execution time increased?
• if so, why?
• Management
• stop a schedule - aborts current run, no new runs can be submitted
• start a schedule
• pause a schedule - allows current run to complete, no new runs can be submitted
• update a schedule

To do this within the context of AI Agents, I need tools; tools that leverage the OIC factory api.

These tools are integrations, here are some of them -

 

I begin with the following - 

• Get Schedule - for a specific integration
• Stop Schedule - for a specific integration
• Start Schedule - for a specific integration
• Update Schedule - for a specific integration
• Retrieve Integration Instances - for a specific integration
• Retrieve Activity Stream - for a specific integration

I also include a simple scheduled job as our guinea pig - 

All it does is wait NN secs. The duration is determined by a schedule parameter. Each run increased the wait parameter by 300 secs.

Monitoring

Now to my agent - it has the following tools - 

and the following guidelines - 

I ask the following - 

get me the start and end times for all the runs of integration ONBOARDING_RUN, with version number 01.00.0000 from the project AA_SCHEDULEJO_AGENT in the last day (1d). If you see execution time is increasing then check and tell me what is happening.

The agent response -

Net, net - the Wait action is taking longer over time. 

I ask - how can I fix this? And I get some cogent suggestions.

I then ask - will my future runs be impinged, if I don't fix this? And I get a positive response - yes, the current schedule of every 10 minutes will not be adhered to. I'm again advised to fix the problem. 

However, I'm from LOB so what I want to do now is just change the schedule to every 45 minutes. I don't have access to OIC, but, I do have my tried and trusted agent.

My agent has been augmented with a tool - Invoke Approval Workflow. This is implemented as an integration that invokes HITL (Human-in-the-Loop). 

Managing

The agent needs to be able to do the following, in the case of updating an integration schedule.

• accept the update request from the user
• invoke HITL to get OIC Admin approval
• if approved
• check if the schedule is active
• if active
• then stop the schedule
• update the schedule
• start the schedule

Human-in-the-Loop (HITL) in Oracle Integration Cloud (OIC) is a functionality that enables, manages, and automates human interaction with agentic AI workflows. It allows for the integration of human judgment, approval, and oversight into automated processes to improve accuracy, safety, and compliance.

For more background, Raison d'être etc. - please check out the detailed post from my esteemed colleague, Stan.

To implement HITL, I need a UI (form) and a workflow(who should approve what etc.).

Let's check out the form, this is the UI you know and love from OIC Process.

Now to the Workflow - this is essentially the Human Task from OIC Process.

I define the input payload - 

Here's the response payload - 

Now to the Human Task - 

Here I assign the UI the use, my form, of course! I also define the possible outcomes e.g. APPROVE, REJECT. I can set the task title; this will be surfaced in the Workspace app. Finally, I define the assignee - 

Yours truly, in this case.

The Data Associations ensure the workflow input is surfaced in the form, as well insuring the task outcome is returned.

This Workflow needs to be wrapped in an integration - 

Note, the integration is async.

This integration is then exposed as an agent tool.

Now to the agent, which now has 8 tools -

The agent guidelines have been augmented for the update schedule use case - 

Testing this out

The current schedule is as follows - 

every 10 minutes. Let's request this be upped to 30 minutes.

update the schedule for the integration ONBOARDING_RUN, version 01.00.0000, in project AA_SCHEDULEJO_AGENT. Set the schedule to MINUTELY, every 30 minutes

Note, the human approval has been invoked, so let's move to Process Workspace and check out the request.

Then click on Tasks - 

Note the buttons top right - 

I click Approve - then return to project observability for the agent - 

As you can see, the agent has received the response from HITL; the OIC admin has approved the request to update the schedule. The next steps the agent executes are - 

GET_SCHEDULE - to check if the schedule is active.

It is active so the agent now calls the STOP_SCHEDULE tool -

We also see the UPDATE_SCHEDULE and START_SCHEDULE tools have been invoked.

Finally, I see the agent summary and the quote from Marcus Aurelius - 

Summa Summarum

What I've described is a very simple example of using an AI Agent to manage and monitor scheduled integrations. It is, naturally, a simple POC, combining integration based tools that leverage the OIC factory api, along with our HITL feature.

I can envisage the productization of such within OIC itself, but that's for another day/release etc. 

Finally, let's check out our updated schedule -