thehardwarestore.ai

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.

Codex Autoresearch is an autonomous, goal-driven experimentation CLI tool for Codex. It allows users to define a numeric target (e.g., reduce error count to zero) and then repeatedly runs a loop: the Codex model inspects the repo, makes one focused code change, the control script commits it, runs a verification command to measure the metric, keeps improvements or reverts failures, and appends audit events. The system supports both foreground (Codex Goal-driven) and background (detached controller with `codex exec` workers) modes, with strict state validation, atomic file operations, and Git-based rollback. Architecture: The codebase is split into three Python modules under `scripts/`—`autoresearch.py` (CLI and lifecycle orchestration), `autoresearch_core.py` (primitives for Git, command execution, event validation, and process management), and `autoresearch_report.py` (read-only rendering of history as terminal tables, TSV, or self-contained HTML). State is stored in `autoresearch-results/` as immutable `run.json` and append-only `events.jsonl`. The skill entrypoint is `SKILL.md`, which references three documentation files. The design emphasizes contract enforcement over silent recovery: malformed input, unexpected Git drift, or failed commands halt with precise diagnostics. The repository demonstrates high craftsmanship in defensive programming, strict JSON schema validation, atomic file writes, process tree management, and comprehensive unit/integration tests (including race condition testing for background controllers). It is a practical and well-documented example of building a reliable autonomous agent harness for codebases.

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.

This repository implements an MCP (Model Context Protocol) server that serves as a bridge between MCP clients (like Claude Code) and OpenAI's Codex CLI. It exposes Codex CLI functionality as MCP tools, enabling AI-powered code analysis, generation, and review within editor environments. The server handles stdio communication, manages conversational sessions, spawns Codex CLI processes with appropriate arguments, and processes their output to provide structured responses to clients. The architecture follows a modular design with clear separation between server setup, tool definitions, handlers, session management, and command execution utilities.

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.

CodeStable is a framework for AI coding assistants (Claude Code, Codex CLI) that provides a set of 'skills' — thin harnesses that guide AI agents through software development tasks such as feature implementation, bug fixing, refactoring, epic decomposition, code review, and lesson management. The system emphasizes risk-based assurance, evidence-driven decisions, and minimal project memory, with a core philosophy of 'thin harness, thick context'. It is distributed as plugins for both Claude Code and Codex CLI, and includes a meta-skill (eval-cs-skill) for authoring, evaluating, optimizing, and releasing skills. The repository contains extensive experiment infrastructure with 15+ structured experiments covering routing accuracy, end-to-end outcomes, planted-defect recall, and learning transfer across multiple models. It features a sophisticated evaluation pipeline with deterministic oracles, hidden tests, regression tests, and checkpointed resume. The codebase demonstrates high craftsmanship with clean abstractions, strict validation, and cognitive honesty tagging (measured/soft/underpowered). Key architectural patterns include the thin skill pattern (compact SKILL.md with progressive disclosure via references), adapter pattern for AI model execution (Claude Code, Codex CLI, API, mock), deterministic seed building for reproducible experiments, and a risk-to-assurance mapping used generically by all task skills. The project has 8 ADRs documenting design decisions and a v1-to-v2 migration path that reduced 32 skills to 8. While the codebase is well-maintained and actively developed, some experiments are marked underpowered and the learning transfer epic was cancelled without completing primary hypotheses. The evaluation system is complex and tightly coupled to specific model names and macOS sandbox profiles, which may limit portability.

ccNexus is a desktop application (built with Wails v2, Go backend + web frontend) and a headless server that acts as a smart proxy for multiple AI API endpoints, including Claude, OpenAI Chat, OpenAI Responses, and Gemini. It manages endpoint rotation with automatic failover, credential token pools (API keys, access tokens, refresh tokens), and real-time format conversion between the different API protocols. The system provides a full-featured GUI for managing endpoints, viewing usage statistics, configuring backup/restore (WebDAV, local, S3), launching Claude Code or Codex CLI terminals, and applying visual themes. A separate web UI is available for headless deployments via Docker. The architecture follows a layered design: a proxy layer handles request routing, authentication, and streaming response transformation; a transformer layer converts between API formats using a registry of converters; a storage layer persists endpoints, credentials, and stats in SQLite; and a service layer orchestrates higher-level operations like backup, updates, and terminal launching. The codebase demonstrates strong engineering practices including thread-safe configuration, adapter patterns for storage abstraction, SSE for real-time stats, and comprehensive contract tests. Notable features include zero-cost endpoint testing, incremental stats updates, and a credential lifecycle management system with rate limit tracking and automatic cooldown. While primarily an application, ccNexus includes some data-oriented components such as token counting, usage statistics aggregation, and credential rate limit parsing. However, these serve the operational needs of the proxy rather than constituting a data research pipeline. The project is actively maintained with a responsive issue tracker and regular releases.

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 a collection of configuration templates for Codex CLI, an AI coding assistant. It provides a structured set of configuration files (config.toml, AGENTS.md, sub-agent definitions, and skill files) to enable multi-agent parallel workflows, system-level contracts via developer_instructions, and a well-crafted terminal dialog style. The templates are designed to be copied into the user's ~/.codex directory to configure Codex CLI for efficient, visually structured AI interactions. The repository is actively maintained with frequent updates aligning with Codex CLI releases, and demonstrates high craftsmanship in prompt engineering and configuration design. It is not a traditional software application but a configuration-as-code repository that optimizes an existing tool.

Agentic Awesome Skills is a curated marketplace infrastructure for AI coding agent skills—instructional playbooks (SKILL.md files) with accompanying scripts and assets. The repository provides a multi-platform distribution system supporting Claude Code, Cursor, Gemini CLI, Codex CLI, Kiro, and others. It includes a React+Vite web application for browsing, searching, and installing skills; a CLI and MCP server for local agent integration; and a comprehensive validation, security scanning, and release pipeline. The codebase implements a transaction engine with deterministic content addressing (canonical JSON + SHA-256), durable state management, and schema-validated skill installation, forming a robust foundation for agent-owned tool selection and workflow planning. While the core infrastructure (AAS v1 library, MCP server, catalog search) demonstrates high craftsmanship and reusability, the repository is hampered by massive file duplication: identical skill scripts and governance modules appear under `skills/`, `plugins/agentic-awesome-skills/`, and `plugins/agentic-awesome-skills-claude/`, creating synchronization risk. Some skills contain hardcoded paths or incomplete boilerplate. The repository is actively maintained with CI/CD, automated audits, and security scrutiny, though the sheer volume of 2,474+ skills imposes ongoing maintenance burden. Overall, it is a well-engineered, production-quality skill distribution platform with notable reusable design patterns.

CodexMCP is a lightweight MCP (Model Context Protocol) server that acts as a bridge between Claude Code and OpenAI's Codex CLI. It exposes a single `codex` tool that allows MCP clients to invoke Codex CLI sessions programmatically over stdio. The server handles session persistence via UUIDs, supports multi-turn conversations, parallel execution, and sandboxed workspace modes. The core implementation consists of a subprocess wrapper that streams JSON lines from Codex's `exec` command, parses agent messages and thread IDs, and returns structured results. It also includes Windows-specific command-line escaping to handle prompt injection safely. The codebase is minimal (two source modules plus a CLI entry point) but demonstrates solid patterns for wrapping external CLI tools in the MCP protocol, with graceful shutdown handling and error reporting. It does not include tests or CI/CD configuration, but the architecture is clean and focused.