Reasoning model and deep agents

OSS Product Help LangGraph
,
1

I was taking the Deep Agents course and one thing I had question about and I think was relate to topic (module one - overview video) and does not covered:

where do reasoning agent/model (like reasoning capability of chatGPT or Gemini or Deepseek R1) seat in these architectures?
are they relate to this or they are completly different approach that binded inside model neural network during training phase not this later framework phase?
because it seems the output and approaches agents takes in them are like deep agent approach we are trying to build.

and also you mention think tool for planning in the comparison table for open-deep-research agents. what does that mean?

2 Likes
2

Hi @ImanHeshmat

great question!

  • Reasoning models (e.g., ChatGPT, Gemini, DeepSeek R1) are just LLM variants you plug into agent steps. They provide stronger inference-time reasoning but do not replace the agent framework.
  • LangGraph is the orchestration layer: it manages state, control-flow, tools, retries, interrupts, and multi-step flows. You can swap in a reasoning model for planner, critic, or decomposition nodes, while keeping lighter models for routine tool calls.
  • A “think” tool is essentially a structured scratchpad: a state-only (side-effect-free) operation that lets the model externalize plans or notes before acting. It improves traceability, observability, and control without exposing raw chain-of-thought.

Where do reasoning models “sit” in the architecture?

  • In LangGraph, models are invoked inside nodes of a StateGraph (planner, actor, critic, summarizer).
  • You can use standard or reasoning-optimized LLMs interchangeably in those nodes — the graph, not the model, enforces state, persistence, tool access, interrupts, budgets, and retries.
  • In practice, reasoning models are most useful for planner/decomposer, critic/verifier, or conflict-resolution nodes. A common pattern is mixture-of-models: cheap model for actors, stronger reasoning model for planning or verification.

Are reasoning models a different approach from agent frameworks?

  • They’re complementary, not alternatives.
    • Training/fine-tuning shapes the model’s internal reasoning behavior, plus inference-time techniques (e.g., reflection, scratchpads) can further enhance it.
    • The framework provides system-level structure: explicit steps, memory/state, tool use, safeguards, retries, timeouts, observability, and governance.
  • Many “deep agent” loops (plan → act → reflect → verify) can be powered by a reasoning model, but the graph still ensures determinism, reliability, and budget control.

What is a “think” tool for planning?

  • A small tool (or node) that captures a model’s high-level plan or notes into the agent’s state before any external actions.
  • Why it exists:
    • Structured planning: record plans/hypotheses as structured state, not just free-form text.
    • Budgets and control: count “think” calls, cap tokens/steps, or interrupt for human review.
    • Traceability/observability: separate plan vs. act phases for debugging and evaluation, without exposing private chain-of-thought.
  • In LangGraph this is usually:
    • a planner node that writes into state.plan or state.notes, or
    • a registered tool (e.g., think(notes: str)) that appends to structured state and returns an acknowledgment.
  • This makes plans visible for developers/monitoring while keeping them private from end users.
1 Like
3

could you share the course? Link?

4

Very interesting. I’m wondering do you know of any implementation of these approaches (publicoly available, maybe on Guthub).
I’m interested in these reasoning node approach, with plan in state, and/vs the think node approach, and would love to see examples (ideally in a notebook :D)