The 2023 Agent Mania of AutoGPT and BabyAGI: Three Core Designs That Survived to 2026

On April 16, 2023, the 1994th issue in the Auto-GPT repository arrived with a title just five words long: "Gets stuck in a loop." A user had asked the agent to research how to register a company overseas. It ran the same Google search, got results, then ran the same search again. The report read: "It clearly succeeded in fetching Google results, yet it loops the same query." The issue was closed that September as stale, marked "not planned."

This little fossil comes from an extremely noisy month. Between late March and mid-April 2023, two open-source projects convinced half the internet that GPT-4 plus a while loop was the first draft of AGI. Most of what was built that spring is gone, but three of its designs survived—and they are running in the coding agents you used this morning.

The spring that rewrote perceptions in two weeks

On March 28, 2023, Yohei Nakajima published an article about a "task-driven autonomous agent," built on GPT-4, Pinecone vector storage, and LangChain. That code later became BabyAGI, whose README notes the whole script was trimmed to "140 lines: 13 lines of comments, 22 blank lines, 105 lines of code."

Two days later, on March 30, Significant Gravitas's Toran Bruce Richards released the Auto-GPT demo, describing it in a tweet as "an open-source experiment to turn GPT-4 into a fully autonomous AI." According to the timeline preserved by Know Your Meme, Andrej Karpathy tweeted on April 2 that the next frontier of prompt engineering was "AutoGPTs." On April 3, Auto-GPT topped GitHub's global trending list, and by April 12 it had passed 30,000 stars. Today the project repository, AutoGPT, has about 188,000 stars, and the original agent still lives in its classic/ directory.

The pitch for both was identical: enter a goal, the model breaks it into tasks, executes them one by one, generates new tasks based on the results, and keeps looping until the goal is reached—all without human intervention.

What actually happened on each loop iteration

BabyAGI's structure was minimal: three prompts and a task queue. The archived script pops the first task, combines it with context retrieved from the vector store, sends it into the execution prompt, stores the result, then generates new tasks through the task-creation prompt, and finally reorders the whole list with a prioritization prompt.

Reading BabyAGI's while loop condition makes the problem obvious. The loop ends when the task list is empty—and the list is filled by the very same model being asked "what should we do next?" The real script had no iteration cap and no cost cap, and its README warned that "running this script continuously can result in high API usage." More importantly, consider what result really was: in BabyAGI, the execution step was just a text completion call, with no tool invoked. The result of "researching something" was merely the model's own prose describing that research—and that prose then became the input for the next round of task generation. Information from the outside world never actually entered the loop.

Auto-GPT went further. Its v0.2.0 README listed internet search, file storage, and "long-term and short-term memory management" backed by Pinecone, Redis, or local JSON files, so it did touch the real world. But it still got stuck in loops. As Wikipedia summarizes, the developers' explanation was that the agent did not know what it had already done, so it repeated the same subtask endlessly.

The ReAct pattern is the key reference point for understanding these loop failures. ReAct was proposed by Shunyu Yao and others in the October 2022 paper "ReAct: Synergizing Reasoning and Acting in Language Models." The core idea is to have a large model alternate between a "reasoning trace" and "acting": the model first outputs a thought, then calls a tool (such as a Wikipedia search), receives the real returned result, and continues reasoning. Unlike BabyAGI's "execution step is just a text completion," every step in ReAct takes the real observation from the external environment as the input for the next step, so it naturally has error-correcting ability. The distinction to keep clear is this: BabyAGI's loop is "generate task—execute task—generate task," with the tasks invented by the model itself; ReAct's loop is "think—act—observe," with the boundaries of action defined by tools. The former is self-talk; the latter is dialogue with the environment. This difference is the fundamental reason why 2023's agents collectively fell into infinite loops, while later coding agents were able to run in production.

Why task-list self-prompting failed

In that spring's issue trackers and various analyses, three categories of failure reasons appeared over and over.

Lack of a real ground truth. A task list written, ordered, and marked complete by the model itself is a closed system—if the model thinks a task is done, it is done. Anthropic's December 2024 article "Building effective agents" pointed out the solution in one sentence: agents need to "get ground truth from the environment at each step." BabyAGI simply had no environment to ask.

Forgetting. Auto-GPT ran on GPT-4's 8K context window. In a commentary article on April 13, 2023, Jina AI's Han Xiao calculated the per-step cost assuming each action filled the context window. Memory did exist, but it was only a similarity search over past results, and in BabyAGI the query was the goal rather than the current task. An agent that cannot see its last ten actions will unhesitatingly execute the same action for the eleventh time—precisely the situation described in issue #1994.

Cost. In seeking sponsors, Auto-GPT's README mentioned that working on the project full-time could cost maintainers "up to $20 per day in API costs," and the disclaimer asked users to regularly check their OpenAI usage and set limits or alerts. At GPT-4's then-current prices ($0.03 per thousand input tokens and $0.06 per thousand output tokens), Xiao calculated about $0.29 per step, and a small task requiring roughly 50 steps would cost about $14. The article also quoted a user complaint: Auto-GPT "never completes a task, it always finds a reason to go deeper and do more research."

Context window is the technical prerequisite for understanding the "forgetting" failure. It refers to the maximum number of tokens a model can receive in a single call, including the system prompt, conversation history, tool results, and all other content. When GPT-4 launched, it offered 8K (roughly 6,000 English words) and 32K versions at different prices. When an agent executes dozens of consecutive steps, each producing tool output, earlier steps get pushed out of the window and can no longer be seen by the model, so the model "does not remember" what it has already done. The solution at the time was vector database retrieval: convert historical results into vectors for storage, and use similarity search each round to recall relevant snippets. But this recalls content that is "semantically similar," not content that "happened most recently," and it is nearly useless for temporal questions like "what did I do in the previous step?" This is the technical root of Auto-GPT repeatedly running the same search, and it is exactly the problem later long-context models and structured note-taking schemes had to solve.

Design one: tool loops with hard stop conditions

The loop itself survived; what changed was what entered it and the mechanism that let it exit.

This pattern predates the mania. The October 2022 ReAct paper had models alternate between reasoning and actions such as Wikipedia queries, with each step building on information already retrieved. By December 2024, Anthropic's definition of an agent had settled into "an LLM using tools in a loop based on environmental feedback," and it recommended "setting stop conditions (such as maximum iterations) to maintain control."

Claude Code's documentation describes its agent loop as gathering context, taking action, and verifying results, where "the information returned by each tool call feeds back into the loop." For a failing test, that means running the test suite, reading the error, modifying the code, and running the test again. The test runner is the real ground truth BabyAGI never had. For unattended runs, the CLI reference docs add hard stops: --max-turns exits with an error when the turn limit is reached, and --max-budget-usd stops the run when estimated spending hits the cap.

The model still decides for itself when it is done. The difference is that every step feeds back real observations, and the loop cannot escape the constraint of max_turns.

Design two: external memory, as plain files

Auto-GPT and BabyAGI correctly recognized that agents need memory beyond the context window, but they chose vector databases. Xiao argued at the time that this was overengineering: memory entries rarely exceed ten thousand, and since each GPT-4 call took about 10 seconds, the database was never the bottleneck.

The form that survived in coding agents is much plainer. Claude Code's memory documentation describes user-written CLAUDE.md files and automatic memories that Claude writes itself, both of which "load at the start of every conversation." Anthropic's September 2025 article on context engineering called this pattern structured note-taking: "agents regularly persist notes to memory beyond the context window," with Claude Code's todo lists and NOTES.md files as examples.

Task lists survived too, but their role changed. In BabyAGI, the list drove the agent's actions. In modern coding agents, the todo list is a note the agent keeps for itself and for you, while what drives the next action is the result returned by tools.

CLAUDE.md is the conventional project memory file for Claude Code, placed in the repository root, where users can manually write long-term constraints such as project conventions, build commands, and code style. It beats vector databases on three points: first, its content is human-readable, editable plain text, so when something is wrong you can fix it directly rather than re-embedding it; second, it loads in full at the start of each session and does not depend on the recall quality of similarity search; third, it is version-controllable and can be committed, reviewed, and rolled back along with the code. The accompanying "automatic memory" allows the model to proactively write curated factual notes during a run, but still commits them to disk as files. Together they form a concrete implementation of the pattern of "persistent memory beyond the context window"—essentially returning part of the decision about "what to remember" to humans and an explicit file system, rather than to an opaque retrieval mechanism.

Design three: human checkpoints

This design existed in Auto-GPT from the start, but it was hidden behind a skippable flag. The v0.2.0 README told users to enter "'y' to authorize a command, 'y -N' to run N commands consecutively." The same README stated that continuous mode was "not recommended. It can be dangerous and may cause your AI to run forever or carry out actions you would not usually authorize."

That y prompt is the direct ancestor of today's coding-agent permission systems. Claude Code's working documentation notes that starting with v2.1.283, interactive sessions launch in Auto mode by default: a background classifier reviews most actions and blocks risky ones rather than asking the user every time. Manual mode asks before file edits and most shell commands. acceptEdits allows edits to pass without asking, while plan mode allows exploration but not source-file modification.

File edits generate snapshots for rollback, and you can press Esc at any time to stop the loop and adjust direction. Anthropic's article defines the same principle for any agent: they "can pause for human feedback at checkpoints or when encountering blockers."

The evolution of permission modes reflects the trade-off between agent autonomy and safety. The y prompt of the Auto-GPT era was coarse-grained: either ask every time or let a whole stretch run continuously, with no gradient in between. Modern coding agents break this choice into multiple levels—for example, Auto mode uses a background classifier to score action risk, executing low-risk actions directly and blocking only high-risk ones; Manual mode confirms item by item; acceptEdits lets file edits through but still requires confirmation for shell commands; and plan mode allows read-only exploration without changing source code. These modes share one principle: build the "human power to stop" into the architecture of the loop, rather than relying on users to remember to manually add flags like --max-turns. Anthropic sums this up as agents pausing for feedback at checkpoints or when blocked, and it is also a key marker of the retreat from the "fully autonomous" narrative back to "supervisable automation."

What actually remained

The legacy of the 2023 mania was not AGI, but three design decisions that survived contact with practice: tool loops that replace self-evaluation with real environmental feedback, memory simplified from vector databases to plain files on disk, and a human power to stop preserved inside the loop. When you use a coding agent today—watching it run tests, read and write note files, and pause at a permission prompt waiting for you—you are in fact using the only survivors of that 2023 experiment.

One-line Summary

2023's AutoGPT and BabyAGI mania is gone, but three design decisions survived.

Paragraph Summary

The article revisits the agent mania triggered by Auto-GPT and BabyAGI between March and April 2023, noting that their advertised "goal-driven autonomous loop" failed in practice through infinite loops, forgetting, and runaway costs: task lists were self-written and self-evaluated in a closed loop without real environmental ground truth, and context-window limits caused repeated actions. It then traces three design decisions that survived the failure: an agent loop rooted in ReAct and centered on real tool feedback and hard stop conditions such as --max-turns and --max-budget-usd; external memory using plain files like CLAUDE.md and NOTES.md instead of vector databases; and a tiered permission system evolved from Auto-GPT's 'y' authorization prompt. The conclusion is that today's coding agents are built from the few survivors of the 2023 experiment.