CtrlK
BabyAGI is an open-source autonomous agent framework created by Yohei Nakajima in March 2023. It was one of the first publicly available systems to demonstrate how a large language model (LLM) could autonomously create, execute, and prioritize tasks in a continuous loop, working toward a user-defined objective without step-by-step human intervention. Built as a compact Python script using OpenAI's GPT-4 API, a vector database for memory, and the LangChain framework, BabyAGI became one of the most influential early experiments in the wave of AI agent development that swept through the AI community in 2023.
Despite its name, BabyAGI is not artificial general intelligence. Nakajima himself described it as "one of the first publicly available processes describing how to build a perpetually autonomous agent using available technology." The project's significance lies not in achieving AGI, but in demonstrating a simple, reproducible pattern for task-driven autonomy that inspired dozens of derivative projects and influenced the design of modern agent frameworks.
Yohei Nakajima is a venture capitalist and general partner at Untapped Capital, an early-stage venture capital firm he co-founded with Jessica Jackley in 2020. Before Untapped Capital, he spent over 15 years supporting early-stage startups through roles at Techstars and Scrum Ventures, working with global corporations such as The Walt Disney Company and Nintendo. He holds a Bachelor's degree in Economics from Claremont McKenna College (2009) and is based in Bellevue, Washington.
Nakajima is not a formally trained software engineer. He has no computer science degree and never worked as a professional developer. He built BabyAGI using AI tools to generate nearly all of the code, a fact he has spoken about openly. His approach to technology follows two guiding philosophies: "VC by day, builder by night" and "build-in-public," meaning he experiments with new technologies during evenings and weekends while sharing his progress publicly on social media.
The idea for BabyAGI emerged from the #HustleGPT movement on Twitter (now X) in early 2023, where people were experimenting with using ChatGPT as a virtual co-founder to help run businesses. Nakajima took this concept further and asked: what if an AI could operate as an autonomous "AI founder" capable of running a company without constant human intervention?
This intellectual exercise led him to prototype a system where an LLM could receive a high-level objective and then independently break it down into tasks, execute those tasks, generate new tasks based on results, and reprioritize the remaining work. The development process was remarkably fast. Nakajima completed the entire project, including the code, a research writeup, flowcharts, and social media content, in approximately three hours spread across two days, with GPT-4 handling much of the code generation and documentation.
On March 28, 2023, Nakajima published a blog post titled "Task-Driven Autonomous Agent Utilizing GPT-4, Pinecone, and LangChain for Diverse Applications" and shared it on Twitter. The post described the architecture and released the code as an open-source Python script. The response was immediate and massive. The tweet and associated GitHub repository went viral, accumulating millions of impressions on Twitter and tens of thousands of stars on GitHub (the repository has over 22,000 stars as of 2025).
Friends jokingly compared the project to AGI and Skynet. In one notable incident, Nakajima humorously tasked the agent with "creating as many paperclips as possible" (a reference to the paperclip maximizer thought experiment in AI safety). The agent independently generated a safety protocol as part of its task list, a response that caught the attention of the original author of the paperclip thought experiment.
The project led to speaking engagements at major events, including the inaugural TED AI conference in San Francisco in October 2023, where Nakajima spoke alongside figures such as Reid Hoffman, Ilya Sutskever, Andrew Ng, and Grammy award winner Oak Felder.
BabyAGI implements what is sometimes called a "task-driven autonomous agent" pattern. The system takes a high-level objective from the user (for example, "research the latest trends in renewable energy") and an optional initial task. It then enters a continuous loop where it executes tasks, creates new tasks based on results, and reprioritizes the task list. This loop repeats until all tasks are completed or a stop condition is reached.
The original implementation was deliberately minimal. The entire codebase was reduced to roughly 140 lines of Python (105 lines of code, 13 comments, and 22 blank lines). This simplicity was a deliberate design choice; Nakajima wanted the system to be easy to understand and build upon.
The core of BabyAGI consists of three specialized agents, each powered by LLM prompts:
| Agent | Role | How it works |
|---|---|---|
| Execution Agent | Completes tasks | Receives the current task and the overall objective. Queries the vector database for relevant context from previously completed tasks. Sends a prompt to the OpenAI API to generate a result. |
| Task Creation Agent | Generates new tasks | Analyzes the result of the just-completed task along with the overall objective. Generates a list of new follow-up tasks that are needed to advance toward the goal. Avoids creating duplicate tasks. |
| Prioritization Agent | Reorders the task queue | Takes the current task list (including any newly created tasks) and reorders them based on relevance, dependencies, and importance relative to the objective. Returns a numbered, reprioritized list. |
The loop operates as follows:
deque).The original BabyAGI used the following components:
| Component | Technology | Purpose |
|---|---|---|
| Language model | GPT-4 (via OpenAI API) | Task execution, creation, and prioritization |
| Vector database | Pinecone | Storing and retrieving task results as embeddings for context |
| Agent framework | LangChain | Structuring agent roles and enabling data-aware decision-making |
| Programming language | Python | Core implementation |
| Task queue | Python deque | Managing the ordered list of pending tasks |
Later versions of the original BabyAGI added support for alternative vector stores, including Chroma and Weaviate, as well as support for alternative LLMs including the Llama model family through Llama.cpp. The default model was changed to gpt-3.5-turbo to reduce API costs, since running GPT-4 continuously could become expensive quickly.
The vector database serves as BabyAGI's memory. Each time a task is completed, the task description and its result are converted into an embedding vector and stored. When the Execution Agent works on a new task, the system performs a similarity search against this memory to retrieve the most relevant past results. This gives the agent context about what it has already accomplished and learned, allowing each subsequent task to build on previous work rather than starting from scratch.
To run BabyAGI, users needed to configure several environment variables:
OPENAI_API_KEY: API key for OpenAIOPENAPI_API_MODEL: The model to use (default: gpt-3.5-turbo)PINECONE_API_KEY: API key for Pinecone (or configuration for an alternative vector store)PINECONE_ENVIRONMENT: The Pinecone deployment regionTABLE_NAME: Name of the table/index for storing task resultsOBJECTIVE: The high-level goal for the agentINITIAL_TASK: The first task to begin with (for example, "Develop a task list")After the original release, Nakajima developed a series of increasingly sophisticated variants, following an alphabetical animal-naming convention (Baby
BabyBeeAGI restructured the task management system with a more complex prompt that handled task list tracking, completion status, task dependencies, and tool assignment in a single consolidated agent. Key changes included:
The trade-off was slower execution and higher API costs due to the heavier reliance on GPT-4 for each operation.
BabyCatAGI modified BabyBeeAGI to improve speed and reliability. Notable changes:
BabyDeerAGI introduced two new capabilities:
BabyElfAGI introduced a Skills Class, a modular system that made it easier to create and register new capabilities ("skills") that the agent could use. This moved the architecture toward a more extensible, plugin-based design.
BabyFoxAGI, a modification of BabyElfAGI, introduced the FOXY method for self-improving task lists. After completing each task, the agent stored a "final reflection" summarizing what it learned. When starting new operations, the system retrieved the most relevant past reflection to guide its task planning. Over time, this allowed the agent to generate increasingly efficient task lists.
Additional features included DALL-E image generation, Deezer music player integration, Airtable search functionality, and a redesigned user interface that separated the chat interface from the task execution panel.
| Version | Key innovation | Notable feature |
|---|---|---|
| BabyAGI (original) | Task-driven autonomous loop | 140-line Python script with three agents |
| BabyBeeAGI | Web tools and improved task management | Web search and scraping; removed vector DB |
| BabyCatAGI | One-shot task creation | Mini agent as tool; multi-task dependencies |
| BabyDeerAGI | Human-in-the-loop and parallelism | User input during execution; parallel tasks |
| BabyElfAGI | Modular skill system | Skills Class for extensible capabilities |
| BabyFoxAGI | Self-improving task lists | FOXY method with stored reflections |
In September 2024, Nakajima released BabyAGI 2, a fundamental reimagining of the project. Rather than iterating further on the task loop architecture, BabyAGI 2 introduced a completely new concept: a self-building autonomous agent built on a "functionz" framework.
The core idea behind BabyAGI 2 came from a lesson Nakajima learned through the earlier iterations: "the optimal way to build a general autonomous agent is to build the simplest thing that can build itself." Instead of a predefined task loop, BabyAGI 2 stores, manages, and executes functions from a database, and the agent can load, run, and update these functions as it builds itself.
localhost:8080/dashboard for function management, dependency visualization, secret key management, execution logs, and trigger configuration.BabyAGI 2 is installable via pip install babyagi and uses Python decorators for function registration.
A companion project called BabyAGI 2o (the "o" standing for "open") focuses specifically on the self-building aspect. Unlike BabyAGI 2, which stores functions persistently in a database, BabyAGI 2o iteratively builds and registers tools at runtime to complete user-defined tasks. When it encounters a problem it cannot solve with existing tools, it creates new ones, breaks complex tools into smaller reusable components, and combines them. The goal is to eventually integrate this self-building capability with BabyAGI 2's persistent function storage.
Nakajima has been explicit that BabyAGI 2 is experimental and not meant for production use. He develops it solo during nights and weekends.
BabyAGI and AutoGPT emerged almost simultaneously in March-April 2023 and are often compared as the two foundational autonomous agent projects of that period. While they share the goal of LLM-driven autonomous task execution, they differ in scope and design philosophy.
| Feature | BabyAGI | AutoGPT |
|---|---|---|
| Release date | March 28, 2023 | March 30, 2023 |
| Creator | Yohei Nakajima | Toran Bruce Richards |
| Codebase size | ~140 lines (original) | Thousands of lines |
| Design philosophy | Minimal, educational, easy to understand | Feature-rich, production-oriented |
| GitHub stars | ~22,000 | ~170,000+ |
| Memory | Vector database (Pinecone/Chroma) | File system + vector memory |
| Tool use | Minimal in original; expanded in variants | Extensive (web browsing, file I/O, code execution) |
| Internet access | Not in original; added in BabyBeeAGI | Built-in from the start |
| Primary strength | Conceptual clarity; rapid prototyping | Breadth of capabilities; larger community |
| Best suited for | Research, education, experimentation | Operational automation, data workflows |
AutoGPT gained a larger following (over 170,000 GitHub stars) partly because it offered more built-in capabilities out of the box, including web browsing, file operations, and code execution. BabyAGI's strength was its conceptual clarity; the 140-line script made the core autonomous agent loop easy to understand, modify, and learn from.
Both projects demonstrated similar fundamental limitations: sensitivity to prompt engineering, difficulty diagnosing failures in the LLM reasoning chain, tendency toward repetitive loops, and high API costs from continuous LLM calls.
BabyAGI's impact on the broader AI agent ecosystem was substantial, particularly given the simplicity of its implementation.
The project spawned numerous derivative projects and forks, including:
BabyAGI's task loop pattern (execute, create, prioritize, repeat) became a foundational concept in the design of later, more sophisticated agent frameworks:
The academic community also took notice. BabyAGI was cited in dozens of papers on arXiv, and the task-driven agent pattern became a standard reference point in research on LLM-based autonomous systems.
BabyAGI, along with AutoGPT, played a significant role in popularizing the concept of AI agents in mainstream technology discourse during 2023. The projects demonstrated that LLMs could do more than answer single prompts; they could be orchestrated into systems that plan, execute, and adapt. This shift in thinking influenced both the open-source community and commercial AI development, contributing to the "agentic AI" trend that continued through 2024 and 2025.
Despite its influence, BabyAGI has well-documented limitations that apply both to the specific project and to the broader class of early autonomous agents.
Outside of demonstrations and experiments, the real-world utility of the original BabyAGI was limited. Many users found that direct interactive conversations with LLMs were more effective for their actual needs than setting up an autonomous loop. The system worked well for simple, well-defined objectives but struggled with complex or ambiguous goals.
The performance of all three agents (execution, creation, prioritization) depended heavily on the quality of their prompts. Small changes in prompt wording could produce dramatically different results, and achieving reliable behavior required extensive manual tuning.
Users frequently reported that the agent would fall into repetitive loops, generating the same or very similar tasks repeatedly without making meaningful progress toward the objective. The prioritization agent did not always prevent this, especially for open-ended goals.
When the system produced poor results, diagnosing the cause was difficult. Because the LLM acts as a black box within each agent, it was hard to determine where in the execute-create-prioritize chain the reasoning went wrong.
Continuous autonomous operation with GPT-4 could generate significant API costs. The documentation explicitly warned users about this, and the later default switch to gpt-3.5-turbo was partly motivated by cost concerns.
While the vector database provided a form of long-term memory, retrieval accuracy was imperfect. The system sometimes failed to retrieve the most relevant past results, leading to redundant work or loss of important context over long-running sessions.
BabyAGI lacked features expected in production software: error handling, observability, scaling mechanisms, security controls, and robust API integrations. It was, and remains, an experimental and educational tool.
The original BabyAGI repository was archived in September 2024 and moved to a separate babyagi_archive repository as a historical snapshot. The main yoheinakajima/babyagi repository on GitHub now hosts BabyAGI 2, the functionz-based framework.
As of 2025, the original repository has accumulated over 22,000 stars, 2,800 forks, and contributions from 75 contributors. The project is licensed under the MIT License. The codebase is primarily Python (66.5%), with HTML (19.7%), JavaScript (11.7%), and CSS (2.1%) for the dashboard.
Nakajima continues to develop BabyAGI 2 as a solo project on nights and weekends. He has acknowledged that pull request management has been slow and that a core contributor group may be assembled before broader collaboration is opened up. The project remains explicitly experimental and is not intended for production use.
BabyAGI's lasting contribution is conceptual rather than practical. The original 140-line script demonstrated that a surprisingly simple arrangement of LLM calls, a task queue, and a vector store could produce emergent autonomous behavior. This insight, that agent planning and execution could be decomposed into a small number of interacting components, influenced a generation of AI agent frameworks and research.
The project also demonstrated the power of building in public. Nakajima, a venture capitalist with no formal engineering background, built a globally influential open-source project using AI tools to write the code, shared it freely, and iterated in response to community feedback. This became a frequently cited example of how LLMs were lowering the barrier to software creation.
While the autonomous agent ecosystem has moved well beyond BabyAGI's original architecture, with frameworks like LangGraph, CrewAI, and AutoGen offering far more sophisticated capabilities, the fundamental task loop pattern that BabyAGI popularized remains visible in the DNA of modern agentic AI systems.