Graph of Thoughts: Search Generalization Beyond Trees
Graph of Thoughts (GoT) generalizes inference-time LLM reasoning from a single chain or branching tree into an explicit graph of intermediate artifacts that can be generated, scored, refined, pruned, and merged. The central claim is not that every reasoning task needs an arbitrary graph, but that tasks with reusable partial results, convergent evidence, or natural merge operators expose a weakness in tree-only search. This article covers Besta et al.’s AAAI 2024 GoT framework, its algorithmic structure, empirical results, implementation realities, adjacent work, and the still-open question of whether graph-structured reasoning is broadly necessary. AAAI Publications
Coverage note: verified through May 11, 2026.
1. Why “graph of thoughts” matters
The intellectual move behind Graph of Thoughts is simple: treat LLM inference as a search process over intermediate natural-language or structured states, then stop assuming that the search space must be a line or a tree. Chain-of-Thought Prompting made intermediate reasoning explicit as a sequence; Self-Consistency Decoding sampled multiple chains and selected the answer with the most agreement; Tree of Thoughts introduced deliberate branching, self-evaluation, lookahead, and backtracking over “thought” units. GoT adds the missing operation that trees forbid: two or more partial reasoning products can converge into a new node. AAAI Publications+3OpenReview+3OpenReview+3
Besta et al.’s paper, Graph of Thoughts: Solving Elaborate Problems with Large Language Models, defines an LLM reasoning process as a directed graph whose vertices are “thoughts” and whose edges record dependencies between thoughts. A thought can be a paragraph, a sorted subarray, a partial set intersection, a keyword count dictionary, or any other intermediate representation appropriate to the task. The key graph-enabled transformations are aggregation, refinement loops, and arbitrary removal or pruning of vertices and edges; these strictly extend the operations available in CoT, self-consistency, and ToT. AAAI Publications+2AAAI Publications+2
The strongest practical intuition is borrowed from ordinary algorithms: sorting, summarization, retrieval, document synthesis, proof search, and planning often do not look like one heroic line of reasoning. They look like decomposition, local solution, verification, and recomposition. A tree is good when branches are alternative futures and only one path survives. A graph is useful when multiple branches produce artifacts that should be preserved and merged. AAAI Publications
2. Position in the thought-structure-search family
The broader literature can be read as a sequence of increasingly explicit Reasoning Topologies. CoT creates a path. Self-consistency creates many independent paths and votes at the end. ToT creates a tree whose nodes are partial solutions and whose edges are expansions. GoT creates a graph whose nodes may be partial solutions, summaries, critiques, counts, sorted chunks, or merged artifacts, and whose edges describe causal or dependency relationships. AAAI Publications+3OpenReview+3OpenReview+3
| Scheme | Topology | Main operation | Evaluation mechanism | Strength | Structural limitation |
|---|---|---|---|---|---|
| Direct input-output prompting | Single node | Generate one answer | None or post-hoc check | Cheap, simple | No explicit intermediate state |
| CoT | Path | Generate sequential intermediate steps | Usually implicit in final answer | Strong baseline for multi-step tasks | No branching or merge |
| CoT + self-consistency | Independent paths | Sample several chains, vote/marginalize | Answer agreement | Improves reliability on many arithmetic and commonsense benchmarks | Paths do not share partial work |
| ToT | Tree | Expand, score, prune, backtrack | LLM/self-evaluation or task score | Good for deliberate search and mutually exclusive branches | Branches do not naturally recombine |
| MCTS-based LLM planning | Usually tree search | Selection, expansion, simulation/evaluation, backup | Reward/value function | Principled exploration-exploitation | Often treats states as tree nodes unless transpositions are explicitly shared |
| GoT | Directed graph | Generate, score, refine, aggregate, prune | Local functions, LLM, human, or external judge | Supports reusable partial products and convergence | Requires task-specific graph design and orchestration |
Self-consistency is important because it separates “more reasoning tokens” from “better search topology.” Wang et al. sample diverse CoT paths and select the most consistent answer by marginalizing over them, reporting gains such as +17.9% on GSM8K and +11.0% on SVAMP, but the method is still structurally a set of independent chains. ToT then makes the search explicit: it considers multiple reasoning paths, self-evaluates choices, looks ahead, and backtracks; in the original Game of 24 result, GPT-4 with CoT solved 4% of tasks while ToT reached 74%. OpenReview
GoT’s distinguishing claim is not “more samples” or “deeper search.” It is that some inference-time computations need joins. Besta et al.’s own comparison table gives GoT full support for arbitrary graphs where CoT, CoT-SC, and ToT do not; their Figure 1 describes GoT’s novelty beyond ToT as aggregating thoughts into a new one and looping over thoughts for refinement. AAAI Publications
3. The Besta et al. GoT framework
Besta et al. formalize GoT as a tuple (G,T,E,R)(G, T, E, R)(G,T,E,R): GGG is the current reasoning graph, TTT is the set of thought transformations, EEE is an evaluator that assigns scores, and RRR is a ranking function that selects relevant thoughts. The reasoning graph G=(V,E)G=(V,E)G=(V,E) contains thought vertices and directed dependency edges; an edge (t1,t2)(t_1,t_2)(t1,t2) means that t2t_2t2 was constructed using t1t_1t1 as direct input. AAAI Publications
The transformation T(G,pθ)T(G,p_\theta)T(G,pθ) modifies the graph using the LLM pθp_\thetapθ. In the paper’s notation, a transformation can add vertices and edges, remove them, or both; this supports not only expansion but also pruning and abandonment of unpromising intermediate state. Three transformations are central: generation, which creates one or more thoughts from a prior thought; aggregation, which combines arbitrary thoughts or reasoning paths into a new thought; and refinement, which loops over a thought to improve it. AAAI Publications
A compact way to read the framework is as an inference-time search controller:
state: directed graph G of thoughtsrepeat according to a graph-of-operations plan: select one or more thought nodes from G apply an operation: Generate(t, k) -> k candidate successor thoughts Aggregate(t1...tk) -> one or more merged thoughts Score(t) -> value / quality estimate Validate(t) -> correctness check ValidateAndImprove(t) -> refinement loop KeepBest(N) -> pruning / ranking parse outputs into structured thought states update G with new nodes, edges, validity flags, and scoresreturn selected final thought(s)
The paper’s implementation architecture separates the static execution plan, called the Graph of Operations (GoO), from the dynamic Graph Reasoning State (GRS). The GoO prescribes which operations to run and in what dependency structure; the GRS maintains the evolving state of generated thoughts, their parsed states, validity, scores, and execution history. The Prompter encodes graph state into prompts, the Parser extracts structured state from LLM replies, the Scoring/Validation module assigns scores, and the Controller coordinates selection and operation execution. AAAI Publications
The “LLM as policy + value” interpretation should be stated carefully. Besta et al. do not present GoT as a reinforcement-learning algorithm. Their formalism separates the LLM pθp_\thetapθ, evaluator EEE, and ranking function RRR. But in search terms, the LLM often acts as a policy when it proposes candidate thoughts, and it can also act as a value estimator when scoring or validating thoughts. The framework also allows non-LLM scoring: sorting can use a local scoring function, document merging can use LLM-derived redundancy and retention scores, and human scoring is allowed by the architecture. AAAI Publications+2AAAI Publications+2
This distinction matters for engineering. GoT is not a claim that the base model internally reasons as a graph. It is an external orchestration pattern: graph state is represented outside the model, then selectively serialized into prompts. The model supplies local transformations over that represented state. GitHub
4. Empirical results in the AAAI 2024 paper
Besta et al. evaluate GoT against input-output prompting, CoT, CoT with self-consistency, and ToT-style baselines on four task families: sorting, set intersection, keyword counting, and document merging. The experiments use 100 input samples for each task and baseline unless otherwise stated, temperature 1.0, and a 4k context window except for document merging, which uses 50 samples and a 16k context. Due to budget limits, the paper focuses on GPT-3.5; the authors report that Llama 2 was usually worse and slower in their setup, making enough samples infeasible. AAAI Publications
4.1 Sorting
Sorting is the cleanest demonstration because the desired decomposition is algorithmically obvious. The task is sorting numbers 0–9 with duplicates; the paper notes that considered LLMs struggle to sort longer sequences consistently because duplicate counts fail. GoT uses merge-style sorting: split the input into subarrays, sort the subarrays, score candidates, keep the best partial sorted sequences, and aggregate them into larger sorted arrays until reaching the final result. AAAI Publications
For sorting 128 numbers, GoT reduces median error by about 62% relative to ToT while also reducing cost by more than 31%. For sorting 64 numbers, GoT’s median error is about 65% lower than CoT and 83% lower than direct input-output prompting, although the paper is explicit that GoT and ToT cost more than IO and CoT because they generate multiple thoughts per operation. AAAI Publications
The result is strong but narrow. Sorting with duplicates is a synthetic algorithmic task where decomposition and merge are known in advance. GoT wins here because the graph can imitate a merge algorithm; that does not prove that arbitrary graph reasoning is needed for open-domain reasoning. It does show that when the task has a natural decomposition/aggregation operator, tree search can waste work that graph aggregation can reuse. AAAI Publications
4.2 Set intersection
Set intersection is implemented similarly to sorting. The second input set is split into subsets; each subset is intersected with the first set using the LLM; the partial intersections are then aggregated into the final result. The evaluation varies set sizes of 32, 64, and 128 elements and varies overlap between 25% and 75%. AAAI Publications
This task again favors graph decomposition because partial intersections are independent and exactly mergeable. A tree can explore alternative partial answers, but the task does not fundamentally ask for a single branch. It asks for distributed local computations whose outputs should be combined. The paper’s overall analysis reports that GoT improves output quality over all considered baselines and reduces inference costs compared with ToT. AAAI Publications
4.3 Keyword counting
Keyword counting asks the model to find frequencies of keywords in a category, with countries used in the paper’s implementation. GoT splits the input into passages, counts keywords in each passage, and aggregates the subresults; the number of passages is configurable and can be left to the LLM, including the extreme of treating each sentence as a separate passage. Scoring uses the summed absolute difference between computed and correct counts for each keyword. AAAI Publications
Keyword counting reveals a key implementation trade-off: decomposition reduces the variable part of each prompt, but the static few-shot portion can become a significant overhead when repeated many times. Besta et al. explicitly discuss this overhead, noting that few-shot examples may need to be reduced in size when subtasks become smaller. This is an important negative result disguised as an engineering note: graph decomposition can be cost-effective only when the savings from smaller subproblems exceed the overhead from repeated prompts, parsing, scoring, and aggregation. AAAI Publications
4.4 Document merging
Document merging is less algorithmically crisp and more representative of practical synthesis tasks. The paper’s setup asks the model to generate a new NDA from several partially overlapping NDAs while minimizing duplication and maximizing information retention. Scoring queries the LLM for redundancy and information-retention values, averages three queries for each value, and computes their harmonic mean. AAAI Publications
This is the most realistic of the original tasks, but also the least cleanly measured. Unlike sorting or set intersection, there is no exact ground-truth comparison. The evaluation depends on LLM scoring of redundancy and retention, so the result is evidence about an orchestrated LLM-and-judge system rather than a clean demonstration of objective reasoning quality. It is still relevant because many production uses of GoT-like systems are document synthesis and report-building pipelines, where merge quality matters more than a single final answer. AAAI Publications
5. What the results do and do not establish
The original paper’s strongest empirical statement is task-specific: GoT improves quality over the evaluated baselines and reduces inference costs compared with ToT on the tested workloads. The headline result is the sorting improvement of 62% over ToT with more than 31% lower cost; the broader claim is that GoT’s advantage grows with problem size because larger tasks benefit more from decomposition, independent subproblem solving, and incremental merging. AAAI Publications
The evidence is thinner for a universal claim about reasoning. The tasks are selected to showcase graph-friendly transformations. The paper itself presents representative results after a large evaluation space and omits data that does not add relevant insights. It focuses primarily on GPT-3.5 for budget reasons. These choices are legitimate for an initial systems paper, but they mean GoT should not be read as proving that arbitrary graphs are generally superior to trees. AAAI Publications
A later taxonomy paper, Demystifying Chains, Trees, and Graphs of Thoughts, reinforces this caution by showing that the “thought topology” literature lacks a consistent benchmark set across approaches. It notes that Besta et al.’s GoT uses sorting, set intersection, keyword counting, and document merging; Lei et al.’s Graph of Thought uses Game of 24, polynomial equations, and recursive sequences; Yao et al.’s GoT evaluates AQUA-RAT/ScienceQA-style reasoning; and other systems use still other tasks. The authors conclude that there is no clear benchmark set used consistently across approaches. arXiv
6. Cost-quality position relative to CoT, self-consistency, ToT, and MCTS
The useful mental model is Inference-Time Scaling under a budget. You can spend extra inference on longer chains, more sampled answers, deeper trees, MCTS rollouts, or graph-structured decomposition. GoT’s value proposition is that graph aggregation can increase the amount of relevant prior work available to a final thought without forcing all of that work to sit on a single long path. AAAI Publications
Besta et al. formalize this as a latency-volume trade-off. In their analysis, “latency” is the number of graph hops needed to reach a final thought, while “volume” is the number of preceding thoughts that could have influenced that thought. CoT has high volume but high latency; CoT-SC lowers latency but also lowers volume per final thought; ToT has low latency but low volume; GoT achieves low latency and high volume because aggregation lets information from many intermediate thoughts flow into a final node. AAAI Publications
| Method | Cost behavior | Quality mechanism | Best fit | Failure mode |
|---|---|---|---|---|
| CoT | Low to moderate | One explicit reasoning path | Short multi-step problems | Early mistake poisons path |
| Self-consistency | Linear in number of samples | Diversity plus answer agreement | Problems with unique answer and many valid derivations | Wastes samples when answers are hard to vote |
| ToT | Branching cost; can be high | Search, scoring, pruning, backtracking | Puzzles, planning, creative search with alternative branches | No natural sharing between branches |
| MCTS/RAP/LATS | Potentially high but principled | Exploration-exploitation via rewards/value | Environments, planning, interactive tasks | Requires reward/value design; rollout cost |
| GoT | Overhead plus decomposition/merge savings | Reusable partial products and aggregation | Map-reduce-like reasoning, synthesis, merging, counting, retrieval | Graph design burden; aggregation and judging errors |
MCTS-based systems are adjacent but not identical. RAP repurposes the LLM as both a world model and a reasoning agent, using Monte Carlo Tree Search to build a reasoning tree guided by rewards; the paper reports results on plan generation, math reasoning, and logical inference, including a 33% relative improvement for LLaMA-33B RAP over CoT on GPT-4 in a plan-generation setting. LATS integrates MCTS with language-agent action, LM-powered value functions, self-reflection, and environment feedback, reporting evaluations across programming, interactive QA, web navigation, and math. ACL Anthology
The key difference is recombination. MCTS can be adapted to graph search when repeated states are recognized as transpositions, but much of the LLM planning literature describes tree search over reasoning paths or action trajectories. GoT begins from a graph abstraction, so merge and refinement are first-class operations rather than implementation optimizations. ACL Anthology+2Proceedings of Machine Learning Research+2
7. Implementation realities
The official GoT implementation is the spcl/graph-of-thoughts repository. It describes the framework as solving complex problems by modeling them as a Graph of Operations that is automatically executed with an LLM as the engine, and it explicitly says the framework is flexible enough to implement GoT as well as GoO structures resembling CoT or ToT. The repository supports installation via pip install graph_of_thoughts and includes task-specific examples such as sorting. GitHub
In practice, implementing GoT requires more than drawing a graph. A production GoT-like system needs stable thought identifiers, typed state, parser robustness, retry logic, scoring functions, budget controls, caching, provenance, concurrency, and observability. It also needs domain-specific merge semantics: merging two sorted subarrays is a crisp operation; merging two legal summaries, two plans, or two research hypotheses is not. These requirements follow from the paper’s architecture: the Prompter must encode graph state, the Parser must extract structured state, the Scoring module must validate outputs, and the Controller must decide which transformations to apply. AAAI Publications
LangChain integration is not “automatic GoT.” A LangChain GitHub issue asking whether Graph of Thoughts could be implemented with LangChain was opened in September 2023 and closed with no branches or pull requests attached. That is not evidence that LangChain cannot implement GoT; it is evidence that GoT did not become a standard LangChain primitive through that issue. GitHub
LangGraph is a more natural fit than classic linear chains because it models agent workflows as graphs with shared state, nodes, and edges, including looping workflows that evolve state over time. Its documentation describes nodes as functions, edges as control-flow decisions, and state as the shared snapshot of the application; its GitHub README calls it a low-level orchestration framework for long-running, stateful agents with durable execution, human-in-the-loop support, memory, and debugging. LangChain Docs
But LangGraph is an orchestration substrate, not a GoT algorithm. It can express GoT-like workflows, but the developer still has to define thought schemas, operation semantics, scoring, pruning, aggregation prompts, parsing, and stop conditions. The clean distinction is: LangGraph gives you stateful graph execution; GoT gives you a reasoning-search topology and a family of graph transformations. LangChain Docs
8. Design patterns for graph-structured reasoning
Several recurring patterns justify GoT-like orchestration:
| Pattern | Graph shape | Example use | Why tree search is awkward |
|---|---|---|---|
| Map-reduce reasoning | Many leaves converge to aggregate nodes | Keyword counts, extraction, document synthesis | Branches are not alternatives; all partial results matter |
| Merge-search | Independent candidates combine | Sorting, set intersection, multi-source synthesis | A final answer depends on multiple branches |
| Critique-refine loops | Self-loop or cycle | Draft → critique → revision | The same artifact is updated, not merely expanded |
| Evidence graph | Retrieved facts connect to claims | Research reports, legal analysis | Dependencies matter; evidence can support multiple claims |
| Multi-agent synthesis | Specialist nodes feed mediator nodes | Debate, planning, review | Agents produce reusable artifacts rather than exclusive paths |
| Tool-augmented task graph | Tool outputs become nodes | Code execution, search, calculators, databases | Tool state must be preserved and cross-referenced |
The strongest design rule is to ask whether the task has a meaningful merge operator. If partial results can be independently produced and later combined with lower difficulty than solving the full task at once, GoT has a plausible advantage. Besta et al. make exactly this point in their task-decomposition discussion: graph decomposition should break the task down until the LLM can solve most subtasks with a single prompt, and combining or concatenating subresults is often easier than solving a large instance from scratch. AAAI Publications
The second rule is to ask whether the score is trustworthy. GoT’s graph can only improve search if selection and aggregation do not systematically preserve bad nodes. Local scoring is strong for sorting and counting; LLM-as-judge scoring is weaker for subjective synthesis. This is why document merging is useful as an application example but weaker as a proof of general reasoning improvement. AAAI Publications
9. Recent extensions and adjacent formulations
“Graph of Thoughts” is not a single unified line of work. The phrase now covers several related but distinct ideas: external graph-orchestrated prompting, graph encoders over thought units, graph-like single-model traces, knowledge graphs for agent state, workflow networks, and graph-guided reward generation.
Yao, Li, and Zhao’s NAACL Findings 2024 paper, GoT: Effective Graph-of-Thought Reasoning in Language Models, is not the same as Besta et al.’s external orchestration framework. It represents thought units as nodes and edges, uses a two-stage framework with an additional GoT encoder, and fuses the graph representation with the original input through gated fusion. It evaluates on AQUA-RAT and ScienceQA, reporting an improvement from 85.19% to 87.59% with T5-base over Multimodal-CoT on ScienceQA. ACL Anthology
Lei et al.’s Boosting Logical Reasoning in Large Language Models through a New Framework: The Graph of Thought is another 2023 preprint using the GoT name. It evaluates on the 24-point game, high-degree polynomial equations, and recursive sequence formula derivation, reporting average accuracy boosts over ToT on those tasks. This is best treated as adjacent graph-structured prompting rather than the same framework as Besta et al.’s Graph of Operations architecture. arXiv
Diagram of Thought attempts to internalize graph-like reasoning within a single autoregressive model rather than relying on external controllers. Zhang, Yuan, and Yao describe DoT as a framework where a single model constructs a directed acyclic graph of propositions, critiques, refinements, verifications, and summaries, using role-specific tokens and validation machinery instead of external multi-call search orchestration. arXiv
Knowledge Graph of Thoughts (KGoT) moves from a graph of prompt-level thoughts to a dynamic knowledge graph representing task contents and resolution state. The KGoT paper describes an assistant architecture that extracts and structures task-relevant knowledge into an evolving KG, enhanced with tools such as math solvers, web crawlers, and Python scripts; it reports a 29% task-success improvement on GAIA over Hugging Face Agents with GPT-4o mini and more than 36× cost reduction relative to GPT-4o by using smaller models. These are primary-source claims and should be treated as claims until independently replicated. arXiv
Knowledgeable Network of Thoughts (kNoT) reframes the problem as executable workflow synthesis. Its preprint introduces an LLM Workflow Template in which single-step LLM operations are nodes and edges pass messages between them; it claims 92% accuracy for sorting 32 numbers versus 12% for ToT and 31% for GoT, while reducing task-specific prompting. Again, this is a recent preprint result, not a settled benchmark conclusion. arXiv
Reward Evolution with Graph-of-Thoughts (RE-GoT) applies graph-of-thought reasoning to reinforcement-learning reward design. The 2025/2026 arXiv version describes a bi-level framework that decomposes tasks into text-attributed graphs, generates reward functions, and iteratively refines them using visual feedback from VLMs; it reports +32.25% average task success on RoboGen and 93.73% average success across four ManiSkill2 manipulation tasks. This extends GoT from answer synthesis into automated reward engineering, but the evidence is still concentrated in one paper’s experimental setup. arXiv
Graph-based CoT pruning is a different but relevant direction. A 2026 arXiv paper argues that reasoning LLMs can waste tokens on inefficient reflection, converts linear CoT traces into directed acyclic graphs with dependency edges, and prunes weak reflection branches or late redundant re-verification. This does not use GoT as a multi-call orchestration framework; it uses graph structure to analyze and compress reasoning traces. arXiv
XoT, or Everything of Thoughts, is another adjacent branch. It uses pretrained reinforcement learning and Monte Carlo Tree Search to incorporate external domain knowledge into thought generation and produce cognitive mappings with fewer LLM interactions; its evaluated tasks include Game of 24, 8-Puzzle, and Pocket Cube. It sits closer to MCTS-guided thought generation than to Besta-style graph aggregation, but it shares the premise that reasoning topology is an inference-time object to be optimized. arXiv
10. Are graphs genuinely needed?
The honest answer is: sometimes, and the field has not proved how often. The strongest case for GoT arises when reasoning artifacts are reusable and convergent. Sorting subarrays, counting keywords across passages, merging overlapping documents, synthesizing multi-source evidence, and maintaining a tool-produced knowledge graph all have graph-like structure because multiple partial products jointly determine the final answer. AAAI Publications+2AAAI Publications+2
Trees are sufficient when branches are mutually exclusive alternatives and the goal is to choose one. Game of 24, crossword solving, many planning rollouts, and many code-generation search procedures can be represented naturally as trees. ToT and MCTS are strong choices when the system needs lookahead, backtracking, and value-guided exploration but does not need to merge partial products from independent branches. arXiv+2ACL Anthology+2
There is also a subtle equivalence issue. A tree plus a final “synthesize the best branches” step becomes a directed acyclic graph the moment the synthesis node depends on multiple branches. Many systems described as tree search already do informal graph-like synthesis at the end. The practical question is whether making this graph explicit improves controllability, reuse, evaluation, and cost—not whether any tree can be mathematically transformed into a graph.
The open empirical question is broad generality. The post-CoT literature uses inconsistent benchmarks, inconsistent budgets, different base models, different prompt engineering, and different definitions of “thought.” The taxonomy paper’s observation that there is no consistent benchmark set across these approaches should be taken seriously. Without standardized budgets and tasks, claims about graphs beating trees are often claims about a particular graph schedule, task decomposition, evaluator, and model. arXiv
11. Practical judgment
GoT is best understood as a systems pattern for LLM Orchestration, not a magic reasoning upgrade. It gives engineers a vocabulary for stateful inference: create partial artifacts, score them, keep the useful ones, refine weak ones, merge compatible ones, and preserve provenance. This is valuable because many real workflows already have graph structure: research synthesis, legal comparison, data extraction, multi-hop retrieval, agent tool use, and report generation.
Its costs are equally real. The orchestrator must be written. The graph schedule is often hand-designed. Prompts and parsers become operation-specific. LLM judging can be noisy. Aggregation can lose information or introduce contradictions. Static prompt overhead can dominate when subtasks become too small. More topology does not automatically mean better reasoning; it means more places for engineering choices to matter. AAAI Publications
The most defensible thesis is moderate: graph-structured reasoning is genuinely useful for tasks whose computational structure includes convergence, reuse, or iterative refinement; trees remain sufficient for many search problems whose branches are alternatives; and the literature has not yet established that arbitrary graph reasoning is broadly necessary for most LLM reasoning tasks.
References
[Besta et al., Graph of Thoughts: Solving Elaborate Problems with Large Language Models — AAAI 2024] Primary paper introducing GoT as arbitrary graph-structured prompting with thoughts as vertices and dependencies as edges. AAAI Publications
[Besta et al., official graph-of-thoughts implementation] Official implementation describing Graph of Operations execution with an LLM engine and PyPI installation. GitHub
[Wei et al., Chain-of-Thought Prompting Elicits Reasoning in Large Language Models — NeurIPS 2022] Foundational CoT paper. OpenReview
[Wang et al., Self-Consistency Improves Chain of Thought Reasoning in Language Models — ICLR 2023] Self-consistency decoding over sampled CoT paths. OpenReview
[Yao et al., Tree of Thoughts: Deliberate Problem Solving with Large Language Models — NeurIPS 2023] Tree-structured search over thought units. arXiv
[Hao et al., Reasoning with Language Model is Planning with World Model — EMNLP 2023] RAP, an MCTS-based planning framework for LLM reasoning. ACL Anthology
[Zhou et al., Language Agent Tree Search Unifies Reasoning, Acting, and Planning in Language Models — ICML 2024] LATS, integrating MCTS, LM value functions, self-reflection, and environment feedback. Proceedings of Machine Learning Research
[Besta et al., Demystifying Chains, Trees, and Graphs of Thoughts] Taxonomy of reasoning topologies and benchmark-fragmentation analysis. arXiv
[Yao, Li, and Zhao, GoT: Effective Graph-of-Thought Reasoning in Language Models — Findings of NAACL 2024] Graph encoder and gated-fusion version of GoT, distinct from Besta et al.’s external orchestration framework. ACL Anthology
[Zhang, Yuan, and Yao, On the Diagram of Thought] Single-model DAG-structured reasoning proposal. arXiv
[Besta et al., Affordable AI Assistants with Knowledge Graph of Thoughts] KGoT, extending thought graphs into dynamic knowledge graphs for tool-using assistants. arXiv
Companion entries
Core theory: Chain-of-Thought Prompting, Self-Consistency Decoding, Tree of Thoughts, Graph Search, Monte Carlo Tree Search, Inference-Time Scaling, Reasoning Topologies
GoT architecture: Graph of Thoughts, Graph of Operations, Graph Reasoning State, LLM-as-Judge, Value Functions for LLMs, Thought Aggregation, Prompt Graphs
Implementation: LLM Orchestration, LangGraph, Custom Agent Controllers, Structured Output Parsing, Prompt Caching, Search Budgeting, Observability for Agentic Systems
Extensions: Diagram of Thought, Knowledge Graph of Thoughts, Knowledgeable Network of Thoughts, Everything of Thoughts, Reward Evolution with Graph-of-Thoughts, Graph-Based CoT Pruning
Evaluation and counterarguments: Reasoning Benchmark Design, When Trees Are Enough, Prompt Overhead and Search Degeneracy, LLM-as-Judge Reliability, Synthetic Reasoning Tasks, The Myth of General Reasoning Algorithms