# Agno Reasoning and reasoning_model Capabilities: A Complete Technical Guide

> Explore Agno reasoning and reasoning_model capabilities. Discover unified native model support, automatic detection, streaming execution, and fallback engines. Your technical guide to Agno's reasoning system.

- Repository: [Agno/agno](https://github.com/agno-agi/agno)
- Tags: deep-dive
- Published: 2026-02-23

---

**TLDR:** Agno's reasoning subsystem provides unified native reasoning model support with automatic provider detection, streaming and non-streaming execution, async variants, and a fallback Chain-of-Thought engine for non-native models, all managed through the `ReasoningManager` class.

The `agno-agi/agno` repository implements a sophisticated reasoning layer that enables AI agents to leverage native "thinking" capabilities from modern LLM providers. This article explores the complete capabilities of Agno's reasoning engine and `reasoning_model` support, covering everything from provider-specific detection logic to event-driven monitoring and tool-level reasoning persistence.

## Core Architecture of the Agno Reasoning Engine

At the heart of Agno's reasoning capabilities lies the **`ReasoningManager`** class in [`libs/agno/agno/reasoning/manager.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/manager.py). This class provides a unified API that abstracts away provider-specific implementations while handling model detection, execution orchestration, and event emission.

The manager relies on **`ReasoningConfig`** (defined in the same file at lines 76-89) to control behavior. Configuration options include `min_steps`, `max_steps`, tool enablement, tool call limits, JSON mode toggles, telemetry settings, and custom `RunContext` objects.

## Native Reasoning Model Detection and Support

Agno automatically detects whether a supplied model instance supports native reasoning through the **`is_native_reasoning_model`** method. This detection logic delegates to provider-specific checker functions located in individual modules such as [`libs/agno/agno/reasoning/openai.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/openai.py), [`anthropic.py`](https://github.com/agno-agi/agno/blob/main/anthropic.py), [`deepseek.py`](https://github.com/agno-agi/agno/blob/main/deepseek.py), [`gemini.py`](https://github.com/agno-agi/agno/blob/main/gemini.py), [`groq.py`](https://github.com/agno-agi/agno/blob/main/groq.py), [`ollama.py`](https://github.com/agno-agi/agno/blob/main/ollama.py), [`azure_ai_foundry.py`](https://github.com/agno-agi/agno/blob/main/azure_ai_foundry.py), and [`vertexai.py`](https://github.com/agno-agi/agno/blob/main/vertexai.py).

### Provider-Specific Implementation Details

Each provider implements a checker function that determines native reasoning eligibility based on model IDs and configuration flags:

- **OpenAI**: `is_openai_reasoning_model` in [`libs/agno/agno/reasoning/openai.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/openai.py) (lines 11-27) detects models including `gpt-4o`, `gpt-3.5-turbo`, `gpt-4.1`, `gpt-4.5`, and `gpt-5.1`.

- **Anthropic**: `is_anthropic_reasoning_model` checks for `thinking=True` parameter support in `Claude` models such as `claude-3-5-sonnet-20241022`.

- **DeepSeek**: Detection relies on model ID substrings "reasoner" or "r1" (e.g., `deepseek-deepseek-r1`, `deepseek-reasoner`).

- **Google Gemini**, **Groq**, **Ollama**, **Azure AI Foundry**, and **Vertex AI** each implement similar detection logic with provider-specific flags such as `thinking` parameters or model ID patterns.

## Execution Modes: Streaming, Non-Streaming, and Async

The `ReasoningManager` supports multiple execution patterns to accommodate different latency and interaction requirements.

### Non-Streaming Native Reasoning

For synchronous execution, the manager calls provider-specific helpers such as `get_openai_reasoning`, `get_anthropic_reasoning`, or `get_deepseek_reasoning`. These return a **`ReasoningResult`** containing the assistant message, extracted thinking content, and a list of **`ReasoningStep`** objects. The implementation resides in [`libs/agno/agno/reasoning/manager.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/manager.py) at lines 96-132.

### Streaming Native Reasoning

Streaming mode yields incremental "thinking" chunks while the model generates output. The **`stream_native_reasoning`** method (and its provider variants like `get_openai_reasoning_stream`) yields tuples of `(delta, None)` for each chunk, concluding with `(None, result)` when the final message is ready. This implementation appears in [`libs/agno/agno/reasoning/manager.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/manager.py) at lines 150-197.

### Async Variants

All execution modes provide async equivalents: **`aget_native_reasoning`**, **`astream_native_reasoning`**, and **`arun_default_reasoning`**. These async implementations occupy lines 215-285 in [`libs/agno/agno/reasoning/manager.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/manager.py).

## Default Chain-of-Thought Fallback

When `is_native_reasoning_model` returns `False`, the `ReasoningManager` automatically falls back to a generic **Chain-of-Thought (CoT)** loop. This fallback uses a dedicated reasoning agent configured with a structured output schema based on **`ReasoningSteps`** (defined in [`libs/agno/agno/reasoning/step.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/step.py)).

The fallback logic, implemented in **`_run_default_reasoning_events`** and **`run_default_reasoning`** (lines 286-363 of [`manager.py`](https://github.com/agno-agi/agno/blob/main/manager.py)), iteratively runs the agent, yields each `ReasoningStep`, and terminates when the agent returns **`NextAction.FINAL_ANSWER`** or reaches the `max_steps` limit configured in `ReasoningConfig`.

## Event-Driven Monitoring with ReasoningEvent

The reasoning subsystem emits a structured event stream through the **`ReasoningEvent`** class, enabling real-time monitoring and UI updates. Event types include:

- **`started`** – Reasoning process initiated
- **`content_delta`** – Incremental thinking content (streaming)
- **`step`** – Completion of a discrete reasoning step
- **`completed`** – Final answer available
- **`error`** – Processing failure

These events are generated throughout `ReasoningManager` methods and can be consumed by higher-level `Agent` or `Team` runtimes to surface progress to users or logs.

## Tool-Level Reasoning with ReasoningTools

For agents requiring explicit thought recording, Agno provides the **`ReasoningTools`** toolkit in [`libs/agno/agno/tools/reasoning.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/tools/reasoning.py). This toolkit exposes two high-level tools:

- **`think`** – Records scratch-pad thoughts with title, reasoning, action, and confidence
- **`analyze`** – Evaluates previous thoughts against specified criteria

When the LLM calls these tools, Agno automatically serializes **`ReasoningStep`** objects into `run_context.session_state["reasoning_steps"]`. You can later retrieve and validate these using `ReasoningStep.model_validate_json()` for audit trails or multi-step reasoning workflows.

## Configuration and Usage Examples

### Detecting Native Reasoning Support

```python
from agno.reasoning.openai import is_openai_reasoning_model
from agno.models.openai import OpenAIChat

model = OpenAIChat(id="gpt-4o")
print(is_openai_reasoning_model(model))   # → True

from agno.reasoning.anthropic import is_anthropic_reasoning_model
from agno.models.anthropic import Claude

model2 = Claude(id="claude-3-5-sonnet-20241022", thinking=True)
print(is_anthropic_reasoning_model(model2))  # → True

```

### Using Native Reasoning with Streaming

```python
from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.run import Message
from agno.reasoning.manager import ReasoningEventType

model = OpenAIChat(id="gpt-4o")
agent = Agent(name="Researcher", reasoning_model=model)

messages = [
    Message(role="system", content="You are a helpful assistant."),
    Message(role="user", content="Explain quantum entanglement."),
]

for event in agent.reason(messages, stream=True):
    if event.event_type == ReasoningEventType.content_delta:
        print("Thinking:", event.reasoning_content)
    elif event.event_type == ReasoningEventType.completed:
        print("Final:", event.message.content)

```

### Implementing Fallback CoT Reasoning

```python
from agno.agent import Agent
from agno.models.base import Model
from agno.run import Message
from agno.reasoning.manager import ReasoningEventType

# Non-native model triggers automatic CoT fallback

model = Model(id="gpt-3.5-turbo-mini")
agent = Agent(name="Planner", reasoning_model=model)

for ev in agent.reason([Message(role="user", content="Plan a weekend trip.")]):
    if ev.event_type == ReasoningEventType.step:
        step = ev.reasoning_step
        print(f"Step {step.title}: {step.reasoning}")
    elif ev.event_type == ReasoningEventType.completed:
        for s in ev.reasoning_steps:
            print(f"- {s.title} → {s.result}")

```

### Recording Custom Thoughts with ReasoningTools

```python
from agno.agent import Agent
from agno.tools.reasoning import ReasoningTools
from agno.run import RunContext
from agno.reasoning.step import ReasoningStep

agent = Agent(name="Investigator")
agent.run_context = RunContext()
agent.run_context.tools = [ReasoningTools(enable_think=True, enable_analyze=True)]

# When the LLM calls think(title="...", thought="...", action="...", confidence=...)

# the tool stores the step in session_state:

run_state = agent.run_context.session_state
if "reasoning_steps" in run_state:
    steps_json = run_state["reasoning_steps"].get(agent.run_context.run_id, [])
    for json_str in steps_json:
        step = ReasoningStep.model_validate_json(json_str)
        print(f"{step.title} → {step.reasoning}")

```

## Summary

- **Unified API**: The `ReasoningManager` in [`libs/agno/agno/reasoning/manager.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/reasoning/manager.py) provides a single interface for all reasoning operations, abstracting provider-specific implementations.

- **Automatic Provider Detection**: Nine major providers (OpenAI, Anthropic, DeepSeek, Gemini, Groq, Ollama, Azure AI Foundry, Vertex AI) are supported through dedicated checker functions that detect native reasoning capabilities based on model IDs and configuration flags.

- **Flexible Execution Modes**: Supports synchronous (`get_*_reasoning`), streaming (`stream_*_reasoning`), and async variants (`aget_*`, `astream_*`) to accommodate different latency requirements.

- **Robust Fallback Mechanism**: Automatically falls back to a deterministic Chain-of-Thought loop using structured output schemas (`ReasoningSteps`) when native reasoning is unavailable.

- **Event-Driven Architecture**: Emits `ReasoningEvent` objects (started, content_delta, step, completed, error) for real-time monitoring and UI integration.

- **Tool-Level Persistence**: The `ReasoningTools` toolkit enables explicit thought recording via `think` and `analyze` tools, automatically persisting `ReasoningStep` objects to `session_state`.

## Frequently Asked Questions

### What is the difference between native reasoning and default CoT in Agno?

Native reasoning leverages provider-specific APIs that expose the model's internal "thinking" process, such as OpenAI's reasoning models or Anthropic's `thinking=True` mode. This provides access to raw reasoning tokens and streaming deltas. Default Chain-of-Thought (CoT) is Agno's fallback implementation that uses a structured output schema (`ReasoningSteps`) and iterative agent loops to generate reasoning steps when the underlying model does not support native thinking APIs.

### How do I enable streaming for reasoning models in Agno?

Pass `stream=True` to the `agent.reason()` method or directly invoke `ReasoningManager.stream_native_reasoning()`. The system returns `ReasoningEvent` objects with `event_type` of `content_delta` for incremental thinking chunks and `completed` for the final answer. This works for all supported native providers including OpenAI, Anthropic, DeepSeek, and Gemini.

### Which LLM providers support native reasoning in Agno?

Agno supports native reasoning detection and streaming for nine major providers: **OpenAI** (GPT-4o, GPT-4.1, GPT-4.5), **Anthropic** (Claude 3.5 Sonnet with thinking=True), **DeepSeek** (R1/reasoner models), **Google Gemini**, **Groq**, **Ollama**, **Azure AI Foundry**, and **Vertex AI**. Each provider has a dedicated checker function (e.g., `is_openai_reasoning_model`) in the `libs/agno/agno/reasoning/` directory.

### How can I persist reasoning steps across agent tool calls?

Use the `ReasoningTools` toolkit from [`libs/agno/agno/tools/reasoning.py`](https://github.com/agno-agi/agno/blob/main/libs/agno/agno/tools/reasoning.py). Enable the `think` and `analyze` tools on your agent. When the LLM invokes these tools, Agno automatically serializes `ReasoningStep` objects into `run_context.session_state["reasoning_steps"]`. You can later retrieve these using `ReasoningStep.model_validate_json()` to reconstruct the reasoning history for audit trails or subsequent agent runs.