Invisible Dots is a self-hosted, open-source platform for deploying and managing persistent AI agents ('Dots'). Each Dot operates within its own dedicated QEMU virtual machine, providing a secure, isolated environment with a full Linux desktop, browser, and file system. The platform is designed for undetectability and long-running autonomy, serving as an open-source alternative to proprietary agent services. The system is a polyglot monorepo with a strict separation between the host control plane (TypeScript) and the guest agent (Go) and engine (Python). The host manages VM lifecycle, scheduling, a web UI, CLI, and messaging channels (Telegram/WhatsApp). The guest runs a Go daemon for low-level system access and a Python engine (forked from nanobot) that orchestrates LLM calls, tool execution, and permissions. Key features include a granular permission system with approval workflows, a cron-like task/automation system, cost capping per task, and a comprehensive benchmark suite for evaluating agent capabilities. The codebase demonstrates exceptional engineering craftsmanship with clean abstractions (Database, Channels, Computer), robust testing strategies (contract tests, fakes, e2e), and reusable utility libraries (ISO writer, SSE parser, atomic file operations). While primarily an application, the project includes a significant research-oriented benchmark suite (tests/bench) and the engine itself is a research fork (nanobot), giving it a hybrid character. The core value, however, is as a production-grade application platform.
Memoh is an open-source, full-stack AI agent platform that provides each agent with an isolated cloud computer (filesystem, desktop, browser, network, long-term memory). The system is built around a Go backend with Echo HTTP and gRPC, Vue 3 frontend with Pinia, and an Electron desktop shell. It supports multiple agent runtimes (native, ACP, Codex, Claude Code), a wide range of messaging channels (Telegram, Discord, Feishu, WeChat, LINE, DingTalk, etc.), and container-based workspaces via containerd or Docker. The architecture is a monolith with clearly separated packages for channel adapters, context management, session orchestration, and tool execution. The codebase demonstrates high engineering craftsmanship with extensive test coverage, sophisticated concurrency patterns (runtime fences, decision waiters, atomic compaction barriers), and a modular context fragment system for prompt assembly. It is actively maintained with frequent commits, thorough CI/CD, and over 140 database migrations.
OpenClaw is a comprehensive self-hosted AI agent control plane that orchestrates autonomous tasks across multiple communication channels and LLM providers. The system functions as a gateway-server architecture, managing agent sessions, tool execution, and persistent memory via SQLite. It features a robust plugin system that decouples channel integrations (Discord, Telegram, WhatsApp, etc.) and model providers (OpenAI, Anthropic, Ollama) from the core runtime, allowing for extensible capabilities without modifying the base application. The platform supports cross-platform deployment including a Node.js CLI, a WebSocket-based gateway, and native companion applications for macOS, iOS, and Android. The architecture emphasizes security and safety, implementing sandboxed tool execution via Docker, strict file system safety wrappers, and centralized secret management. It utilizes a monorepo structure with pnpm, featuring extensive test coverage through Vitest and contract testing to ensure plugin compatibility. The codebase demonstrates high craftsmanship in its plugin SDK design, configuration validation using Zod schemas, and security patterns for exec approval and SSRF guards. However, the sheer scale of the repository (20k+ files) and the high volume of open issues (6745) indicate significant complexity and maintenance overhead. While the project is actively maintained with recent commits, the technical drift is moderate due to the reliance on volatile external APIs (messaging channels, LLM providers) and the use of bleeding-edge dependencies like Node 24. The codebase is suitable for engineers seeking a production-grade, extensible agent platform, though the complexity requires careful navigation. The quality is high, with reusable components for security, configuration, and plugin architecture, but the issue backlog suggests ongoing architectural challenges.
FastGPT is a production-grade AI Agent building platform that enables users to create, deploy, and manage AI applications through a visual workflow editor. The system provides a full-stack solution including a Next.js frontend with Chakra UI, a comprehensive REST API layer, and a modular backend architecture. Core capabilities include a workflow engine with agent loops, tool calling, dataset (knowledge base) management with vector search, sandboxed code execution (JS/Python), multi-tenant team management with fine-grained permissions, billing and usage tracking, and integration with external platforms (WeChat, Feishu, Dingtalk, MCP). The platform is designed for both open-source community and commercial deployments, with feature gating via license activation. The codebase is organized as a monorepo with clear separation of concerns: shared types and constants in `packages/global`, business logic in `packages/service`, UI components in `packages/web`, data access layer in `packages/dal`, and separate services for sandbox execution and volume management. It relies on MongoDB, Redis, BullMQ, S3-compatible storage, and multiple vector database backends (PG, Milvus, OceanBase, SeekDB, OpenGauss). The architecture is predominantly monolithic with the main application as a Next.js app, but sandbox and volume manager run as independent services, indicating a hybrid monolith/microservices pattern.
Hermes Studio is a self-hosted AI agent orchestration platform providing a unified interface for multiple AI agents (Hermes, Ekko, Claude Code, Codex, Pi) with chat, workflow automation, agent management, and skill-based extensibility. The architecture features a Vue 3 frontend, Node.js/Koa backend, Electron desktop client, and hybrid TypeScript/Python agent runtime. Key capabilities include real-time collaboration via Socket.IO, voice processing with multiple STT/TTS providers, file management with preview capabilities, usage analytics, and Model Context Protocol (MCP) integration for extending agent tools. The platform supports social messaging integrations (Feishu, Telegram, Weixin) and MCU device support for embedded voice processing.
Manifold is an AI agent platform enabling multi-step workflow automation through teams of AI assistants. The system provides a chat interface for interacting with configurable specialist agents, a visual workflow editor (WARPP) for creating reusable automation, and an experimentation playground for testing prompts and models. Built with a Go backend and Vue.js frontend, it features extensible tool systems, layered memory architectures (belief, evolving, decision), MCP integration for external tools, and comprehensive observability via OpenTelemetry. The architecture emphasizes modularity with clear separation between agent execution, persistence, tool discovery, and memory subsystems.
ClawDeckX is a desktop/web application that provides a management interface for the OpenClaw AI gateway. It enables users to configure and manage AI agent collaborations, monitor system metrics, install extensions, and access a template marketplace for agent configurations. The application features a Go backend with REST API and WebSocket endpoints, a React/TypeScript frontend, and uses SQLite/PostgreSQL for data storage. Key capabilities include real-time agent room collaboration, configuration management, multi-agent workflow orchestration, notification systems, and cross-platform deployment options.
MultiGen is an AI agent platform designed for private, on-premise deployment. It features a planner-react architecture where a planner agent creates task plans and a react agent executes them using various tools (web browsing, shell commands, file operations, multimodal generation). The system maintains persistent session history via PostgreSQL, enabling conversation continuity and agent memory retention. Extensibility is supported through Model Context Protocol (MCP) and Agent-to-Agent (A2A) integrations. The backend is built with FastAPI using a layered architecture (Interface/Application/Domain/Infrastructure), the frontend with Next.js 14 App Router, and execution occurs in a sandboxed Docker container with Ubuntu, Chrome, and VNC. Real-time updates are delivered via Server-Sent Events (SSE) powered by Redis streams.
This repository is a production-grade, full-stack enterprise AI agent platform developed by iFlytek (Astron Agent). The system allows organizations to create, configure, deploy, and manage conversational AI agents (bots) with advanced workflow automation, knowledge retrieval (multi-strategy RAG), a plugin ecosystem (including MCP and HTTP tools), and multi-tenant team collaboration. The architecture is polyglot and service-oriented: a Java Spring Boot console backend handles bot lifecycle management, publishing to channels (API, WeChat, Feishu, marketplace), RBAC permissions, enterprise spaces, and notification systems. Python FastAPI core services power the workflow engine (20+ node types including LLM, code, decision, memory, knowledge), agent runtime with skill sandbox execution, knowledge indexing and retrieval, and plugin integrations (link server, RPA, MCP). A Go service manages tenant authentication and app key verification. The React + TypeScript frontend provides an interactive console for workflow design, model management, resource management (databases, knowledge bases, skill files), trace logs, and chat interfaces. External dependencies include multiple LLM providers (iFlytek Spark, OpenAI, Anthropic, Google, DeepSeek), MySQL, Redis, Kafka, S3-compatible storage, and Casdoor for SSO. The codebase demonstrates professional engineering with test coverage (JUnit, pytest, Jest), Flyway and Alembic database migrations, CI/CD pipelines, and a modular design using strategy, factory, and AOP patterns. However, it shows signs of complexity from polyglot maintenance, some duplicated frontend components, and legacy credential handling that has been addressed through targeted migration fixes. Overall, it is a well-maintained, actively developed platform suitable for mid-to-large enterprise deployments.
Magic is a large, polyglot enterprise AI-agent and collaboration platform. The production core is a PHP Hyperf backend (`backend/magic-service`) with strict DDD layering, a Python agent runtime (`backend/super-magic`) for tools/skills/browser automation, a Go engine for knowledge processing/embedding, and a React/TypeScript frontend (`frontend/magic-web`) that spans desktop, mobile, admin, and a visual flow editor. The platform delivers chat/messaging, AI agents, workflow automation (MagicFlow), knowledge bases with vector search, an LLM/model gateway, file storage, low-code data tables (MagicBase), MCP integration, and multi-channel bot deployment (DingTalk, Feishu, WeCom). It is fundamentally an application rather than a research repository; the knowledge-base and data-processing subsystems serve product features, not analysis. Architecturally, the strongest parts are the PHP library packages — async-event, cloudfile, flow-expr-engine, code-executor, and easy-dingtalk — which are cleanly separated and demonstrate genuine, extractable craftsmanship. The frontend likewise includes reusable packages for flow editing, HTML-to-PPTX conversion, and UI components. However, the repository is physically enormous and shows maintenance risk: substantial code duplication exists between `backend/magic-service` and `backend/super-magic-module`, several enterprise features are intentionally stubbed out with open-source no-ops, migration rollback methods are frequently empty, and the mix of PHP, Python, Go, and TypeScript adds integration complexity. The codebase is actively developed, but quality is uneven across the many modules.