Self-guided Knowledgeable Network of Thoughts: Amplifying Reasoning with Large Language Models

Chao-Chi Chen; Chin-Yuan Yeh; De-Nian Yang; Hsi-Wen Chen; Ming-Syan Chen

REVIEW 4 major objections 3 minor 29 references

Self-guided Knowledgeable Network of Thoughts: Amplifying Reasoning with Large Language Models

T0 review · 4 major / 3 minor · reviewed 2026-08-11 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read Large language models that script their own step-by-step reasoning networks outperform standard prompting schemes on six tasks while needing fewer hand-written prompts.

desk verdict LWT is a genuinely useful new prompting format, but the paper's headline accuracy claims rest on a mismatched-model comparison and need a controlled rerun before they can be trusted. read the letter →

arxiv 2412.16533 v1 pith:47OSRW5Y submitted 2024-12-21 cs.MA cs.CLcs.LG

Chao-Chi Chen , Chin-Yuan Yeh , Hsi-Wen Chen , De-Nian Yang , Ming-Syan Chen This is my paper · ORCID

classification cs.MAcs.CLcs.LG

keywords knowledgeablenetworkofthoughtsLLMworkflowtemplatepromptengineeringreasoningnetworkselementaryoperationsChain-of-ThoughtTreeGraph

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper claims that a large language model can plan its own reasoning and then execute that plan as a network of simple, individually verifiable steps. It introduces the LLM Workflow Template (LWT), a text format in which each node is one LLM call and each edge passes a previous output, optionally a single indexed element, into the next call. The claim is that this arrangement beats Chain-of-Thought, Tree of Thoughts, and Graph of Thoughts on six test tasks, with the largest gains at longer problem sizes, while cutting human-written task-specific prompts by up to 84.4 percent versus ToT and 87.3 percent versus GoT. If true, it would mean that prompting schemes can delegate both the decomposition and the execution of multi-step reasoning to the model itself rather than to human prompt designers.

What carries the argument

The LLM Workflow Template (LWT) is a script format where each numbered instruction is a single LLM call, input fields {(N)} pass an entire earlier output and {(N)}[M] pass one indexed item from it. This carries the argument by turning an LLM's plan into an executable sequence of elementary operations connected by explicit message passing, so no single inference must track the whole task and the reasoning structure can be any network rather than only a chain, tree, or split-then-merge graph.

What would settle it

Run the first two kNoT steps on a few hundred fresh queries per task and check whether every produced LWT script is syntactically valid, contains no unresolvable {(N)} or {(N)}[M] references, and would yield the correct answer if every instruction were answered perfectly; a substantial fraction of failing scripts would refute the claim that kNoT's advantage is structural.

Watch

Extended reading notes

Core claim

kNoT works in three steps: knowledge extraction, where the LLM produces a solution plan; LWT translation, where the plan is turned into a numbered script whose instructions reference earlier outputs through {(N)} and {(N)}[M]; and script execution, where each instruction is run by the LLM and its output is stored for later reference. By indexing individual list elements, each operation can be elementary, for example adding two digits or checking one set element against another. The paper reports 92 percent accuracy for sorting 32 numbers, versus 12 percent for ToT and 31 percent for GoT, and near-zero baseline accuracy at larger problem sizes on several tasks, while using fewer task-specific prompt characters.

Load-bearing premise

Everything rests on the assumption that the model can reliably write down a correct, parseable plan script before execution begins; if that script is malformed, uses a wrong index, or omits a step, the whole pipeline fails regardless of how well individual steps run.

Editorial extensions

If this is right

On the six evaluated tasks, kNoT reaches accuracy levels that CoT, ToT, and GoT do not reach at the same problem sizes, especially with 32 to 128 elements.
Because LWT supports indexing, kNoT confines each LLM call to an elementary operation, which the paper argues is why accuracy holds on long sequences where whole-task prompting fails.
The scheme reduces task-specific prompt engineering: a single short LWT example per task type suffices, cutting task-specific prompt characters by up to 84.4 percent versus ToT and 87.3 percent versus GoT.
LLM API costs for high-accuracy runs are lower for kNoT than for ToT and GoT on the tested tasks.
LLMs generate instance-specific scripts, so the reasoning network is customized per query rather than fixed by a human-designed template.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

If the planner and executor are different models, kNoT could be tested as a pipeline in which a strong model writes scripts that a weaker model executes, potentially separating planning ability from execution reliability.
The LWT indexing mechanism resembles a restricted programming language; one could extend it with conditionals or iteration, though the paper deliberately forbids loops to keep scripts sequential.
The approach may be most fragile exactly where the paper's gains are largest: as problem size grows, scripts get longer and the planner must keep indices consistent without any feedback, so an error-injection study that perturbs indices would reveal how much of the accuracy margin comes from planning versus execution.
The paper's framework for counting constant versus task-specific prompts in human labor could be applied to compare future prompt schemes on engineering effort rather than final accuracy alone.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Hi,

The one thing to know: the LWT format is a genuine contribution, but the paper's headline accuracy claim is not backed by its own comparison. Table 3 gives kNoT GPT-4o-generated scripts while every baseline runs hand-written GPT-3.5-turbo prompts. That's two variables changing at once. Table 6 makes the problem concrete: put everything on GPT-4o and ToT and GoT also reach ~100% on most tasks. The 92%-vs-12% sorting numbers is therefore a between-condition gap, not a clean test of LWT.

What's actually new: LWT itself. Numbered LLM instructions with input-field references and list indexing let the model write an executable network of elementary steps. That's a real step beyond ToT's fixed tree and GoT's split-then-merge, and the appendix has enough detail to reimplement. The ablation showing the LWT example and indexing are load-bearing is useful. The cost analysis shows kNoT is cheaper even when all schemes run on GPT-4o, so I'd accept 'lower cost and less per-task prompt text' even if the accuracy margins shrink.

Soft spots: - Model asymmetry: the main issue. Fix with a matched-model comparison (GPT-4o-generated modules for baselines, or GPT-3.5-generated LWT scripts, or a full GPT-4o-execution table). - No error bars or significance tests; margins are large, so this is fixable but missing. - Script-generation failure rate is never measured. If GPT-4o occasionally produces malformed LWT, the reliability claim needs a number. - Minor: per-task context and LWT example are hand-authored, so 'automated' covers the plan/script, not the whole per-task setup. Character counts still favor kNoT, just less dramatically.

This is for anyone working on prompting schemes or LLM reasoning; the LWT idea could carry over to agent frameworks. It deserves a serious referee, but the revision should include a matched-model comparison and error bars. I'd accept with major revisions.

Regards,

Referee Report

4 major / 3 minor

Summary. The paper proposes kNoT, a prompting scheme in which an LLM first produces a natural-language solution plan, translates that plan into an LWT-formatted script of numbered 'LLM' instructions with input-field and indexing notation, and then executes the script sequentially, allowing arbitrary networks of elementary LLM operations. The method is evaluated on six tasks spanning natural-language, symbolic, and arithmetic reasoning, with comparisons to CoT, ToT, GoT, and other baselines, and the paper reports large accuracy gains, lower task-specific prompt sizes, ablations, scalability results, and API cost measurements.

Significance. If the empirical claims are validated, kNoT is a worthwhile contribution to prompt engineering: the LWT format cleanly separates plan generation from plan execution, supports flexible network topologies, and the indexing mechanism is a natural way to force elementary operations. The paper is also refreshingly concrete in publishing its prompt templates and examples. The ablations and cost tables are useful, and the scalability experiments address an important weakness of prior schemes. However, the central comparison is currently confounded by the use of GPT-4o for kNoT's script generation while baselines are executed on GPT-3.5-turbo, so the magnitude of the reported gains over the baselines is not yet established.

major comments (4)

[§5.1, Table 3] The headline comparison is not model-matched. Section 5.1 states that kNoT 'directly leverage[s] the LWT-formatted script generated with GPT-4o as the task instructions', while all baseline prompt schemes are executed on GPT-3.5-turbo. Baselines therefore receive hand-written, fixed task-specific modules, whereas kNoT receives a per-query plan authored by a stronger model. Table 6 reinforces the concern: when ToT and GoT are executed with GPT-4o, they reach 100% accuracy on most tasks, so the large margins in Table 3 may reflect the planner's strength rather than the LWT structure. Please add matched-model conditions, for example kNoT with GPT-3.5-turbo-generated scripts, and ToT/GoT with GPT-4o-generated modules or at least GPT-4o execution, and report the same task table under matched planner/executor settings.
[§5.1, Algorithm 1] The pipeline has no specified validation or fallback for script generation, and no failure-rate measurement is reported. The claim that kNoT can 'directly leverage' a generated LWT script assumes GPT-4o always produces a syntactically valid, complete, and executable script. Please report, per task and problem size, the fraction of queries for which knowledge extraction or LWT translation fails, including malformed instructions, unresolved or out-of-range indices, non-list outputs when indexed fields are used, or scripts that reference non-existent steps. Without this information, the reliability of the method and the interpretation of the reported accuracies cannot be assessed.
[Appendix C.2] The few-shot arithmetic examples provided for the CoT baseline contain arithmetic and formatting errors. For example, the first example writes '25+2=37' where the preceding line already gives 35, and the second example writes '27+7=24' where the correct value is 34; later examples use '52=10', '33=9', and '527=70' without multiplication symbols. If these strings were used in the executed baseline prompts, the baselines may have been systematically handicapped, making the comparison in Table 3 unfair. Please verify the executed prompts, correct any typos in the manuscript, and re-run the affected baselines if the erroneous strings were actually used.
[§5.4, Tables 7 and 9] The quantitative labor-reduction claim is not internally consistent. Table 9 reports kNoT's task-specific token counts averaging about 307 tokens per task, but §5.4 states that kNoT 'requires only 600 tokens per task'; the stated ToT and GoT averages of 1467 and 1893 tokens also do not match Table 9, whose averages are about 1390 and 1746, respectively. Because the advertised 'up to 84.4% and 87.3%' reductions are central to the paper's contribution, please clarify which prompt components are counted in each table, recompute the averages, and report token and character counts consistently.

minor comments (3)

[Table 1] The symbols in Table 1 render as broken glyphs (e.g., '/reve'), making the comparison table difficult to interpret; please replace them with standard checkmark/cross symbols.
[§5.2, Table 3] The accuracy results are reported as point estimates on 100 queries per setting without confidence intervals or significance tests. Adding standard errors or a small statistical comparison would strengthen the claim of 'significantly outperforms', especially for the smaller margins such as Yelp (75% vs 52%).
[Figure 4] Figure 4 is referenced in the text but is not described in enough detail in the manuscript; please ensure axis labels, task definitions, and the baselines shown are fully specified in the caption.

Circularity Check

0 steps flagged · score 0.0 of 10

No circularity: kNoT's claims are empirical comparisons against external baselines; no fitted parameter, self-citation, or definitional identity drives the results. The model-asymmetry caveat is an experimental confound, not a circular reduction.

full rationale

The derivation chain here is empirical rather than mathematical. kNoT proposes a prompt format (LWT) and evaluates it on six external benchmark-style tasks against published schemes (CoT, ToT, GoT, etc.). The claimed reductions in task-specific prompt characters are direct counts of the authors' own prompt designs, not quantities predicted from a fitted parameter; the LWT example E and context C are explicitly listed as task-specific inputs (Section 4.2, Table 2), and the per-query script S is generated rather than fit to the test answers. No uniqueness theorem, ansatz, or load-bearing self-citation is invoked; the reference list contains no overlapping authors' prior results that carry the argument. The strongest caveat is Section 5.1's asymmetry: kNoT's scripts are authored by GPT-4o while all baselines are executed with hand-written GPT-3.5-turbo prompts. That is a meaningful confound for the superiority claim, and Table 6 shows the margin shrinks when all schemes are run on GPT-4o, but it is not an equivalence between input and output by construction, so it does not constitute circularity under the stated rules.

Assumptions & free parameters 3 free parameters · 4 assumptions · 1 invented entities

No numeric parameters are fitted to the accuracy results, but several prompt components are hand-chosen. The paper's central claims rest on the reliability of LLM script generation and execution, and on the chosen definition of task-specific prompt labor.

free parameters (3)

Per-task LWT example E = Hand-authored scripts per task (Appendix B.2)
The LWT example encodes the solution strategy for each task, such as counting sort for sorting and sentence splitting for keyword counting. It is manually designed, so the claim of reduced task-specific prompt engineering still relies on human-authored task content.
Per-task context description C = Short hints such as 'You can use counting sort' (Appendix B.2)
Provides algorithmic guidance and is hand-chosen per task. It shapes the generated solution plan and is counted as part of kNoT's task-specific prompts.
Constant prompt templates K and T = Text in Appendix B.1
The knowledge extraction prompt and LWT translation prompt are hand-written constant prompts reused across tasks. They define the instruction format and therefore influence all generated scripts.

assumptions (4)

ad hoc to paper GPT-4o generates a valid and complete LWT script for each task query without human correction.
Used in Section 5.1; no validation step or fallback is provided, so the entire execution depends on this generation succeeding.
domain assumption The executing LLM reliably follows LWT instructions, including indexed input fields, and returns parseable outputs.
Algorithm 1 loops over the script and feeds outputs into later calls; if the model ignores indexing or emits malformed lists, message passing breaks.
ad hoc to paper Character count of task-specific prompts is an appropriate proxy for human prompt-engineering effort.
Definition 2 and Table 7 use prompt character counts to claim 84.4% and 87.3% labor reduction; no timing or expert-effort data supports the proxy.
domain assumption 100 exact-match samples per cell are sufficient to establish that kNoT outperforms baselines.
Table 3 reports point accuracies with no error bars or significance tests.

invented entities (1)

LLM Workflow Template (LWT)
purpose: Structured script format that encodes an arbitrary network of elementary LLM operations with input fields and list indexing.
LWT is introduced in this paper as the core mechanism; its utility is demonstrated only on the paper's six tasks, with no independent implementation or external benchmark validation.

how reviews work

0 comments

Cite this review

Pith. "Pith review of Self-guided Knowledgeable Network of Thoughts: Amplifying Reasoning with Large Language Models." pith.science (2026). https://pith.science/paper/47OSRW5Y

@misc{pith2026241216533,
  author       = {Pith},
  title        = {Pith review of: Self-guided Knowledgeable Network of Thoughts: Amplifying Reasoning with Large Language Models},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/47OSRW5Y}},
  note         = {Machine review of arXiv:2412.16533}
}

read the original abstract

We introduce Knowledgeable Network of Thoughts (kNoT): a prompt scheme that advances the capabilities of large language models (LLMs) beyond existing paradigms like Chain-of-Thought (CoT), Tree of Thoughts (ToT), and Graph of Thoughts (GoT). The key innovation of kNoT is the LLM Workflow Template (LWT), which allows for an executable plan to be specified by LLMs for LLMs. LWT allows these plans to be arbitrary networks, where single-step LLM operations are nodes, and edges correspond to message passing between these steps. Furthermore, LWT supports selection of individual elements through indexing, facilitating kNoT to produce intricate plans where each LLM operation can be limited to elementary operations, greatly enhancing reliability over extended task sequences. We demonstrate that kNoT significantly outperforms the state of the art on six use cases, while reducing the need for extensive prompt engineering. For instance, kNoT finds 92% accuracy for sorting 32 numbers over 12% and 31% for ToT and GoT, while utilizing up to 84.4% and 87.3% less task-specific prompts, respectively.

Figures

Figures reproduced from arXiv: 2412.16533 by the authors.

**Figure 2.** Illustrations of human labor (orange block ␣) and LLM operation (blue block ␣) required for the prompt solution procedure. Gray stripes indicate the labor involved in designing constant prompts, which do not require redesign. Definition 2 (Prompt Solution Procedure). The procedure for solving a prompt engineering problem for a task t consists of the following three stages. 1. Prompt scheme design, which involves d… view at source ↗

**Figure 3.** Illustration of the Self-guided Knowledgeable Network of Thoughts (kNoT). The prompts in kNoT include [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Scalability analysis across varying lengths of ad [PITH_FULL_IMAGE:figures/full_fig_p006_4.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

29 extracted references · 11 canonical work pages

[1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...
[2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...
[3]

Bao, G.; Zhang, H.; Yang, L.; Wang, C.; and Zhang, Y. 2024. Llms with chain-of-thought are non-causal reasoners. arXiv preprint arXiv:2402.16048

arXiv 2024
[4]

Besta, M.; Blach, N.; Kubicek, A.; Gerstenberger, R.; Podstawski, M.; Gianinazzi, L.; Gajda, J.; Lehmann, T.; Niewiadomski, H.; Nyczyk, P.; et al. 2024. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 17682--17690

work page 2024
[5]

Carter, S.; and Nielsen, M. 2017. Using artificial intelligence to augment human intelligence. Distill, 2(12): e9

work page 2017
[6]

Chen, W.; Ma, X.; Wang, X.; and Cohen, W. W. 2023. Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks. Transactions on Machine Learning Research

work page 2023
[7]

Engelbart, D. C. 2023. Augmenting human intellect: A conceptual framework. In Augmented Education in the Global Age, 13--29. Routledge

work page 2023
[8]

Fang, M.; Deng, S.; Zhang, Y.; Shi, Z.; Chen, L.; Pechenizkiy, M.; and Wang, J. 2024. Large language models are neurosymbolic reasoners. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 17985--17993

work page 2024

Show all 29 references

[9]

Feng, G.; Zhang, B.; Gu, Y.; Ye, H.; He, D.; and Wang, L. 2024. Towards revealing the mystery behind chain of thought: a theoretical perspective. Advances in Neural Information Processing Systems, 36

2024
[10]

Gao, L.; Madaan, A.; Zhou, S.; Alon, U.; Liu, P.; Yang, Y.; Callan, J.; and Neubig, G. 2023. Pal: Program-aided language models. In International Conference on Machine Learning, 10764--10799. PMLR

2023
[11]

E.; Pasunuru, R.; Golovneva, O.; Sinha, K.; Celikyilmaz, A.; Bosselut, A.; and Wang, T

Gao, S.; Dwivedi-Yu, J.; Yu, P.; Tan, X. E.; Pasunuru, R.; Golovneva, O.; Sinha, K.; Celikyilmaz, A.; Bosselut, A.; and Wang, T. 2024. Efficient Tool Use with Chain-of-Abstraction Reasoning. arXiv preprint arXiv:2401.17464

2024 arXiv
[12]

Inc., Y. 2015. Yelp Review Dataset. Accessed: 2024-08-05

2015
[13]

S.; Reid, M.; Matsuo, Y.; and Iwasawa, Y

Kojima, T.; Gu, S. S.; Reid, M.; Matsuo, Y.; and Iwasawa, Y. 2022. Large language models are zero-shot reasoners. Advances in neural information processing systems, 35: 22199--22213

2022
[14]

R.; Kailkhura, B.; Bhatele, A.; Geiping, J.; Schwarzschild, A.; et al

McLeish, S.; Bansal, A.; Stein, A.; Jain, N.; Kirchenbauer, J.; Bartoldson, B. R.; Kailkhura, B.; Bhatele, A.; Geiping, J.; Schwarzschild, A.; et al. 2024. Transformers Can Do Arithmetic with the Right Embeddings. arXiv preprint arXiv:2405.17399

2024 arXiv
[15]

Ning, X.; Lin, Z.; Zhou, Z.; Wang, Z.; Yang, H.; and Wang, Y. 2023. Skeleton-of-thought: Large language models can do parallel decoding. NeurIPS 2023 Workshop on Efficient Natural Language and Speech Processing (ENLSP)

2023
[16]

Paul, D.; Ismayilzada, M.; Peyrard, M.; Borges, B.; Bosselut, A.; West, R.; and Faltings, B. 2023. Refiner: Reasoning feedback on intermediate representations. arXiv preprint arXiv:2304.01904

2023 arXiv
[17]

K.; Saha, S.; Jain, V.; Mondal, S.; and Chadha, A

Sahoo, P.; Singh, A. K.; Saha, S.; Jain, V.; Mondal, S.; and Chadha, A. 2024. A Systematic Survey of Prompt Engineering in Large Language Models: Techniques and Applications. arXiv preprint arXiv:2402.07927

2024 arXiv
[18]

Saxton, D.; Grefenstette, E.; Hill, F.; and Kohli, P. 2019. Analysing mathematical reasoning abilities of neural models. arXiv preprint arXiv:1904.01557

2019 arXiv
[19]

Shinn, N.; Cassano, F.; Gopinath, A.; Narasimhan, K.; and Yao, S. 2024. Reflexion: Language agents with verbal reinforcement learning. Advances in Neural Information Processing Systems, 36

2024
[20]

Stechly, K.; Valmeekam, K.; and Kambhampati, S. 2024. Chain of Thoughtlessness: An Analysis of CoT in Planning. arXiv preprint arXiv:2405.04776

2024 arXiv
[21]

Sun, J.; Zheng, C.; Xie, E.; Liu, Z.; Chu, R.; Qiu, J.; Xu, J.; Ding, M.; Li, H.; Geng, M.; et al. 2023. A survey of reasoning with foundation models. arXiv preprint arXiv:2312.11562

2023 arXiv
[22]

N.; Kaiser, L

Vaswani, A.; Shazeer, N.; Parmar, N.; Uszkoreit, J.; Jones, L.; Gomez, A. N.; Kaiser, L. u.; and Polosukhin, I. 2017. Attention is All you Need. In Guyon, I.; Luxburg, U. V.; Bengio, S.; Wallach, H.; Fergus, R.; Vishwanathan, S.; and Garnett, R., eds., Advances in Neural Infor...

2017
[23]

V.; Chi, E

Wang, X.; Wei, J.; Schuurmans, D.; Le, Q. V.; Chi, E. H.; Narang, S.; Chowdhery, A.; and Zhou, D. 2022. Self-Consistency Improves Chain of Thought Reasoning in Language Models. In The Eleventh International Conference on Learning Representations

2022
[24]

V.; Zhou, D.; et al

Wei, J.; Wang, X.; Schuurmans, D.; Bosma, M.; Xia, F.; Chi, E.; Le, Q. V.; Zhou, D.; et al. 2022. Chain-of-thought prompting elicits reasoning in large language models. Advances in neural information processing systems, 35: 24824--24837

2022
[25]

Yang, Z.; Ding, M.; Lv, Q.; Jiang, Z.; He, Z.; Guo, Y.; Bai, J.; and Tang, J. 2023. Gpt can solve mathematical problems without a calculator. arXiv preprint arXiv:2309.03241

2023 arXiv
[26]

Yao, S.; Yu, D.; Zhao, J.; Shafran, I.; Griffiths, T.; Cao, Y.; and Narasimhan, K. 2024. Tree of thoughts: Deliberate problem solving with large language models. Advances in Neural Information Processing Systems, 36

2024
[27]

Yao, S.; Zhao, J.; Yu, D.; Du, N.; Shafran, I.; Narasimhan, K.; and Cao, Y. 2022. React: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629

2022 arXiv
[28]

Zhang, C.; Yang, K.; Hu, S.; Wang, Z.; Li, G.; Sun, Y.; Zhang, C.; Zhang, Z.; Liu, A.; Zhu, S.-C.; et al. 2024. ProAgent: building proactive cooperative agents with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 17591--17599

2024
[29]

Zhang, Z.; Zhang, A.; Li, M.; and Smola, A. 2023. Automatic Chain of Thought Prompting in Large Language Models. In The Eleventh International Conference on Learning Representations

2023

Pith tools

Reviewed August 11, 2026 · model on record in the stance chip above.

[1] [1]

, " * write output.state after.block = add.period write newline

ENTRY address archivePrefix author booktitle chapter edition editor eid eprint howpublished institution isbn journal key month note number organization pages publisher school series title type volume year label extra.label sort.label short.list INTEGERS output.state before.all mid.sentence after.sentence after.block FUNCTION init.state.consts #0 'before.a...

[2] [2]

write newline

" write newline "" before.all 'output.state := FUNCTION n.dashify 't := "" t empty not t #1 #1 substring "-" = t #1 #2 substring "--" = not "--" * t #2 global.max substring 't := t #1 #1 substring "-" = "-" * t #2 global.max substring 't := while if t #1 #1 substring * t #2 global.max substring 't := if while FUNCTION word.in bbl.in capitalize " " * FUNCT...

[3] [3]

Bao, G.; Zhang, H.; Yang, L.; Wang, C.; and Zhang, Y. 2024. Llms with chain-of-thought are non-causal reasoners. arXiv preprint arXiv:2402.16048

arXiv 2024

[4] [4]

Besta, M.; Blach, N.; Kubicek, A.; Gerstenberger, R.; Podstawski, M.; Gianinazzi, L.; Gajda, J.; Lehmann, T.; Niewiadomski, H.; Nyczyk, P.; et al. 2024. Graph of thoughts: Solving elaborate problems with large language models. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 17682--17690

work page 2024

[5] [5]

Carter, S.; and Nielsen, M. 2017. Using artificial intelligence to augment human intelligence. Distill, 2(12): e9

work page 2017

[6] [6]

Chen, W.; Ma, X.; Wang, X.; and Cohen, W. W. 2023. Program of Thoughts Prompting: Disentangling Computation from Reasoning for Numerical Reasoning Tasks. Transactions on Machine Learning Research

work page 2023

[7] [7]

Engelbart, D. C. 2023. Augmenting human intellect: A conceptual framework. In Augmented Education in the Global Age, 13--29. Routledge

work page 2023

[8] [8]

Fang, M.; Deng, S.; Zhang, Y.; Shi, Z.; Chen, L.; Pechenizkiy, M.; and Wang, J. 2024. Large language models are neurosymbolic reasoners. In Proceedings of the AAAI Conference on Artificial Intelligence, volume 38, 17985--17993

work page 2024