> ## Documentation Index
> Fetch the complete documentation index at: https://developer.watson-orchestrate.ibm.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Choosing the agent style

<Warning>
  **Deprecation notice**: The **Default** and **ReAct** styles are going to be removed in a future release. Only **ReAct Core** (`react_core`) remains. Migrate your agents to ReAct Core as soon as possible. See the [agent style migration guide](agent_styles_migration) for instructions.
</Warning>

Agent styles define how the agent reasons through problems and how it behaves when collaborating with other agents. You can choose from three styles:

| **Style**                                                        | **How It Works**                                                                               | **Best For**                                                                                 |
| ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
| [**ReAct Core (`react_core`)**](#react-core-style) ✦ Recommended | Uses the model's built-in function calling with improved collaboration accuracy.               | Complex tasks and multi-agent workflows where performance and collaboration accuracy matter. |
| [**Default (`default`)**](#default-style) (Deprecated)           | Uses the model's built-in function calling.                                                    | Simple, linear tasks with predictable tool usage.                                            |
| [**ReAct (`react`)**](#react-style) (Deprecated)                 | Iterative loop: **Think** → **Act** → **Observe**, using a prompt-based tool calling approach. | Multi-step tasks on models with limited native function calling support.                     |

<Note>
  **Note:**\
  If you use **GPT-OSS-120B** or **GPT-5.4** as your agent's model, the agent ignores all styles and uses ReAct Core automatically.
</Note>

## ReAct Core style

Choose **ReAct Core** (`react_core`) for complex tasks and multi-agent workflows. It uses the model's built-in function calling and is optimized for accurate collaboration, keeping collaborators focused on the task at hand.

Use this style for:

* Multi-agent workflows with collaborator agents
* Complex reasoning tasks
* Any scenario where collaborator accuracy matters

| **Behavior**                                                                                                                                                                                                                                                                                      | **Tool Compatibility**                                                                                                                                            | **Example use cases**                                                                                                                                                              |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>**Think**: Use the model's built-in function calling to assess the request and select the right tool or collaborator</li><li>**Act**: Execute the tool or collaborator</li><li>**Observe**: Evaluate the outcome and adjust reasoning</li><li>Repeat until the goal is achieved</li></ul> | <ul><li>Python tools</li><li>OpenAPI tools</li><li>MCP tools</li><li>Knowledge-intensive tools</li><li>Data-intensive tools</li><li>Collaborator agents</li></ul> | <ul><li>Multi-agent orchestration</li><li>Complex problem-solving with advanced reasoning models</li><li>Tasks requiring accurate delegation to specialist collaborators</li></ul> |

<Note>
  **Note:**
  `react_core` is the canonical identifier in the ADK and the UI, displayed as **ReAct Core**. **ReAct Core** (`react_core`) was previously named **ReAct Intrinsic** (`react_intrinsic`).

  In the ADK, `react_intrinsic` is accepted as an alias for `react_core` and behaves identically. In the REST API, `react_intrinsic` is the accepted value.
</Note>

## Default style (Deprecated)

Choose **Default** (`default`) for simple tasks. This style uses a streamlined, tool-centric reasoning mode. The LLM decides which tool to use, how to use it, and when to respond. It works best for linear logic, such as retrieving a report or checking a ticket, because the agent orchestrates tool calls dynamically.

Use this style for:

* Single-step or lightly sequential tasks
* Scenarios that need flexibility
* Tasks that involve multiple tools without strict sequencing

| **Behavior**                                                                                                                                                                                                                                                       | **Tool Compatibility**                                                 | **Example use cases**                                                                                                                                     |
| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>Prompts the LLM to: <br /> - Identify which tool or collaborator to invoke <br /> - Determine inputs <br /> - Decide whether to call more tools or finalize a response</li><li>Continues prompting until it gathers enough context for an answer</li></ul> | <ul><li>Python tools</li><li>OpenAPI tools</li><li>MCP tools</li></ul> | <ul><li>Extract information from a system or the web</li><li>Check the status of a task or ticket</li><li>Perform tasks with well-defined steps</li></ul> |

## ReAct style (Deprecated)

Choose **ReAct** (`react`) for complex or ambiguous problems where each outcome influences the next step. This style uses an iterative loop: **Think** → **Act** → **Observe**. It supports reasoning, validation, and interactive confirmation. Inspired by the [ReAct methodology](https://arxiv.org/abs/2210.03629), it surfaces the agent's [chain of thought](https://www.ibm.com/think/topics/chain-of-thoughts).

A ReAct agent breaks tasks into smaller steps, reasons through each, takes action, and adjusts based on what it learns. It might ask you for confirmation before continuing.

Use this style for:

* Exploratory or research-intensive tasks
* Scenarios requiring iterative validation
* Tasks with unclear or evolving requirements
* Situations where transparent reasoning matters

| **Behavior**                                                                                                                                                                                                                                                          | **Tool Compatibility**                                                                               | **Example use cases**                                                                                                                                                           |
| --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| <ul><li>**Think**: Assess the request and choose the right tool, collaborator, or reasoning step</li><li>**Act**: Execute the tool or collaborator</li><li>**Observe**: Evaluate the outcome and adjust reasoning</li><li>Repeat until the goal is achieved</li></ul> | <ul><li>Knowledge-intensive tools</li><li>Data-intensive tools</li><li>Collaborator agents</li></ul> | <ul><li>Generate or refactor code</li><li>Answer complex questions by searching and synthesizing information</li><li>Handle support tickets with complex interactions</li></ul> |