open-multi-agent/open-multi-agent

Features

• Multi-Agent Orchestration Systems - Coordinates multiple specialized AI agents to execute complex collaborative workflows through a shared state and task graph.
• Goal-Based Workflow Generators - Transforms natural language goals into executable multi-agent task graphs and coordinates their execution.
• AI-Driven Decomposers - Uses LLMs to decompose high-level natural language goals into a directed acyclic graph of executable tasks.
• Multi-Agent Consensus Systems - Coordinates a proposer-judge consensus protocol where multiple agents cross-validate results to reach a final agreement.
• Agentic Workflow Orchestration - Orchestrates multi-agent workflows by decomposing goals into dynamic task graphs for execution and synthesis.
• Stateful Workflow Persistence - Maintains a persistence layer for task progress and conversation state to resume interrupted agent runs.
• Agent Result Aggregators - Aggregates and synthesizes outputs from multiple completed agent tasks into a single coherent final result.
• Multi-Agent Orchestration Frameworks - Provides a TypeScript framework for orchestrating multiple AI agents to collaborate on complex, natural-language goals.
• Agent Tool Execution - Enables agents to invoke predefined functional tools for interaction with external systems during execution.
• Agent Tool Integrations - Integrates agents with custom external functions, filesystem sandboxes, and protocol servers to extend capabilities.
• Model Provider Integrations - Provides unified interfaces to connect and configure various language model providers using SDKs and API keys.
• AI Agent Tool Integrations - Integrates language models with external functions, filesystem sandboxes, and protocol servers for real-world interactions.
• Agent Team Orchestration - Orchestrates teams of specialized agents by automatically decomposing goals into executable task graphs.
• Model Request Routing - Directs API requests to different AI backends based on matching rules to balance performance and cost.
• Task-Specific Model Assignments - Matches tasks to specific model providers using a first-match policy based on roles and phases.
• Conversation History Management - Provides conversation history management using sliding windows and summarization to avoid hitting model token limits.
• Context Window Optimizations - Reduces token usage through sliding windows and summarization strategies to maximize available LLM context space.
• Consensus Verification Hooks - Implements a proposer and judge pattern with verification hooks to ensure the accuracy and quality of task outputs.
• Execution Checkpointing - Provides programmatic access to load, inspect, or delete snapshots of workflow progress.
• Model Routing Policies - Assigns specific language models to tasks based on agent roles, priority, or execution phase.
• Agent Run Snapshots - Snapshots the state of a multi-agent run so it can be resumed from the last checkpoint after a failure.
• Conversation History Compression - Swaps previously used tool results for concise markers in history to reclaim limited token budget.
• Task Orchestration Systems - Transforms high-level objectives into a directed acyclic graph of parallel and sequential tasks for AI agents.
• Workflow State Persistences - Saves the state of task execution chains to allow restarts from the last completed step.
• Agent Execution Traces - Streams structured trace events to external backends for auditing and debugging orchestration runs.
• Log Persistence After Crashes - Periodically snapshots run state to ensure work is not lost after a system failure.
• Agent Working Directory Mounts - Constrains file operations to a per-agent working directory to ensure secure and isolated filesystem access.
• Cross-Agent Context Sharing - Maintains a namespaced key-value store allowing multiple agents to share findings during execution.
• Agent Memory Management - Maintains continuity across agent interactions using pluggable backends for session data and shared state.
• State Checkpointing - Snapshots the task graph and agent memory to a persistent store to enable recovery after interruptions.
• Workflow State Recovery - Reloads a saved state, rebuilds the task queue, and executes only pending actions to recover from aborts.
• Filesystem Access Controls - Prevents symlink escapes and enforces directory boundaries for built-in filesystem tools used by agents.
• Proposer-Judge Consensus - Implements a proposer-judge consensus protocol to validate and finalize AI-generated results.
• DAG Workflow Executions - Decomposes natural language goals into directed acyclic graphs for parallel and sequential task execution.
• Filesystem Root Restrictions - Restricts agent file operations to a specific root directory by resolving absolute paths to prevent escape.
• Parallel Task Execution - Executes independent tasks within a dependency graph concurrently to reduce total processing time.
• Sandboxed File APIs - Restricts agent file operations to a specified root directory to prevent unauthorized filesystem access.
• Observability Tracing - Tracks execution progress through event streams and spans for observability and debugging.
• Model Execution Spans - Generates detailed spans including durations and token counts for model calls and tool executions.
• Model Operation Tracing - Captures structured spans of tool executions and model calls with durations and token counts.
• Quorum-Based Verification - Runs a proposer-judge loop that requires a quorum of judges to accept and finalize a result.
• Proposer-Judge Consensus Protocols - Validates agent outputs by looping through a proposer and a quorum of judges to refute or accept results.
• Tool Result Excerptors - Caps raw output length for agent tools by trimming long responses into head and tail excerpts.
• Agent Tool Extensions - Registers a user-defined tool via configuration or programmatically to make it available to an agent without filtering.
• Custom Tool and Reward Definitions - Allows the creation of custom tool capabilities with input and output schemas to extend agent functionality.
• Tool Access Controls - Gates agent tool access by assigning capabilities only when explicitly listed or configured via presets.
• Tool Assigners - Manages agent capabilities by assigning specific tools and presets via allowlists.
• MCP Server Connections - Supports establishing connections to external MCP servers to expose their tools to agents.
• AI Observability Tracing - Streams structured execution spans and visualizes task dependency graphs for auditing agent behavior.
• Automation Workflows - Automates multi-step processes by decomposing high-level objectives into manageable tasks for AI models.
• Context Management Tools - Manages token budgets and conversation history using sliding windows, summarization, and tool output truncation.
• Conversation History Compression - Controls how the conversation shrinks as it grows by selecting a window, summarization, or custom compression strategy.
• Built-In Tool Configurations - Requires agents to explicitly list the built-in tools they are permitted to use via allowlists.
• Model Provider Configurations - Provides mechanisms to manage API keys, model selection, and configuration for various AI model providers.
• Tool Output Truncators - Implements raw character count limits on tool results by truncating long outputs into head and tail excerpts.
• Tool Output Compression - Truncates or compresses tool outputs to ensure predictable token consumption within the context window.
• Context-Aware Result Compression - Replaces processed tool outputs with short markers before new model calls to recover token space.
• Result Visualizations - Visualizes the executed task graph along with timing and status details in a dashboard.
• Tool Output Truncation - Truncates raw tool results into head-and-tail excerpts to prevent context window overflow.
• LLM Schema Outputs - Produces typed, schema-validated results from orchestrated agent runs to ensure structural consistency.
• Shared State Persisters - Implements a namespaced key-value store for persisting and sharing state across multiple agents in a workflow.
• Agent Flow Visualizations - Generates a visual representation of the post-execution task DAG and outcomes.
• LLM-Optimized Tool Outputs - Optimizes tool execution results through truncation and validation for efficient consumption by language models.
• Step-Level Checkpoints - Persists the state of the task graph after each step to enable resuming workflows after a crash.
• Task Pause and Resume Controls - Snapshots the run state to allow processes to survive crashes and resume from the last known point.
• Consensus Auditing - Records judge verdicts and dissenting opinions to allow auditing of the agent consensus process.
• Tool Access Controls - Assigns predefined sets of filesystem tools to agents using configuration presets for streamlined access control.
• Allowlist and Deny Rule Middleware - Implements middleware that intersects tool presets with allowlists and denylists for fine-grained agent permissions.
• Orchestration Configuration Files - Provides JSON-based configuration for defining agent roles, model settings, and filesystem sandbox roots.
• Workflow Visualizers - Produces a self-contained HTML dashboard visualizing the task dependency graph and results.
• Execution Trace Streams - Streams structured spans and lifecycle events to external backends for observability and post-run DAG visualization.
• Consensus-Based Result Validation - Validates task results via a consensus process that replaces outputs if the judges disagree.
• Parallel Task Executors - Executes independent tasks in a directed acyclic graph concurrently while respecting dependency constraints.
• Activity Progress Monitors - Triggers lifecycle events for tasks and agents to provide real-time progress updates.
• Conversation Cost Aggregators - Validates and truncates tool results to manage conversation size and reduce input token costs.
• Execution Result Dashboards - Renders a static HTML page visualizing the executed task graph with timing and token usage.
• Consensus Auditing - Emits judge verdicts as trace events and captures dissenting critiques for inspection.
• Agent Input and Output Validators - Ensures agent results adhere to specific types and schemas before they are synthesized into a final response.
• Provider-Agnostic LLM Routing - Provides a routing layer to assign specific LLM providers to tasks based on orchestration phases and agent roles.
• Task Progress Streams - Pushes lightweight lifecycle events for tasks and agents during execution for real-time logging.
• Orchestration Progress Streams - Emits real-time updates as the coordinator decomposes and assigns tasks to agents.

Star history