Enhancing Graph Of Thought: Enhancing Prompts with LLM Rationales and Dynamic Temperature Control
Authors: SungUk Shin
Youngjoon Kim
Venue: ICLR 2025 Poster (2025)
Keywords: LLM
Enhancing Graph Of Thought
Complex Reasoning
Primary area: foundation or frontier models, including LLMs
TL;DR: To improve the quality of responses from the LLM, reasonings are continually added to the prompt, and the temperature is gradually lowered.

Abstract: We introduce Enhancing Graph of Thoughts (EGoT), a method designed to enhance the performance of large language models (LLMs) on complex reasoning tasks. EGoT automates the process of generating accurate responses using given data and a base prompt. The process consists of several steps: It obtains an initial response from the answering node using the base prompt. Evaluation node evaluates the response and generates reasoning for it, utilizing the score's probabilities to enhance evaluation accuracy. The reasoning from both the answering node and the evaluation node is aggregated to identify the problem in the response. This aggregated reasoning is incorporated into the base prompt to obtain an enhanced response. These steps are organized in a graph architecture, where the final leaf nodes are merged to produce a final response. As the graph descends, the temperature is lowered using Cosine Annealing and scoring, to explore diverse responses with earlier nodes and to focus on precise responses with later nodes. The minimum temperature in Cosine Annealing is adjusted based on scoring, ensuring that nodes with low scores continue to explore diverse responses, while those with high scores confirm accurate responses. In sorting 256 elements using GPT-4o mini, EGoT performs 88.31\% accuracy, while GoT (Graph of Thoughts) achieves 84.37\% accuracy. In the frozen lake problem using GPT-4o, EGoT averages 0.55 jumps or falls into the hole, while ToT (Tree of Thoughts) averages 0.89.

Published as a conference paper at ICLR 2025
ENHANCING GRAPH OF THOUGHT: ENHANCING PROMPTS WITH LLM RATIONALES AND DYNAMIC TEMPERATURE CONTROL
Sunguk Shin and Youngjoon Kim
Korea University Scoul, Republic of Korea (ssw1419 419, (horn421J@koreee ac. kr
ABSTRACT
We introduce Enhancing Graph of Thoughts (EGoTT), method designed to en- hance the performance of large language models (LLMs) on complex reasoning tasks. EGoT automates the process of generating accurate responses using given data and base prompt. The process consists of several steps: obtains an initial response from the answering node using the base prompt. Evaluation node evalu- ates the response and generates reasoning for it, utilizing the score's probabilities enhance evaluation accuracy. The reasoning from both the answering node and the evaluation node is aggregated to identify the problem in the response. This aggregated reasoning incorporated into the base prompt obtain an enhanced response. These steps are organized in graph architecture, where the final leaf nodes are merged produce final response. As the graph descends, the temper- ature is lowered using Cosine Annealing and scoring, to explore diverse responses with earlier nodes and to focus on precise responses with later nodes. The mini- mum temperature in Cosine Annealing is adjusted based on scoring, ensuring that nodes with low scores continue explore diverse responses, while those with high scores confirm accurate responses. In sorting 256 elements using GPT-4o mini, EGoT performs 88.31 % accuracy, while GoT (Graph of Thoughts) achieves 84.37% accuracy. In the frozen lake problem using GPT-4o, EGoT averages 0.55 jumps or falls into the hole, while ToT (Tree of Thoughts) averages 0.89.
INTRODUCTION
In recent research, the performance of large language models (LLMs) has evolved incredibly rapidly, with applications in a variety of fields, including math problem (Shao al. 2024), roboties (Park et al. 2023), medicine (Lee et al. 2024b Kwon et al., 2024), and even programming (Wang et al.] 2023a Duong Meng M024|McAleess al. (024). To further improve the performance of LLMs, researchers are now actively exploring methods to significantly scale up the architecture of models, or optimize models through distillation (Qu al. 2024) and fine-tuning (Singh al., (024)). These efforts are broadening the scope of L.LMs and enabling more innovative applications.
Training LLMs directly requires significant time and GPU resources. To address such limitations, Prompt engineering, which involves designing effective prompts rather than training the model di- rectly, stands out. Prompt engineering is a technique that can improve the performance of LLMs on specific tasks without requiring additional training. Examples of prompt engineering include Chain of Thought (CoT) (Wei et al., 2022), Chain of Thought with Self-Consistnncy (CoT-SC) (Wang et al. (2023b), Tree of Thoughts (ToT) (Long] 2023 Yao et al. 2024), Exchange of Thought (EoT) (Yin et al.] (023), and Graph of Thoughts (GoT)) (Besta et al.
2024). These approaches help L.MSs
generate more accurate and useful results.
However, complex problems often impair the reasoning ability of LLMs. When an LLM provides correct answer, its rationale steps are always reliable (Hao et al.
2024). In addition, most architectures utilize external tools (Stechly et al. 2023 Gou et al. 2024 to improve performance,
"Corresponding author

---

Published as a conference paper at ICLR 2025
and prompts often require specific examples (Lee al. 2024a). Since obtaining the valid rationale makes LLM's performance highly contributing Yin et al. (2024), the technique of prompting LLMs with score evaluate the performance (Valmeekam al. 2023 Ren al. 2023) is ongoing research area. There is also research exploring dynamic temperature control techniques (Cai et al,
2024 Nasir et al. 2024 Zhang et al. 2024 Zhu al. 2024 further enhance the reasoning ability LLMs.
Our approach, EGoT, is architecture that automatically generate the prompts and answers from the LLM by only initializing the base prompt. During this process, log probability is utilized evaluate the LLM's responses, increasing their confidence. We also propose dynamically adjust- ing the temperature based on the progress and score of the answer, applying the cosine annealing (Lohhchloov & Hutter, 2016) to set high temperature at the beginning of the graph and low tem- perature at the end. The minimum temperature is set as the inverse of the score, so that nodes with high scores consistently provide correct answers, while nodes with low scores explore wide range of answers. This approach has the advantage of showing constant and consistent performance with- out the evaluation metric, and it does not need additional examples to avoid bias in the results. Note that study proposes a framework that strategically resolves conflicts from naively merging prior methods through trade-offs, thereby ensuring high performance.
To summarize, EGoT provides the following advantages:
Dynamic temperature control using Cosine Annealing to propagate more accurate ratio- nales to child node prompts.
Continuously appending of rationales to the base prompt in graph architecture to generate high-quality final response.
Enhanced confidence by utilizing the probability of LLM answers for scoring, while avoid- ing bias by excluding specific examples.
Direct repetition of the input question in its original form to improve LLM comprehension, followed by integration of prior repetitions into the rationale.
EGoT ARCHITECTURE
2.1
OVERVIEW
rationale (tw)
Tomperstan
Edgo
Nodeya
Vode
Ratorall Edge
natieaates
Reftre, If the parest's
Ananortng
Update
Updaaee
Sode
answering mothed. (eu, m.)
Depth
Nodeya
Nude:
Nudrag
Nodesa
Ancwver Int
Nethod toce
Beftiee Af Prjj)
Paaluation Rade
rationale (r.)
Nodeya
Nudeea
Nudra
Evaluation ratienale (r.)
Previde final rationales
Rationala Rode
Finel
Final
Hode
Finnd snswer (s)
Aggrogatul rationale (tw)
Figure 1: Framework of EGoT. The left side illustrates the overall graph architecture and dynamic temperature. The right side illustrates the internals of each Node. Each Node contains ANSWER- INGNODE, EVALLUATIONNNDS and AGGREGATER, ATIONALENNDE as sub-nodes. The tempera- ture parameter updates child nodes within the tree, propagating the rationale information to deeper levels. As the graph progresses, the temperature decreases and propagates the rationale information.
The EGoT graph structure is shown Figure I Each node consists three stages: Stage 1 (ANSWERINGNODD)) obtains the answer resolve the problem from the LLM;; Stage
2

---

Published as a conference paper at ICLR 2025
(EVALUATIONNODE) asks the LLM to evaluate its response and assign score; and Stage AATGEEEGATERRATONNLLEENEEE
collects the LLM's rationales from both Stage and Stage 2, forwarding them to the next nodes. METHODNODE is executed only once at the beginning of the overall structure, and this step can be replaced with an expert's problem-solving approach.
2.2 МЕТHOО NODE
The METHODNODE inquires about the method for solving the problem and the methods for evalu- ating the answer. Although these methodologies can be formulated by human experts, in this paper, heuristic methods are requested from the LLM and utilized. mh denotes the method for obtaining the answer to the question, and my denotes the method for evaluating the answer. denotes the temperature of the LLM.
Ma: me METHODNODE(Prompp, t =0)
2.3 ANSWERING NODE
ANSWERINGNODE finds the answer to the problem. The top root node solves the problem with the rules. The child node solves the problem using the rationale from the previous nodes. ANSWER- INGNODE outputs the answer to the problem and the rationale for the answer. and ra are the answer and the rationale regarding the response provided by the LLM, and Fpr denotes the ratio- nales of the previous nodes. In this study, the temperature is fixed at for the root node, while for all other nodes is determined by the parent's temperature using cosine annealing. We denote the updated temperature as t..
(INEERINNNODD((PPPPllllm (, 1), if ANSWERINGNODDI(PPOngg Tyr), tw),
Node Root Node
(2)
else Node of
Root Node
2.4 EVALUATION NODE
EVALUATIONNODE evaluates the answer provided by ANSWERINGNODE. The LLM outputs both the accuracy of the answer and the rationale for that accuracy score. If the probability of the score provided by the LLM is lower than the threshold, EVALUATIONNODE is executed again. and r, are the score and the rationale regarding the LLM's response, and Pr(s) is the probability of the score. We request score range of 0 to 100 from the LLM to better represent the scores percentages.
8,Y,, Pr(s)= EVALUATIINN a), 0)
2.5 AGGREGATE RATIONALE NODE
AGGREGATERRATIOVALENOSS integrates the rationales provided from ANSWERINGNODE and EVALUATIONNODE, The LLM outputs the aggregated rationale along with the information con- sidered inaccurate. AGGREGATER ATIONALENODS aggregates the information from the answer rationale and the evaluation rationale, emphasizing the incorrect encountered during the reasoning while omitting details related to successful outputs. This concept is similar to the state evaluator in ToT (Yao et al. 2024); however, our approach provides rationale for identifying flaws without the answer. The inaccurate information refers to elements that the LLM needs to recheck when conflicts occur between the two input rationales. It arises from the LLM's misinterpretation of the problem and can lead to hallucinations and incorrect reasoning. This information, derived from is subsequently incorporated into the prompt of the child's AN- SWERINGNODE. Tpr denotes the aggregated rationale and the inaccurate information.
AECREGATERATIINNAEENGN
T AAARRCCATERKTTOOAAAAOOOOOPPOOOOO
=0)
3

---

Published as a conference paper at ICLR 2025
3 METHODOLOGY
3.1 ENHANCING RESPONSE
This section describes the methods to obtain enhancing responses from the LLM. Two main ap- proaches are used: exploring varied answers for obtaining enriched responses and utilizing the probability of the answers for more accurate scoring.
3.1.1 EXPLORING VARIED ANSWER
To explore different answers, multiple root nodes utilized in the architecture. Since the tempera- ture decreases along the node depth, multiple graphs are used to generate different answers. some cases, node provides the same answer its parent. To address this, a child ANSWERINGNODE gives the same answer as its parent ANSWERINGNODE. a question is only asked once more. This is because cannot be determined exactly whether is the correct answer during the entire process of the graph.
3.1.2 ENHANCING SCORE
To enhance the scoring process, the probability that the LLM predicts the score token is used to answer the score. the probability does not exceed a predefined threshold, the LLM is prompted for the score again. If the LLM outputs extreme score values, such as 0 or 100. a higher threshold is applied because these extreme scores are considered reliable only when the LLM is highly confident. For scores ranging from I to 99, the threshold is set lower to filter out nonsensical answers. It is important to consider the order which the L.LM asked for the score and the rationale for the score. If the LLM is asked for the rationale first and then the score, the LLM thinks that it has basis in the previous rationale. Therefore, a score of or 100 is often returned regardless of whether the answer is correct not, with probability close to 1. For this reason, the score is asked for before the rationale, and the score is obtained with a variety of scores. Detailed explanations of the threshold settings are provided in each experiment.
3.2 TEMPERATURE CONTROL
The temperature in LLMs is typically set to 1.0 when generating creative answers. Whereas when closer for consistent answers. However, setting
creativity required, the temperature the temperature to from the start can lead to fixed answers and errors.
To gradually decrease temperature as the graph progresses, we employ cosine annealing. When high-quality answer is generated, the temperature is reduced to produce fixed response, whereas when the answer uncertain, the temperature is kept high to explore different answers. The purpose for evaluating answers in EVALUATIONNODE is not only to generate rationale but also to control the temperature. If the score is high, it indicates that the rationale of that ANSWERINGNODE is correct. Therefore, this rationale is forwarded the child nodes, which expected to generate good answers. On the other hand, if the score is low, the answer needs to be revised, and the rationale of ANSWERINGNODE also needs improve, requiring various explorations until it is correct.
In cosine annealing, the maximum temperature (Imaz) is fixed at 0.7 and the minimum temperature set to the inverse of the accuracy. This means that higher accuracy results in lower temperature. The total epoch is set to the total number of nodes (N₂) and the current epoch is defined as the progress of the nodes (N.).
No N
4, = Emin + ((max - (mmn) + cos(
)) Amin = V (c 1)2, c= 8. s-(ss) (5)
Here, represents the confidence of ANSWERINGNODE, If an answer receives high score and the probability assigned to that score by the LLM is also high, the confidence is high. Conversely, an answer receives low score the probability assigned to the score is low, the confidence is low. and tmin are between and 1. The probability is used in tmin to differentiate between high and low probability cases when the I.MM answers the score.
4

---

Published as a conference paper at ICLR 2025
3.3
EXAMPLE USE CASE
Node; 1
N Node2.1
Node3
c: 0.082
c 0.170
c: 0.602
tg 0.695
Eu 0.687
tu 0.669
Depth Rationales
Node
Node
Node22
Node23
Node
Node33
0.595
0.593 1yy 0.462
0.171 * 0.599
00.592 tuu 0.462
cc: 0.166
0.164
ffy 0.461
Ly 0.601
tu 0,603
Depth Rationales
Depth Rationales
Node
Node
Node k2-1 *c: 0. 0.162 tyy 0.454
Node *c: :0:1.770 t2i 0.442
Node
Nodesxa cc 0.171
0c:0.881
cc: 0.642
*c: 0.680 *by 0,052
tly 0,426
ttu 0,066
ty 0.441
Depth N Rationales
Answer Rationale
First, each tile: S at [0,0), [0,1],
at [0.2], Fa [0.3), at [0.4] indicate
H
discrepancies at 2 and 3.2 Upon
rechecking, [2, is hole (H) and [3,2] is hole (H), The valid path avoiding holes is: 0. [1.0] [4.4. This path
Final Node
adheres to the rules, avoids all H tiles,
Figure 2: In the Frozen Lake example, the temperature decreases as it progresses down the graph, various positions are explored and the graph finds the correct answer using the information.
This section uses a practical example illustrate the approaches presented in Sections 2 and 3. Figure 2 shows the results of the Frozen Lake experiment, one of the experimental results that demonstrate the advantages of EGoT. The blue background represents the hole and the light blue represents the frozen tile. The two black points on the top left (0, 0) and bottom right (4, 4) represent the start and end points. The green line indicates the route that the LLM predicts as the answer, the orange square marks what EVVALUATIOONNDSS rationale explains as incorrect because it is hole. The brown triangle represents the position that AGGREGATER ATIONALFNNDE aggregates because the rationale from ANSWERINGNODE and EVALUATIONNODE conflict with each other.
Before the graph starts, METHODNODE is invoked once. The information provided by the METHODNODE is utilized by all subsequent nodes in Figure 2 from Node to the Final Node. In this experiment, the graph starts with root nodes. In ANSW EEWWENIGNN,D, Node1,1 passes through the holes (2, 1), (3, 1), and Nodez, and Node3,1 pass through the holes (2, 4), (3, 4). At EVAL- UATIONNODE, N Vode observes the hole at (2, 1) and N Node2,1 observes the hole at (2, 4). As result, ANSWERINGNODE states that the is incorrect, lowering the confidence of Node1,1

---

Published as a conference paper at ICLR 2025
and Node2,1- Conversely, Node3,1 has high confidence in EVALUATIONNODE: because it does not find anything wrong. Since it is the first round, the temperature remains close to 0.7, regardless of confidence. The node updates the temperature of its two child nodes. Node1,2 and Node1,3 update the temperature by Node1,1-
Because depth 0 informs that the coordinates (2, 1) and (2, are holes, depth nodes recognize them as holes and do not traverse these coordinates. Still, Node Node222 and Node3.3 are unsure of the correct answer because the propagated rationale confuses the information about frozen tile and hole. The nodes in depth I also cannot make confident decision and incorrectly state that (3, 3) is a hole. Since one depth has passed, nodes with higher confidence have lower temperature to update to their child. In the middle of the process (the omitted part of the figure), if a node gives an incorrect answer, the temperature increases again, and explores the coordinate (3, 2). When the final node responds to the answer by incorporating aggregate rationales from the leaf nodes, the LLM explores the correct answer, avoiding (2, 1) and (3, 2).
4 EXPERIMENTS
We use the LangChain (Chase 2022) library to construct the graph. The graph structure starts with three root nodes, and when solving problem, the LLM responds with prompts that include all rationale information from the previous depth. At the end of the graph, the answer is aggregated into one by using the response from ANSWERINGNODE with the prompt that incorporates all the aggregated rationales from the leaf nodes.
EGoT is evaluated through three experiments: document merging, number sorting, and Frozen Lake, In the document merging and number sorting experiments. we use the graphs with depth of 3, and we use a graph with a depth of in the Frozen Lake experiment. We experiment with ToT (Long, 2023] which appends the incorrect answer rather than evaluating and exploring each element. This due to, in the experiments, the number of nodes increases exponentially to explore each case. In the original paper, GoT selects the pest-performin node to evaluate the graph; however, has been modified to select a median value to compare structural performance alone. Solving problems with evaluation metrics is not considered a structural advantage. Therefore, to fully automate the LLM process, the evaluation of nodes is assumed to be randomized and the median value is used as the expectation. Experiments are conducted multiple times with the same data. To compare the impact of temperature, the experiment is conducted with temperature fixed to referred to as EGoT
4.1 DOCUMENT MERGING
We conducted an experiment with the dataset and the evaluation prompt provided by GoT for docu- ment merging. The evaluation compares non-redundancy and retained harmonic mean. The perfor- mance scores for each method are as follows: IO 75..6%), CoT (77.79%), ToT (76.74%) )) GoT (76.43%), EGoT (76.01%), and EGoT* (74.98%). This experiment suggests that scoring with an LLM should not simply be evaluated. The experiment shows that autonomous evaluation by an LLM does not have the logical and structural advantages of well-known CoT and ToT. Furthermore, it supports the idea that scoring should be evaluated more rigorously.
4.2 NUMBER SORTING
This experiment involves sorting problem with random numbers as input. The LLM is able to sort short lists successfully. However, performance decreases when sorting longer lists of numbers. To evaluate the sorting problem, two metrics are utilized: accuracy and number of errors (NOE). Accuracy is calculated as the intersection divided by the union to measure how similar the final result is to the ground truth. The number of errors represents the number of elements that ascend rather than descend. The higher the accuracy, the better, the lower the number of errors, the better. All nodes except ANSWERINGNODE set the temperature O. The threshold for score probability is set to 0.99 for 100 and O, and 0.5 for others.
The experiment uses 100 lists of 128 elements and 100 lists of 256 elements. For the 128-element lists, numbers are randomly selected from the range to 1000, allowing for duplicates. For the 256-element lists, numbers randomly selected from the range 1500, also allowing for du-

---

Published as a conference paper at ICLR 2025
plicates, because GPT-4o's tokenizer splits numbers 1000 into two tokens. In this experiment, to demonstrate the effectiveness of repeating the question, CoT is performed in two ways. CoTI utilizes the rationale sort the entire list in three steps: divide the list into four parts, sort each part, and then combine them. CoT2 involves rewriting the input to ensure better understanding before sorting the corresponding numbers.
4.3 FROZEN LAKE
Frozen Lake problem of finding route to a destination while avoiding the holes. To find the correct route in frozen lake, it is necessary to know the exact locations of the holes and under- stand the rules the Frozen Lake. To evaluate the Frozen Lake problem, two metrics are utilized: accuracy and number of errors (NOE). Accuracy is the number of successful routes found correctly divided by the total number of attempts. The number of errors is defined as the sum the number of times the agent falls into a hole and the distance of the jump, which is not valid in the problem setting. All nodes except ANSWERINGN
set the temperature to O. The threshold for score prob- ability is set to 0.95 for 100 and 0, and 0.5 for other scores. This experiment is conducted on a by 5 size lake with 20 test cases containing 8 holes and 20 test cases containing 10 holes. Both GPT-4o and GPT-4o mini used in the experiment.
5
EVALUATION
5.1
NUMBER SORTING
Table presents the experimental result of number sorting. ToT achieves the best performance when sorting 128 elements. followed by the proposed EGoT. When sorting 256 elements, the pro- posed EGoT outperforms the other architectures. EGoT also achieves performance similar to that of EGoT, although slightly lower. Note that five experiments performance of EGoT for 128 elements and 256 elements. The results are shown in Figure 3 which demonstrates generally consistent performance.
conducted to verify the consistent
The result of CoTI and CoT2 is the one to focus on here. While there is a relatively slight per- formance difference when sorting 128 numbers, the performance gap is significantly larger when sorting 256 numbers. The reason for the difference is that in the first step of CoTI's rationale, when dividing the list into lists, many numbers are missing, and in the last step of the rationale, when merging the 4 lists, it sometimes returns only the numbers from the first list without merging, For this reason, the performance of CoT1 is significantly lower compared to the other experiments. Con- versely, CoT2's first step of rationale, which is to repeat elements once more, is relatively simple for the LLM, leading to fewer missing numbers. Subsequently, when prompting for sorting with the previously mentioned numbers, the LLM performs the sorting without difficulty. The tradeoff is an increase in both processing time and the number of output tokens due to the additional rationale steps requiring more outputs.
We also compared the performance various LLMs instead of GPT. Since EGoT requires the probability to evaluate the answer, utilize the Llama 3.1 405B model and the Mixtral 8x22B model. The Claude 3 Haiku model does not provide the probability of the answer, therefore, we fix the probability The experiments were conducted using 10 samples for sorting 256 data. During the evaluation, both Llama and Mixtral, in contrast to GPT-4o mini, consistently assign a score of
Table 1: Results of the Number Sorting experiment (GPT-4o mini)
128 Elements
10
CoT1
CoT2
ToT
GoT
EGoT
EGoT
Accuracy
90.25%
72.13%
90.41%
92.28%
90.98%
92.09%
91.70%
Number of Errors
14.07
38.79
13.87
10.87
11.88
10.94
11.45
256 Elements
Accuracy
70.71%
49.50%
83.17%
75.58%
84.37%
88.31 %
87.94%
Number of Errors
119.51
154.57
49.25
65.74
40.93
34.54
35.19

---

Published as a conference paper at ICLR 2025
Sorting 128 Elements
Sorting 256 Elements
(spt-4o mini)
Frozen
Frozen
(Spt-40)
ACC
NGE ACC
NOE ACC
NOE ACC
NOE
93-
90.
45
1.1
65
0.5
92-
-12
80-
550
35-
11.3
0.9
90
:14
70-
120
25-
1.5
40-
-1.0
10
Oo12
15l
Gol E3ol
B3dl
10
Co12 181
Gol B0ol
EGol"
Ool
1al
B3ol EGol"
Col
10
Bool E3ol
Figure 3: Figure shows Min, Max, and Average for multiple experiments. The blue line on the left of each graph represents accuracy and the green line on the right represents number of errors. The bars represent the maximum and minimum values, and the darker color in the middle represents the average. the sorting problem, IO, CoT2, ToT, and GoT architectures were included as comparative models, and the experiment performed only once. The higher the ACC, the better, the lower the NOE, the hetter.
Table 2: Results of the 256 Number Sorting experiment using various LLMs
Llama 3.1 405B
CoT
ToT
GoT
EGoT
Accuracy
91.39%
92.05%
94.09%
95.85 %
Number of Errors
22.53
21.3
16.4
11.5
Mixtral 8x22B
Accuracy
82.91%
71.91% 83.6
83.85%
89.05 %
Number of Errors
73.63
44.6
30.67
Claude 3 Haiku
Accuracy
92.10%
97.62% %
94.38% 14.6
95.00%
Number of Errors
20.4
6.2
12.9
100 in EVALUATIONNODE. In such cases, request the LLM for the score again. The results of these experiments are presented Table
5.2 FROZEN LAKE
aad Table present the experimental results for the Frozen Lake problem. In the experiment, EGoT and = outperform the other architectures. To evaluate the consistent performance, five experiments were conducted using GPT-4o mini, and three experiments were conducted using GPT- 4o. The results are shown in Figure 3 GoT is applicable only when the problem can be divided into sub-problems, whereas Frozen Lake cannot be broken down into smaller parts. Therefore, we cannot compare GoT in this experiment. When the rationale simply instructs the model to understand the positions of holes and tiles, the LLM often becomes confused. However, when the LLM explicitly writes the coordinates next to the input before attempting to understand the positions of the holes and tiles, its performance improves.
5.3 EGoT's ADVANTAGES
EGoT shows the benefits of utilizing rationale information in prompt engineering instead of focusing only on the LLM's s answer. It also proposes a structure to improve prompt engineering performance by leveraging the effect of LLM's temperature. Therefore, EGoT has two main advantages.
First, EGoT generalizes the problem by generating the prompts to enhance the basis prompt. The basis prompt contains only the rule and rationale step of the problem, and the child node enhances
8

---

Published as a conference paper at ICLR 2025
Table 3: Results of the Frozen Lake experiment (GPT-40 mini)
5 by 5 with 8 holes
CoT
ToT
EGoT
EGoT
Accuracy
36%
28.1% 18
43%
41%
Number of Errors
1.33
1.38
1.13
1.14
5 by 5 with 10 holes Accuracy
36.3% 1.28
27.6%
41.0%
34.0%
Number of Errors
1.54
1.15
1.43
Table 4: Results of the Frozen Lake experiment (GPT-4o)
5 by 5 with 8 holes Accuracy
CoT ToT
EGoT
EGoT
50.8%
39.7%
58.8%
53.3%
Number of Errors
0.83
1.03
0.64
0.62
5 by 5 with 10 holes Accuracy
51.7%
44.4%
59.0%
60.33
Number of Errors
0.80
0.89
0.55
0.60
the prompt by uppending only the parent's rationale output. In all experiments, EGoT demonstrates high performance, showing that the enhancing prompt is effective.
Second, EGoT dynamically adjusts the temperature and requests confidence score from the LLM based on both the score itself and the probability of the corresponding token. Cosine annealing used control the temperature, enabling the exploration of diverse answers and rationales in the early stages. Obtaining variety of rationales helps identify issues in problem formulation and refine prompt engineering more effectively. In the end, the low temperature allows us to focus on more accurate answers rather than diversity.
5.4 DIFFERENCES BETWEEN EGOT AND EGoT
EGoT* does not include dynamic temperature control, which leads to continual exploration di- verse solutions. This exploration helps maintain greater diversity the responses. In tasks where the LLM performs well, EGoT can identify the correct answer, rather than focusing on maintaining response diversity. However, tasks where the LLM performance lower, exploration may lead to better answers. EGoT can sometimes exhibit lower performance when it utilizes only a portion of the provided rationale instead of considering EGoT on average when solving Frozen Lake problems. However, when solving sorting problems, EGoT demonstrates better performance.
For this reason, EGoT performs similarly to
5.5 DIFFERENCES WITH OTHER ARCHITECTURES
Since EGoT relies LLM for evaluation, it does not require external tools to verify the rectness of an answer. Mathematical problems can be easily evaluated for correctness using tools, however, general questions more challenging assess in this manner. EGoT does require problem decomposition. GoT is a useful architecture if the problem can be divided hierarchically. however, it is difficult to apply general problems where the problem cannot be partitioned. ToT functions similarly to BFS or A# in LLM-based reasoning. However, BFS or A becomes inefficient when evaluating a large number of elements, as seen tasks like number sorting. CoT-SC focuses solely on the answer, not the rationale, when voting for the final answer, which is efficient the answer scalar. However, when the answer is a list or vector, such as experiments like number sorting Frozen Lake, it is not as applicable ToT. BGoT emphasizes the importance of rationale and proposes that rationale aggregation can serve similar role voting by continuously integrating valid rationales while discarding incorrect ones. The disadvantage of EGoT compared to the other architectures is that it requires more computational time and resources due to its larger number of nodes. Since EGoT utilizes three nodes (Answering, Evaluation, and Aggregate Rationale) obtain

---

Published as a conference paper at ICLR 2025
single answer, it requires approximately three times the time and computational cost to generate the same number of answers.
RELATED WORK
6.1 CHAINING ARCHITECTURE AND RATIONALE STEP
There are several Prompt engineering architectures, including CoT (Wei et al. 2022). CoT-SC [Wang et al. 2023b), ToT (Long 2023 Yao al.) (024), EoT (Yin et al. (023), and GoT (Besta et al. 2024). Various methods for evolving Co'I' and voting on the results of CoT have been pro- posed. Some papers emphasize the correct answer, while others emphasize the rationale. EGoT utilizes a method to construct its architecture based on EoT and Determir (Sun et al. 2024).
CoT emphasizes the importance of rationale and CoT-SC, in contrast, focuses on the correct an- swer rather than the rationale. The importance of providing rationale steps in prompts is widely recognized, and this leads research on which rationale steps should be included (Xu al. 2024). Generally, this involves summarizing the input (Zhang et al. (203)). separating the steps. providing the feedback in the input (Yuan et al. [2024] Madaan et al.j 2024) and providing an explanation of the input Yuugeswardeenoo et al. (024). Villarreal-Haro et al. (2024) and Yin et al. (2024) demon- strate the effectiveness of two strategies: incorporating negative information into the rationale and evaluating the rationale along with its probability, both of which enhance rationale performance.
These findings support the validity of the rationale step in EGoT.
6.2 TEMPERATURE CONTROL AND EVALUATION LLM RESPONSE
Temperature increases LLM's response diversity, and it also affects the performance of answers. Zhu et al.] (2024) show the performance increase by adapting temperature with token confidence.
To evaluate LLM responses, voting (Li al.) 2022, Du et al. (024). debating (Liang et al. [023] Xiong et al. 2023) and scoring (Lee et al. 2024a) are utilized. Since evaluating LLM response affects the performance of the architecture significantly, external tools (Gou al., 2024 are used to evaluate the confidence level of LLM responses (Zhu et al. (023). Motivated by these methods, we utilize debating to obtain the answer by providing the rationale of the parent node to the LLM for inferring the correct answer. Additionally, we perform self-evaluation by requesting the score for single token from the LLM, rather than utilizing the entire set of responses, such as rationales, the EVALUATIONNODE, We define confidence by utilizing the score and the probability of the token responded by the LLM to self-evaluate.
CONCLUSION
Prompt engineering is an area of study that is key to effectively utilizing LLMs, maximizing the advantage of LLMs: the applicability of the model to wide variety of problems without training. Fine-tuning is essential when an LLM needs to acquire specialized skills for certain tasks, how- ever, can reduce generalization capabilities and tends be costly and resource-intensiee. Chain of Thought (CoT) approach enhanced the ability to reason in general situations, recently various architectures evolved methodologies that are more effective for special cases.
We emphasize that the performance of LLMs is already enough to enable automated solutions for intuitive problems. While reasoning strategies may vary based on individual needs and problem requirements, the EGoT architecture demonstrates broad applicability and consistently improves performance. Our work reemphasizes the importance of rationale, and its concise architecture sug- gests the possibility of prompt engineering for wide variety of problems.
Improving the performance of the LLM is also important, obviously. We tried to compare chess puzzles to verify the performance of EGoT architecture. However, despite adding rule in the prompts that no piece except the knight can jump, GPT-4o mini thinks can jump over piece in find move that captures the opponent's
the middle of a move. As result, no architectures piece and checkmates, and the performance is not enough to compare results. Therefore, we hope that prompt engineering techniques improve with LLM performance improvement.
10

---

Published as a conference paper at ICLR 2025
REFERENCES
Maciej Besta, Nils Blach, Ales Kubicek, Robert Gerstenberger, Michal Podstawski, Lukas Gian- inazzi, Joanna Gajda, Tomasz Lehmann, Hubert Niewiadomski, Piotr Nyczyk, et al. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 17682-17690, 2024.
Chengkun Cai. Xu Zhao, Yucheng Du, Haoliang Liu, and Lei Li. T2 of thoughts: Temperature tree clicits reasoning in large language models, arXiv preprint arXiv:2405.11007, 2024.
Harrison Chase. LangChain, October 2022. URL langehain
Yilun Du, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, and Igor Mordatch. Improving fac- tuality and reasoning in language models through multiagent debate. In Forty-first International Conference on Machine Learning, 2024. URL https:: SltEp:://openreveet net/ nwt.:orunttoooooooeoe corummiis
Ta Nguyen Binh Duong and Chai Yi Meng. Automatic grading of short answers using large language models in software engineering courses. In 2024 IEEE Global Engineering Education Conference (EDUCON), pp. 1-10. IEEE, 2024.
Zhibin Gou, Zhihong Shao, Yeyun Gong, yelong shen, Yujiu Yang, Nan Duan, and Weizhu Chen. CRITIC: Large language models can self-correct with tool-interactive critiquing. In The Twelfth International Conference Learning Representations, 2024. http:::
jek]
Shibo Hao, Yi Gu, Haotian Luo, Tianyang Liu, Xiyan Shao, Xinyuan Wang, Shuhua Xie, Haodi Ma, Adithya Samavedhi, Qiyue Gao, Zhen Wang, and Zhiting Hu. LLM reasoners: New evaluation, library, and analysis of step-by-step reasoning with large language models. In ICLR 2024 Work- shop Large Language Model (LLM) Agents, 2024. URL httpp:://ppenrevier net./
Taeyoon Kwon, Kai Tzu-iunn Ong, Dongjin Kang, Seungjun Moon, Jeong Ryong Lee, Dosik Hwang, Beomseok Sohn, Yongsik Sim, Dongha Lee, and Jinyoung Yeo. Large language models are clinical reasoners: Reasoning-awan diagnosis framework with prompt-generated rationales. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 18417-18425, 2024.
Gyeong- Geon Lee, Ehsan Latif, Xuansheng Wu, Ninghao Liu, and Xiaoming Zhai Applying large language models and chain-of- of-thought for automatic scoring. Computers and Education: Artifi- cial Intelligence, 6:100213, 2024a.
Suhyeon Lee, Won Jun Kim, Jinho Chang, and Jong Chul Ye. LLM-CXR: Instruction-finetuned LLM for CXR image understanding and generation. In The Twelfth International Confer- ence on Learning Representations, 2024b. htttps::/openreviieee wwwp:rewviewwneeeeeeeee BqHaLnans2]
wwreeneeveww.net/oouuiii.... fettforummiid
Yifei Li, Zeqi Lin, Shizhuo Zhang, Qiang Fu, Bei Chen, Jian-Guang Lou, and Weizhu Chen. Making large language models better reasoners with step-aware verifier. arXiv preprint 0233622006.02336 2022.
Tian Liang, Zhiwei He, Wenxiang Jiao, Xing Wang, Yan Wang, Rui Wang. Yujiu Yang, Zhaopeng Tu, and Shuming Shi. Encouraging divergent thinking in large language models through multi- agent debate. arXiv preprint arXiv:2305 19118, 2023.
Jieyi Long. Large language model guided tree-of-thought. arXiv preprint arXiv:2305.08291, 2023.
Ilya Loshchilov and Frank Hutter. Sgdr: Stochastic gradient descent with warm restarts. arXiv preprint /608. 2016.
Aman Madaan, Niket Tandon, Prakhar Gupta, Skyler Hallinan, Luyu Gao, Sarah Wiegreffe, Uri Alon, Nouha Dziri, Shrimai Prabhumoye, Yiming Yang, et al. Self-refine; Iterative refinement with self-feedfee feedback. Advances in Neural Information Processing Systems, 36, 2024.
11

---

Published as a conference paper at ICLR 2025
Nat McAleese, Rai Michael Pokorny, Juan Felipe Ceron Uribe, Evgenia Nitishinskaya, Maja Tre- bacz, and Jan Leike. Lim critics help catch Ilm bugs. arXiv preprint arXiv:2407.00215, 2024.
Muhammad Umair Nasir, Sam Earle, Julian Togelius, Steven James, and Christopher Cleghor. Limatic: neural architecture search via large language models and quality diversity optimization. In Proceedings of the Genetic and Evolutionary Computation Conference, pp. 1110-1118, 2024.
Jeongeun Park, Seungwon Lim, Joonhyung Lee, Sangbeom Park, Minsuk Chang, Youngjae Yu, and Sungjoon Choi. Clara: classifying and disambiguating user commands for reliable interactive robotic agents. IEEE Robotics and Automation Letters, 2023.
Yuxiao Qu, Tianjun Zhang, Naman Garg, and Aviral Kumar. Recursive introspection: Teaching foundation model agents how to self-improve. In Automated Reinforcement Learning: Exploring Meta-Learning, AutoMI, and LLMss 2024.
Jie Ren, Yao Zhao, Tu Vu, Peter J Liu, and Balaji Lakshminarayanan. Self-evaluation improves selective generation in large language models. In Proceedings on, pp. 49-64. PMLR, 2023.
Zhihong Shao, Peiyi Wang, Qihao Zhu, Runxin Xu, Junxiao Song, Mingchuan Zhang, YK Li, Yu Wu, and Daya Guo. Deepseekmath: Pushing the limits of mathematical reasoning in open language models. arXiv preprint arXiv:2402.055: 4420033000.. 2024.
Avi Singh, John D Co-Reyes, Rishabh Agarwal, Ankesh Anand, Piyush Patil, Xavier Gareia, Peter J Liu, James Harrison, Jaehoon Lee, Kelvin Xu, Aaron T Parisi, Abhishek Kumar, Alexander A Alemi, Alex Rizkowsky, Azade Nova, Ben Adlam, Bernd Bohnet, Gamaleldin Fathy Elsayed, Hanie Sedghi, Igor Mordatch, Isabelle Simpson, Izzeddin Gur, Jasper Snoek, Jeffrey Penning- ton, Jiri Hron, Kathleen Kenealy, Kevin Swersky, Kshiteej Mahajan, Laura A Culp. Lechao Xiao, Maxwell Bileschi, Noah Constant, Roman Novak, Rosanne Liu, Tris Warkentin, Yamini Bansal, Ethan Dyer, Behnam Neyshabur, Jascha Sohl-Dickstein, and Noah Fiedel. Beyond human data: Scaling self-training for problem-solving with language models. Transactions on Machine Learning Research, 2024. ISSN 2835-8856. URL httpps////peeeeee.e.eeeeee/e// formm? id id=1NAyUngGFK Expert Certification.
Kaya Stechly, Matthew Marquez, and Subbarao Kambhampati. GPT-4 doesn't know it's wrong: An analysis of iterative prompting for reasoming problems. In NeurIPS 2023 Foundation Mod- els for Decision Making Workshop, 2023. https:::/pppsseeeeeehee
net. forum? id=
PMEZ)DYBBR
Hongda Sun, Weikai Xu, Wei Liu, Jian Luan, Bin Wang, Shuo Shang, Ji-Rong Wen, and Rui Yan. Determlr: Augmenting 1mm-based logical reasoning from indeterminacy to determinacy. In Pro- ceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume
1: Long Papers), pp. 9828-9862, 2024.
Karthik Valmeekam, Matthew Marquez, and Subbarao Kambhampati. Investigating the effective- ness of self self-critiquing in LLMs solving planning tasks. In NeurlPS 2023 Foundation Mod- els for Decision Making Workshop, 2023. URL httts:://ppereeee ew. net. / fo Forum??n di gGOfkybOKL.
Kapioma Villarreal-Haro, Fernando Sánchez-Vega, Alejandro Rosales-Pérez, and Adrián Pastor López-Monroy. Stacked reflective reasoning in large neural language models. Working Notes of CLEF, 2024.
Ruocheng Wang, Eric Zelikman, Gabriel Poesia, Yewen Pu, Nick Haber, and Noah D Goodman. Hypothesis search: Inductive reasoning with language models. arXiv preprint arXiv:2300.055m 2023a.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe V Le, Ed H. Chi, Sharan Narang, Aakanksha Chowdhery, and Denny Zhou. Self-consistency improves chain of thought reasoning in language models. In The Eleventh International Conference on Learning Representations, 2023b. URL https:// ftttp:://openreiiee htwpi//wwweet/oouumieeeeee www.:oiddd-P
.nt/
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi. Quoe V Le, Denny Zhou, et al. Chain-of -h-hn-hf- prompting elicits reasoning in large language models. Advances in neural information processing systems, 35:24824-2444 -24337, 2022.
12

---

Published as a conference paper at ICLR 2025
Kai Xiong, Xiao Ding, Yixin Cao, Ting Liu, and Bing Qin. Examining inter-consistency of large language models collaboration: An in-depth analysis via debate. Findings of the Association for Computational Linguistics: EMNLP 2023, pp. 7572-7590, 2023.
Tianyang Xu, Shujin Wu, Shizhe Diao, Xiaoze Liu, Xingyao Wang, Yangyi Chen, and Jing Gao. Sayself: Teaching ulms to express confidence with self-reflective rationales. arXiv preprint arXiv:2405.20994. 2024.
Shunyu Yao, Dian Yu, Jeffrey Zhao, Izhak Shafran, Tom Griffiths, Yuan Cao, and Karthik Narasimhan. Tree of thoughts: Deliberate problem solving with large language models. Ad- vances Neural Information Processing Systems, 36, 2024.
Zhangyue Yin, Qiushi Sun, Cheng Chang, Qipeng Guo, Junqi Dai, Xuan-Jing Huang, and Xipeng Qiu. Exchange-of-thoughh Enhancing large language model capabilities through cross-model communication. In Proceedings of the 2023 Conference on Empirical Methods in Natural Lan- guage Processing, pp. 15135-15153, 2023.
Zhangyue Yin, Qiushi Sun, Qipeng Guo, Zhiyuan Zeng, Xiaonan Li, Junqi Dai, Qinyuan Cheng, Xuan-Jing Huang, and Xipeng Qiu. Reasoning in flux: Enhancing large language models reason- ing through awaaeee adaptive guidance. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1; Long Papers), pp. 2401-2416, 2024.
Lifan Yuan, Ganqu Cui, Hanbin Wang, Ning Ding, Xingyao Wang. Jia Deng. Boji Shan, Huimin Chen, Ruobing Xie, Yankaí Lin, Zhenghao Liu, Bowen Zhou, Hao Peng, Zhiyuan Liu, and Maosong Sun. Advancing LLM reasoning generalists with preference trees. In AI for Math Work- URL BtLhhttps: /enttpps:/oppnrevvieee http:riwwwwwweeeeeeeeeeeee net/forumm 2tt.orrummmd-iyyiiiiioii
shop @ ICML 2024, 2024.
Dharunish Yugeswardeenoo, Kevin Zhu, and Sean O' O'Brien. Question-analysse prompting improves Ilm performance in reasoning tasks. In Proceedings of the 62nd Annual Meeting of the Association for Compulational Linguistics (Volume 4: Student Research Workshop), pp. 543-554, 2024.
Shimao Zhang, Yu Bao, and Shujian Huang. Edt: Improving large language models' generation by entropy- based dynamic temperature sampling. CoRR, Abbs/240..1454,, 2024. URL https:
//doi. 185.444555511... 2403. 14541
Zhuosheng Zhang, Yao Yao. Aston Zhang, Xiangru Tang, Xinbei Ma, Zhiwei He, Yiming Wang, Mark Gerstein, Rui Wang, Gongshen Liu, et al. Igniting language intelligence: The hitchhiker's guide from chain-of-thought reasoning language agents. arXiv preprint arX1v2231..11997. 2023.
Xinyu Zhu, Junjie Wang. Lin Zhang, Yuxiang Zhang, Yongfeng Huang, Ruyi Gan, Jiaxing Zhang, and Yujiu Yang. Solving math word problems via cooperative reasoning induced language mod- els. In Proceedings of the 61 Annual Meeting of the Association for Computational Linguistics (Volume I: Long Papers), pp. 4471 14455, 2023.
Yuqi Zhu, Jia Li, Ge Li, YunFei Zhao, Zhi Jin, and Hong Mei. Hot or cold? adaptive temperature sampling for code generation with large language models. Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, pp. 437-445, 2024.
13

---

Published as a conference paper at ICLR 2025
A APPENDIX
A.1 EVALUATING COSTS: A COMPARISON TO GOT
Table 5: Cost Comparison for solving one problem (GPT-4o mini) in USD
128 Elements
Average
Minimum
Maximum
EGoT
0.03844
0.02922 0.02815
0.04404
GoT
0.03246
0.03658
256 Elements
EGoT
0.04302 0.05289
0.03484 0.03353
0.06855
GoT
0.05852
The number of nodes in the experiment is adjusted through iterative testing to ensure that the cost difference from GoT remains minimal. As a result, while the number of subnodes and tokens per node in EGoT is higher compared to GoT, the total number of nodes in the graph is reduced, ensuring that the overall cost difference not substantial. For the sorting 128 elements, GoT generally exhibits approximately 20% lower cost; however, does not hold for the sorting 256 elements. This discrepancy can be attributed to EGoT placing greater emphasis on rationale within the prompt and requesting more detailed responses. Consequently, even as the problem and correct answer length increases, the total input/output tokens increase only marginally. In contrast, GoT focuses primarily on the answer, leading to proportional increase in input/output tokens as the problem length grows.
Mathematically, the total output tokens can be represented as A + R, where A denotes the number of answer tokens and R represents the number of rationale tokens. FGoT generally has R > A, so even with an increase in A, the rate of increase in the total token count A + R is relatively smaller. On the other hand, GoT typically has < A. meaning that as increases, the rate of increase in the total token count is greater. For sorting 256 elements, EGoT has a lower average cost, while GoT has lower costs in both minimum and maximum. When the LLM solves difficult problems, it tends to generate uncertain additional responses, which increases the total number of tokens. Conversely, for simpler problems, a more concise answer is produced, resulting in fewer tokens.
The reason for the cost difference in maximum is that EGoT has conditional statements. EGoT queries again for uncertain answers to increase the confidence of the answer at the ANSWERINGN- ODE and NVALU If this process occurs at every node, it would require higher cost. There is a higher cost increase for problems that are difficult for LLM to solve. However, in general, EGoT performs better than GoT even though its is lower.
14

---

Published as a conference paper at ICLR 2025
A.2
METHOD NODE PROMPT EXAMPLE (SORTING PROBLEM)
Human Message
<Goal>
-When list of numbers is entered, answer the question about how to them.
Answer the questions about how to evaluate whether the sorted numbers found by this method correct.
</Goal>
<Instruction>>
Answers the method based keywords.
The evaluation methods should be done by LLM, so only print heuristic answers.
Answer without being abstract, only considering the method with the best performance.
</Instruction>
LLM Response
Method:
QuickSort
Evaluation Method:
Check if the sorted list is in ascending order by comparing each element with the next one.
Count the number of inversions in the original list and the sorted list; the number of inversions should decrease.
Verify that the sorted list contains the same elements as the original list by checking for dupli- cates and ensuring all elements are present.
Table 6: METHODNODE Prompt Example.
Table is an example of a real prompt we used. The method and evaluation method may not be effective, however, used it minimize human intervention.
15

---

Published as a conference paper at ICLR 2025
A.3 ANSWERING NODE PROMPT EXAMPLE (SORTING PROBLEM)
Human Message
[Provide the method and data to resolve the problem.]
<Rationale Step>>
Rationalize through processes and must provide a step-by-ster explanation in detail.
First, accurately determine and write the all numbers in Input Data.
Be sure sort the numbers and write down the rationale in detail using the information provided in the previous step.
Make sure you explain why the sorting is correct with rationale for the entire process.
Finally, answer the process of deducing the correct answer by synthesizing the previous process.
</Rationale Step?>
[Provide the information from the upper nodes.]
{% if aggregate rationale %
<Hint>
Refer the hint, but they are not always accurate, so verify the hint by checking the input data and using them.
(% for idx in range(aggregate rationol length) %}
Hint {{ idx }): (aggregate rationale({{ { idx }}) (% endfor %}
</Hint>
{% endif }
LLM Response
Answer:
6. 20, 20, 25.
Answer Rationale:
First, I will identify all the numbers the input list, which are: [1348, 147, 1454, 1111,... Next, using the QuickSort algorithm, will sort this list in ascending order. Using QuickSort, will choose a pivot and divide the list into smaller sub-lists numbers less than or greater than the pivot, then further sort those sub-lists until the entire list is sorted. The resulting sorted list is: [6, 20, 20, 25
Table 7: ANSWERINGNODE Prompt Example. (Jinja2 template)
Table the prompt that requests the LLM answer the question. Because we emphasize the importance of rationale, we set four rationale steps and gather effective rationale. The top node does have aggregate rationale information, while the lower nodes have aggregate rationale information received from the upper nodes. Therefore, the prompt utilizes jinja2 template and forwards this information to the lower nodes at the bottom of the prompt with the Hint tag.
16

---

Published as a conference paper at ICLR 2025
A.4 EVALUATION NODE PROMPT EXAMPLE (SORTING PROBLEM)
Human Message
[Provide the question, the answer from ANSWERINGNODE, and request a score.]
<Evaluation Rationale Step>
Rationalize through processes and must provide a step-by-ster explanation in detail.
First, accurately determine and write all the numbers in Input Data.
Be sure to each number included in the sorted data and write down the rationale in detail using the information provided in the previous step.
Make sure you explain why the sorting is correct with rationale for the entire process.
Finally, answer the process of deducing the correct answer by synthesizing the previous process. </Evaluation Rationale Step?>
Evaluate Methods>>
(% for idx in range(evaluate methods/length) %]
fevaluate methods[{ idx }}1}} (% endfor %
</Evaluate Methods>
LLM Response
Accuracy:
-80
Evaluation Rationale:
... For instance, the number '680' appears in the sorted data but is not present in the input data. Additionally, the number '994" is also present in the sorted data but is missing from the input. Therefore, while the majority of the numbers are sorted correctly, the presence of these dis- crepancies warrants a score below 90.
Table 8: EVALUATIONNODE Prompt Example. (Jinja2 template)
Tiile the prompt that requests the LLM evaluate the response. The Evaluation Rationale Step is almost identical to table 7 However, only the content of step 2 changes slightly because it needs to evaluate the score. By parsing the log probability the number "80" the LLM response, the confidence is calculated 0.607.
17

---

Published as a conference paper at ICLR 2025
A.5
AGGREGATE RATIONALE NODE PROMPT EXAMPLE (SORTING PROBLEM)
Human Message
Rationales
Evaluation Rationale: fevaluation rationale)
Answer Rationall /amsserrrationale]
</Input Rationales>>
<Instruction>>
Aggioaate_Rtiionale>>>
Rationale>
Don't print the successes or valid, just print the incorrectly missing numbers.
Integrate the flaws that problematic invalid.
Be sure to consider the previous two steps, aggregate the Input Rationales.
</Aggregate Rationale>>
<Inaccurate_ Info
Inaccurate Info is information to recheck regarding the missing numbers, it seems be inaccurate.
If the number information in two rationales is different, the number should be included in the inaccurate information.
</Inaccurate_Inee Info
</Instruction>>
LLM Response
Aggregate Rationale:
The sorted list contains discrepancies, including numbers that are not present in the original input data, such as '680' and '994'...
Inaccurate Info:
The numbers '680" and '994' are present in the sorted data but are missing from the input list. Additionally, the number '1496' appears twice in the input list but is only represented once in the sorted list, indicating potential error in the sorting process.
Table 9: ACCREGAATERATIIOVAEENNNI Prompt Example. (Jinja2 template)
is the prompt that summarizes the rationale generated by the two nodes NNSWERINGNODE and VOAL AGGRECATEERAIIONAEEE
provides the rationale information by summarizing the key points. Additionally, it extracts negative information and propagates this to the lower nodes. In table g LLM informs that 680 and 994 are present in the input, however, the sorted result doesn't contain these numbers, therefore table 9 aggregates this information. Misinformation like 1496 also propagates, though the misinformation gradually vanishes as the graph progresses.
18


Reviews:
[{"review_id": "g4q4NtQCJ5", "reviewer": "Reviewer_Gedu", "summary": "This paper introduces EGoT, an architecture for enhancing large language model (LLM) performance by dynamically generating prompts and answers using a base prompt. It utilizes cosine annealing for temperature control to refine answer confidence and log probabilities to improve accuracy without needing additional training or examples. EGoT demonstrates consistent, high-quality output across tasks by continuously appending rationale steps and focusing on diverse yet accurate responses.", "questions": "- Given that EGoT requires three times the resources compared to other mechanisms, for which tasks does this approach offer an advantage, and in which cases might it be less suitable?\n- Is there any rationale behind selecting these specific experimental setups—document merging, number sorting, and frozen lake?", "limitations": "", "rating": 6, "confidence": 2, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- The use of rationale-driven approaches is well-motivated, and experiments show EGoT achieving higher performance in tasks like number sorting and frozen lake.\n- Example use cases effectively illustrate the mechanism’s function, though additional examples of negative rationales would enhance understanding.", "weaknesses": "- It would be beneficial to include cases where EGoT fails and scenarios where the gap between EGoT and EGoT* is more pronounced.\n- Experiments were limited to GPT-4o models. Findings might differ from other model types.\n- How the aggregate rationale node functions is unclear. How effectively can LLMs aggregate rationales?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "QdoZbWs8KL", "reviewer": "Reviewer_X27s", "summary": "The paper present an architecture for prompt engineering based on Graph of Thoughts, aimed at supporting LLM reasoning for complex reasoning tasks. It is evaluated on the frozen lake problem.", "questions": "Can you provide a clear workflow and an example of a concrete prompt on a real world reasoning problem?\nCan you formalise the steps used in the method?\nCan you experiment with the method on existing LLMs?\nI acknowledge that the authors made efforts to clarify the workflow and broadened the set of tested LLMs.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 2, "contribution": 3, "strengths": "Addressing advanced methods for prompting LLMs is valuable.\nThe proposed method starts from a reasonable basis.", "weaknesses": "The paper should be enhanced to resolve readability issues and exemplification of the steps in their workflow, e.g., the nested steps are not explained following a clear workflow, and are not associated with the claimed approach for dynamic temperature control. I acknowledge that the authors provided some context to understand their results, and took several steps to improve the narrative of the paper.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "GwYVCAj6o4", "reviewer": "Reviewer_JcuQ", "summary": "This paper proposes Enhancing Graph of Thoughts (EGOT) to improve the performance of LLM on reasoning tasks. They design a flow within each node to answer the question with rationales, evaluate the answer with rationales, and consolidate the answer and evaluation rationales as inputs to the child nodes. They also introduce temperature control with cosine annealing to explore answer space at earlier nodes and refine the promising answers at later nodes. They report that the proposed methodology shows better performance on number sorting and frozen lake tasks compared to baselines including CoT, ToT, and GoT.", "questions": "1. It would be good to add the prompts used for each task and each node to appendix\n\n2. In section 3.3, the illustrated case branches each node in depth 0 into 2 child nodes, but after depth 0, each parent node only generates 1 child node. What's the criteria to determine how many child nodes to be generated.\n\n3. In section 3.1.1, the authors state that if the child gives the same answer as the parent, a questions is only asked once more, since it cannot be determined whether it’s the correct answer. It would be good to validate if the score or confidence level produced by the evaluation node could determine if one more run is needed.\n\n4. Curious to understand the cost compared to other baselines.", "limitations": "", "rating": 5, "confidence": 4, "soundness": 2, "presentation": 1, "contribution": 2, "strengths": "1. This paper goes beyond the evaluation scoring used in ToT and GoT for pruning and ranking; instead, they also leverage LLMs to provide rationales for the answers and evaluation scores to help the model refine the answers.\n\n2. This paper introduces temperature control with cosine annealing to balance between exploration and exploitation.\n\n3. This paper demonstrates the effectiveness of EGoT on an additional reasoning task, Frozen Lake problem, which has not been explored in any of baselines including CoT, ToT, and GoT.", "weaknesses": "1. The paper formulates the methodology with a graph architecture, but it does not hold certain characteristics of a graph similar to Graph of Thoughts (GoT). First, figure 1 starts with Method Node as root and section 2.2 says “heuristic methods are requested from LLM and utilized”, but it’s not clearly illustrated in the example use case (section 3.3), hence making the interaction between Method Node and other nodes confusing. Second, based on the section 3.3 example use case, the methodology starts with 3 nodes and there are no interaction between child nodes either from the same parent or different parents until the very end. Given these observations, it seems like 3 Tree of Thoughts with aggregation at the last layer. It would be good to explain more clearly on this front.\n\n2. Some settings mentioned in the paper seem arbitrary without thorough explanation. First, for the evaluation score, the authors run evaluation once more with a temperature of 1 if the probability is lower than a threshold and different scores have different thresholds. Without looking at the specific evaluation prompt, it is not clear why we select a scale of 0-100 instead of 0-10 or 0-5. Since the evaluation requires more accuracy and lower diversity, it it not clear why we set a temperature of 1 to re-run the evaluation instead of relying on the scores generated with a temperature of 0. Could you provide justifications for these choices? Are they based on any experiment results?\n\n3. In section 4, the authors state that “for GoT, instead of evaluating the best performing node, they select the one with medium score value, with the goal of comparing only structural performance, as solving problems with evaluation metrics is not considered to be a structural advantage.” However, it may not be convincing as EGoT also takes advantage of LLM evaluation with rationales instead of structure changes only; it may not be a fair comparison to only select the medium for GoT.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "PttvZLsvzX", "reviewer": "Reviewer_fxo8", "summary": "This paper introduces a dynamic an approach of enhancing prompts with dynamic temperature control. The steps are organized in a tree-like structure, where there is an answering, an evaluation and an aggregate rationale component in each node and each node passes the information to the child nodes. The authors evaluate this approach evaluate a range of closed and open LLMs on tasks and compare with other relevant methods from the literature.", "questions": "- From your benchmarking, I see that by fixing the temperature (EGoT*) the accuracy is sometimes very similar to dynamic temperature (EGoT). Would that indicate that for those instances dynamic temperature has no effect?\n- Is there an established set of benchmarks for evaluating these methods? For example in the GoT paper I see that they also evaluate on sorting and document and merging tasks as you do, but they also evaluate on keyword counting and document merging and they don't evaluate on the frozen lake\n- Minor mistakes:\nUse “Prompt engineering” instead of “Prompted engineering”\n\"As a result, no architectures cannot find a move that captures the opponent’s piece\". Do you mean $\\textbf{\"can find\"}$?\n- In your figure 2 it's hard for me to follow the coordinates. Would it be possible to make each cell look more distinct and add a x,y axis ticks?", "limitations": "", "rating": 8, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The authors borrow ideas from other methods from the literature and combine them in a good way\n- They use a dynamic temperature which initially allows for more exploration when the model has less confidence and decreases as the model gains more confidence of its answers\n- They show that this method is improving on some common benchmarks using GPT4o/GPT4o mini\n- This is a method that doesn't require fine-tuning which can be resource intensive and time consuming\n- The paper is well-written and comprehensible", "weaknesses": "- This method is only evaluated with GPT4o. It would be important to see how other models are performing like Llama or Mistral. \n- I think for this method the bottleneck is the model's self-evaluation and answering. For self-evaluation If it assigning incorrect scores and rationales, then the performance will also be bad no matter what method you use. In such a case it may even yield in worse performance than some of the methods you presented. For answering, you already provided the chess example. The best way around it is to fine-tune with well curated examples.\n- For the most part these ideas are not novel. We've seen these ideas in papers like ToT,  $T^{2}oT$, GoT, SC, Self-Evaluation", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)