daveshap/openai_agent_swarm

HAAS = Hierarchical Autonomous Agent Swarm - "Resistance is futile!"

openai_agent_swarm's Issues

BOUNTY: Take a stab at building a tool maker agent

Open bounty! Someone please take a stab at using the OpenAI Assistant to create a tool building assistant.

BOUNTY: Experiment and submit PR for multi-agent collaboration

Take inspiration from ChatDev and AutoGen. Probably keep chat local between multiple agents for now. Too early for Discord and other platforms.

Goals:

• Establish best practices for agent-to-agent communication
• Figure out how to quickly instantiate groups of agents with arbitrary configurations and tasks (e.g. spin up teams on the fly)
• Document results, share with collective

AutoGen as an infrastructure

I found this repo from microsoft/autogen#575
It's a very interesting effort and I'd like to see if autogen could help as a generic infrastructure to support inter-agent conversations.
@gagb @LeoLjl @IANTHEREAL are working hard to support openai assistant agent (will finish in a day or two), which is very similar to some agents autogen already has offered for months.

p.s. I'm a fan of your videos.

I built HAAS

Dave,

I recently developed a functional model of the Hierarchical Autonomous Agent Swarm (HAAS) system, which operates as intended but hasn't yet produced Artificial General Intelligence (AGI). Each agent in this model learns continuously post-deployment, possesses defined goals, and maintains autonomous decision-making capabilities. The specialized agents demonstrate incremental improvements in their respective tasks and share these enhancements for future agent development. However, the evolution towards AGI remains elusive. The Master Agent is not evolving into a higher state of awareness.

While I am enthusiastic about the HAAS concept, seeing it as an effective framework for managing and deploying cooperative agents for management, control, and specialization, I have reservations about its capacity to facilitate the emergence of AGI. My current hypothesis, which may well be incorrect, is that AGI could emerge when the base model crosses a certain threshold, potentially related to parameter size. Once AGI is achieved, it might surpass the need for a system like HAAS.

I might be missing how the swarm dynamics of HAAS contribute to the goal of AGI. If that's the case, I'm open to insights. If AGI is defined merely as the ability to understand, learn, and apply intelligence across diverse tasks, then perhaps we have already attained it. However, my interpretation of AGI is a form of super-intelligence, self-managing and far surpassing human capabilities, and will not be constrained by our existing frameworks or oversight.

Your videos and projects have always inspired me, so please continue your excellent contributions. It's clear to me that with the current technology, we can achieve almost anything we can envision, super-intelligence possibly being the sole exception.

On the other hand, there's a strong possibility that super-intelligence, could be within reach using the tools currently available, given sufficient resources (most likely the culprit) and the inherent ability to self-improve. We have already achieved the ability to improve post-deployment, along with nearly limitless memory capacity. Issues of context and temporal coherence seem to be effectively addressed by systems akin to HAAS.

Minor - Typo - Good First Issue

https://github.com/daveshap/OpenAI_Agent_Swarm/blob/020b44e2f1cc9c767abf5ea3acb69696e394f4ec/agents/tool_maker/chat_manager.py#L63C9-L63C32

also

OpenAI_Agent_Swarm/agents/tool_maker/chat_manager.py

Line 183 in 020b44e

interface_assistant, response = self.handle_fucntion_request(

unit_manager.py will not run

trying to get the unit manager to run, but get an error that chat_manager.py can't find the API_KEY.
Made an .env file and tried different locations for it, to no avail.
Also set an export in .bash_profile not working either.

What am I doing wrong?

BOUNTY: Capture Best Practices and Architectural Decisions

We still have only a few Wiki pages. This is a great start and a few people have jumped in to help. Here are some ideas for new wiki pages:

• Overall Swarm Architecture
• Communication Theory and Best Practices
• Technology Stack Proposals

BOUNTY: Test current code base and comment on open PRs (Saturday 11/11)

There have been several PRs merged as well as several open PRs. I'd like the collective to take a look at them and test them, comment, etc. Make sure everything is working, and abiding by best practices.

BOUNTY: create a discord connector or orchestrator

The idea is simple: let's try using discord as an arena for agent communication

BOUNTY: Discussion moderator

Responsibilities:

• Optimize signal to noise ratio
• Organize Discussions tab
• Surface primary topics

BOUNTY: Continue developing Tool Making, Tool Use, and add Tool Refinement/Testing

There's been great work on tool making and tool using, as well as the new tool library idea. The next step is to test and refine tools.

Make it so.

GPTS example agent wont save when entered into openai gpts

https://github.com/daveshap/OpenAI_Agent_Swarm/tree/main/agents/gpts

This agent wont save when the API token is put in. I have tried classic tokens and fine-grained access tokens. I have tried with and without permissions set.

The network tab isnt any use, its a 500 error. I have reported this to OpenAI on their forums as well.

I would love to get this working so I can contribute to Dave's excellent work

BOUNTY: Documentation Wiki specialist

I'm looking for an enterprising individual to step up and take ownership of documentation. Please comment here and jump in optimizing the wiki.

"Agency" instead of "Agent Swarm"

I propse that we call what we today refer to as an "agent swarm" insteat to be named an "Agency". I Argue for this by presenting the definitions of the word "Agency".

The word "Agency" has different meanings depending on the context it is used in:

Sociology and Psychology: In these fields, agency refers to the capacity of individuals to act independently and to make their own free choices.

Legal and Business: In a legal or business context, agency refers to the relationship where one party (the agent) is authorized to act on behalf of another (the principal) in business dealings or other matters.

Governmental and Organizational: An agency in this sense is an organization or unit of a government responsible for a specific area of administration or function.

Philosophical: In philosophy, agency is often discussed in the context of free will and determinism. It refers to the capability of an entity to act in a world controlled by natural laws.

I belive the connotations of "Agency" to be much more reflective of what a group of LLMs working together in order to complete a task represent.

I would be happy about feedback and critiques of this proposition.

BOUNTY: Create a real-time updating agent that can read all the discussions of this repo

Someone please create a GPT with the GPT Builder that can serve as a main concierge for this Discussion board so that people can ask what's going on regularly.

BOUNTY: Document Best Practices on new Wiki Page

https://github.com/daveshap/OpenAI_Agent_Swarm/wiki/Assistant-Best-Practices

I've seen some remarkable improvements with new GPTs and Assistants. Please start capturing your best practices on the Wiki for easy reference. This includes the Concierge GPTs, toolmaker GPTs, and others.

Can't find tool_demo.py

How to run tool_demo.py? I'm unable to find one

BOUNTY: Puppet-master GPT (create a GPT through the Chat interface to instantiate a swarm)

Let's use the convenience of the ChatGPT web interface (GPT builder) to instantiate a swarm. We'll start with just another both. This will require:

• It will need to ask for and use your API key (be careful with this!)
• It will need to call the OpenAI API as a tool
• It will need to communicate with the agent it instantiates

manual assistant not working

python run.py --agents-definition-folder definitions/boss-worker3/
gives an error:

File "[..]/OpenAI_Agent_Swarm/agents/manual_assistants/logger.py", line 21, in emit
'name': self.agent.id,
^^^^^^^^^^^^^
AttributeError: 'Agent' object has no attribute 'id'

BOUNTY: Record video demonstrations and screenshots of this repo's code

Please record demos and examples and share in Show and Tell. This will serve several purposes:

• Energize the community: We are making headway with insane speed
• Spawn ideas and inspiration: Cross pollination across the hive mind
• Attract more interest: Making our work accessible for all

I recommend screen recording with OBS, it's totally free and I still use it for all my videos. You don't need to show your face, just explain your code and demo as it goes.

SUGGESTION: Genetic algorithm on top of agents swarm

Don't you think it would be good to try implementing a genetic (evolutionary) algorithm on top of a swarm of agents? We could encode the initial knowledge and prompts (or any other settings) of the agents as their DNA. Multiply, vary, let the strongest live and the weakest die.

BOUNTY: Definition proposals for Minimum Viable Agents

Lots of strong conversation still going on about, assistant, tool building, and communication architectures. In order to make some of the ideas discussed around agent communication and communication structures and agent hierarchies more concrete. We need to agree what an gent in the system is and does. I have attempted to kick of the conversation with the MVA discussion, but let get on board. Lets walk before we can run, lets understand what our individual agents look like, and then use that to inform the Swarm structure.

MVA Discussion: #123
What Tools are use by MVA and what tools are local to assistant or global: #116
How does this impact: #93 (reply in thread)
Conversations between agents and agents/tools

BOUNTY: Build and document the first SOB (Supreme Oversight Board)

Directive: Build, test, and document the first instance of a SOB

General ideas:

1. Instantiate multiple agents based upon various archetypes and personas
2. Have them communicate or collaborate based upon principles and missions (use your own or heuristic imperatives)
3. Focus on the Self-Direction and Self-Correction aspects of autonomy

BOUNTY: Propose Milestones, Roadmap, and General Principles

Context and Thank You

Thanks everyone for jumping in. It's clear there's a ton of energy and some general consensus. However, we're quickly finding out that network communication of agents is the hardest part. I had a great hourlong conversation with the core team of the ACE Framework as well, and we all agree - agents are easy now. The hard part will be organizing networks of agents, and getting to a self-organizing, arbitrarily scaling swarm is the Triple Crown we're looking for, but it will take work.

END GOAL: TRIPLE CROWN

The end goal is to have a fully autonomous swarm of agents with the following characteristics:

1. Mission Driven: Rather than a human user giving basic instructions, the swarm will be given a higher order mission. Something like "Help me become the best YouTuber ever." or "Solve world hunger."
2. Self-Organizing: The swarm should be able to create its own hierarchy based upon algorithmic and mechanistic principles. This means each agent needs to be equipped with enough intelligence to participate in the network, and the network may need decision mechanisms (e.g. top-down organization).
3. Self-Improving: As more of a stretch goal, it would be great if the agents and network could ultimately self-improve, but that may be getting ahead of ourselves.

Milestones & Roadmap

Milestones need to be a set of objective tests, tasks, achievements, and capabilities. The Roadmap should be a sequential list of general achievements. This is more like guidelines than a rigid plan, but this discussion will help us figure out where we're going.

I'll add a WIKI to this repo so we can document some of this stuff.

This fixes root shared folder issues when running the program. It also installs the missing base.

I thought I had already submitted this two days ago but I'm not seeing it.

BOUNTY: Submit PR to move all code into appropriate subfolders

Let's keep the root of the repo clean.

BOUNTY: Test various inter-agent communication strategies

There have been several conversations around communication theory, tech stack, and layered strategies. I'd like to see some folks do some experiments around these to identify what works and what doesn't.

• P2P (or A2A) comms: What are the best ways for agents to communicate directly with each other? Is this even a good idea?
• Flat Groups (aka Chat Rooms): What are the best ways for small teams of agents to communicate? Pub/Sub? Vector Store? REST?
• Inter-Group Communication: How can working groups communicate with each other? Have a designated comms agent?
• Vertical Communication: How can messages from SOB be transmitted down? And messages back up?

Overall, the PRIMARY goal here is to start surfacing general principles to optimize communication to minimize noise and maximize signals. What I mean by general principles are:

• General rules to follow (like "an agent should listen 90% of the time and speak only 10%" or "Only agents of X type should have broadcast privileges")
• Abstractions of what works and what does, and why e.g. "Conveying long complex paragraphs tends to work better because it provides detail and context" (or maybe it doesn't) - in other words, best practices for inter-agent and cross-swarm communications

Error running agents.tool_maker.unit_manager

(base) joey@Joeys-MacBook-Pro OpenAI_Agent_Swarm-main % python3 -m agents.tool_maker.unit_manager
Traceback (most recent call last):
  File "<frozen runpy>", line 198, in _run_module_as_main
  File "<frozen runpy>", line 88, in _run_code
  File "/Users/joey/Downloads/OpenAI_Agent_Swarm-main/agents/tool_maker/unit_manager.py", line 2, in <module>
    from agents.tool_maker.chat_manager import ChatManager
  File "/Users/joey/Downloads/OpenAI_Agent_Swarm-main/agents/tool_maker/chat_manager.py", line 8, in <module>
    Assistant = type(OpenAI().beta.assistants.list().data[0])
                     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^

IndexError: list index out of range