1. Introduction and problem

In the 2021–2026 span the market for «AI agents» has installed a package of artifacts that claim to count as a production harness: a larger model that «already reasons»; a ReAct prompt or a template with tools that «already acts»; an API or function-calling demo without an observation–action–verification loop; a chatbot labeled agent because it remembers the thread or retrieves documents (RAG); a fine-tune presented as execution control; and a benchmark ranking without describing the agent–computer interface, the verifiers, the budgets or isolation. The artifacts fit on a slide. The leap —from scale, prompt, demo, marketing or leaderboard to claiming reliable work— is not authorized by the state of the art when the object is to convert generative capacity into verifiable execution against an environment (Yao et al., 2023; Yang et al., 2024; Jimenez et al., 2024; Patil et al., 2024; Wang, L. et al., 2024; Xi et al., 2025; Liu, J. et al., 2026).

The thesis is restrictive: those artifacts do not constitute a harness. The harness —typed tools, memory/state, stop policies, verifiers, budgets, logging and isolation— converts generative capacity into reliable work; without it, the model fails by compound error, tool hallucination and lack of external evidence. Anchor status: Yao et al. (2023) contribute a reason–act prompt loop (framework/empirical of a loop, not a production harness). Schick et al. (2023) contribute self-supervised tool-use as a typed artifact, not as an external verifier. Patil et al. (2024) document API hallucination when retrieval evidence is missing. Jimenez et al. (2024) shift the metric from perplexity to real GitHub issues: task is measured, not fluency. Yang et al. (2024) show, as an empirical finding of interface, that the design of the agent–computer interface (ACI) changes what the same kind of model can do. That authorizes asking what was measured: a plausible completion, a plugin demo, a leaderboard score —or a loop that observes, acts with typed tools, verifies against external evidence and stops under budget.

The problem is aggravated by six category confusions. First: a harness is not the LLM alone —scaling does not sign control (Wang, L. et al., 2024; Xi et al., 2025)—. Second: it is not a prompt loop —ReAct (Yao et al., 2023) and Reflexion (Shinn et al., 2023) are components, not a harness with isolation and verifiers—. Third: it is not the catalog of APIs —Toolformer, ToolLLM, HuggingGPT and Gorilla show invocation, orchestration or hallucination; they do not equal an external verifier (Schick et al., 2023; Qin et al., 2023; Shen et al., 2023; Patil et al., 2024)—. Fourth: it is not RAG nor a fine-tune: retrieving documents or adapting weights does not replace observation, stopping or logging. Fifth: it is not «agent» marketing —the surveys distinguish profile, memory, planning and action as architecture, not as a slogan (Wang, L. et al., 2024; Sumers et al., 2023; Xi et al., 2025; Liu, J. et al., 2026)—. Sixth: it is not the ranking read as craft: SWE-bench, AgentBench and WebArena evaluate task in an environment; they do not authorize declaring a harness by a table row without ACI, verifiers or budgets (Jimenez et al., 2024; Liu, X. et al., 2023; Zhou et al., 2024). The axis is Technology and AI, not classroom pedagogy. Inference: reliable work is fulfilled with the craft of the harness, not with scale, prompt or plugin.

There is, besides, an economy of coordination: the artifacts fit in an advertisement; the loop with external evidence does not. The contributions are three: separating craft and artifacts; examining marked cases (model/prompt/demo; craft of ACI, memory, roles and budgets; boundaries versus RAG, fine-tune and marketing); and offering four tests of a harness. No N, SWE-bench or AgentBench percentages, d, r, AUC or DOI is invented: the category logic of the sources is cited —interface design, task evaluation, API hallucination—, not a fabricated number.

2. State of the art: situated practice vs artifact

It is useful to separate four strata that the market of «autonomous agents» usually mixes. The first is the construct of an LLM agent as a system that perceives an environment, decides and acts with tools, not as a longer completion (Wang, L. et al., 2024; Sumers et al., 2023; Xi et al., 2025). The second is the craft of the harness in a real environment —agent–computer interface, state, typed tools, verification, stopping and budget (Yang et al., 2024; Wang, X. et al., 2024; Park et al., 2023; Wang, G. et al., 2023; Wu et al., 2023)—. The third is the evidence of artifacts and of tool-use —prompt loops, self-supervised tools, orchestration, APIs, API hallucination— without equating them to a production harness (Yao et al., 2023; Schick et al., 2023; Shinn et al., 2023; Shen et al., 2023; Qin et al., 2023; Patil et al., 2024). The fourth is evaluation with task evidence and the framework surveys (Jimenez et al., 2024; Liu, X. et al., 2023; Zhou et al., 2024; Liu, J. et al., 2026). Inference: a leaderboard does not observe the repository; an ACI with a verifier does.

In construct and loop, Yao et al. (2023) saturate ReAct: synergy of reasoning and acting in a prompt loop. Status: framework/empirical of a reason–act loop; not a production harness with isolation and stopping. Shinn et al. (2023) contribute Reflexion: verbal self-reflection as ephemeral memory (empirical component, not a harness). Sumers et al. (2023) propose CoALA: memory, action and grounding (framework). Wang, L. et al. (2024) organize profile, memory, planning and action (framework survey). Xi et al. (2025) review potential and limits (2025 survey). Inference: the construct authorizes asking for architecture; not selling a prompt as control.

In craft of interface and of state, Yang et al. (2024) saturate the ACI: the design of the agent–computer interface enables automated software engineering. Status: empirical finding of interface; SWE-bench percentages are not invented. Wang, X. et al. (2024) describe OpenHands as an open platform with an agent–environment interface (framework/platform; development harness). Wang, G. et al. (2023) contribute Voyager: curriculum, skill library and open-ended loop —craft of state and procedural memory—. Park et al. (2023) articulate memory, reflection and planning as situated architecture. Wu et al. (2023) formulate AutoGen: multi-agent conversation as a coordination harness. Qian et al. (2024) describe ChatDev: communicative roles for software development (organizational harness). Inference: the craft is not «the model spoke»; it is the controlled relation among model, environment, memory and roles.

In artifacts of tool-use and in evaluation, Schick et al. (2023) show self-supervised tool-use: a typed artifact, not an external verifier. Shen et al. (2023) orchestrate models and tools (HuggingGPT): planning + tools ≠ a complete verifier. Qin et al. (2023) scale real APIs (ToolLLM): contrast with a verification harness. Patil et al. (2024) document Gorilla: massive APIs and API hallucination / tool calling without evidence. Jimenez et al. (2024) propose SWE-bench: real GitHub issues (empirical SE benchmark; measure task, not perplexity; invented rates are not cited). Liu, X. et al. (2023) propose AgentBench: multi-environment evaluation. Zhou et al. (2024) propose WebArena: a realistic web environment with task evidence. Liu, J. et al. (2026) close with a TOSEM survey of LLM agents in SE. Category inference: the state of the art distinguishes component, platform, benchmark and survey; the market crushes them into the word «agent».

3. Review method

A critical narrative review was conducted, not a primary meta-analysis. The purpose was not to estimate a homogeneous effect size nor to combine SWE-bench, AgentBench or WebArena rates —rates this article does not invent— but to articulate a category argument: what counts as a harness and what remains at the artifact ceiling. Inclusion criteria: (a) 2021–2026; (b) LLM agents, tool-use, agent–computer or agent–environment interfaces, cognitive architectures, multi-agent orchestration, or task benchmarks (SE, web, multi-environment); (c) peer-reviewed, proceedings or preprint with abs/DOI verifiable on 16 September 2026; (d) relevance to the craft/artifact contrast. Early-childhood axes of this editorial series, product catalogs without a paper, and any figure not present in the verified sources were excluded. The nineteen sources of fuentes.md were used. No authors, venues or DOI foreign to that list were added.

Search and verification were executed on 16 September 2026 (America/Mexico_City slot) against arXiv abs pages and Crossref records of the corpus. Each source was read by the object it actually measures or proposes. Empirical finding, framework and pedagogical inference of design were distinguished. When an artifact —model-only, prompt-only, tools demo without a loop, RAG, fine-tune or the agent label— lacks a verified trial that equates it to a production harness, it is discussed as a category ceiling, not as a quantitative finding. No N, d, r, AUC, resolution percentages or DOI was invented. The inferences of section 7 are category hypotheses, not an industrial standard.

4. Case 1. The artifacts do not constitute support

Yao et al. (2023), Schick et al. (2023) and Shen et al. (2023) saturate the ceiling when a prompt loop, a tool-use artifact or an orchestration is presented as a production harness. Yao et al. (2023) —ReAct— map reasoning and acting in the model's own context: a finding of a prompt loop, not that «Thought/Action/Observation» traces cultivate isolation, budgets and external verifiers. Schick et al. (2023) —Toolformer— show self-supervised tool calls: a typed artifact, not an external verification harness. Shen et al. (2023) —HuggingGPT— coordinate ChatGPT with Hugging Face models: planning + tools, not a complete external verifier. Pedagogical inference of design: the gesture «the model called an API = there is already a reliable agent» is a demo ceiling. A ReAct prompt can coexist with absence of external evidence, of stopping and of auditable logging.

Qin et al. (2023) and Patil et al. (2024) name the risk of the API catalog without the craft of verification. Qin et al. (2023) —ToolLLM— facilitate tool-use at scale over real APIs: framework/empirical; contrast with a verification harness. Patil et al. (2024) —Gorilla— connect the LLM with massive APIs and document API hallucination and retrieval-aware tool calling. Status: empirical finding of failure when external evidence is missing. Restrictive inference: invoking thousands of APIs does not sign that the invocation is the correct one; a retrieval-aware caller reduces tool hallucination, it does not replace a task verifier (tests, oracle, web evidence). Shinn et al. (2023) contribute Reflexion as verbal memory. Status: component; reflection in text is not an external oracle. Inference: a model that «corrects itself» in the same channel in which it hallucinates has not left the context; it has prolonged it.

Model-only, prompt-only and a tools demo without a loop lack, in the verified corpus, trials that authorize treating them as a harness. SWE-bench or AgentBench percentages are not invented here to declare that «scaling the LLM is enough». Jimenez et al. (2024) measure real issues, not fluency: the benchmark exists because the completion does not sign the patch. Liu, X. et al. (2023) evaluate LLMs-as-agents in multiple environments: evaluation assumes an environment, not a chat. Zhou et al. (2024) anchor the realistic web: task evidence, not text alone. Restrictive inference: model ≠ control; prompt ≠ evidence; API ≠ craft. Wang, L. et al. (2024), Xi et al. (2025) and Liu, J. et al. (2026) map the field without equating the slogan of «autonomous agent» to a system with verifiers. The artifacts share a grammar of substitution: scale speaks for control; the prompt for the loop; the demo for verification; marketing for architecture; the ranking for the craft of interface.

Failure chain without a harness: tool or API hallucination, undetected error, compound error and unreliable work, with three absences that do not constitute a harness
Figure 2. Failure modes without a harness. Conceptual chain —not an empirical rate— of tool/API hallucination, undetected error, compound error and unreliable work. The three absences (a larger model alone, a «better» prompt without a verifier, a tools demo without a loop) do not constitute a harness. Anchored in Patil et al. (2024), Yao et al. (2023) and Schick et al. (2023). Reports no N and no percentages.

It is useful to specify the ceiling without inventing effects. A larger model can produce more coherent traces; Wang, L. et al. (2024) and Xi et al. (2025) do not authorize reading that coherence as control. A «better» prompt can imitate ReAct; Yao et al. (2023) describe a prompt loop, not a runtime with isolation. A function-calling demo can impress; Patil et al. (2024) show that the hallucinated invocation is a specific failure mode. Inference: «the agent finished the message» or «the plugin returned 200» does not sign reliable work. The undetected error compounds: a hallucinated tool produces a false state; the next step reasons over that state; the output looks finished and is wrong. Without an external verifier there is no one to cut the chain. That is the ceiling: exhibiting generative capacity and hiding the absence of craft.

5. Case 2. The relational craft in the kindergarten

The «kindergarten» of this case is not an early-childhood classroom: it is the operational environment in which a language agent works —repository, browser, API, simulator, workspace— and in which the craft of the harness is recognized as relational practice among model, tools, state and external evidence. The floor is not a completion: it is an episode in which the system observes, plans, acts with typed tools, verifies against evidence that is not its own text, and stops when the budget or the policy requires it (Yang et al., 2024; Wang, X. et al., 2024; Sumers et al., 2023; Wang, G. et al., 2023). Inference: there is a harness when that loop is protected; not when a larger model, a prompt or a plugin is exhibited. The model is not «the agent» in solitude; the agent is the controlled coupling of model and environment.

Harness loop: Observe, Plan, Act with typed tools, Verify with external evidence and Stop by budget, with feedback to state
Figure 1. Harness loop: Observe (state, logs) → Plan → Act (typed tools) → Verify (external evidence) → Stop / budget, with feedback to a new Observe. The components —typed tools, memory/state, stopping, verifiers, budgets, logging, isolation— are not the LLM alone. A craft schema, not a numerical result of SWE-bench or AgentBench.

Yang et al. (2024) saturate the interface anchor. SWE-agent formulates that ACIs enable automated software engineering: the finding is of design —which commands, which observation of the repository, which feedback format—, not that «a larger LLM is enough». Status: empirical finding of interface; resolution rates are not invented. Inference: changing the interaction harness changes the work that is possible. Wang, X. et al. (2024) —OpenHands— describe an open platform for software developers as generalist agents, with an agent–environment interface (platform framework / development harness). The craft is institutionalized as a runtime, not as a prompt pasted onto a chat. Liu, J. et al. (2026) review LLM agents in SE: the 2026 survey treats the field as a system, not as a demo, and makes the harness an object.

Wang, G. et al. (2023) and Park et al. (2023) saturate the craft of state and of memory. Voyager articulates an open-ended embodied agent with curriculum, skill library and a loop that reuses skills: craft of procedural memory, not a context that is forgotten when the session closes (situated framework/empirical). Park et al. (2023) compose memory, reflection and planning as an architecture of interactive simulacra (situated framework/empirical). Shinn et al. (2023) are reread as a verbal-memory component that the craft can incorporate, not as a complete harness. Sumers et al. (2023) —CoALA— give the framework of memories, actions and grounding: the agent needs anchoring, not tokens alone. Inference: the operational kindergarten has state; a chat without persistent memory or grounding is not that kindergarten.

Wu et al. (2023) and Qian et al. (2024) saturate the craft of roles. AutoGen enables applications via multi-agent conversation: the harness is the protocol of who speaks, with which tools and with which stopping criterion (coordination framework). ChatDev organizes communicative agents with roles for software development: organizational harness (design, code, review as parts, not as slogans). Inference: multiplying characters in a prompt is not AutoGen nor ChatDev; the craft requires roles with tools, memory and stopping. A marketing «agent team» without isolation or verifier is role theatre, not an organizational harness.

Jimenez et al. (2024), Liu, X. et al. (2023) and Zhou et al. (2024) anchor evaluation of the craft, not its substitution by a ranking. SWE-bench asks whether models resolve real GitHub issues: the unit is the task with tests, not perplexity. AgentBench evaluates LLMs-as-agents in several environments. WebArena offers a realistic web environment with task evidence. Status: empirical environment benchmarks. Restrictive inference: citing them without describing ACI, verifiers and budgets is exhibiting the empty kindergarten. The craft is verified when the loop leaves a trace —logs, diffs, oracles, stops—, not when the model produces a paragraph about what it «would have done».

6. Case 3. Category boundaries

The first boundary is RAG: retrieving passages can reduce factual hallucination; it does not observe a repository, execute a patch, verify a test or implement stopping. Patil et al. (2024) show that tool calling requires retrieval evidence; that does not turn RAG into an agent harness. Inference: «we have embeddings = we have an agent» does not sign. The second is the fine-tune: adapting weights can change invocation style; Schick et al. (2023) teach tools in the model; the checkpoint is not a runtime with isolation and logging. Inference: a tuned model remains a model; the harness is the system around it. The third is the prompt loop: ReAct and Reflexion (Yao et al., 2023; Shinn et al., 2023) are pieces; Sumers et al. (2023) and Wang, L. et al. (2024) ask for architecture. Inference: a Thought/Action template is not CoALA nor an ACI.

The fourth boundary is orchestration and the catalog of APIs. HuggingGPT (Shen et al., 2023) plans and dispatches experts; ToolLLM (Qin et al., 2023) scales the domain of APIs. Status: framework/empirical of orchestration and of tool-use at scale. Category inference: planning + tools ≠ a complete external verifier; a massive catalog ≠ the craft of verification. A dispatcher can choose the wrong expert; a catalog can be invoked in a hallucinated way (Patil et al., 2024). The fifth is «agent» marketing: Xi et al. (2025) and Wang, L. et al. (2024) describe potential and limits; Liu, J. et al. (2026) situate the field in SE. None authorizes labeling as an agent a chatbot with thread memory. The sixth is the leaderboard as craft: Jimenez et al. (2024), Liu, X. et al. (2023) and Zhou et al. (2024) build environments and tasks; Yang et al. (2024) and Wang, X. et al. (2024) show that the interface is part of the evaluated system. Inference: a table row without a harness description does not distinguish model, prompt and harness.

Internal boundaries of the craft remain. Memory and skill library (Wang, G. et al., 2023; Park et al., 2023) are components: without a verifier and without a budget they can memorize the error. Multi-agent roles (Wu et al., 2023; Qian et al., 2024) are an organizational harness only if there is protocol, tools and a cut; otherwise they are dialogue. An embodied or web environment (Wang, G. et al., 2023; Zhou et al., 2024) is an operational kindergarten, not a license to omit isolation. Pedagogical inference of design: the category «harness» is conjunctive —a loop with external evidence, typed tools and isolation, stopping/budget/logging, and design judgment—. One piece missing and the system falls back into artifact, even if the slide says agent.

7. Four tests of support (not artifact)

The framework that follows is a pedagogical inference of design of this article, anchored in the cases and in the verified sources. It is not an ISO standard nor a leaderboard. It distinguishes four tests. If a platform or a product does not pass them, it cannot declare that model-only, prompt-only, a tools demo, RAG, a fine-tune or the agent label constitute a harness.

7.1. Test of the observation–action–verification loop with external evidence, not of the model alone nor of the prompt loop without an oracle. Yao et al. (2023) define a prompt loop; Shinn et al. (2023) add verbal reflection; Sumers et al. (2023) require grounding; Jimenez et al. (2024), Liu, X. et al. (2023) and Zhou et al. (2024) evaluate with task evidence. Inference: support is verified when there is Observe → Act → Verify against tests, workspace, a web page or an oracle that is not the model's own token. If the «evidence» is that the model wrote «done» or that the prompt includes the word Observation, there is theatre of a loop, not a harness.

7.2. Test of typed tools and isolation, not of the API catalog nor of the function-calling demo. Schick et al. (2023) type the invocation; Qin et al. (2023) and Shen et al. (2023) scale and orchestrate; Patil et al. (2024) show API hallucination; Yang et al. (2024) and Wang, X. et al. (2024) situate interface and isolation. Inference: there is a harness when the tools have schema, permissions and a sandbox, and a hallucinated invocation does not have unrestricted access to the world. A plugin in the chat does not sign that test. Isolating is not aesthetics: it is admitting the failure mode Gorilla names.

7.3. Test of stop policies, token/time budgets and logging, not of the agent that «keeps trying» until the card is exhausted. Wu et al. (2023) and Qian et al. (2024) coordinate with roles and a cut; Wang, G. et al. (2023) and Park et al. (2023) sustain open-ended loops with memory and curriculum, not with unlimited spend; Xi et al. (2025) mark limits. Inference: a system without a budget or an auditable log is not reliable even if it solves a demo. Stopping is craft: knowing when one does not know and when the verifier failed. Logging is the external memory Reflexion does not replace.

7.4. Test of category distinction and of design judgment, not of the product catalog. Harness ≠ LLM alone ≠ prompt-only ≠ tools demo ≠ RAG ≠ fine-tune ≠ «agent» marketing ≠ leaderboard row. Wang, L. et al. (2024), Xi et al. (2025) and Liu, J. et al. (2026) prevent reducing the field to a slogan. Yang et al. (2024) prevent omitting the interface. Inference: a laboratory cannot treat the model as if it were the system nor the ranking as if it were the craft. Reliable work is fulfilled by designing the model–environment coupling with the three previous tests and declaring which piece is missing.

Conceptual schema of relative work reliability: model alone, tools demo without a loop, partial loop without verification, and full harness with budget; does not report empirical data
Figure 3. Conceptual comparison (schema, not fabricated data). Illustrative relative bars: model alone (prompt); tools demo without a loop; partial loop without verify; full harness observation–plan–action–verification with budget. The schema does not invent SWE-bench or AgentBench results; it reports no N, percentages or AUC. Reading: the craft of the harness, not the scale of the LLM alone, sustains relative reliability.

The framework admits subordinate components —ReAct, Toolformer, Reflexion, RAG, fine-tune, HuggingGPT, ToolLLM— as pieces (Yao et al., 2023; Schick et al., 2023; Shinn et al., 2023; Shen et al., 2023; Qin et al., 2023). It refuses to declare a harness by any of them alone, and refuses to read Gorilla, SWE-bench, AgentBench or WebArena as a license to omit verifiers (Patil et al., 2024; Jimenez et al., 2024; Liu, X. et al., 2023; Zhou et al., 2024). The four tests are read together.

8. Discussion

Three tensions organize the discussion. The first is between exhibiting the artifacts and exercising the craft of the harness. Yao et al. (2023), Schick et al. (2023), Shen et al. (2023) and Qin et al. (2023) sustain real components —loop, tools, orchestration, APIs— that the market inflates until they pass as a system. Yang et al. (2024), Wang, X. et al. (2024), Wu et al. (2023) and Qian et al. (2024) sustain the contrast: interface, platform, roles. Inference: the piece is true in its domain; «piece = production harness» is an illegitimate category inference.

The second is between scaling the LLM and designing the interface. Xi et al. (2025) and Wang, L. et al. (2024) describe the rise of agents based on more capable models; Yang et al. (2024) show that the ACI is an object of empirical design; Jimenez et al. (2024) measure issues, not predicted tokens. It is not invented here that a small model with a good harness «beats» a large model: that figure is not in the corpus and is not fabricated. The thesis is stricter: the empirical gain reported in the agent literature is not read honestly if it is attributed only to scale and the harness is hidden. Inference: omitting the harness in the causal story is a display bias, not a conclusion of SWE-bench.

The third is between tool hallucination and external evidence. Patil et al. (2024) name the failure; Zhou et al. (2024) and Jimenez et al. (2024) build environments where the evidence is not the model's own context; Sumers et al. (2023) ask for grounding; Shinn et al. (2023) show that verbal reflection does not leave language. Inference: the failure mode is not «the model is dumb»; it is that, without an oracle, the error is not seen. Voyager and generative agents (Wang, G. et al., 2023; Park et al., 2023) illustrate that memory and curriculum sustain open-ended loops. Liu, J. et al. (2026) recall that in SE the agent is at stake in the patch and in the test, not in the prose of the commit.

The four tests read these tensions. The contrast of interface and of benchmark defines the floor the artifacts do not reach alone. A ReAct prompt, a Gorilla-style caller, an AutoGen role or a Voyager skill can live inside the harness; it is not legitimate to invert the sequence: first the announcement of «autonomous agent», then the hope that the model will verify itself (Xi et al., 2025; Wang, L. et al., 2024). If there are logs, typed tools, an oracle and stopping, there is a harness; if there is only scale, prompt or plugin, there are artifacts.

9. Limits

This review is narrative. It does not apply its own PRISMA nor estimate combined effects. SWE-bench, AgentBench, WebArena or SWE-agent percentages are not invented; N, d, r or AUC is not invented. Yao et al. (2023), Schick et al. (2023), Shinn et al. (2023), Shen et al. (2023), Qin et al. (2023) and Patil et al. (2024) are read by the object they propose (loop, tools, reflection, orchestration, APIs, hallucination), not as trials of the «production agent» package. Yang et al. (2024) and Wang, X. et al. (2024) anchor interface and platform: they are not generalized to every domain. Jimenez et al. (2024), Liu, X. et al. (2023) and Zhou et al. (2024) are environment benchmarks. Wang, G. et al. (2023) and Park et al. (2023) are embodied or simulacrum environments: marked setting transfer. Wu et al. (2023) and Qian et al. (2024) are coordination and roles. Sumers et al. (2023), Wang, L. et al. (2024), Xi et al. (2025) and Liu, J. et al. (2026) are frameworks and surveys, not a trial of the artifact ceiling.

No trials were located, in this kit's corpus, that equate model-only, prompt-only or a tools demo without a loop to an observation–action–verification harness with isolation; they are discussed as a category ceiling. Several sources are arXiv preprints with verified abs: they are cited as such, without inventing a DOI. Commercial products and leaderboards are not evaluated. The inferences of section 7 are category hypotheses, not evidence of a particular runtime. The «kindergarten» of heading 5 names the operational environment; it does not transfer findings from early childhood education.

10. Conclusions

A larger model, a «better» prompt or a tools demo without an observation–action–verification loop do not constitute a harness. Neither do, by themselves, RAG, a fine-tune, an agent label or a leaderboard row without interface, verifiers and budgets. Yao et al. (2023), Schick et al. (2023), Shinn et al. (2023), Shen et al. (2023) and Qin et al. (2023) confirm components —loop, tools, reflection, orchestration, APIs— without equivalence to a production harness. Patil et al. (2024) confirm API hallucination when evidence is missing. Wang, L. et al. (2024), Xi et al. (2025) and Liu, J. et al. (2026) set the map and the limits. When there is a harness there is situated craft: ACI (Yang et al., 2024); agent–environment platform (Wang, X. et al., 2024); memory and skill library (Wang, G. et al., 2023; Park et al., 2023); roles (Wu et al., 2023; Qian et al., 2024); grounding (Sumers et al., 2023); evaluation with task evidence (Jimenez et al., 2024; Liu, X. et al., 2023; Zhou et al., 2024). The harness is distinguished from the LLM alone, from prompt-only, from the tools demo, from RAG, from the fine-tune and from the slogan.

Where the sources do not measure a production runtime, this article does not claim it. Where they measure loops, tools, benchmarks, platforms or surveys, it does not translate them into «the model is already a reliable agent» via scale or via demo. Converting generative capacity into reliable work is to exercise typed tools, memory/state, stopping, verifiers, budgets, logging and isolation, in a loop that observes, acts and verifies against external evidence. The rest is model-only, prompt-only and a tools demo without a loop. It is not a harness, and it must not be presented as what it is not.

Laboratorio Editorial de NEXTECH.IA / Ingeniero Mitre.

References

  1. Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., y Narasimhan, K. (2024). SWE-bench: Can language models resolve real-world GitHub issues? arXiv. https://arxiv.org/abs/2310.06770
  2. Liu, J., Wang, K., Chen, Y., Peng, X., Chen, Z., Zhang, L., y Lou, Y. (2026). Large language model-based agents for software engineering: A survey. ACM Transactions on Software Engineering and Methodology. https://doi.org/10.1145/3796507
  3. Liu, X., Yu, H., Zhang, H., Xu, Y., Lei, X., Lai, H., Gu, Y., Ding, H., Men, K., Yang, K., Zhang, S., Deng, X., Zeng, A., Du, Z., Zhang, C., Shen, S., Zhang, T., Su, Y., Sun, H., Huang, M., Dong, Y., y Tang, J. (2023). AgentBench: Evaluating LLMs as agents. arXiv. https://arxiv.org/abs/2308.03688
  4. Park, J. S., O’Brien, J. C., Cai, C. J., Morris, M. R., Liang, P., y Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. En Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology (pp. 1–22). ACM. https://doi.org/10.1145/3586183.3606763
  5. Patil, S. G., Zhang, T., Wang, X., y Gonzalez, J. E. (2024). Gorilla: Large language model connected with massive APIs. En Advances in Neural Information Processing Systems 37. https://doi.org/10.52202/079017-4020
  6. Qian, C., Liu, W., Liu, H., Chen, N., Dang, Y., Li, J., Yang, C., Chen, W., Su, Y., Cong, X., Xu, J., Li, D., Liu, Z., y Sun, M. (2024). ChatDev: Communicative agents for software development. En Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers) (pp. 15174–15186). Association for Computational Linguistics. https://doi.org/10.18653/v1/2024.acl-long.810
  7. Qin, Y., Liang, S., Ye, Y., Zhu, K., Yan, L., Lu, Y., Lin, Y., Cong, X., Tang, X., Qian, B., Zhao, S., Hong, L., Tian, R., Xie, R., Zhou, J., Gerstein, M., Li, D., Liu, Z., y Sun, M. (2023). ToolLLM: Facilitating large language models to master 16000+ real-world APIs. arXiv. https://arxiv.org/abs/2307.16789
  8. Schick, T., Dwivedi-Yu, J., Dessì, R., Raileanu, R., Lomeli, M., Hambro, E., Zettlemoyer, L., Cancedda, N., y Scialom, T. (2023). Toolformer: Language models can teach themselves to use tools. En Advances in Neural Information Processing Systems 36. https://doi.org/10.52202/075280-2997
  9. Shen, Y., Song, K., Tan, X., Li, D., Lu, W., y Zhuang, Y. (2023). HuggingGPT: Solving AI tasks with ChatGPT and its friends in Hugging Face. En Advances in Neural Information Processing Systems 36. https://doi.org/10.52202/075280-1657
  10. Shinn, N., Cassano, F., Gopinath, A., Narasimhan, K., y Yao, S. (2023). Reflexion: Language agents with verbal reinforcement learning. En Advances in Neural Information Processing Systems 36. https://doi.org/10.52202/075280-0377
  11. Sumers, T. R., Yao, S., Narasimhan, K., y Griffiths, T. L. (2023). Cognitive architectures for language agents. arXiv. https://arxiv.org/abs/2309.02427
  12. Wang, G., Xie, Y., Jiang, Y., Mandlekar, A., Xiao, C., Zhu, Y., Fan, L., y Anandkumar, A. (2023). Voyager: An open-ended embodied agent with large language models. arXiv. https://arxiv.org/abs/2305.16291
  13. Wang, L., Ma, C., Feng, X., Zhang, Z., Yang, H., Zhang, J., Chen, Z., Tang, J., Chen, X., Lin, Y., Zhao, W. X., Wei, Z., y Wen, J. (2024). A survey on large language model based autonomous agents. Frontiers of Computer Science, 18(6), Article 186345. https://doi.org/10.1007/s11704-024-40231-1
  14. Wang, X., Li, B., Song, Y., Xu, F. F., Tang, X., Zhuge, M., Pan, J., Song, Y., Chan, B., Ding, J., Li, J., Geng, H., Li, A., Yang, J., Li, M., Wang, Z., Yu, A., Yang, N., Tang, N., y Neubig, G. (2024). OpenHands: An open platform for AI software developers as generalist agents. arXiv. https://arxiv.org/abs/2407.16741
  15. Wu, Q., Bansal, G., Zhang, J., Wu, Y., Li, B., Zhu, E., Jiang, L., Zhang, X., Zhang, S., Liu, J., Awadallah, A. H., White, R. W., Burger, D., y Wang, C. (2023). AutoGen: Enabling next-gen LLM applications via multi-agent conversation. arXiv. https://arxiv.org/abs/2308.08155
  16. Xi, Z., Chen, W., Guo, X., He, W., Ding, Y., Hong, B., Zhang, M., Wang, J., Jin, S., Zhou, E., Zheng, R., Fan, X., Wang, X., Xiong, L., Zhou, Y., Wang, W., Jiang, C., Zou, Y., Liu, X., Yin, Z., Dou, S., Weng, R., Cheng, W., Zhang, Q., Qin, W., Zheng, Y., Qiu, X., Huang, X., y Gui, T. (2025). The rise and potential of large language model based agents: A survey. Science China Information Sciences, 68(2), Article 121101. https://doi.org/10.1007/s11432-024-4222-0
  17. Yang, J., Jimenez, C. E., Wettig, A., Lieret, K., Yao, S., Narasimhan, K., y Press, O. (2024). SWE-agent: Agent-computer interfaces enable automated software engineering. En Advances in Neural Information Processing Systems 37. https://doi.org/10.52202/079017-1601
  18. Yao, S., Zhao, J., Yu, D., Du, N., Shafran, I., Narasimhan, K., y Cao, Y. (2023). ReAct: Synergizing reasoning and acting in language models. arXiv. https://arxiv.org/abs/2210.03629
  19. Zhou, S., Xu, F. F., Zhu, H., Zhou, X., Lo, R., Sridhar, A., Cheng, X., Ou, T., Bisk, Y., Fried, D., Alon, U., y Neubig, G. (2024). WebArena: A realistic web environment for building autonomous agents. arXiv. https://arxiv.org/abs/2307.13854