Orchestrator Operator

The Agent Orchestrator is a powerful operator designed to manage and automate complex, multi-round interactions with AI agents. It acts as a supervisor, running an agent through a task iteratively until a goal is met or a budget is exhausted.

Its primary function is to support autonomous agent workflows. By default, it operates a single “Action Agent” in a loop, providing robust budget controls (tokens, time, and rounds) to ensure predictable, cost-effective execution. It also features a live tool history, dual display outputs for monitoring, and generates comprehensive reports upon completion.

For more complex scenarios requiring human-in-the-loop or programmatic validation, the Orchestrator can be configured to use an optional “Validator Agent” to review the Action Agent’s work at each step.

Default Autonomous Workflow

Input Task

User provides a task DAT

Orchestrator

Manages the loop based on budget

Action Agent

Executes the task and uses tools

Output Report

Generates detailed JSON/Markdown report

Agent Tool Integration

🔧 GetTool Enabled 2 tools

This operator exposes 2 tools that allow Agent and Gemini Live LOPs to signal task completion in autonomous mode or provide structured validation feedback when a Validator Agent is used..

Use the Tool Debugger operator to inspect exact tool definitions, schemas, and parameters.

The Orchestrator exposes one of two tools to other agents, depending on its configuration:

1. task_complete (Default/Autonomous Mode): Allows the Action Agent to signal that it has finished its task, providing a final answer and status. This immediately stops the loop.
2. orchestrator_control (Validator Mode): Allows a designated Validator Agent to programmatically provide feedback (success, failure, retry) to control the workflow loop.

Requirements

• Action Agent: An Agent operator must be assigned to the Action Agent parameter. This is the primary agent that will perform the work.
• Task Definition: A task must be provided by connecting a textDAT or tableDAT to the second input (in2), which is linked by default to the Task DAT parameter.

Input/Output

Inputs

• in1 (Conversation Context): A tableDAT with role and message columns can be connected here. This provides the initial conversation history to the Action Agent, which is useful for “warming up” the agent or continuing a previous workflow.
• in2 (Task DAT): The primary task description. By default, the Task DAT parameter is linked to this input, so you can connect a textDAT or tableDAT containing your main prompt directly via a wire.

Outputs

The Orchestrator provides two configurable DAT outputs for flexible monitoring.

• out1 (DAT): A primary display output, configurable via the [display] DAT out1 menu. Defaults to showing the live Conversation.
• out2 (DAT): A secondary display output, configurable via the DAT out2 menu. Defaults to showing the Markdown Report.

Internal DATs

The Orchestrator contains several internal DATs for monitoring and reporting, which can be routed to the outputs:

• conversation_table: The full history of messages between the orchestrator and the agents.
• tool_history_table: A live, real-time log of every tool call made by the agent, including arguments, results, and execution time.
• report_markdown / report_json: Comprehensive reports generated at the end of a session, detailing token usage, costs, and a round-by-round breakdown.
• event_history: A log of all internal events within the orchestrator.

Parameters

Page: Controls

Status (Status) op('orchestrator').par.Status Str

Displays the current state of the orchestrator (e.g., IDLE, ACTIVE, COMPLETE). Read-only.

Default:

IDLE

Current Round (Currentround) op('orchestrator').par.Currentround Int

The current iteration number of the processing loop. Read-only.

Default:

0

Max Rounds (Maxrounds) op('orchestrator').par.Maxrounds Int

The maximum number of rounds the autonomous loop will run before stopping automatically. This is a key budget control.

Default:

15

Max Tokens (Maxtokens) op('orchestrator').par.Maxtokens Int

The maximum total tokens (input + output) the agent can consume before the session is automatically stopped. A value of 0 disables this limit.

Default:

50000

Max Time (seconds) (Maxtime) op('orchestrator').par.Maxtime Int

The maximum duration in seconds that a session can run before being automatically stopped. A value of 0 disables this limit.

Default:

0

Start (Start) op('orchestrator').par.Start Pulse

Starts the orchestration loop.

Default:

False

Pause (Pause) op('orchestrator').par.Pause Pulse

Pauses the orchestration loop.

Default:

False

Reset (Reset) op('orchestrator').par.Reset Pulse

Resets the orchestrator, clearing all history and reports.

Default:

False

[display] DAT out1 (Out1) op('orchestrator').par.Out1 Menu

Selects which internal DAT to route to the first output (out1).

Default:

conversation_table

DAT out2 (Out2) op('orchestrator').par.Out2 Menu

Selects which internal DAT to route to the second output (out2).

Default:

report_markdown

Page: Task

Action Agent (Actionagent) op('orchestrator').par.Actionagent OP

The primary agent operator that will perform the task.

Default:

"" (Empty String)

Task DAT (Taskdat) op('orchestrator').par.Taskdat DAT

The DAT containing the initial task description or prompt.

Default:

"" (Empty String)

Enable Review Phase (Enablereview) op('orchestrator').par.Enablereview Toggle

When enabled, the agent will perform a final review of its work after the loop completes, generating a summary.

Default:

True

Review Prompt DAT (Reviewpromptdat) op('orchestrator').par.Reviewpromptdat DAT

An optional DAT containing a custom prompt for the final review phase.

Default:

"" (Empty String)

Validation Agent Header

Use Validator (Usevalidator) op('orchestrator').par.Usevalidator Toggle

Enables the validation workflow. When off (default), the orchestrator runs in autonomous mode.

Default:

False

Validation Mode (Validationmode) op('orchestrator').par.Validationmode Menu

Determines how the validation step is triggered when 'Use Validator' is on. 'Automatic' runs the validator agent immediately; 'Manual' pauses and waits for the 'Send To Validator' pulse.

Default:

Manual

Send To Validator (Validate) op('orchestrator').par.Validate Pulse

When in 'Manual' validation mode, this pulse sends the action agent's work to the validator agent for review.

Default:

False

Validator Agent (Validatoragent) op('orchestrator').par.Validatoragent OP

The agent operator assigned to validate the action agent's work.

Default:

"" (Empty String)

Validator Info (optional) (Validatorcontextdat) op('orchestrator').par.Validatorcontextdat DAT

An optional DAT containing additional context or instructions for the validator agent.

Default:

"" (Empty String)

Setup Validator Agent (Configvalidator) op('orchestrator').par.Configvalidator Pulse

A utility pulse that automatically configures the assigned 'Validator Agent' with the required 'orchestrator_control' tool.

Default:

False

Page: About

Bypass (Bypass) op('orchestrator').par.Bypass Toggle

Bypasses the orchestrator, passing the input directly to the output.

Default:

False

Usage Examples

1. Basic Autonomous Workflow

This is the default and most common use case.

1. Create an orchestrator and an agent operator.
2. On the Orchestrator’s Task page, drag the agent operator onto the Action Agent parameter.
3. Create a textDAT and write your task description in it (e.g., “Summarize the provided text and identify key themes.”).
4. Connect this textDAT to the second input (in2) of the Orchestrator.
5. On the Controls page, set your budget. For example, set Max Rounds to 5.
6. Pulse the Start parameter.
7. Monitor the process. The conversation_table (visible by default in out1) will show the agent’s messages, and the tool_history_table (viewable by setting Out1 or Out2 to it) will show any tools the agent uses in real-time.
8. When the loop finishes (either by hitting the round limit or the agent calling task_complete), a detailed report will be available in the report_markdown and report_json DATs.

2. Providing Initial Context

You can “warm up” the agent with existing conversation history.

1. Set up the autonomous workflow as described above.
2. Create a tableDAT with two columns: role and message.
3. Add rows to simulate a conversation (e.g., user, “What is the capital of France?”).
4. Connect this tableDAT to the first input (in1) of the Orchestrator.
5. Pulse Start. The agent will now have this history as context for its first round.

3. Using the Validation Loop

For tasks that require verification at each step. This workflow is also essential when an agent’s action triggers a long-running external process, and the orchestrator needs to wait for it to complete. By using Manual validation mode, the orchestrator will pause after the agent acts. The user is then responsible for signaling that the external process is finished by pulsing the Send To Validator parameter, which allows the workflow to resume.

1. Create two agent operators: one for action (action_agent) and one for validation (validator_agent).
2. On the Orchestrator’s Task page, assign both agents to the Action Agent and Validator Agent parameters respectively.
3. Enable validation by turning the Use Validator toggle On.
4. Set the Validation Mode to Manual to have control over each step.
5. Configure the validator by pulsing the Setup Validator Agent parameter. This will automatically give the validator_agent the necessary orchestrator_control tool.
6. Pulse Start. The action_agent will perform one round and the Orchestrator will pause, with its Status showing PAUSED.
7. At this point, you would typically have the validator_agent analyze the action_agent’s work.
8. Pulse the Send To Validator parameter. The validator_agent will then be called and use its tool to send back a success, failure, or retry signal, controlling the loop.

Related Operators

• Agent: The core operator used by the Orchestrator to perform tasks.
• ChatTD: The underlying operator that handles API communication for any connected agents.