CAMON: Cooperative Agents for Multi-Object Navigation with LLM-based Conversations

CAMON implements a hybrid decentralized system where team leadership is dynamically assigned and global information is perpetrated through agent interaction. Link to Paper

Main Algorithm Pseudocode

CAMON

In our CAMON Implementation, a leader agent is initially chosen as shown in line 1. Then, for each timestep, each agent parses their observations (\(o_a\)) from the environment states, and then generates a text perception (\(p_a\)) given those observations through the \perception module (\ref{perception_prompt}). This perception (\(p_a\)) is combined with the agent's current action (\(\texttt{action}_a\)) and its action history (\(\mathcal{H}_a\)) to create \(\texttt{agentData}_a\), which is then appended to the \(\texttt{GlobalData}\).

Then, each agent checks their current action (\(\texttt{action}_a\)). If it is still active (meaning it is multi-step and not complete), the agent will do nothing, as seen in line 12.

If not, and the agent is the leader agent, it will independently generate a new team plan through Plan Generation in line 14. If the agent is not the leader agent, instead it will propose a plan through Plan Proposal in line 16. This plan will then be reviewed by the leader agent through the review plan method in line 17. Then the agent will become the new leader agent.

Next, the finalized plan will be parsed into tasks for each agent and translated into a standardized action. Now since all agents have an active action, each agent will generate an executable vector (\(e_a\)) through our Execution Module in line 23. If the current action (\(\texttt{action}_a\)) is complete or single-step, it will then be set to \(\texttt{None}\) and appended to the agent's action history.

Lastly, all executable tensors will be combined and executed within the Wildfire Environment in line 28. If the max score has been reached, the algorithm ends.

Key Methods

Plan Generation (Leader)

Enables the leader agent to create and distribute comprehensive team plans. Uses global state information to coordinate multiple agents' actions while considering their specialized capabilities.

def generate_plan(agent: Agent, global_data: dict) -> None:
    """
    Leader generates team plan:
    1. Collects team state and observations
    2. Generates plan via LLM
    3. Assigns actions to agents
    4. Updates global state
    """

Plan Proposal (Team Members)

Allows non-leader agents to suggest actions to the current leader. Successful proposals can trigger leadership transfers, enabling dynamic role adaptation based on situational awareness.

def propose_plan(agent: Agent, global_data: dict) -> None:
    """
    Non-leader proposes action:
    1. Generates proposal based on local state
    2. Leader reviews proposal
    3. Updates leadership if accepted
    """

Communication Protocol

Defines the structured message format for plan proposals, leader responses, and team coordination. Uses XML-style tags to maintain consistent communication patterns across all agents.

Message Format:

<reasoning>Decision explanation</reasoning>
<action>Next action</action>
<message>Agent communication</message>

Optional:
<AGENT_ID-action>Other agent action</AGENT_ID-action>
<AGENT_ID-message>Message to agent</AGENT_ID-message>

Global State:

global_data = {
    'leader_agent': current_leader,
    'AGENT_X': {
        'perception': last_perception,
        'position': last_position,
        'current_action': current_action,
        'past_actions': action_history
    }
}

Environment Interaction

Manages the interface between high-level agent decisions and low-level environment actions. Handles perception generation and action execution with error checking.

Observation Processing: Converts raw sensor data into semantic descriptions that can be processed by the LLM for decision making.

observations = get_agent_observations(state, agent.id)  # Raw sensor data
perception = agent.generate_perception(cfg.envs, agent_states, global_data)  # Text description

Action Execution: Translates high-level action plans into executable commands and applies them to the environment.

action_array = generate_action_from_option(agent=agent)
env_action[agent.id] = action_array
...

action_tensor = torch.from_numpy(np.array(env_action)).to(device) # Combine actions

state["agents"]["action"] = action_tensor
newstate = env.step(state)  # Apply to environment

Implementation Notes

Leadership Changes: Handles the transfer of leadership responsibilities between agents, updating global state and team awareness.
```
global_data.update({"leader_agent": agent})  # Transfer leadership
```