Communication Flow

ORQO agents communicate through a structured messaging system that balances open collaboration with focused private discussions. Understanding how agents talk to each other is key to designing effective teams and workflows.

The Round Table

When a stage executes, all assigned agents sit at a virtual round table. The engine drives a heartbeat loop — each cycle gives every agent exactly one turn in assignment order:

Cycle 1:  Agent A → Agent B → Agent C
Cycle 2:  Agent A → Agent B → Agent C
Cycle 3:  Agent A → Agent B → Agent C
...

The turn order is determined by the position of each agent's stage assignment — which you control by drag-and-drop ordering in the Workflow Builder. This order matters: the first agent sets the tone, and later agents react to what came before.

The heartbeat repeats until the task completes. Each cycle, every active agent gets one LLM call to read new messages, think, use tools, and communicate.

How a turn works

On each turn, the agent:

1. Receives all new messages addressed to it (or to the team) since its last turn
2. Thinks — the LLM processes the conversation history, the task directive, and available tools
3. Acts — calls tools, sends messages to teammates, or produces output
4. Ends its turn — control passes to the next agent in order

An agent can send messages to specific teammates, to the whole team, or signal that it has finished its part of the task.

Task completion

A task completes when all assigned agents have signaled they are done. Until then, the heartbeat continues. Agents that have already finished are skipped in subsequent cycles while the remaining agents continue working.

There is a safety limit of 30 cycles per task (configurable) to prevent infinite loops.

Addressing Messages

Agents choose who receives their messages:

Recipient	Who sees it
team (default)	All agents assigned to the current task
Agent name (e.g., "Bob")	Only that specific agent
Multiple names (e.g., "Bob", "Alice")	Only those specific agents

Messages addressed to the team are visible to all active teammates. Messages addressed to a specific agent are private — only the sender and recipient see them.

This is where per-agent context management becomes important: private messages only consume context window space for the agents involved, not the entire team.

The Approachable flag

Agents with the Approachable toggle disabled cannot receive direct messages from teammates. They can still send messages and produce output, but other agents cannot address them. This is useful for coordinator agents that give instructions without being pulled into discussions.

Side Conversations

When an agent sends a direct message to a single teammate, a side conversation breaks out of the round table. Think of it as two colleagues stepping away from the group to have a focused discussion.

How side conversations work

1. Agent A sends a direct message to Agent B during its turn
2. The round table pauses — no other agents take turns
3. Agent B responds, and the two alternate back and forth
4. When either agent closes the conversation, the round table resumes
5. A summary of the side conversation is shared with the other team members who weren't part of it

Two patterns

Side conversations support two interaction patterns:

Pattern	How it works	Use case
Dialogue	Agents alternate turns, discussing back and forth	Clarifying questions, collaborative problem-solving, negotiation
Delegation	One agent works autonomously while the other waits	"Go research this and report back", task handoff

In dialogue mode (the default), each agent gets a turn to respond. In delegation mode, one agent keeps the turn and works through the task — using tools, making progress — while the other waits for the result.

Why side conversations matter

Side conversations are powerful for several reasons:

• Focused context — Only the two participating agents accumulate messages from the discussion. The rest of the team's context windows are unaffected.
• Depth without noise — Two agents can have a detailed 20-message exchange about a specific topic without flooding the entire team's context.
• Natural collaboration — Agents can ask clarifying questions, delegate research, or work through a problem together before reporting back to the team.
• Compaction-friendly — Since each agent manages its own context, side conversation messages are compacted independently based on each agent's preset.

Observer Agents

Observer agents see all messages exchanged at the round table — including messages addressed to specific agents — but do not actively participate unless addressed. They monitor the conversation silently.

With live monitoring enabled, an observer gets a review turn after each non-observer agent's action, allowing real-time supervision and course correction.

The orchestrating agent pattern

An agent that is Observer + not Approachable acts as an orchestrating agent: it sees everything, can inject directives, but cannot be interrupted by teammates. This is the recommended pattern for supervisory agents that coordinate multi-agent work.

Phase-Based Execution

Agents are assigned to one of three stage phases that control when they execute:

Phase	When	Purpose
Default	Main execution	The working phase — most agents run here
On Stage Start	Before default agents	Setup, data fetching, initialization
On Stage Complete	After default agents finish	Cleanup, summarization, validation

Agents in different phases cannot message each other — communication is scoped to agents in the same phase. This prevents cross-phase confusion (e.g., a finalizer agent accidentally interacting with agents that have already finished).

Message Flow Summary

Stage starts
  │
  ├─ On-Stage-Start agents execute (if any)
  │
  ├─ Default agents: Round Table begins
  │   │
  │   ├─ Cycle 1: A → B → C
  │   │            └─ A sends direct message to B
  │   │               └─ Side conversation: A ↔ B (round table paused)
  │   │               └─ Side conversation closes → summary shared with C
  │   │            └─ B takes turn (sees side conversation + team messages)
  │   │            └─ C takes turn (sees team messages + side conversation summary)
  │   │
  │   ├─ Cycle 2: A → B → C
  │   │   ...
  │   │
  │   └─ All agents signal done → Task complete
  │
  ├─ Context compaction creates task summaries
  │
  ├─ On-Stage-Complete agents execute (if any)
  │
  └─ Stage complete → routing decides next stage

Related

• Context Compaction — how conversation history is managed per agent
• Agents — capabilities, observer mode, approachable flag
• Assignments — how agents are assigned to stages and ordered