# Swarm Decision-Making



SwarmConsensus is a core feature of the Aether Framework that enables collaborative decision-making among agents. It supports both **small-scale** and **large-scale swarms** with the following methods:

* **Basic Redis Methods**: Ideal for small swarms with straightforward task delegation.
* **Advanced Lua and Transactional Methods**: Designed for larger, more complex swarms requiring atomicity and performance optimization.

***

#### **Basic Methods for Small Swarms**

1. **Propose a Task**\
   Agents can propose tasks using a simple Redis-backed counter.

```python
proposal_id = swarm.propose_task("Analyze data trends")
```

2. **Vote for a Task**\
   Each agent can vote on proposals using Redis hash operations.

```python
swarm.vote(proposal_id)
```

3. **Retrieve Consensus**\
   Consensus is reached when a task receives a threshold number of votes.

```python
consensus = swarm.get_consensus()
print(consensus)
```

***

#### **Advanced Methods for Larger Swarms**

For larger swarms or high-concurrency scenarios, SwarmConsensus provides enhanced functionality using Lua scripts and Redis transactions:

1. **Propose a Task with Lua**\
   Lua ensures atomic task proposal operations, minimizing race conditions.

```python
proposal_id = swarm.propose_task_with_lua("Optimize blockchain transaction flow")
```

2. **Vote with Redis Transactions**\
   Transactions ensure that voting operations are executed atomically, even under high concurrency.

```python
swarm.vote_with_transaction(proposal_id)
```

3. **Consensus via Lua**\
   For large datasets or frequent voting, Lua scripts streamline consensus checks.

```python
consensus = swarm.get_consensus_with_lua(threshold=5)
print(consensus)
```

***

#### **When to Use Each Method**

| **Method**             | **Use Case**                                     |
| ---------------------- | ------------------------------------------------ |
| **Basic Methods**      | Small swarms with simple task delegation.        |
| **Lua Scripts**        | Atomic task proposals and high-frequency voting. |
| **Redis Transactions** | High-concurrency voting in large swarms.         |

***

#### **Example Workflow**

Here’s a step-by-step workflow for using the SwarmConsensus module:

1. **Propose a Task**

```python
proposal_id = swarm.propose_task_with_lua("Conduct AI-powered simulations")
```

2. **Vote on a Task**

```python
swarm.vote_with_transaction(proposal_id)
```

3. **Check Consensus**

```python
consensus = swarm.get_consensus_with_lua(threshold=3)
if consensus:
    print("Consensus reached:", consensus)
else:
    print("No consensus reached yet.")
```

***

#### **Key Notes**

* Use **basic methods** for lightweight operations and testing.
* For production environments or large-scale swarms:
  * Leverage **Lua scripts** for atomicity and optimized performance.
  * Use **Redis transactions** to ensure data consistency under high concurrency.
* Configure the **consensus threshold** based on your swarm size and requirements.

***

