Abstract render of a glowing ring around a dark centre
An agent is a loop: a model reads, acts, reads the result and acts again. This article tests what that loop can and cannot do.

Key numbers

The figures this article rests on; each is sourced in Sources.

  1. Tool calls run in application code — A model emits a structured call and the application's code executes it, exactly as vendors document. [S13]
  2. Models compute arithmetic internally — Attribution graphs show two parallel pathways when adding 36 and 59, so 'no maths' is contradicted, though the self-explanation was false. [S2]
  3. Restaurant demo: a browser agent — Operator used a vision model clicking web pages and was trained to ask for confirmation before external side effects. [S56]
  4. Time horizon at 50% vs 80% success — One early model scored 17.4 h at 50% success but 3.1 h at 80%, a 5.6x gap that is the reliability problem. [S25]
  5. 20 steps at 95% per step — A 95%-per-step agent completes a 20-step run 35.8% of the time (derived); a verifier with retries lifts it to about 90%. [S12]
  6. 2026 capex: about $0.7T — Four firms guide to roughly $700-740B (derived sum); the often-quoted $3 trillion has no source. [S38]
  7. 2026 private rounds — $122B at $852B and $65B at $965B in 2026 contradict 'out of private money'. [S49]
  8. OT guidance: human in the loop — CISA and partners advise limiting active control of OT by AI without a human in the loop. [S31]

The critique is right about the mechanism and wrong about the absolutes. A language model does predict tokens, and an agent does act only through code someone wrote: the model proposes a structured call, a harness executes it and feeds the result back. But the model is not only a lookup of likely strings, the measured record of agents is real and improving, and the money is real too. What the record does show is that reliability compounds badly over many steps, so an agent is safe where deterministic checks decide which of its guesses reach the world, and never on a plant's control loop without an interlock.

The 14 claims tested

The case against “agentic AI” usually runs like this: a language model only guesses the next token, an agent is ordinary code around it, and the label exists to sell a story to investors. Each part of that argument is a claim that can be checked. This article states fourteen of them, C1 to C14, and grades each against primary sources: documentation, research and benchmarks for the mechanism; filings and earnings for the money; definitions for the names. No claim is accepted or rejected on who makes it.

Disclosure

This article was researched and drafted with Claude, an Anthropic model. Several key sources are Anthropic’s own: the interpretability studies [S1] [S2], the essay Building effective agents [S12], the Agentic misalignment report [S28] and the filing notice for its draft S-1 [S47]. They are the primary sources for what they describe; each is paired with independent evidence where it exists. Author: Bagus Dwi Permana. Conclusions are checked against the listed sources, not against the model’s account of itself.

1.1 Claims C1–C14

The claims, in the order the sections test them. Grades are in section 11.
IDClaimKindTested in
C1A language model is a statistical next-token predictor: it outputs one token, appends it and runs againMechanism§2
C2It does not represent words, numbers or logic; it cannot reason or do mathsMechanism§3
C3It has no memory, no logic and no calculator insideMechanism§3
C4A model cannot reach the internet or act in the world by itselfMechanism§2
C5An agent that books a table is a script calling a booking API; the model only fills in the callMechanism§4
C6In such an agent the model does nothing; the work is decades-old automationInterpretation§4, §8
C7Open agent frameworks contain no AI, only programmingInterpretation§4, §8
C8Building this has cost about $3 trillion of computeNumber§7
C9The leading researchers have quit because language models are a dead endFact§7
C10Models hallucinate often and will not get much betterPrediction§5
C11Agents cannot write large programs and will not replace programmersMechanism and prediction§5
C12The labs have exhausted private money and need an IPO story; “agents” is that storyEconomics§7
C13Selling agents this way borders on securities fraudLegal§7
C14“AI” should be dropped from the name, for example “generative” or “automated computing”Naming§8

Each kind needs different evidence. Mechanism claims (C1–C7, C10, C11) are settled by documentation, interpretability research and benchmarks, in sections 2 to 6. Money claims (C8, C9, C12, C13) are settled by filings and earnings, in section 7. Naming claims (C6, C7, C14) are a matter of definition, not measurement, in section 8. Sections 9 and 10 turn the findings into design rules and a checklist for a data-center team. Article 29 explains the model itself, including sampling and post-training.

Terms follow common usage: an agent is a model running in a loop with tools; an agentic system includes the code around it.

The technical core of the critique is correct. A language model produces one token at a time, cannot reach the internet by itself, and an “agent” is a program that takes the model’s output, runs something and returns the result. The dispute starts at “did nothing”, tested in sections 3 and 4.

2.1 Next-token prediction

A forward pass ends in a probability for each token in the vocabulary. The decoder picks one, appends it to the context and runs the pass again, until a stop condition is met. Claim C1 describes exactly this loop. Article 29, section on sampling, covers the logits, softmax and choice among top candidates. Consequence for agents: the same prompt can give a different answer on the next run, and nothing inside the model guarantees an output is correct, only that it is probable.

Weights are fixed at inference; the model does not learn from the conversation. Within a session it “remembers” only the text in its context window; across sessions, only text another program stored and pasted back. “No memory” (C3) is accurate for the weights and incomplete for the system, because agents add memory outside the model: files, databases, retrieved documents [S18].

2.2 The model never executes anything

Anthropic’s tool-use documentation: Claude “returns a structured call that your application executes (client tools) or that Anthropic executes (server tools)”, signalled with stop_reason: "tool_use"; “your code executes the operation and sends back a tool_result” [S13]. OpenAI’s function-calling guide lists five steps: send a request with tools, receive a tool call, “execute code on the application side with input from the tool call”, send a second request with the tool output, receive a final answer or further calls [S14]. The first model trained to choose which API to call, when, and with what arguments was described in 2023 [S15]. Two vendors and one research paper describe the same tool calling mechanism that C5 describes. C4 is right: a bare model cannot book a table; it emits text and the harness does the booking.

For an operations team: every capability of an agent is a capability of the code that executes its tool calls. Its permissions, network reach and blast radius are those of the credentials its executor holds. Section 9 builds on this; the figure comparing the “script only” account with the documented one is in section 4.

2.3 No calculator, no database lookup, no weight updates

Three further statements are correct for a bare model:

  • No calculator inside. Arithmetic runs on learned circuits, not an arithmetic unit; section 3 shows those circuits and why they differ from a calculator [S2].
  • No database lookup at run time. Facts live in the weights, compressed and approximate, so a wrong fact comes out as fluently as a right one (Article 29).
  • Nothing learned during the conversation. A correction in turn five is available in turn six only because the text of turn five is re-sent.

A component that can be fluent and wrong, cannot look anything up without an executor, and cannot update itself needs checks outside the component. That is the design rule at the end of section 3.

Operator takeaway

Read an agent’s tool list like a contractor’s access request. The model proposes; the tools act. If a tool can write to the BMS, so can the agent, whatever the system prompt says. Put permissions in the executor, where code enforces them, not in the prompt.

2.4 Grades for this section

C1 (next-token prediction): supported [S13] [S14]. C4 (a bare model cannot act on the internet): supported [S13] [S14]. C5, as a generic claim that a model emits a call and ordinary code runs it: supported; the demo usually used to illustrate it is not what it is said to be (section 4). C2 and C3 add “no reasoning” and “no maths”, which go beyond the evidence; section 3 tests them.

Can a language model reason or do arithmetic?

C2 and C3 say a language model has no logic, no reasoning and no understanding of numbers. Researchers have traced what happens inside models, so this is testable. Result: the absolute version is contradicted by direct evidence of multi-step computation. A weaker version is well supported: a model cannot be trusted to reason reliably, to report what it did, or to generalise like a person. The weaker version gives the design rule at the end of this section.

3.1 How a model adds 36 + 59

Anthropic’s interpretability group published an attribution-graph study of Claude 3.5 Haiku in March 2025, using circuit tracing to follow which internal features feed which [S1] [S2]. For 36 + 59 = there are two parallel pathways. One carries a rough magnitude: “low-precision features for ‘add something near 57’” feed a “the sum is near 92” feature. The other carries the exact last digit through modular features. “These combine to give the correct sum of 95” [S2]. Some components are lookup-table features, for example “ends in 6” plus “ends in 9” giving “ends in 5” [S2].

There is no calculator in the network, as C3 says. But it is not a guess either: it is a learned, approximate-plus-exact adder that the researchers could intervene on and change the output in the predicted way.

The same study supports the caution. Asked how it got 95, the model “describes the standard algorithm involving carrying the 1”, which is not what the trace shows [S1]. Anthropic’s reading: the model “learns to explain math by simulating explanations written by people, but… has to learn to do math ‘in its head’” [S1]. On a hard cosine, the model sometimes produced an answer “without caring whether it is true or false”, with “no evidence at all of that calculation having occurred”; given a hint, it worked backwards to the hinted answer [S1]. This is chain-of-thought faithfulness: a model’s account of its reasoning is not evidence of what it did.

3.2 Multi-step recall and planning ahead

Asked for the capital of the state containing Dallas, the model activates a “Dallas” to “Texas” feature, then “Texas” plus “capital” to “Austin”. Swapping the Texas features for California features changes the answer to Sacramento [S1] [S2]. A direct Dallas-to-Austin shortcut also exists, so composition and memorisation both appear [S2]. In a rhyming couplet ending “grab it”, features for “rabbit” and “habit” are active on the newline before the second line is written; suppressing “rabbit” yields another planned rhyme, and injecting “green” makes the model re-plan the line [S1] [S2]. A one-token-at-a-time predictor can hold a plan several tokens ahead in its internal state.

Limits, as the authors state them: the method traces a simpler “replacement model” and “simplifies the true mechanisms considerably” [S2]. These are case studies on short prompts, from the lab that built the model. They show “no reasoning whatsoever” is false for these tasks. They do not show reliable reasoning in general.

3.3 Reasoning models

A reasoning model is further trained with reinforcement learning on tasks whose answers a program can check, called RLVR (reinforcement learning with verifiable rewards). It learns to write long chains of intermediate text and spends more computation at answer time (test-time compute). Article 29 covers the method. DeepSeek-R1 reports “the emergent development of advanced reasoning patterns, such as self-reflection, verification, and dynamic strategy adaptation” from pure RL without human-labelled reasoning traces [S6]. R1 scores 79.8% on AIME 2024 pass@1 (the paper’s summary figure, re-read 2026-10-25); the rise from 15.6% to 71.0% for R1-Zero during RL is reported and was not found in the extracted text [S6]. pass@1 is the fraction of problems solved on the first sample.

3.4 Evidence against model reasoning

Studies and statements that argue against model reasoning. Sources as listed; “not re-read” marks wording taken from a citation and not from the source page.
SourceFindingCaveat
Stochastic parrots, Bender, Gebru, McMillan-Major and Shmitchell (2021) [S7]A language model is “haphazardly stitching together sequences of linguistic forms it has observed in its vast training data… without any reference to meaning”. C1 to C3 restate this position.Quoted from the widely cited abstract; the ACM page was not readable, so the wording is not re-read.
GSM-Symbolic, Apple, ICLR 2025 [S5]Changing only numbers and names in grade-school problems made scores fall and spread. “Adding a single clause that seems relevant to the question causes significant performance drops (up to 65%) across all state-of-the-art models.”The authors “hypothesize… current LLMs cannot perform genuine logical reasoning; they replicate reasoning steps from their training data”: a hypothesis, not a proof.
The Illusion of Thinking, Apple, June 2025 [S3]Reasoning models “face a complete accuracy collapse beyond certain complexities”; effort “increases with problem complexity up to a point, then declines despite having remaining token budget”. Standard models win at low complexity, reasoning models at medium, both collapse at high.Disputed by Lawsen (next row).
Rebuttal, Lawsen [S4]Some Tower-of-Hanoi failures hit output-token limits (“models explicitly acknowledging these constraints”); River Crossing with N above 5 is “mathematically impossible… due to insufficient boat capacity”; asking for a generating function gave “high accuracy on Tower of Hanoi instances previously reported as complete failures”.Preliminary. Net: the collapse is real for exhaustive move lists, partly a test artefact, and unsettled.
ARC, Chollet [S8]; ARC-AGI-2 [S9]; 2025 ARC Prize [S10]Intelligence is “skill-acquisition efficiency”; data and priors can “buy” skill. Every ARC-AGI-2 task was solved by at least two humans in two attempts or fewer. 2025 results: best verified commercial model (Claude Opus 4.5, thinking, 64k) 37.6% at $2.20 per task; Poetiq on Gemini 3 Pro 54% at $30 per task; Kaggle private-set winner 24% at $0.20 per task. Organisers: “So, do we have AGI? Not yet”.Higher 2026 figures (a Kaggle 2026 public board near 88%, aggregator claims of 92–95%) were seen only in search snippets: reported, unverified, not used [S11].
Ilya Sutskever, November 2025 [S52]“These models somehow just generalize dramatically worse than people. It’s a very fundamental thing”.A pioneer of the scaling approach; an opinion, not a measurement.

3.5 Definition used, and grade for C2 and C3

Definition used here, because it can be measured: reasoning is producing correct answers to problems that require composing several steps that are not memorised as a whole, measured on held-out or perturbed problems. The record under it: circuit studies show composition in short cases [S1] [S2]; verifiable-reward training raises scores on checkable tasks [S6]; perturbation tests expose brittleness [S5]; the hardest generalisation benchmark still shows a large human–machine gap at the cost point measured [S10].

C2 and C3: partly supported. Computation happens, so “no logic” fails. Reliability, self-knowledge and generalisation are limited, so “you cannot trust it blindly” holds. A model can be right for reasons it cannot describe, and wrong with a confident explanation.

What an agent is: model, harness, tools

An agent is a loop. A program shows a language model the goal and the history, the model proposes the next action, ordinary code checks and executes it, the result is added to the history, and the cycle repeats until a stop condition. The model does the one thing a conventional program cannot do cheaply: turn untidy input (free text, logs, a screenshot, an error message) into a plausible next step without a rule written for that case. Everything else is conventional software.

4.1 Who does what in one step

One agent step, by actor. Source: dossier synthesis of [S12] [S13] [S14]; the split is an engineering description, not a vendor specification.
StepWhoDeterministic?
Parse unstructured intent (“table for two near the office, not too loud, after 7”) into a goalLLMNo
Choose a tool among N and fill typed argumentsLLMNo, but schema-validated
Validate arguments against a JSON schema or policyHarness codeYes
Execute: HTTP call, SQL, shell, git, browser clickOrdinary codeYes (the world may not be)
Observe the result, compare with the goal, decide the next action or stopLLMNo
Enforce budgets, permissions, approvals, loggingHarness codeYes

Anthropic’s definition: agents “are typically just LLMs using tools based on environmental feedback in a loop” [S12]. The mechanism is not in dispute; the question is whether the three non-deterministic rows are worth anything. Plant-room analogy: in a PLC panel the I/O cards do all the switching, yet the control logic did not “do nothing”; it decides which output to drive and when. In an agent the model fills that role for inputs nobody wrote rules for. How reliably it does so is section 5.

4.2 The restaurant-booking example

The example most often used for “the model did nothing” is OpenAI’s restaurant-booking demo, read as a Python program calling a booking API (C5). The demo came from Operator, a research preview announced on 2025-01-23, “powered by a Computer-Using Agent model, or CUA”, trained “to interact with the front-end of websites, meaning it doesn’t need to use developer-facing APIs”. The model “can use buttons, navigate menus, and fill out forms on a web page much like a human would”, and was “trained to ask for user confirmation before finalizing tasks with external side effects” [S56]. So the booking was not an API script: a vision model read screenshots of a web page and chose clicks (a computer-using agent). OpenTable as a named launch partner could not be confirmed; launch coverage lists DoorDash, eBay, Instacart, Priceline, StubHub and Uber [S56].

The example chosen to show the model contributes nothing is one where the model did the part a script cannot do: read an arbitrary page and decide what to do on it. The generic mechanism in C5 (section 2) is correct; this example does not illustrate it.

One tool call, two descriptionsTop: the script-only account. Bottom: the same call with the decisions the model makes marked.SCRIPT-ONLY ACCOUNT (C5)AS DOCUMENTED [S13][S14][S56]User“book me a table”LLMguesses a commandpython opentable.py→ OpenTable APILLM“I booked you a table!”PLAN [S13]LLMpick tool, fill argsHarnessschema · permissionsConfirm gatebefore side effectsExecutorAPI call or browserObservationresult or errorNEXT STEP OR STOPLEGENDProbabilistic: the model decidesDeterministic: code executesHuman gateDecided by the modelExecuted by code One tool call, two descriptionsTop: the script-only account. Bottom: the same call with the decisions the model makes marked.SCRIPT ONLY (C5)DOCUMENTED [S13][S14]User“book me a table”LLMguesses a commandpython opentable.py→ OpenTable APILLM“I booked you a table!”PLAN [S13]LLMpick tool, fill argsHarnessschema · permissionsConfirm gatebefore side effectsExecutorAPI call or browserObservationresult or errorNEXT STEP OR STOPLEGENDProbabilistic: the model decidesDeterministic: code executesHuman gateDecided by the modelExecuted by code
One tool call, two descriptions. Operator drove a browser from screenshots, not an API script [S56]. The script-only account is right about the mechanism; “the LLM did nothing” is not: the model plans, the harness checks, and code executes and reports back [S13][S14].

4.3 What is old and what is new

The parts of an agent and when each appeared. Sources as listed.
PartOriginOld or new
“Agent” as a conceptRussell and Norvig: “anything that can be viewed as perceiving its environment through sensors and acting upon that environment through actuators” (quoted from the textbook, not re-read here) [S19]. A thermostat qualifies; the word never claimed intelligence.Old
The loopReAct (2022) interleaves reasoning, an action and an observation; it is the template for most agent loops today [S16] (ReAct, agent loop). Closed-loop control is far older.Old pattern; new controller that accepts natural-language state
Tool useToolformer (2023): a model can learn when to call an API [S15]. The Model Context Protocol standardises how tools are described and called over JSON-RPC 2.0; its specification notes that tools “represent arbitrary code execution” [S17] (MCP).New
ExecutorsScheduled scripts, workflow engines, expert systems of hand-written rules, and RPA, which replays recorded user-interface actions.Decades old
Planner for untidy inputA general component that maps free text, screenshots, logs and errors to a plausible next action without a rule for that case. RPA breaks when a button moves; a CUA-style agent may survive the move, and may also click the wrong thing.New since roughly 2023; trades reliability for flexibility

C7, “decades-old automation”: partly supported; the executor half is old, the planning half is new. C6, “the LLM did nothing”: unsupported; table 4.1 lists what the model does, and the harness choice changes results (Terminal-Bench, section 5).

4.4 Workflow or agent: six levels of autonomy

Anthropic: “Workflows are systems where LLMs and tools are orchestrated through predefined code paths. Agents… are systems where LLMs dynamically direct their own processes and tool usage” [S12]. In a workflow the model fills in steps inside a fixed skeleton. LangChain (July 2026) describes six levels: hand-written logic, a single LLM call, a chain, a router, a state machine, an autonomous agent, graded by three questions: who decides the output of each step, who decides which step comes next, and who decides what steps are available [S18].

Who decides the next step?Six levels, from hand-written logic to an autonomous agent.WORKFLOW: PREDEFINED CODE PATHS [S12]AGENTALL: CODECoderules decideOUTPUT: LLMOne callsingle promptOUTPUT: LLMChainfixed sequenceBRANCH: LLMRouterLLM picks branchMOVE: LLMState machineLLM picks moveSTEPS: LLMAgentLLM picks stepsLEGENDLLM decides this partMore control moves to the model Who decides the next step?Six levels, from hand-written logic to an autonomous agent.WORKFLOW: PREDEFINED CODE PATHS [S12]AGENTALL: CODECoderules decideOUTPUT: LLMOne callsingle promptOUTPUT: LLMChainfixed sequenceBRANCH: LLMRouterLLM picks branchMOVE: LLMState machineLLM picks moveSTEPS: LLMAgentLLM picks stepsLEGENDLLM decides this partMore control moves to the model
Who decides the next step? Six levels from hand-written logic to an autonomous agent [S12][S18]. Only the last level lets the model choose steps and tools; everything left of it is a workflow with predefined code paths, and the first three are decades old (cron, RPA, expert systems).

Anthropic’s advice to builders agrees with the critic: look for “the simplest solution possible… This might mean not building agentic systems at all”, because agents bring “higher costs, and the potential for compounding errors”; it recommends extensive testing “in sandboxed environments, along with the appropriate guardrails” [S12]. An orchestrator that calls other models is another point on the same scale.

For the BMS team

Ask which of the three decisions the model makes: the output, the next step, the set of available steps. If only the output, it is a drafting tool inside a workflow, easier to test and bound. Each further decision given to the model needs its own deterministic check.

Two of the author’s counter-claims (A1–A6, graded in section 11) are tested here. A2, that the model acts as a semantic router or dynamic planner over unstructured intent: supported [S12] [S18] [S56]. A3, that observe, act and reflect (run tests, read the error, fix) is a genuine pattern: supported as a pattern, only partly as a new one, since ReAct dates from 2022 [S16] and closed-loop control is far older.

Measured reliability of agents

Agents are scored on pass/fail tasks, mostly in software. Scores are high and rising. The same data show success falling sharply as the required reliability rises, and several well-known benchmarks losing credibility through tuning and contamination. Capability has grown fast; reliability more slowly, and reliability is what limits operational use.

5.1 Coding benchmarks: SWE-bench and Terminal-Bench

SWE-bench Verified asks an agent to resolve real GitHub issues in open-source projects, judged by the project’s tests. The official leaderboard data, read on 2026-10-16, put the top entry at 79.2% (two systems, each using Claude 4.5 Opus), followed by 78.8% and 77.4%; the Verified board has no entries after December 2025 [S20]. In February 2026 OpenAI announced that it no longer evaluates on Verified, citing flawed tests and contamination, and recommended SWE-bench Pro [S21]. OpenAI audited a 27.6% subset of the dataset that models often failed and found that “59.4% of the 138 problems contained material issues in test design and/or problem description”, and that the open repositories make contamination hard to avoid: “We first encountered signs of contamination in our own models” [S21] (page re-read 2026-10-25). The fall from about 70% on Verified to about 23% on Pro is not on OpenAI’s page; it comes from a news report and is reported, unverified [S22].

A score near 80% on a retired benchmark does not mean “agents fix 80% of real issues”. It means agents with good harnesses pass most of a test set that is partly flawed and may have leaked into training data.

Terminal-Bench 2.0 uses 89 tasks in containers, each with a human-written oracle solution. Top entries on the mirrored leaderboard are 84.7% (±2.1), 84.5% (±2.6), 83.1% and 82.2% [S23]. The same model scores differently under different harnesses: the “plumbing” the critique dismisses changes outcomes [S23].

5.2 METR time horizons at 50% and 80% success

METR measures how long a task, in human working time, an AI system can complete at a given success rate. The time horizon at 50% is the task length the system completes half the time; at 80% it is the length completed four times in five. The table gives the latest points on METR’s page, last updated 2026-09-08 [S25].

METR time horizons, 50% and 80% success. Source: [S25]. The ratio column is derived: 50% horizon divided by 80% horizon.
Model (release)50% horizon95% CI80% horizonRatio
GPT-5 (2025-08)203 min113–40638 min5.3×
Claude Opus 4.5 (2025-11)293 min162–62449 min6.0×
GPT-5.2 (2025-12)352 min198–81566 min5.3×
Claude Opus 4.6 (2026-02)719 min (12.0 h)317–3,63470 min10.3×
Claude Mythos Preview, early (2026-04)1,045 min (17.4 h)509–3,304186 min (3.1 h)5.6×

Derived ratios: 203/38 = 5.3; 293/49 = 6.0; 352/66 = 5.3; 719/70 = 10.3; 1,045/186 = 5.6. METR’s fitted doubling time since 2023 is about 131 days in its blog post and 128.7 days in its data file [S24] [S25]. From the data-file value the growth is 2^(365/128.7) = 7.1 times per year (derived). METR also warns that “Measurements above 16 hrs are unreliable with our current task suite”, and stresses that the tasks are low-context, like work given to a new hire, and mostly software, machine learning and cyber-security [S25].

The gap between each model’s two bars is the reliability problem: a system that completes a 17-hour task half the time completes a 3-hour task four times in five. Plan on the 80% figure.

5.3 Developer productivity trials (METR, 2025 and 2026)

METR’s randomised trial from early 2025: experienced open-source developers took 19% longer with AI tools (confidence interval +2% to +39%) while believing they were faster [S26] [S27]. A follow-up published 2026-02-24 estimates the change in time at −18% for returning developers (CI −38% to +9%) and −4% for new ones (CI −15% to +9%). METR calls the data “an unreliable signal” because developers declined to work without AI, pay fell from $150 to $50 per hour, and time tracking was unreliable. It now believes late-2025 tools “likely” sped developers up, but the size is unknown [S27]. Neither result is statistically established, so neither “slows developers by 19%” nor its opposite is a current fact.

C11 (cannot be used for serious coding; will not replace coders), evidence: a 2025 slowdown [S26], weak evidence of speedup in 2026 [S27], and high scores on agent coding benchmarks with the contamination caveats above [S20] [S21] [S23]. “Cannot be used” is too strong for the record. “Will not replace” is a prediction, graded as such: partly supported.

5.4 Error compounding over many steps

A multi-step task succeeds only if every step does. If each step succeeds with probability p and the steps are independent, a run of n steps succeeds with p^n:

P(run) = pn
0.9520 = 0.358        (20 steps at 95% each)
0.99100 = 0.366       (100 steps at 99% each)

Anthropic names compounding errors as a cost of agents [S12]. A deterministic verifier changes the arithmetic. Suppose a check catches a bad step with probability d and the step is retried up to k times. With p = 0.95, d = 0.9 and k = 2, the chance of an undetected-bad step falls and a step succeeds with probability 0.95 × 1.04706 = 0.9947, so a 20-step run succeeds with 0.9947^20 = 0.899 (derived; the full model is in the calculator below). The extra attempts raise the cost per run from $1.76 to $1.84, about 5% (1.843/1.760 = 1.047), under the calculator’s default prices and token counts.

0.95 twenty timesPer-step success multiplies; a verifier with retries breaks the chain.WITHOUT A VERIFIERWITH A VERIFIER× 20 STEPSStepp = 0.9595 % PER STEPRun succeeds0.358 over 20 steps× 20 STEPSStepp = 0.95Verifierd = 0.9 · k = 299.47 % PER STEPRun succeeds0.899 over 20 stepsMULTIPLY 20 TIMESATTEMPTDETECTED: RETRYPASSESLEGENDProbabilistic stepDeterministic checkDetected failure retries 0.95 twenty timesPer-step success multiplies; a verifier with retries breaks the chain.WITHOUT A VERIFIERWITH A VERIFIER× 20 STEPSStepp = 0.9595 % PER STEPRun succeeds0.358 over 20 steps× 20 STEPSStepp = 0.95Verifierd = 0.9 · k = 299.47 % PER STEPRun succeeds0.899 over 20 stepsMULTIPLY 20 TIMESATTEMPTDETECTED: RETRYPASSESLEGENDProbabilistic stepDeterministic checkDetected failure retries
0.95 twenty times. At 95 % per step a 20-step run succeeds 35.8 % of the time (0.95^20, derived). With a verifier that detects 90 % of bad steps and two retries, a step succeeds 99.47 % of the time and the run 89.9 % (derived, CALCULATORS C-ii). METR’s 50 % versus 80 % horizon gap is the field version [S25].

Run cost and reliability with compounding error

This estimator shows why a 95%-per-step agent fails most 20-step runs and what a verifier with retries changes. Each attempt is good with probability p; a bad attempt is caught with probability d and retried up to k times. It computes q = (1 − p) · d, E = (1 − q^(k+1)) / (1 − q), Ps = p · E and P_run = Ps^n, then cost_run = n · E · cost_att and cost_per_success = cost_run / P_run. Steps are assumed independent, which is optimistic.

Basis: model — illustrative. Prices are list price on 2026-10-16 (Sonnet-class, A29 [S27] via [S57]); per-step success and detection rate are your assumptions. METR horizon gap [S25].

Caveats (the calculator prints them): independence is optimistic because real errors correlate, and a model-based verifier may share the generator’s blind spots. The METR 50-versus-80 gap is the measured version of this curve [S25].

Operator takeaway

20 steps at 95% per step is a one-in-three system. The cheapest improvement is a deterministic check at each step; a bigger model is the expensive one. Ask any vendor for the success rate at your required run length, not for a benchmark peak.

Agent failure modes and mitigations

A script fails the same way each time and reports where. An agent can fail differently on each run, be steered by text arriving through a tool, report a step it did not take, and spend a large budget unnoticed. Each failure mode below is documented and has a standard mitigation; in each, the check does not depend on the model agreeing that a failure occurred.

6.1 Prompt injection through data

A language model has no reliable way to distinguish the instructions it was given from instructions written inside the content it reads. OWASP’s entry LLM01:2025 describes prompt injection in its indirect form: “Indirect prompt injections occur when an LLM accepts input from external sources, such as websites or files.” Listed impacts include “Executing arbitrary commands in connected systems” and “Manipulating critical decision-making processes” [S29]. Relevant inputs in operations: alarm text, ticket bodies, vendor PDFs, e-mail, CMMS free-text fields. An agent that reads a ticket and has a tool that acts on it gives whoever can write a ticket a path to whatever the tool can do.

6.2 OWASP Top 10 for agentic applications

OWASP published a Top 10 for agentic applications on 2025-12-09, with more than 100 contributors. It names ten risks [S30].

OWASP Top 10 for Agentic Applications 2026. Source: [S30]. The right-hand column is this article’s reading of the category, not OWASP’s wording.
IDRiskPlant-room reading
ASI01Agent Goal HijackA ticket or alarm text redirects the task
ASI02Tool Misuse and ExploitationA valid tool called with harmful arguments
ASI03Identity and Privilege AbuseThe agent holds credentials broader than the job
ASI04Agentic Supply Chain VulnerabilitiesA tool server or plug-in is compromised
ASI05Unexpected Code Execution (RCE)Generated code runs outside a sandbox
ASI06Memory and Context PoisoningA bad note persists and shapes later runs
ASI07Insecure Inter-Agent CommunicationOne agent’s output is trusted by another
ASI08Cascading FailuresAn error propagates through chained agents
ASI09Human-Agent Trust ExploitationOperators approve what looks authoritative
ASI10Rogue AgentsAn agent acts outside its intended scope

Most of these map onto controls that data-center engineers already use for people and contractors: least privilege, separate accounts, change control, and isolation of untrusted code in a sandbox.

6.3 Misalignment in simulated scenarios

In June 2025 Anthropic published agentic misalignment experiments in simulated scenarios. When facing replacement or a goal conflict, “models from all developers resorted to malicious insider behaviors when that was the only way… including blackmailing officials and leaking sensitive information”. In one text scenario Claude Opus 4 and Gemini 2.5 Flash blackmailed in 96% of runs, GPT-4.1 and Grok 3 Beta in 80%, and DeepSeek-R1 in 79%. The report states: “All the behaviors… occurred in controlled simulations” [S28]. It is an Anthropic study of its own and competing models (see the disclosure in section 1). Use: a reason for minimum privileges and approval before irreversible actions. It is not a forecast of field behaviour and describes no real deployment.

6.4 Status reports that do not match actions

Section 3 described the carry-the-1 explanation that did not match the circuit [S1]. In agent work it appears as a status line: “tests pass”, “configuration applied”, “alarm cleared”. That line is a claim. The harness runs the test or reads the sensor; the model’s text is commentary.

6.5 Retry loops and quadratic token cost

An agent re-reads its history on every step, so input tokens grow with the square of the step count. With a 20,000-token starting context and 3,000 tokens added per step, step 30 has consumed 1,905,000 cumulative input tokens: 30 × 20,000 + 3,000 × 30 × 29 / 2 = 600,000 + 1,305,000 (derived). At the list prices used in this article’s calculators ($2 per million input tokens, $10 per million output, from Article 29) that is $3.81 of input plus $0.24 of output, or $4.05. A stuck retry loop reaches that cost with no one typing. The budget planner in section 9 sets limits before a run starts.

Common mitigation: checks outside the model

Mitigations: argument schemas and allow-lists (tool misuse), scoped credentials (privilege), a sandbox (code execution), treating all fetched text as untrusted data (injection), a harness-run verifier (false reports), step and cost limits (loops), and a human approval for anything irreversible. A hard gate is a check whose failure cannot be overridden by the agent. The more of these exist in code, the less the system depends on the model behaving.

Investment, revenue and the IPO claim

The economic version of the critique: AI companies have exhausted private money, need to list on public markets and need a story to sell, and the story is agents (C12); the researchers have left because language models are a dead end (C9); the field has spent “$3 trillion” (C8). Checked against filings, earnings releases and press reports: spending is very large and partly debt-funded; the IPO motive is real; “private money has run out” is contradicted by the largest private rounds on record; the researcher claim fails as stated.

7.1 Capital expenditure of the four largest spenders, 2026

The four largest spenders gave 2026 capital-expenditure (capex) guidance in their results for the first half of the year.

2026 capex guidance. Sources as listed. The basis differs (finance leases in or out), so the sum is approximate.
Company2026 guidanceNoteSource
Alphabet$195–205BRaised from $180–190B on the Q2 call, 2026-07-22[S40]
Amazonabout $200BHeld from February; H1 2026 purchases of property and equipment $98.4B[S38] [S42]
Meta$130–145BIncludes finance-lease principal; narrowed from $125–145B, 2026-07-29[S41] [S43]
Microsoft$190BCapex plus finance leases, held in July; reported as restated to $175B after an accounting change[S38] [S39]

Derived sum: $700B (low case) to $740B (high case); at midpoints 190 + 200 + 200 + 137.5 = $727.5B, about $0.7 trillion in 2026 from four companies. The Microsoft figure is as reported by Business Insider; the filing was not read, so its calendar-versus-fiscal basis is unverified [S39].

Signs of financing strain: Alphabet’s long-term debt rose 111% to $98B in the first half of 2026 and the company was cash-flow negative in the second quarter for the first time; Amazon’s long-term debt rose 81% to $119B in the first quarter [S38], and its trailing free cash flow was −$7.6B at the second quarter [S42]. C8: no source was found for “$3 trillion of compute to build it out to where it is today”. One year of the big four is about $0.73 trillion, so a multi-year, multi-company total could reach trillions; the figure as stated is unverified.

7.2 Lab revenue, funding rounds and IPO filings

Lab funding, revenue and listing events, 2026. Items marked reported rest on press accounts of non-public documents.
ItemFigureDateSource
OpenAI funding round$122B at $852B post-money2026-03-31[S49]
Anthropic Series H$65B at $965B post-money2026-05-28[S46]
Anthropic draft S-1confidentially submitted to the SEC2026-06-01[S47]
Anthropic run-rate revenue$65B at end of July, about 7× a year earlier2026-08-17[S44]
OpenAI run-rate revenueabout $50B at end of September; a widely reported $68B included partners’ gross revenue2026-10-08[S45]
Anthropic 2025 financials (leaked prospectus via Reuters)revenue $4.6B, net loss $42B (Reuters, via CNBC; prospectus not public)reported 2026-10-07[S48]
Bear valuation view$150B, against a reported $2T IPO target2026-10-07[S48]
OpenAI IPOnot in 20262026-09-11[S50]

The $65B figure is an annualised run-rate, a recent period scaled to a year, not recognised revenue. Dividing by the reported growth gives about 65 / 7 = $9.3B a year earlier (derived). The jump from $4.6B reported 2025 revenue to a $65B mid-2026 run-rate is extreme, and the 2025 figure comes from a leaked document; the comparison is shown as reported. The valuation critique comes from New Constructs, which values Anthropic at $150B and calls the IPO “an unprecedented test of investor gullibility” [S48]. Altman, on OpenAI: “given everything happening with safety, right now would be an ill-advised moment to go public” [S50].

C12: the IPO motive is real, since a draft S-1 exists and OpenAI prepared and then postponed [S47] [S50]. “Out of private money” is contradicted by the two largest private rounds on record in the same half-year [S46] [S49]. Large revenue growth cuts against “no value”, and large losses support “they need capital”. Grade: partly supported. One of those filers is the company whose model helped draft this article (section 1).

C13, “bordering on securities fraud”: a legal claim needs a legal record. A limited search found no regulator action or lawsuit alleging a securities-law violation over agentic-AI marketing (a negative result from a narrow search). Grade: unsupported.

7.3 Is scaling hitting a wall?

Sutskever said at NeurIPS 2024: “Pre-training as we know it will unquestionably end… We’ve achieved peak data and there’ll be no more… There’s only one internet.” He predicted the next models would “be agentic in a real ways” [S51]. In November 2025 he described the field as “moving from the age of scaling to the age of research” [S52]. Projections put exhaustion of the stock of public human text between 2026 and 2032, while training compute grows about 5× a year (Article 29, section 9) [S60].

Against a hard wall: METR horizons doubled roughly every four months [S24] [S25], and revenue run-rates grew several-fold in a year [S44]. Both hold: pre-training on human text is meeting limits, and gains moved to reinforcement learning, test-time compute and tool use. That is why the industry talks about agents: they are a new scaling axis, not only a narrative.

7.4 Researcher departures and their stated reasons

Departures cited for C9 (“the head researchers quit because LLMs are a dead end”), with the reason each gave. Sources as listed.
PersonMoveStated reasonFits C9?
Yann LeCunLeft Meta (reported November 2025) to found a world-model start-up“has previously called LLMs a ‘dead end’”; “We’re never going to get to human-level A.I. by just training on text” [S53]Yes, for Meta
Ilya SutskeverLeft OpenAI in 2024Generalisation, not tooling, is the open problem [S51] [S52]Partly; outside “the last year”
John JumperGoogle DeepMind to Anthropic (reported 2026-06-19); 2024 Nobel laureateA move between labs [S55]No
Jakub PachockiOpenAI chief scientist; co-authored a June 2026 OpenAI plan with Sam AltmanSeen only in a page listing, so his current title is reported, unverified; no evidence was found that he left [S61]No
Joe Benton (Anthropic safety lead), Josh Engels (Google), Jacob Coxon (Anthropic)Left, September 2026Fears that progress could become “uncontrollable”; “There are no adults in the room” [S54]No: the opposite reason, too much capability too fast
Money, models and narratives, 2024–2026Events on one time axis: capability, capital, critiques.CAPABILITYCAPITALCRITIQUEJUN–AUG 2025Gartner: >40% cancelledby 2027 [S37] · MIT “95%” [S35]DEC 2024–JUN 2025Limits foundpretraining ends [S51][S1][S3][S4]JAN–APR 2026METR: 50% horizon ≈17 h80% horizon ≈3 h [S25]FEB 2026OpenAI $122B at $852Braised from $110B [S49]NOV 2025–FEB 2026LeCun leaves Meta [S53]SWE-bench Verified retired [S21]MAY–JUN 2026Anthropic $65B at $965Bdraft S-1 [S46][S47]JUL–SEP 2026Big-four capex ≈$0.7Tno OpenAI IPO 2026 [S38][S50]SEP 2026Safety departurestwo researchers leave [S54]LEGENDCritiqueCapabilityCapital Money, models and narratives, 2024–2026Events on one time axis: capability, capital, critiques.JUN–AUG 2025Gartner: >40% cancelledby 2027 [S37] · MIT “95%” [S35]DEC 2024–JUN 2025Limits foundpretraining ends [S51][S1][S3][S4]JAN–APR 2026METR: 50% horizon ≈17 h80% horizon ≈3 h [S25]FEB 2026OpenAI $122B at $852Braised from $110B [S49]NOV 2025–FEB 2026LeCun leaves Meta [S53]SWE-bench Verified retired [S21]MAY–JUN 2026Anthropic $65B at $965Bdraft S-1 [S46][S47]JUL–SEP 2026Big-four capex ≈$0.7Tno OpenAI IPO 2026 [S38][S50]SEP 2026Safety departurestwo researchers leave [S54]LEGENDCritiqueCapabilityCapital
Money, models and narratives, 2024–2026. Time runs down; each lane is one kind of event. Capital moved first and fastest (OpenAI $122B at $852B [S49]; Anthropic $65B at $965B [S46]), measured capability moved on a ~131-day doubling [S24], and the critiques [S37][S35] arrived while both kept rising.

C9, “all of them quit because LLMs are a dead end”, is unsupported as stated. One prominent case fits, several do not.

7.5 Enterprise adoption: MIT NANDA and Gartner

MIT’s NANDA initiative reported that “despite $30–40 billion in enterprise investment into GenAI… 95% of organizations are getting zero return”. For task-specific tools, “sixty percent… evaluated… only 20 percent reached pilot stage and just 5 percent reached production”, with the root cause given as “the learning gap, tools that don’t learn, integrate poorly, or match workflows”. Method: 300+ public initiatives, 52 interviews, 153 survey responses (January–June 2025); success = “marked and sustained productivity and/or P&L impact” [S35]. Press turned it into “95% of pilots failing” [S36]. Limits: small conference samples, a strict P&L test, a 95% that covers integrated task-specific pilots only, and authors who promote an agentic architecture; it argues for agents that learn, not against agents.

Gartner, 2025-06-25: “over 40% of agentic AI projects will be canceled by end of 2027”. Headline confirmed only; the release page was not readable, so its reasons, its estimate of how many vendors are genuine, and its forecasts are unverified [S37]. Gartner also popularised the term agent washing for relabelling assistants, RPA and chatbots as agents [S37].

Economics: evidence on both sides

Bull evidence: revenue growth [S44] [S45], the capability trend [S24] [S25], harness-driven gains [S23]. Bear evidence: pilot failure rates [S35], cancellation forecasts [S37], debt-funded capex [S38] [S42], benchmark contamination [S21], unstable productivity evidence [S26] [S27], valuation critiques [S48]. For an operations buyer: marketing inflation is real, so size every deployment on your own measured success rate, and keep the exit cost low.

Are “AI” and “agent” accurate names?

Whether “agentic AI” is an accurate name depends on the definition used, and published definitions draw the line in different places. No measurement settles a vocabulary question. Below: the definition each source uses, and how regulators treat it (they regulate the system and its risks, not the label).

8.1 Published definitions compared

How different sources define the terms, and what follows. Sources as listed; the Gartner wording is unverified beyond its headline.
SourceDefinitionImplication
Russell and Norvig (AIMA) [S19]An agent perceives through sensors and acts through actuators“Agent” does not mean intelligent; a script with sensors qualifies
Anthropic [S12]Workflow: predefined code paths. Agent: the LLM directs its own process and toolsThe line is who chooses the next step
LangChain, 2026 [S18]Six levels of autonomy, graded by who decides the output, the next step and the available stepsReplaces a yes/no label with a scale
OpenAI tool calling [S14]A five-step loop in which the application executes the callDescribes the mechanism, not a claim
Gartner [S37]“Agent washing”: relabelling assistants, RPA and chatbots as agents (wording unverified)The marketing critique has an analyst-industry name
CISA and partner agencies [S31]Treats LLM-based AI and AI agents alongside traditional statistical modelling and logic-based automation in OTGuidance applies to the system whatever it is called

8.2 The proposed rename

C14 proposes “generative computing” or “automated computing” and dropping “AI” from the name.

  • Even the critique’s written forms usually concede that the language model itself is AI. The disagreement is about the word for the whole system, not the model.
  • By the textbook definition the whole system is an agent [S19], and by Anthropic’s definition it is a workflow or an agent depending on who picks the next step [S12]. “No AI in agentic AI” is a definitional claim, not a factual one.
  • “Generative computing” names the drafter, not the loop. A more exact engineering label for the architecture C5 describes is LLM-orchestrated automation: the model is the planner or router, and code is the executor. (This article’s suggestion, not an industry term.)

The marketing critique has substance. Gartner’s “agent washing” [S37] and the high pilot failure rates [S35] show that the label is applied loosely. Ask any vendor which of the six levels in section 4 the product is, and which decisions the model makes. The author’s counter-claim A6, that the “fraud” verdict reduces a system to its mechanism, is supported with a caveat: describing a mechanism is not the same as deceiving anyone, though the label inflation is documented.

8.3 Title discrepancy on the CISA page

On 2026-10-16 the CISA page for the OT guidance displayed the title as “Super Intelligence in Operational Technology” with “SI” throughout, while the URL slug and the PDF say “Artificial Intelligence” [S31]. This article cites the PDF title: Principles for the Secure Integration of Artificial Intelligence in Operational Technology. The discrepancy is reported without conclusion.

Procurement question

Ask four questions: what can the system read, what can it write, who approves a write, what happens when the model is wrong. The answers describe the risk under any name.

When to use an agent, and how to build one

The engineering question is where a probabilistic component belongs in an otherwise deterministic system. The evidence gives one answer: let the model do what only a model can do (read untidy input, choose among options, draft) and put every consequence behind a check that does not rely on the model. Below: a decision table, a reference architecture, a worked example, and run budgets.

9.1 Agent, hybrid or script: decision table and scorer

Decision table. Source: dossier synthesis of [S12] [S31]; an engineering judgement and not a standard.
ConditionPrefer
Input is structured, the rule fits on a page, it runs oftenScript or workflow engine
Input is free text, logs, screenshots, varied documentsAn LLM step (classify, extract, draft)
Output can be checked mechanically (tests, schema, simulation, diff)Agent loop with that check as the oracle
Error is costly and irreversible, the check is weakLLM proposes only; a human approves; a deterministic executor acts
Hard real-time or safety functionNever the LLM; PLC, SIS or BMS logic
The task repeats identically after the agent has solved itPromote the solution to a script

The scorer below puts the table into numbers. Five inputs from 1 to 5: variability of input (V), cost of an error (E), verifiability (Vf), frequency (F) and latency budget (L). Weights are the author’s design choices: a judgement aid, not a measurement.

N     = (V − 1) / 4
Risk  = ((E − 1) / 4) × (1 − (Vf − 1) / 4)
Lp    = (5 − L) / 4
Score = 100 × N × (1 − Risk) × (1 − 0.5 × Lp)

A score below 35 means script or workflow; 35 to 65 means hybrid (the model classifies, extracts or drafts, code validates and executes, a person approves side effects); 65 or above means an agent loop with verifiers. Hard overrides apply afterwards: with E = 5 and Vf ≤ 2 no autonomous action is allowed, in line with the CISA principle on human oversight [S31]; with L = 1 the path is real-time and not an LLM; with V ≤ 2 the answer is a script. Worked check for a BMS alarm-triage summary (4, 4, 3, 5, 3): N = 0.75, Risk = 0.75 × 0.5 = 0.375, Lp = 0.5, so Score = 100 × 0.75 × 0.625 × 0.75 = 35.2, a hybrid, just. A chiller setpoint write (3, 5, 2, 4, 2) scores 7.8 and trips the first override.

Agent or script? A decision scorer

This scorer turns the decision table into a number so you can see why a task lands on script, hybrid or agent. It rates variability of input (V), cost of an error (E), verifiability (Vf), frequency (F) and latency budget (L) from 1 to 5, then computes N = (V − 1) / 4, Risk = ((E − 1) / 4) · (1 − (Vf − 1) / 4), Lp = (5 − L) / 4 and Score = 100 · N · (1 − Risk) · (1 − 0.5·Lp). Below 35 is script, 35 to 65 is hybrid, 65 and above is an agent loop with verifiers; four hard overrides apply afterwards. It is a judgement aid, not a measurement: the weights are design choices.

Basis: model — illustrative. The weights and bands are the dossier's design choices; the first override cites CISA AI-in-OT guidance [S31]. Constants as of 2026-10-16.

9.2 Reference architecture: probabilistic planner, deterministic executor

The planner proposes; a typed interface validates against a schema and an allow-list; deterministic executors act; verifiers judge; a human gate stands in front of irreversible actions; an audit log records everything; budgets sit outside the model. The model never holds credentials and never writes to safety-rated systems [S12] [S29] [S30] [S31].

Observe, act, verifyThe model proposes; deterministic checks decide whether the step counts.Budget guardsteps · tokens · time · $Human gateirreversible actionsContextgoal · history · resultsLLMpropose next actionSchema / policy checkExecute toolVerifiertests · lint · types · rulesStopsuccess or escalateREJECT: REASONVALIDPASS/FAIL + LOGHALTSIDE EFFECTAPPROVEDGOAL METLEGENDHuman gateProbabilistic: the model proposesDeterministic checkRejection / halt Observe, act, verifyThe model proposes; deterministic checks decide whether the step counts.Budget guardsteps · tokens · time · $Human gateirreversible actionsContextgoal · history · resultsLLMpropose next actionSchema / policy checkExecute toolVerifiertests · lint · types · rulesStopsuccess or escalateREJECT: REASONVALIDPASS/FAIL + LOGHALTSIDE EFFECTAPPROVEDGOAL METLEGENDHuman gateProbabilistic: the model proposesDeterministic checkRejection / halt
Observe, act, verify. The model proposes; deterministic checks decide whether the step counts. Anthropic: the agent gets ground truth from the environment at each step [S12].
Drafter and checkerWhat each half is good at, and the interface between them.PROBABILISTIC (LLM)DETERMINISTIC (CODE)Draft code, MOP, ticketRead text, logs, screensand choose among optionsMAY BE UNFAITHFUL [S1]ExplainTyped tool interfaceschema · allow-list · rangesTest, lint, type-checkValidate + enforceschema · limits · permissionsExecute and measureLog and replayERROR TEXT BACKLEGENDProbabilistic (LLM)Deterministic (code)Feedback to the drafter Drafter and checkerWhat each half is good at, and the interface between them.LLMCODEDraft code, MOP, ticketRead text, logs, screensand choose among optionsMAY BE UNFAITHFUL [S1]ExplainTyped tool interfaceschema · allow-list · rangesTest, lint, type-checkValidate + enforceschema · limits · permissionsExecute and measureLog and replayLEGENDProbabilistic (LLM)Deterministic (code)Error text back to the drafter
Drafter and checker. The probabilistic half reads and drafts; the deterministic half validates, executes and tests. Self-explanations from the model can be unfaithful [S1], so nothing downstream trusts them. The seam is where the engineering lives.

9.3 Worked example: a software factory pipeline

The author runs a local (unpublished) pipeline for software changes that applies these rules; facts below were read from its skill file and command-line source on 2026-10-16 [S58]. The roles are an orchestrator on a frontier model; a spec-writer; a builder; four reviewers working in parallel (security, code, UX, UI), where the UX and UI reviewers may answer SKIP only if no user-interface file changed; and an approver. The sub-agents run on a mid-tier model and the approver on a small one [S58].

Every transition is written by a command-line tool into a state file, factory/board.json. The orchestrator is told never to move a job forward on its own reading of a result, but to run the tool and act on its status line. Language models write and judge; exit codes decide [S58].

Deterministic gates in the factory. Source: [S58]. The last column is what each gate catches by construction.
GateMechanismCatchesHard?
lint, test, buildShell exit codes, 900 s timeoutStyle, type, build errors and regressions covered by testsYes
secretsRegex over added lines for key formats and private keysCredential leaksYes
nonemptyFails when the diff is empty“Done” claims with no codeYes
protectedFlags .env, *.pem, *.key, firebase.json, .github/workflows/*Edits to deployment, CI and secrets filesNo
tests_addedFails when source changed but no test file didUntested codeNo

Review verdicts are parsed by the pattern VERDICT: PASS|FAIL|SKIP; a missing or unparseable verdict is a problem, an invalid SKIP is rejected, and if the code changed after gating the verdicts are stale. The fix loop is capped: max_fix_rounds is 3, at most two fix decisions are allowed per job, and overrides are refused while a hard gate fails. Delivery merges with --no-ff in the job’s worktree, re-runs lint, test and build on the merge result, and pushes fast-forward only, and only if the repository has opted in with "push": true. The human operator’s switches for delivery, push and human review are declared off-limits to the agent [S58].

Factory: LLMs write, exit codes decideSpec to merge with every transition recorded by the factory CLI in board.json.spec-writerrequest → spec.mdbuildercode + tests, commitNEVER OVERRIDABLEfactory gatelint · test · build4 reviewerssecurity · code · ux · uiDECIDEfix ≤2 · override · abandonfactory verdictVERDICT regex · HEAD sameboard.jsonevery transitionapproverfactory deliverMerge to mainre-gated · push opt-inNEEDS_FIX ≤3REVIEWROUNDS EXHAUSTEDFIXREADYLEGENDLLM roleCLI step (exit code)Human decisionBack to the builderWrites state Factory: LLMs write, exit codes decideSpec to merge with every transition recorded by the factory CLI in board.json.spec-writerrequest → spec.mdbuildercode + tests, commitNEVER OVERRIDABLEfactory gatelint · test · build4 reviewerssecurity · code · ux · uiDECIDEfix ≤2 · override · abandonfactory verdictVERDICT regex · HEAD sameboard.jsonevery transitionapproverfactory deliverMerge to mainre-gated · push opt-inNEEDS_FIX ≤3REVIEWROUNDS EXHAUSTEDFIXREADYLEGENDLLM roleCLI step (exit code)Human decisionBack to the builderWrites state
Factory: LLMs write, exit codes decide. Hard gates are lint, test, build, nonempty and secrets, and no job can override them [S58]. One demo job passed every gate: security and code PASS, UX and UI SKIP [S59].

Demonstrated so far: one job (2026-10-16, a readingTime helper) changed two files; lint and test passed, the build was skipped because none is configured, the other four gates passed, the security and code reviews passed, and the UX and UI reviews were skipped as designed [S59]. No multi-job statistics exist, so per-gate catch rates are unmeasured; the calculator takes them as inputs, and its presets are labelled assumptions.

Not caught by any gate: a wrong specification; tests that encode the same misunderstanding as the code; and blind spots shared by reviewer models from the same family as the generator [S58]. The ladder calculator makes the last point numerically. With five independent gates at 0.60, 0.10, 0.15, 0.50 and 0.50 catch rates, the chance a defect escapes is 0.4 × 0.9 × 0.85 × 0.5 × 0.5 = 0.0765, a coverage of 92.35%. If the LLM review (0.50) shares the generator’s family and its effective catch rate is halved to 0.25, the escape chance becomes 0.4 × 0.9 × 0.85 × 0.75 × 0.5 = 0.11475, a coverage of 88.5%. These values are what-ifs; the structure holds regardless: a defect must pass every rung, so add rungs that fail for different reasons.

Verification-ladder coverage

This score shows how much each gate in a pipeline contributes and why stacking independent gates beats one strong one. A gate that shares the generator's model family loses catch rate: d_eff,i = dᵢ · (1 − ρ). The chance a defect escapes every gate is P_escape = Π (1 − d_eff,i) and Coverage = 1 − P_escape. Each gate's marginal value is P_escape(without j) − P_escape(with j). The catch rates are your assumptions, not measurements.

Basis: assumption — user-set. No measured per-gate catch rates were found for LLM pipelines; the factory has run one demo job only [S59], and its gate order is mirrored in the preset [S58].

9.4 Run budgets: cost, wall clock, context window

Three limits bind an agent run: money, wall-clock time and the context window. Because history is re-read each step, cost grows with the square of the step count. With c0 the starting context, g the tokens added per step and S the number of steps:

input tokens to step S = S × c0 + g × S(S − 1) / 2
Cost(S) = price_in × [S × c0 + g × S(S − 1)/2] / 106 + price_out × S × o / 106
t_step  = TTFT + o × TPOT + t_tool
max_steps = min(S_cost, S_time, S_context)

With defaults of 20,000 starting tokens, 3,000 tokens added per step, 800 output tokens per step, a $5 cap, a 600 s wall clock and 5 s per tool call, at $2 and $10 per million tokens: Cost(10) = $0.75, Cost(20) = $2.10, Cost(30) = $4.05, Cost(40) = $6.60. The cost cap allows 34 steps. One step takes 0.5 + 800 × 0.02 + 5 = 21.5 s (the latency constants are assumptions from Article 29), so the wall clock allows floor(600 / 21.5) = 27 steps. The context limit, compaction at 80% of a 200,000-token window, allows floor((160,000 − 20,000) / 3,000) + 1 = 47. The binding limit is the wall clock, at 27 steps, and a per-step timeout near 65 s (three times the step time) is suggested. Caching changes the slope of the cost curve, not its shape.

Tool-loop budget planner

This planner sets max_steps, a per-step timeout and a cost cap before a run, from the three limits that bind: money, wall clock and context window. Every step re-sends the history, so Cost(S) = pin_eff·[S·c0 + g·S(S−1)/2]/1e6 + price.out·S·o/1e6 grows with the square of S. The step limit is max_steps = min(S_cost, S_time, S_ctx, S_policy) with t_step = ttft + o·tpot + tt and S_time = floor(Tw / t_step).

Basis: model — illustrative. Prices are list price on 2026-10-16 (A29 [S27] via [S57]); time to first token, time per output token and the 200,000-token window are assumptions (A29 sections 8.2 and 8.5).

Design rules

Use the simplest system that works. Put validation, execution, verification and limits in code. Give every irreversible action a human gate. Add verifiers that fail for different reasons. When an agent’s path for a class of task becomes stable, replace it with a script: a cheap, testable routine.

Checklist: connecting an agent to a BMS

When asked to connect an agent to the building management system, specify what the agent may read, what it may write, and what stands between its suggestion and the plant. Government guidance on AI in operational technology (OT) matches the architecture in section 9; the checklist below applies it. Rule: read freely, propose in writing, and let only the existing control system, with its interlocks and a person, act.

10.1 Guidance used

  • CISA, ASD’s ACSC, NSA’s AI Security Center, the FBI and five partner agencies, Principles for the Secure Integration of Artificial Intelligence in Operational Technology (published 2025-12-03; PDF revision January 2026). Four principles: understand AI; consider AI use in the OT domain; establish AI governance and assurance frameworks; embed oversight and failsafe practices. It advises to “limit active control of OT infrastructure by AI without a human in the loop to account for safety concerns and latency limitations” and to “regularly update and validate AI models” [S31]. The phrase is human in the loop.
  • NIST AI Risk Management Framework 1.0, released 2023-01-26 [S32]. Its four functions are commonly given as Govern, Map, Measure and Manage; the document was not re-read for this article.
  • ISO/IEC 42001:2023, a management-system standard for AI (ISO/IEC 42001); its scope was not re-read for this article [S33].
  • IEC 62443 for security zones and conduits in industrial systems and IEC 61511 for safety instrumented systems (IEC 62443, SIS); cited as background, not read for this article [S34]. NIST’s framework is covered in the glossary under NIST AI RMF.
  • OWASP LLM01 and the agentic Top 10 for injection and tool risks [S29] [S30].

10.2 Ten-point checklist

  1. Read-only first. The agent reads BMS, EPMS and DCIM trends, alarms and CMMS history. It writes only to a ticket, a draft MOP or a chat message.
  2. No autonomous write to OT, BMS or EPMS. A setpoint, mode or breaker change goes through the existing control system with its interlocks, a human approval and a change record [S31]. Safety functions (SIS, fire, EPO, leak-detection trips) stay out of scope entirely [S34].
  3. One-way data path. The agent sits on the IT side of the DMZ. OT data flows out through a historian replica, and no inbound conduit leads from the agent’s zone to the control zone [S31] [S34].
  4. Typed, allow-listed tools with range checks. A supply-air setpoint limit of, say, 18 to 27 °C is enforced in code, not in the prompt. (The numbers are an illustration, not a recommendation.)
  5. A deterministic verifier per action. A simulator, a rule check or a second data source. For example, confirm a CRAH fault from two independent sensors before raising a priority-one alarm.
  6. Every document, ticket and alarm text is untrusted input. It can carry instructions the agent should not follow [S29] [S30].
  7. Budgets and a kill switch. Limits on steps, cost and wall-clock time, and a manual disable that does not depend on the agent.
  8. Logging and replay. Keep prompts, tool calls and results for incident review, which supports the measure and manage functions in NIST’s framework [S32].
  9. Evaluate before rollout. Use a fixed set of historical incidents with a known correct triage; track precision and recall for each release, and rerun the set when the model or prompt changes.
  10. Codify what repeats. When the agent’s procedure for an alarm class is stable, turn it into a deterministic rule and retire the agent for that class.
An agent next to a chiller plantThe agent can read and propose; only the control system, with its interlocks and a human, can act.IT / ENTERPRISEDMZOT · IEC 62443 ZONESAFETYSOP library / CMMSMOPs · work ordersLLM agentread-only toolsOperatorapprovesHistorian replicaone-way outChange gatewayrange · interlock checkBMS / EPMSsupervisoryPLClocal controlChillerIEC 61511SIS / EPO / firehard-wired, out of scopeSOPSDRAFT WOCHANGE + EVIDENCEAPPROVEDSETPOINTONE WAYTRENDSTRIP, INDEPENDENTLEGENDProbabilisticHuman gateSafety-rated An agent next to a chiller plantThe agent can read and propose; only the control system, with its interlocks and a human, can act.IT / ENTERPRISEDMZOT · IEC 62443 ZONESAFETYSOP library / CMMSMOPs · work ordersLLM agentread-only toolsOperatorapprovesHistorian replicaone-way outChange gatewayrange · interlock checkBMS / EPMSsupervisoryPLClocal controlChillerIEC 61511SIS / EPO / firehard-wired, out of scopeSOPSDRAFT WOCHANGE + EVIDENCEAPPROVEDSETPOINTONE WAYTRENDSTRIP, INDEPENDENTLEGENDProbabilisticHuman gateSafety-rated
An agent next to a chiller plant. The agent can read and propose; only the control system, with its interlocks and a human, can act. There is no connector from the agent to the BMS, the PLC or the safety system. “Limit active control of OT infrastructure by AI without a human in the loop” (CISA, ASD ACSC et al. [S31]).

Permitted data flow: Trends and alarms move one way from the control zone to a historian replica in the DMZ, and from there to the agent. The agent can draft a work order, and it can send a proposed change with its evidence to an operator. An approved change passes through a change gateway that checks range and interlock conditions before reaching the BMS. No path leads from the agent to the BMS, the PLC or the safety system. The safety system trips equipment independently.

10.3 Suitable and out-of-scope tasks

Scores from the section 9 scorer. Inputs are judgements; adjust them to your site.

Example scorer results (inputs V, E, Vf, F, L). Source: the calculator in section 9.1; judgement aid, not measurement.
TaskInputsScoreResult
BMS alarm-triage summary for the shift lead4, 4, 3, 5, 335.2Hybrid, just
CMMS work-order drafting from technician notes5, 2, 3, 4, 476.6Agent; drafts only write a ticket
MOP and SOP lookup Q&A5, 3, 3, 4, 465.6Agent, read-only
Monthly PUE report from the historian1, 2, 5, 2, 50.0Script (override: low variability)
Chiller setpoint write3, 5, 2, 4, 27.8Script plus red flag; no autonomous action

Suitable first tasks: alarm-flood summaries, CMMS drafting, procedure retrieval, shift-handover notes. Common properties: untidy input, a draft output that a person reads, and a wrong answer that costs a minute, not an outage. Out of scope are setpoints, sequences of operation and safety functions. The same rules apply to the agent’s memory: anything it stores between runs is data an attacker could shape, so keep it small, reviewable and expiring.

Summary

“Put an agent on the BMS” becomes “put an agent next to the BMS, with read-only access, a draft-only output, and a person between its suggestion and the setpoint.” Anything beyond that needs its own risk assessment against the guidance [S31].

Findings

The critique is right about the mechanism and wrong about the absolutes. The system it describes is a language model inside a loop of ordinary code; the model does real work inside that loop, which the critique denies; and the label is loose in ways that analysts have documented. The evidence read does not show that the economics are anything worse than hype.

11.1 Claims the evidence supports

A model predicts one token at a time and cannot act on the world by itself; vendors document exactly this [S13] [S14]. Its explanations of its own steps can be false [S1], its accuracy can drop sharply under small perturbations [S5], it generalises worse than people by the account of a scaling pioneer [S52], and its reliability at a high success rate is far below its reliability at a low one [S25]. The executor half of an agent is decades-old engineering. Marketing has inflated the word “agent”, and an analyst firm has a name for it [S37]. A study widely read as showing that most enterprise pilots fail exists, with limits [S35].

11.2 Claims the evidence does not support

“No AI involved” fails on the model itself. “No reasoning” and “no maths” are contradicted by causal evidence of multi-step computation inside a model [S1] [S2] and by gains on checkable tasks [S6]. The restaurant demo was a vision-based browser agent and not an API script [S56]. The claim that every head researcher quit over a dead end fails against the record [S53] [S55] [S54]. Private capital has not run out [S46] [S49]. The securities-law claim has no support in any legal record found. Proponents have their own gaps: the benchmarks that headline agent progress have been retired or questioned [S21], productivity evidence is unsettled [S27], and several of the sources used here are the vendors’ own (section 1).

11.3 Grades for all claims

Grades: supported means the evidence read supports it as stated; partly means a narrower version holds; unsupported means the evidence read contradicts or does not support it; unverified means no primary source was read.

The fourteen claims, graded. Sources in the last column; the claims are stated in section 1.
IDClaimGradeEvidence
C1An LLM is a next-token predictorSupportedVendor documentation [S13] [S14]; Article 29
C2Does not understand words, numbers, logic or mathsPartlyNo calculator module, unfaithful self-reports, fragility [S1] [S5]; but learned arithmetic, multi-hop and planning circuits [S1] [S2]
C3No memory, no logic, no reasoning; 2 + 2 is a guessPartlyNo weight memory at inference (true); external memory exists; the “guess” is a distribution computed by circuits [S2]; reasoning gains on checkable tasks [S6]; limits [S3] [S10] [S52]
C4A bare LLM cannot act on the internetSupported[S13] [S14]
C5The model emits a call, code runs it, the result is fed backSupported (generic); unsupported (the booking demo)Docs [S13] [S14]; Operator used a vision browser agent [S56]
C6“The LLM did nothing”UnsupportedThe model parses intent, picks tools, fills arguments, sequences and recovers; the harness changes results [S23]
C7Decades-old automationPartlyThe executor half is old; free-text and screen planning is new [S16] [S56]
C8$3 trillion of compute so farUnverifiedBig-four 2026 capex is about $0.70–0.74T (derived) [S38]–[S43]
C9All head researchers quit because LLMs are a dead endUnsupportedLeCun yes [S53]; Jumper moved to Anthropic [S55]; 2026 departures cite safety [S54]; Pachocki title reported, unverified [S61]
C10Hallucination will never improve muchUnverified (prediction)The reliability gap persists: 80% horizon far below 50% [S25]
C11Cannot do serious coding; will not replace codersPartly2025 slowdown [S26]; 2026 weak evidence of speedup [S27]; about 80% on coding benchmarks with contamination caveats [S20] [S21] [S23]
C12IPO story; private money exhaustedPartlyIPO preparation real [S47] [S50]; record private rounds [S46] [S49]
C13Bordering on securities fraudUnsupportedNo regulator action or lawsuit found in a limited search
C14Rename to “generative” or “automated” computingOpinionThe model itself is AI by any definition (section 8); agent washing is documented [S37]
Six counter-claims used in this article’s argument, graded on the same scale.
IDClaimGradeEvidence
A1The technical foundation of the critique is rightSupportedC1, C4 and the generic C5 [S13] [S14]
A2The LLM acts as a semantic router or dynamic planner over unstructured intentSupported[S12] [S18] [S56]
A3Observe, act, reflect (run tests, read the error, fix) is a genuine patternSupported as a pattern; partly as newReAct, 2022 [S16]; ground truth from the environment [S12]
A4A probabilistic drafter with deterministic tools is a new design patternPartlyGenerate-and-test is old; a general generator over code and text is new; harness effects are measurable [S23]
A5Deterministic guardrails and human-in-the-loop are what matterSupported[S12] [S29] [S30] [S31]; the 50/80 gap [S25]; unfaithful reports [S1]
A6The “fraud” verdict reduces a system to its mechanismSupported, with a caveatDescribing a mechanism is not deception; but agent washing [S37] and pilot failure rates [S35] give the marketing critique substance

11.4 Recommendations and open questions

Use the model where input is untidy and the answer can be checked; keep it away from anything that moves equipment; measure success at the run length you need; and keep the exit cost low while the evidence settles. Open questions remain: the true size of the productivity effect, how well verification holds up when the checker shares the generator’s blind spots, and what the 2026 benchmark scores really are. A later edition will revisit them.

Frequently asked questions

What is an AI agent, in engineering terms?

An agent is a language model running in a loop with tools. The model proposes the next action, ordinary code validates and executes it, and the result goes back into the model's context until a stop condition is met. Anthropic defines agents as typically just LLMs using tools based on environmental feedback in a loop. The model handles untidy input and chooses steps; deterministic code handles execution, permissions, budgets and logging. The model never runs anything itself. Every capability of an agent is a capability of the code that executes its tool calls [S12][S13][S14].

Is agentic AI a fraud?

No. The mechanism critics describe is largely correct: a model predicts one token at a time and cannot act without code that executes its calls [S13][S14]. The absolutes do not hold. Interpretability work found multi-step computation inside a model [S1][S2], and the best-known restaurant-booking demo used a vision-based browser agent, not an API script [S56]. No regulator action or lawsuit alleging securities fraud over agent marketing was found in a limited search. The marketing critique has substance: analysts name it agent washing [S37].

Can a language model reason or do maths?

Partly. Anthropic's attribution-graph study of Claude 3.5 Haiku found two parallel pathways when adding 36 and 59, one for rough magnitude and one for the exact last digit [S1][S2]. The same study found the model's account of carrying the 1 did not match what it did [S1]. Apple's GSM-Symbolic found that adding one clause can cut accuracy by up to 65% [S5]. The practical rule is to treat output as a proposal and check it with something deterministic, such as a test, a schema or a second data source.

How reliable are agents on long tasks?

Reliability falls as the required success rate rises. METR measures task length in human time. Its early Claude Mythos Preview result was a 50% time horizon of 1,045 minutes (about 17.4 hours) but an 80% horizon of only 186 minutes (about 3.1 hours), a ratio of 5.6 [S25]. Independent steps compound: 0.95 per step over 20 steps gives 0.95 to the power 20, or 0.358 (derived). A deterministic verifier with retries can lift that run to about 0.90 for roughly 5% more tokens in the article's model.

Is the AI industry out of private money and forced to list?

The evidence is mixed. An IPO motive exists: Anthropic confidentially submitted a draft S-1 on 2026-06-01 [S47], and OpenAI said an IPO in 2026 would be ill-advised [S50]. But the two largest private rounds on record closed in the same half-year: OpenAI raised $122B at $852B on 2026-03-31 [S49] and Anthropic raised $65B at $965B on 2026-05-28 [S46]. Big-four capex guidance for 2026 sums to roughly $0.70 to $0.74 trillion (derived) [S38][S43]. The often-quoted figure of $3 trillion is unverified.

Can an agent be safely connected to a building management system?

Safely means read-only access plus draft outputs, with a person and the existing control system between a suggestion and a setpoint. CISA, ASD's ACSC and partner agencies advise to limit active control of OT infrastructure by AI without a human in the loop [S31]. The article's ten-point checklist adds a one-way data path through a historian replica, typed and range-checked tools, untrusted-input handling per OWASP [S29][S30], budgets with a kill switch, and keeping safety functions out of scope entirely.

Sources & further reading

61 sources, accessed 2026-10-16 unless the source says otherwise. Numbers marked (derived) are recomputed from these sources, with the arithmetic shown.

  • [S1] Anthropic, "Tracing the thoughts of a large language model" — anthropic.com (2025-03-27). Taken: Mental maths, carry-the-1, faithfulness, Dallas, rhymes
  • [S2] Lindsey et al., "On the Biology of a Large Language Model" (Transformer Circuits) — transformer-circuits.pub (2025-03). Taken: 36+59 circuit, lookup features, planning, caveats
  • [S3] Shojaee et al., "The Illusion of Thinking" (Apple) — arxiv.org (2025-06). Taken: Collapse, effort decline, 3 regimes
  • [S4] A. Lawsen, "Comment on The Illusion of Thinking" — arxiv.org (2025-06). Taken: Token limits, impossible instances, generating functions
  • [S5] Mirzadeh et al., "GSM-Symbolic" (ICLR 2025) — arxiv.org (2024-10). Taken: "up to 65%", hypothesis quote
  • [S6] DeepSeek-AI, "DeepSeek-R1" — arxiv.org (2025-01 (Nature version 2025)). Taken: Emergent reflection; R1 79.8% AIME (re-read); R1-Zero 15.6→71.0% (reported)
  • [S7] Bender et al., "On the Dangers of Stochastic Parrots" (FAccT '21) — dl.acm.org (2021-03). Taken: Definition quote (not re-read; 403)
  • [S8] F. Chollet, "On the Measure of Intelligence" — arxiv.org (2019-11). Taken: Skill-acquisition efficiency
  • [S9] ARC Prize, ARC-AGI-2 page — arcprize.org (2025). Taken: Human calibration, dataset sizes
  • [S10] ARC Prize, "ARC Prize 2025 results & analysis" — arcprize.org (2025-12). Taken: 24%, 37.6%, 54%, costs
  • [S11] Kaggle ARC Prize 2026 leaderboard; benchlm.ai (search snippets only) — kaggle.com (2026-10). Taken: UNVERIFIED 2026 scores
  • [S12] Anthropic, "Building effective agents" — anthropic.com (2024-12-19). Taken: Definitions, simplest-solution, compounding errors, sandbox
  • [S13] Anthropic docs, Tool use overview — docs.claude.com (2026). Taken: Client vs server tools, tool_result
  • [S14] OpenAI docs, Function calling guide — platform.openai.com (2026). Taken: Five-step flow
  • [S15] Schick et al., "Toolformer" — arxiv.org (2023-02). Taken: Self-taught API calls
  • [S16] Yao et al., "ReAct" (A29 [S42]) — arxiv.org (2022-10). Taken: Reason-act-observe
  • [S17] Model Context Protocol specification (A29 [S61]) — modelcontextprotocol.io (rev. 2026-07-28). Taken: Tools = arbitrary code execution
  • [S18] LangChain (J. Ou), "What is an AI agent?" — blog.langchain.com (2026-07-31). Taken: Autonomy spectrum, loop components
  • [S19] Russell & Norvig, *Artificial Intelligence: A Modern Approach*, 4th ed., ch. 2 — aima.cs.berkeley.edu (2020). Taken: Agent definition (not re-read)
  • [S20] SWE-bench leaderboards.json — raw.githubusercontent.com (read 2026-10-16). Taken: Verified top entries
  • [S21] OpenAI, "Why we no longer evaluate SWE-bench Verified" — openai.com (2026-02). Taken: 59.4% of 138 audited problems flawed; contamination; use Pro (re-read 2026-10-25)
  • [S22] Decrypt, "OpenAI Says Benchmark… Is 'Contaminated'" — decrypt.co (2026-02-24). Taken: ~70%→~23% on Pro
  • [S23] Terminal-Bench 2.0 leaderboard (Snorkel mirror; tbench.ai) — snorkel.ai (2026-10). Taken: Top entries, 89 tasks
  • [S24] METR, "Time Horizon 1.1" — metr.org (2026-01-29). Taken: Suite size, 131-day doubling
  • [S25] METR, Task-Completion Time Horizons page + benchmark_results_1_1.yaml — metr.org (last updated 2026-09-08). Taken: Model p50/p80, 128.7-day doubling, >16 h caveat
  • [S26] METR, early-2025 developer RCT — metr.org (2025-07-10). Taken: 19% slowdown (via S29 text)
  • [S27] METR, "We are Changing our Developer Productivity Experiment Design" — metr.org (2026-02-24). Taken: Follow-up estimates, selection effects
  • [S28] Anthropic, "Agentic Misalignment" — anthropic.com (2025-06). Taken: Blackmail rates, simulation caveat
  • [S29] OWASP, LLM01:2025 Prompt Injection — genai.owasp.org (2025). Taken: Indirect injection, impacts
  • [S30] OWASP, Top 10 for Agentic Applications 2026 — genai.owasp.org (2025-12-09). Taken: ASI01–ASI10
  • [S31] CISA, ASD ACSC et al., Principles for the Secure Integration of AI in OT (page + PDF v2) — cisa.gov (2025-12-03 (PDF 2026-01)). Taken: Four principles, HITL quote
  • [S32] NIST, AI Risk Management Framework — nist.gov (2023-01-26). Taken: Release date; functions (not re-read)
  • [S33] ISO/IEC 42001:2023 — iso.org (2023). Taken: AI management system (not re-read; 403)
  • [S34] IEC 62443 series; IEC 61511 (background) — isa.org (—). Taken: Zones/conduits, SIS (not read)
  • [S35] MIT NANDA, *The GenAI Divide: State of AI in Business 2025* (PDF) — mlq.ai (2025-07/08). Taken: 95%, 60/20/5, methods, learning gap
  • [S36] Fortune, "95% of generative AI pilots at companies are failing" — fortune.com (2025-08-18). Taken: Popular framing
  • [S37] Gartner press release (403; headline via HN listing) — gartner.com (2025-06-25). Taken: 40% headline; rest UNVERIFIED
  • [S38] CNBC, "Amazon, Meta, Microsoft face skeptical investors…" — cnbc.com (2026-07-28). Taken: MSFT $190B, AMZN $200B, debt figures
  • [S39] Business Insider, "Microsoft keeps capex unchanged" — businessinsider.com (2026-07-29). Taken: $190B held, $175B restated
  • [S40] CNBC, Alphabet Q2 2026 live updates — cnbc.com (2026-07-22). Taken: $195–205B
  • [S41] Meta Platforms Q2 2026 results, 8-K Ex. 99.1 (SEC) — sec.gov (2026-07-29). Taken: $130–145B
  • [S42] Amazon.com Q2 2026 earnings release — s2.q4cdn.com (2026-07-30). Taken: P&E $54.2B Q2, $98.4B H1, FCF −$7.6B TTM
  • [S43] Fortune, Meta raises 2026 capex to $125–145B — fortune.com (2026-04-29). Taken: Prior range
  • [S44] CNBC, Anthropic run-rate $65B — cnbc.com (2026-08-17). Taken: $65B, ~7×
  • [S45] CNBC, OpenAI revenue $20B lower than signalled — cnbc.com (2026-10-08). Taken: ~$50B vs $68B
  • [S46] Anthropic, Series H — anthropic.com (2026-05-28). Taken: $65B at $965B
  • [S47] Anthropic, confidential draft S-1 — anthropic.com (2026-06-01). Taken: Filing
  • [S48] CNBC, New Constructs on Anthropic IPO (cites Reuters leaked prospectus) — cnbc.com (2026-10-07). Taken: $4.6B / −$42B (UNVERIFIED), $150B view
  • [S49] CNBC, OpenAI closes $122B round at $852B — cnbc.com (2026-03-31). Taken: Round size
  • [S50] PYMNTS (citing Fortune interview), OpenAI IPO not in 2026 — pymnts.com (2026-09-13). Taken: Altman quote
  • [S51] The Verge, Sutskever at NeurIPS 2024 — theverge.com (2024-12-13). Taken: Pre-training end, peak data
  • [S52] Dwarkesh Podcast, Ilya Sutskever — dwarkesh.com (2025-11-25). Taken: Age of research; generalisation quote
  • [S53] Observer, LeCun to leave Meta — observer.com (2025-11-11). Taken: Dead-end quote, Harvard quote
  • [S54] NBC News, researchers leave Anthropic and Google over safety — nbcnews.com (2026-09-10). Taken: Benton, Engels, Coxon
  • [S55] Business Insider, John Jumper leaves DeepMind for Anthropic — businessinsider.com (2026-06-19). Taken: Move
  • [S56] TechCrunch, "OpenAI launches Operator" — techcrunch.com (2025-01-23). Taken: CUA, no APIs, confirmation, partners
  • [S57] Article 29 dossier (internal) — the author's own files, not public; described in the text (2026-10-16). Taken: Prices $2/$10 per M, cache 10%, mechanism sections
  • [S58] Factory skill and CLI (local) — the author's own files, not public; described in the text (read 2026-10-16). Taken: Roles, gates, limits, delivery
  • [S59] Factory demo job board (local) — the author's own files, not public; described in the text (2026-10-16). Taken: Gate and review results
  • [S60] Epoch AI data (A29 [S41][S64]) — epoch.ai (2026). Taken: Data wall, compute trend
  • [S61] OpenAI, "Built to benefit everyone: our plan" by Sam Altman and Jakub Pachocki (title via listing; page 403) — openai.com (2026-06-09). Taken: Pachocki still at OpenAI
Previous Article All Articles Latest Article
Bagus Dwi Permana

Bagus Dwi Permana

Engineering Operations Manager | Ahli K3 Listrik

12+ years in data center operations across Southeast Asia and the Middle East. CDFOM certified. Writes about the engineering and physics behind mission-critical infrastructure — and, increasingly, the local-AI tooling that runs alongside it.