Skip to main content
Agent styles define how the agent follows instructions and how it behaves. You can choose from three styles:
StyleHow It WorksBest For
Default (default)Uses LLM prompts to decide tools and actions dynamically.Simple, linear tasks needing flexibility.
ReAct (react)Iterative loop: Think → Act → Observe. Adjusts based on outcomes.Complex, evolving tasks needing reasoning.
ReAct Intrinsic (react_intrinsic)Like ReAct, but uses native chain-of-thought reasoning without external tool calls for thinking.Complex tasks with models supporting intrinsic reasoning.
Note:
If you use GPT-OSS-120B as your agent’s model, the agent ignores all styles.

​
Default style

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
BehaviorTool CompatibilityExample use cases
  • Prompts the LLM to:
    - Identify which tool or collaborator to invoke
    - Determine inputs
    - Decide whether to call more tools or finalize a response
  • Continues prompting until it gathers enough context for an answer
  • Python tools
  • OpenAPI tools
  • MCP tools
  • Extract information from a system or the web
  • Check the status of a task or ticket
  • Perform tasks with well-defined steps

​
ReAct style

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, it surfaces the agent’s chain of thought. 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
BehaviorTool CompatibilityExample use cases
  • Think: Assess the request and choose the right tool, collaborator, or reasoning step
  • Act: Execute the tool or collaborator
  • Observe: Evaluate the outcome and adjust reasoning
  • Repeat until the goal is achieved
  • Knowledge-intensive tools
  • Data-intensive tools
  • Collaborator agents
  • Generate or refactor code
  • Answer complex questions by searching and synthesizing information
  • Handle support tickets with complex interactions

​
ReAct Intrinsic style

Choose ReAct Intrinsic (react_intrinsic) for complex tasks when using LLM models that support native chain-of-thought reasoning. This style is similar to ReAct but uses intrinsic reasoning capabilities built into the model itself. The agent leverages the model’s internal reasoning without additional prompting overhead. This style is optimized for models with advanced reasoning capabilities that can perform chain-of-thought processing natively. It follows the same Think → Act → Observe pattern as ReAct, but the thinking phase happens within the model’s internal processing. Use this style for:
  • Complex reasoning tasks with compatible LLM models
  • Scenarios requiring efficient reasoning without external thinking tool calls
  • Tasks where the model’s native chain-of-thought capabilities are sufficient
  • Situations where reduced latency in the reasoning phase is beneficial
BehaviorTool CompatibilityExample use cases
  • Think: Uses the model’s intrinsic reasoning capabilities without external tool calls
  • Act: Execute tools or collaborators based on internal reasoning
  • Observe: Evaluate outcomes and adjust reasoning internally
  • Repeat until the goal is achieved
  • Requires LLM models with native chain-of-thought support
  • Knowledge-intensive tools
  • Data-intensive tools
  • Collaborator agents
  • Compatible with models supporting intrinsic reasoning
  • Complex problem-solving with advanced reasoning models
  • Multi-step analysis requiring efficient reasoning
  • Tasks benefiting from reduced reasoning overhead
Note: The react_intrinsic style requires LLM models that support native chain-of-thought reasoning. Verify your model’s compatibility before using this style.