When you create an agent in Oracle Integration (OIC), one of the first decisions you make is how it thinks. OIC exposes two distinct reasoning patterns — ReAct and Plan & Execute — each reflecting a fundamentally different philosophy about how an intelligent agent should approach a task.
This is not a cosmetic choice. The pattern you select shapes how the agent handles unexpected results, how many LLM tokens it consumes, how deterministic its behavior is, and ultimately how well it performs for a given class of problems.
Two Ways to Think
At their core, the two patterns answer one question differently: “Does the agent need to know the full plan before it starts?”
Pattern 01 — Adaptive
⚡ ReAct
Reason + Act — a tight loop where the agent thinks, takes one action, observes the result, then decides the next step. Every action is informed by what just happened.
The agent never has a full plan. It navigates step-by-step, adapting its path in real time based on what tools return.
“I don’t know exactly where this leads — I’ll figure it out as I go.”
Pattern 02 — Methodical
🗺️ Plan & Execute
Plan first, then execute — in OIC, this is implemented as two separate agents: a Planner agent that decomposes the goal into an ordered list of steps, and an Executor agent (itself a ReAct agent) that blindly runs those steps in sequence.
The Planner never calls tools — it only thinks. The Executor never improvises — it only acts on what the Planner prescribed.
“I’ll figure out the full plan first, then hand it off to be executed exactly as written.”
In OIC, Plan & Execute is not one agent — it is two. The Planner thinks without acting. The Executor acts without thinking. Together, they separate strategy from execution.
Inside Each Pattern
Execution Flow Comparison
How to Choose the Right Pattern
The right pattern is not about complexity — it is about the structure of the task. Use these signals to guide your decision in OIC.
Quick Litmus Test: Write down the task in one sentence. If you can already list the exact tools that need to be called before the agent starts — use Plan & Execute. If you cannot list them without knowing intermediate results first — use ReAct.
| Decision Signal | Use ReAct When… | Use Plan & Execute When… |
|---|---|---|
| Path Predictability | The sequence of steps is unknown until the previous result is seen — for example, “find all blocked orders and resolve each one.” | The steps required are knowable from the goal alone — for example, “generate a monthly report by pulling data from three systems.” |
| Step Count | Tasks requiring 1–5 tool calls where each call informs the next. Deep chaining with unknown depth. | Tasks with a known set of sequential steps — where the full tool sequence is predictable from the goal description alone. |
| Error Recovery | The agent must handle unexpected tool failures creatively — try an alternative lookup, reframe the query, and escalate selectively. | Failures follow predictable retry or fallback logic that can be encoded in the plan step definition. |
| Auditability | Acceptable for conversational or low-stakes tasks where the execution trace is less critical. | Required for regulated, high-stakes, or compliance-sensitive workflows where every step must be logged and inspectable. |
| Latency Priority | Lower latency for simple tasks — no upfront Planner call overhead. Starts executing immediately. | Adds latency for the Planner LLM call before any tool runs. Worth it when explicit step ordering and auditability matter more than raw speed. |
| Determinism | Some variation in approach is acceptable — the goal is the answer, not the exact path taken. | The same task must execute the same way every time — deterministic, repeatable, and comparable across runs. |
| Task Type | Investigative, diagnostic, conversational, and ambiguous — questions the agent must explore to answer. | Analytical, reporting, orchestration, and batch processing — tasks with clear inputs and structured outputs. |
| Token Cost | Simple tasks: more cost-efficient — no Planner call overhead; pays only for actual tool steps taken. | Two agent calls (Planner + Executor) before work is done. But you have the flexibility to compensate the executor with a relatively cheaper model. |
Pattern in Practice
Abstract guidance only goes so far. Here is how real OIC agent use cases map to each pattern — and why the pattern choice matters for each one.
ReAct Use Cases
Plan & Execute Use Cases
OIC Agent Design Best Practices
These principles apply across both patterns and should guide every agent you build in OIC.
Series Note:
This is Part 1 of the OIC Agentic AI – Thinking Pattern Best Practices. In Part 2 (Stay Tuned !) I plan to cover the details of how to implement both the patterns in OIC.