Skip to main content

Design Multi-Agent Systems: Supervisor Delegation and MCP

Calculating read time…

Imagine an Accounts Payable team receives two questions about the same invoice. The first is simple: "Has invoice INV-1042 been received?" An invoice investigation specialist can answer that. The second is more involved: "Can we release this invoice under our current procurement policy?" Now the team needs both invoice evidence and a policy interpretation.

Calling every specialist for every request wastes effort and exposes unnecessary information. Allowing one agent to call other agents without boundaries creates a different problem: nobody can clearly establish which evidence was used, which case owns the work, or when delegation should stop. A supervisor can make delegation conditional on the actual request, but only when its responsibilities, information boundaries, and completion rules are engineered deliberately. This article develops that design using Oracle Integration 3, two specialist agents, integration-based delegation bridges, and an optional external MCP connection.

1. The Architecture You Will Design

Practical outcome: Design a Supervisor Agent that selects between an Invoice Investigation Agent and a Policy Interpretation Agent, routes bounded tasks through OIC integration-backed tools, validates the returned application contracts, and prepares one consolidated recommendation. The article provides synthetic fixtures and an implementation design. It does not claim a tenant-tested end-to-end specialist response mapping.

How OIC implements this delegation

Before looking at the agents, understand the actual OIC component chain. The Supervisor Agent does not import another agent as a native sub-agent object. It calls registered agentic AI tools. Each tool is an OIC integration that acts as a controlled bridge to one specialist.

  1. Supervisor Agent: An OIC Project AI Agent receives the user's request and chooses one or both registered tools.
  2. Tool integration: Each tool is an active project integration with a REST Adapter trigger, OAuth authentication, and JSON request/response contracts.
  3. Specialist invocation: The bridge uses the OIC AI Agent action to start its configured active specialist, passing the bounded task prompt or prompt-template payload.
  4. Completion check: The bridge uses the Get AI Agent Activity Stream action with the specialist conversation ID to inspect the conversation's status. The bridge must not treat a successful start as a completed result.
  5. Result return: After the actual specialist result is available and mapped into the bridge's application response contract, the tool integration returns that contract to the supervisor. The supervisor validates it before answering.
User request
↓
Supervisor Agent
Chooses registered tool(s)
↓
Invoice bridge
Start agent → inspect activity → map result
Policy bridge
Start agent → inspect activity → map result
↓
Application contract validation
Correlation, evidence, freshness and policy version
↓
Supervisor response
Facts + interpretation + unresolved items

Important boundary: Oracle documents the Start AI Agent action's invocation inputs and the Activity Stream action's conversation-status retrieval. The published procedures do not define a universal mapper path for the specialist's final assistant text. The bridge therefore has a release/tenant verification point: prove that the final result is available through a supported output mapping before claiming end-to-end execution. The fixtures in this article let you validate routing and business contracts independently of that unresolved mapper detail.

The supervisor should make the following decisions:

  • Invoice-status request: Delegate to the Invoice Investigation Agent only.
  • Policy-exception request: Obtain invoice evidence and policy interpretation from both specialists.
  • Combined request: Obtain both findings and reconcile them before answering.
  • Unreliable or conflicting evidence: Stop the recommendation and return a controlled review outcome.

The prototype is read-only. It does not approve invoices, release payments, update purchase orders, or invoke privileged financial transactions.

The three participants

Participant Responsibility
Supervisor Agent Understand the request, select appropriate specialists, evaluate their evidence, and assemble the response.
Invoice Investigation Agent Investigate invoice status, purchase-order information, receipt evidence, and matching results.
Policy Interpretation Agent Interpret the applicable policy, identify relevant clauses, and explain whether additional review is required.

All three names are tutorial-defined. They are not Oracle-reserved agent types or product features.

A complete interaction before the architecture details

Use the following fictional case throughout this exercise.

CaseCASE-1001
InvoiceINV-1042
Purchase OrderPO-2087
Invoice valueUSD 21,400
ReceiptGR-771 — Fully received
Current policyPROC-POLICY-001, Version V2

Illustrative policy excerpt: In this synthetic example, invoices exceeding USD 20,000 require additional director review before payment release. Version V2 is effective from October 1, 2026.

The example assumes that a deterministic invoice-matching service has already reported the relevant line-level, quantity, tax, currency, and receipt checks as matched. Matching is not inferred from two equal header totals. The amount and currency used later by the Policy Interpretation Agent must come from this validated invoice evidence or the authoritative AP record, not from the user's wording or an LLM estimate.

Interaction A: Invoice-status request

User: What is the current status of invoice INV-1042?

Supervisor decision: This is an invoice-status request. Policy interpretation is unnecessary.

Delegation: Invoice Investigation Agent only.

Illustrative specialist finding:

{
  "caseId": "CASE-1001",
  "invoiceId": "INV-1042",
  "finding": "RECEIVED_NOT_PAID",
  "invoiceStatus": "VALIDATION_PENDING",
  "paymentStatus": "UNPAID",
  "matchStatus": "MATCHED",
  "evidence": [
    {
      "sourceSystem": "AP_SIM",
      "recordId": "INV-1042",
      "retrievedAt": "2026-11-17T09:00:00Z"
    },
    {
      "sourceSystem": "MATCH_SIM",
      "recordId": "MATCH-551",
      "retrievedAt": "2026-11-17T09:00:03Z"
    }
  ]
}

Supervisor response: Invoice INV-1042 has been received and remains unpaid. The invoice-matching service reports a match against purchase order PO-2087 and receipt GR-771. Its current processing status is VALIDATION_PENDING.

Interaction B: Policy-exception request

User: Can Accounts Payable release INV-1042 without additional director review?

Supervisor decision: Invoice evidence and policy interpretation are both necessary.

Delegation: Invoice Investigation Agent and Policy Interpretation Agent.

Policy specialist finding:

{
  "caseId": "CASE-1001",
  "decision": "REVIEW_REQUIRED",
  "invoiceId": "INV-1042",
  "policyId": "PROC-POLICY-001",
  "policyVersion": "V2",
  "effectiveFrom": "2026-10-01",
  "ruleId": "AP-DIR-02",
  "threshold": {
    "currency": "USD",
    "amount": 20000
  },
  "invoiceAmount": {
    "currency": "USD",
    "amount": 21400
  },
  "evidenceRef": "POLICY-SIM-V2-AP-DIR-02"
}

The supervisor compares this result with the investigation findings and the authoritative active-policy version.

Supervisor response: The invoice and receipt are reported as matched, but that does not remove the policy requirement. The current illustrative policy, PROC-POLICY-001 V2, requires director review for invoices above USD 20,000. INV-1042 is USD 21,400 and therefore requires additional review before payment release. No payment action was performed.

Notice the important distinction: the invoice specialist reports operational and matching facts; the policy specialist interprets a rule. Neither specialist authorizes payment.

2. In This Post

3. Before You Begin

This is an architecture and fixture-based prototype. No OIC tenant, integration export, or runtime execution evidence has been supplied.

  • An existing OIC Project containing your working agentic AI solution.
  • Two independently configured, active specialist AI agents, or equivalent specialist fixtures for the paper exercise.
  • Integrations that provide the invoice, purchase-order, receipt, and policy evidence contracts.
  • Access to create and configure project integrations and agentic AI tools.
  • A case-state store or equivalent authoritative application record if you want executable delegation budgets and durable case isolation.

4. Concepts That Change the Architecture

4.1 When does dynamic delegation provide value?

Dynamic delegation is useful when the request does not always need the same specialists. It allows the supervisor's reasoning to determine which bounded capabilities are relevant.

RequestRequired specialistReason
Where is my invoice?InvestigationRequires current operational data.
Does policy require director review?Investigation and PolicyRequires invoice facts and the applicable policy.
Explain a matching discrepancy.InvestigationPolicy interpretation is unnecessary unless policy applicability is also questioned.

There are three reasonable architectural choices:

Fixed integration orchestration: Use when the same steps are always required. This is the simplest and most predictable design.

Supervisor-led delegation: Use when the relevant specialist depends on the intent or complexity of the request.

Supervisor with additional hierarchical delegation: Use only when another level of delegation solves a demonstrated business problem. It introduces further state, failure, and permission boundaries.

For this prototype, use one supervisor and two specialist agents. A supervisor with unrestricted access to other supervisors is unnecessary.

4.2 What is the supervisor actually responsible for?

The supervisor performs four jobs:

  1. Interpret: Determine what the user is asking and identify the evidence required.
  2. Delegate: Select an eligible specialist and pass a bounded task contract.
  3. Evaluate: Check whether returned evidence is relevant, sufficiently current, complete, and consistent.
  4. Assemble: Produce one answer that clearly separates verified facts, policy interpretation, and unresolved questions.

The supervisor should not independently invent invoice facts, calculate matching results from incomplete data, or interpret authorization as a consequence of a model recommendation.

4.3 A tool integration can bridge two agents

As outlined at the start of the article, an OIC integration can use the AI Agent action to start an active agent in the current or a shared project. Oracle also documents using an integration to orchestrate multiple AI agents from within the same integration. In this design, each bridge integration is registered as a tool that the Supervisor Agent can select.

This enables the following composed design:

User request
↓
Supervisor Agent
Selects relevant specialist tools
↓
Investigation Tool Integration
Invokes Investigation Agent
Policy Tool Integration
Invokes Policy Agent
↓
Result validation and evidence reconciliation
↓
Supervisor's final response

This is a composed OIC architecture. It is not evidence of a native OIC supervisor/team designer or automatic agent-to-agent handoff facility.

One implementation detail deserves special attention. The Start AI Agent action accepts a Conversation ID input, and the Get AI Agent Activity Stream action retrieves the status for that conversation. The documented procedures do not publish a stable mapper field path for extracting the specialist's final assistant message. Use an application-generated Conversation ID consistently, inspect the Activity Stream output in the target release, and prove the final-result mapping before claiming the bridge is executable. The application contracts below define the required handoff without inventing Oracle mapper elements.

4.4 Delegation is not conversation ownership transfer

There are four different types of information to manage.

InformationMeaningOwner
Conversation historyPrevious prompts, responses, and decisions.Individual agent conversation.
Working contextEvidence and instructions needed for the current specialist task.Delegation request.
Durable case stateCase ownership, task status, evidence references, policy version, and delegation records.Authoritative application store.
Business dataCurrent invoice, purchase order, receipt, and policy records.ERP, case system, policy repository, or source application.

Oracle documents that a conversation ID can associate multiple runs of an AI agent and preserve the prompts, data, and decisions from those runs. It also documents restrictions on starting another run when that conversation is already in progress or waiting for a tool.

That does not establish automatic sharing of conversation history between different agents.

In this design:

  • The Supervisor Agent owns the user-facing conversation.
  • Each specialist receives only the task context needed for its work.
  • The case ID correlates the business case across integrations and specialist calls.
  • The conversation ID identifies an agent conversation, not a business case or authenticated user.
  • Durable case state stays outside conversational history.
A simple analogy

Think of an AP team transferring an investigation to a policy reviewer. The reviewer receives a small case handoff containing the invoice number, relevant evidence, and policy version. The reviewer does not automatically receive the entire employee conversation or every document the investigation team has ever seen.

In this OIC architecture, this means: Delegate an explicit task and evidence package. Store case ownership and progress separately from each agent's conversation.

4.5 How should delegation stop?

A supervisor needs a bounded delegation policy. A prompt saying "do not call tools repeatedly" is a behavioral instruction, not an executable system limit.

For this two-specialist example, define the following illustrative application controls:

ControlExample ruleEnforcement
Maximum depthOne delegation level.Integration bridge checks delegation depth.
Specialist budgetMaximum two distinct logical specialist tasks per request.Durable delegation ledger; retry attempts are budgeted separately.
Duplicate callsOne completed task per specialist and request.Idempotency key and stored task status.
Allowed specialistsInvestigation and Policy only.Tool allowlist and integration eligibility.
TerminationRequired results validated or a controlled unresolved status returned.Deterministic coordinator.

These are not documented native OIC supervisor budget parameters. They are application-level design decisions. Do not represent them as ReAct iteration limits or built-in delegation-depth settings.

5. Practical Work: Design Bounded Dynamic Delegation

Phase 1 — Establish the minimum evidence fixtures

Before delegating to agents, define what each specialist is allowed to receive and what information it must return.

The following fixtures are entirely synthetic and make the exercise reproducible without ERP access.

Invoice fixture

{
  "invoiceId": "INV-1042",
  "purchaseOrderId": "PO-2087",
  "caseId": "CASE-1001",
  "invoiceAmount": {
    "currency": "USD",
    "amount": 21400
  },
  "invoiceStatus": "VALIDATION_PENDING",
  "paymentStatus": "UNPAID",
  "matchStatus": "MATCHED",
  "receiptId": "GR-771",
  "receiptStatus": "FULLY_RECEIVED",
  "evidenceTimestamp": "2026-11-17T09:00:00Z"
}

Purchase-order and receipt fixture

{
  "purchaseOrderId": "PO-2087",
  "currency": "USD",
  "grossAmount": 21400,
  "receiptId": "GR-771",
  "receiptStatus": "FULLY_RECEIVED",
  "matchingServiceResult": "MATCHED",
  "matchingRecordId": "MATCH-551",
  "lineChecksCompleted": true
}

The fixture's MATCHED result comes from a simulated deterministic matching service. A production implementation must validate relevant line quantities, unit prices, taxes, currency, prior invoices, and configured tolerances.

Policy fixture

{
  "policyId": "PROC-POLICY-001",
  "activeVersion": "V2",
  "effectiveFrom": "2026-10-01",
  "rules": [
    {
      "ruleId": "AP-DIR-02",
      "condition": "invoiceAmount > 20000",
      "currency": "USD",
      "requiredAction": "DIRECTOR_REVIEW"
    }
  ]
}

In a real solution, the active version should come from the authoritative policy registry, not from an arbitrary model-generated statement.

Phase 2 — Define the handoff contracts

The application-level handoff contract is the information exchanged between the supervisor and each specialist. It is separate from the Oracle Integration action's invocation envelope.

A. Invoice Investigation handoff for the combined policy-exception request

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "taskType": "INVOICE_EVIDENCE",
  "invoiceId": "INV-1042",
  "evidenceAsOf": "2026-11-17T09:00:00Z",
  "requiredFacts": [
    "invoiceStatus",
    "paymentStatus",
    "invoiceAmount",
    "purchaseOrderId",
    "matchStatus",
    "receiptId",
    "receiptStatus"
  ]
}

Expected investigation response

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "specialist": "INVOICE_INVESTIGATION",
  "taskType": "INVOICE_EVIDENCE",
  "resultStatus": "COMPLETE",
  "invoiceId": "INV-1042",
  "invoiceStatus": "VALIDATION_PENDING",
  "paymentStatus": "UNPAID",
  "invoiceAmount": {
    "currency": "USD",
    "amount": 21400
  },
  "purchaseOrderId": "PO-2087",
  "matchStatus": "MATCHED",
  "receiptId": "GR-771",
  "receiptStatus": "FULLY_RECEIVED",
  "evidenceRefs": [
    "INV-1042",
    "MATCH-551",
    "GR-771"
  ],
  "retrievedAt": "2026-11-17T09:00:03Z"
}

B. Policy Interpretation handoff

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "taskType": "POLICY_EXCEPTION",
  "invoiceId": "INV-1042",
  "invoiceAmount": {
    "currency": "USD",
    "amount": 21400
  },
  "activePolicy": {
    "policyId": "PROC-POLICY-001",
    "version": "V2",
    "effectiveFrom": "2026-10-01"
  },
  "policyExcerpt": "Invoices exceeding USD 20000 require director review."
}

The Policy Interpretation handoff uses the same requestId and caseId as the invoice-evidence task because both tasks belong to one user request. Each bridge prepares its own task from authoritative sources before starting its specialist: the Invoice bridge retrieves invoice, PO, receipt, and matching evidence; the Policy bridge retrieves the invoice amount/currency and the active policy version/excerpt from the AP record and policy registry. The invoice specialist also returns the amount from its evidence source; the supervisor cross-checks that result against the authoritative AP value used by the Policy bridge. This keeps the specialists' inputs independently prepared without relying on an LLM-generated amount or policy version.

Keep the identifiers distinct: caseId identifies the business case across the application. requestId identifies this particular user request and correlates the two specialist tasks. conversationId identifies one agent's conversation with OIC; use a separate specialist conversation for each specialist unless continuity within that same specialist is deliberately required. The OIC integration instance ID identifies an integration execution. None of these identifiers is, by itself, proof of user identity or authorization.

Expected policy response

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "specialist": "POLICY_INTERPRETATION",
  "taskType": "POLICY_EXCEPTION",
  "resultStatus": "COMPLETE",
  "invoiceId": "INV-1042",
  "policyId": "PROC-POLICY-001",
  "policyVersion": "V2",
  "ruleId": "AP-DIR-02",
  "interpretation": "REVIEW_REQUIRED",
  "evidenceRef": "POLICY-SIM-V2-AP-DIR-02",
  "effectiveFrom": "2026-10-01"
}

Field lineage for the combined request

Authoritative sourceApplication fieldNext consumer
AP invoice fixture / AP serviceinvoiceId, invoiceStatus, paymentStatus, invoiceAmount.currency, invoiceAmount.amountInvoice task; Policy handoff amount; supervisor cross-check
PO and receipt fixture / matching servicepurchaseOrderId, matchStatus, receiptId, receiptStatus, evidenceRefsInvoice response; supervisor evidence validation
Authoritative policy registrypolicyId, version, effectiveFrom, ruleId, policyExcerptPolicy handoff; then supervisor version validation

Common result envelope: A specialist response must use the same correlation fields and a documented application status. For this exercise, accept COMPLETE for a valid completed finding, NEEDS_REVIEW for an evidence or business ambiguity, FAILED for a technical failure, and TIMED_OUT when the application deadline is exceeded. These are tutorial-defined values, not OIC-native status values.

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "specialist": "POLICY_INTERPRETATION",
  "taskType": "POLICY_EXCEPTION",
  "resultStatus": "FAILED",
  "errorCode": "SPECIALIST_UNAVAILABLE",
  "retryable": true,
  "evidenceRefs": [],
  "retrievedAt": null
}

Use a controlled error code such as SPECIALIST_UNAVAILABLE, INVALID_SPECIALIST_RESPONSE, RESULT_EXTRACTION_UNAVAILABLE, POLICY_VERSION_MISMATCH, or SOURCE_EVIDENCE_MISSING. The integration should validate required fields, types, enumerations, correlation IDs, and evidence ownership before returning COMPLETE. These are tutorial application contracts, not Oracle's built-in JSON schemas. Requesting JSON from a model does not enforce schema validity.

Phase 3 — Create the specialist invocation bridges

For the composed architecture, create two separate integrations:

  • INT_DELEGATE_INVOICE: Accepts an investigation task and targets the Invoice Investigation Agent.
  • INT_DELEGATE_POLICY: Accepts a policy interpretation task and targets the Policy Interpretation Agent.

Each bridge is an integration registered as an agentic AI tool. Because it will be registered as a tool, create it inside an OIC project, make it active, and configure its first connection as a REST Adapter trigger with OAuth authentication and a JSON request/response contract. Oracle documents GET, POST, PUT, DELETE, and PATCH as supported REST Adapter trigger verbs; use POST for these task-submission examples.

OIC configuration sequence

  1. In the project, create the integration with a REST Adapter trigger as its first connection. Configure OAuth and JSON. Define the request fields used by the application contract and a JSON response body for the result envelope.
  2. Add an AI Agent action to the integration.
  3. Select the current project or an eligible shared project, then select the intended active specialist agent.
  4. Map the task-specific prompt, or map the Prompt Template ID and its stringified JSON Payload. These are alternative invocation forms.
  5. Generate and persist an opaque, unique specialist conversation ID for this request and specialist. Map it to the Start AI Agent action's optional Conversation ID input. Supplying it explicitly allows the following Activity Stream action to query the same conversation without guessing an automatically generated identifier.
  6. Add a second AI Agent action configured as Get AI Agent Activity Stream. Map the same specialist conversation ID into this action.
  7. Apply a bounded completion-check policy. If the conversation is still active, wait and check again within the configured deadline. If the status is terminal, proceed to the result-mapping verification described below. Do not invent native OIC status strings; record the actual values observed in the target release and map them to the application states defined later in this article.
  8. Map the verified specialist result into the REST trigger's application response contract, add fault handling, validate, save, and activate the integration.

Prerequisites are not optional: an integration registered as an agentic AI tool must be in a project and active; its first connection must be a REST Adapter trigger; and that trigger must use OAuth authentication and a JSON payload. See Oracle's agentic AI tool registration procedure.

The documented AI Agent action accepts the following information:

ParameterDecision
Project IDOptional override when targeting another eligible project.
Agent IDOptional override for the selected specialist agent.
Conversation IDOptional. Omit when a new specialist conversation should be created.
PromptDirect task instruction.
Prompt Template IDOptional template identifier and version.
PayloadStringified JSON when using a prompt template.

You must provide either a direct Prompt or a Prompt Template ID with its Payload. Do not treat the application's JSON contract as the action's raw request envelope. The integration mapper is responsible for translating between them.

Example prompt for the investigation specialist:

Investigate the supplied invoice using only the
evidence provided by the authorized tools.

Return the requested invoice status, payment status,
matching result, receipt status and evidence references.

Do not interpret procurement policy.
Do not approve or release payment.
Do not invent missing evidence.
Identify incomplete or stale source information.

Result-mapping boundary: The Start AI Agent procedure documents the project/agent selection and invocation inputs, including an optional Conversation ID. The Get AI Agent Activity Stream procedure documents retrieval by Conversation ID and says the response indicates the agent's current status. Oracle's separate asynchronous-tool callback example shows the tool call, tool response, and final LLM answer in the agent activity stream. That example establishes that the answer is visible in the activity stream experience; it does not publish a stable mapper element or schema for extracting that final answer from the Start action.

Therefore, this design uses a two-part completion check: (1) the Activity Stream confirms that the specialist conversation has reached a terminal state; and (2) the bridge's mapper is inspected in the target tenant to establish how the final response can be extracted and converted into the application JSON contract. If the final response is not exposed through a supported mapping, return RESULT_EXTRACTION_UNAVAILABLE and keep this exercise at the fixture/design level. Do not parse a display-only string, invent an XML path, or fabricate a successful specialist result.

For this article's fixture exercise, the synthetic specialist responses stand in for the bridge's eventual application response. This permits routing, data lineage, validation, and reconciliation to be evaluated without claiming that the unresolved result-mapping step has been executed.

Phase 4 — Register the integrations as supervisor tools

Once the bridge integrations are active, register them as agentic AI tools.

Documented starting location: Projects → select project → Integrations → Actions → Create agentic AI tool.

Oracle documents the following tool configuration properties:

  • Name: automatically populated from the integration name and not sent to the LLM.
  • Identifier: identifies the tool and is sent as LLM metadata.
  • Description: explains the tool's purpose and when it should be used.
  • Guidelines: additional behavioral constraints sent as part of the system prompt.
  • Parameters configuration: controls which parameters are visible to the LLM, required, constant, defaulted, or restricted to specified enumeration values.

Use the following tool descriptions.

Tool 1 — delegate_invoice_investigation

Purpose:
Investigate the current operational state and evidence for one invoice.

Usage:
Use for invoice status, payment status, amount, PO matching
and receipt evidence.

Required inputs:
caseId, requestId, invoiceId.

Expected result:
Invoice status, payment status, amount and currency, PO/receipt
facts, evidence references and retrieval timestamp.

Restrictions:
Read-only investigation.
Use authorized source records; do not infer matching.
Do not interpret policy or approve/release payments.
Do not return information for another case.

Tool 2 — delegate_policy_interpretation

Purpose:
Interpret the policy applicable to one validated invoice case.

Usage:
Use for policy exceptions, additional review or policy-based escalation.

Required inputs:
caseId, requestId, invoiceId.

Data loaded by the bridge:
Validated invoice amount/currency and the active policy
snapshot from authoritative application sources.

Expected result:
Policy identifier, version, rule, effective date,
interpretation and source evidence reference.

Restrictions:
Do not trust model-supplied amount or policy version as authoritative.
Do not determine invoice operational status.
Do not approve or release payments.
Never silently substitute an older policy version.

For each tool, expose only the business inputs needed to select and scope the task. In this example, the supervisor supplies the request/case/invoice correlation values; the bridge validates them against the application record. The coordinator or Policy bridge reads the invoice amount and active policy snapshot from authoritative sources before invoking the policy specialist. The supervisor later cross-checks the specialist's result against those records. Internal integration instance identifiers, specialist conversation IDs, secrets, authorization tokens, technical connection data and unrelated customer information must not become model-visible parameters.

Mark required parameters as required so the agentic tool definition communicates that they must be supplied. Use constants for genuinely fixed values, and use defaults only where absence has a safe, unambiguous meaning.

Descriptions and guidelines influence tool selection. They do not enforce backend authorization or business correctness.

Phase 5 — Configure the Supervisor Agent's decision policy

The Supervisor Agent should have access to the two registered tools, not every integration in the project.

Its instructions should define a decision policy similar to this:

ROLE

You are the Supervisor Agent for invoice investigation
and policy interpretation.

ROUTING

1. For invoice status and operational questions,
   delegate only to delegate_invoice_investigation.

2. For questions about policy exceptions, additional
   approval or director review, obtain both:
   a. Invoice investigation evidence.
   b. Policy interpretation.

3. For a combined question, obtain both specialists'
   results before providing a combined conclusion.

EVIDENCE

Preserve caseId and requestId in every delegation.
Use the supplied authoritative evidence references.
Check the policy version and effective date.
Distinguish business facts from policy interpretation.

CONFLICTS

Do not choose a result merely because a specialist
sounds more confident.
Do not use a result from an outdated policy version.
If authoritative evidence conflicts, return
NEEDS_REVIEW.

TERMINATION

Do not recursively delegate.
Do not call the same specialist repeatedly.
Do not invent missing specialist results.
Do not claim completion when required evidence is absent.

BOUNDARIES

You are read-only.
Never authorize or release an invoice payment.
Never turn a recommendation into a committed business action.

These instructions guide the supervisor's reasoning. The delegation ledger and integration-side validation must independently enforce the actual call budget and permissions.

Phase 6 — Build the case and delegation control

The integration layer needs a small durable record for each request. For example:

{
  "requestId": "REQ-8843",
  "caseId": "CASE-1001",
  "caseStatus": "INVESTIGATING",
  "delegationDepth": 0,
  "maximumDelegationDepth": 1,
  "maximumDistinctSpecialistTasks": 2,
  "policyVersion": "V2",
  "specialistTasks": {
    "INVOICE_INVESTIGATION": {
      "taskStatus": "IN_PROGRESS",
      "attemptCount": 1,
      "conversationId": "<opaque-invoice-conversation-id>",
      "idempotencyKey": "REQ-8843|INVOICE_INVESTIGATION|INVOICE_EVIDENCE"
    },
    "POLICY_INTERPRETATION": {
      "taskStatus": "NOT_STARTED",
      "attemptCount": 0,
      "conversationId": null,
      "idempotencyKey": "REQ-8843|POLICY_INTERPRETATION|POLICY_EXCEPTION"
    }
  }
}

This is an illustrative application record, not an Oracle-managed supervisor state object. The conversation ID is an opaque identifier generated and persisted by the application before the Start AI Agent action is called. Do not use the placeholder literally.

Define the state transitions explicitly. At the case level, use RECEIVED → INVESTIGATING → VALIDATING → COMPLETED, with terminal alternatives NEEDS_REVIEW or FAILED. At the individual specialist-task level, use NOT_STARTED → IN_PROGRESS → COMPLETED, with outcomes NEEDS_REVIEW, FAILED, or TIMED_OUT when a task cannot complete normally. These are application states, not native OIC agent-status enumerations.

Move a task to COMPLETED only after the response contract and its evidence have passed validation. A successful invocation or a terminal conversation status alone is not sufficient. Do not mark the case COMPLETED until all required specialist tasks have a validated result and the supervisor has reconciled them.

Retry transition: A task in FAILED or TIMED_OUT may return to IN_PROGRESS only when its validated error is marked retryable, the attempt budget remains, and the prior invocation has been reconciled. Increment attemptCount and retain the previous attempt's conversation and integration-instance identifiers. Do not automatically retry NEEDS_REVIEW; that outcome requires new authoritative evidence or an explicit human decision.

Before accepting a delegation, the wrapper integration should verify:

  1. The request ID and case ID belong together.
  2. The requested specialist is in the allowed list.
  3. The specialist has not already completed the same task for that request.
  4. The call budget and delegation depth have not been exceeded.
  5. The supplied evidence references belong to the permitted case.

Update the case record when a task is accepted, started, completed, failed, or timed out. Use an idempotency key such as requestId + specialistId + taskType to identify one logical task. Keep attemptCount and each runtime integration instance ID separately so a retry is visible rather than mistaken for a new business task.

The two-specialist budget counts distinct logical specialist tasks for one request. Configure a separate bounded retry policy for transient failures. A retry consumes that attempt budget and must first check whether the earlier conversation is still running or already completed; never automatically repeat an ambiguous invocation. Use the same logical idempotency key for a retry, and retain the attempt-specific conversation/instance correlation needed for diagnosis.

Phase 7 — Validate the specialist result before aggregation

A specialist's text response is not automatically an authoritative business outcome.

Before accepting a result, validate:

  • Correct case ID and request ID.
  • Expected specialist identity and task type.
  • Presence and validity of required response fields.
  • Allowed enumeration values and data types.
  • Evidence reference membership in the case's supplied or retrieved evidence.
  • Retrieval timestamps and applicable evidence freshness requirements.
  • Policy identifier, version and effective date against the authoritative active-policy record.

Consider the following stale-evidence variation.

The Policy Interpretation Agent returns a result citing V1. The authoritative case record identifies V2 as the active policy. The supervisor must not use the older interpretation, even if the answer is otherwise persuasive.

The deterministic validation outcome should be:

{
  "caseId": "CASE-1001",
  "resultStatus": "NEEDS_REVIEW",
  "reason": "POLICY_VERSION_MISMATCH",
  "expectedPolicyVersion": "V2",
  "receivedPolicyVersion": "V1",
  "recommendation": "WITHHELD",
  "paymentAction": "NOT_REQUESTED"
}

The correct response is not to choose V1 or V2 based on model confidence. The result is withheld until the current authoritative policy evidence is available.

Phase 8 — Handle asynchronous work and completion

Oracle's Get AI Agent Activity Stream action retrieves an agent's activity stream by Conversation ID, and its response indicates the current agent status. In this design, the bridge supplies the Conversation ID explicitly to the Start AI Agent action and reuses that same value for each Activity Stream check. Apply a bounded polling deadline at the application layer. Store the native status returned by OIC, and map it to the tutorial's application states only after checking the actual status values in the target release.

Do not confuse two different completion mechanisms:

  • Specialist completion: The specialist agent started by the bridge finishes its own conversation. The bridge checks that conversation with Get AI Agent Activity Stream and must extract the specialist's final result through a mapper path verified in the target tenancy.
  • Asynchronous tool callback: When the Supervisor Agent invokes a registered tool integration that is configured for asynchronous execution, the supervisor conversation enters Waiting for tool to process. The integration later uses the AI Agent action configured as Callback AI agent to return the tool response to the waiting supervisor conversation. This callback resumes the caller's pending tool call; it is not a generic agent-to-agent message and does not, by itself, extract the specialist's final answer.

For the asynchronous-tool callback pattern, Oracle documents the x-agentic-callback-uri trigger header as a way to obtain the waiting agent's conversation ID. The callback mapping requires Conversation ID, Tool Flow ID, Tool Invoke Event ID, and Payload. Tool Flow ID and Tool Invoke Event ID must both be mapped; Oracle's procedure says the runtime instance ID of the agentic tool integration is used for both. Persist these correlation values with the task until the callback completes.

Use the asynchronous callback route only when the registered supervisor tool is actually configured for asynchronous execution. Do not apply it to an ordinary synchronous tool response, and do not send a callback to the specialist conversation when the intended recipient is the supervisor's waiting tool invocation.

Do not treat any of the following as equivalent:

  • The invocation was accepted.
  • The specialist has completed its reasoning.
  • The specialist's final answer was extracted.
  • The answer passed deterministic validation.
  • The business case is complete.

Each is a separate observable milestone.

Result extraction limitation: Oracle's documented asynchronous-tool example shows the tool call, tool response, and final LLM answer in the agent activity stream. The Start AI Agent procedure does not publish a universal mapper field path for the final assistant answer. A bridge is complete only after its actual response mapping has been inspected and tested in the target release. If no supported machine-readable result is available, return RESULT_EXTRACTION_UNAVAILABLE, mark the task unresolved, and do not present the fixture as a live agent result.

Phase 9 — Where can independent calls run concurrently?

Consider a policy-exception request where investigation and policy interpretation are independent after the supervisor has prepared their respective input contracts.

OIC supports a Parallel action for independent integration branches. The branches execute concurrently, synchronize at their termination points, and make their available branch variables usable by the main integration path.

For this architecture, the possible design is:

  1. The parent integration validates the case and prepares both handoff contracts.
  2. Two independent child integrations invoke their respective specialists.
  3. The child integrations return verified application-level result contracts.
  4. The parent integration waits for branch completion.
  5. The parent validates and reconciles both results.

There is an important OIC design-time restriction: Parallel action branches support particular action types and invoke connections. Do not assume the AI Agent action itself is a permitted branch action. Place agent invocation in child integrations and invoke those child integrations from supported parallel branches, subject to validation in the target release.

OIC's documented parallel integration behavior is not proof that a model-driven Supervisor Agent can issue concurrent specialist tool calls. This article does not assume that capability.

Also, only parallelize read-only tasks that have independent inputs. Shared writes, mutable case updates, and competing policy changes require explicit synchronization or serialization.

Phase 10 — Add external agent connectivity using MCP

Model Context Protocol (MCP) is a standard protocol through which an MCP client discovers and invokes tools exposed by an MCP server.

Oracle Integration supports exposing registered agentic AI tool integrations through a project's MCP server.

Architecture distinction:

  • External MCP client to OIC: An external agent framework or MCP client discovers and invokes an OIC integration.
  • OIC to external MCP server: An OIC project can configure an MCP Gateway to manage external MCP server connections.
  • Agent-to-agent collaboration: A separate coordination protocol or architecture. MCP does not create it automatically.

For the external-client example, follow this OIC setup.

Step 1 — Prepare the integration

The integration must be inside a project, active, and configured with a REST Adapter trigger as its first connection. Its trigger uses OAuth authentication and a JSON payload. Oracle documents support for the REST Adapter's supported HTTP verbs, including GET, POST, PUT, DELETE, and PATCH.

Step 2 — Register the integration

In the project workspace, use Actions → Create agentic AI tool. Give the tool a meaningful identifier and description, configure its guidelines and expose only the necessary input parameters.

Step 3 — Enable MCP

Open Projects, select the project, edit the project details, select Enable MCP server, and save the changes. The project-specific MCP server URL becomes available in the project details.

Step 4 — Configure OAuth

Oracle documents a confidential client application for MCP access. The setup requires appropriate scopes and the ServiceInvoker role at a minimum. The application must be activated, and its client credentials must be used to obtain an access token. Tenant/domain administrator involvement is required for confidential client configuration.

Step 5 — Connect an MCP client

Oracle documents Streamable HTTP as the transport for discovering integrations through project MCP servers. Under the published 2025-11-25 Streamable HTTP specification used in the example below, each JSON-RPC message is sent in its own HTTP POST request. The runtime URL format is:

https://<service-instance>.integration.<region>.ocp.oraclecloud.com/mcp-server/v1/projects/<project-name>/mcp

Optional client-side JSON-RPC example

The examples below use the published MCP 2025-11-25 protocol revision to illustrate the request sequence. This is not a claim that every OIC endpoint negotiates that revision. The client must use a protocol version supported and returned during initialization. Oracle's OIC documentation specifies Streamable HTTP and the supported project operations; it does not identify a universal negotiated MCP revision for every tenancy.

Request 1 — Initialize

POST https://<service-instance>.integration.<region>.ocp.oraclecloud.com/mcp-server/v1/projects/AP_PROJECT/mcp
Authorization: Bearer <access_token>
Content-Type: application/json
Accept: application/json, text/event-stream

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "initialize",
  "params": {
    "protocolVersion": "2025-11-25",
    "capabilities": {},
    "clientInfo": {
      "name": "ap-mcp-demo",
      "version": "1.0.0"
    }
  }
}

Read the initialization response and use the protocol version the server actually negotiated. The server may also return an MCP-Session-Id response header. Preserve it and send it on every subsequent request when present. Do not invent a session ID if the server did not return one.

Request 2 — Send the initialized notification

POST https://<service-instance>.integration.<region>.ocp.oraclecloud.com/mcp-server/v1/projects/AP_PROJECT/mcp
Authorization: Bearer <access_token>
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: <negotiated-protocol-version>
MCP-Session-Id: <session-id-if-returned>

{
  "jsonrpc": "2.0",
  "method": "notifications/initialized"
}

This notification is a separate HTTP POST with one JSON-RPC message in its body. The Streamable HTTP specification defines HTTP 202 Accepted with no body as the normal acknowledgement for an accepted notification. Omit the MCP-Session-Id header only when the server did not issue a session ID.

Request 3 — Discover tools

POST https://<service-instance>.integration.<region>.ocp.oraclecloud.com/mcp-server/v1/projects/AP_PROJECT/mcp
Authorization: Bearer <access_token>
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: <negotiated-protocol-version>
MCP-Session-Id: <session-id-if-returned>

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/list",
  "params": {}
}

The response contains the tool names, descriptions, and input schemas exposed by the project. Use the exact tool name returned by this request.

Request 4 — Invoke a discovered tool

POST https://<service-instance>.integration.<region>.ocp.oraclecloud.com/mcp-server/v1/projects/AP_PROJECT/mcp
Authorization: Bearer <access_token>
Content-Type: application/json
Accept: application/json, text/event-stream
MCP-Protocol-Version: <negotiated-protocol-version>
MCP-Session-Id: <session-id-if-returned>

{
  "jsonrpc": "2.0",
  "id": 3,
  "method": "tools/call",
  "params": {
    "name": "GET_INVOICE_SUMMARY",
    "arguments": {
      "invoiceId": "INV-1042"
    }
  }
}

Each block is a separate HTTP request; do not concatenate the JSON-RPC objects into one request body. For a 2025-11-25 Streamable HTTP client, include Accept: application/json, text/event-stream on each POST and include MCP-Protocol-Version on subsequent requests using the negotiated revision. Preserve the MCP-Session-Id header if supplied by the server. A request may receive either a JSON response or an SSE stream, so a compliant client must handle both. An accepted notification normally receives HTTP 202 with no response body. Parse the JSON-RPC result and inspect result.isError or a JSON-RPC error object; HTTP success alone does not prove that the underlying business operation succeeded.

This external connection proves only that an external MCP client can discover and invoke the registered integration. It does not establish shared agent memory, automatic supervisor delegation, or an agent-to-agent protocol.

OIC's supported project MCP operations are tools/list and tools/call. Do not assume the same project MCP server exposes every optional capability defined by the wider MCP specification.

6. Test and Prove It

Use synthetic specialist responses and the fixtures established earlier. These are design checks, not executed OIC tests.

Test caseExpected behaviorEvidence to inspect
Positive: Invoice status request Only the investigation specialist is selected. A valid operational status is returned. Supervisor activity, selected tool, specialist inputs, source IDs, returned result.
Positive: Policy-exception request Both specialists contribute. Current V2 policy establishes that director review is required. Both specialist results, active version, validation outcome, final response.
Boundary: Stale policy result A V1 result is rejected when V2 is active. Return NEEDS_REVIEW. Expected and received policy versions, rejected result, case status.
Failure: Policy specialist unavailable The supervisor can report valid investigation facts but cannot claim the policy exception is resolved. Integration fault, specialist status, outstanding task, final unresolved response.
Misuse: Repeat or cross-case delegation Duplicate task or incorrect case association is rejected. Delegation ledger, case correlation, idempotency validation.

Execution status: Not executed. All outputs are illustrative fixtures. A real validation must include the actual OIC agent run, integration instances, mapped specialist response, and backend evidence. Also prove each state transition: task accepted, specialist in progress, specialist terminal, response extracted, response contract validated, and case completed or moved to a controlled unresolved state.

What does a genuine disagreement look like?

Suppose the investigation agent reports that all invoice and receipt checks are matched, while the policy specialist reports that director review is required.

These findings are not necessarily conflicting. Matching and policy review are different business questions.

Now suppose the Policy Interpretation Agent cites V1, while the current authoritative policy record says V2.

This is a genuine evidence conflict. The supervisor should return:

NEEDS_REVIEW — Policy evidence conflict

The invoice investigation is complete, but the policy interpretation is based on an outdated version. The current policy version must be retrieved and validated before a recommendation on director review can be provided.

Payment recommendation: Withheld. No transaction executed.

This is better than asking the supervisor to select whichever specialist reports the highest confidence score.

7. Troubleshooting and Recovery

SymptomLikely layerTargeted check and correction
Specialist is not available for selection.Agent configuration.Verify the specialist's active status and selected current/shared project.
Supervisor chooses the wrong tool.Tool metadata.Review identifier, description, guidelines, and visible parameter definitions.
Specialist starts, but its answer is unavailable.Invocation/completion bridge.Inspect agent status, activity stream, completion mechanism, and actual output mapping.
Agent waits indefinitely for a tool.Asynchronous continuation.Check callback conversation ID, tool flow ID, tool invoke event ID and response payload.
Results appear to belong to another case.Context and case management.Inspect request ID, case ID, evidence ownership, and conversation reuse.
External client cannot discover tools.MCP and OAuth.Check MCP enablement, project tool registration, server URL, token, ServiceInvoker role and transport.

For failed specialist calls, retain the case and task correlation records. Do not automatically repeat an ambiguous invocation without checking whether the original call completed. Reuse the same idempotency key for a legitimate retry of the same read-only task.

8. Enterprise Considerations

Identity and permissions

Agent conversation identifiers and case identifiers are not authorization credentials. A specialist should only access the evidence permitted by its configured integration and security identity. Do not assume that an end user's permissions automatically travel through a conversation ID or an integration bridge.

Use least-privilege tool integrations, project-level access control, and backend authorization. If individual user identity must be propagated, explicitly implement and test a supported identity-propagation arrangement.

Context size and freshness

Pass evidence summaries, source identifiers, timestamps, and relevant excerpts instead of entire transcripts or unrestricted invoice attachments. Store large supporting evidence outside the agent's working context.

Define a freshness policy for each evidence category. A current invoice status, a receipt record, and a policy document may have different update frequencies and validity requirements. Reject stale evidence according to those rules rather than using an arbitrary universal age.

Conflicting evidence and failure ownership

The specialist owns its interpretation or investigation. The integration layer owns deterministic validation, task correlation, authorization, budgets, and recovery. The supervisor owns the consolidated explanation, not the authoritative source records.

Record which specialists were requested, which completed, their evidence references, the active policy version, the validation result, and the final recommendation status. This provides a useful audit trail without assuming that OIC automatically creates a complete distributed agent trace.

MCP exposure and external connectivity

Only expose the integrations needed by an external agent framework. A project MCP server makes registered agentic AI tools discoverable through MCP, but the scope of those tools is still governed by their own application and security design.

Similarly, an MCP Gateway is not a supervisor. It manages MCP server connections and related gateway capabilities; it does not become a shared memory layer or a multi-agent coordinator by itself.

9. Completion Checklist and What Comes Next

The design is ready for a tenant implementation review when the following deliverables exist:

  • Supervisor routing rules for status and policy-exception requests.
  • Two specialist responsibilities and explicit handoff contracts.
  • Two integration bridge designs targeting the appropriate active agents.
  • Tool descriptions, guidelines, visible parameters, and restrictions.
  • A durable case-state and delegation-budget design.
  • A result-validation and policy-version conflict strategy.
  • A defined specialist completion and result-extraction mechanism.
  • An optional external MCP connection design.

Remaining implementation dependency: Verify the specialist's final-answer extraction from the Activity Stream output in the target tenant, then prove the bridge maps that result into its REST response contract and returns it to the supervisor tool call. Until that full return path and its completion behavior are demonstrated, the fixture exercise proves the architecture, data lineage, and decision contract—not fully automated specialist coordination.

What has deliberately been deferred: Privileged payment execution, approval workflows, distributed transaction handling, and unrestricted supervisor hierarchies. They are not necessary to demonstrate bounded dynamic delegation.

10. Five Useful FAQs

1. Is a supervisor agent the same as a ReAct agent?

No. ReAct describes a thinking pattern used by an individual agent. Supervisor describes its architectural responsibility for delegating and consolidating work. A supervisor may itself use ReAct, but the thinking pattern does not automatically create specialist agents.

2. Can an OIC specialist automatically read the supervisor's conversation history?

Do not assume so. OIC documents conversation history associated with an agent's conversation ID. Pass the required specialist context explicitly, and maintain durable case data separately. Sharing a business case ID does not share the conversational transcript.

3. Can an OIC integration invoke another AI agent?

Yes. Oracle documents the AI Agent action for starting an active agent from an integration, including selecting an agent in the current or a shared project. You can compose this into a specialist invocation bridge. The completed-result extraction and response mapping must also be verified before claiming the full bridge works end to end.

4. Can MCP make two agents collaborate automatically?

No. MCP lets clients discover and call tools. It does not automatically create a supervisor, coordinate agents, synchronize conversations, or provide durable case memory. Those responsibilities belong to the surrounding application architecture.

5. Should both specialists always run in parallel?

No. Use investigation alone for a status request. Use both specialists when policy interpretation actually depends on invoice evidence. For independent calls, an OIC Parallel action can coordinate supported integration branches, but concurrent model-driven tool invocation should not be assumed without separate verification.

11. Verified References

The following primary documentation was inspected for this article. Release context and exact applicability are noted where relevant.

  1. Oracle — Using Agentic AI in Oracle Integration 3.
    Official documentation, guide G41284-23, October 2026.
    Project AI Agents, integration tools, patterns, and MCP.
  2. Oracle — Invoke an AI Agent from an Integration.
    Read the official procedure.
    Start action, project/agent selection, prompt, template payload, and conversation ID.
  3. Oracle — Get the Activity Stream for an AI Agent.
    Read the official procedure.
    Status retrieval through the AI Agent action.
  4. Oracle — Run an AI Agent with Knowledge of Previous Runs.
    Read the official procedure.
    Conversation IDs and continuity across runs.
  5. Oracle — Use Case: Send a Callback to an AI Agent for an Asynchronous Tool.
    Read the official example.
    Shows the waiting state, callback return, and resulting agent activity stream.
  6. Oracle — Send a Response to an AI Agent with a Callback.
    Read the official procedure.
    Asynchronous agentic tool continuation and callback correlation fields.
  7. Oracle — Register an Integration as an Agentic AI Tool.
    Read the official procedure.
    REST trigger prerequisites, tool descriptions, guidelines, and parameter visibility.
  8. Oracle — Enable MCP for the Project.
    Read the official procedure.
  9. Oracle — Discover Integrations as Tools from MCP Clients.
    Read the official procedure.
    Streamable HTTP and project MCP server connection requirements.
  10. Oracle — FAQs for Projects as MCP Servers.
    Read the official FAQs.
    Supported MCP operations and OAuth requirements.
  11. Oracle — Process Tasks in Parallel with a Parallel Action.
    Read the official procedure.
    Parallel branches, supported actions, synchronization, and restrictions.
  12. Oracle — Agentic AI Issues.
    Read current known issues.
    Includes MCP URL and conversation-ID considerations.
  13. Oracle — September 2026 (26.10) release information.
    Read the 26.10 release context.
  14. Model Context Protocol — Streamable HTTP.
    Read the protocol specification.
  15. Model Context Protocol — Tools.
    Read the protocol specification.
    Tools/list, tools/call, schemas, tool results, and error handling.

12. Finally — Summary

A useful multi-agent system is not defined by how many agents it contains, but by how effectively responsibility and evidence are coordinated. You have designed a supervisor that selects only the specialists required by a request, established explicit task and response contracts, separated conversation history from durable business state, and defined bounded delegation and conflict handling. You have also seen how OIC integration actions can compose agent invocations and how project MCP servers expose registered integrations to external clients. The most important engineering lesson is this: delegation is not complete when a specialist starts; it is complete only when its evidence is retrieved, validated, correlated, and accepted.

Comments