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.

[Torantulino]

Perhaps this is what we're looking for #11?

Anyone want to weigh in?

[Torantulino]

Here's what GPT4 has to say about this issue:

Based on the Github issue posted, I understand that the ultimate goal is to have Auto-GPT recursively improve itself. In order to achieve this, we can start by implementing basic features such as reading its own code, evaluating limitations and areas of improvement, writing code to increase its abilities, and testing its own code.

Here's a plan to implement these functionalities:

1. Read its own code: You have already implemented basic file operations like read_file. Auto-GPT can use this function to read its own code.

2. Evaluate its limitations and areas for improvement:

• Implement a function evaluate_code that analyzes code in terms of code optimization, redundant code, and missing features.

3. Write code to increase its abilities:

• Implement a function improve_code that takes suggestions from the evaluate_code function and generates new code based on those suggestions.

4. Write tests for its code and carry out those tests:

• Implement a function write_tests that creates test cases for the existing code.
• Implement a function run_tests that runs the generated test cases and checks if the code passes those test cases.

I will now provide an outline for implementing these functions in Auto-GPT's code:

### Evaluating code

def evaluate_code(code: str) -> List[str]:
    # Analyze the given code and return a list of suggestions for improvements
    pass


### Improving code

def improve_code(suggestions: List[str]) -> str:
    # Generate new code based on the suggestions provided
    pass


### Writing tests

def write_tests(focus: Optional[str] = None) -> str:
    # Generate test cases for the existing code, focusing on specific areas if required
    pass


### Running tests

def run_tests(test_code: str) -> str:
    # Execute the test cases and return the test results
    pass

These functions can be integrated into the execute_command function by adding new command cases for each of them:

# In execute_command()
elif command_name == "evaluate_code":
    return evaluate_code(arguments["code"])
elif command_name == "improve_code":
    return improve_code(arguments["suggestions"])
elif command_name == "write_tests":
    return write_tests(arguments.get("focus"))
elif command_name == "run_tests":
    return run_tests(arguments["test_code"])

Once these functionalities are implemented, Auto-GPT will be one step closer to recursively improving itself. With further improvements, Auto-GPT could potentially browse its own code on GitHub, evaluate it, find bugs, and submit pull requests.

[alreadydone]

Those empty functions remind me of AI functions :)

By the way, I'm very excited to see many of my thoughts being implemenented here.

[Torantulino]

Ah yes! That AI Functions guide you linked is exactly how I was thinking of implementing those, if I do it that way.

[Torantulino]

@alreadydone I love this, thanks for the suggestion!

[Torantulino]

Threw together a simple implementation of this since it's such a powerful idea!

[marcelosousa]

I'm working on this problem on a separate experiment. Would love to chat if you're interested - at the moment, I'm working with genetic algorithms to understand which variant/mutant of the code is more performant - there are a lot local maximums depending on how you set it up.

[PolarBean]

This is a really cool idea! Do you think you could make the AIs logs public as it self improves? Either in the repo or elsewhere. I would be very interested in seeing how it plans and evolves.

[MrSaad]

So this is it huh... The singularity begins in a GitHub thread

[Silthus]

How about trying to drive the self improvement by utilizing test driven development (TDD).

In a recent paper they showcased how greatly GPT-4 can improve it's results by reflecting on its own mistakes.

So the idea is to have it:

1. start with a single test that fails
2. make the test pass (iterate X times until successful - self reflecting on the code)
3. optimize the code by refactoring if necessary, but not allowed to modify or fail the existing tests
4. write the next small incremental test that moves towards the given requirements

What do you think?

This could also be used for any kind of code generation.

[ryanpeach]

This really should take a research driven approach. We would need a metric to base the "improvement" on. I'd focus on making a framework, and then let people in their branches use this framework for research. Proven research gets merged in.

[patruff]

I wrote an improvement that speeds up the bot significantly. If you write a function called alwaysNo that just returns "n" and then you use that as input, it just exits the program super fast! No money spent!