open-sourcing "babyagi-2o" 🫠

the simplest self-building general autonomous agent that builds and uses new tools as needed

📃 174 lines of code
🔁 single llm loop starting with three tools:
🛠️ create_or_update_tool (dynamically loaded)
📥 install_dependencies
🛑 task_completed (to exit loop)

github/replit👇 here is the github:
github.com/yoheinakajima/…

here is the replit:
replit.com/@YoheiNakajima…

ooooh yess i got this working in 244 lines of code

- single llm loop with three tools
- installs required packages
- creates new tools and loads it for itself dynamically
- uses the tools to handle user request

in this case, i asked it to scrape techmeme:

iter 1: install 'requests'
iter 2: install 'beautifulsoup4'
iter 3: create_tool (error'd)
iter 4: create_tool (worked)
iter 5: use new scrape_techmeme tool
iter 6: write summary

task completed!
😮 ohhh... it's less code but can do the same thing* ditto can... it just created a create_directory tool and so on...

*almost the same - it can't create a flask app because it accidentally initiates the flask app and kills the loop. but it can write multi-file apps.

introducing "ditto"
the simplest self-building coding agent

📄 ~500 lines of code
🛠️ can build multi-file apps
🔁 a simple LLM loop with 5 tools

github/replit/more below 👇 to jump right into it, here's the @github: github.com/yoheinakajima/…

here's the @replit: replit.com/@YoheiNakajima…

when you run the app, you'll be welcomed with this simple form.

describe the app you want and click "submit"

okay, i did a thing…

here’s babyagi 2 - a weird Python framework for building a self-building autonomous agent

- stores and executes functions from a database
- auto logging (as graph)
- built-in dashboard & chat playground
- prototype self-build functionality

wanna see? 👇 friendly reminder: babyagi is a personal side project being shared publicly. i am not a dev, never studied cs, this is not secure, not meant for production, and meant for playing/as inspiration for developers.

A helpful autonomous agent has access to all the tools you need - and nothing more. But we all have different needs, changing all the time, so...

what we need is a self-building autonomous agent.

Here, I'll describe the 3 levels of self-building autonomous agents: Before we start, this is Level 0.

A library of functions built by human developers that the AI has access to. The agent is not building its own functions.*

*tools, skills, api calls, are all just functions

here friends, i open-sourced it: prettygraph



at 201 lines of code (69 in back, 132 in front), it's just a quick hack i did for myself to test this UIgithub.com/yoheinakajima/… if you're interested in a web app, you can try out (which doesn't have highlights, but has more robust knowledge graph building).

the repo for instagraph is here: instagraph.ai
github.com/yoheinakajima/…

look at this pretty little text-to-knowledge graph ui

great to see everyone at AI rabbithole event today!

as promised, here's my deck with abbreviated narrative.

(video was recorded, will share when available) agents agents agents!

40+ agent related github projects today with 500+ stars, 90% of which are less than a year old.

fascinating! the left and right images are built with the same agent log data (last 100 logs).

- left: each log is a unique node
- right: bundled edges/nodes by the function type of the log

result on right let's me easily see most used paths and functions.

Refactored the code and you can visually see the changes by comparing the two graphs!

version 1 of auto-generate graph of actions taken by the agent

system_chat_handler_advanced is our chat interface endpoint, which used load_skill_description to find and pick the find_similar_files skill to find a relevant skills, which used the generate_embeddings skill to embed the input. then used generate_text_completion to generate the response filtered out the common functions used by the front-end so it shows me the logs that are most relevant to check

Been talking lots about knowledge graphs and LLMs, specifically for autonomous agents, recently.

Organized some thought here if you want to dig in 👇

KG 🤝 LLM

🧵 (a thread) For those not familiar, knowledge graphs are a type of data representation in the form of nodes (objects) and edges (relationships) and looks like this.

25 files across 9 nested folders with functions that depend on each other, cleanly organized

created by AI based on auto-generated file descriptions which currently shrink 14k+ tokens (full code) down to about 6k tokens*

*this include param description for each function which I don't need for this (that's for later), so this could shrink to much less. (~15% of full code) as my projects got larger, i realized i first needed an ai that can understand my big projects so it can help me without messing up

hence working on reading, traversing, and condensing the code

Open-sourcing "MindGraph", a proof of concept starter kit for building and querying against an ever-expanding knowledge graph with natural language!

- multiple input types
- simple interface
- basic search/RAG against knowledge graph
- easily extendable with integrations
- basic database swapping

GitHub in 🧵 Quick background is that I paused on BabyAGI work after the BabyFoxAGI mod because I felt I was missing some pieces.

Went deep on knowledge graphs (KGs) and released Instagraph () which lets you build, merge, and edit KGs....instagraph.ai

Some Qs to ask when building an autonomous agent, around topic of…

Task planning and mgmt
Task execution and routing
Tool usage and learning
Memory and knowledge
Self improvement
UI/UX (input/output)
Auth and tool auth
Personalization & generalization
Security

Let’s dig into each of these shall we? 👇 Task planning & management

How is your agent generating and tracking tasks? Hand crafted (you are chaining them)? CoT (one at a time)? Task list (BabyAGI style)? Knowledge graph? Are you using past tasklists to help generate new ones?

Okay @tldraw is pretty addicting



1) draw your UI
2) use text to describe
3) highlight (i.e. draw box around), and
4) click the blue "make real" on top right) makereal.tldraw.com
super quick prototypes that don't actually work, but give you the sense of what it would feel like to play with? count me in!

The Assistants API is awesome, had to build something...

Open-sourcing "GPTvsGPT" 🕵️🕵️
(109 lines of code)

A simple template to have two AI Assistants converse. What's exciting is the ability to extend these with retrieval, data, and custom functions.

GH/Replit in thread 🔽 As you saw above, you set the parameters for two Assistants, then feed that in with the topic, and number of messages you want.

You'll get something like this:

famous songs as knowledge graphs

obsessed w this new learning tool

need some time before sharing the tool but in the meantime… any requests?

Introducing BabyFoxAGI 👶🦊🤖

Newest mod of @babyAGI_ with:

🔂 Self-improving task lists (FOXY method)
💬 Novel Chat UI w parallel tasks
🛠️ New skills (DALLE, Airtable, etc)
📄 It’s own README

Breakdown, Github, Replit 👇 BabyFoxAGI is mod of BabyElfAGI, in a series of mods w the naming of Baby<animal>AGI in alphabetical order:

🐝Bee, 🐱 Cat, 🦌 Deer, 🧝 Elf, 🦊 Fox

You can find the thread introducing BabyElfAGI here: x.com/yoheinakajima/…

Introducing the "FOXY method" 🦊

Our new approach to self improving auto agents, introduced in the next mod of @babyagi_.

Dig in shall we? 👇 How it works:

With FOXY (Final Output eXamination from "Yesterday"), we do a final reflection on the output of each run, and use this to guide future runs, pulling most relevant reflection using a similarity search, paired with a decay mechanism to prioritize recent reflections.

Meet BabyElfAGI!

Biggest update to the OG @babyAGI_, finally broke out into multiple files:

🛠️ Skills Class allows for easy skill creation
📝 Dynamic Task List example w vector search
🔍 Beta Reflection Agent
🖇️ Can read and write own code (yes it can write new skills and task… https://t.co/mN6jHZydwqtwitter.com/i/web/status/1…
Skills Class

New “Skills” (prev called Mini Agents) are what the task execution agent uses to complete tasks. Enabled in main files handles APIs centrally.

Each skill can be as simple as a simple API call, or a long script w many functions.