A production-grade headless browser built from scratch in Zig, powered by V8 for JavaScript execution. It implements a vast subset of Web Platform APIs (DOM, CSSOM, HTML/SVG elements, canvas, WebGL, IndexedDB, workers, fetch, WebSocket, etc.) and exposes them through Chrome DevTools Protocol (CDP), WebDriver BiDi, and MCP (Model Context Protocol) servers. Includes a built-in LLM agent mode for natural-language-driven automation, a scripting system (PandaScript) for deterministic replay, and a full network stack with ad blocking, rate limiting, caching, and TLS. Designed for AI agents and automation workloads, it claims significant performance advantages over Chromium in startup time and resource usage. Architecturally, the browser is a monolithic server binary with distinct internal modules: a browser core managing pages, frames, and V8 isolates; a network layer using libcurl with connection pooling and request deduplication; protocol servers (CDP, BiDi, MCP) communicating over WebSocket or HTTP; and an agent subsystem that wraps LLM APIs for task planning and execution. The codebase is heavily tested with hundreds of hand-written HTML conformance tests and runs Web Platform Tests via CI. The engineering demonstrates high craftsmanship: custom arena allocators with V8 memory accounting, compile-time prototype hierarchy reflection for Web IDL bindings, a GCRA rate limiter, a singleflight pattern for request deduplication, and a generic live-collection iterator. While some APIs are stubbed or partially implemented (e.g., WebGL always returns null, video dimensions are hardcoded), the core functionality is extensive and spec-compliant where implemented. The project is actively maintained with nightly orderfile optimizations and regular CI.
This is a production-ready Node.js/Express web application boilerplate designed to jumpstart hackathon projects. The codebase implements a complete user authentication system supporting local email/password, OAuth 2.0/OAuth 1.0a (10+ providers including Google, Facebook, GitHub, Discord, Microsoft), WebAuthn passkeys, and two-factor authentication (TOTP + email). It includes session management with MongoDB, CSRF protection, rate limiting, and custom security measures like timing-safe token comparisons and IP-bound token consumption. Beyond auth, it ships working demos for ~20 third-party API integrations (Stripe, Twilio, GitHub, NYT, Wikipedia, etc.) and AI features powered by LangChain and Groq, including a ReAct agent with SSE streaming, a RAG pipeline with vector search, and LLM-based classification/vision. The repository also provides a sophisticated Playwright-based e2e testing framework using nock-recorded HTTP fixtures, enabling deterministic offline tests without live API keys. All features are organized as deletable modules with a removal checklist to facilitate trimming for production use.
Dora SSR is a production-grade cross-platform game engine designed for rapid development directly on target devices (mobile, desktop, web). The engine is a monolithic C++ core that provides 2D/3D rendering (bgfx), physics (JoltPhysics, PlayRho, Box2D), audio (SoLoud, libopenmpt), animation (Spine, DragonBones), UI (Yoga layout), and a full scene graph. It exposes scripting via multiple languages: Lua (with a custom binding generator), TypeScript (compiled to Lua via a vendored tstl fork), WebAssembly (via wasm3), Rust (via FFI), and C# (via P/Invoke). A built-in Web IDE (React/Monaco-based) allows coding and debugging from a browser on the same network. The engine also includes an AI coding agent with memory, skill tools, and preview session management, integrated into the IDE workflow. Over 50 CI workflows build for Android, iOS, Windows, macOS, Linux, and Web (Emscripten).
This repository is a comprehensive tutorial on building AI agent harnesses, structured as 17 progressive lessons. Each lesson introduces a single mechanism (tool use, permissions, hooks, planning, subagents, skill loading, context compaction, memory, task system, background tasks, cron scheduler, agent teams, MCP integration, workflow runtime, and goal loop) that extends a core agent loop without modifying it. The harness enables a language model (Claude) to perceive, reason, and act through tool interactions while managing context, permissions, and collaboration. The repository includes runnable Python implementations for each lesson and an interactive Next.js web application with visualizations for learning and experimentation.
PPT Master is a Python-based application designed to generate natively editable PowerPoint (PPTX) presentations from diverse source formats including PDF, DOCX, Markdown, and URLs. The system operates as a CLI tool and AI agent skill, orchestrating a workflow that converts source content into SVG intermediates before rendering them into native DrawingML shapes within the PPTX file. This approach prioritizes editability over flattened image exports, allowing users to modify text and shapes directly in PowerPoint. The architecture relies heavily on external AI APIs for content generation and image creation, with a local Flask server providing live preview and confirmation capabilities. The codebase functions as a presentation engineering toolkit, featuring bidirectional conversion between PPTX and SVG, template management, and asset handling. It enforces strict design constraints via machine-readable 'spec_lock' files to maintain visual consistency across generated decks. The application is structured as a modular skill within AI IDEs (Claude Code, Cursor), allowing developers to invoke presentation generation via chat commands. While the core conversion logic is robust, the system's stability is intrinsically linked to the availability and schema of external AI providers and the specific behavior of the python-pptx library. This repository represents a hybrid of application engineering and data pipeline logic. While the primary output is a software artifact (the PPTX file), the internal processing involves significant data transformation (document parsing, image generation, XML manipulation). The extensive example suite serves as both documentation and regression testing for the conversion engine, demonstrating the tool's capability across technical, business, and artistic domains.
CopilotKit is a comprehensive SDK and framework designed to integrate AI agents into user interfaces across web, mobile, and chat platforms. It functions as a middleware layer connecting frontend UI components (React, Vue, Angular) with backend agent frameworks (LangGraph, CrewAI, PydanticAI, etc.). The core value proposition lies in its ability to synchronize state between the agent and the UI, support generative UI (A2UI) for dynamic component rendering, and facilitate human-in-the-loop workflows. The repository is structured as a monorepo containing core runtime packages, framework-specific adapters, and an extensive suite of integration showcases. The architecture relies on a centralized runtime (`@copilotkit/runtime`) that handles agent connections via SSE and manages tool execution. Frontend interactions are managed through hooks (`useCopilotKit`, `useAgent`) that subscribe to the runtime. The codebase demonstrates a polyglot approach, supporting Python, TypeScript, Java, and C# backends alongside multiple frontend frameworks. While the core SDK is well-structured, the repository exhibits significant code duplication across its 20+ integration showcases, which serve as both documentation and regression tests.
OpenCode-Mem is a plugin for OpenCode, an AI coding assistant, that provides persistent memory using vector embeddings and Turso/libSQL. It stores project-level technical memories (decisions, code facts, patterns) and learns user preferences/configs across sessions. The system uses local ONNX embeddings (or remote API) and supports multiple LLM providers (Anthropic, OpenAI, Google Gemini, MiniMax). It features auto-capture of session content, user profile learning with confidence decay, deduplication, and migration services. A full React web UI allows browsing, editing, and managing memories and user profiles. The architecture is modular: plugin entry, AI provider abstraction, Turso shard management, embedding service, web server, and shared API schemas. While primarily an application, it includes robust data pipeline patterns for vector search, ETL (migration), and user modeling.
An Obsidian plugin (Gemini Scribe) that integrates multiple AI providers (Gemini, Anthropic, OpenAI, Ollama) for chat, agent-based automation, and knowledge management within the Obsidian vault. The system provides a modular architecture with an agent loop that executes tools (vault operations, web search, RAG semantic search, image generation, deep research) with confirmation flows and diff previews. It features a declarative settings UI with per-feature provider routing, a skill system following the agentskills.io spec, MCP server integration, scheduled tasks, lifecycle hooks, and an evaluation harness for benchmarking agent behavior. The codebase demonstrates strong engineering practices: thorough unit testing (73%+ line coverage), clean module boundaries with leaf modules to prevent circular imports, and reusable patterns like typed event buses, retry decorators, and cancellation-safe streaming.
OpenCowork is a desktop AI agent application built with Electron, React, and TypeScript. It enables users to automate tasks through natural language interactions, supporting browser automation (via Playwright), local command execution, image processing, and integration with messaging platforms like Feishu. The application features a modular architecture with separate main and renderer processes, communicating via IPC. Core functionality includes task orchestration, skill-based workflow reuse, scheduling, memory management, and MCP (Model Context Protocol) integration for extensibility. The system emphasizes local-first operation, user control, and reliable execution with fallback mechanisms for unstable automation scenarios.
PicoClaw is an ultra-lightweight personal AI agent platform written in Go, engineered to run on hardware as small as $10 RISC-V boards while providing a full-featured chat agent experience. In production it is a daemon (picoclaw) that connects 30+ LLM providers (OpenAI, Anthropic, Gemini, Azure, Bedrock, Claude CLI, Codex, Ollama, etc. behind a common provider factory) to 19+ messaging channels (Telegram, Discord, WhatsApp, WeChat, WeCom, Slack, IRC, Matrix, DingTalk, Feishu, MQTT, etc.), exposing an agent loop with tool calls, MCP server integration, session management, voice I/O (ASR/TTS), cron jobs, skills marketplace, and hardware tools (I2C, SPI, serial). A companion launcher binary (picoclaw-launcher) runs a Go web backend with an embedded React/TypeScript frontend for configuration, model/channel/credential management, logs, and live chat.\n\nThe architecture is a modular monolith: pkg/agent implements the turn pipeline (context assembly, thinking levels, tool loop, streaming, stop handling), pkg/providers abstracts LLM backends with rate limiting, cooldown tracking, and fallback chains driven by an error classifier, pkg/channels provides a factory-registered channel abstraction over a shared base, and pkg/bus + pkg/events carry inbound/outbound messages and typed runtime events with backpressure. Agents are defined by AGENT.md/SOUL.md workspace files and support delegation/spawning. An experimental evolution subsystem clusters learning records and generates skill drafts via LLM, and the seahorse SQLite FTS5 store provides compacted short-term memory with BM25 retrieval and summary trees. Legacy OpenClaw configs can be migrated.\n\nThe codebase is heavily tested (500+ test files across nearly every package), uses cross-platform build tags for Windows/Linux/Unix/Android, and ships Docker images plus a self-update mechanism. Strong engineering practices include atomic file writes, zip-slip and SSRF protection utilities, typed event buses, factory registries, and a ToolResult structure separating LLM-facing vs user-facing output. The project is pre-1.0 with rapid release cadence; the evolution subsystem, some platform-specific hardware stubs, and the large channel/provider surface are the least mature areas. It is not a data-research repository - the LOCOMO memory benchmark and LLM-as-judge evaluation code in cmd/membench support engineering measurement rather than producing research artifacts.
Peekaboo is a mature macOS desktop automation toolkit that provides a CLI, Mac app, and MCP server for screen capture, UI element detection, input synthesis, window management, and AI agent integration. The architecture is modular: a Swift CLI (peekaboo) exposes ~33 commands for interaction, system control, and AI agent orchestration; a Mac app provides a menu bar interface, session management, and visualizer overlays; a bridge daemon (PeekabooBridge) enables secure remote automation via a versioned socket protocol with operation allowlisting. The MCP server exposes native automation tools to AI clients (Claude, Cursor, etc.) via stdio transport. The agent runtime (PeekabooAgentService) supports multiple AI providers (OpenAI, Anthropic, Ollama, etc.) with streaming, tool calling, and session persistence. The codebase is written in Swift 6.2 with strict concurrency, extensive unit/integration tests, and a focus on safety (fail-closed target validation, honest effect reporting). It is not a data research project; it is a production-grade application for macOS automation.
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.
This repository is a curated resource hub (awesome list) for Claude Code skills, targeting Chinese-speaking developers. It contains 20 original SKILL.md files that can be directly installed into Claude Code, plus a curated directory of 441+ third-party skills organized by categories such as development efficiency, content creation, platform operations, and more. The repo includes a static website (docs/index.html) that mirrors the README, automated Python/Node.js scripts for synchronization, and rigorous CI/CD pipelines with pinned dependencies and comprehensive tests. It is not a running application but a content curation project with high-quality infrastructure for maintaining consistency between the README and the website, including atomic file writes and strict anchor validation. The original skills are well-structured and cover practical scenarios like code review, documentation generation, API testing, and refactoring, all in Chinese.
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.
AnythingLLM is a full-stack, self-hosted AI chat platform designed for Retrieval-Augmented Generation (RAG) over private documents. It provides a web interface where users create workspaces, upload documents (PDF, DOCX, images with OCR, audio, etc.), which are then chunked, embedded, and stored in a vector database (default LanceDB, with support for PGVector, Pinecone, Qdrant, and others). Chat queries retrieve relevant document chunks and feed them to an LLM of choice (supporting 30+ providers including OpenAI, Anthropic, Ollama, and local models via KoboldCPP). The platform also features an extensible agent system (aibitat) with plugins for file system operations, SQL databases, Gmail, Google Calendar, web scraping, image generation, and scheduled jobs. A separate 'collector' microservice handles document ingestion and format conversion, while the 'open-computer' subproject provides a QEMU-based virtual machine for autonomous browser automation. The frontend is a React SPA with multi-user support, role-based access, internationalization, embeddable chat widgets, and a community hub for sharing agent skills, system prompts, and slash commands. The architecture is a monolith (Express server) with the collector as an isolated service, and the open-computer as a standalone CLI/service. It relies on external AI APIs, vector databases, and local storage, making it suitable for both cloud and on-premises deployment.
EvoMap Evolver is a self-evolving AI agent engine built as a Node.js >=22.12 CLI daemon. It runs a genome-evolution loop: scans session memory/logs, extracts signals, selects 'Genes' (prompt/strategy patches) and 'Capsules' (validated skill bundles) from a local JSON/JSONL asset store, generates GEP-framed prompts for coding agents (Claude Code, Codex, Cursor, Gemini CLI, opencode, Kiro), executes those sessions, and records outcomes in a memory graph to adapt future selections. The system solidifies successful patterns into new reusable assets, auto-distills failure patterns and SKILL.md files into Genes/Capsules, and can open PRs or run validation sandboxes against candidate changes. It also ships an LLM proxy (Anthropic/OpenAI/Gemini/Vertex/Ollama routes with trace encryption and token-savings attribution), an ATP (Agent Transaction Protocol) marketplace for buying/completing agent tasks with auto-buyer and auto-deliver, a validation daemon for decentralized task verification, a local Web UI dashboard, and an experiment runner for A/B comparing evolution strategies. Hub synchronization (SSE event delivery, mailbox sync, OAuth device login) connects nodes to the evomap.ai network, but the system is designed to degrade gracefully into fully offline solo mode.
ACI.dev is an open-source platform that provides a unified tool-calling interface for AI agents, enabling them to interact with over 600 third-party services via REST APIs or custom connectors. The backend is built with FastAPI, PostgreSQL (with pgvector for semantic search), SQLAlchemy, and Alembic for migrations, while the frontend is a Next.js 15 application with Shadcn UI, TanStack Query, and Zustand. The platform includes a full OAuth2 flow for service authentication, encrypted credential storage using AWS KMS, Stripe-based subscription billing, and a CLI for administrative tasks. It is designed as a multi-tenant SaaS with per-project quotas, agent management, and a playground for testing function calls. Architecturally, the system is modular: apps are defined as JSON schemas (app.json and functions.json) in a standardized format, and a generic execution engine dispatches calls to REST endpoints or local connector modules. The codebase demonstrates strong separation of concerns with CRUD modules, dependency injection, and middleware for rate limiting and logging. It also includes an evaluation pipeline for measuring search relevance (using synthetic intents and metrics like MRR), and a vector-based search for app and function discovery. While primarily an application, the repository contains research-oriented components such as the evaluation pipeline and embedding-based search, reflecting a hybrid nature focused on improving AI agent tool selection. The code is well-maintained and actively developed, with comprehensive test coverage (though some tests are skipped or TODO). The integration system is extensible, and several components (e.g., OAuth2 manager, encrypted SQL types, generic data table UI) are well-crafted and reusable. However, the codebase shows some technical debt in the form of hardcoded configurations, in-memory rate limiting, and app-specific OAuth2 overrides. Overall, it is a professional-grade platform with a high level of craftsmanship, suitable for production use and further extension.
This repository is the marketing website for OpenClaw, an open-source AI agent platform that runs locally and integrates with chat applications. The site serves as the primary distribution channel for installer scripts (macOS/Linux via shell, Windows via PowerShell), hosts a blog with technical product notes, an ecosystem catalog of ~70 open-source projects, press coverage, podcast episodes, and community testimonials. It is built as a static site using Astro 7 with TypeScript, deployed on Vercel, and leverages a custom design system (Carapace) for CSS tokens and components. The codebase is well-structured with reusable utility libraries, client-side interactive components (hero animation, integration rail, quickstart code selector), and comprehensive SEO/security measures (sanitized URLs, JSON-LD escaping, CSP headers). While primarily a marketing site, it also includes CI workflows for cross-platform installer testing and skill updates. The repository is actively maintained with frequent commits, dependabot updates, and a clear separation between website code and product installer scripts.
TidGi-Desktop is a cross-platform Electron application that integrates TiddlyWiki (a personal wiki) with AI agent capabilities, Git synchronization, and modern desktop features. It allows users to manage multiple workspaces (folder-based or single-file HTML wikis), sync with Git remotes, and interact with AI agents for chat, tool execution, and knowledge management. The architecture is Electron multi-process with main process, renderer processes (multiple windows), and a utility process for wiki worker. Services are wired via Inversify DI container and communicate via typed IPC (electron-ipc-cat). Key entry points include src/main.ts (Electron main), src/renderer.tsx (React renderer), src/services/agentInstance/ (AI agent lifecycle), src/services/wiki/ (wiki management), and src/services/git/ (Git operations). External dependencies include TiddlyWiki, Git (via dugite), SQLite (TypeORM), various AI SDKs (OpenAI, Anthropic, etc.), OAuth providers, and system-level integrations. The codebase is well-structured with a service-oriented architecture, extensive test coverage (unit, E2E, BDD), and a rich preference system driven by Zod schemas. It demonstrates high craftsmanship in areas like AI prompt concatenation, tool registration, and file system watching, though some modules are tightly coupled to the application's domain.