Skip to main content

OIC AI Agents: Prepare Your Project, Model Route, and Starter Integration

Calculating read time…

Prepare a reusable OIC Project AI Agents environment, verify an approved model connection, activate the ReAct pattern variant supported by that route, and build a deterministic order-status integration that can become an agent tool in the next module.

The lab uses fictional purchase orders and a read-only lookup. It establishes a repeatable starting point for the Procurement Exception Assistant without creating an AI agent prematurely or assuming that a configured model connection proves that an agent works.

1. What You Will Build

You will prepare three reusable assets inside an Oracle Integration project:

  • An isolated training project with an identifiable owner and consistent naming conventions.
  • An active ReAct thinking pattern associated with one supported, approved language-model route.
  • An active REST integration that returns predictable order-status results for known, unknown, and invalid order numbers.

For example, the integration receives this request:

{
  "orderNumber": "PO-1001"
}

Its deterministic response is:

{
  "orderNumber": "PO-1001",
  "found": true,
  "status": "SHIPPED",
  "expectedDeliveryDate": "2026-10-25",
  "message": "Order found."
}

Completion boundary: this module prepares the first-build environment. An active thinking pattern and a working integration do not constitute a completed AI agent. The next module will associate an agent with the pattern and make the integration available to it as a tool.

2. In This Post

3. Before You Begin

These are the prerequisites that can actually block this lab. You do not need to relearn ordinary OIC orchestration, REST mapping, or activation procedures.

  • CORE — Licensed environment: Oracle Integration 3 in an edition entitled to use Agentic AI.
  • CORE — Project access: a service role with developer privileges and appropriate access to create and edit project resources.
  • CORE — Approved model route: the provider, model identifier, endpoint, authentication method, and permission to transmit the intended test data.
  • CORE — Credentials: valid model-provider credentials or the required OCI Generative AI configuration, according to the chosen route.
  • CORE — Test client: a way to invoke and inspect the REST integration, including OAuth authentication for its trigger.

Check the licence before troubleshooting the UI.

Oracle's current edition comparison lists Agentic AI as unavailable in Standard edition and available in Enterprise and Healthcare editions. The feature-availability page lists Agentic AI across Oracle Integration regions. That does not establish your tenant's edition, entitlement, actual release, or access permissions. Confirm those facts with the instance administrator before treating a missing feature as a configuration defect.

Oracle Integration Editions · AI Feature Availability

3.1 Confirm permissions and ownership

Oracle Integration combines service roles with project-level permissions. A project permission cannot grant capabilities that the assigned service role does not allow. For example, a project monitor cannot become a developer simply by being given a project-level editor permission.

For this lab, request a developer-capable service role and Owner or Editor access to the training project. An owner can also administer project access; an editor can create and edit project resources within the permissions allowed by their service role.

Oracle's general project-access documentation describes these permissions, but the inspected pattern-configuration pages do not identify a separate, universal Agentic-AI-only service role. If a specific create or activate action is denied, have the administrator inspect the effective service role and project permission rather than granting unrestricted access automatically.

Oracle documentation: project access control

4. Concepts That Affect This Build

4.1 A model route is not a thinking pattern

The model route determines which language-model service processes the agent's requests. The thinking pattern determines the reasoning and action strategy that the agent follows. Both matter, and the pattern must be compatible with the chosen provider route.

Component What it controls What you must verify
Provider The model service receiving requests. Organizational approval, endpoint access, and data-handling requirements.
Model identifier The specific model requested from that service. The identifier is supported by the selected endpoint and works with the intended API.
Base URL or endpoint The destination used to reach the model service. The exact endpoint format required by the chosen route.
Authentication How OIC authenticates to the provider. Valid credentials and the provider's required authorization.
Thinking pattern How the agent decides whether and how to take actions. Provider compatibility, settings, and active status.

Oracle documents generic ReAct and Plan patterns for OpenAI, Anthropic, and Azure using the OpenAI adapter's chat-completions API. OCI Generative AI uses separate pattern variants. Do not select a generic ReAct pattern merely because the desired model is described as compatible with OpenAI-style APIs; confirm that the particular provider route is supported by Oracle's documented configuration.

Approved route Pattern to select Principal configuration
OpenAI, Anthropic, or Azure ReAct Base URL, model identifier, API-key authentication, and connection test.
OCI Generative AI ReAct for OCI GenAI OCI model type, the required OCI configuration, compartment, and region.

Source: supported language models · OCI-specific ReAct procedure

How to select the model: first apply the organization's provider, data-residency, privacy, retention, and security requirements. Then verify supported API compatibility and model availability. Compare expected tool-selection quality, structured-argument reliability, latency, and cost using representative test cases. A cheap, fast model that repeatedly chooses incorrect tools may be more expensive operationally than a better-performing alternative.

A successful connection test shows that the configured connection can communicate successfully under the test conditions. It does not prove that the model will reliably choose a tool, pass correct arguments, obey business policy, or provide a truthful final answer.

4.2 ReAct versus Plan and Execute

A thinking pattern is a model-facing strategy for carrying out the task. It is not the model itself, a business integration, or an authorization mechanism.

ReAct — Reason and Act: the agent requests the next action, observes the result, and decides what to do next. It can adapt its next move when the available information changes. This is useful when developing a new workflow whose branches are not yet fully understood.

For example, an order-status assistant could query a status tool, examine the returned status, and decide what information to communicate. If a future version adds a second read-only tool for shipment details, the next decision could depend on the first result.

Plan and Execute: Oracle documents a two-agent arrangement. The planner creates an ordered plan of tool calls; the acting agent carries out the specified steps. The acting agent does not independently skip, reorder, or choose a different tool for a planned step. This can be appropriate when the process and required sequence are known beforehand and an explicit sequence is important.

Planning does not make a workflow correct by itself. A flawed plan can lead to flawed execution, and required business validations and access controls must still exist outside the model.

For the generic OpenAI, Anthropic, or Azure route used in the main click-through, select ReAct. For OCI Generative AI, select ReAct for OCI GenAI and follow its separate configuration procedure. ReAct supports learning how an agent chooses actions and adapts to tool responses without prematurely committing to a fixed multi-step sequence. Oracle's pattern guidance also recommends prototyping new use cases with ReAct before considering Plan and Execute once the workflow is better understood.

Oracle documentation: choosing an agentic AI pattern

4.3 Maximum iterations: a bound on reasoning and action

What it governs: Oracle describes Max iterations as limiting the reasoning and action steps an agent can take before providing a final answer or exiting. Its purpose is to put a limit on repetitive or unproductive execution.

Why it matters: an agent might repeatedly reconsider a result, attempt further actions, or fail to reach a useful conclusion. A limit constrains the opportunity for that behavior, although it does not guarantee that an agent will terminate safely or produce a correct answer.

Do not confuse a conceptual cycle with Oracle's exact counter. A conceptual ReAct cycle is a sequence in which an agent decides on an action, receives an observation, and uses that observation to decide what comes next. Oracle's public configuration description refers to reasoning and action steps, but the inspected documentation does not precisely specify the internal iteration-counting algorithm. It does not establish that one business-tool invocation equals exactly one iteration or clarify every end-of-limit behavior.

Choosing an initial value

For the first lab, retain the Max iterations value initially displayed by the pattern configuration. Oracle's current guide illustrates a value of 10 and gives broader guidance of 10–15 for most tasks and 20–25 for deep investigation. These are documented guide values, not a published universal allowed range, guaranteed default, or promise about how many tool calls can occur.

For one order lookup, a large investigative budget is not justified by the intended task complexity. However, setting the limit too low before seeing actual runtime behavior could prevent task completion. Setting it unnecessarily high can permit more model activity, increasing latency and model usage and potentially allowing repeated actions.

How to calibrate it: after an agent and tool are available, run representative traces. Inspect which tool was selected, the arguments, returned observations, the number and order of observable actions, whether the task reached a valid stopping point, and why any run terminated. If a run stops before obtaining its required evidence, determine whether the cause was the limit, an incorrect tool decision, or a tool failure before changing the setting. Increase capacity only when observed task complexity justifies it.

Boundary for this module: the integration and model route can be tested now, but the appropriate runtime iteration limit cannot be demonstrated without executing an actual agent. That calibration is deferred to the first-agent module.

4.4 Guidelines are not enforcement

The pattern's Guidelines tell the model how to follow the selected reasoning strategy. The pattern recipe defines the reasoning approach; its guidelines explain how to apply that approach. They are not the same as the agent's business instructions or a tool's description.

Keep the default pattern guidelines for the first lab unless the documented behavior needs a deliberate change. In the future agent module, business instructions will specify the assistant's role, scope, response rules, and how it should use the tools. Tool metadata will explain each integration's purpose and exposed parameters.

Prompts influence model behavior; they do not enforce authorization, guarantee input validity, or prove that a transaction succeeded. Enforce access, validation, and transaction rules in the relevant OIC integration and target system.

5. Build and Configure

Step 1 — Verify the environment and access

Starting point: sign in to the Oracle Integration instance intended for the lab.

  1. Confirm the instance edition and entitlement with the administrator.
  2. Locate Projects in the navigation pane and confirm that you can access the intended workspace.
  3. Confirm that the AI Agents area is available in a project where you have developer access.
  4. Confirm that the approved model provider is reachable from the intended route and that you possess the required credential or OCI configuration.

Expected checkpoint: you have established that the environment is a viable candidate for the lab, your project permissions are sufficient for the planned work, and a specific model-provider route has been approved.

If Agentic AI is missing, resolve edition entitlement, release, and access questions before trying alternative model credentials. An API key cannot enable an OIC feature that the instance is not entitled to use.

Step 2 — Create the training project

Navigation: Projects → Add → Create → New project → Choose.

Create a project dedicated to the Procurement Exception Assistant lab. Project names and prefixes below are tutorial conventions rather than reserved Oracle identifiers.

Field or item Tutorial value or decision Reason
Project name Procurement Exception Lab Readable name for the training solution.
Identifier Accept the generated identifier unless a naming policy requires otherwise. Avoid inconsistent references between assets.
Description Training project for a synthetic order-status assistant and its first ReAct pattern. Makes the purpose and scope clear to other maintainers.
Access Restrict access to the appropriate users or groups. Avoid granting every instance user unnecessary edit access.

Click Create. Assign or verify the project owner and intended editors using the project's access controls.

Use the prefix PEA_ for related assets. Reserve the project for this scenario so future modules can locate the pattern, integration, agent, and any later tools together.

Expected checkpoint: the project exists, you can open its details page, and you have the appropriate access to design its resources.

Step 3 — Select and prepare the approved model route

Before configuring the pattern, decide which documented provider route you will use. Do not copy credentials from another developer or assume that a model configured for a different integration is automatically the correct route for this pattern.

For a generic ReAct route, Oracle's configuration guide identifies the following connection fields:

Field Meaning and decision Source of value
Base URL The model-service endpoint used by the configured route. Approved provider's endpoint documentation.
Model The specific model identifier the service should use. Approved model inventory and provider's current API documentation.
API Key Based Authentication The credential OIC uses to authenticate to the model service. The organization's approved credential-management process.

Temperature or other optional model settings: do not invent values just because a screenshot or another provider's configuration shows them. Oracle's current textual ReAct procedure identifies Max iterations, Guidelines, Base URL, Model, and API-key authentication, but does not define a universal temperature range or default in that procedure. Follow the documented settings actually supported by your selected route.

💡 Deep Dive Recommendation

To learn how temperature works alongside Top-P, Top-K, and frequency penalties, check out our comprehensive guide on Mastering LLM Hyperparameters.

Important identity boundary: the model-service credential authenticates OIC to the model service. It does not authenticate the eventual user to a purchase-order system or grant the agent permission to query an ERP system. The later integration and target-system security configuration must enforce those separate permissions.

Step 4 — Create the ReAct thinking pattern

Navigation: Projects → Procurement Exception Lab → AI Agents → Agent patterns → Add.

Create the pattern and use these tutorial-defined values:

Field Value or choice Explanation
Name PEA ReAct Order Lookup Human-readable name identifying this pattern's intended scenario.
Identifier Accept the generated value unless your naming policy requires another valid identifier. A project-scoped identifier for references to the pattern.
Version Use the automatically assigned version. Oracle manages the initial version assignment.
Pattern recipe ReAct Selects the supported adaptive reasoning strategy for this lab's generic provider route.

Click Create. On the pattern details page, configure Max iterations and Guidelines. Save your initial pattern settings before continuing to the model connection.

Step 5 — Set the iteration limit and review guidelines

Max iterations: retain the displayed default for the first lab and record its actual value. If your UI shows 10, record 10 as the starting value for this environment, not as a universal Oracle default. Oracle's guide describes the setting's purpose and provides example guidance, but does not publish a complete, universal accounting algorithm for the counter.

Do not use an artificially small value merely to save tokens. The limit has to leave enough room for the selected pattern to reach a useful stopping point. You will validate that decision when the agent is runnable in the next module.

Guidelines: use Oracle's documented starter ReAct guidelines for this first build. If the field is pre-populated, review and retain that text; if it is empty, enter the guidelines provided by the current Oracle procedure. Do not assume the text is pre-populated in every release. These guidelines govern the reasoning strategy, not the procurement business rules. Changing them without a specific reason makes it harder to determine whether later behavior is caused by the pattern, the agent instructions, or a tool definition.

If you later customize pattern guidelines, preserve a coherent action-and-observation strategy, avoid guessing required tool arguments, and test the behavior with representative inputs. A guideline can influence a model's decision, but it does not replace backend validation or authorization.

Checkpoint: the saved pattern uses the ReAct recipe and has a recorded iteration-limit value and guideline configuration.

Step 6 — Configure and test the LLM connection

Navigation: on the pattern details page, locate LLM Connections and select the edit action for the generated LLM connection.

  1. Enter the approved model provider's Base URL.
  2. Enter the provider-supported model identifier.
  3. Configure API-key authentication with the approved credential, when using the generic provider route.
  4. Use the connection's Test action.
  5. When the test succeeds, save the connection settings.

Do not write the actual secret into the article, screenshots, project description, or configuration notes. Record only the credential reference or approved secret-management identifier if your organization uses one.

For the OCI Generative AI route, create ReAct for OCI GenAI instead. Follow the OCI-specific prerequisites and configure the supported Model type. Then update the OCIGenAI_Properties lookup with the OCI compartment OCID and region, as required by Oracle's procedure. Confirm that the selected model is available in that region. This route has different configuration requirements and is not a drop-in substitution for the generic API-key procedure.

Expected checkpoint: the connection test reports success in your tenant and the saved connection refers to the intended provider, endpoint, and model. If you cannot obtain approved credentials or the test fails, record that as a blocked dependency instead of reporting the route as verified.

Step 7 — Save and activate the pattern

Oracle documents a system-generated integration for a configured ReAct pattern. On saving the generic model connection, Oracle Integration creates ReAct Pattern Intg in the project's Integrations area and automatically activates that generated integration.

This generated integration is part of the pattern implementation. It is different from the pattern resource that you select for an agent. Do not treat the generated integration's active status as proof that the pattern itself is active.

Navigation: return to the project’s AI Agents area. Under Agent patterns, locate PEA ReAct Order Lookup. Open the row's Actions menu and select Activate. Confirm that the pattern status becomes Active.

Activation establishes the pattern's active lifecycle state so it can be associated with an AI agent. It does not prove that an agent has selected the correct tool, that a reasoning sequence will finish, or that business results will be correct.

Expected checkpoint: the pattern is Active, the relevant model connection has a recorded successful test result, and the generated pattern integration is present. Record the displayed resource names and statuses rather than assuming that the UI matches the documentation illustration.

Step 8 — Prepare the starter order-status integration

The next asset is a deterministic REST integration. It uses static synthetic data so that the first agent build will have a predictable tool result without connecting to a live ERP system or exposing real procurement records.

Tutorial integration name: PEA_OrderStatusLookup

Contract:

Item Specification
Trigger REST Adapter, POST, OAuth authentication, JSON request and response.
Illustrative resource path /orders/status
Input orderNumber: required string.
Output orderNumber, found, status, expectedDeliveryDate, message.
Side effects None. This lab only looks up synthetic data.

The business-level response field status is not an HTTP status code. This lab represents invalid and unknown order results in JSON so that the expected business outcomes are deterministic. HTTP-level authentication errors, malformed requests, and other transport failures remain separate concerns.

Seed data:

[
  {
    "orderNumber": "PO-1001",
    "status": "SHIPPED",
    "expectedDeliveryDate": "2026-10-25"
  },
  {
    "orderNumber": "PO-1002",
    "status": "PROCESSING",
    "expectedDeliveryDate": "2026-10-29"
  },
  {
    "orderNumber": "PO-1003",
    "status": "DELAYED",
    "expectedDeliveryDate": "2026-10-31"
  }
]

These dates and order numbers are illustrative data for the lab. They do not represent actual purchase orders or a live business system.

Implementation behavior: create the REST-triggered orchestration using the contract above. Normalize the supplied order number by trimming surrounding whitespace and converting it to uppercase before evaluating the synthetic cases.

  • For PO-1001, return found: true, status SHIPPED, and delivery date 2026-10-25.
  • For PO-1002, return found: true, status PROCESSING, and delivery date 2026-10-29.
  • For PO-1003, return found: true, status DELAYED, and delivery date 2026-10-31.
  • For an empty or whitespace-only order number, return found: false, status INVALID_REQUEST, an empty delivery-date string, and a message requesting a non-empty order number.
  • For a non-empty, unknown value such as PO-9999, return found: false, status NOT_FOUND, an empty delivery-date string, and a message stating that the supplied order was not found.

Use a validation branch followed by a switch or equivalent deterministic mapping for the known orders. Define the JSON request and response structures explicitly. An omitted field can be rejected by the request contract before orchestration logic runs, depending on the configured schema; test the behavior of your actual integration instead of assuming the blank-string branch covers every malformed request.

For example, the unknown-order response should be:

{
  "orderNumber": "PO-9999",
  "found": false,
  "status": "NOT_FOUND",
  "expectedDeliveryDate": "",
  "message": "No order found for supplied order number."
}

Build and activate the integration using your standard OIC development process. The REST trigger must be configured for OAuth authentication and JSON. Keep it within the training project and preserve its contract for later use.

Oracle's current documentation on registering integrations as agentic tools requires the integration to be part of a project, active, and fronted by a REST Adapter trigger using OAuth and JSON. It documents supported REST trigger verbs; POST is selected here because this lab submits a lookup request in the request body.

Oracle documentation: requirements for registering an integration as an agentic AI tool

Important sequencing: do not register the integration as an agentic AI tool in this module. The next module will cover the tool's description, identifier, visible parameters, and association with the first agent. Preparing the integration first lets you verify the business behavior independently.

Step 9 — Test the integration independently

Use OIC's integration test facilities or a REST client with valid OAuth authentication. Inspect the request, the orchestration behavior, and the actual response. Do not infer integration success merely because the deployment or activation completed.

For the positive case, submit:

{
  "orderNumber": "PO-1002"
}

The expected business response contains found: true, status: PROCESSING, and expectedDeliveryDate: 2026-10-29.

Expected checkpoint: the integration is Active and produces the specified deterministic JSON responses for positive, invalid, and unknown order-number cases. Record test evidence from the actual execution.

6. Test and Prove It

The table below defines the minimum acceptance tests. These are expected outcomes, not claims that the tests have already passed. Execute them in your tenant and record the actual result, timestamp, and relevant run identifier.

Case Expected behavior Evidence to inspect Execution status
Model connection positive test Connection test succeeds for the approved provider and model. Connection test result and saved provider/model configuration. Not executed
Model connection negative test A deliberately invalid credential in an isolated test configuration is rejected; the real saved secret remains protected. Connection error and authentication or endpoint diagnostics. Not executed
Known order A seeded order returns its exact synthetic status and delivery date. Request, integration run, and actual response payload. Not executed
Unknown order The integration returns found: false and NOT_FOUND. Branch selected and returned JSON. Not executed
Blank order number The validation branch returns INVALID_REQUEST. Validation path and response payload. Not executed
Invalid REST authentication The caller is rejected before being allowed to perform the protected lookup. HTTP response and trigger security diagnostics. Not executed
Pattern activation The pattern displays Active and its connection configuration has been saved. Pattern status and generated integration presence. Not executed
End-to-end agent and iteration behavior The configured agent chooses the correct tool, passes suitable arguments, uses the result, and stops appropriately. Agent trace, tool invocation, returned data, and runtime termination details. Blocked — next module

The last test cannot be completed in this module because the agent and its tool association have not yet been built. Do not label its iteration limit as calibrated until actual agent runs provide evidence.

7. Troubleshooting and Recovery

Symptom Likely cause Targeted check and correction
AI Agents or pattern creation is unavailable. Edition entitlement, effective service role, project permission, or environment capability. Confirm the entitled edition and developer access before recreating the project or changing credentials.
Connection test fails. Incorrect endpoint or model identifier, invalid credentials, route incompatibility, or network/provider issue. Check the selected pattern against the supported-model matrix, then verify endpoint format, credential validity, and provider-side diagnostics.
Generated pattern integration exists, but no agent can select the pattern. The integration's status was mistaken for the pattern's lifecycle status. Return to Agent patterns and confirm that the pattern itself is Active.
The model reports a successful lookup, but no matching integration run exists. The response may be a model-generated claim rather than evidence of an actual tool execution. Inspect runtime evidence for the tool invocation and independently confirm its returned payload before accepting the claim.
The integration rejects a request unexpectedly. REST trigger authentication, request schema, normalization, or branch logic. Separate HTTP-level rejection from business-level JSON output. Inspect the actual request and integration execution evidence.

Preserve the working state. Before changing a successful model connection or pattern configuration, record the existing settings and relevant resource identifiers. Do not delete the system-generated pattern integration to troubleshoot an unrelated REST integration failure.

If a future move to another OIC instance is required, plan a separate migration test. Oracle's known-issues documentation reports an activation problem when exporting AI agents and related integrations through a project deployment; its documented workaround is to create and activate a new agent in the destination instance. Do not assume that a successful source-instance activation proves destination activation.

Oracle documentation: Agentic AI known issues

8. Enterprise Considerations

Keep model access separate from business access. The model credential is for the provider connection. The REST trigger's OAuth configuration is for its callers. Any future connection to ERP, procurement, or another target system needs its own appropriate authentication and authorization design.

Keep the lab read-only. The synthetic lookup does not modify orders or delivery commitments. If a later module introduces write tools, enforce permissions, business validation, duplicate prevention, and uncertain-outcome handling in the actual integration and target-system control plane. A prompt asking an agent to avoid unauthorized actions is not a substitute for these controls.

Manage project access deliberately. Restrict edit access to the developers responsible for the lab and keep sensitive credentials out of tutorial artifacts. A successful provider connection test does not itself establish that the organization's data-handling policy permits sending production data to that provider.

Record configuration, not secrets. Capture the project identifier, pattern identifier and version, provider and model identifiers, non-secret endpoint reference, observed iteration-limit value, connection-test outcome, pattern status, integration version, and test run identifiers. Do not record raw API keys or OAuth tokens.

9. Completion Checklist and What Comes Next

Mark each item only after observing it in the actual environment.

  • Edition, environment capability, project permissions, and approved provider route have been confirmed.
  • The training project exists with recorded ownership and naming conventions.
  • The model connection has been saved and its connection-test result recorded.
  • The ReAct pattern uses the selected route, has documented initial settings, and displays Active.
  • The generated pattern integration is present; its configuration has not been mistaken for agent activation.
  • The synthetic order-status REST integration is active and its JSON contract is documented.
  • Positive, unknown-order, and blank-order tests have been executed and their actual results recorded.
  • Authentication failure testing has been completed in an appropriate test environment.
  • The project, pattern, integration, configuration observations, and test evidence are ready for the next module.

What comes next: build the Procurement Exception Assistant, associate it with the active ReAct pattern, register the order-status integration as an agentic AI tool, configure tool metadata and model-visible parameters, and execute end-to-end tests. Only then can you measure actual tool-selection behavior and calibrate Max iterations from runtime evidence.

10. Five Useful FAQs

1. Is a thinking pattern the same thing as an AI agent?

No. The pattern defines a reasoning strategy and is associated with a language model. The agent combines its configured role and instructions with the selected pattern and available tools to perform a task. An active pattern alone does not create a working assistant.

2. Does a successful model connection test prove that the agent will work?

No. The connection test verifies the configured provider route under its test conditions. Tool selection, argument correctness, use of returned evidence, stopping behavior, and final-answer accuracy must be tested through actual agent runs.

3. Does the LLM API key authorize an agent to access the ERP system?

No. It authenticates the configured OIC connection to the model provider. Access to a protected integration or target system is a separate identity and authorization concern, enforced through the corresponding security configuration and backend controls.

4. Does Max iterations equal the maximum number of tool calls?

The inspected Oracle documentation does not establish that equivalence. It describes a limit on reasoning and action steps, but does not precisely publish the runtime counter's accounting algorithm. Examine actual traces instead of treating the setting as a tool-call counter.

5. When should the project use Plan and Execute instead of ReAct?

Start with ReAct when the workflow is new, exploratory, or depends on information returned by earlier tool calls. Consider Plan and Execute when the process is understood, the step sequence is known in advance, and explicit planned execution is important. Neither pattern replaces backend security or business validation.

11. Additional References


Comments