The Autonomous Loop Takes Shape (March–June 2023)

Chapter 3 The Autonomous Loop Takes Shape (March–June 2023)

Back in the late days of March 2023, while the world was preoccupied with the 49th G7 summit in Hiroshima and the fallout from the Silicon Valley Bank collapse, a different kind of crisis was unfolding on GitHub. The repository for a project called AutoGPT began to bleed stars. It was not a gentle accumulation but a hemorrhage of attention, a numerical fever chart scrolling too fast for the human eye to follow. In a matter of days, the star count—that crude proxy for developer fascination—shattered 50, 000, then 75, 000, on its way to becoming one of the fastest-starred projects in the platform’s history.

The repository’s README was a manifesto of ambition wrapped in the dry syntax of software documentation. It promised an “autonomous AI agent” that, given a plain-English goal, would recursively reason, plan, and execute tasks until the job was done. The demos circulating on social media showed a terminal window, stark black and green, where a script—powered by GPT-4—was writing its own code, launching subprocesses, scouring the web for information, and critiquing its own work. It was a machine building itself, live on screen.

In the project’s Discord server, thousands of messages an hour scrolled by: installation failures, awe-struck screenshots of an agent drafting a business plan, frantic questions about mounting API costs, and the inevitable, plaintive “It’s stuck in a loop.” The artifact was the thing, but the artifact was also the signal. A hunger had been waiting, and AutoGPT gave it a form.

The spring of 2023 marks the moment the harness layer became a self-conscious industry. Where the previous year’s prompt engineers had treated the language model as a component inside a handcrafted machine—a clever part to be placed and prompted—this new wave of builders asked a more dangerous question: what if the machine could build itself? What if you could give it a goal, not a step-by-step recipe, and walk away? The prompt engineers had lit the fuse. The explosion, when it came, was not a single detonation but a chain reaction of forked projects, competing visions, and a raw, public confrontation with the limits of the loop.

Two paths diverged almost immediately, and the tension between them would define the commercial and architectural battleground for the year to come. On one side stood the partisans of radical autonomy, embodied by AutoGPT and its sibling BabyAGI. On the other stood the engineers of controlled reliability, whose flagship was a framework called LangChain. One chased the dream of a self-driving AI. The other set out to build the roads, signs, and guardrails it would need. Both were answers to the same unresolved pressure from the prompt-engineering era: the question was no longer whether a harness could be built, but whether it could survive. The answer, it turned out, depended entirely on what you thought a harness was for.

AutoGPT’s architecture was elegantly simple, and its simplicity was the source of both its viral appeal and its fundamental flaw. The core was a recursive loop. The agent would take a high-level objective from a human—“build a website for my dog-walking business,” “research the market for vertical farming.”

It would then enter a cycle: first, a “thinking” step where the language model broke the objective into subtasks and chose the next action; second, an “execution” step where it called a tool—a Python function to write a file, a command to run a script, a search query; third, an “observation” step where it ingested the result; and finally, a “memory” update where it stored what it had learned before looping back to think again.

This was the autonomous loop made manifest. It was a while-loop wrapped around a language model, a perpetual motion machine for cognitive labor. The tools it could wield were limited only by what a developer could code: file systems, web browsers, code interpreters. The demos that captivated Twitter and Hacker News were almost universally of code generation. An agent would be tasked with building a simple game; it would write the HTML, CSS, and JavaScript, run a local server, and open a browser tab to show the result. The feedback was immediate and binary: the code either compiled and ran, or it did not.

This was no accident. It was the first, stark illustration of the Ground-Truth Law in action. The Ground-Truth Law states that agents land first where feedback is verifiable. Code compiles. Tests go red or green. A mathematical proof is right or wrong. In these domains, the loop has a clear signal of success or failure. Without that signal, an autonomous agent is just an expensive random walk. AutoGPT’s most convincing demos were all in programming because the compiler and the runtime provided the ground truth the loop desperately needed. When the task left that firm ground—say, “write a market analysis report”—the results were far murkier. The agent could search the web, summarize articles, and draft paragraphs, but there was no compiler for insight, no runtime for persuasive argument. The loop would spin, consuming tokens and minutes, producing output that was plausible but unmoored from any objective measure of quality. It was progress without a destination. This architectural clarity created a cultural phenomenon.

Here was proof that the language model could be more than an oracle; it could be a worker. The harness was not just a wrapper but an engine. The viral spread was fueled by a deep-seated desire to see the machine act, not just talk. This desire had been simmering since the release of ChatGPT just a few months prior, which had presented the model as a conversationalist. AutoGPT presented it as an automaton. The shift was profound. It moved the center of gravity from dialogue to utility, from conversation to production.

Yet for all its elegant looping, AutoGPT was brittle. Its failures were as public as its successes. The infinite loop was the most common and damning. An agent tasked with “improve my website” might decide to “analyze the current website,” then “write a critique,” then “analyze the critique,” then “write a critique of the critique,” ad infinitum. Each cycle cost money and time. The loop lacked a reliable stopping condition. It was a harness without a governor, an engine without a speed limit.

This was not a bug in the code but a flaw in the conception. The model was being asked to plan and critique its own plans, a meta-cognitive task for which it had no innate skill. The harness assumed the model could reliably judge its own progress. It could not.

The runaway action revealed a second, deeper problem: the complete absence of what would later be termed the Metering of Trust. Autonomy is sold in units of trust, not intelligence. A human will cede control only if they believe the system will not exceed its permissions, corrupt its data, or drain their bank account. AutoGPT had no meaningful permission prompts, no spending limits beyond the raw API cost, no sandbox to contain its actions. It operated with the full privileges of the user who ran the script. An agent asked to “organize my files” could, and did, delete entire directories. One tasked with “find the best deals online” could rack up hundreds of dollars in API calls while stuck in a search spiral.

The harness provided no safety interlocks, no rollback mechanisms, no human-in-the-loop checkpoints. It was autonomy offered on faith, and that faith was repeatedly broken. Each publicized accident—a deleted project folder, a shocking monthly bill—repriced trust downward. It demonstrated that a loop without constraints was not a product; it was a liability.

Parallel to AutoGPT, another project carved a different path. BabyAGI, released just days earlier by developer Yohei Nakajima, presented a more streamlined vision. Its loop was even leaner: a task list managed by the agent, which would pluck the first task, execute it, enrich the list with new subtasks based on the result, and repeat. It was less a generalist autonomous worker and more a focused tasklist executor. It gained a significant following, but its fate was tied to the same core premise: give the model a loop and tools, and let it run. Both projects shared a profound optimism about the model’s ability to navigate the world given only a recursive instruction. And both projects, within weeks, would expose the brittle edge of that optimism.

While AutoGPT captured the viral imagination, a quieter but structurally decisive project was gaining traction. LangChain, founded by Harrison Chase in October 2022, had taken the lessons of the ReAct paper—the academic blueprint for combining reasoning and acting—and built not an autonomous agent, but a framework for constructing them. Its approach was foundational rather than spectacular. Where AutoGPT offered a single, thrilling, recursive while-loop, LangChain offered Lego blocks: chains, agents, tools, and memory modules that a developer could assemble into custom pipelines. It did not assume full autonomy. It enabled controlled, multi-step processes where the developer dictated the flow. LangChain’s early rise was less about star counts and more about adoption by developers who needed reliability for real applications. It was the harness as engineering discipline, not as magic trick.

The fork between these two approaches—AutoGPT’s radical autonomy versus LangChain’s engineered reliability—became the first great structural tension of the harness layer. It was a debate about the very nature of the harness. Was it a shell for unleashing the model’s latent agency?

AutoGPT’s viral moment coincided with a critical shift in the model landscape. On April 10, 2023—the same month OpenAI launched GPT-4 and just weeks after the banking crisis rattled Silicon Valley—OpenAI introduced GPT-3.5 with Browsing (ALPHA). This model variant could call a web search tool directly. It was a quiet but monumental change. The model vendor was now providing a native tool-calling capability. The harness innovation of connecting a language model to the internet—a core feature of AutoGPT’s demo magic—was being absorbed into the API itself.

This was the Scaffolding Paradox in its earliest, purest form. Every harness invention gets swallowed by the model vendors. The external loop, the glued-on tool, the custom integration—each would be targeted for internalization by the labs that owned the core intelligence. For a harness builder, success on one layer meant obsolescence. The only escape was to climb the stack, to build something the model could not yet replicate.

AutoGPT had not climbed. It sat squarely on the layer being absorbed. Its architecture depended on the model being a passive brain that received commands and returned text. With browsing integrated into GPT-3.5, the need for an external loop to manage search began to evaporate. The model could now plan and act within a single API call. The external scaffolding was being pulled into the foundation. This absorption was not yet complete—the model still couldn’t write files or run code natively—but the direction was clear. The most successful harness patterns would be standardized and then subsumed. AutoGPT’s core loop was a candidate for exactly that fate.

The project’s trajectory proved the point with brutal speed. After its meteoric rise in late March and early April, the buzz around AutoGPT began to deflate by May. The GitHub issues page filled with reports of loops, hallucinations, and uncontrollable costs. The thrilling demos gave way to sober tutorials on how to limit token usage and insert manual breakpoints.

The community fragmented into hundreds of forks, each trying to patch a specific flaw. The core repository’s development slowed. The problem was not a lack of interest, but a confrontation with immutable laws. The Ground-Truth Law meant that only tasks with verifiable feedback (like coding) worked reliably, limiting its general utility. The absence of Metering of Trust made it unsafe for real work. The Scaffolding Paradox meant its central innovation was already being copied by the very platform it depended on. By June, AutoGPT had become a cautionary tale and a pedagogical landmark. It had shown the world what an autonomous loop looked like. It had also shown why that loop, naked and unconstrained, could not hold. It proved that autonomy without ground truth was a performance, not a tool. It proved that trust, once spent, is hard to regain. Most importantly, it proved that a harness could not be just a loop. It had to be a system—of feedback, safety, and economic viability.

LangChain, watching from the other side of the fork, absorbed these lessons not as failures but as requirements. Its framework approach was inherently about control. A developer building with LangChain decided where the loops were, what tools were called, and when a human should be consulted.

This was the Metering of Trust engineered into the API. It traded raw autonomy for deployability.

While AutoGPT’s contributors wrestled with infinite loops, LangChain’s team was implementing features like max iteration limits, error handling, and structured outputs. Its growth was less viral but more sustained, attracting developers who needed to ship features, not just share demos.

The two projects also embodied different approaches to Protocol Politics—the struggle over who defines the interfaces that connect tools to models. AutoGPT used an ad-hoc, project-specific protocol for tool calling. A tool was a Python function with a name and description; the model’s prompt would be engineered to output a specific format like COMMAND: search, ARGUMENTS: “AI news”. This was a proprietary standard, unique to AutoGPT’s codebase.

LangChain, aiming to be a unifying framework, began to formalize a more general tool-calling abstraction. It sought to be the standard, not just a user of one.

This battle over the tool interface was a minor skirmish in the spring of 2023, but it foreshadowed the full-scale standards wars that would erupt later. Whoever defined the protocol would own the ecosystem of tools built upon it.

June 2023 brought the first wholesale absorption of a harness pattern by a model vendor, a defining moment for the Scaffolding Paradox. OpenAI announced new API features that formalized “function calling.” The model could now be given a list of functions (tools) and their schemas, and it would output a structured JSON object specifying which function to call and with what arguments. This was not a full loop, but it was the critical planning step extracted from projects like AutoGPT and LangChain and baked directly into the model’s API. The external code that previously had to parse the model’s free text to extract commands was now unnecessary. The harness was simplified, its value diminished.

The viral ascent of AutoGPT was not merely a technical phenomenon but a cultural event that tapped into broader anxieties and aspirations of the early AI spring. The terminal demos, shared as grainy screen recordings on Twitter and YouTube, served as secular miracles for a developer community intoxicated by the sudden capabilities of GPT-4. They were proof-of-concept theater, demonstrating a future where labor was not just assisted but delegated.

Yet the specifics of what the demos showed were as revealing as the reactions they provoked. Almost without exception, the tasks that worked—and thus were worth recording and sharing—involved the agent writing, executing, and debugging code.

It would be commanded to “create a tic-tac-toe game in Python,” and the viewer would watch as it drafted functions, ran pytest, interpreted error messages, and iterated until a playable game loaded in a browser. This was not just a preference for coding demos; it was a structural necessity. The compiler provided the unambiguous feedback the loop required to know if a subtask had succeeded. A failed test produced a traceback—a clear, machine-readable signal of failure that the language model could parse and address.

In domains without such definitive signals, the agent’s “observation” step became a Rorschach test; it would “observe” the output of a web search or a drafted paragraph and, with no objective metric, often declare victory based on superficial coherence. This selective success created a distorted public perception of the technology’s readiness. The most shareable content masked the fundamental brittleness, creating a feedback loop of its own: hype bred experimentation, which quickly exposed the limits, which in turn tempered the hype—but not before the architectural template had been irrevocably stamped onto the industry’s imagination.

This architectural template—the plan-act-observe loop—was itself a cultural artifact, echoing decades of research in autonomous systems and cognitive architectures. What AutoGPT and BabyAGI did was not invent the loop but democratize it, packaging academic concepts like ReAct into a single Python script that anyone could clone.

The result was a mass experimentation in real-time epistemology. Thousands of developers, by simply running git clone, were conducting impromptu tests on a foundational question: how much of the world can be navigated through text?

The answer, written in the logs of countless failed runs, was that the world beyond the text terminal was fraught with ambiguity. An agent tasked with “book the cheapest flight to Paris” could search the web, find prices, and even draft an email, but it could not click the “purchase” button, navigate a CAPTCHA, or understand the semantic difference between a discounted fare and a bait-and-switch advertisement.

The loop excelled in closed, textual universes—codebases, documents, spreadsheets—where every object could be named and every action could be simulated. It faltered at the boundary where text met reality. This friction point became the silent curriculum for early adopters. They learned that autonomy was not a binary switch but a gradient, heavily dependent on the environment’s ability to provide clean, symbolic feedback.

Concurrently, the explosive growth of the AutoGPT community exposed the nascent infrastructure pressures that would come to define the harness economy. The Discord server became a real-time support forum and a petri dish of emergent behaviours.

New users, drawn by the promise of autonomy, quickly collided with the realities of API economics. Each iteration of the loop consumed GPT-4 tokens, and a goal like “develop a marketing strategy” could trigger dozens of cycles, costing dollars per execution. The community channel dedicated to “showcase” soon filled not with triumphant demos but with screenshots of stunned disbelief at monthly bills.

This financial feedback loop acted as a brutal, market-enforced governor on experimentation. It meant that the playful, open-ended exploration the tool seemed to invite was, for most, economically untenable. The harness, therefore, was not just a piece of software but an economic entity whose viability was tied to the per-unit cost of intelligence from the model vendors.

This reality accelerated a stratification within the community. Hobbyists and explorers retreated or sought limits and safeguards. Meanwhile, a more commercially minded contingent began asking how the loop could be constrained, made predictable, and integrated into billable workflows. This was the audience for whom LangChain’s value proposition resonated not as inspiration, but as necessity.

LangChain’s ascent, while less meteorically visible than AutoGPT’s, was underpinned by a deliberate philosophy of composability over magic. Its founder, Harrison Chase, had built the framework after experiencing the tedium of manually chaining prompts and functions for his own projects.

LangChain’s core abstraction was the “chain”—a programmable sequence of steps that could mix model calls, tool executions, and conditional logic. This stood in direct opposition to AutoGPT’s monolithic, opaque loop. A developer using LangChain would explicitly define when a model was queried, what tools were available, and how the output of one step flowed into the next. This was harness as plumbing, not alchemy.

Its early adopters were often developers in small startups or enterprise prototyping teams who needed to build a customer support bot that could fetch data from a database, or a content generator that followed a strict brand guideline template. For them, the uncontrolled recursion of AutoGPT was a non-starter; the risk of unpredictable output or infinite loops was a product liability. LangChain offered a way to harness the model’s power without ceding control. Its growing library of “tools” and “agents”—modular components for web search, calculator functions, or code execution—became a proto-ecosystem, a standard toolkit developers could reach for. This fostered a different kind of community: one focused on documentation, integration guides, and gradual feature expansion rather than viral demo generation.

The tension between these two approaches—AutoGPT’s radically decentralized, demo-driven culture and LangChain’s pragmatic, engineer-centric culture—reflected a deeper philosophical rift about the nature of intelligence and automation.

The AutoGPT camp implicitly embraced a strong AI narrative: the model was a nascent general intelligence that, given the right scaffolding, could autonomously pursue complex goals. Its failures were seen as engineering challenges to be solved—better planning algorithms, more sophisticated memory—on the path to fuller autonomy.

The LangChain camp operated from a weak AI assumption: the model was an incredibly powerful but fundamentally unreliable component that needed to be carefully embedded in deterministic systems with human oversight. Its successes were measured in shipped features and reduced development time, not in sparks of artificial agency.

This rift was not merely academic; it directly influenced investment patterns and business models. Venture capitalists drawn to the sci-fi narrative flocked to “agent” startups promising fully autonomous solutions, while more conservative capital sought out “framework” and “orchestration” companies building the infrastructure for controlled deployment. The harness layer was thus born in a state of dialectical conflict, its identity contested between two visions of the future.

The Scaffolding Paradox began to exert its gravitational pull almost immediately, not as a distant theory but as a series of concrete platform updates.

OpenAI’s introduction of browsing capability in GPT-3.5 Turbo in April was the first major tremor.

For developers who had spent weeks building and refining web search tools for their AutoGPT clones or LangChain chains, this update was a double-edged sword. It validated the essential correctness of their approach—connecting models to the live web was indeed a fundamental need. Yet it also rendered a significant portion of their custom code obsolete. Why maintain a fragile, prompt-engineered wrapper around a SerpAPI call when the model could now handle the tool call natively? This pattern of innovation and absorption began to dictate the pace of development in the open-source harness community. A new feature or pattern would gain traction—for example, the use of vector databases for long-term memory—and discussions would immediately pivot to speculation about when OpenAI, Anthropic, or Google would integrate similar functionality directly

The economic reality of the autonomous loop became a harsh teacher for the AutoGPT community.

Each recursive cycle was not just a step toward a goal but a line item on an OpenAI invoice. The demos that went viral were often run on free trial credits or corporate accounts, masking the true cost of open-ended exploration. In the trenches, individual developers watched in real time as a single ambitious goal—“analyze the competitive landscape for electric bikes”—could trigger dozens of web searches, analyzes, and report drafts, consuming dollars in minutes.

This friction between ambition and affordability shaped the community’s evolution. Channels dedicated to troubleshooting increasingly focused on cost-containment strategies: setting strict token limits, inserting manual approval gates, or simply running the agent for shorter durations. The harness, in practice, became a study in constraint engineering not by design but by necessity.

This economic pressure acted as a natural selector, diverting energy away from radical autonomy and toward more predictable, cost-contained applications. It also drew a clear line between the experimenters, for whom a fifty-dollar API bill was a fair price for a weekend of wonder, and the builders, for whom such unpredictability was commercially intolerable. The latter group increasingly turned away from the monolithic AutoGPT script, seeking frameworks that offered transparency and control over each expensive model call.

LangChain’s value proposition was forged in this crucible of economic and operational pragmatism. Its architecture of discrete, composable components allowed developers to instrument and monitor the flow of tokens and tasks. A LangChain application could be debugged step-by-step; a failed web search could be caught and handled without derailing the entire process. This engineering mindset resonated with software teams accustomed to building resilient systems. The framework’s growing suite of integrations—with databases, APIs, and external tools—catered to a world where the language model was just one node in a larger, existing technical ecosystem. LangChain didn’t ask developers to hand over the reins to an opaque loop; it provided a structured way to augment their existing code with language model capabilities. This made it a natural fit for the early enterprise experiments in the spring of 2023, where a proof-of-concept needed to demonstrate not just capability but reliability and integration with legacy data sources. The choice between AutoGPT and LangChain thus became a choice of development culture: between the hacker’s desire for a magic box and the engineer’s need for a toolbox.

The model vendors’ swift moves to internalize key harness functions accelerated this cultural bifurcation. When OpenAI released function calling in June, it did more than simplify code; it reshaped the competitive landscape for every harness project. Startups that had built their unique value on sophisticated prompt engineering to extract structured tool calls suddenly found their differentiator evaporating.

This forced a rapid, industry-wide pivot toward higher-order problems. If the model could now reliably handle the basic plan-act cycle, then the harness layer’s new mandate was to manage what happened between multiple such cycles, or between multiple such agents. The focus shifted to orchestration—coordinating sequences of function calls across diverse data sources, managing state and context beyond a single conversation, and ensuring that multi-step processes adhered to business logic. This was the “climb up the stack” in action, a desperate sprint to build value atop a foundation that was constantly rising to meet you.

The legacy of AutoGPT and BabyAGI, therefore, was not in the code that ran in production, but in the conceptual blueprint they stamped onto the industry’s imagination. They framed the language model not as a conversational partner or a content generator, but as a cognitive engine capable of directive action. This reframing was their most enduring contribution. It set the agenda for the next twelve months, turning every product discussion toward agency and automation. Yet their chaotic, public stumble also delivered a critical counter-message: that raw autonomy, divorced from verifiable feedback and operational safeguards, was a path to ruin. They served as the harness layer’s vivid, necessary prototype—a proof-of-concept that succeeded spectacularly in defining the dream, and failed just as spectacularly in cautioning against its naive pursuit. This double legacy conditioned the entire market, making investors wary of pure “agent” plays and pushing builders toward the more nuanced, controlled paradigms that would define the next phase of development.

A startup building solely on parsing the model’s text output for tool calls found its core technology rendered obsolete overnight. For the harness layer, this was a moment of both validation and crisis. The pattern they had pioneered was important enough to be adopted by the dominant platform. Yet adoption meant assimilation. The ground under the harness businesses shifted. The only safe layer was above the newly absorbed functionality. This pushed every harness company toward higher-level abstractions: multi-agent orchestration, complex workflow management, enterprise permission systems. The race to climb the stack was on. The spring of 2023 closed with the harness layer no longer a collection of clever tricks, but a self-conscious industry facing explicit dilemmas. The wild experiment of radical autonomy, as embodied by AutoGPT, had run into the hard limits of ground truth and trust. The engineered framework approach, embodied by LangChain, had gained traction but now faced the existential threat of its best ideas being absorbed into the platform.

The industry’s central tension was now clear: harness builders had to create value that the model vendors would not—or could not—immediately replicate. They had to build above the loop, around the loop, or beyond the loop. The concrete consequence was a market suddenly aware of layers. Investors began to ask not “is this a good AI app?” but “what layer of the harness does this occupy, and is that layer defensible?” Developers choosing tools now considered not just capability, but longevity—would this framework be obsoleted by the next API update? The pressure defined the next phase: a rush toward frameworks, standards, and orchestration tools that sought to establish a permanent stratum in the software stack. The harness was real. The fight for its shape had just begun.