In AutoGen's SelectorGroupChat, how is the next speaker chosen and how do you override it?

## The selection loop `SelectorGroupChat` is the team type where routing is a model decision. On every turn the group-chat manager builds a selector prompt, calls the configured `model_client`, parses a participant name out of the reply, and gives that participant the turn. Everything else — broadcast context, termination conditions, `max_turns`, `TaskResult` — behaves as in other AgentChat teams. The default `selector_prompt` is a template with placeholders the team fills in: `{roles}` (each participant's name and description), `{participants}` (the legal names to choose from) and `{history}` (the conversation so far). Overriding `selector_prompt` is how you inject routing policy in natural language — "prefer the planner when the task is not yet decomposed", "never pick the reviewer before a draft exists". A detail that surprises people: the quality of selection depends heavily on each agent's `description`, not its `system_message`. The description is what the selector sees in `{roles}`; the system message is private to the agent. Vague descriptions produce erratic routing, and the fix is a one-line, decision-shaped description per agent. ## What selection costs Selection is not free. Compared with a positional team, you pay: - one extra model call per turn, with its own latency on the critical path; - a prompt containing conversation history, so selection cost rises as the run grows; - non-determinism — the same task can route differently on two runs, which makes reproducing a bug harder. Those costs are the reason `selector_func` exists. Anything you can decide with code, decide with code. ## selector_func and candidate_func `selector_func` receives the message sequence so far and returns either a participant name or `None`: ``` def selector_func(messages): if messages[-1].source == "planner": return "researcher" # deterministic hop, no model call return None # let the model decide ``` Returning a name skips the selector model call entirely for that turn — cheaper, faster, reproducible. Returning `None` restores model selection, so you can encode the handful of rules you are sure about and leave genuinely ambiguous turns to the model. This hybrid is the pattern to reach for in production: hard-code the deterministic spine, delegate only the branches that need judgment. `candidate_func` is the softer knob: rather than picking the speaker, it restricts the candidate list the model may choose from on a given turn — useful for phase gating, where only certain agents are legal in the current stage. ## allow_repeated_speaker and retries `allow_repeated_speaker` defaults to `False`, meaning the previous speaker is excluded from candidates for the next turn. That prevents the common failure where one talkative agent monopolises the conversation, but it also forces a switch even when the same agent genuinely should continue — for a research agent that needs several consecutive tool-calling turns, set it to `True`. When the model's reply does not resolve to exactly one participant name, the team retries selection up to `max_selector_attempts` (default 3). If all attempts fail it falls back to the previous speaker when there is one, otherwise the first participant. This makes selection robust, but it also means a poorly specified roster can degrade into near-round-robin behaviour while still paying for a selector call every turn. Watching who actually speaks, rather than trusting that the selector works, is a real operational task. ## When to pick this team SelectorGroupChat earns its cost when the next speaker genuinely depends on content that you cannot enumerate: open-ended research, triage across many specialists, work whose stages are not known in advance. When the flow is a fixed pipeline, a positional team is cheaper and reproducible; when the deciding knowledge is local to the current speaker, a handoff-based team removes the central call altogether. The strongest answer in an interview names the cost of the extra call and says which parts of the flow you would move into `selector_func`.