oh-my-openagent (omo) is a massive, actively-developed TypeScript monorepo that ships as a multi-harness AI-agent orchestration plugin. Its production function is to instrument coding-agent runtimes (OpenCode, OpenAI Codex CLI, and adapters for Claude Code and other harnesses) with a rich layer of lifecycle hooks, background agents, multi-model routing, LSP/AST tooling, team-mode parallelism, and a curated prompt system — all installable via a single `bunx oh-my-openagent install` or `npx lazycodex-ai install` command. The architecture is a workspace of 20+ pure-TypeScript core packages (model-core, rules-engine, skills-loader-core, team-core, tmux-core, delegate-core, hashline-core, lsp-core, mcp-client-core, etc.) that are consumed by two main adapter packages: `omo-opencode` (the full-featured OpenCode plugin with 11 agents, 54+ hooks, team mode, ultrawork/ULW loop, background agents, Codegraph MCP, etc.) and `omo-codex` (a lightweight Codex CLI plugin that vendories a subset of components — rules, comment-checker, LSP, git-bash, ultrawork, ulw-loop, telemetry — as isolated Codex components). A large shared-skills layer provides cross-harness SKILL.md files for programming languages, frontend design, ultimate browsing, debugging, and more. The codebase is notable for its aggressive package layering refactor (documented in ROADMAP.md), its strict no-excuse TypeScript policy, extensive automated QA evidence (.omo/evidence/), and its depth of agent-facing features like hash-anchored edits, prompt-async-gate, runtime fallback with model-suggestion retry, and the start-work/ULW-loop goal orchestration systems. With 64K stars, daily commits, 790 open issues, and a sprawling CI matrix, it is one of the most ambitious open-source agent-orchestration projects in maintenance today.
Orca is a production-grade Electron desktop application that functions as an integrated development environment (IDE) and orchestrator for multiple AI coding agents (Claude Code, Codex, Gemini, etc.). It manages isolated worktrees (Git, SSH, WSL) as execution environments, provides a full-featured terminal emulator (xterm-based), a browser pane, rich markdown editing, and deep source control integration (GitHub, GitLab, Linear, Jira). The system is architected as a monorepo containing the Electron desktop app (main/renderer/preload), a React Native mobile companion, a Node.js CLI, and cloud services (relay, push) for mobile pairing and notifications. Communication between processes is handled through a strict, Zod-validated RPC contract, ensuring type safety across the wire. The codebase demonstrates exceptional engineering discipline with a massive test suite (Vitest, Playwright), extensive CI/CD pipelines, and a strong emphasis on platform compatibility (macOS, Windows, Linux, WSL, Wayland). It is actively maintained with daily releases and a clear focus on managing technical debt through explicit legacy compatibility shims and migration paths.
This repository is a production-grade meta-framework for building and managing AI agent plugins across multiple coding assistants (Claude Code, Codex, Cursor, OpenCode, Gemini, Copilot). It establishes a single source of truth in Markdown (`plugins/`) that is compiled into harness-specific artifacts via Python adapters. Key features include a security layer using Cedar policies for tool-call authorization and signed audit receipts, a project management system (`conductor`) for track-based development, and a quality evaluation framework (`plugin-eval`) using static analysis and LLM-based scoring. It solves the fragmentation problem of AI agent ecosystems by enforcing portability and governance.
Gentle-AI is a CLI-driven application that manages AI coding agents through installation, configuration, and review workflows. It provides a deterministic engineering environment with features like persistent memory (Engram™), receipt-driven development (RDD) for verifiable code reviews, and telemetry collection. The architecture is modular, separating concerns into CLI commands, agent adapters, components (like Skills and Context7), review transaction logic, state management, and a text-based user interface. The system interacts with external AI agents (Claude Code, OpenCode, Cursor, etc.) via adapter patterns, manages state in $HOME/.gentle-ai, and supports cross-platform operation (Linux, macOS, Windows). Key entry points include the gentle-ai CLI command and TUI screens for interactive workflows.
AxonHub is a production-grade, multi-provider LLM API gateway that routes, transforms, and manages requests to a wide range of AI providers (OpenAI, Anthropic, Gemini, DeepSeek, xAI, and 60+ others). It provides a unified API surface for chat completions, embeddings, moderations, audio, images, and video generation, with sophisticated features like load balancing (latency-aware, weighted round-robin, circuit breaker), per-channel rate limiting, provider quota enforcement, streaming, and reasoning token handling. The backend is written in Go using Gin, Ent ORM, gqlgen, and Uber Fx for dependency injection, supporting PostgreSQL, MySQL, and SQLite with automatic migration. The frontend is a comprehensive React/TypeScript SPA (Vite, TanStack Router/Query, Tailwind, shadcn/ui) that provides administration of channels, models, API keys, users, roles, projects, and system settings. It includes analytics dashboards, request tracing, usage logs, and OIDC SSO. The system is designed for multi-tenancy with fine-grained RBAC (scope-based permissions) and privacy policies enforced at the Ent ORM layer. Deployment is supported via Docker, Docker Compose, and Helm charts. The codebase exhibits strong engineering practices: extensive unit and integration tests (including race-condition tests and E2E Playwright tests), pipeline middleware for request transformation, generic caching abstractions, stream processing utilities, and a Zanzibar-inspired authorization framework. While there are minor issues (duplicate utility packages, a typo in a folder name, and some frontend boilerplate repetition), the overall architecture is clean, modular, and well-documented. The project is actively maintained with frequent commits, issue triage, and a clear release process.
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.
CodeNomad is a desktop application (Electron and Tauri) that serves as a sophisticated AI coding cockpit, wrapping the OpenCode CLI. It provides an advanced chat-based interface for managing AI coding sessions across multiple workspaces, with support for tool execution (bash, read, write, diff), file browsing, Git integration, voice input, and remote access. The architecture consists of a Node.js/Fastify server that orchestrates OpenCode instances and manages settings, a SolidJS UI rendered in a webview, and native desktop shells (Electron and Tauri) providing OS integration. The codebase is a monorepo with multiple packages, extensive test coverage, and a focus on developer experience with features like session persistence, worktree management, and a plugin-based right panel. While primarily an application, it includes usage tracking providers that aggregate token consumption from various AI services.
OpenViking is an agent-native context database that unifies memories, resources, and skills under a virtual filesystem paradigm (viking:// URIs). It provides a three-tier context model (L0 abstract, L1 overview, L2 full content), recursive directory-based retrieval with visualized trajectories, and automatic session memory extraction. The system consists of a FastAPI HTTP server with embedded Rust components (RAGFS filesystem, vector index engine), a Rust CLI (ov), Python SDKs, a React/Vite Web Studio dashboard, and VikingBot - an agent framework with multi-channel support (Telegram, Slack, Feishu, etc.) and MCP integration. It integrates with OpenClaw, Claude Code, Codex, OpenCode, Hermes, and LangChain/LangGraph. The codebase demonstrates strong engineering: clean separation of concerns, async-first design, comprehensive test coverage (unit, integration, e2e), and production-ready deployment artifacts (Docker, Helm, multi-arch builds). Benchmarks show significant improvements over baseline agents on LoCoMo (82% vs 24-57% accuracy), tau2-bench (+6-12pp), and HotpotQA (91% at top-20).
Paseo is a full-stack, multi-platform development environment for orchestrating AI coding agents (Claude Code, Codex, OpenCode, Pi, etc.) from a unified interface. It consists of a daemon server that manages agent sessions, workspaces, terminals, and git operations; a cross-platform client built with React Native/Expo (iOS, Android, web, Electron desktop); a CLI tool; and a plugin ecosystem. The architecture is provider-agnostic, supporting multiple AI backends through a common protocol layer. The codebase demonstrates high engineering craftsmanship with extensive test coverage, clean separation of concerns, and reusable patterns like the plugin SDK, protocol schemas, and platform abstraction layers. It is actively maintained with rapid release cycles and a large community.
CC Switch is a desktop application built with Tauri (Rust backend + React/TypeScript frontend) that serves as a unified management hub for multiple AI coding assistants, including Claude Code, Claude Desktop, Codex, Gemini CLI, Grok Build, OpenCode, OpenClaw, and Hermes Agent. Its core function is provider switching: it manages configurations, API keys, OAuth tokens, and MCP servers across these tools, and provides a local HTTP proxy that routes API requests to different AI providers with failover, circuit breaking, and usage tracking. The application also includes session management, skills/prompts synchronization, cloud sync (S3/WebDAV), deep link import/export, and a usage dashboard with cost tracking. The architecture follows a command-service-DAO pattern in Rust, with a React frontend using TanStack Query for state management, react-hook-form for forms, and shadcn/ui components. The proxy subsystem is particularly sophisticated, implementing format conversion bridges between different AI API protocols (Anthropic Messages, OpenAI Chat/Responses, Gemini), streaming transforms, thinking budget optimization, cache injection, and content encoding handling with bomb protection. The frontend is organized around per-app provider forms, a universal provider panel, and settings pages for proxy, MCP, skills, and usage. Key features include: 50+ provider presets for third-party API relay services, one-click provider switching with live config backup/restore, a local proxy with auto-failover and circuit breaker, session history browsing across supported apps, skills installation from GitHub repos, prompt management with per-app sync, and usage statistics with custom pricing. The application supports i18n (English, Japanese, Chinese) and runs on Windows, macOS, and Linux.
This repository is an OpenCode plugin that provides interactive pseudo-terminal (PTY) management for AI coding agents. It allows agents to spawn, write to, read from, and kill multiple background terminal sessions, enabling long-running processes like dev servers, watch modes, and interactive programs. The plugin exposes five tools (pty_spawn, pty_write, pty_read, pty_list, pty_kill) and two slash commands for opening a web UI. The architecture is modular: a core PTYManager orchestrates session lifecycle, output buffering (via a RingBuffer), and exit notifications, while adapters decouple the plugin from OpenCode V1 and V2 APIs. A Bun-based web server serves a React frontend with real-time WebSocket streaming and a REST API for session management. The codebase demonstrates strong TypeScript patterns, clean abstractions, and comprehensive testing (unit, integration, and Playwright E2E).
This repository implements a persistent memory server for AI agents, designed to solve the problem of agent amnesia across sessions, devices, and team members. The production system is a Rust-based HTTP server (Axum) that exposes a RESTful API with 48+ endpoints, backed by LanceDB for vector storage and supporting both hosted and self-hosted deployments. It ingests conversational or document data via an LLM-powered pipeline that extracts atomic facts, filters noise, scores admission, and reconciles with existing memories using seven operations (CREATE, MERGE, SUPERSEDE, etc.). The system manages a full memory lifecycle with Weibull decay, tier-based promotion/demotion, and auto-forgetting, and provides a multi-stage retrieval pipeline that combines vector search, BM25, cross-encoder reranking, decay boosting, and MMR diversity. Plugins for Claude Code, OpenCode, OpenClaw, and MCP allow client-side integration, and a GitHub connector ingests commits, issues, and PRs as memories. The architecture is multi-tenant with personal, team, and organization spaces, each isolated in separate LanceDB directories, and supports versioned, provenance-tracked sharing with staleness detection.
Optio is a self-hosted, Kubernetes-native orchestration platform for AI coding agents (Claude Code, OpenAI Codex, GitHub Copilot, Gemini, Cursor, OpenCode). In production it runs three task tiers — repo tasks (issue/request → agent pod → PR), standalone jobs (parameterized agent runs without repo checkout), and persistent agents (long-lived, message-driven agents with turn-based execution) — plus an autonomous PR review loop. The core loop is driven by ~15 BullMQ workers (task, PR watcher, review, webhook, ticket sync, reconcile, workflow trigger) against a Postgres database, with Redis pub/sub powering a real-time event bus and WebSocket log/terminal/chat streaming to the Next.js dashboard and CLI. Agents execute in ephemeral pods built from per-language Docker images; a K8s-style reconciliation control plane (world snapshot + pure decision functions + CAS-gated executor) converges four run kinds and catches drift. The architecture is a pnpm/turbo monorepo: a Fastify 5 API with Drizzle ORM and Zod-validated OpenAPI schemas; a Next.js 15 admin dashboard (tasks, jobs, reviews, sessions, agents, cluster, analytics); a Commander-based CLI (login, task/repo/session/secret commands over REST + WebSocket); and a static docs site. Shared packages provide a clean AgentAdapter interface (`validateSecrets` → `buildContainerConfig` → `parseResult`), a Docker/Kubernetes container runtime abstraction, ticket provider adapters (GitHub, GitLab, Jira, Linear, Notion), and shared types/utilities (task state machines, repo URL parsing, SSRF guards, cost arithmetic). Workspace-scoped multi-tenancy with admin/member/viewer RBAC, AES-256-GCM secret encryption with AAD binding, WebSocket upgrade tokens, HMAC-signed internal calls, and a security-focused audit trail (optio_actions) are enforced throughout. Engineering strengths: the test suite is unusually thorough for a project this size — nearly every route, service, worker, and shared utility has a unit test, with per-file Postgres/Redis isolation for integration tests, real-server E2E tests using a deterministic fake container runtime (with mock directives like [[mock:pr]]), and Playwright smoke tests. The reconcile pattern, generic state machine utilities, and pure decision functions in `packages/shared/src/reconcile/` are the highest-craftsmanship code. Known debt: five near-duplicate NDJSON event parsers (one per agent, with drift risk), hardcoded model pricing tables in the Codex/Gemini adapters, scattered duplicated workspace-scoping checks, a 60+ file migration history with historical prefix collisions (now script-enforced), and raw SQL in the analytics service. The project moves fast (v0.1 → v0.4.1 within months, last commit 2026-08) and some surface area (OpenCode/OpenClaw adapters, skills marketplace) is explicitly experimental, but the core architecture is coherent and production-oriented.
OpenAgents Control (OAC) is a framework for managing, testing, and orchestrating AI coding agents. It provides a CLI tool (`oac`) to install, update, and manage agents, context files, and skills from a registry. The system includes a plugin architecture for OpenCode and a compatibility layer that converts agent definitions between OAC, Claude Code, Cursor, and Windsurf formats. A comprehensive evaluation framework tests agent behavior against critical rules (approval gates, context loading, stop-on-failure, delegation, tool usage) using YAML-defined test suites and timeline-based analysis. The repository is primarily a software development toolchain for AI-assisted coding workflows, with strong emphasis on deterministic safety rules and multi-agent coordination.
Peon-ping is a cross-platform sound notification system for AI coding agents (Claude Code, Cursor, Codex, OpenCode, etc.). It intercepts agent lifecycle events (session start/stop, task complete, error, permission requests) via shell hooks and IDE-specific adapters, translates them into a standardized CESP (Coding Event Sound Pack Specification) JSON format, and plays themed sound effects with optional desktop notifications and TTS speech. The architecture is event-driven and hook-based: each IDE has a thin adapter script that pipes CESP events to a core hook script (`peon.sh` on Unix, `peon.ps1` on Windows) which performs sound selection from configurable packs, asynchronous audio playback via platform-native players, state persistence (atomic file I/O), and notification dispatch (macOS overlay, system notifications, relay for remote/SSH sessions). Additional features include a trainer (exercise reminders), an MCP server for agent-controlled sound playback, and a sound pack registry with 160+ packs. The codebase applies an adapter pattern, atomic state I/O, structured debug logging (ADR-002), and a path-rules-based pack resolution system. It is heavily tested with BATS (Unix) and Pester (Windows) suites, managed via an agent-based gitban workflow with sprint planning and code reviews. Dependencies include Python3, audio players (afplay, ffplay, pw-play, PowerShell MediaPlayer), and platform-specific notification tools. Key concerns are the monolithic hook scripts (single ~5000-line files per platform), cross-platform code duplication, and the maintenance burden of 20+ IDE adapters.
A Neovim plugin that integrates with AI CLI tools (opencode, claude, cursor-agent, gemini) to provide agentic coding workflows. It allows users to perform semantic searches, replace visual selections, run 'vibe' sessions for code generation, and get tutorials. The plugin manages state, request tracking, logging, and window management. It supports multiple providers, custom rules via SKILL.md files, and file completions. The architecture is modular with clear separation of concerns: providers, operations, extensions, and UI layers.
OpenTeams is a multi-agent AI coding assistant platform that enables users to collaborate with multiple AI coding agents (Claude Code, Codex, Gemini CLI, etc.) in a single shared session. The system provides a local-first desktop application built with Tauri (Rust backend + React/TypeScript frontend), a standalone CLI tool (`openteams-cli`) written in TypeScript with Bun, and a web frontend. The backend is an Axum HTTP server in Rust with SQLite persistence managed via SQLx, supporting chat sessions, workflow orchestration, source control integration, approval systems, and a skill registry. The architecture is modular: a `crates` workspace separates database models, services, executors, deployment, and utilities, while the CLI uses Effect-TS for dependency injection and includes a TUI built with SolidJS. In production, the system orchestrates AI agents through the Agent Client Protocol (ACP) and provider-specific SDKs, managing execution processes, worktrees, and chat message queues. Key data flows include: user input → chat runner → agent execution (with tool calls, file edits, git operations) → event streaming back to frontend/CLI. The platform integrates with GitHub for PR review, issue tracking, and work item management, and supports custom MCP servers and skill plugins. External dependencies include SQLite, Tauri, Bun, various AI provider APIs (Anthropic, OpenAI, Gemini, Copilot), and GitHub CLI for certain operations.
This repository is a comprehensive plugin and skill set for Claude Code (and compatible CLI assistants like Codex CLI and OpenCode), designed to transform the AI into a semi-automated research assistant for academic and software development workflows. It is not a standalone application but a configuration package that installs skills, commands, agents, hooks, and rules into the user's Claude environment. The architecture follows a skill-based pattern: each skill is a directory with a SKILL.md entry point, references, examples, and optional scripts, all consumed by the AI at runtime. The repository covers the full research lifecycle—ideation, literature review (via Zotero MCP and arXiv APIs), experiment analysis, ML paper writing with conference-specific LaTeX templates (NeurIPS, ICLR, ICML, ACL, AAAI), reviewer response drafting, publication chart creation, and post-acceptance promotion. It also integrates deeply with Obsidian for project knowledge management and includes a meta-toolchain for developing and QA-ing skills themselves. While primarily an application configuration, it contains substantial research-oriented content (Kaggle competition analyses, citation verification workflows, writing pattern references), making it a hybrid tool that bridges software engineering and data science research. The codebase is actively maintained, well-documented, and demonstrates strong craftsmanship in its script utilities and hook infrastructure.
This repository is the official awesome list for OpenCode, a terminal AI coding agent. It maintains a curated catalog of plugins, themes, agents, projects, and resources as YAML files under data/. A small set of Node.js scripts validates the YAML against a JSON schema, generates the README.md from a template, and exports a normalized dist/registry.json for downstream consumers such as opencode.cafe. CI workflows validate PRs and automatically regenerate the README/registry whenever the YAML data changes. Architecturally this is a data-driven build tool: YAML files are the source of truth, and scripts/validate.js, scripts/generate-readme.js, and scripts/export-json.js are the functional entry points. They use standard dependencies (ajv, js-yaml, glob) and are organized cleanly. There is no runtime service, API, or library here; the repo is a curated content registry plus lightweight tooling to keep the catalog consistent and machine-readable. The code is straightforward, with no tests but with solid validation and a well-designed schema.
This repository is a collection of Agent Skills for AI coding assistants (Claude Code, Codex, OpenCode) that enables them to interact with Obsidian vaults. It contains six skill definitions: obsidian-markdown (creating Obsidian Flavored Markdown with wikilinks, embeds, callouts, properties), obsidian-bases (creating database-like .base files with views, filters, formulas), json-canvas (creating visual .canvas files with nodes and edges), obsidian-cli (interacting with Obsidian via CLI for note management and plugin development), defuddle (extracting clean markdown from web pages), and knap (rendering Markdown templates from structured data). Each skill is a self-contained markdown file following the Agent Skills specification, providing detailed syntax, examples, and validation steps. The repository is purely documentation with no executable code, serving as a knowledge base that AI agents use to perform Obsidian-related tasks on behalf of users.