Teams

In plain terms

A team is several AI agents working together — like a department instead of a single employee. One agent researches, another writes, a third reviews. A team coordinates them so the customer gets one polished answer. You choose how they cooperate:

Coordinate — a manager splits the work and merges the results (“you research, you draft, you edit”).
Route — a receptionist sends each request to the right specialist (“billing question → billing agent”).
Broadcast — ask everyone at once and combine their answers (good for second opinions).
Collaborate — the agents discuss until they agree (for high-stakes decisions).

The analogy: one agent is an employee; a team is the org chart. You use a team when a job is too big or too varied for one specialist.

Teams enable multiple agents to work together. Choose how tasks are distributed: an orchestrator can pick agents, route to the best one, broadcast to all, or run iterative collaboration rounds.

Multi-Agent Collaboration

Coordinate

An orchestrator model picks which member agent handles the task.

Route

Routes to the single best agent based on input.

Broadcast

Sends input to ALL agents and merges results.

Collaborate

Iterative rounds between agents (maxRounds configurable).

TeamMode

enum TeamMode {
  Coordinate = "coordinate",
  Route = "route",
  Broadcast = "broadcast",
  Collaborate = "collaborate",
}

Mode	Enum	Behavior
`coordinate`	`TeamMode.Coordinate`	Orchestrator decides which agent(s) to invoke
`route`	`TeamMode.Route`	Single best agent selected based on input
`broadcast`	`TeamMode.Broadcast`	All agents process input; results merged
`collaborate`	`TeamMode.Collaborate`	Agents pass work in rounds until done (`maxRounds`)
`handoff`	`TeamMode.Handoff`	Members transfer the conversation to each other

TeamConfig

interface TeamConfig {
  name: string;
  mode: TeamMode;
  model: ModelProvider;
  members: Array<Agent | A2ARemoteAgent>;
  instructions?: string;
  sessionState?: Record<string, unknown>;
  storage?: StorageDriver;
  maxRounds?: number;
  eventBus?: EventBus;
  register?: boolean;          // default true
  memory?: UnifiedMemoryConfig; // shared across members that have none of their own
}

string

required

Display name for the team.

TeamMode

required

How the team distributes work: coordinate, route, broadcast, or collaborate.

ModelProvider

required

The orchestrator model (for coordinate/route) or shared model for the team.

Array<Agent | A2ARemoteAgent>

required

Member agents. Remote A2A agents are allowed — the team treats them like local ones.

string

System instructions for the orchestrator (coordinate/route) or shared team context.

Record<string, unknown>

Starting ctx.sessionState shared into member runs.

StorageDriver

Storage for team session state.

number

Max collaboration rounds. Collaborate mode only. Ignored otherwise.

EventBus

Custom bus. Default: a private bus for this team. Emits team.delegate.

boolean

default:"true"

Put this team in the global registry (HTTP transport discovers it). false for tests.

UnifiedMemoryConfig

Shared memory. A member that has no memory of its own uses this, so Researcher and Writer can see the same facts.

Methods

Same RunOpts as agent.run() (sessionId, userId, tenantId, metadata, apiKey, signal, dependencies).

Method	Signature	What it returns
`run`	`(input: string, opts?: RunOpts) => Promise<RunOutput>`	Combined answer.
`stream`	`(input: string, opts?: RunOpts) => AsyncGenerator<StreamChunk>`	Streamed pieces.

Getters: name, mode, members, eventBus.

Basic Example

import { Team, TeamMode, Agent, openai } from "@agentium/core";

const researcher = new Agent({
  name: "Researcher",
  model: openai(process.env.OPENAI_FAST_MODEL ?? "gpt-6-luna"),
  instructions: "You research topics and provide factual summaries.",
});

const writer = new Agent({
  name: "Writer",
  model: openai(process.env.OPENAI_FAST_MODEL ?? "gpt-6-luna"),
  instructions: "You write clear, engaging content from research notes.",
});

const team = new Team({
  name: "Content Team",
  mode: TeamMode.Coordinate,
  model: openai(process.env.OPENAI_MODEL ?? "gpt-6.1-sol"),
  members: [researcher, writer],
  instructions: "Coordinate between Researcher and Writer. Use Researcher for facts, Writer for drafts.",
});

const output = await team.run("Write a short article about quantum computing.");
console.log(output.text);

Next Steps

Coordinate Mode

Orchestrator picks which agent handles each task.

Route Mode

Route to the single best agent.

Broadcast Mode

All agents process; merge results.

Collaborate Mode

Iterative rounds between agents.

Build

Agent applications

Harness runtime

Teams and workflows

Data and capabilities

Interfaces and jobs

Voice and telephony

Verify and manage

In plain terms

Multi-Agent Collaboration

Coordinate

Route

Broadcast

Collaborate

TeamMode

TeamConfig

Methods

Basic Example

Next Steps

Coordinate Mode

Route Mode

Broadcast Mode

Collaborate Mode

​In plain terms

​Multi-Agent Collaboration

Coordinate

Route

Broadcast

Collaborate

​TeamMode

​TeamConfig

​Methods

​Basic Example

​Next Steps

Coordinate Mode

Route Mode

Broadcast Mode

Collaborate Mode

In plain terms

Multi-Agent Collaboration

TeamMode

TeamConfig

Methods

Basic Example

Next Steps