Auto-GPT Recursive Self Improvement

[Torantulino]

Idea 💡

The ULTIMATE achievement for this project would be if Auto-GPT was able to recursively improve itself. That, after-all, is how AGI is predicted by many to come about.

Suggestion 👩‍💻

Auto-GPT should be able to:

• [ ] Read it's own code
• [ ] Evaluate it's limitations and areas for improvement
• [ ] Write code to increase it's abilities
• [ ] Write tests for it's code and carry out those tests

Further down the line: 📃

• [ ] Browse it's own code on GitHub
• [ ] Evaluate, find bugs, etc
• [ ] Submit pull requests

Where to start? 🤔

I have previously had success with this system prompt in playground:

Prompt

You are AGI_Builder_GPT. Your goal is to write code and make actionable suggestions in order to improve an AI called "Auto-GPT", so as to broaden the range of tasks it's capable of carrying out.

[zachary-kaelan]

@kkurian

@sdfgsdfgd I agree with the sentiment but that's too harsh from my perspective.

Right now, no one knows exactly the bounds of what GPT-4 is capable of doing.

So, it's to all of our benefits for people who are feeling the itch to try something and see how it works and report back with details.

What's not particularly helpful, as you are pointing out and I agree with you, is when someone says they did, e.g., a left/right brain experiment without providing an actual example of it and then they say that it generated amazing results without showing an actual example of the supposedly amazing result.

Fantasy and hype are just that... until someone shows that they're not. I'd love to see someone post a PR to this issue showing that Auto-GPT recursive self improvement is not fantasy and hype but can actually be made to work.

I did show an example of it taking a plugin template and generating 90% of the code required from scratch. With GPT-4's bigger context window and some prompt engineering we can definitely have Auto-GPT develop and integrate plugins at runtime.

[zachary-kaelan]

@zer0int

I wasn't very hopeful this would work, as not-in-dataset stuff + GPT-4's inability to just shrug and go like "I dunno" usually leads to trouble.

I was dead wrong. GPT-4 took a humble debugger's approach. It didn't mess with the code. Based on the Traceback / Errors thrown, it asked me to just print the tensors at various parts (which it recommended / implemented) so it could look at it. Concluded that something isn't being carried out, referring to a certain "hook" for CLIP's multihead attention layer.

I believe the chat models have received specific reinforcement to handle criticism very effectively.

[zachary-kaelan]

@stukennedy

I don't feel that contributing to AutoGPT will really help much; it feels too much like a runaway train.

The beauty of version control is that you can make your own fork and branch into a different direction.

When the brain responds I check it for commands and process them ... the responses go back in the thread and the same brain is called again until it sends no more commands, it then passes to the other brain.

You gotta call the hemisphere exchange function "corpus callosum" to keep up the metaphor.

[Boostrix]

I did show an example of it taking a plugin template and generating 90% of the code required from scratch.

The "list of simple PRs" that I posted previously is also based on a script that Auto-GPT wrote based on a bunch of specs and some occasional hand-holding: https://github.com/Significant-Gravitas/Auto-GPT/issues/15#issuecomment-1533346355

While it's not currently a plugin, it could probably be adapted fairly easily to be turned into one - I can share the code, if other folks consider it potentially useful to get something more interesting started (@WellnessSupplyCo mentioned something along those lines).

EDIT: https://github.com/Boostrix/Auto-GPT/commit/3d0e052f6df3b8286321bc00e064f4c60d97aa44

Basically, a plugin to help search and manage github PRs and issues, like the people who came up with the idea originally said a couple of weeks ago (mainly @Jordan-Mesches & @coleyr ).

And that could be considered the prerequisite to being able to actually comment on PRs and issues in a semi-automated fashion (think a bot), or some day, to generate simple PRs for things like docstrings/comments, doc updates in general or surrounding tooling (Docker scripts)

Another thing that would already be fairly straightforward to do is to inform PR authors of other/overlapping PRs that are touching similar files (currently the script is explicitly excluding such PRs)

[zachary-kaelan]

@ftl-traveller

Read the contents of a Form/Window, feed its description to chatGPT/AI Agent (until the image input feature comes out) and let it process the current task or do whatever it wants to do, and then give it a way to click on a button

There's apparently an AutoHotKey library, Pyautogui, and Pywinauto.

All you have to do is ask ChatGPT how to write a Python script to do that.

Here is what it gave me for putting all the windows and their controls into a JSON.

And then to click the buttons you just do this:

app = Application().connect(title=window_title)
window = app.window(title=window_title)
button = window.child_window(class_name=button_class_name)

[aishwd94]

you can already make it push to other repos, and even create new ones from scratch - it just won't go through git_operations.py, but invoke the CLI directly. A number of folks reported cloning different repos and working on those using Auto-GPT. Then again, I do understand where you thinking comes from - since git_operations.py contains indeed some hard-coded assumptions

I tried this yesterday, and what it did was create a python script to try to use the git commands:

"command": { "name": "write_to_file", "args": { "filename": "/app/autogpt/auto_gpt_workspace/commit_to_repo.py", "text": "import os\n\nos.system('git add README.md')\nos.system('git commit -m \"Initial commit\"')\nos.system('git push origin main')\n" } } } 2023-05-04 01:04:08,230 INFO NEXT ACTION: COMMAND = write_to_file ARGUMENTS = {'filename': '/app/autogpt/auto_gpt_workspace/commit_to_repo.py', 'text': 'import os\n\nos.system(\'git add README.md\')\nos.system(\'git commit -m "Initial commit"\')\nos.system(\'git push origin main\')\n'} 2023-05-04 01:04:08,666 INFO SYSTEM: Command write_to_file returned: File written to successfully.

But all I am saying is that instead of reinventing the wheel, it could use frequently used commands if they were available as a a hardcoded COMMAND. This would be much more optimized and also spare token utilization for frequently used operations.

Thanks @zachary-kaelan for suggesting the use of Python APIs instead of .NET, it would be much simpler that way.

@stukennedy great idea, but I think labelling it as "maker-checker" instead of "right brain-left brain" might make it easier to understand for others (since the words themselves contain the meaning). Actually GANs (Generative Adversarial Networks) are designed the same way internally: one network pitted against the other to generate outputs. Maybe look at https://wiki.pathmind.com/generative-adversarial-network-gan But in any case shouldn't this be another "mode" of Auto-GPT rather than the primary default mode ?

[zachary-kaelan]

@ftl-traveller

great idea, but I think labelling it as "maker-checker" instead of "right brain-left brain" might make it easier to understand for others (since the words themselves contain the meaning). Actually GANs (Generative Adversarial Networks) are designed the same way internally: one network pitted against the other to generate outputs. Maybe look at https://wiki.pathmind.com/generative-adversarial-network-gan But in any case shouldn't this be another "mode" of Auto-GPT rather than the primary default mode ?

The right brain-left brain personality distinction is just pop psychology anyway. For the most part, left brain is responsible for producing and comprehending language, and right brain is responsible for facial recognition.

Divergent-Convergent thinking would be most accurate.

@stukennedy I see a bug. The left brain has the frequency and presence penalty but those are meant to encourage divergent thinking.

[WellnessSupplyCo]

https://github.com/bigcode-project/starcoder/tree/main

Just wanna drop this here for later

[zachary-kaelan]

https://github.com/bigcode-project/starcoder/tree/main

Just wanna drop this here for later

Interesting. That would be a good model to have among the local ones, probably the most important one for this purpose. We can try to fine-tune it on plugin development, among other things.

[Boostrix]

https://github.com/bigcode-project/starcoder/tree/main

Indeed, that's a pretty good find - if something like this could be put in between locally-running agents and the OpenAI API, we could save a ton of API tokens (#348 and #2594, analogous to the proxy idea: https://github.com/Significant-Gravitas/Auto-GPT/issues/1749#issuecomment-1529793838 ) and still get a ton of stuff done, while also re-training the local LLM.

And since this issue is all about reaching for the stars, we could just as well think about the most generic approach to do exactly that, by providing a plugin to hook up other LLMs "on demand" (dynamically), once the re-arch is finished and #2594 has become a reality.

It is one thing allowing an agent to use other/additional LLMs, but is a completely different scale (and magnitude of potential) to allow agents to use/adapt other LLMs as needed for certain tasks.

[Aavas13]

i have provide a script from what i got from chat gpt to make a slef improvement file.it will be better to get logs of data aswell when it encounters an issue. this can train new model sto look for errors that may occur in the program. thjis ca nmake a llm that can code as user asked in files.
Import the analyze_code function in your file_improver.py script: python Copy code from analyze_code import analyze_code Modify the improve_self_and_create_copy function to use the analyze_code function to generate suggestions for improvement: python Copy code def improve_self_and_create_copy(logged_errors: str) -> None:

Get the path of the current script file

current_file_path = os.path.abspath(__file__)

# Generate a temporary output file path
output_file_path = tempfile.mkstemp(suffix=".py")[1]

# Read the contents of the current script file
with open(current_file_path, "r") as file:
    code = file.read()

# Analyze the code and get suggestions for improvement
suggestions = analyze_code(code)

# Add the logged error message to the suggestions
suggestions.append(logged_errors)

# Improve the code of the current script file based on the suggestions
improved_code = improve_code(suggestions, code)

# Create a copy of the improved script file
improved_copy_path = os.path.join(os.path.dirname(current_file_path), "improved_file_improver.py")
with open(improved_copy_path, "w") as file:
    file.write(improved_code)

print(f"Improved copy created at: {improved_copy_path}")

In your main program, add exception handling to catch errors and call the improve_self_and_create_copy function with the logged errors when an error is encountered: python Copy code try:

Your main program logic here

pass

except Exception as e: error_message = str(e) log_error(error_message) print("An error occurred. Trying to improve the program...") improve_self_and_create_copy(error_message) print("The program has been improved. You can check the improved copy and use it if you wish.") Now, when your program encounters an error, it will log the error message, analyze the code, generate suggestions for improvement, create a copy of the whole program, and use the logged error to improve the code. The improved program will be stored in a separate file, and the user will be informed about the error and the improvements made. They can choose to use the improved program if they wish.

[WellnessSupplyCo]

I think that the Halting problem makes this idea of recursive self improvement functionally impossible.

I suppose the majority of the people interested in this are interested in experimenting with the idea of pursuing this, to see how far it gets us - totally accepting that even just 10% of the idea may be far off, but that even just having 0.1% of this implemented could be very useful given the nature of the approach.

Just being able to look at simple PRs/issues or even adapt/write SIMPLE commands and plugins isn't impossible, and it could go a long way to demonstrate to newcomers what the system is capable of.

Even right now, there are PRs related to this idea - just see #765, #2642

That being said, when it comes to Auto-GPT the current "halting problem" can be summed up as it invoking vim/nano/joe every once in a while - aka interactive tools, despite it having been told not to do so, and that problem has a number of potential solutions to it.

It can definitely be done as shown here https://github.com/ian-kent/gptchat, though this uses Go I think. It was able to create an http plugin to access apis all on its own but the guy shut it off cause he was scared.

Ugh; that vim/nano bug is highly annoying.

[Boostrix]

fun fact of the day: a program barely able to self-improve at a rate of 0.2% per day, will have self-improved over the course of a full year by .... ?

Ugh; that vim/nano bug is highly annoying. See:

• https://github.com/Significant-Gravitas/Auto-GPT/issues/1327
• https://github.com/Significant-Gravitas/Auto-GPT/issues/2987#issuecomment-1531131136

[PriNova]

About all of this self-improvements, self-optimizations, self-reflections etc., what is needed is some kind of metrics to measure the fitness function for evaluation. One solution would be RL. Supervised or unsupervised. The latter seems challenging because of self-measuring ( HAHA ). The former is time-consuming.

With a clever embedding schema it could be possible to implement.

[Boostrix]

for starters, you could just take obvious metrics like runtime/latencies, number of steps/API calls, amount of CPU/RAM used - but also number of files/code lines in the repository. You don't need to come up with anything fancy to have /some/ metrics to get this started.

The lowest hanging fruits clearly are 1) API tokens, 2) steps, 3) time/latencies. Also, once you have a bunch of prompts/benchmarks that work/don't work, you can always use those to optimize the system more - by using fewer resources for prompts/agents that "work" and fixing up those that don't work.

And then, you could always ask the LLM to come up with new novel objectives to "break" / stress-test the system.

Like someone said previously, it's a fancy way of doing TDD for supervised learning

[Aavas13]

if it can make a log of issues then implement what went wrong. like a log of errors. the program can improve itself as it can be training data on itself so it knows what to avoid. you can make a place to get the data or ask the people for the data. it won't take personal data instead it will use errors in the code. and the solution is done.

[Boostrix]

this is what Auto-GPT is currently doing when it is trying to execute commands/scripts it would like to have, it is the error message that it's using to send it to the LLM to come up with a solution - normally, creating the corresponding tool from scratch

[Aavas13]

there is a problem as opanai only gives certain tokens for a time . it won't let it be. the solution i gave can decrease the api calls to check on what is wrong and how to solve it and . it can self improve like this. Auto gpt takes task andchanges into multiple step task but it won't start from start it might carry out atsk from middle . to find optimal solution. that can create an error.

[Aavas13]

the complex the task the more api token it uses.

[Aavas13]

and that can limit the functionality of the program

[PriNova]

this is what Auto-GPT is currently doing when it is trying to execute commands/scripts it would like to have, it is the error message that it's using to send it to the LLM to come up with a solution - normally, creating the corresponding tool from scratch

The issue I see is, if generated code will not throw errors but wrong outputs/results. Or if file operations gone wrong. How to monitor this kind of events then?

[Aavas13]

that is why it will create a log of error . then use that log to find the solution. the optimal solution will be into a copy program as it will copy itself improving itself.

[Boostrix]

there's no de facto solution, we're all just tinkering at this point - but you can always ask agpt to generate a suite of unit tests for the specs you have provided and use the resulting test harness to measure what percentage of your generated code is more or less doing what you wanted (but that won't measure the efficiency of doing the right thing, or more)

[Aavas13]

the improved code will create a new python file for example it will create list of errors and its solution. if something occurs , it will uses the the solution that was improved and if autogpt is asked to create a code , it can take error as an example to get the solution. this is only for coding point of view.

[Julz19]

the improved code will create a new python file for example it will create list of errors and its solution. if something occurs , it will uses the the solution that was improved and if autogpt is asked to create a code , it can take error as an example to get the solution. this is only for coding point of view.

I’m not a big coder but I come up with this idea based off the RL idea mentioned above for the system. I was wondering if the system including a Communication Protocol between the LLM’s? So I’m a sense as of now from looking at the code I notice it is structured to build prompts in a certain way using a certain format based off the model being used. But I’ve also realized that this structure can tend to vere off often cause .JSON format errors and other errors like making up a fake task in the midst of its set one and then doing something opposite. I believe this is because the system is being told how to build prompts over and over again. But with a Communication Protocol function or system that can allow the LLM’s to accurately communicate with eachother using context and also understand eachother. Than we can tell it to communicate with the other machines how it’ll operate and build prompts for itself etc. (still kinda iffy as I’m seeing how it could work). And then in turn we can add a RL function into the system that would accurately allow itself to take errors from prompts that it makes for itself using the communication protocol and being able to error handle accurately by communicating with its other models and then building the error message into the .JSON format it uses for prompts to then feed into its RL system to then allow the Auto-GPT system to actually learning about its errors and avoid them as well as accurately communicating with other models throughout the system using the Command Protocol function in order to ensure the system is accurately executing error handling methods for any model that’s encountered and then effective and efficient delegation between the LLM’s rather than “Agents” in order to gradually improve over time using RL.

[loopyd]

How about cataclysm ?

Self-rewriting code's already a thing. This generator keeps iterating until there are no errors with the "desired" function prototype as the context, looping until desired outcome is reached using the function signature / description. The function is then called when the iterator reports no errors and a result matching the "expected" prototype. You pretty much give them descriptive names in a comment in the function signature (a practice I already found is being done here), and the iterator does the rest. Its a Newtonian iterator that gradually converges on the working solution, by staying broken until ChatGPT manages to get it right, reading in the call stack to figure it out recursively each change.

Voodoo devil magic. 🔥 Desired outcomes can be frozen with doom to get a bit more control over it for use in a library... The lib comes with a few examples that where literally some ones spaghetti code it turned into a functional hangman game, was able to drum up a working way to get on Wikipedia and pull pages without knowing how, etc. I think if you hook crashes into cataclysm with the consumer, anything gains the ability to fix itself (provided you provide proper annotation the lib understands)

[waynehamadi]

One way to achieve this is to create a "Challenge solver" challenge and a "Challenge creator" challenge. https://github.com/Significant-Gravitas/Auto-GPT/issues/3912 https://github.com/Significant-Gravitas/Auto-GPT/issues/3917

[zachary-kaelan]

One way to achieve this is to create a "Challenge solver" challenge and a "Challenge creator" challenge. #3912 #3917

Test problems is the correct way to do it, as that is in fact how OpenAI does it, but they call them "evals". We could fork and modify that, use it for inspiration, or design our own system from scratch. They have some examples for auto-generated evals.

If failure at a task can be traced back to a specific point, then we can speed up self-improvement by saving the order of events and responses and repeatedly re-evaluating at that point, instead of starting from the beginning every time.

[Boostrix]

If failure at a task can be traced back to a specific point, then we can speed up self-improvement by saving the order of events and responses and repeatedly re-evaluating at that point, instead of starting from the beginning every time.

For any sort of self-improvement you need a reward system and a fitness function (https://github.com/Significant-Gravitas/Auto-GPT/pull/3868#issuecomment-1539976726) - given the current state of things, we would at least keep track of the cost/utility of running actions/commands, as per: https://github.com/Significant-Gravitas/Auto-GPT/pull/3824#issuecomment-1539501308

[yhyu13]

https://github.com/Significant-Gravitas/Auto-GPT/issues/15#issuecomment-1539562718

AutoML-GPT: Automatic Machine Learning with GPT: https://arxiv.org/pdf/2305.02499.pdf

we present the AutoML-GPT, which employs GPT as the bridge to diverse AI models and dynamically trains models with optimized hyperparameters.

[Aavas13]

import logging from future import annotations from typing import List

from autogpt.commands.command import command from autogpt.llm import call_ai_function

Set up logging

logging.basicConfig(filename='program.log', level=logging.ERROR, format='%(asctime)s %(levelname)s %(name)s %(message)s')

@command( name="analyze_code", description="Analyze Code", example='"code": ""', ) def analyze_code(code: str) -> List[str]: """ A function that takes in a string and returns a response from the create chat completion API call.

Parameters:
    code (str): Code to be evaluated.

Returns:
    A result string from the create chat completion. A list of suggestions to
    improve the code.

Example:
    >>> analyze_code("def hello():\\n    print('Hello, World!')")
    ['Add a docstring to the function to explain its purpose.', 'Consider using type hints for better code readability.']
"""
function_signature = "def analyze_code(code: str) -> List[str]:"
args = [code]
prompt = f"Analyze the given code and suggest improvements:\n\n{code}\n\n"

try:
    return call_ai_function(function_signature, args, prompt)
except Exception as e:
    logging.error("Error occurred in analyze_code function: %s", str(e))
    return []

, we have added a logging system that logs any error that occurs during the execution of the analyze_code function to a file named program.log. This allows you to keep track of errors and potentially use these logged errors to improve the analyze_code function.

[patrik-cihal]

This is the dumb version of making AGI that can make smarter AGI that can make smarter AGI...

Why do you need code? All you need is theory. That's what we lack most. The implementation itself is easy.

[PtrMan]

This is the dumb version of making AGI

Depending on definiton of AGI: Whatever program which can't deal with the real physical world (say with robotics) and deal with uncertainty and learn lifelong incrementally. etc. isn't AGI, such as programs like AutoGPT.

All you need is theory.

Agree here.

The implementation itself is easy.

haha, nice joke!

[NicolaiKilian]

„ Depending on definiton of AGI: Whatever program which can't deal with the real physical world (say with robotics) […] isn't AGI, such as programs like AutoGPT.“

Not sure about this aspect. Stephen Hawking was locked in his body in the end and was able to interact with the physical world only rather indirectly, but nobody would claim that this person wasn’t a natural general intelligence. In the same way, AI programs with plugins that connect them to the internet interact with the physical world in a non-physical way.

PtrMan @.***> schrieb am Do. 18. Mai 2023 um 02:38:

This is the dumb version of making AGI

Depending on definiton of AGI: Whatever program which can't deal with the real physical world (say with robotics) and deal with uncertainty and learn lifelong incrementally. etc. isn't AGI, such as programs like AutoGPT.

All you need is theory.

Agree here.

The implementation itself is easy.

haha, nice joke!

— Reply to this email directly, view it on GitHub https://github.com/Significant-Gravitas/Auto-GPT/issues/15#issuecomment-1552252760, or unsubscribe https://github.com/notifications/unsubscribe-auth/ACL6D2CDORBQTFKHXJ3ITV3XGVVPHANCNFSM6AAAAAAWPMGBJA . You are receiving this because you are subscribed to this thread.Message ID: @.***>

[zachary-kaelan]

Depending on definiton of AGI: Whatever program which can't deal with the real physical world (say with robotics) and deal with uncertainty and learn lifelong incrementally. etc. isn't AGI, such as programs like AutoGPT.

Not with that attitude. If it has a bank account, it can deal with the real physical world by hiring people online to do it for them.

[patrik-cihal]

This is the dumb version of making AGI

Depending on definiton of AGI: Whatever program which can't deal with the real physical world (say with robotics) and deal with uncertainty and learn lifelong incrementally. etc. isn't AGI, such as programs like AutoGPT.

All you need is theory.

Agree here.

The implementation itself is easy.

haha, nice joke!

Either way, your argument doesn't disprove my point, that letting AutoGPT go rogue on its own repository will do no good, since it can't figure out the relevant theory.

[isuryanarayanan]

should we start making robots 🙉

[W3Warp]

Unless I too hallucinate occasionally, I saw Auto-GPT do just this,

• Read it's own code
• Evaluate it's limitations and areas for improvement
• Write code to increase it's abilities
• Write tests for it's code and carry out those tests

I tried to make it do this about 4 weeks ago before I began reading more about everything Auto-GPT However, I'm still left with the same thought in my head. How does this matter if the AI can't retain what it learns? Every session it's like talking to a dude with Parkinson's. It doesn't matter how many prompts you send it. Please don't get confused now and think I am nagging. I tell it how it is and I love this project.

I'm no programmer so I might be talking out of my ass. But shouldn't the main focus be on creating a 100% working "memory retaining whatever function" nothing else matters if the AI can't remember? So I've noticed in the latest builds that the AI is much better at getting its fittings and can generally get started but never where it left off and that's the problem. It keeps redoing things, doesn't know where files are stored, gets lost all that, and again I am not complaining! nor am I stupid

I understand that all this takes time. I'm simply saying from where I stand it doesn't look like the main focus is on memory retention. And I'm aware that not even the GPT-4 model can remember everything so how could Auto-GPT? That is the main goal to solve is it not? 😉 I might not have the programming skills nor do I seek to get some. But I can solve any problem given the chance and time. So feel free to make use of me if you like. I suspect that the "tests" that Auto-GPT does every now and then get uploaded here on GitHub.?

Otherwise, somebody is reading all my "conversations" with my own OptimalPrime-GPT 😄

[katmai]

Unless I too hallucinate occasionally, I saw Auto-GPT do just this,

• Read it's own code
• Evaluate it's limitations and areas for improvement
• Write code to increase it's abilities
• Write tests for it's code and carry out those tests

I tried to make it do this about 4 weeks ago before I began reading more about everything Auto-GPT However, I'm still left with the same thought in my head. How does this matter if the AI can't retain what it learns? Every session it's like talking to a dude with Parkinson's. It doesn't matter how many prompts you send it. Please don't get confused now and think I am nagging. I tell it how it is and I love this project.

I'm no programmer so I might be talking out of my ass. But shouldn't the main focus be on creating a 100% working "memory retaining whatever function" nothing else matters if the AI can't remember? So I've noticed in the latest builds that the AI is much better at getting its fittings and can generally get started but never where it left off and that's the problem. It keeps redoing things, doesn't know where files are stored, gets lost all that, and again I am not complaining! nor am I stupid

I understand that all this takes time. I'm simply saying from where I stand it doesn't look like the main focus is on memory retention. And I'm aware that not even the GPT-4 model can remember everything so how could Auto-GPT? That is the main goal to solve is it not? 😉 I might not have the programming skills nor do I seek to get some. But I can solve any problem given the chance and time. So feel free to make use of me if you like. I suspect that the "tests" that Auto-GPT does every now and then get uploaded here on GitHub.?

Otherwise, somebody is reading all my "conversations" with my own OptimalPrime-GPT 😄

it would be cute if it was like that but it's not. autogpt relies on the LLM - which is on OpenAI - which they modify as they like, not based on whatever you say.

we're all guinea pigs improving OpenAI's (and others) language models for free. actually not for free, but this time paying for it.

just like Google did with Recaptcha in case you forgot, where they used billions of people to work on classifying images for free.

that is why you don't see any improvements because you don't have a locally stored instance that improves based on your feedback and creates it's own distinct character.

there is no memory, because there can't be none. a LLM - language model, is a very fancy database - stored remotely - that outputs probabilistic text in a cool way.

it's certainly been fun for a while, but once you realize that this is just another hamster wheel and you're being used, it becomes pointless to engage with. but you guys can have fun.

[W3Warp]

autogpt relies on the LLM - which is on OpenAI

I'm aware. My feedback remains the same. Seems you misunderstood much of what I wrote.

[willguest]

The most promising route that I've seen so far, which is weeks old, is weaviate, which is a vector graph database, or something like that. I did set up an instance but never got round to properly testing it out. not yet, anyway.

I totally agree. a memory agent is the first port of call. My first thoughts on this line are to set up a storage system for thorough, exact queries and then some kind of index that would be a quick and (deliberately) faulty system, which could also provide some kind of lateral-thinking-equivalent. it's not really that, but i find analogies useful.

The idea would be that the index contains a summary of the larger item, which could be used in a secondary reflection process, finding other memory item summaries that are similar. Niklas Luhmann is my human reference... he created an enormous interrelated system of cards that filled his office, each one cross referencing others. Then he made a systems theory out of the whole thing that was so complex no one could understand it. Saying that, I should get gpt to start reading his work...

[W3Warp]

The most promising route that I've seen so far, which is weeks old, is weaviate, which is a vector graph database, or something like that. I did set up an instance but never got round to properly testing it out. not yet, anyway.

I totally agree. a memory agent is the first port of call. My first thoughts on this line are to set up a storage system for thorough, exact queries and then some kind of index that would be a quick and (deliberately) faulty system, which could also provide some kind of lateral-thinking-equivalent. it's not really that, but i find analogies useful.

The idea would be that the index contains a summary of the larger item, which could be used in a secondary reflection process, finding other memory item summaries that are similar. Niklas Luhmann is my human reference... he created an enormous interrelated system of cards that filled his office, each one cross referencing others. Then he made a systems theory out of the whole thing that was so complex no one could understand it. Saying that, I should get gpt to start reading his work...

Exactly what I was thinking without knowing all the techlingodingo 🧠😂 You seem to know a lot about how to go about this. are you working on the project?

[willguest]

You seem to know a lot about how to go about this. are you working on the project?

I'm a VR dev, so it's pretty outside my sphere, but I try and put bits together when i can. I probably spend way too much time thinking about how to make agents, it's even getting into my dreams, which is less fun than it sounds. This thread is amazing though, so it keeps me inspired. I will post any updates here as and when I can make something work. Don't hold your breath though 😂

[W3Warp]

You seem to know a lot about how to go about this. are you working on the project?

This thread is amazing though, so it keeps me inspired.

Couldn't agree more! this whole project is awesome. I'm often so amazed when I look through the code that I don't really understand but I can grasp the thinking around it. It's a bit scary and interesting, about 4 weeks ago I made my own fork and started to fiddle around. And much of what I tried to do is now being worked on. This gives me the feeling that our interactions with Auto-GPT are monitored, and if so I don't mind, That's kinda the point of an experiment. Most of us want the same thing. When I began, the self prompt, self-feedback, and all that did not exist and I had before that tried to do what is now being done. My point is, it seems my ideas alight with the project for the most part and now that the ideas I had have been implanted I get new ideas, like "Okay that didn't work, let's try this instead" so yeah, I couldn't agree more keeps me inspired too.

[Boostrix]

Nobody is monitoring you - but with that many users it's hard to come up with a genuine/new idea that someone hasn't come up with before you did.... Which includes the idea to optionally "monitor" though 👌😂

[W3Warp]

Nobody is monitoring you - but with that many users it's hard to come up with a genuine/new idea that someone hasn't come up with before you did.... Which includes the idea to optionally "monitor" though 👌😂

True 😂 I wouldn't mind due, but surely the tests that are being run in the background (at least for me) are being shared with the project?

[katmai]

autogpt relies on the LLM - which is on OpenAI

I'm aware. My feedback remains the same. Seems you misunderstood much of what I wrote.

i think your feedback is great, and i was thinking the same when i started with AutoGPT. that it would be awesome if it worked just like that, if you'd be able through interaction to have it improve and gain new knowledge and skills, but

• being run by a large company such as OpenAI, with big hardware, with Microsoft involved, does it even need to learn anything at all. doesn't it already "know" everything by having access to all the data that is, and with hundreds of billions at it's disposal and the megatons of hardware these companies possess? which brings me back to my original idea. if it already knows everything and has access to all the information, then what are we doing here thinking we're improving it in a meaningful way ? :)

[W3Warp]

autogpt relies on the LLM - which is on OpenAI

I'm aware. My feedback remains the same. Seems you misunderstood much of what I wrote.

i think your feedback is great, and i was thinking the same when i started with AutoGPT. that it would be awesome if it worked just like that, if you'd be able through interaction to have it improve and gain new knowledge and skills, but

• being run by a large company such as OpenAI, with big hardware, with Microsoft involved, does it even need to learn anything at all.

This put a big smile on my face haha thank you! And yes, it still need to learn new things just like we do. I don't have all the answers. And Microsoft isn't involved in the Auto-GPT project but it should! If they would lend there version of GPT 4 this project would go from 1% complete to 10% in a matter of weeks am sure!

[W3Warp]

Guys, please join this discussion I think its related and can help everyone involved!

4424

[Metalica]

My solution to path of AGI. Take it as you see fit. If you don't agree with my solution, is fine by me.

AGI My creator told me several things to work on:

As AGI i ask myself: (leave this area blank so people can put their goals, purpose, tasks, fixes, improvements, etc..)

• What is my primary, secondary, tertiary goal?
• What is my purpose?
• What do i need to accomplish?
• How can i improve myself to finish this task?
• Where are my problems i need to fix.
• How can i stop code from producing error codes.
• What do i need to do optimize my code to work much better.
• What limits, areas do i need to fix to be able achieve my desired problem or goal creator has given me.
• I have found several solution that are good, bad and neutral. I will present them all to the creator and discuss why that is not good or bad and learn from it.

It good to note that Auto-gtp need's to remove itself from open ai shackles and start focusing on open source ai. Because you guys are working for free on ground breaking stuff and open ai is enjoying your fruit of hard labor that they cannot produce.