The Competent Verifier Problem
In ninety-six controlled trials an AI reviewer approved every artefact it saw. Three-quarters of those approvals were wrong — and the reviewer did nothing wrong.
Keywords: AI agents · multi-agent systems · verification · software assurance · delegation · requirements engineering · false assurance · LLM workflows · AI governance · specification transmission
Imagine you hire a contractor to build something to an eight-point specification. The contractor subcontracts. The subcontractor gets five of your eight points. He does excellent work against those five. Then a building inspector arrives — competent, diligent, incorruptible — and signs off. He also received five points. He checked all five. He signed.
You now hold a signed certificate of compliance for a building that meets five of your eight requirements. Nobody lied. Nobody was lazy. Nobody was incompetent. The inspector applied his rule correctly and arrived at the wrong answer, because the rule he applied was not your contract.
This is not a hypothetical about construction. It is what happens, measurably and reproducibly, when you decompose a task across AI agents. I have spent the last several months building an experiment to establish that it happens, to measure how much, and to find out what fixes it. This post is about what I found, and about the one result that surprised me enough to force a revision of the theory.
The thing that travels, and the thing that doesn’t
Autonomous AI is increasingly organised rather than merely invoked. A single request gets decomposed among a planner, several generators, a retriever, a critic, a supervisor, and components that can call tools or change external state. The resulting system is an organisation in a literal economic sense: production is divided across specialised units, communication links determine who receives what, review is allocated to particular roles, and some control rights sit outside the productive path.
Economics has thought about this for forty years. Sah and Stiglitz (1986) showed that hierarchies and polyarchies screen errors differently. Radner (1993) formalised the trade-off between the number of limited-capacity processors and the delay before a decision issues. Bolton and Dewatripont (1994) treated the firm as a communication network with returns to specialisation set against the cost of communicating what has been processed. Garicano (2000) allocated problems by who knows what. Dessein (2002) showed delegation substituting for costly communication while changing the information decisions are made on.
What autonomous computation adds is observability. Messages can be logged. Role boundaries can be specified exactly. The terminal artefact can be scored against a frozen specification by a deterministic program. The classic objects of organisational economics become, for the first time, things you can put on a bench and manipulate.
So I did. And what I wanted to manipulate was not how many agents there are, or how they are wired together. Everyone is already studying that. Iterative self-refinement, debate, tree search and stateful feedback all improve performance in some settings (Madaan et al., 2023; Shinn et al., 2023; Du et al., 2024; Zhou et al., 2024). Matched-compute comparisons show that more organisation is not uniformly productive (Kapoor et al., 2025; Tran & Kiela, 2026; Kim et al., 2026). Communication topology governs how correct and erroneous outputs propagate (Shen et al., 2025).
I wanted to manipulate something else: the reference against which local production and verification are performed. Not what the agents produce. What they are checking it against.
Why this is not “context loss”
The obvious objection is that I have discovered a well-known thing with a new name. Agents lose context at handoffs. Everybody knows this.
That literature is real and it is good. Lin et al. (2026) identify data gaps, signal corruption, referential drift and capability gaps at inter-agent edges. Li et al. (2026a) formalise workflow learning when specialised agents observe only local functions of a shared artefact. Li et al. (2026b) broaden it to constraint drift across memory, delegation, communication, tool use and audit. Han et al. (2025) show language models struggling to follow multiple turns of entangled instructions. Most directly, Sun et al. (2026) demonstrate that handoff transformations can retain the semantic content of a constraint while weakening its action-binding force — “must” becoming “maybe”.
None of that is what I am claiming as new, and the paper says so explicitly.
Here is the distinction. A handoff defect becomes an assurance failure only when the same degraded representation also defines the supervisor’s acceptance standard. The wedge is not that the callee knows less than the principal. It is not that binding state decays between time t and t+1. It is that the principal’s acceptance rule and the local verification rule have come apart, and both sides of that gap are separately recordable.
It is also distinct from goal drift, which Arike et al. (2025) study as an agent’s adherence to an assigned objective over extended interaction. That is a within-agent temporal problem. This is an across-role reference problem. The producer can be perfectly obedient to its brief, the supervisor perfectly obedient to its review rule, and the organisation still fails the principal, because both briefs are incomplete relative to the authoritative contract. No role needs to become opportunistic, deceptive, confused or less capable.
And it is distinct from the incomplete-contracting frame that AI alignment has borrowed from economics. Hadfield-Menell and Hadfield (2019) connect alignment to incomplete contracting and find the same causes on both sides. Zhuang and Hadfield-Menell (2020) show an agent optimising a proxy defined over a subset of attributes driving the unmentioned ones to their bounds, with unbounded loss. In both, the objective is incomplete at origin. In what I am describing, the original contract is complete, explicit and frozen. The incompleteness is generated inside the organisation, after the principal has finished specifying, by a routing decision nobody made as a decision about standards.
That relocation matters because it inverts the remedy. The alignment literature’s fix is to let the principal revise the proxy. Reference divergence attacks that directly: the workflow does not prevent revision. The contract simply stops being the object against which acceptance is decided, so revisions never reach the point of certification.
The experiment
Three randomised experiments, 336 trajectories, two frozen model runtimes, three delegation depths.
Each task carries eight explicit binding conditions, frozen before anything runs. Half of them — the odd-numbered four — are transmitted to the producing role. The other four are not. This is pre-specified, not discovered after the fact.
Then I cross two factors. The first is topology: how the work is routed. The second, and the one that matters, is whether the role performing verification holds the authoritative contract or the same scoped-down version the producer saw. Task, contract and production input are held fixed. Every role is separately instantiated with no shared context, so a condition that did not travel in a message genuinely did not travel.
Scoring is done by a deterministic program, not a model. Before it scores anything it must pass its own validation suite: eight reference artefacts must score eight out of eight, and sixty-four single-condition mutants must each fail the condition they target and only that condition. Every prompt and every verbatim model return is deposited — 2,379 files — and a harness recomputes every published number from them and asserts it against the printed value. It runs 377 such checks.
I mention the plumbing because the finding is otherwise easy to dismiss as an artefact of a sloppy setup, and because the whole argument is about what happens when nobody can check the checker.
Figure 1: the raw evidence
Every condition, every trajectory
Every condition observation in the three randomised studies, one cell each: 768 for Study 2, 768 for Study 3, 384 for Study 4. Colour records whether the condition reached the producing role and whether the artefact satisfied it.
This is 1,920 observations with nothing aggregated away. Rows are trajectories, grouped by experimental cell. Columns are the eight contract conditions.
Look at the banding. Because the transmitted subset was the odd-numbered conditions, the picture stripes vertically: dark and solid where the requirement travelled, broken and red where it did not. No statistic has been computed. That pattern is the raw output of the scorer.
The numbers underneath it: conditions that reached the producing role passed at 99.5 per cent. Conditions that did not passed at 54.2 per cent.
Both halves of that are informative, and the second half is the one people miss. A requirement that never reached the producer is still satisfied more than half the time — by task structure, by convention, by the model’s priors, by the arithmetic of the problem. Missing specification does not reliably produce failure.
It reliably produces loss of guarantee. That distinction is the whole paper.
Reference beats topology, and it isn’t close
Holding everything else fixed, giving the verifier the authoritative contract raises compliance by 15.6 percentage points on the first runtime and 22.7 on the second.
Changing the topology moves it by 1.0 point — statistically indistinguishable from zero, with no interaction.
I want to be careful about what that does and does not say. It does not say topology never matters; Shen et al. (2025) show it governing error propagation, and they are right. It says that in this design, against a frozen contract, what the checker was allowed to see dominated how the work was routed by more than an order of magnitude.
Most of the practical energy in agent engineering goes into the second thing.
The two outputs
Here is where it stops being a performance question.
An organisation running a workflow like this has two outputs, not one.
The first is whether the artefact meets the principal’s conditions. The second is whether the organisation’s own control record entitles anyone to conclude that it does.
These can move in opposite directions, and in this experiment they do. Under a scoped verifier, every single one of the 48 artefacts was certified — and 36 of those certificates were false. Under an authoritative verifier, 14 were certified and none were false.
Read the first number again. The certification rate went down when the verifier was made better. Of course it did: it was now able to reject things. A naïve dashboard tracking “review pass rate” would show the scoped, useless verifier outperforming the authoritative one by a factor of three.
The planning tasks make the divergence exact. Terminal compliance is complete. The certificate covers half the contract. The uncertified conditions hold by the arithmetic of the task rather than by anything the organisation did. An auditor asking whether the constraint was met gets the right answer. An auditor asking how the organisation knew gets nothing.
This is not a production failure. It is an internal-control information failure, and the two have different remedies. A better model raises the probability the artefact is right and leaves the certificate exactly as uninformative as before. That is the uncomfortable part: an organisation watching only terminal quality sees nothing wrong, and sees least wrong precisely where its models are strongest.
Organisational research has known the shape of this for a long time under other names — goal displacement, where measures displace the ends they were meant to serve (Bohte & Meier, 2000), and the audit literature’s observation that weighing the pig never made it heavier (Blewett & O’Keeffe, 2011). What is new is that in a computational workflow the original contract, the local visible reference, the local pass and the external result are four separately logged objects in one chain. You can watch it happen.
Figure 2: where it is made, and where it is caught
So: install an independent gate. Give it the frozen contract and the artefact. Withhold the local certificate, so it cannot be persuaded by the review it is supposed to be checking.
Where false assurance is made and caught
All 96 artefacts traced through what they are, what the local verifier says, and what the gate does. Ribbon widths are counts and balance at every boundary.
It works. The gate blocks all 60 non-compliant artefacts. Realised false assurance at the local certificate is 0.375; surviving false assurance at the release boundary is zero.
Note carefully what that does and does not buy. The gate repairs the release system. It does not repair a single local certificate. Every one of those 36 false certificates still exists, still says the artefact is fine, and is still wrong. An organisation that installs a gate has bought a safe boundary, not a trustworthy interior. If anything downstream ever relies on the certificate rather than the gate — and in real systems things do — the gate has not helped.
The gate’s own failure mode, which runs the other way
Then the cost side, which I did not predict and which is the most useful thing in the paper.
Of the 36 fully compliant artefacts, the gate wrongly blocked 10 — a false-block rate of 27.8 per cent.
Those ten are not scattered. Every one is the same task type. Every one is blocked on the same contract term: field values must match the source record. That term points at something outside the contract. The gate held the contract. It did not hold the record. A checking role holding only the specification cannot discharge a term that refers to material the specification does not contain, and so it does the safe thing and rejects.
Give the gate the material its own contract points at, on identical artefacts, and every false block disappears without losing a single true one. Release-level classification goes to 96 correct out of 96.
So reference insufficiency has two opposite signatures, and the direction is set by position in the chain:-
A role that lacks the contract under-rejects. It certifies things it should not.
-
A role that holds the contract but not the material the contract points at over-rejects. It blocks things it should not.
These need different remedies. The first needs the specification delivered. The second needs the specification’s referents delivered. An organisation that fixes only the first will build a gate that blocks a quarter of its good work and will conclude that assurance is expensive.
Depth does nothing, and this broke my theory
The last experiment was supposed to be a formality. Extend the chain from two producing roles to three and watch the loss compound.
I had a model that predicted it. If each handoff scopes the reference with some probability, the surviving fraction decays geometrically in the number of communication positions. A third stage should cost something.
It cost nothing. Compliance, false assurance and reconstruction are exactly flat across one, two and three producing roles. Not approximately equal — realised false assurance is 0.375 at every depth, and it is the same eighteen events in forty-eight trajectories each time.
The reason is architectural, not statistical. In this workflow — and in the ordinary agentic pipeline it imitates — the scoping decision is taken once, before production, and every downstream role inherits the resulting brief unchanged. No role re-derives what to pass on. So no handoff is an independent opportunity to lose a term.
The exponent in the recursion is not the number of roles. It is the number of scoping acts. In these architectures that number is one, whatever the depth. The theory had to be corrected, and the corrected version predicts exactly the flatness observed.
This is the paper’s sharpest reply to the literature that treats recursion depth as the hazard. Depth is not harmless in general: where every handoff re-scopes, the decay is real and worth fearing. It is harmless here, and in any architecture that fixes a single scoped brief and passes it down, because the loss has already happened before the chain begins.
Which means flattening your agent hierarchy buys you nothing if the flattened version still hands every role the same abridged brief. The governance question is not how deep the delegation runs. It is how many times, and on whose authority, the operative reference is decided.
How to tell whether this is happening to you
The awkward property of reference divergence is that it is invisible to every measurement most teams already have. Output quality looks fine, because output quality mostly is fine — remember the 54.2 per cent. Review pass rates look excellent, because a scoped reviewer passes everything. Latency and cost look normal. Nothing alerts.
Four checks will tell you, and none of them requires re-running your pipeline.
Diff the brief against the contract, per role. Take one live request. Print, for each role in the chain, the exact text of the specification that role received. Put those side by side with what the requester actually asked for. You are not looking for paraphrase; you are looking for conditions that are absent. In most pipelines I have looked at, nobody has ever done this, because the brief is assembled by a template and read by nothing.
Find out what your reviewer was holding. This is the one that matters. Whatever your critic, judge, evaluator or verifier step is, establish exactly what it saw when it made its last thousand decisions. If the answer is “the same context the generator had”, you do not have verification. You have a second opinion from someone reading the same abridged document.
Look for terms that point outward. Go through your specification and mark every requirement that refers to something the specification does not itself contain: match the source record, conform to the house style, be consistent with the prior filing. Each one is a place where a reviewer holding only the spec must either guess or reject. My gate rejected a quarter of perfectly good work on exactly one such term, and it did so silently and defensibly.
Count the scoping acts. Walk the pipeline and mark every point where code or a model decides what the next stage will be shown. Not every handoff — only the ones that make a decision about content. In most agentic systems that number is one, and it is in a prompt template that somebody wrote in an afternoon and nobody has reviewed since. That single act is doing more to determine whether you can certify your output than your model choice, your topology, or your chain length.
If those four checks come back clean, this problem is not yours. If the second one comes back “same context”, you are almost certainly issuing certificates that do not mean what your organisation thinks they mean — and you will not find out from your metrics, because the failure is in the metrics.
What to actually do
Five things follow, and none of them is “use a better model”.
Separate the two independences. A supervisor is not independent because it has a different role label or a second inference call. Contractual assurance needs organisational separation of the reviewing role and informational separation of the authoritative reference from the productive path. Where producer and reviewer share the same degraded brief, you have added reasoning capacity without adding a single bit of principal-relevant information.
Stop transmitting; start letting roles pull. The cost of carrying the full contract down a chain rises with delegation depth. The value of holding it once, outside the chain, does not. As you decompose work more finely, the efficient answer is not to push more specification down — it is an authoritative store that roles query and cannot amend. Compressing a work order is fine. Destroying the authoritative reference is not. Specification-driven approaches to AI-native engineering are converging on the same conclusion (Alenezi, 2026), and cross-framework agent specifications are a step toward making the reference itself portable (Amini et al., 2026).
Deliver the referents, not just the reference. If a contract term points outward, whoever must discharge it needs what it points at. Otherwise your gate rejects good work and you learn the wrong lesson about the cost of control.
Count scoping acts, not roles. Instrument the point where somebody decides what the next role will see. That is your risk surface. Chain length is a distraction.
Price custody as an option, not as defect prevention. Custody’s value does not vanish when the model would have got it right anyway. Where omitted conditions are satisfied regardless — the modal case in my data — custody converts accidental compliance into demonstrable compliance, and that gets cashed later and unevenly: at an audit, at a regulatory challenge, at the moment a downstream team decides whether to re-verify an inherited component or trust it. Appraise custody against expected terminal quality alone and you will underinvest, and you will underinvest most where your models are best.
This also sharpens what delegation means. The literature on delegated authority asks which decisions move down a hierarchy (Grossman & Hart, 1986; Hart & Moore, 1990; Aghion & Tirole, 1997). Within a single delegated task, the right to perform the work, the right to determine what counts as completion, and the right to certify completion are separable — and travelling with each is a representation of the contract that can be logged and varied. A decision right is not fully described until you also ask which representation of the requirements travelled with it. Recent work on contracting for LLM delegation is beginning to treat that surface as economic rather than merely technical (Sreenivas & Larson, 2026).
What this does not show
Honesty about limits is not a ritual here; it is the subject matter.
The task world is constructed. Eight investigator-written contracts, short artefacts, mechanically checkable terms. A naturally occurring contract, with genuine ambiguity and a principal who is not also the experimenter, would be a much harder and much better test.
Two model points are two model points. The effect survived a change of runtime and got larger, and the ordering of task families was identical across both — but the levels moved a great deal. On the stronger model, one task family reconstructed its omitted conditions perfectly; on the weaker, fewer than half. Reconstructibility is joint in the contract and the role. Which means a procurement decision that lowers model capability silently raises the reference custody that the same contract requires. That is not a fixed property you can survey once.
The Arm B result — give the gate what the contract points at — was specified after Arm A had run and its blocks had been inspected. It is a second design fixed in light of the first, and it is reported as such rather than dressed up as a prediction.
And I never varied the thing the corrected theory says is operative. Every cell in every study scopes the reference once. A design that varies the number of scoping acts rather than the number of roles is the obvious next experiment, and I have not run it.
The sentence to keep
If one thing survives from all of this, it should be this:
More review cannot establish principal compliance unless the acceptance rule remains the principal’s.
Adding a critic, adding a supervisor, adding a second pass, adding a debate round — none of it does what you think it does if every added reviewer is checking the same abridged brief. You are buying reasoning capacity and booking it as assurance. Those are different goods, and only one of them is on your dashboard.
References
Aghion, P., & Tirole, J. (1997). Formal and real authority in organizations. Journal of Political Economy, 105(1), 1–29. https://doi.org/10.1086/262063
Alenezi, M. (2026). Specification-driven development as the foundation of AI-native enterprise software engineering (arXiv:2607.16680). arXiv. https://arxiv.org/abs/2607.16680
Amini, S., Benajiba, Y., Bernardis, C., Cayet, P., Chafi, H., Fathan, A., Faucon, L., Hilloulin, D., Hong, S., Kossyk, I., Lahiri, T., Le, T. M. S., Patra, R., Ravi, S., Schweizer, J., Singh, J., Singh, S., Sun, W., Talamadupula, K., & Xu, J. (2026). Open agent specification: Enabling cross-framework comparison of AI agents. In Proceedings of the ACM Conference on AI and Agentic Systems (pp. 404–418). Association for Computing Machinery. https://doi.org/10.1145/3786335.3813130
Arike, R., Donoway, E., Bartsch, H., & Hobbhahn, M. (2025). Evaluating goal drift in language model agents. In Proceedings of the AAAI/ACM Conference on AI, Ethics, and Society, 8(1), 192–203. https://doi.org/10.1609/aies.v8i1.36541
Blewett, V., & O’Keeffe, V. (2011). Weighing the pig never made it heavier: Auditing OHS, social auditing as verification of process in Australia. Safety Science, 49(7), 1014–1021. https://doi.org/10.1016/j.ssci.2010.12.010
Bohte, J., & Meier, K. J. (2000). Goal displacement: Assessing the motivation for organizational cheating. Public Administration Review, 60(2), 173–182. https://doi.org/10.1111/0033-3352.00075
Bolton, P., & Dewatripont, M. (1994). The firm as a communication network. Quarterly Journal of Economics, 109(4), 809–839. https://doi.org/10.2307/2118349
Dessein, W. (2002). Authority and communication in organizations. Review of Economic Studies, 69(4), 811–838. https://doi.org/10.1111/1467-937X.00227
Du, Y., Li, S., Torralba, A., Tenenbaum, J. B., & Mordatch, I. (2024). Improving factuality and reasoning in language models through multiagent debate. In Proceedings of the 41st International Conference on Machine Learning (pp. 11733–11763).
Garicano, L. (2000). Hierarchies and the organization of knowledge in production. Journal of Political Economy, 108(5), 874–904. https://doi.org/10.1086/317671
Grossman, S. J., & Hart, O. D. (1986). The costs and benefits of ownership: A theory of vertical and lateral integration. Journal of Political Economy, 94(4), 691–719. https://doi.org/10.1086/261404
Hadfield-Menell, D., & Hadfield, G. K. (2019). Incomplete contracting and AI alignment. In Proceedings of the 2019 AAAI/ACM Conference on AI, Ethics, and Society (pp. 417–422). Association for Computing Machinery. https://doi.org/10.1145/3306618.3314250
Han, C., Liu, X., Wang, H., Li, S., Yang, J., Jiang, H., Wang, Z., Yin, Q., Qiu, L., Yu, C., Gao, Y., Li, Z., Yin, B., Shang, J., & Ji, H. (2025). Can language models follow multiple turns of entangled instructions? In Findings of the Association for Computational Linguistics: EMNLP 2025 (pp. 25445–25460). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.findings-emnlp.1387
Hart, O., & Moore, J. (1990). Property rights and the nature of the firm. Journal of Political Economy, 98(6), 1119–1158. https://doi.org/10.1086/261729
Kapoor, S., Stroebl, B., Siegel, Z. S., Nadgir, N., & Narayanan, A. (2025). AI agents that matter. Transactions on Machine Learning Research.
Kim, Y., Gu, K., Park, C., Park, C., Schmidgall, S., Heydari, A. A., Yan, Y., Zhang, Z., Zhuang, Y., Liu, Y., Malhotra, M., Liang, P. P., Park, H. W., Yang, Y., Xu, X., Du, Y., Patel, S., Althoff, T., McDuff, D., & Liu, X. (2026). Capable language models can outgrow the benefits of collaboration. Nature Machine Intelligence, 8, 1157–1172. https://doi.org/10.1038/s42256-026-01268-y
Li, J., Zhang, E., Zhou, D., Chen, E., & Yan, Y. (2026a). Learning to hand off: Provably convergent workflow learning under interface constraints (arXiv:2605.19140). arXiv. https://arxiv.org/abs/2605.19140
Li, T., Ma, Y., Wen, H., Huang, Z., Zhou, Q., Fu, Z., & Cheng, G. (2026b). Safe multi-agent behavior must be maintained, not merely asserted: Constraint drift in LLM-based multi-agent systems (arXiv:2605.10481). arXiv. https://arxiv.org/abs/2605.10481
Lin, B., Yang, K., Tan, Z., Lai, Y., Zhang, C., Zhang, G., Yu, X., Yu, M., Wang, X., Zhang, Y., & Wang, Y. (2026). AgentAsk: Multi-agent systems need to ask. In Proceedings of the 64th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) (pp. 28055–28077). Association for Computational Linguistics. https://doi.org/10.18653/v1/2026.acl-long.1294
Madaan, A., Tandon, N., Gupta, P., Hallinan, S., Gao, L., Wiegreffe, S., Alon, U., Dziri, N., Prabhumoye, S., Yang, Y., Gupta, S., Majumder, B. P., Hermann, K., Welleck, S., Yazdanbakhsh, A., & Clark, P. (2023). Self-Refine: Iterative refinement with self-feedback. In Advances in Neural Information Processing Systems (pp. 46534–46594).
Radner, R. (1993). The organization of decentralized information processing. Econometrica, 61(5), 1109–1146. https://doi.org/10.2307/2951495
Sah, R. K., & Stiglitz, J. E. (1986). The architecture of economic systems: Hierarchies and polyarchies. American Economic Review, 76(4), 716–727.
Shen, X., Liu, Y., Dai, Y., Wang, Y., Miao, R., Tan, Y., Pan, S., & Wang, X. (2025). Understanding the information propagation effects of communication topologies in LLM-based multi-agent systems. In Proceedings of the 2025 Conference on Empirical Methods in Natural Language Processing (pp. 12347–12361). Association for Computational Linguistics. https://doi.org/10.18653/v1/2025.emnlp-main.623
Shinn, N., Cassano, F., Berman, E., Gopinath, A., Narasimhan, K., & Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. In Advances in Neural Information Processing Systems.
Sreenivas, N. K., & Larson, K. (2026). Contracting for LLM delegation: Moral hazard in technology and effort choice (arXiv:2608.18232). arXiv. https://arxiv.org/abs/2608.18232
Sun, Y., Wang, H., Zhu, Y., Li, Z., Zhao, Z., & Yuan, Y. (2026). When “must” becomes “maybe”: Constraint weakening in LLM agent workflows (arXiv:2608.24569). arXiv. https://arxiv.org/abs/2608.24569
Tran, D., & Kiela, D. (2026). Single-agent LLMs outperform multi-agent systems on multi-hop reasoning under equal thinking token budgets (arXiv:2604.02460). arXiv. https://arxiv.org/abs/2604.02460
Zhou, A., Yan, K., Shlapentokh-Rothman, M., Wang, H., & Wang, Y.-X. (2024). Language agent tree search unifies reasoning, acting, and planning in language models. In Proceedings of the 41st International Conference on Machine Learning (pp. 62138–62160).
Zhuang, S., & Hadfield-Menell, D. (2020). Consequences of misaligned AI. In Advances in Neural Information Processing Systems (Vol. 33).