Agentic Reasoning: How LLMs Use Tools for Deep Research

A 2025 ACL paper titled Agentic Reasoning: A Streamlined Framework for Enhancing LLM Reasoning with Agentic Tools gave the concept a precise definition: a framework that "enhances large language model reasoning by integrating external tool-using agents". Put simply, the model stops answering in one shot. It plans, calls tools, reads the results, and reasons in a loop.

Users tend to discover the catch quickly. When a Hacker News commenter ran OpenAI Deep Research on the topic he knew best, himself, he caught three factual errors in a 500-word report. He still called it "decent enough for a springboard", provided that you "treat the output with caution and follow the links provided". The tool was useful, but its work still needed checking. That tension runs through this article.

That loop powers the "deep research" features from OpenAI, Gemini, Perplexity, and browser-level agents. Give one of these tools a broad question and it may run the cycle dozens of times before returning a cited report. This article connects the pieces: agentic reasoning, tool calling, the reasoning loop, and deep research. It also looks at how a browser-level tool such as Tabbit Browser runs the loop where you already work.

Key takeaways

• Agentic reasoning = reasoning plus tools, in a loop. The model plans a step, takes an action (search, code, memory lookup), observes the result, and reasons again instead of answering in a single turn.

• Tool calling is the hinge. Reasoning and tool use are different abilities; agentic reasoning combines them so the model can both think and act.

• Deep research is the loop run at scale. The same plan-act-observe-reason cycle, repeated across many sources, is what turns a chat model into a research agent.

• The mechanism is shared, the packaging differs. ChatGPT, Gemini, Perplexity, and browser agents like Tabbit all run a version of this loop, but differ in runtime, source access, and where the work happens.

• Output is a cited draft, not a verdict. The tools read the public web, can hallucinate, and require more model calls. A human still needs to verify anything important.

What is agentic reasoning?

At its simplest, agentic reasoning is when a large language model decides its own next step. Given a goal, it can break the goal into sub-tasks, choose a tool, run it, look at what came back, and keep going until the goal is met. The alternative is a single-turn chatbot: you send a prompt, the model answers from its weights and limited context, and the exchange ends.

Sources define the term slightly differently, but describe the same basic process:

• The arXiv paper above defines it as enhancing reasoning by integrating external tool-using agents: web search, code execution, and a "mind-map" agent that builds a structured knowledge graph to track logical relationships.

• IBM describes agentic reasoning as the decision-making component of an AI agent that lets it act autonomously.

• NVIDIA frames it as the "reason, plan, act" building block of agentic AI.

What makes it agentic is autonomy at the task level. The model does not need to run unsupervised for hours; it only needs to choose its next action instead of following a fixed script. Our what is an agentic browser explainer covers how this idea works inside a browser.

From reasoning to tool use: how LLMs call tools

To reason on its own, a model only needs its trained weights and the conversation so far. To act, it needs tools. This is where tool calling, also called function calling, comes in.

The mechanism is straightforward. The application gives the model a list of available tools and a description of what each one accepts. When the model decides it needs outside information, it does not write a natural-language guess; it emits a structured call (for example, "run this search query" or "execute this code"). The application runs the tool and hands the result back. The model reads the result and continues.

Two production examples:

• OpenAI function calling lets a model emit a structured function request that the application executes and returns.

• Anthropic tool use follows the same pattern: the model requests a tool, the client runs it, and the observation is fed back into the conversation.

This exchange separates a model that talks about the world from one that reads it. A chat model might say "the latest figures are probably around X". A tool-using model can search, read the actual page, and answer from that evidence instead of relying only on training memory.

The reasoning loop: plan → act → observe → reason

Tool calling gives the model hands. The reasoning loop tells it how to use them. The clearest description is ReAct (Reason + Act), introduced by Yao and colleagues in 2022, which interleaves three kinds of steps:

1. Thought (reason). The model reasons about where it is and what to do next.

2. Action (act). It calls a tool, such as search, code execution, or memory lookup.

3. Observation (observe). It reads the tool's result.

Then it reasons again. A realistic task is not one Thought-Action-Observation triple; it is a chain of them. The model plans, acts, observes, learns something that changes the plan, and continues. The paper found that interleaving reasoning with acting works better than either one alone. Reasoning-only models can drift into confident hallucination, while acting-only models lack the planning needed to choose good actions.

A modern agentic system compresses this into four repeating moves:

• Plan: break the goal into the next sub-step.

• Act: call the right tool.

• Observe: read the result.

• Reason: update the plan and decide what to do next.

The arXiv Agentic Reasoning framework adds a web-search agent, a code-execution agent, and a mind-map agent that records what has been learned in a knowledge graph. This helps long chains keep track of earlier findings. Deployed on DeepSeek-R1, the framework produced results that the authors report as state of the art among public models and comparable to OpenAI Deep Research. The specific score matters less here than the mechanism: a reasoning loop paired with the right tools.

How this loop becomes deep research

Deep research is the reasoning loop applied to a question too broad for a single search. Picture the same plan-act-observe-reason cycle, but run dozens of times across many sources:

1. Plan the research. The agent reads your question, identifies sub-questions, and lays out a search plan. Ask for a competitive landscape and it might split the work into market position, pricing, features, and recent news.

2. Search and act. It runs many queries, opens pages, and updates the plan as it learns. These are the "act" and "observe" steps repeated.

3. Reason across sources. It compares claims, flags conflicts, and filters low-relevance material. This is where synthesis happens, not just listing snippets.

4. Report with citations. It writes a structured document with links back to sources so you can verify each claim.

This is why deep research takes minutes rather than seconds. OpenAI Deep Research reports runtimes of five to thirty minutes; Perplexity Deep Research typically finishes in two to four minutes. The difference comes down to how many times the loop runs and how much reasoning happens between searches. A faster run is cheaper but shallower. A longer run reasons more, costs more, and can still be wrong.

The same trade-off shows up in every tool. Once you see the loop, "deep research" stops being a mysterious feature and becomes a question of three engineering choices: how many times does it loop, what tools can it reach, and where do you see the sources?

Deep research approaches compared

Runtimes and quotas change often, so treat this as a snapshot and check each tool's current page before committing.

A practical browser-level option: Tabbit Deep Research

Not every research task belongs in a chat window or behind a productivity-suite subscription. If you already read articles, compare product pages, and fill spreadsheets in the browser, a browser-level AI browser can run the reasoning loop in the same place. That is the idea behind Tabbit.

Tabbit Browser runs an Agent Mode inside the browser window. You describe the research outcome; Tabbit plans searches, opens relevant pages, reads the content, and assembles a structured report. It uses the same plan-act-observe-reason cycle described above, with the browser itself as the tool surface.

What makes the browser-level version different:

• Browser context with @ references. Instead of copy-pasting context, you can attach open tabs, tab groups, screenshots, bookmarks, or local files to the task. The agent reasons over what you are already looking at.

• Sources stay visible. The original pages remain open beside the answer, so checking a claim is a glance rather than a scroll through a long report. This directly addresses the "where do you see the sources?" question from the last section.

• Multi-model choice. Tabbit can route the same task to several models and show their answers side by side, which is useful when you are unsure which model reasons best about your topic.

• From research to deliverable. Because the agent controls the browser, it can place results directly into a web spreadsheet or document rather than returning plain text.

There are clear trade-offs. The same browser automation that makes Tabbit flexible also means it cannot read your Microsoft 365 emails, Teams chats, or SharePoint documents unless you deliberately share those pages as context. If your research depends on internal work content, Gemini or Microsoft 365 Copilot Researcher is the more integrated choice. If your research is mostly web-based or personal-document-based, Tabbit keeps the source pages next to the answer without a subscription jump. For the wider workflow, our best practices guide covers how to get more out of Agent Mode, and the researcher overview and deep research browser pages describe the product in more detail. See the current Tabbit pricing before choosing a plan.

When agentic deep research helps, and when it doesn't

The last row is the one to remember. Agentic deep research is valuable precisely because the loop is expensive. If a question can be answered by one search, running dozens of them wastes time and tokens. The loop earns its cost when a question is broad, multi-source, and benefits from synthesis.

Limitations to keep in mind

Academic sources are clear about the limits of agentic reasoning. Users should be too.

• Hallucination does not disappear. Tools ground the model better, but an LLM can still state something false with confidence. The ReAct paper aimed partly to reduce reasoning-only hallucination, not eliminate it. The failure is well documented in practice. On Hacker News, an experienced developer wrote that the worst part of an LLM is "simply being wrong, and then doubling down on it". A practitioner describing the reasoning loop calls "fabricated observations", where "the agent imagines a response that it never actually got", a standard pitfall that a built-in critic step is meant to catch.

• More calls mean more cost and latency. Every loop step is a model call. Deep research is slower and more expensive than a chat turn by design; free tiers are limited for exactly this reason.

• Source quality is still your problem. The tools read whatever is on the public web. Outdated pages, marketing copy, and low-quality content can enter the synthesis unless the tool filters them.

• Private and paywalled data is restricted. Unless you upload files or connect an authorized data source, these systems cannot see internal documents or subscription research.

• Verification is still a human job. Citations help you check, but they do not guarantee accuracy. For any high-stakes claim, read the primary source.

Treat the output of any agentic deep research tool as a cited first draft. It gets you to a structured brief faster than starting from zero, but the final judgement is yours.

Final verdict

Agentic reasoning is a mechanism, not a product. An LLM plans, calls tools, observes results, and reasons in a loop. Tool calling gives the model a way to act; the reasoning loop directs those actions; deep research repeats the loop across many sources until it has a cited report. ChatGPT, Gemini, Perplexity, and browser agents package that mechanism differently. They vary in how long they run, what they can reach, and where they show their sources.

If you already work in chat-based tools and want the deepest reasoning, ChatGPT Deep Research is a natural starting point. If your research happens in the browser, Tabbit Browser is worth testing. You can download it free for macOS or Windows and run a research task while the source pages stay in view. Features can shift tiers or retire, as happened when Microsoft moved Copilot Deep Research behind a subscription. Our notes on Copilot Deep Research retiring cover that change. The underlying mechanism will outlast any single product version.

Secholar.L

Growth & Content at Tabbit

Secholar.L writes hands-on guides about AI browsers and agent workflows, comparing tools with real research and citing verifiable sources.