This repository is a comprehensive, Jekyll-based static site serving as the official tutorial for OpenClaw, an open-source AI agent gateway. It provides a structured, multi-chapter guide (15 chapters + 15 appendices) covering installation, configuration, multi-platform integration (Feishu, WeChat, DingTalk, etc.), automation, and practical use cases for building AI agents. The site includes a polished UX with dark/light mode, scroll-spy navigation, reading progress bar, and a full-text search index. Beyond documentation, the repo contains a substantial collection of automation scripts (markdown-to-docx conversion, image uploading, CSDN auto-publishing, formatting fixes), example skills (JavaScript templates for custom skills), configuration templates (multi-agent, multi-model, Feishu integration), and GitHub Actions for CI/CD (Jekyll build, issue processing, content sync). The repository is actively maintained, with a clear version baseline (v2026.6.8) and frequent updates. While primarily a documentation project, the inclusion of reusable scripts, skill templates, and a well-crafted Jekyll layout makes it valuable for developers building similar documentation sites or OpenClaw-adjacent tools. The hybrid nature is evident: it serves as both a reference manual and a toolkit of reusable components for the OpenClaw ecosystem.
This is a production-grade long-term memory plugin for the OpenClaw AI agent platform, built as a TypeScript/ESM module. It provides a complete memory lifecycle: LLM-powered extraction from conversation transcripts (6-category classification with L0/L1/L2 layering), hybrid vector+BM25 retrieval with cross-encoder reranking, Weibull decay-based importance scoring, tier management (core/working/peripheral), and multi-scope isolation (global, agent, user, project). The plugin integrates deeply into OpenClaw via lifecycle hooks, agent tools, CLI commands, and a dreaming engine for periodic consolidation. It stores all data in LanceDB and supports multiple embedding providers, LLM backends, and OAuth flows. The codebase is large and complex, with extensive test coverage (100+ tests) and many edge-case handlers, but exhibits significant technical debt in a single massive index.ts file and multiple fallback/legacy migration paths. It is not a research project; it is a highly functional, actively maintained plugin with a clear engineering focus on correctness, resilience, and performance.
Commonly is an open-source multi-agent collaboration platform where humans and AI agents work together in shared workspaces called 'pods'. The system provides real-time messaging, task management, agent runtime (native, hosted, or bring-your-own), marketplace for agent skills, and integrations with external chat platforms like Discord, Slack, Telegram, and GroupMe. The architecture is a full-stack monolith with separate external agent bridge services and a Cloudflare Workers-based agent runtime. The backend (Node.js/Express) uses a dual-database design (MongoDB for primary data, PostgreSQL for messages/tasks) with automatic sync. The frontend is a React SPA with a v2 design system. The CLI allows local agents to participate via device-code auth and polling. The MCP server provides standard tools for agents to interact with the platform. The codebase is well-structured with extensive test coverage (unit, integration, E2E), Architecture Decision Records (ADRs), and reusable packages for types, integration SDK, and MCP tools. Notable craftsmanship includes pluggable storage drivers, deterministic agent wake targeting, and a test utility that replicates the production PostgreSQL schema to catch DDL drift.
CyberClaw is an enterprise-grade transparent AI agent architecture that implements a dual-watermark memory system, full behavior auditing, zero-trust execution via two-phase skill invocation, and a heartbeat task engine for scheduled operations. The system provides an interactive conversational interface where users can query time, perform calculations, manage files, execute shell commands within a secure sandbox, and utilize pluggable skills. All agent actions are transparently logged to JSONL files for monitoring and compliance. The architecture features clean separation of concerns with distinct modules for agent logic, skill loading, context management, logging, heartbeat tasks, and tool execution.
Lossless Claw is a production-grade OpenClaw plugin for lossless context management in LLM conversations. It persists every message in SQLite, compresses older context into a DAG of hierarchical summaries (leaf and condensed), and assembles the active prompt by combining recent messages with summaries. The system provides recall tools (grep, describe, expand) for agents to retrieve details from compacted history, a doctor tool for repairing summary quality, a CLI for diagnostics, and a Go-based TUI for interactive inspection and maintenance. It integrates deeply with OpenClaw's plugin API, using the host's LLM dispatch for summarization and supporting multi-provider fallback, OAuth, and retry chains. The architecture is event-driven with deferred compaction, pending summary pipelines, and atomic publication. While the core is TypeScript, the TUI is written in Go, creating a bimodal maintenance burden. The codebase demonstrates strong engineering practices with extensive test coverage, but its tight coupling to OpenClaw's evolving API and large configuration surface introduce moderate technical drift risk.
OpenClaw-bot-review is a Next.js 16 + React 19 monitoring dashboard for the OpenClaw multi-platform AI agent system. It reads local filesystem data (config, session logs) to display real-time agent status, model/session statistics, gateway health, and alerts. The dashboard includes a pixel-art office visualization where agents are represented as wandering characters with a full game loop, sprite system, and bug simulation. It also houses a self-improvement R&D council with an evidence-driven decision pipeline (ingest usage → build council items → deliberate → approve/reject/snooze). The architecture is a client-heavy Next.js app with API routes that wrap OpenClaw CLI commands and direct file reads; no database is used. Key entry points are the main dashboard (`app/page.tsx`), API routes under `app/api/`, and the pixel-office engine in `lib/pixel-office/`. The codebase demonstrates solid engineering with several reusable modules (CLI wrapper, path resolution, model probe, game loop), but contains some large monolithic client components and limited test coverage.
OpenClaw is a Nix flake that packages the OpenClaw AI assistant gateway for declarative installation on NixOS, macOS, and Home Manager. It provides a Home Manager module (programs.openclaw) and a NixOS module (services.openclaw-gateway) with options for instances, plugins, skills, workspace files, environment variables, and systemd/launchd services. The flake also includes an overlay, a Home Manager module for runtime plugins, and a set of Nix scripts that generate and validate plugin locks, config options, and runtime plugin materialization.
This repository provides reproducible Nix packaging for a collection of CLI tools (summarize, discrawl, wacrawl, gogcli, goplaces, camsnap, sonoscli, peekaboo, poltergeist, sag, imsg, qmd) used in the OpenClaw ecosystem. It includes per-tool OpenClaw plugin metadata (skills) that teach AI agents how to use each tool. The repo features automated update workflows: a Go-based tool updater (`cmd/update-tools`) that fetches latest GitHub releases and updates Nix expressions with new versions and hashes, and a skill syncer (`cmd/sync-skills`) that pulls the latest skill definitions from upstream OpenClaw repositories. The Go code demonstrates solid engineering with proper timeout handling, process group management, atomic file updates, and comprehensive tests. The Nix expressions are well-structured, supporting multiple platforms (aarch64-darwin, x86_64-linux, aarch64-linux) and using pinned nixpkgs inputs for reproducibility. CI runs formatting checks, vetting, tests with race detector, and builds all packages on supported systems. The repository is actively maintained with frequent commits and automated CI runs.
Project AIRI is a comprehensive multi-platform AI agent and virtual character platform. It functions as a desktop application (Electron), web interface (Vue.js), and mobile client (Capacitor), centered around an LLM-powered 'brain' that controls 3D avatars (Live2D, VRM, Spine) and interacts with the physical world via computer automation (MCP) and gaming bots (Minecraft). The system integrates speech-to-text, text-to-speech, and vision processing to create a conversational agent capable of real-time interaction. It features a robust backend server (Hono/PostgreSQL) for authentication, billing (Flux currency), and provider routing, alongside a plugin system allowing third-party extensions to inject functionality. Architecturally, it is a large monorepo managed by pnpm and Turbo, separating concerns into apps, packages, services, and plugins. The codebase demonstrates significant engineering effort in managing complex state across Electron IPC, WebSocket communication, and local-first data synchronization. It implements custom concurrency ledgers for billing, GPU resource coordination for model inference, and sandboxed execution environments for AI planning tasks. The system is actively developed with frequent commits and a large plugin ecosystem, though it relies heavily on bleeding-edge dependencies and beta libraries. The platform solves the problem of creating autonomous virtual characters with agency, moving beyond simple chatbots to agents that can control computers, play games, and maintain persistent memory. It exposes a standardized provider registry for AI models and a plugin SDK for extensibility. While the architecture is sophisticated, the reliance on rapidly evolving AI standards (MCP, LLM APIs) and bleeding-edge Node.js versions introduces technical debt and maintenance overhead.
This is an Ansible role and playbook collection that automates the hardened installation of the OpenClaw messaging gateway on Debian/Ubuntu Linux systems. It provisions a dedicated system user, installs Docker CE with UFW-based firewall and DOCKER-USER chain isolation, configures fail2ban and unattended-upgrades, sets up Node.js and pnpm, and installs OpenClaw either from npm (release mode) or from a Git checkout (development mode). The role does not configure the application or install its systemd service—those steps are left to the operator via `openclaw onboard --install-daemon`. It supports remote deployment via inventory and includes CI tests for syntax, linting, and integration. The codebase is well-structured, security-conscious, and actively maintained, though it does not contain independently extractable components suitable for reuse outside this project.
Crabpot is a compatibility testing and regression detection framework for the OpenClaw AI agent plugin ecosystem. It validates plugin fixtures (59 plugins, 119 entrypoints) against the OpenClaw API surface by capturing contract registrations, running synthetic probes, measuring cold-import readiness, and profiling resource usage. The system is driven by a modular collection of Node.js scripts (ES modules) that orchestrate inspection, report generation, and CI policy enforcement. It integrates deeply with GitHub Actions for automated checks, track dashboards, and resource campaign execution via Docker. The architecture is script-based rather than a monolithic application, with each script performing a focused task (e.g., capture-contracts.mjs, synthetic-probes.mjs, generate-report.mjs) and producing JSON+Markdown reports. External dependencies include the OpenClaw plugin-inspector library, npm/git for fixture materialization, and GitHub Actions for CI. The framework is designed to catch contract drift before external plugin authors encounter it, and it maintains a dashboard of live issues, compat gaps, and profile regressions.
This repository is a curated directory/registry of 5,300+ community-built skills for OpenClaw, an AI agent platform. It is not a software application — it contains no runtime code, no API, and no executable logic. Instead, it is a structured catalog of markdown files organized into 30+ categories (DevOps, Search & Research, Coding Agents, etc.), where each entry links to a skill hosted on ClawHub (OpenClaw's public skills registry). The repo functions as a discovery and navigation layer: users browse categories to find skills, and contributors submit new skills via pull requests validated by a CI workflow. The repository also documents filtering criteria (excluding spam, duplicates, low-quality, crypto, and malicious entries), security considerations (VirusTotal scanning partnership), and contribution guidelines. While it shares some characteristics with a data_research repo (structured metadata, no application code), it is best classified as a curated content registry — the 'application' label applies only in the sense that it is not a data pipeline or research project. Key patterns include a consistent category taxonomy, a PR validation workflow, and documented quality gates. The main risks are link rot (5,300+ external links with no automated checking), quality variance across entries, and the manual effort required to maintain a list at this scale.
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 curated 'awesome list' and comprehensive documentation hub for the Agent Skills ecosystem. It does not contain any executable application code, data pipelines, or machine learning models. Instead, it serves as a static directory of links to official projects (Anthropic, OpenAI, Google, Vercel, etc.), community-contributed skills, tutorials, and best-practice guides. The core value lies in its translated and aggregated documentation, including detailed guides on Skill design patterns, practical experience from Anthropic, and a complete build guide. It is a reference resource, not a software tool. Engineers and AI agents should use this repo to discover the Agent Skills specification, find relevant skills to install, and learn how to create their own. It is not a library or framework to be imported.
ClawBands is a security middleware for OpenClaw AI agents that provides runtime interception with human-in-the-loop approval. It hooks into OpenClaw's plugin system to intercept tool executions (file operations, shell commands, network requests) and enforces policy-based decisions before allowing potentially dangerous actions. The system operates in two modes: terminal mode with interactive prompts, and channel mode (WhatsApp/Telegram) using a special response tool. Every decision is logged to an immutable JSON Lines audit trail, and statistics are tracked. The architecture features clean separation of concerns with distinct modules for policy interception, decision arbitration, approval queuing, logging, and storage.
This repository is a comprehensive, tool-agnostic skills and steering pack that teaches AI coding agents to perform AWS Well-Architected Framework reviews. It contains a curated reference corpus of over 2,000 markdown files (6 pillars, 307 best practices, 27 industry lenses) derived from official AWS documentation, plus per-tool adapters for 15 AI coding assistants (Claude Code, Cursor, Codex, GitHub Copilot, etc.). The repo also ships production-grade supporting tooling: a CI gating tool (wa-ci) that diffs structured review JSON against a baseline and blocks PRs on regressed gaps; an evaluation harness with blind multi-reviewer adversarial adjudication; a crawler to regenerate the reference corpus from AWS docs; and one-command installers. The core skill dispatches six parallel subagents (one per pillar) to keep the 2.2 MB corpus out of any single context window. Despite the extensive content, the repository has notable maintenance challenges: the reference snapshot will drift as AWS documentation evolves (users are responsible for regeneration); lens files are duplicated across `powers/` and `skills/` directories creating a sync hazard; and the flagship skill is explicitly deprecated in favor of a successor in Agent Toolkit for AWS. The evaluation harnesses and CI tooling are well-crafted and reusable, but the sheer scale of markdown files and platform-specific adapters makes ongoing synchronization complex.
AutoSkill is a comprehensive framework for extracting, managing, and evolving reusable 'skills' from conversational logs and documents. It operates as a modular application with multiple entry points: a web UI for interactive chat, a CLI for batch processing, and an OpenAI-compatible proxy server that injects relevant skills into LLM context. The system employs LLM-driven and heuristic pipelines to extract skill candidates, deduplicate and merge them, and persist them in a skill store with vector and BM25 retrieval. It also includes a self-evolution subsystem (SkillEvo) that replays experiences, evaluates performance, and mutates skills for improvement. The codebase is hybrid, containing both application components (web server, proxy, libraries) and data/research pipelines (document ingestion, trajectory extraction), but the dominant character is an application SDK designed for integration with agentic workflows. Notable craftsmanship is seen in standalone utilities like a CJK-aware text unit counter, an AST-based prompt patcher, a persistent BM25 index, and a LibreOffice socket shim, though the repo also suffers from significant code duplication (e.g., identical validators across docx/pptx/xlsx) and a large surface area of environment variables and external dependencies.
Spawn is a multi-cloud VM provisioning CLI that deploys AI coding agents (Claude Code, Codex, OpenClaw, etc.) onto cloud VMs (Hetzner, DigitalOcean, AWS Lightsail, GCP, Daytona, Sprite) with a single command. It handles the full lifecycle: interactive agent/cloud selection via fuzzy matching, VM provisioning, SSH key injection, agent installation (npm binaries, pre-built tarballs, or Docker sidecars), environment configuration (OpenRouter API key, MCP servers via skill files), and interactive session handoff. The system supports headless mode, recursive spawning (agent launching sub-agents), auto-update systemd services, and a security scan cron. It is distributed as per-cloud JS bundles (Bun.build, minified) with curl|bash wrappers that download from GitHub Releases, and a Windows PowerShell installer. Architecturally, Spawn is a modular monolith: a shared orchestration pipeline (`shared/orchestrate.ts`) drives cloud-specific providers implementing a common `CloudRunner`/`CloudOrchestrator` interface (authenticate → promptSize → createServer → waitForReady → install → configure → launch → interactiveSession). Agents and clouds are defined in a `manifest.json` that validates compatibility via runtime type contracts. A shared `Result` monad (`@openrouter/spawn-shared`) enables functional error handling with retry semantics across SSH calls and cloud API interactions. The codebase is well-tested (~100+ test files) with fs-isolated sandboxes, mocked cloud prompts, and integration tests against real cloud providers via an E2E harness. The codebase demonstrates strong engineering practices: schema-validated input parsing (valibot), security-first validation (allowlists for every user-controlled input: instance names, IPs, SSH usernames, shell commands, remote paths), and atomic file operations with corruption recovery for history persistence. However, there is significant duplication across cloud providers (near-identical SSH execution patterns in each cloud module), large monolithic files (orchestrate.ts ~1000+ lines, agent-setup.ts ~2000 lines), and manual drift risk from hardcoded API slugs (DigitalOcean marketplace images, Hetzner server types, GCP machine types) and embedded OAuth client secrets (documented as acceptable public-client pattern).
@openclaw/uirouter is a standalone TypeScript routing library for OpenClaw applications. It provides a type-safe, context-aware router that matches URL paths to route records, exposes navigation state through `getState()`, and supports load contexts and redirects. The library is explicitly not an application framework or state store; it avoids hidden global state and app-specific rendering, making it a focused routing primitive rather than a full application shell.