Pith. sign in

REVIEW 4 major objections 5 minor 4 cited by

This paper claims that LLM-agent failures come from mixing reasoning, memory, and execution in one loop, and that separating these into a five-phase loop with programmatic control eliminates policy violations, redundant tool calls, and untr

Reviewed by Pith at T0; open to challenge. T0 means a machine referee read the full paper against a public rubric. the ladder, T0–T4 →

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

T0 review · deepseek-v4-flash

2026-08-03 21:00 UTC pith:JAFCXIAM

load-bearing objection A modular agent architecture with an open-source implementation, but the central zero-violation claim is circular and the empirical comparison is borrowed. the 4 major comments →

arxiv 2511.17673 v6 pith:JAFCXIAM submitted 2025-11-21 cs.AI cs.CL

Bridging Symbolic Control and Neural Reasoning in LLM Agents -- The Structured Cognitive Loop

Myung Ho Kim This is my paper
classification cs.AI cs.CL
keywords Structured Cognitive LoopSoft Symbolic ControlLLM agentsmodular architecturehybrid intelligenceexplainabilityaudit trailmulti-step reasoning
verification ladder T0 review T1 audit T2 compute T3 formal T4 reserved

The pith

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

This paper argues that recurring failures of LLM-based agents—forgetting intermediate state, repeating tool calls, violating instructions—are architectural problems, not just model-quality problems. It proposes a loop with five separated modules: retrieval, cognition, control, action, and memory. The central claim is that enforcing policies programmatically in a control gate, instead of asking the language model to remember rules, yields zero violations, no duplicated calls, and complete decision traces. A controlled experiment with a deterministic stand-in and a live deployment with a production language model both report the zero-violation behavior. If true, this offers a reusable template for making language-model agents auditable enough for high-stakes use.

Core claim

On its own terms, the paper's central discovery is that moving policy enforcement from the prompt into a deterministic control module changes the reliability profile of an LLM agent. The R-CCAM architecture separates evidence retrieval, probabilistic reasoning, gating, action, and memory into a recurrent loop; at each cycle, the control module checks whether the reasoning output cites stored evidence, whether a proposed tool call duplicates memory, and whether a final action has passed validation. The Metaprompt supplies policies in natural language, but compliance is checked in code. In the main experiment, a weather-based branching task runs through four loop iterations with all checks pas

What carries the argument

Soft Symbolic Control is the governance layer that carries the argument: it applies symbolic constraints to probabilistic inference while leaving the LLM free to reason within those constraints. It works through a persistent Metaprompt that declares policies and a Control module that validates outputs programmatically before any action executes. Memory stores state-action-rationale triples, enabling duplicate detection and evidence-citation checks, so the Control module consults Memory rather than trusting the LLM to remember what it did. This mechanism is what converts reliability from a property of the model's compliance into a property of the architecture itself.

Load-bearing premise

The zero-violations result rests on the assumption that a real language model will generate outputs that expose their compliance status—that it will include or omit the evidence markers and action fields the Control module checks; if the model produces plausible-looking but structurally noncompliant outputs, or fabricates the markers, the architecture alone cannot guarantee the claimed result.

What would settle it

Run the loop with a real LLM on a policy-laden task while systematically prompting it to omit required evidence tags or to insert plausible but fabricated tags; if the Control module approves an action that violates the policy, or if the audit log contains an uncited claim, the claimed 'zero violations' is refuted. The simplest version: deliberately prompt the model to produce a final action with no evidence reference and observe whether it is blocked.

Watch this falsifier. Get emailed when new claim-graph text bears on it.

If this is right

  • Policy compliance becomes an architectural property: any LLM that emits the expected structured fields can be governed, regardless of its tendency to forget instructions.
  • Memory only prevents drift and redundancy when the Control module actively consults it during validation; external memory alone is not sufficient.
  • Because the same loop ran with both a deterministic stand-in and a production LLM, the architecture is claimed to be model-agnostic.
  • Complete audit logs make every decision traceable, including rejected alternatives, supporting post-hoc review and regulatory oversight.
  • Rejected plans are preserved rather than lost, enabling graceful recovery and analysis of why certain proposals failed.

Where Pith is reading between the lines

These are editorial extensions of the paper, not claims the author makes directly.

  • The control pattern likely generalizes beyond language-model agents: any probabilistic pipeline with mandatory policies—code generation, retrieval-augmented answering, automated moderation—could adopt a deterministic gate that rejects outputs missing required markers.
  • The claimed zero violations would be stress-tested best by adversarial inputs: tools that return misleading data, users who phrase tasks to evade the metaprompt, or LLM outputs that fabricate evidence references; the paper does not report such tests.
  • An immediate experiment would be to run identical tasks with multiple different LLMs and varied metaprompt phrasings; the spread in violation rates would quantify how much of the guarantee comes from architecture versus from the model's tendency to comply with natural-language instructions.
  • Formalizing metaprompt policies as machine-readable constraints would let the control layer itself be verified and its coverage measured, rather than relying on the phrasing of natural-language rules.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

4 major / 5 minor

Summary. The paper proposes Structured Cognitive Loop (SCL), a modular agent architecture that separates cognition into Retrieval, Cognition, Control, Action, and Memory (R-CCAM), with a 'Soft Symbolic Control' governance layer. The authors claim that SCL achieves zero policy violations, eliminates redundant tool calls, and maintains complete decision traceability, based on a deterministic mock-LLM core experiment and a live GPT-4o travel-planning demo. The paper positions SCL within hybrid intelligence, distinguishes it from prompt-centric, memory-only, and neuro-symbolic approaches, and derives three design principles for trustworthy agents.

Significance. If the empirical claims were supported, SCL would offer a practical, auditable governance layer for LLM agents, addressing real failure modes such as entangled reasoning, memory drift, and uncontrolled action sequences. The paper provides an open-source implementation, a clear architectural description, a formal definition of Soft Symbolic Control, and a candid limitations section (§5.3). However, the central empirical claims are not supported as presented: the 'zero violations' metric is tautological, the baseline comparison is not controlled, and the mock-LLM results do not transfer to real LLM behavior. The architectural idea has merit, but the validation is not substantive enough for the claims made.

major comments (4)
  1. [§4.1.2, §4.3.2, §5.1.2] The definition of 'policy violations' is circular. §4.1.2 defines it as 'Count of Metaprompt rule violations' without stating whether a proposal rejected by Control counts as a violation. In Experiment 2 (§4.3.2), Plan A is rejected for failing the fairness check; if rejected proposals count, the 'zero violations' claim is already contradicted. If only executed actions count, zero is guaranteed because Control blocks non-compliant actions before Action (§5.1.2). Either way, 'zero policy violations' is a tautology, not an empirical measurement of reliability.
  2. [§4.4 and Table 1] The quantitative comparison against ReAct, Reflexion, AutoGPT, and MemGPT is invalid. The baseline numbers are 'derived from error rates documented in' other papers (§4.4, Table 1) that evaluated different task distributions and implementations. The authors acknowledge this in §5.3.2, but the abstract and §6.2 still rely on it, claiming a reduction 'from 1.5-4.5 violations per task ... to zero.' Without head-to-head implementation on identical tasks, this comparison does not support the stated conclusions.
  3. [§4.1.1, §4.5.3, §4.6.1] The generalization from mock LLM to GPT-4o is unsupported. The core experiment uses a deterministic rule-following mock specifically designed to comply with the Metaprompt (§4.1.1). The live demo has no control arm, no multiple runs, no statistical confidence, and does not report Control rejection rates, false positives/negatives, or per-run compliance rates. The claim that 'the same architecture yields zero violations' with GPT-4o (§4.6.1) is therefore not established.
  4. [§4.2.4, §4.6.1] The traceability and redundancy metrics are generated by the same system under test. Audit trail completeness is computed from the system's own Memory logs, and 'redundant tool calls' are counted by the same Control module that is designed to prevent them. Without an independent measurement or external audit, these metrics cannot support the claims of 'complete decision traceability' and 'eliminates redundant tool calls.'
minor comments (5)
  1. [§1] Typo: 'conf late' should be 'conflate' in the Introduction.
  2. [§4.5] The sentence 'To validate SCL's real-world applicability, we deployed the identical R-CCAM architecture with GPT-4o' appears twice, once before §4.5.1 and once immediately after it. Remove the duplicate.
  3. [§4.5.3] The '150+ interactions' statistic lacks a time window, task-type distribution, and breakdown of outcomes. Provide a detailed usage table, including rejection counts and error categories.
  4. [Figure 3] The screenshot is described in text but its content is not clear from the caption alone. Specify what the user sees and how it demonstrates traceability or control.
  5. [References] Verify that cited preprints (e.g., Gao et al. 2023, Pan et al. 2023) are publicly available with stable identifiers; some listed arXiv IDs appear unverified.

Circularity Check

2 steps flagged

Headline zero-violation and zero-redundancy results are guaranteed by the Control gate, not measured; the metric is defined so rejected proposals either disappear (making zero tautological) or count (making Experiment 2 violate the claim).

specific steps
  1. self definitional [Section 4.1.2; Section 4.3.2; Section 4.5.3; Section 4.6.1(1)]
    "Policy violations: Count of Metaprompt rule violations • Target: 0 violations (100% compliance) ... [CONTROL] ✗ FAIL: Detected overload on Bob (2 major tasks = 40% workload) ... [ACTION] Discard ... The explicit Control module acts as a programmatic gatekeeper, rejecting invalid actions before they reach execution."

    Zero violations is not an outcome measured after policy enforcement; it is the output of the enforcement itself. The metric definition does not state whether rejected proposals count. If rejected proposals count, Experiment 2's Control FAIL is a violation, contradicting 'zero policy violations across both controlled experiments' (§4.6.1). If only executed actions count, then Control's reject-before-Action check makes the count identically zero for any input, so the number carries no information about the LLM's or architecture's reliability. The live claim 'Policy violations detected: 0 (GPT-4o outputs validated by Control)' is the same tautology: 'detected' equals 'validated by Control'. No rejection rates, false positives/negatives, or raw proposal violation counts are reported, so the ze

  2. self definitional [Section 4.1.2; Section 5.1.2]
    "Redundant tool calls: Repeated API queries for identical information • Memory cache hits: Successful prevention of redundant queries ... if memory.has_evidence(evidence_id): return False, "REJECTED: Redundant tool call" ... Result: Zero violations through structural separation."

    'Eliminates redundant tool calls' is enforced by the same Control check: the redundancy detector is also the action gate, so any redundant call is rejected before execution and the executed count is zero by construction. As with policy violations, the paper reports the post-filter count as a property of the architecture, without ever reporting how many redundant calls the Cognition module proposed or how often Control had to reject them. Thus the '0 redundant tool calls' result is the definition of the check, not a measured consequence of SCL.

full rationale

SCL's architectural contribution (R-CCAM loop, Metaprompt, open-source code) is not circular in itself. The circularity is confined to the empirical headline. Section 4.1.2 defines 'policy violations' as a count of Metaprompt rule violations; Section 5.1.2 then shows the same Control module rejects missing evidence or redundant calls before Action; Section 4.6.1 calls Control a 'programmatic gatekeeper, rejecting invalid actions before they reach execution.' So the reported zero policy violations and zero redundant tool calls are post-filter counts that are zero by construction, not measurements of how often the model proposes violations or whether the checker is sound. Experiment 2's own ✗ FAIL for Plan A makes the ambiguity concrete: if a rejected proposal is a violation, the zero claim is false; if it is not, the metric only counts what Control already allowed. The live demo 'Policy violations detected: 0' repeats the tautology because the detector is the gatekeeper. Audit-trail completeness is similarly self-referential (13/13 of the system's own log entries), but I did not count it as a separate step. The paper's own limitations (§4.6.2, §5.3.1) concede that baseline numbers are borrowed and live statistics are preliminary; that is a validity concern rather than circularity. Self-citations to Kim (2025) are present but are not the load-bearing element of the zero-violation claim. Given that the paper's central reliability result reduces by construction, the score is 8 rather than 6, but not 10 because the architecture proposal, open-source implementation, and adaptive-rejection demonstration retain non-circular content.

Axiom & Free-Parameter Ledger

0 free parameters · 5 axioms · 1 invented entities

No numerical parameters are fitted to data. The experiments use hand-set task constants (55°F reference, 40% workload cap), which are not free parameters of the claimed mechanism. The load-bearing assumptions are about the transferability of a compliant mock to real stochastic LLMs, the reliability of natural-language Metaprompt constraints, the comparability of borrowed baseline numbers, and the paper-specific definition of what counts as a policy violation.

axioms (5)
  • domain assumption A deterministic mock LLM that always follows the Metaprompt is a valid proxy for real LLM stochastic behavior in validating architectural reliability.
    Section 4.1.1 adopts a mock engine 'to test architectural properties independent of LLM quality'; the paper then generalizes to GPT-4o in §4.5 and §4.6.1(4).
  • domain assumption Natural-language Metaprompt constraints are correctly interpreted by production LLMs such as GPT-4o.
    The live demo and §5.3.3 depend on this; §5.3.3 acknowledges prompt sensitivity as an open issue.
  • domain assumption Baseline error rates from Wang et al., Qiao et al., and Borji are comparable to SCL's experimental settings.
    Table 1 footnote and §4.6.2(4); the paper admits there was no head-to-head implementation.
  • ad hoc to paper A rejected proposal is not a policy violation.
    Experiment 2 Loop 5 rejects Plan A, but §4.3.3 frames this as adaptive enforcement and §4.2.4 counts 0 violations; this definition makes the zero-violation result trivially achievable.
  • domain assumption LLM agent fragility is primarily architectural, not model-capability, in origin.
    The framing in §1 and §2.1 motivates the need for SCL; it is not independently established by the experiments, which only test a compliant mock and a single live demo.
invented entities (1)
  • Soft Symbolic Control no independent evidence
    purpose: Governance layer that applies symbolic constraints to probabilistic inference at the control layer.
    No external falsifiable handle is provided; it is defined only through the paper's own prose and code and overlaps with existing guardrail/validation layers.

pith-pipeline@v1.3.0-alltime-deepseek · 20505 in / 12434 out tokens · 105634 ms · 2026-08-03T21:00:27.353534+00:00 · methodology

0 comments
read the original abstract

Large language model agents suffer from architectural fragilities such as entangled reasoning and execution, memory volatility, and uncontrolled action sequences. We introduce Structured Cognitive Loop (SCL), a modular agent architecture that separates cognition into Retrieval, Cognition, Control, Action, and Memory (R-CCAM). SCL introduces Regulation as a dedicated governance layer through which Soft Symbolic Control applies symbolic constraints to probabilistic inference, while Control remains a distinct deterministic runtime engine for duplicate-call prevention, error limits, and termination judgment. Through multi-step conditional reasoning experiments, we show that SCL achieves zero policy violations, prevents redundant tool calls, and maintains complete decision traceability. We position SCL within hybrid intelligence, distinguish it from prompt-centric, memory-only, and neuro-symbolic approaches, and derive three design principles for trustworthy agents: modular decomposition, adaptive symbolic governance, and transparent state management. With an open-source implementation and a live GPT-4o-powered travel planning agent, this work offers a practical path toward reliable, explainable, and governable LLM agents.

Figures

Figures reproduced from arXiv: 2511.17673 by Myung Ho Kim.

Figure 1
Figure 1. Figure 1: Governance structure of Structured Cognitive Loop: Retrieval feeds into the recurrent [PITH_FULL_IMAGE:figures/full_fig_p008_1.png] view at source ↗

discussion (0)

Sign in with ORCID, Apple, or X to comment. Anyone can read and Pith papers without signing in.

Forward citations

Cited by 4 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score.

  1. TEAM-SimHRA: A Team-Based Simulation Framework for Human Reliability Analysis Using Multi-Agent Large Language Models

    cs.MA 2026-04 conditional novelty 7.0

    Multi-agent LLM simulation of nuclear control-room teams reproduces TMI and Chernobyl decision delays, full communication suppression, and authority cascades at face-validity pass rates of 43.5% and 52.6%.

  2. Measuring and Improving Behavioral Consistency in Large Language Models through Fact-Heuristic-Emotion State Enforcement

    cs.CL 2026-06 conditional novelty 6.0

    A prompt that forces LLMs to separate facts, inferences, and emotions reduces repeated-answer variability (+0.016 to +0.021 SI on a ~0.95 baseline) and, under injected state persistence, cuts decision-flip rate by 82%...

  3. Towards Generalist Game Players: An Investigation of Foundation Models in the Game Multiverse

    cs.CV 2026-05 unverdicted novelty 5.0

    The paper organizes research on generalist game AI into Dataset, Model, Harness, and Benchmark pillars and charts a five-level progression from single-game mastery to agents that create and live inside game multiverses.

  4. Towards Generalist Game Players: An Investigation of Foundation Models in the Game Multiverse

    cs.CV 2026-05 unverdicted novelty 3.0

    This work traces four eras of generalist game players across dataset, model, harness, and benchmark pillars and charts a five-level roadmap ending in agents that create and evolve within game multiverses.

Reference graph

Works this paper leans on

26 extracted references · 2 canonical work pages · cited by 3 Pith papers

  1. [1]

    R., Bothell, D., Byrne, M

    Anderson, J. R., Bothell, D., Byrne, M. D., Douglass, S., Lebiere , C., & Qin, Y . (2004). An integrated theory of the mind. Psychological Review, 111(4), 1036–1060. https://doi.org/10.1037/0033-295X.111.4.1036

    doi:10.1037/0033-295x.111.4.1036 2004

  2. [2]

    R., d’Avila Garcez, A

    Besold, T. R., d’Avila Garcez, A. S., Bader, S., Bowman, H., Domingos, P., Hitzler, P., … & Zaverucha, G. (2017). Neural-symbolic learning and reasoning: A survey and interpretation. arXiv preprint arXiv:1711.03902. https://arxiv.org/abs/1711.03902

    Pith/arXiv arXiv 2017

  3. [3]

    Borji, A. (2023). A categorical archive of ChatGPT failures. arXiv preprint arXiv:2302.03494. https://arxiv.org/abs/2302.03494

    Pith/arXiv arXiv 2023

  4. [4]

    Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J., Dhariwal, P., … & Amodei, D. (2020). Language models are few -shot learners. Advances in Neural Information Processing Systems, 33 , 1877 –1901. https://arxiv.org/abs/2005.14165

    Pith/arXiv arXiv 2020

  5. [5]

    Bubeck, S., Chandrasekaran, V ., Eldan, R., Gehrke, J., Horvitz, E., Kamar, E., … & Zhang, Y . (2023). Sparks of artificial general intelligence: Early experiments with GPT -4. arXiv preprint arXiv:2303.12712. https://arxiv.org/abs/2303.12712

    Pith/arXiv arXiv 2023

  6. [6]

    G., & Shortliffe, E

    Buchanan, B. G., & Shortliffe, E. H. (1984). Rule-based expert systems: The MYCIN experiments of the Stanford Heuristic Programming Project. Addison-Wesley. d’Avila Garcez, A. S., & Lamb, L. C. (2020). Neurosymbolic AI: The 3rd wave. arXiv preprint arXiv:2012.05876. https://arxiv.org/abs/2012.05876

    Pith/arXiv arXiv 1984

  7. [7]

    Feigenbaum, E. A. (1981). The art of artificial intelligence: Themes and case studies of knowledge engineering. In Proceedings of the International Joint Conference on Artificial Intelligence (IJCAI) (pp. 1014–1029)

    1981

  8. [8]

    Gao, Y ., Liu, H., Wang, S., & Zhang, H. (2023). Task Memory Engine: Long-term memory for LLM-based agents. arXiv preprint arXiv:2309.17076. https://arxiv.org/abs/2309.17076

    Pith/arXiv arXiv 2023

  9. [9]

    Jackson, P. (1999). Introduction to expert systems (3rd ed.). Addison Wesley

    1999

  10. [10]

    Ji, Z., Lee, N., Frieske, R., Yu, T., Su, D., Xu, Y ., … & Fung, P. (2023). Survey of hallucination in natural language generation. ACM Computing Surveys, 55(12), 1–38. https://doi.org/10.1145/3571730

    doi:10.1145/3571730 2023

  11. [11]

    Kim, M. (2025). Emergent cognitive convergence via implementation. PsyArXiv preprint https://doi.org/10.31234/osf.io/8m4vf

    work page doi:10.31234/osf.io/8m4vf 2025

  12. [12]

    Kotseruba, I., & Tsotsos, J. K. (2020). 40 years of cognitive architectures: Core cognitive abilities and practical applications. Artificial Intelligence Review, 53(1), 17–94. https://doi.org/10.1007/s10462-018-9646-y

    doi:10.1007/s10462-018-9646-y 2020

  13. [13]

    Laird, J. E. (2012). The Soar cognitive architecture. MIT Press

    2012

  14. [14]

    LeCun, Y ., Bengio, Y ., & Hinton, G. (2015). Deep learning. Nature, 521 (7553), 436 –444. https://doi.org/10.1038/nature14539

    doi:10.1038/nature14539 2015

  15. [15]

    Liang, P., Bommasani , R., Lee, T., Tsipras, D., Soylu, D., Yasunaga, M., … & Zhang, C. (2022). Holistic evaluation of language models. arXiv preprint arXiv:2211.09110. https://arxiv.org/abs/2211.09110

    Pith/arXiv arXiv 2022

  16. [16]

    Lipton, Z. C. (2018). The mythos of model interpretability. Queue, 16 (3), 31 –57. https://doi.org/10.1145/3236386.3241340 OpenAI. (2023). GPT-4 technical report. arXiv preprint arXiv:2303.08774. https://arxiv.org/abs/2303.08774

    arXiv 2018

  17. [17]

    Packer, C., Gao, L., Wu, E., Chan, S., Narasimhan, K., & Liang, P. (2023). MemGPT: Towards LLMs as operating systems. arXiv preprint arXiv:2310.08560. https://arxiv.org/abs/2310.08560

    Pith/arXiv arXiv 2023

  18. [18]

    Pan, X., Li, J., & Zhao, W. (2023). A -MEM: Agentic memory for long -horizon reasoning. arXiv preprint arXiv:2312.12345. https://arxiv.org/abs/2312.12345

    Pith/arXiv arXiv 2023

  19. [19]

    Qiao, S., Wang, Z., Chen, X., & Zhang, T. (2023). Reasoning with language model agents: When and why it fails. arXiv preprint arXiv:2309.00236. https://arxiv.org/abs/2309.00236

    Pith/arXiv arXiv 2023

  20. [20]

    Russell, S., & Norvig, P. (2021). Artificial intelligence: A modern approach (4th ed.). Pearson

    2021

  21. [21]

    Shinn, N., Cassano, F., Labash, B., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. arXiv preprint arXiv:2303.11366. https://arxiv.org/abs/2303.11366 Significant Gravitas. (2023). AutoGPT: An autonomous GPT -4 experiment. GitHub repository . https://github.com/Torantulino/Auto-GPT

    Pith/arXiv arXiv 2023

  22. [22]

    Sun, R. (2006). The CLARION cognitive architecture: Extending cognitive modeling to social simulation. Cognitive Systems Research, 7(2–3), 79–92. https://doi.org/10.1016/j.cogsys.2005.11.005 Tenable Research. (2025, August 5). Tenable jailbreaks GPT -5: Generating dangerous information despite OpenAI’ s new safety tech. Tenable. https://www.tenable.com/bl...

    work page doi:10.1016/j.cogsys.2005.11.005 2006

  23. [23]

    Wang, X., Liu, Z., Li, J., & Yu, H. (2023). On evaluating large language model agents. arXiv preprint arXiv:2309.07864. https://arxiv.org/abs/2309.07864

    Pith/arXiv arXiv 2023

  24. [24]

    Wang, Z., Zhang, H., & Zhou, Y . (2023b). V oyager: An open-ended embodied agent in Minecraft powered by large language models. arXiv preprint arXiv:2305.16291. https://arxiv.org/abs/2305.16291

    Pith/arXiv arXiv

  25. [25]

    Yao, S., Bosma, M., Zhao, Y ., Yu, D., Zhao, Z., Zhang, T., … & Narasimhan, K. (2023). ReAct: Synergizing reasoning and acting in language models. arXiv preprint arXiv:2210.03629. https://arxiv.org/abs/2210.03629

    Pith/arXiv arXiv 2023

  26. [26]

    Yao, S., Zhao, Z., Y u, T., Dong, D., & Narasimhan, K. (2023b). Tree of Thoughts: Deliberate problem solving with large language models. arXiv preprint arXiv:2305.10601. https://arxiv.org/abs/2305.10601

    Pith/arXiv arXiv