Graphify is a CLI tool and library that extracts structural and semantic knowledge graphs from source code across 36+ programming languages. It parses files using tree-sitter grammars, builds a graph of nodes (functions, classes, modules, etc.) and edges (calls, imports, inheritance, etc.), performs community detection via Leiden/Louvain, and generates reports, wikis, and exports to formats like Obsidian, Neo4j, and FalkorDB. The system integrates with AI coding assistants through an MCP server (stdio/HTTP), skill files (SKILL.md, CLAUDE.md), and git hooks for automatic graph updates. Key entry points include `graphify extract`, `graphify query`, `graphify serve`, and `graphify install`. External dependencies include tree-sitter grammars, LLM APIs (OpenAI, Anthropic, Gemini, Ollama), and optional databases. The architecture is modular: per-language extractors in `graphify/extractors/`, graph assembly in `build.py`, clustering in `cluster.py`, and export in `export.py`. The codebase demonstrates strong engineering practices with extensive tests, atomic file writes, security validation (SSRF, path traversal), and cross-platform support.
Nanobot is a self-hosted, open-source personal AI assistant framework that operates as a full-stack application. The Python backend provides an agent loop with tool execution, session management, multi-provider LLM orchestration (OpenAI, Anthropic, etc.), and a plugin system for 18+ messaging channels (Telegram, Discord, Slack, WeChat, Feishu, etc.). It exposes a WebSocket-based gateway, an OpenAI-compatible API, and a CLI. Two frontends exist: a rich WebUI built with React/TypeScript/Vite/Tailwind and a terminal TUI built with Bun/OpenTUI. The architecture is event-driven via a message bus, with decoupled channel adapters, provider abstraction, and a config system supporting hot-reload. It includes security features like workspace sandboxing, credential redaction, and SSRF protection. The codebase is extensively tested (hundreds of unit/integration tests) and demonstrates strong engineering practices with clean abstractions, though its large dependency surface and multiple frontends introduce some maintenance surface area.
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).
ClawHub is a full-stack registry marketplace for AI agent skills and OpenClaw plugins. It provides a web application (React + TanStack Router + Convex backend), a CLI tool (clawhub) for publishing and managing skills, an admin CLI for moderation, and a public HTTP API. The system handles skill/plugin publishing, versioning, search (with OpenAI embeddings), trending leaderboards, security scanning (VirusTotal, ClawScan, static analysis), moderation, and catalog feeds. It also mirrors an external skills.sh catalog. The architecture is a monorepo with shared schema packages, extensive test coverage (unit, e2e, Convex), and CI/CD via GitHub Actions. While primarily an application, it includes data/research elements like security dataset export and ranking metrics pipelines.
ClawSweeper is a production GitHub App and CLI that autonomously reviews issues and pull requests across OpenClaw repositories, writes durable markdown reports with YAML front matter, applies conservative close/merge/repair actions behind policy guards, and runs Codex/OpenClaw-powered fix, automerge, and issue-implementation repair pipelines. It is deployed as a set of GitHub Actions workflows plus a Cloudflare Workers dashboard backed by Durable Objects, R2, and a separate git state repository with ledgers, canonical record tuples, and telemetry. This is a hard operational bot, not a library or user-facing product; it consumes GitHub webhook and scheduled sweep data and emits state, review records, notifications, and merge/close mutations.
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.
OfficeCLI is a cross-platform CLI application written in C#/.NET that creates, reads, and mutates OOXML Office documents (Word .docx, Excel .xlsx, PowerPoint .pptx) without requiring Microsoft Office. It is explicitly engineered as an agent-facing tool: every document element is addressable through a uniform path syntax (e.g. /slide[1]/shape[2]), all commands emit structured JSON with error codes and suggestions, and it ships AI-skill files for Claude/Copilot/Cursor/Codex, an MCP server, plus Python and Node SDKs. The core operation model is a batch command language: documents are mutated by replayable JSON items (add/set/remove/get) executed atomically through the CLI or over a named pipe to a resident process. Architecturally the repo is a single .NET binary (embedded runtime) with a CommandBuilder layer, a DocumentHandlerFactory dispatching to three large partial-class handlers (WordHandler, ExcelHandler, PowerPointHandler), and a shared Core layer containing chart-to-SVG rendering, a formula evaluator implementing 350+ Excel functions with statistical distributions, pivot table construction, Mermaid diagram parsing, OOXML theme/table-style resolution, HTML/PNG/SVG preview rendering, and a plugin protocol for foreign-format dump-readers and exporters. Security is taken seriously: SsrfGuard validates remote fetch targets, HyperlinkUriValidator allowlists URI schemes, XmlTextValidator and DocumentLimits guard against decompression bombs and DOM sprawl, and AtomicPackageWriter prevents torn file writes. Quality is strong but carries real maintenance debt. The code demonstrates deep OOXML craftsmanship - schema-order-correct XML insertion, exact EMU unit round-trips, Lanczos-based gamma functions, and curated chart-style galleries. However, handlers are split across dozens of partial-class files that evolved from former god methods, the property API is stringly-typed (props dictionaries parsed per key), examples must be maintained in parallel shell and Python twins, and the tool deliberately tolerates 'UNSUPPORTED props' warnings (exit code 2), which can mask incomplete feature coverage. The best reuse targets are the self-contained Core utilities rather than the format handlers. The project is actively maintained with multi-platform CI publishing to npm and PyPI.
NanoClaw is a self-hosted, multi-agent AI orchestration platform that runs containerized agent sessions, integrates with a wide range of chat channels (Slack, Discord, Telegram, WhatsApp, iMessage, etc.), and provides a CLI-based admin interface. It is architected as a host service (Node.js/TypeScript, SQLite) that manages per-session agent containers (Bun runtime) isolated via Docker. The system features a typed guard/approval system for privileged actions, a plugin-based skill system for extensibility, and a structured migration framework for database schema evolution. Key operational flows include inbound message routing from channel adapters, session lifecycle management with two-DB mailbox split (inbound/outbound SQLite), container orchestration with credential injection via OneCLI vault, and host sweep for periodic maintenance. The CLI (`ncl`) provides resource CRUD with hooks, command guard integration, and a socket-based transport protocol. The project emphasizes a small, auditable codebase, skill-based feature installation over configuration, and deterministic setup/upgrade workflows with Claude Code fallback for error recovery.
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.
slacrawl is a local-first Slack archiving CLI tool written in Go. It ingests messages, files, users, and channels from multiple sources—Slack API (bot/user tokens), Slack Desktop local cache (LevelDB + IndexedDB), MCP (Model Context Protocol) adapters, and external provider subprocesses—and stores them in a local SQLite database with full-text search (FTS5). The tool provides a rich command surface including sync, search, TUI browsing, analytics reports (digest, trends, quiet channels), retention purging, and Git-based archive sharing (publish/subscribe). It is designed for privacy-conscious users who want offline access to their Slack history without cloud dependency. The architecture follows a clean internal package separation: `cmd/slacrawl` is the entry point, `internal/cli` handles command routing via Kong, `internal/store` provides the SQLite persistence layer with schema migrations and batch writes, `internal/syncer` orchestrates multi-source synchronization, and `internal/slackapi`, `internal/slackdesktop`, `internal/slackmcp`, and `internal/provider` implement source-specific adapters. The codebase is well-tested with extensive Go tests, CI/CD via GitHub Actions, and cross-platform releases (Linux, macOS, Docker). While primarily an application, slacrawl exhibits data pipeline characteristics: it ingests raw Slack data, transforms it into a normalized relational schema with FTS indexing, and exposes analytical outputs (reports, digests). The embedding_jobs table hints at future ML integration. The Git archive sharing module is a novel pattern for distributed data replication. Overall, the codebase demonstrates strong engineering practices with reusable components like the generic MCP client, platform-specific file locking, and the external provider protocol.
This is a mature, actively maintained AI agent skill called 'last30days' that enables agents (Claude Code, Codex, Grok, Gemini CLI, MCP hosts) to research any topic by aggregating content from 20+ social and news platforms (Reddit, X, YouTube, TikTok, Instagram, Hacker News, Polymarket, GitHub, arXiv, Techmeme, Digg, and more) over a rolling 30-day window. The system is primarily a CLI engine (Python) with a companion Go MCP server for Claude Desktop. It employs a sophisticated pipeline: query planning by intent, parallel retrieval from multiple backends (keyless APIs, paid scrapers, CLI tools, LLM-based search), source-specific normalization, engagement-weighted relevance scoring, cross-source clustering, and deterministic fusion (weighted RRF) with per-author caps and diversity floors. Output is rendered as structured JSON, compact text, or self-contained HTML with optional publishing and Atom feeds. The codebase emphasizes security (credential hygiene, no browser cookie reads in unattended mode), determinism (fixture-based evaluation harness with grounding/recency/coherence scores), and graceful degradation (per-source fallback chains, never-raise error envelopes). While classified as an application (it's a skill/plugin for agent hosts), it exhibits strong data engineering traits: source adapters, normalization pipelines, scoring models, and an offline evaluation framework.
AgentMemory is a persistent memory system designed for AI coding agents (Claude Code, Cursor, Codex, etc.) that captures agent observations via hooks, compresses and stores them, and enables semantic/recall search across sessions. Built on the iii-engine framework, it provides a modular architecture with CLI, REST API, MCP server, and web viewer interfaces. The system eliminates repetitive context re-explanation by automatically injecting relevant memories into agent sessions, implements memory consolidation to extract stable facts, and includes features like working memory management, audit trails, and health monitoring. Agent integrations occur through platform-specific hooks and MCP tools, allowing agents to store observations and retrieve context without manual intervention.
This repository implements a Cloudflare Worker that runs the OpenClaw personal AI assistant inside a Cloudflare Sandbox container. The worker acts as a reverse proxy, forwarding HTTP and WebSocket traffic to the OpenClaw gateway running on port 18789 inside the container. It provides an admin UI (React SPA) for device pairing management, REST API endpoints for device approval and storage sync, a Chrome DevTools Protocol (CDP) shim for browser automation via Cloudflare Browser Rendering, and debug routes for troubleshooting. The architecture is a single Hono application with middleware for logging, environment validation, and Cloudflare Access authentication. The catch-all route proxies requests to the container, with special handling for WebSocket connections (message interception for error transformation) and crash recovery (automatic gateway restart with R2 backup restore). The codebase is well-structured with TypeScript strict mode, comprehensive unit tests, and a full end-to-end test suite that deploys to real Cloudflare infrastructure. Notable features include a robust process lifecycle manager for the gateway, a cron-based container wake mechanism, and a CDP shim that translates CDP commands to Puppeteer calls.
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.
CowAgent is a production-grade multi-agent AI assistant platform that routes messages from 12+ IM channels (WeChat, Feishu, Telegram, DingTalk, Slack, Discord, QQ, WeCom, web console, desktop Electron app) through a modular agent core. The core implements planning, tool use (bash, file editing, browser, web search, MCP, sub-agent delegation, scheduler, memory, vision), three-tier memory with vector embeddings and markdown-aware chunking, knowledge base management, skill system with SKILL.md manifests and a skill hub, self-evolution (idle-conversation review loop), and multi-agent team orchestration with peer transport. The architecture is a modular monolith: channel adapters normalize messages into a unified ChatMessage, the Bridge dispatches to per-agent/session model resolution, the Agent protocol (Task/AgentResult/AgentAction) drives the execution loop with streaming, cancellation, and steering, and all state persists to SQLite with incremental migration. Key entry points are app.py (startup orchestration), cli/cli.py (daemon lifecycle), channel/web/web_channel.py (HTTP API and SSE streaming), and the desktop Electron client (React/TypeScript with Zustand stores). External dependencies include LLM APIs (OpenAI, Claude, Gemini, DeepSeek, etc.), IM platform webhooks/SDKs, optional voice TTS/ASR providers, and MCP servers. The codebase demonstrates strong engineering practices with extensive regression tests (200+ test files), atomic file writes, thread-safe context propagation via ContextVar, and security guards for credential paths and SSRF.
Plugin Inspector is a CLI tool and library for offline static and runtime analysis of OpenClaw plugins. It validates plugin structure, SDK imports, hook registrations, and manifest contracts without requiring a live OpenClaw host. The tool generates rich compatibility reports in JSON, Markdown, SARIF, and JUnit formats, integrates with CI pipelines (GitHub Actions, GitLab, CircleCI), and supports batch analysis across plugin corpora. Its architecture is modular: a core inspection engine (src/inspector.js) performs static analysis using AST parsing (acorn, eslint-scope) and regex-based detection; an optional runtime capture subsystem (src/capture-api.js, src/synthetic-probes.js) executes plugin entrypoints with a dynamically generated mock SDK (src/sdk-mock.js) to verify registration behavior and hook handling. The tool also includes a CI policy engine, workspace planning, platform probes, and profiling/diffing utilities. While tightly coupled to OpenClaw internals, the codebase demonstrates strong engineering practices with extensive test coverage, reusable components, and a well-defined public API surface.
1Panel is a production-grade, open-source Linux server management panel built on a distributed core-agent architecture. The system provides a comprehensive web-based GUI (Vue 3 frontend) and a REST API (Go/Gin) that orchestrates an agent running on each managed host. It covers the full server lifecycle: website management (Nginx/OpenResty with custom config parser), database administration (MySQL, PostgreSQL, MongoDB, Redis), Docker container orchestration, firewall management (abstraction over iptables, nftables, firewalld, UFW), system monitoring, backup/restore to multiple cloud storage providers, cron jobs, SSL certificate automation via ACME, and terminal access (local, SSH, container) with AI-assisted command generation. The architecture splits control plane (core) and execution plane (agent) communicating over Unix sockets or HTTPS, supporting multi-node environments. Notable engineering highlights include a reusable task framework with retry/rollback, a firewall lifecycle abstraction with rule identity hashing, a custom Nginx config lexer/parser, and an enterprise extension system via Go build tags and frontend dynamic imports. The codebase is actively maintained with frequent commits and a large open-source community (37k+ stars). However, there is significant code duplication between core and agent packages, and some hardcoded paths and legacy migration logic add complexity.
PPTAgent is an agentic framework for automatic PowerPoint presentation generation from documents. It operates as a production-grade application with CLI, web UI, Docker deployment, and an MCP server for integration with external tools like Claude and Cursor. The system uses a two-stage pipeline: analysis (induction of slide layouts and content schemas from reference presentations) and generation (editing actions via a structured API). It supports multiple generation modes—freeform (DeepPresenter) and template-based (PPTAgent)—and includes a multi-agent orchestration loop with planner, research, and design agents. The codebase is split into two packages: `pptagent` (core generation library and evaluation framework) and `deeppresenter` (production runtime with CLI, Docker, and HTML-to-PPTX conversion). While primarily an application, it has strong research roots, including academic papers at EMNLP 2025 and ACL 2026, an evaluation framework (PPTEval) for content, style, and coherence scoring, and a set of induced slide templates. The architecture is modular, with role-based agents defined in YAML, MCP-based tool servers, and a presentation data model with closure-based editing. External dependencies include OpenAI, Tavily, SerpAPI, MinerU, and Docker, making it a complex but well-structured system for automated presentation creation.
Activeloop's DeepLake is a production-grade, multi-vector database engine for AI data. At its core, it is a columnar, chunked, compressed storage system for tensors (multi-dimensional arrays) with native support for embeddings, images, video, text, and other complex AI data types. It exposes a Python library for dataset management, ingestion (COCO, Labelbox, CSV, Parquet), version control, and integration with PyTorch/TensorFlow/MMDetection. A high-performance C++ backend provides lazy NumPy-like array operations (nd::array), a composable async framework (async::promise), and a Tensor Query Language (TQL). The most distinctive component is a PostgreSQL extension (pg_deeplake) that allows SQL access to DeepLake datasets via custom table and index access methods, supporting vector similarity search (cosine, BM25) and hybrid search. Query execution is delegated to DuckDB through a custom scan node, enabling efficient analytical queries. The extension also includes WAL-based DDL replication across instances. This is primarily an application (a database system), with substantial research-oriented features such as medical image formats, compression codecs, and TPC-H benchmarking.
小贝 (xiaobei) is an AI-powered multi-agent content marketing automation platform for small and medium businesses, built on top of the OpenClaw agent framework. It focuses on producing, publishing, and tracking content across major Chinese social media platforms (WeChat, Douyin, Xiaohongshu, Bilibili, etc.). The system uses a custom forked browser automation CLI (camoufox-cli) for platform interaction, a relay service for API signing, and SQLite databases for content and performance metrics. It includes multiple specialized agent crews (main, IT engineer, content producer, sales-cs) that collaborate through a modular skill system with thin wrapper scripts for agent invocation. The codebase demonstrates solid architecture with consistent patterns (DNA style analysis, workflow steps, patch application), but is heavily coupled to specific platform APIs and DOM structures, making it fragile to upstream changes. It is an actively developed, production-grade application aimed at automating social media operations.