Forem: Halton Chen

Evaluation: Prove it before you ship it

Halton Chen — Mon, 18 May 2026 03:14:10 +0000

There's a saying in AI circles: monitoring tells you what's happening — evaluation tells you how good it is. You can have an agent that responds instantly, never crashes, and answers every question with absolute confidence. But confidence without correctness is just a well-dressed mistake.

That's exactly why Oracle AI Agent Studio gives us two complementary capabilities: Monitoring and Evaluation. In this post, we're focusing on Evaluation — what it is, how to set it up, and why you should care before your agent goes anywhere near production.

Curious about Monitoring? Check out this post.

Why Evaluation Matters

Evaluation ensures your agent can meet defined standards and business outcomes across three dimensions: accuracy, latency, and token usage.

Without it, you're essentially deploying on vibes.

With a proper evaluation framework, you can validate that your agent answers correctly, responds within acceptable time, and doesn't burn through your token budget faster than your cloud spend budget. It's the closest thing to a test suite for your AI agent.

The Metrics: What Gets Measured

Oracle AI Agent Studio provides a rich set of metrics, and it's worth understanding which ones are available for Evaluation versus Monitoring, because they serve different purposes.

Metric	Evaluation	Monitoring
Error Rate	✅	✅
Error Count	✅	✅
Session Count	✅	✅
P99 Latency	✅	✅
P50 Latency	✅	✅
Total Tokens	✅	✅
Input Token Count	❌	✅
Output Token Count	✅	✅
Median Correctness	✅	❌
Groundedness	✅	❌
Answer Relevance	✅	❌
Context Relevance	✅	❌

The quality metrics — Correctness, Groundedness, Answer Relevance, and Context Relevance — are exclusive to Evaluation. These are the metrics that tell you whether your agent is genuinely useful, not just technically operational.

A quick breakdown of what these mean in practice:

Median Correctness measures how closely your agent's answer matches the expected reference response. Scores range from 0 to 1. Think of it as your agent's grade on the test.

Groundedness measures whether the generated answer is actually grounded in the retrieved source content. A grounded response stays faithful to what the knowledge base says — it doesn't hallucinate or embellish. (Hallucination: the nemesis of every enterprise AI implementation.)

Answer Relevance measures how directly and precisely the agent's response addresses the user's question. Getting the right answer to the wrong question doesn't count.

Context Relevance measures the quality of the retrieved information itself — whether the context pulled in by the agent was actually appropriate and reliable enough to produce a good answer.

Setting Up an Evaluation: Step by Step

Step 1 — Define Your Evaluation Set

Before you can run anything, you need to define an evaluation set. Think of this as your test plan. It includes:

Test questions — the inputs your agent needs to handle
Expected responses — the gold-standard answers you're measuring against
Success criteria — the thresholds each metric needs to meet

An evaluation set without expected responses is just a demo. The expected responses are what turn a run into a meaningful quality gate.

Step 2 — Choose Your Run Mode

When setting up your evaluation run, you'll choose between two modes:

Sequential runs questions in the exact order you define them. Use this when one question depends on the context from the previous one — for example, a multi-turn conversation flow.

Random runs questions in a randomised order. This is useful when testing independent questions where order doesn't matter, and it helps reduce positional bias in your evaluation results.

Step 3 — Define Your Questions

In the Questions tab, add the questions users are expected to ask your agent, paired with the exact responses you want the agent to return.

Here's an example from an HR benefits agent:

Q: Who is eligible for the benefits program?

A: Eligibility Criteria:

Full-time employees working 30+ hours per week are eligible for full benefits.

Part-time employees may qualify for limited benefits.

Benefits eligibility begins on the first day of the month following hire date.

Dependents (spouse and children under age 26) may be enrolled in applicable plans.

Keep your expected responses as close to production-quality as possible. The correctness metric is only as good as the reference answer you define.

Step 4 — Configure Your Metrics

In the Metrics tab, you select which metrics to include in this evaluation run. This is where you tailor the evaluation to your agent's specific use case and business requirements.

For example:

If your agent doesn't invoke any APIs, you can exclude API error metrics — no point cluttering your results with noise.
If accuracy is your top priority (say, a policy or compliance agent), set your correctness threshold high — 0.8 is a reasonable baseline for enterprise use.
If token cost is a concern, configure output token thresholds to flag responses that are running unnecessarily long.

Metrics without thresholds are just numbers. Thresholds are what turn numbers into pass/fail signals.

Step 5 — Initiate the Evaluation Run

Click Initiate Evaluation Run. Oracle AI Agent Studio will execute the evaluation and return results for each question, including:

Actual response vs. expected response — side by side
Latency per question
Token usage (input and output)
Quality scores for the metrics you selected

Reading Your Results

After the run completes, reviewing the results is where the real value surfaces. Here's an example of what you might find:

Latency: One question took over 20 seconds — exceeding the defined threshold. That's a red flag worth investigating. It could point to an overly complex retrieval step, a large system prompt, or a knowledge base that needs optimisation. The remaining questions came in well within threshold.

Token Usage: Both input and output token counts were within acceptable limits. Good news for the budget.

Correctness: With a threshold of 0.8, any question scoring below that benchmark gets flagged for review. Patterns in low-scoring questions often reveal gaps in your knowledge base or ambiguities in your system prompt.

This combination of latency, cost, and quality signals gives you a complete picture — not just "did it answer?" but "did it answer well, quickly, and efficiently?"

Final Thoughts

An AI agent that passes evaluation isn't just technically sound — it's one you can actually stand behind when a business user asks, "How do we know this is right?"

Defining quality thresholds, building meaningful evaluation sets, and reviewing results against expected outcomes is what separates a production-ready agent from a prototype running in a demo environment. Oracle AI Agent Studio gives you the tooling to do this properly. Use it.

Monitoring: From Black Box to Glass Box

Halton Chen — Sun, 10 May 2026 03:31:42 +0000

You've built your AI agent. You've configured the tools, crafted a thoughtful system prompt, and deployed it to your users. Job done, right?

Not quite. Once your agent is live, a whole new set of questions emerges: Is it actually working? How fast is it responding? How many tokens is it burning through — and what does that mean for your costs?

That's where the Monitoring and Evaluation tab in Oracle AI Agent Studio comes in. Think of it as your agent's mission control — minus the dramatic countdowns.

Let's walk through how it works.

Before You Start: Run the ESS Job

Monitoring data doesn't appear by magic. Before you can view any meaningful metrics, you need to run the ESS job: Aggregate AI Agent Usage and Metrics.

This job does exactly what it says — it aggregates the usage data and metrics displayed in the Monitoring and Evaluation tab. Oracle recommends running it once or twice per day, so it's worth scheduling it on a regular cadence rather than remembering to kick it off manually.

Set it and (mostly) forget it.

What the Monitoring Tab Shows You

Once the ESS job has run, the Monitoring tab gives you an aggregated view across all your agents — both published and draft. That last part is worth noting: draft agents are included too, which is great for testing before you go live.

You can filter the view by time period: last 1 day, 7 days, 1 month, or 3 months. This flexibility lets you spot trends over time, not just point-in-time snapshots.

At the top level, the dashboard answers the big-picture questions:

How many users are engaging with my agents?
How many sessions are being initiated?
How much latency are users experiencing?
How many tokens are being consumed — and what does that mean for cost?

Speaking of tokens — pay close attention to this number. Oracle's pricing strategy is tied to token consumption, so the token count is more than just a technical metric. It directly informs your cost management and capacity planning decisions. (No one wants a surprise on the bill😒)

Drilling Down: From Agent Team to Individual Session

The real power of the monitoring view comes from its drill-down capability. Here's how it layers:

Level 1 — Agent Team View

Click on an agent team to see its detailed runs. Each row represents a session — a single end-to-end interaction between a user and the agent.

Key metrics at this level include:

Turns — The number of back-and-forth exchanges within a session. Two turns means the user asked two questions and the agent responded twice. Simple, but useful for understanding conversation depth.
Session Status — Whether the session completed successfully or hit an error. Keep an eye on error rates; a spike usually means something upstream has changed.
Total Tokens Used — As mentioned, this is your cost signal. In a typical example, just 2 turns can consume around 20,000 tokens. That adds up quickly at scale.
P99 Latency — This is the maximum wait time (in milliseconds) for 99% of your users. For example, a P99 of 16,375ms means 99% of users received their response within 16 seconds. It's a practical measure of worst-case user experience, not just average performance.

Level 2 — Session Trace View

Drill into any individual session and you get a detailed trace view — a timeline of exactly what happened, in what order, and how long each step took.

This is where troubleshooting becomes genuinely useful. You can see:

Which tools were called and how long each tool execution took
When the LLM was invoked and how long the model took to process each request
Token usage and latency broken down at the individual LLM call or tool level

This level of granularity is invaluable when you're optimising agent performance. If a tool is consistently slow, it shows up here. If the LLM is the bottleneck, the trace makes it obvious. No guessing required.

Why This Matters for Enterprise AI

Monitoring isn't just a nice-to-have — it's a governance and cost control requirement in any serious enterprise deployment. Oracle AI Agent Studio's built-in monitoring gives you the visibility to:

Manage costs proactively by tracking token consumption before it becomes a budget conversation
Ensure reliability by catching session errors early and resolving them before users notice
Optimise performance by identifying slow tools or LLM calls that degrade the user experience
Support adoption reporting by providing concrete usage data across your agent portfolio

Whether you're reporting upwards to a CIO or fine-tuning agent logic with your development team, the Monitoring tab speaks both languages — executive summary at the top, engineering detail at the bottom.

Summary

The Monitoring and Evaluation capability in Oracle AI Agent Studio gives you a clear, layered view of how your agents are performing in production. From aggregate usage trends down to individual tool traces, the data is there — you just need to run the ESS job first.

Build it, deploy it, monitor it. That's the full loop.

Three Different Ways to Access Oracle AI Agent — And Why It Matters

Halton Chen — Sun, 03 May 2026 20:32:40 +0000

Oracle AI Agent Studio brings intelligent, role-aware agents directly into your workflow. But did you know there's more than one way to get there? Let's break down the three access methods and when to use each.

Introduction

Oracle AI Agent Studio is Oracle's answer to embedding AI directly into your enterprise workflows. Rather than forcing users to switch context and open a dedicated AI tool, the studio lets you meet users where they already are — whether that's the Oracle UI, a business process page, or (yes, really) Slack.

In this post, we'll walk through three distinct ways to access and interact with Oracle AI agents, explore the role-based access model that underpins them, and highlight the real-world use cases where each method shines. By the end, you'll have a clear picture of which approach fits your users best.

A Quick Word on Role-Based Access

Before we dive in, it's worth understanding how Oracle AI Agent Studio controls who gets to do what.

Oracle uses role-based access control (RBAC) to determine what a user can see and interact with. For example, a user assigned the Employee and AI Agent Explorer roles can discover and interact with published AI agents — but they can't configure, modify, or deploy them. That's a developer's privilege.

This matters because the three access methods we're about to cover all operate within this permission model. A user with limited roles will still have a great experience — they just won't have the keys to the engine room. (Which, honestly, is probably for the best.)

Method 1: Access via AI Chat

Best for: Role-based exploration and general-purpose agent interaction.

The first and most straightforward way to access an Oracle AI agent is through the AI Chat tile on the Oracle homepage.

Here's how it works:

Log in to Oracle and navigate to the homepage.
Head to the Me tab.
Find the AI Chat tile — this is your gateway to Oracle AI Agent Studio.
Select the agent you want to interact with and start chatting.

In practice, this looks like a clean conversational interface where users can ask questions relevant to their role. For example, asking "Do I have any incomplete requisitions?" returns a response scoped to your own data only — no peeking at other users' records.

This is important: the agent respects data access boundaries. It's not just intelligent; it's also appropriately scoped. Which, in an enterprise context, is non-negotiable.

When to use this method: When you want a general-purpose entry point for employees to explore available agents without needing to be deep in a specific workflow.

Method 2: Access via Guided Journey

Best for: Contextual, workflow-embedded agent interaction.

The second method takes things up a notch — literally embedding the AI agent inside a business process page. This is the Guided Journey approach.

Here's the scenario: imagine a procurement employee is working on a purchase requisition in Oracle's Redwood UI. Instead of leaving the page to open AI Chat, the AI agent is already right there — embedded directly in the requisition page. The user can ask questions in context, like checking for incomplete requisitions, without ever navigating away.

This is made possible by customising the relevant Oracle page (in this case, the Redwood purchase requisition page) to include the AI agent widget. And the best part? This approach isn't limited to procurement. You can embed agents into any relevant business page — payroll, HR, supply chain — wherever contextual AI assistance adds the most value.

Why this matters: Contextual access reduces friction. Users stay in their workflow, get answers faster, and complete tasks more efficiently. It's the difference between having a knowledgeable colleague sitting next to you versus having to walk down to IT every time you have a question.

When to use this method: When you want to optimise task completion rates and minimise context-switching for users who are deep in a specific business process.

Method 3: Access via Slack Chat

Best for: Users who want Oracle AI capabilities without logging into Oracle at all.

Third — and perhaps the most impressive from a user adoption perspective — is accessing Oracle AI Agent directly through Slack.

This requires some upfront configuration: a dedicated Slack app (called, fittingly, Ask Oracle) needs to be set up and connected to your Oracle environment. Once configured, users can simply message the app in Slack and get detailed, structured responses directly in their Slack workspace.

That's real enterprise data, surfaced in Slack, without the user ever opening Oracle. 🎉

When to use this method: When your users are Slack-first and you want to meet them in the tool they already live in. This is especially powerful for approvers or managers who need quick data access on the go, without the overhead of logging into Oracle for a single query.

Comparing the Three Methods

Access Method	Setup Complexity	Best Audience	Key Advantage
AI Chat (Oracle UI)	Low	All employees	Simple, role-aware, no extra config
Guided Journey	Medium	Process-specific users	Embedded, contextual, workflow-native
Slack Chat	Medium-High	Slack-heavy teams	No Oracle login required

Each method has its place. The right choice depends on your users' workflows, technical comfort, and how deeply Oracle is integrated into their daily routine.

Key Takeaways

Oracle AI Agent Studio isn't a one-size-fits-all tool — and that's actually a strength. By offering multiple access patterns, Oracle ensures that:

Casual users can explore agents safely via AI Chat without overwhelming them with configuration options.
Power users embedded in specific workflows benefit from contextual agent access via Guided Journeys.
Mobile or Slack-first users can access enterprise intelligence without ever opening Oracle.

As organisations continue to roll out Oracle AI Agent Studio, thinking carefully about which access method to deploy for which user persona will be critical to adoption success.

If you're just getting started with Oracle AI Agent Studio, I'd recommend beginning with AI Chat to build familiarity, then progressively exploring Guided Journeys and Slack integration as your use cases mature.

Have questions or want to share your own Oracle AI Agent Studio experience? Drop a comment below — the community always learns best together.

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