Shannon is an autonomous, white-box AI penetration testing platform that orchestrates multi-agent workflows via Temporal to analyze source code, identify attack vectors, and execute real exploits against running web applications. The system is structured as a pnpm monorepo with two primary applications: a CLI (`apps/cli`) that provides the user-facing interface for launching scans, and a worker (`apps/worker`) that runs the actual pentest pipeline inside Docker containers. The architecture follows a multi-agent pipeline pattern with 13 specialized agents (pre-recon, recon, 5 vulnerability analyzers, 5 exploiters, and a report generator) coordinated through Temporal workflows for reliability and resumability. The codebase demonstrates strong software engineering practices with a clear separation of concerns between Temporal orchestration (activities/workflows), pure domain logic (services), and infrastructure concerns. The worker implements a sophisticated DI container pattern, comprehensive audit logging with crash-safe append-only streams, and a custom error classification system that maps errors to Temporal retry behavior. The system supports multiple LLM providers (Anthropic direct, AWS Bedrock, Google Vertex AI, custom proxies) and implements defense-in-depth billing detection, git checkpointing for workspace rollback, and parallel agent execution with mutex-protected shared state. Key architectural strengths include the deterministic renderer pattern (MCP tool calls → markdown without LLM in the loop), the injectable provider interfaces for extensibility, and the sophisticated session management that enables resumable workspaces. The codebase uses TypeScript with strict compiler options, implements a Result type for explicit error handling, and maintains comprehensive type definitions. The CI/CD pipeline includes semantic releases, Docker image signing with cosign, and multi-platform builds. The system processes vulnerability queues through Zod-validated structured outputs and maintains forensic audit trails of all agent executions with timing, cost, and model metadata.
Oh-My-ClaudeCode (OMC) is a multi-agent orchestration layer for Claude Code, Anthropic's AI coding assistant. It extends Claude Code with a plugin system, custom MCP tools, a team collaboration engine, a real-time HUD, and a rich hook system. The system is implemented in TypeScript and runs as a CLI tool (`omc`), an npm package (`oh-my-claude-sisyphus`), and a Claude Code plugin. It manages autonomous coding pipelines (autopilot, ralph), multi-worker team sessions via tmux, skill learning and injection, and provides extensive tooling including LSP integration, AST analysis, Python REPL, and git-based checkpoints. Architecturally, OMC is a modular monolith with clear separation: a CLI entry point (Commander-based), a hook registry with ~20+ lifecycle hooks (session-end, pre-tool-use, persistent-mode, etc.), a team subsystem with state machines and tmux-based worker management, a HUD rendering engine, and a standalone MCP server exposing 33+ tools. The system integrates with multiple AI providers (Claude, Codex, Gemini, Grok, Cursor) and git hosting providers (GitHub, GitLab, Azure DevOps, Bitbucket, Gitea). External dependencies include `@anthropic-ai/claude-agent-sdk`, `@modelcontextprotocol/sdk`, `better-sqlite3`, `zod`, and `commander`. Key data flows include: user input → CLI or Claude Code hook → hook dispatcher → feature modules (autopilot, team, skills) → tool execution → state persistence (filesystem, SQLite). The system maintains extensive state on disk (`.omc/state/`, session transcripts, team events, skill files) and uses file-based locking for concurrency safety. The JEV shadow judgment system provides non-blocking evaluation of heuristic decisions against an external API for quality monitoring. The codebase demonstrates strong engineering practices: extensive test coverage (~3000+ tests), modular architecture with clear interfaces, atomic file operations, and security-conscious utilities (SSRF guard, token redaction, path traversal prevention). It is actively maintained with frequent releases and responsive issue triage.
Swarm is a production-grade Swift-native agent runtime framework for building multi-agent conversational systems with type-safe tools, on-device Apple Foundation Models, composable workflows, memory, guardrails, and observability. The architecture is modular: core agent execution (Agent, Workflow, Job) with pluggable inference providers (Foundation Models, OpenAI-compatible, mock), memory backends (conversation, sliding window, summary, vector, persistent via SwiftData or Wax SQLite), and tool integration (built-in tools, MCP protocol, web search). Key entry points include Agent.run()/stream(), Workflow.execute(), and the SwarmMCPServerService for exposing tools via MCP. Data flows involve agent turns with tool calls, memory retrieval/consolidation, and durable workflow checkpointing via the HiveCore deterministic runtime. External dependencies include Apple FoundationModels (macOS 26+), swift-log, swift-syntax (for macros), and optional Wax (SQLite vector store) and OpenTelemetry SDK. The framework emphasizes compile-time safety via @Tool and @Agent macros, and provides resilience patterns (retry, fallback, circuit breaker, rate limiting) and observability (tracing, metrics, OpenTelemetry).
oh-my-codex is a multi-agent orchestration CLI tool extending OpenAI Codex with team coordination, workflow automation, and persistent infrastructure. It provides a command-line interface (omx) and a suite of native Rust binaries for tasks like tmux session management (omx-mux), command family execution (omx-sparkshell), and runtime replay (omx-runtime-core). The system orchestrates AI agents through states (autopilot, ralph, team, ultragoal), manages tmux-isolated worker panes, maintains a persistent wiki knowledge base with full-text query and linting, dispatches lifecycle notifications to Discord/Telegram/webhooks, and includes a hook plugin system with an SDK for implementing custom event handlers. It also features a VSCode extension for session management and a mission-driven research workflow (autoresearch) that executes evaluator-gated experiments. Architecturally, it is a hybrid Node.js CLI application with Rust sidecar binaries. The TypeScript core (src/) implements the CLI, state machines, team coordination, MCP servers, notification engine, and extensibility framework. Rust crates provide low-level tmux interaction, command execution with language-specific registries, and a replay-capable runtime core. The system integrates deeply with Codex CLI through native hooks and plugin marketplace, and supports platform-specific behavior for macOS, Linux, and Windows. The codebase is heavily tested (hundreds of unit/integration/contract tests), uses atomic file operations for state persistence, and employs file-based locking with heartbeat for cross-process coordination. While primarily an application, it includes a small data/research component: playground demos for Bayesian optimization and ML model tuning, and the autoresearch mission framework with evaluator scripts. However, these are peripheral to the main orchestration purpose. The repository demonstrates strong engineering practices with modular design, dependency injection for testability, and clear separation of concerns across systems (auth, adapters, notifications, team state, hooks, MCP). It is actively maintained with frequent releases and extensive QA documentation.
UmaDev is an AI-powered development agent that orchestrates multiple first-class AI coding CLIs (Claude Code, Codex, Grok Build, Kimi Code, OpenCode) as subprocesses, providing a unified terminal UI, governance, knowledge retrieval, and a spec-driven pipeline. It acts as a 'project manager' for AI coding agents, handling planning, execution, review, and acceptance. The architecture is a multi-crate Rust workspace with a TUI (ratatui), agent orchestration, governance engine, knowledge retrieval (BM25 + optional local embeddings), contract validation, and cross-platform process management. It is distributed via npm with platform-specific binaries. The codebase demonstrates high craftsmanship with pervasive fail-open patterns, bounded resource usage, and extensive testing. Key subsystems include a deterministic governance engine with 113 content checks, a hybrid retrieval system with CJK-aware tokenization, a cross-process run lock with boot-id liveness, and a host-owned Git commit transaction with rollback. While primarily an application, it includes a curated knowledge corpus (~400 markdown files) and an offline embedding model, giving it a hybrid character. The repository is actively maintained with a clear release pipeline and CI/CD. Notable design patterns include: fail-open governance (every check wrapped in catch_unwind), bounded file system operations (RootedDir with no-follow, size limits), circuit breaker for compaction, and source tree fingerprinting for freshness. The codebase is well-structured with clear separation of concerns across 11 crates, though some files are large hotspots (e.g., app.rs, director_loop.rs). Overall, it is a sophisticated, production-quality tool for AI-assisted software development.
ChatDev 2.0 (DevAll) is a zero-code multi-agent orchestration platform for building and executing graph-based AI workflows. Users define directed acyclic or cyclic graphs in YAML, composing agent nodes (with LLM providers, memory, tools, thinking modes), human-in-the-loop nodes, Python executors, subgraphs, and control-flow edges with conditions and data transformations. The system supports dynamic parallel execution patterns (Map/Tree), multiple memory stores (simple, file-based FAISS, cloud Mem0), and extensible tooling via local Python functions or MCP servers. The architecture is a full-stack application: a FastAPI backend with REST and WebSocket endpoints for workflow execution, batch runs, artifact streaming, and session management; a Vue 3 frontend with a visual workflow editor (VueFlow), dynamic schema-driven forms, and real-time execution monitoring; a CLI entry point (`run.py`); and a Python SDK (`runtime/sdk.py`) for programmatic use. The codebase is well-structured with registry patterns for extensibility, declarative configuration dataclasses with auto-generated UI forms, and a modular runtime with pluggable node executors, edge conditions, and memory stores. While primarily an application, the project has strong research roots (OpenBMB lab, Tsinghua NLP) and includes academic references (ChatDev, Co-Learning, MacNet). It serves as both a production-grade tool for multi-agent automation and a research platform for experimenting with agent architectures, memory systems, and collaborative workflows. The repository includes 20+ example workflows demonstrating diverse use cases from software development and data visualization to 3D scene generation and deep research.
Awesome Cursor Skills is a curated knowledge repository — an 'awesome list' that doubles as a library of 70 ready-to-use SKILL.md instruction files for Cursor's AI agent. Each skill is a self-contained markdown document with YAML frontmatter (name, description, user-invocable flag) and a body of workflow instructions, organized as resources/<slug>/SKILL.md. Skills cover browser-based QA (visual testing, accessibility auditing, responsive/dark-mode checks), testing (Playwright, TDD, parallel test fixing), CI triage, code review, security/performance auditing, auth/payments integration, infrastructure (Docker, Kubernetes, Terraform), and meta-skills for generating new skills, rules, and hooks. The README is the curation layer: a categorized index linking to in-repo skills, external community skills, and official Cursor marketplace plugins. This is a content library rather than a traditional software application — the only executable code is resources/generating-images/scripts/generate_image.py, a production-grade Python CLI wrapping OpenAI's gpt-image-2.
Mobilerun is a comprehensive CLI and Python SDK framework for controlling Android and iOS devices through natural language commands powered by LLM agents. It orchestrates multi-agent workflows (Manager, Executor, FastAgent) built on llama-index Workflows, with device interaction via ADB (Android) and a separate iOS binary (WebDriverAgent). The system supports multiple LLM providers (OpenAI, Anthropic, Gemini, xAI, DeepSeek, Ollama, etc.), including custom OAuth flows for subscription-based access (Anthropic Claude, Google Code Assist, xAI Grok). It features a configurable agent architecture with Jinja2 prompt templates, macro recording/replay, MCP-based custom tool integration, telemetry (PostHog), tracing (Phoenix, Langfuse), and a rich set of developer tools (device selection, configuration wizard, doctor, credential management). The codebase is well-tested with over 50 test files covering XML parsing, coordinate coordinate contracts, OAuth flows, and agent workflows. While there is some code duplication in OAuth implementations and tight coupling to llama-index internals, the overall architecture is modular and extensible. The project is in active development (version 0.7.0, Beta) with commercial ties to Mobilerun Cloud.
CCteam-creator is a Claude Code skill that enables multi-agent team orchestration through file-based planning and role-based collaboration. It sets up persistent agent teams with specialized roles (backend-dev, frontend-dev, researcher, e2e-tester, reviewer, custodian) that communicate via SendMessage while maintaining state in .plans/ directories. The system includes mechanisms for context recovery, team snapshots, doc-code synchronization, invariant-driven review, and automated code quality checks via golden_rules.py. Team-lead (the main conversation) acts as the control plane managing task delegation, phase gates, and operational protocols.
Opensquad is a multi-agent orchestration framework that enables users to create, manage, and run teams of AI agents (squads) for automated content workflows. The system is primarily a CLI tool (`npx opensquad init`) that bootstraps projects with agent definitions, pipeline configurations, and IDE integrations. It includes a Phaser-based 2D dashboard that visualizes agents working in a virtual office, updated in real-time via WebSocket. The architecture is file-based: squads are defined as YAML/Markdown files in `squads/`, pipelines as step sequences with bash validation gates, and skills as self-contained directories with `SKILL.md` manifests. The framework supports multiple content formats (Instagram carousels, blog posts, email newsletters) through a best-practices catalog and platform-specific Sherlock investigators that extract real engagement data from social media profiles. Key entry points include `bin/opensquad.js` (CLI dispatcher), `src/init.js` (project initialization), `src/update.js` (core file updates), `src/skills.js` (skill registry management), and `src/agents.js` (agent management). The dashboard is a React + Vite app with a Phaser scene (`OfficeScene.ts`) that renders pixel-art sprites and desks. External dependencies include Node.js 20+, Playwright (for browser automation and image rendering), and various MCP services (Apify, Canva, Blotato, Resend). The system is designed for non-technical users and emphasizes zero-config setup, progressive disclosure of complexity, and token-efficient phased execution (discovery → investigation → design → build).
PraisonAI is a production-oriented, multi-language AI agent orchestration framework shipped as a monorepo of cooperating Python, TypeScript, and Rust packages. The core SDK (`praisonaiagents`) implements `Agent`, `Task`, `AgentTeam`, and `AgentFlow`/`Workflow` abstractions with MCP support (stdio/HTTP/WebSocket/SSE), integration with 20+ LLM providers via LiteLLM-style configuration, memory backends (SQLite, file, mem0, MongoDB), RAG/knowledge bases over vector stores, guardrails, approval flows, policy engines, context compaction, telemetry, background jobs, and durable run ledgers. A user-facing `praisonai` wrapper provides a Typer CLI (`run`, `chat`, `code`, `serve mcp`, agent-as-API), bot adapters for Telegram/Discord/Slack via a WebSocket gateway, sandboxed compute (Docker, E2B, Modal, Daytona), deployment registries, cloud managed agents, and a fine-tuning package (`praisonai-train`). The repository is decisively an application/framework, though it carries data-research features as part of the product surface (RAG pipelines, evaluation loops, synthetic-data generation, LoRA fine-tuning), making it a hybrid in feature terms only.
AgentTeams is a production-grade multi-agent orchestration platform that manages teams of LLM-powered worker agents on Kubernetes. It uses a central Manager controller that reconciles Custom Resource Definitions (Worker, Team, Human, Manager) with container backends (Docker, K8s), a Matrix chat layer for all agent communication, and an AI Gateway (Higress) for credential isolation. The system supports multiple worker runtimes (OpenClaw, QwenPaw, Hermes, DeepSeek Harness) through a plugin architecture, provides a CLI tool (`agt`) for resource management, and includes human-in-the-loop oversight via Matrix rooms. Key features include STS token-based credential management, role-based authorization, audit logging, file synchronization via MinIO/OSS, and a skill discovery and distribution system. The codebase is heavily tested with unit, integration, and end-to-end tests, but shows moderate technical drift due to legacy runtime coexistence (CoPaw EOL migration) and some duplicated shell scripts across runtimes.
This repository is a comprehensive plugin marketplace and reference implementation for legal practice automation using Anthropic's Claude AI. It contains 12 first-party plugins (commercial, corporate, employment, privacy, product, regulatory, AI governance, IP, litigation, legal clinic, law student, and a builder hub) plus one vendor plugin from Thomson Reuters. Each plugin provides a set of 'skills' (prompt-engineered workflows) invoked via slash commands, a cold-start interview to configure the AI to a specific legal professional's role and preferences, and optional scheduled agents. The repo also includes five managed-agent cookbooks demonstrating multi-agent orchestration with tool isolation (read-only subagents, write leaf, orchestrator with no write access). While the vast majority of content is markdown prompt files, the repository also contains reusable Python and shell scripts for deployment, validation, and linting of agent configurations. The system is designed to be deployed on Claude Code or Claude Cowork, with MCP connectors for legal research tools, document management, and other integrations. It emphasizes citation provenance, injection defense, and consequential-action gates for non-lawyer users.
Youtu-Agent is a comprehensive AI agent framework developed by Tencent Cloud's Youtu Lab, designed for building, orchestrating, and evaluating LLM-powered agents. It provides a modular toolkit system, multi-agent orchestration patterns (simple, orchestra, orchestrator, workforce), a reusable configuration system (Hydra+YAML), and support for various environments (local shell, Docker, E2B sandbox, browser). The framework also includes a research-grade evaluation pipeline with benchmarks like GAIA, SWE-bench, WebWalkerQA, and a training-free GRPO module for agent self-improvement through experience distillation. Two front-end applications accompany the backend: a React-based chat UI and a Next.js evaluation analysis dashboard, both communicating via WebSocket and REST APIs. While the primary character is an application framework, Youtu-Agent has a strong data/research dimension: it ingests benchmark datasets, runs model-based judges, stores trajectories in SQL/PostgreSQL, and implements a meta-learning loop that extracts 'experiences' from agent behaviors. This hybrid nature makes it suitable both for production agent deployment and for conducting RL/benchmarking experiments. The codebase is well-organized into distinct modules (agents, tools, config, eval, practice, tracing, utils), uses modern Python packaging (uv, pyproject.toml), and includes extensive example configs and scripts. External dependencies include the openai-agents SDK, various LLM providers (OpenAI, Anthropic, etc. via litellm), search APIs (Serper, Jina, Google), document parsers (Chunkr, Unstructured), and MCP servers. Deployment supports Docker and multiple environment types. The repository is actively maintained with CI/CD, documentation (mkdocs), and a growing set of features.
UFO (UI-Focused agent) and Galaxy constitute a multi-agent AI framework for automating GUI-based tasks across Windows, Linux, and mobile platforms. The system uses LLM-driven agents (AppAgent, HostAgent, ConstellationAgent) that interact with desktop applications via UI automation (UIA, COM) and execute distributed task workflows modeled as DAGs (task constellations). It includes a client-server architecture with WebSocket-based Agent Interaction Protocol (AIP), MCP tool servers, a configurable RAG knowledge substrate, and a Web UI (React+FastAPI) for real-time monitoring and control. The framework is primarily an application with strong research elements: it supports trajectory analysis, evaluation agents, demonstration learning, and configurable LLM backends (OpenAI, Claude, Gemini, DeepSeek, Ollama).