Forem: Halton Chen

Business Object Tool: Powering AI Agents with Structured Enterprise Data

Halton Chen — Fri, 24 Apr 2026 04:09:06 +0000

Introduction

If you've ever wished your ERP system could just answer your questions instead of making you click through fourteen screens to find a purchase order — good news. With Oracle AI Agent Studio, that's no longer wishful thinking. In this post, I'll walk you through how I built an AI agent that retrieves live purchase order data from Oracle Fusion using a REST API, a Business Object, a custom Tool, and an Agent Team. From architecture to deployment, here's how it all fits together.

What We're Building

Before diving in, let's map out the architecture at a high level:

Oracle Fusion Data → REST API → Business Object → Tool → Agent → Agent Team

Each layer builds on the one before it. The REST API is the data source, the Business Object wraps it in a structured schema, the Tool exposes it to the agent, and the Agent Team makes the whole thing available to end users. Clean, composable, and — once you've done it once — surprisingly straightforward.

Step 1: Validate the REST API

Every good agent starts with reliable data. I used Oracle's published Fusion REST API for Purchase Orders:

Endpoint: GET /fscmRestApi/resources/11.13.18.05/purchaseOrders

Reference: Oracle Fusion Procurement REST API Docs

Before doing anything in Agent Studio, I validated the endpoint to confirm it returns the fields I need — things like OrderNumber, Status, Supplier, Buyer, Total, and Date. Take this as the foundation check. Test early, test often.

Step 2: Create the Business Object

With a validated API in hand, I navigated to Oracle Applications → Tools → AI Agent Studio and headed to the Business Object tab.

Here's how I configured it:

Field	Value
Family	PRC
Product	Purchasing
Name	Halton_Return_PO_Information
Resource Type	Monolith Resource
Resource Path	`/fscmRestApi/resources/11.13.18.05/purchaseOrders`

Add a Business Function
Import fields via “Add Field from Specification”
Select only relevant attributes (e.g., OrderNumber, Status, Supplier, Buyer, Total)

This step is where most implementations go wrong.

Common mistake: importing everything.
Correct approach: curate fields aligned to query intent.

Once saved, the Business Object is ready to be used as a data source by a Tool.

Step 3: Create the Tool

A Business Object on its own doesn't do anything — you need a Tool to expose it to an agent. I created a new tool called Halton_Return_PO_Tool and linked it to the Business Object created in Step 2.

The Tool acts as the bridge between the agent's reasoning layer and the actual data retrieval logic. When a user asks the agent a question, the agent invokes the Tool, the Tool calls the Business Object, and the Business Object hits the REST API. It's turtles all the way down — in the best possible way.

Step 4: Configure the Agent

I created a new AI Agent in Agent Studio and wired up the Tool. But the real differentiator is the system prompt — this is what tells the agent how to behave, not just what it can access.

Here's the prompt I used:

"You are a Purchase Order (PO) advisor who answers questions from employees about purchase order details retrieved by the Purchase Order system.

Always display retrieved purchase order results in a table format.

Use the following rules to match user input to the correct PO data fields:

If a user provides a purchase order status, match it with the Status field.

If a user provides a supplier name, match it with the Supplier field.

If a user provides a buyer name, match it with the BuyerDisplayName field.

If a user provides a PO total or amount, match it with the Total field.

If a user provides a purchase order number, match it with the OrderNumber field.

If a user provides a date or date range, match it with the Date field.

If a user asks about line items, retrieve and display them in a table.

If no purchase orders match the user's search criteria, respond with: "No purchase orders were found matching your search. Please verify the details and try again."

Always be concise, professional, and only return information retrieved from the Purchase Order system."

A few things worth calling out here.
First, the explicit instruction to display results in a table format — without this, LLMs will happily dump data as unstructured prose, which no one wants to read.
Second, the field-matching rules eliminate ambiguity: the agent doesn't have to guess what "show me all open POs" means; the prompt tells it exactly which API field to filter on.
Third, the fallback message for no results is a small but meaningful UX touch.

This is where the investment in a well-crafted prompt pays dividends. A vague prompt produces a vague agent.

Step 5: Build the Agent Team

With the agent configured, the final step is creating an Agent Team — Oracle's mechanism for grouping and deploying agents for end-user interaction.

I created a new Agent Team, added the configured agent to it, and published it. That's it. The agent is live.

The Result

Once deployed, the agent can respond to natural language queries like:

"Retrieve all POs from ABC Corp"
"Find all purchase orders for buyer Halton"
"What are the line items on PO 10042?"

The agent pulls real-time data from Oracle Fusion, applies the filtering logic defined in the prompt, and returns a clean, structured table. No ERP navigation. No SQL. No reporing. Just a question and an answer.

Key Takeaways

Validate your API first. Don't assume the REST endpoint returns what the documentation says. Confirm it before building anything on top of it.
Be explicit in your prompts. Map every user intent to a specific field. The more explicit the instructions, the more predictable the agent's behaviour.
Use field selection wisely. Only pull the fields that are meaningful to your use case. Unnecessary fields add noise and can confuse the agent's reasoning.
The architecture scales. Once you've built one Business Object and Tool, adding more agents or extending to new APIs follows the same pattern. The investment in understanding the framework pays off quickly.

Wrapping Up

Oracle AI Agent Studio makes it genuinely accessible to build enterprise-grade AI agents without needing a data science background or a custom ML pipeline. If you have a REST API and a clear use case, you have everything you need to get started.

The purchase order agent I built here is a practical, real-world example — not a demo with mock data. It queries live Oracle Fusion data and responds to the kinds of questions procurement teams ask every day. That's the whole point.

If you're exploring Oracle AI Agent Studio for your organisation, I'd encourage you to start with a well-understood API, keep your first agent focused, and iterate from there. The platform rewards curiosity.

Have questions or want to share your own Oracle AI Agent Studio experience? Drop a comment below or reach out on the Oracle Cloud Customer Connect.

Document Tool: Grounding AI in Enterprise Knowledge

Halton Chen — Mon, 13 Apr 2026 03:59:29 +0000

Overview

Oracle AI Agent Studio provides a structured way to build intelligent agents that go beyond static workflows. In this guide, I demonstrate how to create a document-driven AI agent capable of answering real user questions using enterprise content.

Rather than relying on predefined responses, this agent uses a custom document tool with retrieval-based capabilities (RAG) to deliver context-aware answers grounded in uploaded documents.

This walkthrough reflects hands-on implementation, including setup, customization and validation.

New to Oracle AI Agent and haven't build your first AI Agent yet? Start here.

What You’ll Learn

How to start from an Oracle-delivered agent template
How to create and customize a document tool
How to upload and publish enterprise documents
How to configure an agent to use retrieval-based responses

Architecture at a Glance

This solution consists of three core components:

Agent Team – Orchestrates the interaction
Custom Document Tool – Enables document retrieval
Uploaded Policy Document – Acts as the knowledge source

Together, these form a lightweight RAG implementation inside Oracle AI Agent Studio.

Step 1: Start from a Template (Don’t Reinvent the Wheel)

Instead of building from scratch, I used the Benefits Policy Advisor template available in AI Agent Studio.

Why this matters:

Templates encode Oracle’s recommended structure—bypassing them often leads to avoidable configuration errors.

What I did:

Navigated to: Tools → AI Agent Studio
Searched for Benefits Policy Advisor
Used Copy Template
Created a custom version: Benefits Policy Advisor Halton

This produced an agent team with:

1 agent
1 document tool
No topics configured initially

Step 2: Create a Custom Document Tool

To avoid altering the standard tool, I created a copy:

New Tool Name: Halton_Lookup_benefits_policies

Why this step is essential:

Preserves the original configuration
Enables controlled customization
Aligns with enterprise change management practices

Step 3: Upload and Prepare the Document

I uploaded a sample benefits policy document into the custom tool.

Don’t have one? No problem—ask any AI to generate a default benefits policy with whatever perks you wish your company offered (yes, unlimited PTO is highly recommended 🙂).

Then:

Set document status to Ready to Publish

Step 4: Publish the Document

To activate the document:

Navigated to Scheduled Processes
Ran: Process Agent Documents

After successful completion:

Verified document status = Published

Insight:

This step effectively performs indexing and enables retrieval. Skipping it leads to failures during testing.

Step 5: Replace the Tool in the Agent

Next, I updated the agent configuration:

Removed standard tool: ORA_lookup_benefits_policies
Added custom tool: Halton_Lookup_benefits_policies

Then:

Replaced the default agent with a customized version
Updated the agent team to use the new agent

Why this matters:

This ensures that the agent team utilizes the custom agent along with the tool configured against the published document.

Step 6: Validate the Output

Now ask the agent:What's the PTO policy?

The agent successfully retrieved content
Responses were grounded in the uploaded document
Queries returned accurate, contextual answers

This confirms a working document-driven AI agent pipeline.

Final Outcome

The completed agent:

Accepts natural language questions
Retrieves relevant content from enterprise documents
Produces context-aware responses
Demonstrates a working RAG-style architecture within Oracle AI Agent Studio

Where This Becomes Valuable in Real Projects

This pattern is directly applicable to:

HR policy assistants
Finance and procurement knowledge bots
IT support automation
Compliance and regulatory guidance

The key shift is from:

“Predefined chatbot responses”

to

“Dynamic, document-grounded intelligence”

What the next question in real implementation

How will this scale with hundreds of documents?
What governs document freshness and accuracy?
How do you prevent conflicting answers across sources?
What is your evaluation metric for response quality?

Without the answers, this is still a demo—not a production system.

Building a document-driven agent is straightforward. Building one that is reliable, scalable, and trustworthy is not.

Deep Link Tool: Turning insights into Actions

Halton Chen — Thu, 09 Apr 2026 03:41:55 +0000

Introduction

In my previous post, I walked through how to build your first Oracle AI Agent. If you haven’t seen it, I recommend starting there.

This post addresses a more important question:
How do you make an AI agent actually useful in real business workflows?
The answer is simple but often overlooked: you must connect insights to actions.

In Oracle AI Agents, this is achieved through tools, and one of the most powerful types is the Deep Link tool.
Specifically, I’ll show:

What a deep link looks like in an AI agent response
Why it matters
How to configure a deep link tool in Oracle

What does a deep link look like in an AI Agent?

Let’s start with a simple example.
When I ask the agent:
“Show me my incomplete requisitions”
The agent does two things:

Returns the relevant data
Provides a clickable link to each requisition

When I click the link, I’m taken directly to that requisition in Oracle Fusion.
No navigation. No searching. No extra clicks.
This is where AI agents move beyond answering questions — they start enabling real work.

Once we click on “here”, it will automatically link to the requisition page.

Why Deep Links Matter

A deep link is a URL that takes a user directly to a specific page or record inside Oracle Fusion.
Instead of navigating through the UI, the user is routed instantly to the exact destination.

Without deep links, the workflow looks like this:
• Navigate to Procurement
• Open Purchase Requisitions
• Search for the requisition
• Open it

With deep links:
• Click once → land directly on the record
This reduces friction and makes the AI agent actionable, not just informative.

How deep link work in the AI Agent

In the Purchase Requisition Status Advisor, there are three tools:
• Get User Session,
• Purchase Requisition Details,
• View Purchase Requisition Details
The tool "View Purchase Requisition Details" is a deep link tool.

Understanding the deep link configuration

In our case, Oracle provides a standard deep link tool, “ORA_VIEW_PURCHASE_REQUISITION_DETAILS”
Tool Type: Deep Link

The deep link tool is connected with deep link “Deep link that enables employees to view the full details of a requisition.”

The most important part of deep link is the relative url, it tells Oracle which page to open.

/fscmUI/redwood/procurement/requisitions/tabbar/shopping/requisitiondetails?requisitionHeaderId={RequisitionHeaderId}

Key Concepts:
• Relative URL: Everything after your Oracle domain
• Parameter:
requisitionHeaderId={RequisitionHeaderId}

Example: full URL
When you open a requisition in the browser, the full URL looks like below, you can copy it when open a requisition in the browser.

https://yourcompany.oraclecloud.com/fscmUI/redwood/procurement/requisitions/tabbar/shopping/requisitiondetails?requisitionHeaderId=300000303705247&tabSelected=tab_requisitions

The relative URL is just the tail end of the real URL, everything after your company’s Oracle domain name.
The AI agent simply generates this dynamically using the correct Requisition Header ID.

Key Takeaway

Deep links are what make AI agents operational, not just conversational.
They:
• Reduce navigation effort and improve user experience
• Connect AI insights directly to business actions

Oracle AI Agent 101 : Build your first agent step-by-step

Halton Chen — Sat, 04 Apr 2026 23:57:36 +0000

Introduction

Oracle AI Agent Studio enables organizations to rapidly build AI-powered assistants embedded within Oracle Cloud Applications. In this walkthrough, I demonstrate how to create, configure, test, and publish a custom procurement-focused AI agent using an out-of-the-box template.

Procurement users often spend time manually checking requisition status across systems. This agent simplifies that by enabling natural language queries tied directly to transactional data.

What You Will Build

A custom AI Agent for Purchase Requisition status
Integration with business objects and document retrieval (RAG)
Defined topics to control agent scope
A tested and published AI Agent Team

Access Oracle AI Agent Studio

Navigate to Tools → AI Agent Studio within Oracle Cloud Applications. This provides access to prebuilt agent templates that accelerate development.

Create a Custom Agent from Template

Filter templates by Procurement and select a relevant out-of-the-box agent. Use the 'Copy Template' feature to create a custom version. Apply a naming convention (e.g., adding a suffix) to distinguish your agent.

Key Components of an AI Agent

Tools

Defines the additional utilities an agent can use to accomplish a task. One or more tools are assigned to agents, and they're reusable among agents.

List of Tools:

• Calculator tool
• Email tool
• Business object tool: Use Business Object tools when you need structured transactional data (e.g., PR status).
• User query tool
• Document retrieval tool for retrieval-augmented generation (RAG) : Use Document Retrieval (RAG) when answers depend on unstructured knowledge (e.g., policies or documents).

Topics

Defines the areas of expertise through instructions that set the boundaries and constraints for agent conversations and abilities.
Without well-defined topics, the agent may respond outside procurement scope, reducing accuracy.

Configure Agent Details

Review agent configuration including prompts, LLM provider selection, and tool assignments. Save the agent in draft status for further testing.

Configure Agent Team

In Agent Team settings, configure LLM providers, define security roles, and set starter questions to guide user interaction.

Currently, three LLM options are available: GPT-5 mini, GPT-4.1 mini, and GPT-OSS-120B. Rather than defaulting to the latest model, selection should be based on the use case.

GPT-5 mini: strong balance of reasoning capability and efficiency; suitable for most enterprise workflows
GPT-4.1 mini: faster and more cost-efficient; works well for simpler, high-volume interactions
GPT-OSS-120B: more flexible and customizable; useful when control or specific tuning is required

In practice, model choice is a tradeoff between capability, latency, token usage, and cost. For most scenarios, the “best” model is not the most advanced one, but the one that meets requirements with the lowest operational overhead.

Test Using Debug Mode

Click on the Triangle to run in debug mode.
Use the Debug feature to validate agent responses. Ensure queries return accurate procurement data and remain within defined topic boundaries.

Example: “What is the status of my purchase requisition?”
The agent retrieves real-time data using the business object tool and returns the current approval status.

Publish the Agent

Once validation is complete, publish the agent team to make it available to end users.

Key Takeaways

Templates significantly reduce setup time
Tools extend agent capabilities through integrations
Topics are critical for controlling agent scope
Debugging ensures reliability before deployment