Parallel Stepping Conflict

Nobody has claimed this yet.

## Parallel Stepping Conflict

`mesa-llm` enables parallel stepping by patching Mesa's `AgentSet.shuffle_do`.
When `model.agents.step()` is executed, it creates a single flat batch of **all agents**, which are then run concurrently.

### The Conflict

The scheduler treats a **MetaAgent `M`** and one of its **constituent agents `A`** as independent peers and schedules them simultaneously.

If `M` internally triggers its agents:

```python
for agent in self.agents:
agent.step()
```

then `A` will be stepped **twice in the same model tick**:

1. Once by the **parallel scheduler**
2. Once by its **parent MetaAgent**

This leads to inconsistent state updates.

---

## Fix: Create a "Team Badge" (`is_component`)

Introduce a small internal flag on agents called `is_component`.

```python
self.is_component: bool = False
```

Meaning:

- `False` → Independent agent (scheduled normally)
- `True` → Component of another agent (not scheduled directly)

### Behavior

The scheduler ignores agents where:

```python
agent.is_component == True
```

This ensures that **component agents are only stepped by their parent MetaAgent**, preventing duplicate execution in a single tick.

Start by tracing the mesa-llm patch around Mesa's AgentSet.shuffle_do and the model.agents.step() entry point, then inspect how MetaAgent invokes its constituent agents. Confirm the scheduler can distinguish component agents from independent agents, and verify that a component is stepped once through its parent rather than again as a parallel peer.

Written by the indexing model from the issue text.