OpenManus is an open-source framework for building general AI agents, inspired by the Manus agent. It provides a modular architecture with a hierarchy of agents (BaseAgent, ReActAgent, ToolCallAgent, Manus, SWEAgent, BrowserAgent, etc.), a rich set of tools (bash, file editing, web search, browser automation, code execution, chart visualization, desktop automation), and multiple execution modes: single-agent CLI, multi-agent planning flow, MCP client/server, and sandboxed execution via Docker or Daytona. The system is LLM-agnostic, supporting OpenAI, Anthropic, Azure, AWS Bedrock, Ollama, and others through a configurable LLM abstraction. It also implements the A2A (Agent-to-Agent) protocol for inter-agent communication. While primarily an application framework, it includes data analysis and chart generation capabilities, giving it a hybrid character. The codebase is well-structured with clean abstractions, but contains some hardcoded values and Chinese comments that may hinder maintainability.
OxyGent is a production-grade Python multi-agent system (MAS) framework that unifies LLMs, agents, tools, and flows into a declarative component model. It provides a runtime container (MAS) that orchestrates agent loops (ReAct, Chat, Workflow, PlanAndSolve, Parallel, Reflexion), tool execution (via MCP protocol, FunctionHub decorators, HTTP tools, bank tools), and communication (SSE streaming, A2A protocol for cross-framework interop). The framework ships with a FastAPI web service offering chat, evaluation, prompt management, and SSE endpoints, as well as a built-in web UI. A reference application, OxyBank, demonstrates full-stack data annotation with document ingestion, vector search (Vearch), and annotation agents. The architecture is plugin-based: components reference each other by name, and the MAS container handles lifecycle, wiring, and persistence (Elasticsearch, Redis, Vearch, local fallbacks). OxyGent supports distributed deployments via SSEOxyGent and A2AClientAgent, and integrates with LangChain, LangGraph, AgentScope, and Google A2A SDK. The codebase is well-tested with unit, integration, and regression tests, and includes extensive bilingual documentation.
The Agent2Agent (A2A) Protocol repository defines an open standard for AI agent interoperability. It maintains the canonical Protocol Buffers specification (`a2a.proto`) that defines core data structures (AgentCard, Task, Message, Part, Artifact) and service interfaces for agent communication. The repository includes comprehensive documentation, build scripts for generating JSON Schema and SDK docs, and CI/CD pipelines for validation. Rather than being a runnable application, it serves as a specification foundation for implementing A2A-compliant agents across multiple languages and frameworks. The protocol supports multiple bindings (JSON-RPC, gRPC, HTTP/REST), features like agent discovery via Agent Cards, task-based interaction patterns, streaming, push notifications, and enterprise capabilities including multi-tenancy and modern OAuth 2.0 flows.
Conductor is a production-grade workflow orchestration engine originally built at Netflix, now maintained by Orkes and the community. It provides durable execution for microservices, AI agents, and adaptive workflow graphs. The system defines workflows as versioned JSON DAGs with support for dynamic forks, loops, retries, timeouts, cancellation, pause/resume, and human-in-the-loop approvals. It has a modular Spring Boot backend with multiple persistence backends (PostgreSQL, MySQL, Cassandra, Redis, SQLite, Elasticsearch/OpenSearch) and event queue integrations (AMQP, NATS, SQS). The frontend is a modern React application with XState state machines, Material-UI, and a plugin system for extensibility. The codebase also includes a comprehensive AI integration layer with LLM providers (OpenAI, Anthropic, Gemini, etc.), vector databases, MCP tool calling, and the A2A agent-to-agent protocol. The architecture is microservices-ready with REST and gRPC APIs, a scheduler for cron-based workflows, and external payload storage (S3, GCS, Azure Blob). The project is actively maintained with a large community, but shows signs of technical drift due to multiple persistence backends, two coexisting UI codebases (legacy and modern), and some deprecated components.
The google/adk-go repository is a production-grade, open-source Go framework for building, orchestrating, and deploying multi-agent AI systems. It provides a comprehensive set of abstractions including agents, workflows, tool integrations, model backends (Gemini, OpenAI, Apigee), session management, artifact storage, and human-in-the-loop (HITL) support. The architecture centers around a workflow engine that supports graph-based execution with nodes, edges, retry, concurrency, and dynamic branching. It also implements agent-to-agent (A2A) and Model Context Protocol (MCP) for inter-agent communication. The framework is designed to be deployed via REST API, WebSocket, SSE, or as a console application, and includes launchers for Google Cloud Run and Vertex AI Agent Engine. While primarily an application framework, it also includes telemetry and analytics plugins for observability. The codebase is well-structured with extensive unit and integration tests, but some internal packages and experimental features (e.g., OpenAI model adapter) indicate ongoing development and potential for interface drift.
This Rust codebase is an LLM inference proxy and tool-routing gateway. It exposes an OpenAI-compatible HTTP API (`/v1/chat/completions`, `/v1/models`) and forwards requests to multiple upstream LLM providers (OpenAI, Anthropic via direct/Bedrock, Vertex AI, vLLM DeepSeek, TokenHub) through a unified Provider trait. A QUIC server (s2n-quic, TLS 1.3) accepts connections from serverless tools written in Go or Node.js; the agent loop performs multi-round tool calling, invokes registered tools, and streams results back in SSE format. A separate model API proxy layer handles non-chat endpoint shapes (messages, responses, generateContent) with usage extraction and injection. Architecturally, the system is a Rust CLI binary (`yomo`) with three subcommands: `serve` starts the HTTP API and QUIC zipper, `init` scaffolds serverless tool projects, and `run` launches a tool subprocess and connects it to the zipper. Tool registration is done at runtime over QUIC and stored in-memory, so state is lost on restart. The HTTP layer is Axum, auth is bearer-token, and observability uses OpenTelemetry. The serverless execution model is subprocess-based: it creates temporary directories, runs `npm install`/`go mod tidy`, and exchanges metadata over stdout. Reusable engineering exists in the framing protocol (`io`), streaming SSE mappers, usage aggregation logic, TLS configuration, and provider error separation. However, the provider implementations are duplicated and brittle to upstream API drift; hard-coded model limits, ephemeral tool state, and near-empty serverless stubs reduce long-term maintainability. No integration tests against real upstream APIs were found in the reviewed surface.
This repository implements the Agent-to-Agent (A2A) protocol in Python. It is a comprehensive SDK providing both server and client libraries for building interoperable agent systems. The architecture is modular with abstract interfaces (AgentExecutor, TaskStore, ClientTransport) and supports multiple transports: JSON‑RPC, REST/HTTP+JSON, and gRPC, with a full backward‑compatibility layer for v0.3. Key features include agent card signing/verification (JCS canonicalization), push notifications, event streaming, and database persistence via SQLAlchemy. The codebase is well-structured with extensive automated testing (unit, integration, cross‑version, and conformance), CI/CD pipelines, and release automation. While primarily an SDK for protocol compliance, it also includes a sample agent application and an interop test kit.
rsclaw is a production-grade AI agent gateway and runtime written in Rust, with a React/Tauri desktop UI. It provides a local-first autonomous agent engine that routes messages through 13+ messaging channels (WeChat, Telegram, Discord, Slack, Feishu, etc.) to any of 15+ LLM providers (Anthropic, OpenAI, Gemini, Grok, DeepSeek, etc.). The core architecture is a WebSocket gateway that manages agent sessions, tool execution, memory persistence, skill invocation, and a knowledge base RAG pipeline. Key subsystems include a computer-use GUI agent (native + browser + ADB + iPhone Mirror operators), a plugin system (WASM, JS subprocess, Codex bundles), an agent-to-agent (A2A) protocol for distributed orchestration, and a three-tier memory store (redb KV + Tantivy FTS + HNSW vectors). The binary is a single compiled crate (~21MB) with no Node.js runtime dependency for the backend. The accompanying Next.js web UI and Tauri desktop shell provide a ChatGPT-like chat interface, memory management, model configuration, and computer-use overlays. While primarily an application, the knowledge base and memory subsystems incorporate significant data engineering patterns: content-aware chunking, hybrid vector/FTS search, entity extraction, and a job-based ingestion pipeline with leadership/leaderboard semantics.
OpenCrew is a multi-agent operating system designed to extend OpenClaw into a manageable AI team. It enables users to create specialized agents (Chief of Staff, CTO, Builder, CIO, Knowledge Officer, Operations, Research) that collaborate through messaging platforms like Slack, Discord, and Feishu. The system implements structured collaboration through role-based channels, thread-based task isolation, and agent-to-agent communication protocols. Key features include autonomy levels (L0-L3), task classification (QAPS), two-mode agent collaboration (delegation and discussion), and three-layer knowledge distillation. The application is actively maintained with recent updates focusing on cross-agent collaboration capabilities.
Solace Agent Mesh is a production-grade, full-stack platform for building, deploying, and managing event-driven multi-agent AI systems. It comprises a Python backend (FastAPI, Google ADK, SAC), a React/TypeScript web UI (chat, projects, workflows, prompts, scheduled tasks), a Click-based CLI, and a Docusaurus documentation site. The system uses a microservices-like architecture with separate gateway (HTTP/SSE), platform service (model configuration, storage), and agent components, all communicating via the Solace event broker and the A2A (Agent-to-Agent) protocol. Key entry points include the CLI (`solace-agent-mesh`), the web UI (`/chat`, `/projects`, `/workflows`), and the REST API (`/api/v1`). Data flows involve user requests via SSE, agent orchestration with workflow DAGs, tool execution (built-in, MCP, OpenAPI), artifact storage (S3/GCS/Azure/filesystem), and session persistence in SQL databases (SQLite/PostgreSQL/MySQL). External dependencies include a Solace broker, LLM endpoints (LiteLLM), optional databases, and cloud storage services. The repository is marked as deprecated (Development Status 7 – Inactive), with the new version being a desktop application.