All Classes and Interfaces
Class
Description
Abstract base class for protocol handlers.
Defines how agents are created and maintained in a
LazyAgentPool.Factory for creating agent instances on demand.
A checked-out agent handle that returns the agent to the pool on
AgentHandle.close().Manages agent health monitoring and recovery within a supervised group.
Functional interface for agent health checks.
Agent health status snapshot.
Action to take when an agent is unhealthy.
Listener notified of recovery events.
Policy governing recovery behavior.
Result of a recovery attempt.
Bridges streaming channels between agents for push-based inter-agent communication.
Represents a single execution thread for an agent.
Stores named artifacts (files, data) produced by group members.
An artifact stored by a group member.
Determines whether a task is atomic (solvable directly) or needs decomposition.
Multi-agent auction mechanism supporting various auction types.
Supported auction types.
Adapter that wraps the existing
Auction as a NegotiationProtocol.Result of an auction execution.
Defines how a
StreamingChannel handles overflow when the buffer is full.A bid submitted by an agent in an auction.
Strategy for how an agent decides its bid value.
Bilateral negotiation protocol - two-party offer/counter-offer exchange.
Analyzes an
InteractionGraph to detect performance bottlenecks
in multi-agent systems.A detected bottleneck in the agent interaction graph.
Types of bottlenecks that can be detected.
A conditional branch in a workflow.
Handler for broadcast messaging (one-to-many).
Tracks resource budgets (tokens, API calls, time) for a group.
A named resource budget.
Filter for querying agents by capability.
Registry for agent capability advertisement and discovery.
Executes a choreography specification using decentralized agent coordination.
Result of the entire choreography execution.
Result of a single interaction step.
Event-driven bus for choreography coordination.
An event published on the choreography bus.
Declarative specification of agent interactions for choreography-based coordination.
A single interaction rule in the choreography.
Coalition is a goal-oriented temporary alliance with reward distribution.
Negotiation status.
Reward distribution record.
Builder for creating Coalition instances.
Strategy for forming coalitions.
Result of a coalition goal achievement attempt.
Individual member contribution to the coalition.
Strategy for computing the next offer value during negotiation.
Routes a handoff to the first agent whose predicate matches the context.
Workflow executor with conditional branching and loop support.
Fluent builder that orchestrates a voting session among agents.
Represents a contract awarded to a contractor in the Contract-Net protocol.
Adapter that wraps the existing
MultiRoundContractNet as a NegotiationProtocol.FIPA Contract Net Interaction Protocol.
FIPA Conversation Protocol interface.
Protocol execution states.
Multi-model council deliberation executor.
Builder for CouncilExecutor.
Individual response from a council member (Stage 1).
Result of a council deliberation.
Peer review from a council member (Stage 2).
Chairman's synthesis (Stage 3).
Manages cross-functional team assignments in a matrix organization.
Executes workflow steps as a Directed Acyclic Graph (DAG).
Detects potential deadlocks in choreography specifications by finding cycles
in the agent interaction graph using DFS-based cycle detection.
A detected cycle in the interaction graph.
Result of deadlock detection.
Debate executor for adversarial collaboration between LLM agents.
Builder for DebateExecutor.
Format for debate execution.
Handler for multi-agent debate and consensus building protocol.
Result of consensus check.
Represents an active debate session.
Debate status.
Agent position in a debate.
Snapshot of a completed round.
Result of a debate execution.
Record of a single round in a debate.
A proposal submitted for group decision-making.
The outcome of a group decision process.
Persistent store for group decision traces.
Default implementation of AgentGroup.
Default SPI implementation of
AgentGroupFactory.Default implementation of Coalition.
Default implementation of
GroupDecisionFramework.Default implementation of GroupEventBus.
Default group planner that decomposes goals using agent capabilities.
Default handoff implementation that transfers a task from one agent to another
via
AgentMessage and invokes the receiving agent's chat method.Default implementation of Hierarchy.
Default implementation of HubSpoke.
Default implementation of MatrixOrganization.
Default implementation of MembershipManager.
Default implementation of NetworkMesh.
Default implementation of PipelineOrganization.
Default SPI implementation of
ProtocolManagerHandle.Factory.Default implementation of Swarm.
Default implementation of Team.
Tracks how tasks flow through the hierarchy via delegation and escalation.
A single delegation/escalation entry.
Type of delegation flow.
Handler for point-to-point direct messaging.
Central discovery service for agents.
Registration mode enum.
Extended MessageBroker interface for distributed messaging backends.
Exception for message broker operations.
SPI-based factory for discovering and creating
DistributedMessageBroker instances.Represents an agent's dual reporting assignment in a matrix organization.
Manages dynamic peer-to-peer connections in a network mesh.
Cross-agent episodic memory for recording and querying interaction episodes.
A single interaction episode.
An execution plan with lifecycle control (pause, resume, cancel).
Execution plan states.
Exponential concession strategy - concedes slowly at first, then faster.
Cascading failure protection for multi-agent systems.
Exception thrown when FAIL_FAST strategy is used and circuit is open.
Circuit breaker states.
How to handle failures when circuit is open.
FIPA ACL Message.
FIPA Message Builder.
FIPA Agent Communication Language (ACL) performatives.
Performative categories.
Parses a string-based flow definition into a DAG of agent routing steps.
Exception thrown when a flow definition cannot be parsed.
Directed acyclic graph representing agent flow routing.
Result of decomposing a goal across a group of agents.
Orchestrates graceful shutdown of an agent group.
Result of a group shutdown operation.
Captures and persists snapshots of group state for recovery.
Snapshot of a group's state at a point in time.
Framework for group-level decision-making with propose, vote, and converge phases.
Decomposes a high-level goal across a group of agents.
Restores a group from a previously captured checkpoint.
A guardrail that checks whether an agent action is permitted.
Result of a guardrail check.
Severity level for guardrail decisions.
Strategy interface for executing a one-shot handoff between two agents.
Chains multiple handoff steps into an
A -> B -> C pipeline.Immutable context passed through a handoff between agents.
Observer for handoff lifecycle events.
Message types used in the handoff protocol.
Immutable result of a handoff operation.
Hierarchical agent orchestrator implementing the HLM (Hierarchical Language Model) pattern.
Builder for HierarchicalAgentOrchestrator.
Result of a hierarchical orchestration execution.
Execution status.
A task within the hierarchical orchestration system.
Task execution status.
A tree-based organization structure with parent-child relationships.
Builder for creating Hierarchy instances.
Hierarchy levels in the HLM (Hierarchical Language Model) pattern.
Result of a hierarchy delegation or escalation operation.
Human-in-the-Loop guardrail that requires human approval for certain actions.
Request for human approval of an agent action.
HTTP-based transport for remote agent communication.
A hub-spoke organization with a central hub agent and peripheral spoke agents.
Builder for creating HubSpoke instances.
Result of a hub-spoke operation.
Thread-safe in-memory implementation of
DecisionTraceStore.Directed weighted graph representing inter-agent interactions.
A directed, weighted edge in the interaction graph.
A node in the interaction graph representing an agent.
In-memory transport for agents in the same JVM.
Context passed to a
JudgePolicy during evaluation.Wraps any coordination execution with judge-at-cycle-end quality control.
Builder for JudgeCoordinator.
Result of a judged coordination cycle.
Strategy interface for evaluating coordination cycle output.
Decision produced by a
JudgePolicy after evaluating cycle output.Possible judge decisions.
A lazy agent pool that creates agents on demand and manages their lifecycle.
Builder for
LazyAgentPool.Linear concession strategy - concedes at a constant rate per round.
Detects livelock conditions in multi-agent systems.
Builder for LivelockDetector.
Result of livelock analysis.
Listener for livelock detection events.
A single livelock violation.
Type of livelock violation detected.
A
JudgePolicy that uses an LLM to evaluate coordination output.Builder for LLMJudgePolicy.
Load balancer for distributing tasks to spoke agents.
Load balancing strategies.
Defines loop termination conditions for workflow loops.
Tallies votes using majority-based methods: MAJORITY, SUPERMAJORITY, UNANIMOUS, and WEIGHTED.
Builder for creating MatrixOrganization instances.
A matrix organization with dual-reporting structure.
Result of a matrix organization operation.
Tracks mission progress for a Team.
Mission event.
Mission event types.
Listener for mission events.
Mission progress snapshot.
Mission status states.
Task execution record.
Task status states.
Monotonic concession protocol - all parties concede toward agreement.
Observes an AgentGroup's event bus and records all inter-agent interactions.
Summary statistics for an observation session.
Multi-round Contract Net Protocol (CNP) implementation.
Builder for MultiRoundContractNet.
Listener for negotiation events.
Result of a negotiation round.
Represents a task to be negotiated.
Strategy for evaluating proposals.
Source of contractor proposals.
Configuration for a negotiation session, typically extracted from
@Coordination.Negotiation.Orchestrator that resolves the appropriate
NegotiationProtocol
from a NegotiationConfig and executes the negotiation.Callback interface for observing negotiation events.
Extracts
NegotiationConfig from @Coordination.Negotiation annotation metadata.An offer made during a negotiation.
The result of a completed negotiation.
Interface for negotiation protocol implementations.
Lifecycle states for a negotiation session.
Strategy for detecting neighbors in a swarm.
A mesh network organization with peer-to-peer agent connections.
Builder for creating NetworkMesh instances.
Result of a network mesh operation (broadcast, route, etc.).
Outcome of an agent interaction for trust scoring.
Peer review executor where one agent produces and another reviews iteratively.
Builder for PeerReviewExecutor.
A single iteration of peer review.
Result of the peer review process.
Types of pheromone signals used in swarm communication.
Builder for creating PipelineOrganization instances.
Executes workflow steps in a sequential pipeline.
Tracks per-stage timing, throughput, and bottleneck metrics for a pipeline.
A sequential processing pipeline where tasks flow through ordered stages.
Result of a pipeline execution.
Configuration for a
LazyAgentPool.Listener for pool lifecycle events.
Snapshot of pool statistics.
Usage-pattern-based predictive activation for
LazyAgentPool.Represents a proposal from a contractor agent in the Contract-Net protocol.
FIPA Propose Interaction Protocol.
Base interface for protocol handlers in the TnsAI multi-agent communication system.
Callback interface for async sends.
Handler exception.
Protocol Manager - Orchestrates all communication paradigms for an agent.
Handler for publish-subscribe messaging.
Result of a publish operation.
FIPA Query Interaction Protocol.
Tallies votes using instant-runoff (ranked-choice) voting.
Aggregate ranking entry for a council member.
Recursive Open Meta-Agent (ROMA) task solver.
Result of a recursive solve operation.
Trace entry recording a step in the recursive solve process.
Represents a parent-child reporting relationship in a hierarchy.
FIPA Request Interaction Protocol.
Handler for synchronous request-reply messaging.
Resource limits for an
AgentThread.Aggregates results from multiple workers in the orchestrator-worker pattern.
Aggregation statistics.
Strategy for distributing rewards among coalition members.
Executes workflow steps as a Saga with compensation (rollback) support.
Runs agent actions in a sandboxed context with resource limits.
Configuration for sandboxed execution.
Result of a sandboxed execution.
Scatter-Gather pattern for multi-agent communication.
Response from a single agent.
Aggregated responses from scatter operation.
Manages group work sessions with start/end tracking.
A work session for a group.
States a session can be in.
Thread-safe shared key-value store for group members.
Represents a single stage in a processing pipeline.
Connects two pipeline stages with optional input transformation.
A typed streaming channel for inter-agent communication with configurable backpressure.
Exception thrown when backpressure strategy is ERROR and buffer is full.
Channel metrics snapshot.
A sub-goal decomposed from a parent goal, assigned to a specific agent.
Wraps an AgentGroup and applies guardrails to all member actions.
Swarm is a decentralized agent group with emergent behavior.
Defines the collective behavior patterns for a Swarm.
Builder for creating Swarm instances.
Shared environment for swarm coordination.
Swarm intelligence algorithm for collective problem solving.
Result of a swarm operation (explore or solve).
Individual agent's contribution to the swarm task.
Snapshot of swarm state at a point in time.
Represents a task to be executed by a worker agent.
Decomposes a complex task into smaller sub-tasks.
Thread-safe priority-based task queue for orchestrator-worker pattern.
Represents the result of a task execution.
Builder for TaskResult.
A mission-oriented group of agents working toward a common goal.
Builder for creating Team instances.
Execution formation patterns for a Team.
Result of a team task execution.
Individual member's output.
Roles that can be assigned to team members.
Events emitted by
AgentThread during its lifecycle.Exception thrown by thread operations.
Exception for invalid state transitions.
Exception for quota violations.
Exception for recovery failures.
Manages the lifecycle of
AgentThreads.Configuration for an
AgentThread.Represents the lifecycle state of an
AgentThread.Tracks resource usage for an
AgentThread.Snapshot for serialization.
A
JudgePolicy that approves output when a numeric score meets a threshold.Time-dependent concession strategy - concession rate depends on time pressure.
Tit-for-tat concession strategy - mirrors the opponent's last concession.
Per-agent token budget management for multi-agent orchestration.
Network topology types for mesh organizations.
Transport interface for sending messages between agents.
Callback interface for async sends.
Transport exception.
Routes tasks to agents based on their trust scores.
Central registry for agent trust scores.
Represents a trust score for an agent on a specific capability.
Strategy for updating trust scores based on interaction outcomes.
Quality gate that verifies whether a result meets acceptance criteria.
Verification result containing acceptance status and optional feedback.
Represents a single vote cast by a voter.
Configuration for a voting session.
Listener for voting session events.
Message types for the voting protocol.
Available voting methods for consensus building.
Result of a completed voting session.
Manages a pool of worker agents for the orchestrator-worker pattern.
Pool statistics.
Worker status tracking.
Shared context passed through workflow steps.
Result of a single workflow step execution.
Result of a complete workflow execution.
A single step in a workflow execution plan.