Coordination

Agent teams: Router, Orchestrator, Parallel, Sub-Workflow, Debate, Message Hub, Sequential, and Voting.

Updated on Sep 02, 2026

Coordination cards organize multiple agents in a single workflow: routing, parallelizing, debating, and voting. Several of them accept static participants (defined in the modal) or dynamic ones (coming from a Start collection via {{collection.* | filters}}).

Router

Coordination · router · classifies and directs

An LLM classifier that reads the message and chooses one of the connected paths (route-N). Describe each route well — it's the decision criterion.

namestringpadrão: 'router'

Node name (sanitized).

modelstring

Model that decides the route. Empty = agent's default model.

routesobjectobrigatório

By handle: `{target_node_id, target_name, description}` — the description guides the choice.

default_routestring

Route used when confidence falls below the threshold.

confidence_thresholdnumberpadrão: 0.7

Minimum confidence to accept the model's decision.

include_historybooleanpadrão: true

Consider conversation history when routing (not just the last message).

routing_promptstring

Extra routing instructions.

Orchestrator

Coordination · orchestrator · divides and delegates

Breaks the task into subtasks and delegates them to workers connected in slots, iterating until completion. Good for composite tasks ("research, compare, and write the report").

namestringpadrão: 'Orchestrator'

Node name.

modelstring

Orchestrator model.

orchestrator_promptstring

How to plan and divide the work.

worker_promptstring

Base prompt applied to workers.

max_iterationsnumberpadrão: 10

Maximum planning rounds.

worker_max_iterationsnumberpadrão: 10

Maximum rounds for each worker.

Parallel

Coordination · parallel · simultaneous branches

Fires the connected branches (branch-N) at the same time and aggregates the results. Also connects as a tool to an Agent — the model decides when to trigger parallelism. Each branch can receive its own variables.

namestringpadrão: 'parallel'

Node name (sanitized).

instructionstring

What each branch should do with the input.

branchesobjectobrigatório

By handle: `{target_node_id, target_name, variables[]}` — variables injected into that branch.

aggregation_modeconcat | merge | first | votepadrão: concat

How to combine results: concatenate, merge, first to finish, or vote on the best.

wait_allbooleanpadrão: true

Wait for all branches before aggregating.

timeout_secondsnumber

Wait timeout for branches.

Sub-Workflow

Coordination · sub_workflow · workflow within workflow

Executes another published agent as a step in this workflow, mapping variables on input and output.

namestringpadrão: 'Sub-Workflow'

Node name.

sub_workflow_idstringobrigatório

The agent to execute.

input_mappingobject

From local variable → sub-workflow variable.

output_mappingobject

From sub-workflow variable → local variable, on return.

Debate

Coordination · debate · conflicting perspectives

Multiple agents discuss a topic in rounds, each seeing previous statements, with synthesis at the end. Static participants in the modal or dynamic ones from a collection.

namestringpadrão: 'debate'

Node name (sanitized).

debate_topicstringobrigatório

The theme. Accepts `{{variables}}` (e.g., `Analyze the case: {{case}}`)

max_roundsnumberpadrão: 3

Discussion rounds.

consensus_thresholdnumberpadrão: 0.7

Agreement level that ends the debate before the ceiling.

moderator_promptstring

Moderator instructions/synthesis.

agent_behaviorstring

Behavior guideline attached to all participants.

debate_agents{name, system_prompt}[]

Static mode: the participants and their personas.

debate_agents_sourcestring

Dynamic mode: source `{{collection.* | filters}}`.

agent_name_fieldstringpadrão: name

Item field that gives the participant's name (dynamic).

agent_prompt_templatestring

Persona template with `{{fields}}` from the item (dynamic).

Message Hub

Coordination · msg_hub · private conversation

Creates a channel where only the listed participants see each other's messages — parallel conversations invisible to the rest of the workflow (the AgentScope MsgHub standard).

namestringpadrão: 'Msg Hub'

Node name.

hub_idstringpadrão: gerado

Channel identifier.

participantsstring[]obrigatório

Names of the agents who participate.

announcementstring

Opening message announced in the channel.

inherit_parent_hubbooleanpadrão: false

Participants see messages from the parent channel.

share_to_parentbooleanpadrão: false

Messages from this channel go up to the parent channel.

Sequential

Coordination · sequential · one after another

Executes a queue of agents in order, each able to see what the previous ones produced. Static participants (with model per participant) or dynamic from a collection, with filters and model mapping.

namestringpadrão: 'sequencia'

Node name (sanitized).

source_modedynamic | staticobrigatório

Where the participants come from.

pass_contextbooleanpadrão: true

Each participant sees the responses of the previous ones.

agent_behaviorstring

Guideline common to all.

static_participants{id, name, instructions, model?}[]

Static mode: the queue, with persona and model optional per participant.

agents_sourcestring

Dynamic mode: source `{{collection.* | filters}}`.

agent_name_fieldstringpadrão: name

Item field that gives the name (dynamic).

agent_prompt_templatestring

Persona template with `{{fields}}` from the item (dynamic).

model_mapping / default_modelobject / string

Model per participant and fallback (dynamic).

filters{field, operator, value}[]

Filters the collection items (`equals`, `contains`, `not_equals`).

max_participantsnumber

Ceiling of participants per execution.

Vote

Coordination · vote · collective decision

Each voter chooses in secret among the options; the result comes out with count, winner and majority. The on_result saves the winner back to a variable or collection — this is what closes the loop with While and If/Else.

namestringpadrão: 'vote'

Node name (sanitized).

vote_promptstringpadrão: 'Cast your vote.'

The voting instruction. Accepts `{{variables}}`.

vote_agentsstring[]

Static mode: the voters.

vote_agents_sourcestring

Dynamic mode: `{{collection.* | filters}}` or `{{on-debate.participants.*}}` to reuse participants from a Debate.

voter_id_field / voter_name_fieldstringpadrão: id / name

Item fields that give the voter's id and name (dynamic).

voter_prompt_templatestring

Voter persona with `{{fields}}` from the item; without template, the item's `instructions` field becomes the persona.

vote_optionsstring[]

Static mode: the options.

vote_options_sourcestring

Dynamic mode: options from collection (`option_value_field`/`option_label_field`).

exclude_selfboolean

Voter cannot vote for themselves (dynamic options).

require_majoritybooleanpadrão: false

Requires absolute majority to declare a winner.

allow_abstainbooleanpadrão: false

Allows abstention.

on_resultobject

`{update_collection, match_field, update_field, update_value}` — records the winner. If the target is an object variable (e.g., `votes`), increments the winner's key.

on_tieobject

`{action: none | revote | random, max_retries, reduce_options, fallback}` — what to do in case of a tie.

agent_behaviorstring

Common guideline for voters.

The jury standard

Debate + Voting + While: jurors debate (debate-jur), vote (vote_agents_source: {{debate-jur.participants.*}}), the on_result increments {{votes}} and the While decides if there is a new round ({{votes.guilty}} < 2 AND ...). It is exactly the "Jury Trial" template from the platform.

Was this page helpful?