#1
World Monitor is a real-time global intelligence dashboard built by Elie Habib that aggregates AI-synthesized news, geopolitical signals, financial data, and infrastructure tracking into a unified situational awareness interface. The project ingests 500+ curated feeds across 15 categories from 65+ external data providers, covering geopolitics, finance, energy, climate, aviation, cyber, military, and news intelligence. A standout feature is its dual map engine combining a 3D globe (globe.gl/Three.js) and a WebGL flat map (deck.gl/MapLibre GL) with 56 layer types, alongside a proprietary Country Instability Index (CII v8) scoring 31 Tier-1 countries and a 7-signal finance market composite tracking 29 stock exchanges, commodities, and crypto. The platform ships six domain-specific variants (world, tech, finance, commodity, happy, energy) from a single TypeScript/Vite codebase, with native desktop apps via Tauri 2 for macOS, Windows, and Linux, and supports 25 languages including RTL. Notably agent-friendly, it exposes an MCP server, REST API with OpenAPI spec, an official CLI (`worldmonitor` npm package), and zero-dependency SDKs in Python, Ruby, and Go, making it well-suited for AI agent pipelines and programmatic intelligence workflows. Local AI inference is supported via Ollama with no API keys required, and cloud inference via Groq and OpenRouter is also available. The project is actively maintained under AGPL-3.0, has a stable public deployment, and is notable for its breadth of data integration, multi-platform reach, and first-class agent/MCP tooling — positioning it as a trending open-source geopolitical intelligence platform.
AppsMCPAgentslocal-firstmultimodalworkflow-automation
★ 74,912 total+12,862 this week
#2
**mattpocock/skills** is a curated collection of AI coding agent "skills" — small, composable prompt-based workflows — built by Matt Pocock for real-world software engineering rather than casual "vibe coding." The project directly addresses four common failure modes when using AI coding agents: misalignment between intent and output, excessive verbosity, broken or untested code, and architectural decay. To fix misalignment, it introduces "grilling" skills (`/grill-me`, `/grill-with-docs`) that force the agent to ask detailed clarifying questions before writing any code. To combat verbosity, it promotes building a shared domain language via a `CONTEXT.md` file and Architecture Decision Records (ADRs), inspired by Domain-Driven Design principles. For code quality, it wraps test-driven development into a `/tdd` skill enforcing red-green-refactor loops, and provides a `/diagnosing-bugs` skill for structured debugging. To prevent architectural rot, `/improve-codebase-architecture` periodically scans the codebase and surfaces improvement opportunities as an HTML report. Skills are split into user-invoked (orchestration, e.g., `/implement`, `/wayfinder`, `/to-spec`, `/triage`) and model-invoked (reusable discipline, e.g., `/prototype`, `/code-review`). Installation is flexible: either via the `skills.sh` installer (`npx skills@latest add mattpocock/skills`), which copies editable files into your project, or as a managed Claude Code plugin that auto-updates. The project supports GitHub, Linear, and local file issue trackers. With ~60,000 newsletter subscribers and grounding in classic engineering literature, it is trending as a pragmatic, philosophy-driven alternative to heavier AI workflow frameworks like GSD, BMAD, and Spec-Kit, appealing to developers who want AI assistance without surrendering engineering control.
ToolsAgentscodingworkflow-automation
★ 189,984 total+12,197 this week
#3
OmniRoute is a free, open-source AI gateway that aggregates a vast ecosystem of AI providers into a single unified endpoint, letting developers route requests from any AI coding tool through one interface. Its central promise is to let users "never stop coding" by aggregating the documented free tiers of numerous providers into roughly 1.53 billion free tokens per month (steady state), potentially rising to ~2.15 billion in the first month when one-time signup credits are included. The project claims support for 290 AI providers—more than 90 of which offer free tiers—and computes its free-token figure from 43 provider pools spanning 516 models. OmniRoute connects popular AI coding tools and agents such as Claude Code, Codex, Cursor, Cline, Copilot, and Antigravity to free Claude, GPT, and Gemini models, with automatic fallback so that if one provider hits its rate limit, requests seamlessly reroute to another. It offers 19 routing strategies to distribute load intelligently across providers and pools, and starts at $0 cost to use.
A key differentiating feature is its token compression technology: a stacked "RTK + Caveman" compression approach that reduces token usage by 15–95% (averaging about 89%), helping users avoid hitting their limits and stretch free allowances much further. The project emphasizes honesty in its free-tier accounting, using pool-deduplication math where each shared pool is counted only once—noting that naively counting every rate limit 24/7 would inflate the number to roughly 10 billion, which they refuse to publish. They also flag 15 providers with restrictive Terms of Service so users can decide for themselves, and surface signup credits and permanently-free no-token-cap providers (such as SiliconFlow, Z.AI GLM-Flash, Kilo, OpenCode Zen, and Baidu) separately so they never inflate the headline figure. Notable per-model free allowances include Mistral Large 3 (1B), GPT-4o mini (150M), Gemini 2.5 Flash (60M), and Claude Sonnet 4.5 (25K). First-month signup credits are listed for providers like Vertex (300M), AgentRouter (200M), Predibase (25M), Together (25M), GLM-CN (20M), Doubao (15M), AI21 (10M), LongCat (10M), DeepSeek (5M), Hyperbolic (5M), and Nscale (5M), plus a $10 OpenRouter top-up that unlocks an additional 24M/month. These figures are re-audited every two weeks against the live catalog and can move in either direction as providers add or remove free tiers, with a live dashboard at /dashboard/free-tiers showing used and remaining tokens.
Regarding the query "a2a": OmniRoute provides a full CLI along with A2A (agent-to-agent) and MCP (Model Context Protocol) integration, positioning it as a comprehensive tool for AI agent workflows and interoperability. The project appears to be quite mature and actively maintained, distributed across multiple channels: it is available as an npm package, a Docker Hub image, and an Electron desktop application, with badges tracking npm monthly downloads, Docker pulls, and Electron downloads. It is licensed under the permissive MIT license and is local-first and privacy-focused, meaning user data and API keys stay on the user's own machine. The project supports a flagship "Combos" feature for stacking providers, runs "anywhere," and offers dashboard screenshots and demos. OmniRoute has strong signs of trending momentum: it carries a Trendshift repository badge (repository 23589), a Star History rank badge, and social star tracking, indicating rising GitHub popularity. It maintains an active community across Discord, Telegram, and WhatsApp (both global and Brazil-specific groups), and the maintainer Diego Souza promotes it via LinkedIn and GitHub. The README is exceptionally polished and heavily internationalized, available in 43 languages including English, Portuguese (Brazil and Portugal), Spanish, French, Italian, German, Dutch, Russian
MCPServingToolslocal-firstcodingworkflow-automation
★ 31,258 total+10,869 this week
#4
Orca (stablyai/orca) is a cross-platform desktop AI orchestrator designed for high-productivity developers — self-described as a tool for "100x builders" — that lets users run multiple AI coding agents simultaneously, each isolated in its own Git worktree, all tracked and managed from a single unified interface. The core value proposition is parallel agent orchestration: a single prompt can be fanned out across up to five agents (e.g., Codex, Claude Code, OpenCode, Pi), with results compared and the best branch merged, dramatically accelerating iterative development workflows. Orca supports an exceptionally broad ecosystem of CLI-based AI agents, including Claude Code, Codex, Grok, Cursor, GitHub Copilot, Cline, Devin, Goose, Auggie, Amp, Hermes Agent, MiMo Code, Autohand Code, Codebuff, and many more — essentially any agent that runs in a terminal. Key features include a mobile companion app (iOS and Android) for monitoring and steering agents remotely, Ghostty-class WebGL terminal splits with persistent scrollback, a Design Mode that captures live HTML/CSS/screenshots from an embedded Chromium browser directly into agent prompts, native GitHub and Linear integrations for in-app PR and issue management, SSH remote worktrees with auto-reconnect and port forwarding, annotated AI diff review, drag-and-drop file/image prompting, a scriptable CLI, Computer Use for desktop UI automation, and usage/rate-limit tracking with hot-swap account switching. The project ships updates daily and is available on macOS, Windows, and Linux under the MIT license. It is notably trending due to the rapid convergence of agentic AI coding tools and Orca's unique positioning as an agent-agnostic orchestration layer rather than a single-agent IDE, making it broadly relevant across the fragmented AI coding assistant landscape. The project has an active Discord community and social presence on X, and its multilingual README (Chinese, Japanese, Korean, Spanish, French, Portuguese) signals strong international adoption momentum.
AgentsToolsAppscodingworkflow-automationmultimodal
★ 29,974 total+7,385 this week
#5NEWPartial week
OpenWorker is an open-source, local-first AI desktop agent created by Andrew Ng that delivers finished work products—documents, reports, calendar updates, inbox triage—rather than just conversational responses. Currently in open beta, it runs a Python-based agent server paired with a React/Tauri desktop GUI, breaking user-specified goals into steps and executing them across 25+ integrations including GitHub, Slack, Jira, Notion, Linear, HubSpot, Gmail, Google Calendar, Outlook, and monday.com. It supports MCP-compatible tools and is model-agnostic, allowing users to bring API keys from OpenAI, Anthropic, Google Gemini, DeepSeek, Mistral, Grok, Qwen, and others, or run fully locally via Ollama. Privacy is emphasized: all agent logic, credentials, and conversations stay on-device, with only OAuth brokering handled in the cloud. Built on Ng's own aisuite library, OpenWorker is notable for combining broad LLM provider support, approval-gated actions, scheduled automations, and a Slack-native workflow in a single self-updating desktop app. Its association with Andrew Ng and its practical, deliverable-focused approach likely contribute to its GitHub trending status.
AgentsMCPAppslocal-firstworkflow-automationon-device
★ 7,075 total+6,946 this week
#6
Openship is an open-source, self-hostable deployment platform with built-in CI/CD that automates the full lifecycle of getting an application from source code to production. Users point it at a GitHub repo, local folder, or prebuilt artifact, and Openship handles detection, building, running, routing, and TLS termination end-to-end — with zero config files required. The platform supports any stack (Node, Python, Go, Rust, PHP, Ruby, Java, .NET, Docker, monorepos) and includes full backend services: Postgres, MySQL, MongoDB, Redis, workers, WebSockets, storage, a built-in mail server with DKIM/SPF/DMARC, scheduled backups, CDN with HTTP/3 and Brotli, and real-time monitoring. It can be driven through three interfaces — a desktop app (for solo users managing servers over SSH), a web dashboard (for teams), and a CLI — plus a REST API and an MCP endpoint designed for AI agents, with strict permission re-checking and credential route exclusions. Deployment targets include Openship Cloud (managed, zero setup), any VPS (Hetzner, DigitalOcean, Linode, OVH), dedicated/bare-metal servers, and multi-server setups. The self-hosted stack runs via Docker Compose (Linux, using OpenResty for edge routing and Let's Encrypt for TLS) or in bare mode on macOS/Windows. Push-to-deploy via GitHub webhooks rebuilds only affected monorepo services. Self-hosting is free, the core is described as production-ready, and the project is actively developed with multi-node clustering noted as coming next. Its Trendshift badge and broad multilingual README signal growing international traction.
MCPAgentsAppsworkflow-automationlocal-firstsecurity
★ 8,765 total+5,305 this week
#7
`code-review-graph` (CRG) is an open-source Python tool designed to reduce token waste when AI coding assistants perform code review tasks. The core problem it addresses is that AI tools tend to re-read large portions of a codebase during reviews, burning excessive tokens; CRG solves this by building a structural map of the code and feeding AI assistants only the precise context they need. It parses a repository into an Abstract Syntax Tree (AST) using Tree-sitter, stores the code as a graph of nodes (functions, classes, imports) and edges (calls, inheritance, test coverage) in a SQLite backend, and queries this graph at review time to compute the minimal set of files an AI assistant must read. Integration with AI assistants happens through the Model Context Protocol (MCP), allowing the assistant to query graph tools directly. A central feature is "blast-radius analysis": when a file changes, the graph traces every caller, dependent, and test affected by that change, so the AI reads only impacted files rather than scanning the whole project. The tool supports incremental updates in under two seconds—file saves and commit hooks trigger diffs that use SHA-256 hash checks to re-parse only changed files, allowing a 2,900-file project to re-index in under two seconds. CRG is particularly aimed at solving the monorepo token-waste problem, funneling hundreds of thousands of source tokens down to roughly 2,495-token graph responses (a claimed 93x reduction). Installation is streamlined via a single `code-review-graph install` command that auto-detects and configures supported AI coding platforms, writing correct MCP configurations, installing platform-native hooks/skills, and injecting graph-aware instructions into platform rules. Supported platforms include Codex, Claude Code, CodeBuddy Code, Cursor, Windsurf, Zed, Continue, OpenCode, Antigravity, Gemini CLI, Qwen, Qoder, Kiro, and GitHub Copilot (both VS Code and CLI variants). The tool offers a symmetric, safe uninstall command with dry-run, keep-data, and per-repo options that only removes CRG-owned files while preserving unrelated MCP servers and configurations via atomic writes. Language coverage is broad, spanning web, backend, systems, mobile, scripting, and config categories—including Python, JavaScript/TypeScript/TSX, Go, Rust, Java, C/C++, C#, VB.NET, Ruby, Kotlin, Swift, PHP, Scala, Solidity, Dart, R, Perl, Lua/Luau, Objective-C, shell scripts, Elixir, Zig, PowerShell, Julia, ReScript, GDScript, Nix, Verilog/SystemVerilog, SQL, Terraform/OpenTofu, Ansible, Vue/Svelte, Astro, and Jupyter/Databricks notebooks. Users can add support for uncovered languages without forking by dropping a `languages.toml` file mapping extensions
RetrievalMCPToolslocal-firstcodingvector-database
★ 26,697 total+5,078 this week
#8
Graphify is an open-source developer tool built by Graphify Labs that transforms entire software projects — including code, documentation, PDFs, images, and video — into a traversable knowledge graph that AI coding assistants can query directly. Rather than relying on traditional file search or vector embeddings, Graphify constructs a real graph of concepts and relationships that developers and AI agents can navigate using natural language queries, path tracing, and node explanation commands. The core philosophy is that understanding a codebase should feel like exploring a map, not grepping through files, and Graphify delivers on that by making the graph the primary interface for project comprehension.
The tool is invoked by typing `/graphify .` inside any supported AI coding assistant, after which it parses the entire project and produces three output artifacts: an interactive `graph.html` file viewable in any browser with clickable nodes and community filtering, a `GRAPH_REPORT.md` summarizing key concepts and surprising connections, and a `graph.json` file that persists the full graph for repeated querying without re-reading source files. This on-demand workflow is positioned as the open-source entry point, while the team is building an always-on, continuously updating version at graphify.com, for which users can join a waitlist.
A defining technical feature is that code parsing is entirely local and deterministic, powered by tree-sitter AST analysis across approximately 40 programming languages. No LLM is invoked and no data leaves the machine during the code-mapping phase. Only the semantic pass over non-code assets like documents, PDFs, images, and audio/video calls an external model, and only when the user configures an API key. This local-first design is a deliberate differentiator from most AI-powered code intelligence tools that rely on per-token LLM calls for every analysis step.
Every edge in the graph carries a confidence tag: `EXTRACTED` for relationships explicitly present in the source, and `INFERRED` for those resolved by Graphify's own analysis. This transparency lets developers and AI agents distinguish ground-truth structural facts from derived inferences, which is important for trust in agentic workflows. The graph also surfaces "god nodes" — the most-connected concepts that everything flows through — and uses the Leiden community detection algorithm to split the graph into labeled subsystems without requiring any LLM calls, making community labeling both fast and cost-free.
Query capabilities include `graphify explain "<concept>"` for detailed node inspection, `graphify path A B` for shortest-path tracing between any two concepts, and `graphify query "<question>"` for returning a scoped subgraph in response to a plain-language question. These commands operate against the persisted `graph.json`, meaning the graph is a durable artifact that can be queried repeatedly and shared across team members or CI pipelines. Inline code annotations such as `# NOTE:` and `# WHY:` comments, as well as ADR and RFC citations, are promoted to first-class graph nodes linked directly to the relevant code, preserving architectural rationale as a queryable layer.
Benchmarks reported in the README show competitive performance on established memory and retrieval tasks. On the LOCOMO benchmark with 300 samples, Graphify achieves a recall@10 of 0.497, compared to 0.048 for mem0 and 0.149 for supermemory. On LongMemEval-S with 50 samples, it reaches 76% QA accuracy, tied with dense RAG approaches. Crucially, Graphify achieves these results with zero LLM credits consumed during graph construction, whereas most competing systems incur per-token costs. The benchmarks were run on a shared harness with blind judge validation achieving 90.6% agreement and a Cohen's kappa of 0.81, lending methodological credibility to the reported numbers.
The tool integrates with a wide range of AI coding assistants including Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot, among 15 or more platforms. Installation is straightforward via `uv tool install graphifyy` or `pipx install graphifyy`, followed by `graphify install` to register the skill with the assistant. Project-scoped installs are supported via a `--project` flag, writing skill files into the repository itself for team sharing and CI use. A strict mode for Claude Code (`--strict`) is also available to ensure the assistant actively uses the graph rather than merely having access to it.
The README is available in over 30 languages, signaling a strong internationalization effort and a broad intended audience. The project is listed on Trendshift and is backed by Y Combinator (S26 batch), which adds institutional credibility and suggests it is in active early-stage commercial development. The PyPI package name is `graphifyy` (double-y) to distinguish it from unaffiliated packages, while the CLI command remains `graphify`. The combination of zero-cost local graph construction, transparent edge provenance, multi-modal input support, broad AI assistant compatibility, and strong benchmark results makes Graphify a notably well-positioned project in the rapidly growing space of AI agent tooling and codebase intelligence.
RetrievalToolsMCPlocal-firstmultimodalcoding
★ 96,592 total+4,880 this week
#9
Hallmark is a design skill/prompt layer for AI coding assistants (Claude Code, Cursor, and Codex) that aims to produce UI designs that don't look generically AI-generated. Created by Together AI and authored by Nutlope, it works by selecting a "macrostructure" for a given brief, applying one of twenty curated themes, and running 57 "slop-test" gates plus a pre-emit self-critique to avoid the default on-distribution patterns LLMs tend to produce. It exposes four verbs: a default build mode, an audit mode for scoring existing code, a redesign mode that rebuilds with a different fingerprint, and a study mode that extracts design DNA from screenshots or URLs. A newer "Custom" mode generates fully bespoke palettes, typography, and layouts from scratch when no catalog theme fits. Output is self-contained HTML + CSS. Installation is via `npx skills add nutlope/hallmark` and it integrates into Claude Code, Cursor, or Codex. The project is early-stage but notable for directly addressing the homogeneity problem in AI-generated UI, making it relevant to developers and designers seeking more distinctive, varied outputs from AI coding tools.
ToolsAppscodingworkflow-automation
★ 18,367 total+4,838 this week
#10
QwenPaw is a personal AI assistant platform developed under the agentscope-ai organization, designed to be deployed locally or in the cloud and extended through a rich ecosystem of Skills, Plugins, and multi-channel integrations. The project's tagline — "Works for you, grows with you" — reflects its philosophy of being a persistent, extensible, and privacy-respecting agent that adapts to user needs over time. At its core, QwenPaw is built on top of AgentScope 2.0, representing a ground-up architectural rewrite that introduced what the team calls an "Agent OS" paradigm, treating the AI agent as an operating system layer with distinct pillars for Resources, Governance, and Sandbox execution.
One of QwenPaw's most distinctive features is its three-layer memory architecture: a live working context, a full verbatim history, and a distilled long-term knowledge store powered by ReMe v0.4.0. Unlike many AI assistants that summarize and discard older conversation turns, QwenPaw persists every turn and indexes evicted context for on-demand recall, ensuring nothing is permanently lost. This "Scroll Context" approach is a deliberate design choice aimed at making the assistant genuinely reliable for long-running tasks and complex workflows.
The platform ships its own family of fine-tuned models — QwenPaw-Flash in 2B, 4B, and 9B parameter sizes — specifically trained for agent tasks, and includes a built-in local runtime that requires no API key or cloud dependency. It also supports Ollama, LM Studio, and more than 14 cloud providers, giving users maximum flexibility in how they run inference. This local-first stance is reinforced by kernel-level security features including a Sandbox, Tool Guard, File Guard, Skill Scanner, and Access Policy system that blocks dangerous commands before execution.
QwenPaw supports multi-agent orchestration, allowing users to spawn independent agents with their own memory and skill sets, coordinate sub-agents at runtime, and connect across systems using the Agent Communication Protocol (ACP), as well as MCP and A2A connector layers. A dedicated Coding Mode provides a three-panel Web IDE with file tree, diff preview, chat interface, jump-to-definition, find-references, and structural code search, making it a capable development assistant as well as a general-purpose one.
The platform is reachable across an impressive range of messaging and collaboration channels — DingTalk, Lark, WeChat, Discord, Telegram, iMessage, and QQ — all from a single deployed instance. Users can also interact via a Console web UI, a full-screen Terminal UI (TUI), or a desktop application. This omnichannel reach makes QwenPaw particularly notable for enterprise and power-user scenarios where communication is fragmented across platforms.
Extensibility is a first-class concern: QwenPaw supports a plugin marketplace, a Skill system covering scheduling, document processing, browser automation, and news aggregation, and MCP integration for external tools. The recently launched AgentScope Platform provides free cloud deployment, plugin sharing, and a Skill marketplace, lowering the barrier to entry significantly. The v2.0.1 release introduced PawApp, a mini-app platform, user-editable Agent Modes, and Oh-My-Paw plugins, signaling a growing ecosystem around the core assistant.
In terms of maturity, QwenPaw is actively developed with frequent releases — v2.0.0 launched in July 2026 followed quickly by v2.0.1 — and maintains documentation in English, Chinese, Japanese, and Russian, indicating a broad international audience. It is available via PyPI, supports Python 3.11 through 3.13, and offers one-command script installers for macOS, Linux, and Windows. The project is licensed under Apache 2.0 and uses the Black code style. Its presence on Trendshift's daily trending repositories badge, combined with active Discord, X, and DingTalk communities, suggests strong and growing community momentum. For
AgentsAppsMCPlocal-firstcodingworkflow-automation
★ 28,261 total+4,753 this week
#11
Baidu's **Unlimited-OCR** is an advanced OCR system designed to push the boundaries of document parsing through "one-shot long-horizon parsing," positioning itself as a significant step beyond DeepSeek-OCR. Released in late June 2026 with rapid community adoption, it supports single-image inference in two modes ("gundam" for cropped high-resolution and "base" for full-page), as well as multi-page and PDF document parsing. The model is deployable via HuggingFace Transformers, vLLM, and SGLang backends, with Docker images provided for CUDA 12.9 and 13.0 environments, making it highly flexible for production use. It features an OpenAI-compatible streaming API, batch inference scripts, and n-gram repetition suppression for cleaner outputs. The project has gained rapid traction on GitHub Trending, is available on Baidu Cloud, Hugging Face Spaces, and ModelScope, and supports training via ms-swift. Its notable momentum—community integrations within days of launch, a published arXiv paper, and backing from a major tech company—makes it a strong trending candidate. It builds on PaddleOCR and DeepSeek-OCR lineage, representing Baidu's push into state-of-the-art multimodal document understanding.
ModelsServingAppsmultimodalvisionlocal-first
★ 19,382 total+4,696 this week
#12
AI Engineering from Scratch is a free, open-source (MIT-licensed) educational curriculum created by Rohit Ghumare that teaches learners how to build AI systems end-to-end by hand, rather than merely calling APIs. The project is substantial in scope: it comprises 503 lessons organized into 20 sequential phases, representing roughly 320 hours of study, with implementations spanning four programming languages — Python, TypeScript, Rust, and Julia. The curriculum's core thesis addresses a stated gap: while 84% of students already use AI tools, only 18% feel prepared to use them professionally. It aims to close that gap by teaching not just usage but underlying construction. The pedagogical philosophy is that most AI material is fragmented — scattered papers, fine-tuning posts, and flashy demos that never line up — so this curriculum acts as a coherent "spine," building every algorithm from raw math first (backpropagation, tokenizers, attention, agent loops) before introducing production frameworks like PyTorch or scikit-learn. Each lesson follows a consistent six-beat loop: MOTTO (core idea), PROBLEM (concrete pain), CONCEPT (diagrams and intuition), BUILD IT (raw math, no frameworks), USE IT (the same thing in a production library), and SHIP IT (a reusable artifact). The distinctive "Build It / Use It" split ensures learners understand what frameworks do because they first wrote a smaller version themselves.
The curriculum's phases stack from mathematical foundations up to autonomous systems. Phase 0 covers setup and tooling; Phase 1 math foundations; Phase 2 ML fundamentals; Phase 3 deep learning core; Phases 4–6 vision, NLP, and speech/audio; Phase 7 transformers; Phase 8 generative AI; Phase 9 reinforcement learning; Phase 10 LLMs from scratch; Phase 11 LLM engineering; Phase 12 multimodal; Phase 13 tools and protocols; Phase 14 agent engineering; Phase 15 autonomous systems; Phase 16 multi-agent systems and swarms; Phase 17 infrastructure and production; Phase 18 ethics and alignment; and Phase 19 capstone projects. Regarding the "agents" query, agents are a central pillar of the upper curriculum: learners build the agent loop by hand (Phase 14, lesson 1 ships ~120 lines of pure Python with no dependencies), progress to autonomous systems (Phase 15) and multi-agent swarms (Phase 16), and build MCP servers end-to-end in Phase 13. The creator also authored Agent Memory, described as the #1 persistent memory tool that works with any agents or chat assistants.
A defining feature is that every lesson ships a reusable artifact — a prompt, a skill, an agent, or an MCP server — so learners finish with a portfolio of 503 practical tools they genuinely understand. Prompts can be pasted into any AI assistant, skills drop into Claude, Cursor, Codex, OpenClaw, Hermes, or any agent reading SKILL.md, agents deploy as autonomous workers, and MCP servers plug into any MCP-compatible client. There are three onboarding paths: reading lessons on the website, cloning and running the repository directly, or using the recommended built-in agent skills. Two named skills stand out: `/find-your-level`, a ten-question placement quiz that maps knowledge to a starting phase with hour estimates, and `/check-understanding <phase>`, an eight-question per-phase quiz with feedback. The entire course also compiles into a six-volume book series (Foundations, Deep Learning, Language, Large Language Models, Agents, and Production), with EPUB and PDF editions built by CI from the same lesson sources and attached to every GitHub release. Each lesson lives in its own folder with code, docs, and outputs subdirectories.
In terms of maturity and trending significance, the project shows strong traction: statistics cite 150,639 read
TrainingAgentsMCPmultimodalcodingsynthetic-data
★ 43,878 total+4,017 this week
#13
Ponytail is an AI agent skill/plugin that teaches coding agents to write dramatically less code by following a strict "laziness ladder" before generating any solution. The core idea is simple: before writing code, the agent checks whether the thing needs to exist at all (YAGNI), whether it already exists in the codebase, whether the standard library handles it, whether a native platform feature covers it, whether an installed dependency does it, whether it can be done in one line, and only then writes the minimum that works. The canonical example is replacing a full flatpickr date-picker component with a single `<input type="date">` HTML element. The project is benchmarked rigorously against real agentic workloads: a headless Claude Code session editing tiangolo's full-stack-fastapi-template (a FastAPI + React open-source repo), running twelve feature tickets with and without the skill, four runs each, using Claude Haiku 4.5. Results show ponytail reduces lines of code by ~54% on average (up to 94% on over-built tasks), cuts token usage by ~22%, lowers cost by ~20%, and speeds up sessions by ~27%, all while maintaining 100% safety — never dropping validation, error handling, security, or accessibility guards. Competing approaches like a terse "caveman" prose control or a "YAGNI + one-liners" prompt either fail on safety or don't cut every metric simultaneously. The project is notably mature in its multi-platform support, integrating with at least 20 agents including Claude Code, Codex, GitHub Copilot CLI, OpenCode, Gemini CLI, Antigravity CLI (Google's renamed Gemini CLI), Pi agent harness, Qoder, Hermes Agent, CodeWhale, and Swival. Installation is typically two plugin commands or a JSON config entry. The plugin injects its ruleset on every prompt turn via lifecycle hooks and registers slash commands like `/ponytail`, `/ponytail-review`, `/ponytail-audit`, `/ponytail-debt`, `/ponytail-gain`, and `/ponytail-help`. It is available on npm as `@dietrichgebert/ponytail` and is MIT-licensed. The project is trending on Trendshift both daily and weekly, suggesting rapid community uptake. Its honest, self-correcting benchmark methodology — acknowledging earlier inflated single-shot numbers and replacing them with a fairer agentic baseline — adds credibility. Ponytail is notable because it addresses a real and growing pain point: AI agents that over-
ToolsAgentsTrainingcodingworkflow-automation
★ 89,931 total+3,747 this week
#14NEWPartial week
AOS Community Edition is an open agent operating system developed by Unicity, designed to provide an inspectable and composable environment for running AI agents and agent-native software. It encompasses the `aos` CLI, HTTP API, distributions, first-party capsules, provider/model experience, and Unicity Audit. The system installs 21 Community Edition capsules under a product-owned `~/.aos` root, with every release publishing checksums, Sigstore bundles, GitHub build-provenance attestations, and a `runtime-compatibility.toml` for pinned runtime versioning. AOS enforces strict upgrade and self-heal gates before any tagged release can publish. A key feature is `aos mcp serve`, which acts as a product edge compatible with Codex, Claude, and Grok via the Model Context Protocol, with explicit interaction policies and a constrained local approval surface. The system ships Forge as OS construction tooling, enabling agents to inspect the running system, identify capability gaps, and build least-privilege capsules autonomously. Signed release channels (stable, dev, nightly) are supported, and state can be imported from standalone runtime installations. The project appears early-stage but architecturally sophisticated, notable for its security-conscious design and agent-native OS abstraction.
AgentsMCPSafetylocal-firstsecurityworkflow-automation
★ 7,419 total+3,651 this week
#15NEWPartial week
**img2threejs** is an AI-driven pipeline that reconstructs any reference image of an object into a fully procedural, animation-ready Three.js model expressed entirely as TypeScript/JavaScript code — no mesh files, no photogrammetry, no downloaded art packs. Given a single reference image, the system produces a `THREE.Group` factory built from geometric primitives, procedural shaders, and generated geometry, complete with a runtime hierarchy of pivots, sockets, colliders, and destruction groups so the output is immediately usable in interactive 3D applications. The project is agent-agnostic and runs under Claude Code, Codex, or OpenCode, leveraging whatever vision capability the host agent provides.
The core approach is a **staged sculpting pipeline** gated at every step by agent vision review. Passes proceed in a fixed order — blockout → structural → form-refinement → material → surface → lighting → interaction → optimization — and no pass advances without a real browser render, a side-by-side comparison sheet, and a vision score at or above threshold. A strict-quality gate blocks code generation until a detailed `ObjectSculptSpec` is complete, preventing shallow or single-root specs for compound objects. Self-correction is built in: after each pass the agent selects one of five actions (`continue`, `refine-spec`, `refine-code`, `request-input`, or `stop`), enabling autonomous iteration toward likeness.
Key features include a **detail inventory** system that enumerates identity-defining small details (bevels, panel seams, fasteners, engraved linework, gloss/matte zones, wear) before any code is written; a **character and likeness track** that fits parametric templates to facial landmarks, de-lights photos, and camera-matches renders; and **CS2 weapon-specific review gates** with component-coverage contracts, exactness tiers, and map-stripped blockout checks to prevent texture from substituting for real geometry. Materials use independent PBR channels with real lights rather than aliasing albedo into roughness.
The live demo gallery showcases reconstructions of CS2 weapons (Glock-18 Ghost Protocol, Classic Knife Fade, M9 Bayonet Doppler Phase 2), hard-surface objects (BMX bike, Sony WF-1000XM3 earbuds, ISSACA shotgun, Gerber Paracord Knife, War-Hauler), and dioramas (Doraemon House), all running live in the browser. Tooling requires only Python 3.10+ stdlib. At version 1.4.1
AgentsAppsToolsmultimodalvisioncoding
★ 6,012 total+3,482 this week
#16
Voicebox is a free, open-source, local-first AI voice studio created by Jamie Pine that positions itself as a unified alternative to both ElevenLabs (voice output) and WisprFlow (voice input), combining the full voice I/O stack into a single desktop application that runs entirely on the user's machine. The project's core philosophy is complete privacy — no voice data, model weights, or audio captures ever leave the local device, making it a compelling option for privacy-conscious developers, creators, and AI power users. At its heart, Voicebox supports seven distinct TTS engines — Qwen3-TTS, Qwen CustomVoice, LuxTTS, Chatterbox Multilingual, Chatterbox Turbo, HumeAI TADA, and Kokoro — each with different strengths in terms of language coverage, speed, expressiveness, and VRAM requirements, switchable per generation. Voice cloning is zero-shot, requiring only a short reference audio sample, and the app also ships with over 50 curated preset voices across Kokoro and Qwen CustomVoice for users who don't have reference audio. The platform supports 23 languages spanning English, Arabic, Japanese, Hindi, Swahili, and many more, with Chatterbox Multilingual offering the broadest coverage. Expressive speech is supported through paralinguistic tags like `[laugh]`, `[sigh]`, and `[gasp]` via Chatterbox Turbo, while Qwen CustomVoice enables natural-language delivery control such as "speak slowly" or "whisper." Post-processing is handled by eight audio effects powered by Spotify's Pedalboard library, including pitch shift, reverb, delay, chorus, compression, and filters, with built-in and custom presets assignable per voice profile. A Stories Editor provides a multi-track timeline for producing conversations, podcasts, and narratives with drag-and-drop composition, inline trimming, and synchronized playback. On the input side, Voicebox offers global dictation via a configurable hotkey with push-to-talk and toggle modes, accessibility-verified auto-paste on macOS, and optional LLM-based cleanup of transcripts using a bundled local language model. Transcription is powered by OpenAI Whisper, running on MLX for Apple Silicon or PyTorch for CUDA, ROCm, and DirectML backends. A standout feature is agent voice integration: any MCP-aware AI agent such as Claude Code, Cursor, or Cline can invoke a single tool call (`voicebox.speak`) to speak back to the user in a cloned voice, with support for voice personas and LLM-driven compose, rewrite, and respond modes over MCP. The app is built with Tauri (Rust) rather than Electron for native performance, and runs on macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, and Docker. It exposes a REST API and
AppsMCPModelsaudiolocal-firstmultimodal
★ 46,944 total+3,417 this week
#17
OpenCodeReview (OCR) is an AI-powered code review CLI tool open-sourced by Alibaba Group after two years of internal use serving tens of thousands of developers and identifying millions of defects. It reads Git diffs and sends changed files to a configurable LLM via an agent with tool-use capabilities, generating structured review comments with line-level precision. Its core design philosophy is a hybrid of deterministic engineering and agent-based dynamic decision-making: engineering logic enforces hard constraints like precise file selection, smart file bundling, and fine-grained rule matching, while the agent handles dynamic context retrieval and scenario-tuned prompting. Compared to general-purpose agents like Claude Code, OCR achieves significantly higher precision and F1 scores using only ~1/9 of the tokens, as validated on a benchmark of 50 open-source repos, 200 real PRs, and 1,505 annotated issues across 10 languages. It supports a "Delegation Mode" where coding agents like Claude Code, Codex, or Cursor perform the review using their own LLMs without requiring OCR API key configuration. Additional features include full-file scanning via `ocr scan`, CI/CD integrations (GitHub Actions, GitLab CI, Gerrit), MCP server support, OpenTelemetry observability, and session replay. Installable via npm, the project holds OpenSSF Silver badge status and is actively trending on Trendshift, making it notable for teams seeking precise, cost-efficient, production-validated AI code review.
ToolsAgentsEvalscodingsecurityworkflow-automation
★ 14,049 total+3,345 this week
#18
AI Job Search is an open-source, locally-run job application automation framework built on top of Anthropic's Claude Code CLI, created by Mads Lorentzen, a geophysicist-turned-AI-engineer who used the exact same system to conduct his own job search after being laid off in late 2025. The project is notably grounded in real-world validation: 69 tailored applications, 20 first interviews, and one signed contract resulted in Lorentzen starting as an AI engineer in June 2026, giving the framework a credibility that purely theoretical tools lack. The core idea is to fork the repository, populate a personal profile, and then let Claude Code handle the heavy lifting of evaluating job postings, tailoring CVs, writing cover letters, and preparing for interviews — all running locally on the user's machine without cloud dependencies beyond the Claude Code CLI itself. The workflow is organized around three primary commands: `/scrape` searches multiple job portals and deduplicates results sorted by fit, `/apply` takes a job URL or pasted description and runs a full drafter-reviewer pipeline producing LaTeX-compiled CVs and cover letters, and `/setup` builds the user's profile from uploaded documents, a pasted CV, or a guided interview. A second-agent reviewer critiques drafts before final output, encoding career guidance best practices such as structured fit evaluation across five dimensions, forward-looking cover letter framing, and optional salary benchmarking. The framework is language- and country-agnostic in its core logic, though its job portal search skills are currently built for the Danish market, covering platforms like Jobindex, Jobnet, Akademikernes Jobbank, JobDanmark, LinkedIn, and FreeHire, with a clear extension pattern for adding portals in other markets via the `/add-portal` command. Beyond the core trio, ten additional commands extend the system: `/interview` builds stage-specific prep packs with STAR-mapped questions and mock interview roleplay; `/outcome` tracks application results, archives submitted materials, and drafts follow-up messages; `/rank` batch-scores scraped postings in parallel before committing to full applications; `/expand` enriches profiles by scanning linked public sources like GitHub, Kaggle, and Google Scholar; `/upskill` performs gap analysis between the user's profile and target postings with web-searched learning resources; `/html-report` generates a fully offline, self-contained HTML dashboard with funnel charts and application tables; `/notion-sync` publishes a live read-only pipeline view to Notion via MCP; `/gmail-sync` reads Gmail for application status signals and proposes tracker updates for user approval; and `/add-template` registers custom CV or cover letter templates in LaTeX or Typst. Security is addressed explicitly: job postings are treated as untrusted input, the workflow follows no embedded instructions from postings, and a dedicated SECURITY.md file outlines the agentic defense model while acknowledging it is instruction-level rather than a full sandbox. Prerequisites include Python 3.10+, Bun for the CLI search tools, and a LaTeX distribution supporting lualatex and xelatex, with optional poppler for ATS parseability checks. The project is actively trending on Trendshift, has CI badges indicating maintained quality, and explicitly disclaims any affiliation with Anthropic or any cryptocurrency scheme, signaling a community-first, transparent
AppsAgentsToolslocal-firstworkflow-automationsynthetic-data
★ 27,348 total+3,237 this week
#19
OpenSEO is an open-source, pay-as-you-go alternative to expensive SEO platforms like Semrush and Ahrefs, designed for individuals and AI agents. It covers core SEO workflows including keyword research, rank tracking, competitor insights, backlink analysis, site audits, and AI visibility monitoring. A standout feature is its MCP (Model Context Protocol) server, which allows AI agents such as Claude Code, OpenClaw, and Hermes to directly consume SEO data through reusable "Agent Skills" — making it notably AI-native. Rather than bundling data costs into a subscription, OpenSEO uses a bring-your-own-key model via the DataForSEO API, so users pay only for what they use. Self-hosting is supported via Docker (for personal use) or Cloudflare (for team/internet-facing deployments). A hosted version is available at openseo.so for $10/month, with the project monetizing through a 28% markup on DataForSEO requests. The project is early-stage but actively developed, with community channels on Discord and X. Its combination of open-source flexibility, AI-agent integration, and cost transparency makes it a notable trend in the intersection of SEO tooling and agentic AI workflows.
MCPToolsAppsworkflow-automationlocal-first
★ 8,292 total+3,183 this week
#20
Colibrì (JustVugg/colibri) is a lightweight, pure-C inference engine designed to run GLM-5.2, a massive 744-billion-parameter Mixture-of-Experts (MoE) language model, on consumer hardware with as little as ~25 GB of RAM — no GPU required, no Python runtime, zero external dependencies. The core insight is that MoE models only activate roughly 40B parameters per token, meaning the model doesn't need to fit in fast memory but instead needs to be intelligently *placed* across a three-tier storage hierarchy: VRAM, RAM, and NVMe disk. The dense components (~17B params, ~9.9 GB at int4) stay resident in RAM, while the 19,456 routed experts (~370 GB total) are streamed on demand from disk using a per-layer LRU cache, a learned hot-store, and optional VRAM pinning. The engine is described as "a JIT, but for weights" — it learns which experts your workload routes to, pins the hottest ones automatically, and literally gets faster the more you use it via a persistent usage file. Key engineering features include router-lookahead prefetching (routing is 71.6% predictable one layer ahead), async I/O with batch-union deduplication, dual-SSD mirroring for doubled read bandwidth, O_DIRECT support, and a NUMA-aware multi-socket mode. Speculative decoding via GLM-5.2's native MTP head achieves 2.2–2.8 tokens per forward pass, with hard-won defaults around int8 draft heads and kernel consistency. The forward pass is validated token-exact against a Hugging Face Transformers oracle. A rich web dashboard visualizes live token metrics, per-tier expert residency, and a stunning "Brain" page showing all 19,456 experts as a living cortex with routing heat and topic affinity. Performance ranges from 0.05 tok/s on a 25 GB dev box to 5.8–6.8 tok/s on six RTX 5090s with full expert residency. The project supports Linux, macOS, and Windows, with an experimental Metal backend for Apple Silicon. It is notably early-stage but already versioned at v1.1.0,
ServingModelsAppslocal-firston-device
★ 19,706 total+3,158 this week
#21
**Skills for Design Engineers** is a curated collection of AI agent "skills" created by Emil Kowalski, a design engineer with experience at Vercel and Linear, aimed at helping developers and designers build higher-quality user interfaces — particularly around animations and motion design. The core premise is that AI agents lack aesthetic taste and frequently make subtle but impactful mistakes, such as using the wrong easing curves or poor visual choices like solid borders instead of semi-transparent shadows. The skills act as structured rule sets that guide AI agents toward better decisions, effectively encoding years of domain expertise into reusable prompts or instructions. Installation is straightforward via `npx skills@latest add emilkowalski/skills`. The skill set covers animation review, animation improvement auditing, finding animation opportunities, animation vocabulary, Apple design principles translated for the web, and UI library selection. The project is notable for its timely positioning at the intersection of AI-assisted development and design craft, arguing that human expertise amplifies rather than gets replaced by AI. It is relatively early-stage but gaining traction, likely trending due to growing interest in "taste-driven" AI tooling and the broader agentic development ecosystem.
ToolsAppsworkflow-automation
★ 21,152 total+2,838 this week
#22
Agent Reach is a Python-based (3.10+) agent infrastructure layer that gives AI agents one-click internet access across 15+ major platforms including YouTube, Twitter/X, Reddit, Bilibili, Xiaohongshu (Little Red Book), LinkedIn, Facebook, Instagram, GitHub, V2EX, Xueqiu, and RSS feeds. Rather than being a tool itself, it acts as a capability routing layer that selects, installs, health-checks, and routes between the best available backend for each platform — abstracting away the pain of API paywalls, login requirements, anti-scraping blocks, and dirty HTML. Installation is triggered by a single natural-language prompt to any compatible agent (Claude Code, OpenClaw, Cursor, Windsurf, etc.), which then auto-installs CLI tools, system dependencies, MCP search integration via Exa, and registers a SKILL.md guide so agents autonomously know which upstream tool to invoke. The architecture uses an ordered primary+fallback backend list per channel (e.g., Bilibili switched from yt-dlp to bili-cli after B-site rate-limiting in June 2026), making platform changes transparent to users. A built-in `agent-reach doctor` command diagnoses which channels are live and which need fixing. Security is emphasized: cookies/tokens are stored locally with 600 permissions, never uploaded, with safe-mode and dry-run install options. The project is actively maintained by a solo developer, has reached Trendshift GitHub Trending #1 Repository of the Day, and is fully MIT-licensed and free, with optional ~$1/month proxy only needed for server deployments. It targets the rapidly growing agent-infrastructure niche, making it notably relevant as AI agents increasingly need reliable, maintained internet access pipelines.
ToolsMCPAgentsbrowser-useworkflow-automationsecurity
★ 61,066 total+2,725 this week
#23
jcode is a terminal-based AI coding harness (agent CLI) developed by 1jehuang, positioning itself as the most RAM-efficient and most intelligent harness available for AI-assisted software development. The project is cross-platform, supporting Linux, macOS, and Windows, and is installable via a single curl or PowerShell command. It is currently in active development, with versioned releases tracked on GitHub and a community Discord server for users and contributors.
The central value proposition of jcode is extreme resource efficiency, particularly in RAM consumption and startup speed, which the project argues is critical for scaling multi-session agentic workflows. The README presents detailed benchmark tables comparing jcode against a wide field of competing AI coding tools: pi, Codex CLI, OpenCode, GitHub Copilot CLI, Cursor Agent, Claude Code, and Antigravity CLI. In a single-session scenario with local embedding disabled, jcode consumes just 27.8 MB PSS — a baseline against which Claude Code uses 13.9× more RAM (386.6 MB) and OpenCode uses 13.4× more (371.5 MB). With local embedding enabled, jcode uses 167.1 MB for one session, still significantly less than most competitors. The efficiency advantage becomes dramatically more pronounced at scale: running 10 concurrent sessions, jcode (embedding off) uses only 117.0 MB, while OpenCode balloons to 3,237.2 MB (27.7× more) and Claude Code reaches 2,300.6 MB (19.7× more). The per-session memory scaling cost for jcode is approximately 9.9–10.4 MB per added session, compared to 318.4 MB for OpenCode and 212.7 MB for Claude Code.
Startup performance is equally emphasized. jcode achieves a time-to-first-frame of just 14.0 ms, making it 245.5× faster than Claude Code (3,436.9 ms) and 139.3× faster than Cursor Agent (1,949.7 ms). Time-to-first-input is 48.7 ms for jcode versus 3,512.8 ms for Claude Code. These benchmarks were measured across 10 interactive PTY launches on a Linux machine, with specific version numbers cited for reproducibility.
A standout architectural feature is jcode's agent memory system. Rather than relying on explicit tool calls or naive context stuffing, jcode embeds each conversation turn as a semantic vector and queries a memory graph using cosine similarity to surface relevant past information automatically. This creates a human-like passive recall mechanism. Memory extraction is triggered by semantic drift, a turn count threshold, or session end, and is handled by a dedicated memory side-agent. A separate ambient mode periodically consolidates memories, resolving conflicts and pruning stale entries. The system also supports explicit memory tools for active search and storage, as well as session search for traditional retrieval-augmented generation (RAG) over prior sessions.
The UI layer is also a notable differentiator. jcode features side panels that can display files in real time, serve as diff viewers, or accept direct agent writes. Both the chat and side panel support inline rendering of Mermaid diagrams, enabled by a custom Mermaid rendering library the author built specifically for this project, reportedly achieving 1,800× rendering improvement. Info widgets and careful attention to scrolling and alignment round out the terminal UI experience.
In terms of maturity, jcode appears to be a serious, actively maintained project in late pre-release or early release stage (version v0.9.1888-dev at time of benchmarking). It has a dedicated website (jcode.sh), documentation, a benchmarks page, and a contributing guide, suggesting it is moving toward a stable public release. The project is MIT-licensed and openly invites community participation.
From a trend analysis perspective, jcode is notable because it enters a rapidly crowding space of AI coding agents — competing directly with well-funded products like GitHub Copilot CLI, Cursor, and Claude Code — but differentiates on a dimension most competitors have neglected: systems-level efficiency. As agentic, multi-session AI workflows become standard in developer tooling, RAM and startup overhead become real operational costs. jcode's approach of treating resource efficiency as a first-class concern, combined with a sophisticated passive memory architecture and
ToolsAgentsAppscodinglocal-firstvector-database
★ 11,707 total+2,693 this week
#24
OfficeCLI is an open-source, self-described "world's first" Office suite purpose-built for AI agents, enabling any AI agent to create, read, modify, and analyze Word, Excel, and PowerPoint documents through a single binary with no Microsoft Office installation or external dependencies required. The project's central value proposition is collapsing what previously required 50+ lines of Python across multiple libraries into a single, expressive CLI command, dramatically lowering the barrier for AI agents to interact with Office file formats. It supports all three major Office formats — `.docx`, `.xlsx`, and `.pptx` — with full read, modify, and create capabilities across the board, making it a comprehensive solution rather than a format-specific tool.
A standout architectural feature is OfficeCLI's built-in HTML rendering engine, which converts Office documents to HTML or PNG with high fidelity. This closes the critical "render → look → fix" feedback loop for AI agents, effectively giving them visual awareness of the documents they are generating or editing. This is particularly significant for agentic workflows where an AI must iteratively refine a document's appearance without human intervention. The live preview server (`officecli watch`) reinforces this loop for human developers as well, refreshing a browser view in real time as commands are applied.
Integration with AI coding agents is a first-class concern. Running `officecli install` automatically detects and injects the OfficeCLI skill into popular AI coding environments including Claude Code, Cursor, Windsurf, and GitHub Copilot, requiring zero additional configuration. For AI agents themselves, a single `curl` command fetches a `SKILL.md` file that teaches the agent how to install the binary and use all commands autonomously. This design philosophy — agent-first, human-optional — is a notable differentiator from traditional Office automation libraries.
The feature set is remarkably deep for what presents as an early-stage open-source project. Word support includes full internationalization and RTL language support with per-script font slots, BCP-47 language tags, complex-script formatting, locale-aware page numbering for Hindi, Arabic, Thai, and CJK scripts, LaTeX equation input, Mermaid diagram rendering to native editable shapes or PNG, tracked changes with accept/reject actions, 22+ field types, content controls, OLE objects, and much more. Excel support covers 350+ built-in formula functions with auto-evaluation, dynamic array spilling, pivot tables with extensive configuration options including calculated fields and persistent filters, box-whisker and Pareto charts, sparklines, slicers, conditional formatting, data validation, CSV/TSV import, and phonetic/furigana cell guides. PowerPoint support includes rich shape manipulation, pattern fills, blur effects, hyperlink tooltips, slide-jump links, and header/footer controls.
The project ships as a single binary available via shell script, Homebrew (`brew install officecli`), npm (`npm install -g @officecli/officecli`), and PowerShell for Windows, making cross-platform deployment straightforward. It is licensed under Apache 2.0, signaling openness to commercial use and community contribution. A companion desktop GUI application, AionUi, is available for users who prefer natural language interaction over direct CLI usage, with OfficeCLI powering the document operations underneath.
The README is multilingual, available in English, Chinese, Japanese, and Korean, suggesting an intentional push toward a global developer and AI-agent ecosystem audience. The project includes a Discord community and a dedicated website at officecli.ai. All showcase documents — presentations, Word reports, and Excel dashboards — were generated entirely by AI agents using OfficeCLI without templates or manual editing, serving as a compelling demonstration of the tool's agentic capabilities.
From a trend analysis perspective, OfficeCLI sits at the intersection of two major currents: the rapid growth of agentic AI systems that need to interact with real-world productivity tools, and the demand for lightweight, dependency-free developer utilities. Its agent-first design, deep Office format support, visual feedback loop, and seamless integration with leading AI coding environments position it as a potentially high-momentum project as autonomous agent workflows become mainstream. The bold "world's first" claim and the breadth of features packed into an early release suggest an ambitious team moving quickly to establish category leadership.
ToolsAgentsAppsworkflow-automationcodingmultimodal
★ 22,440 total+2,682 this week
#25
Taste Skill is an open-source "Anti-Slop Frontend Framework for AI Agents" — a collection of portable Agent Skills designed to upgrade AI-generated user interfaces beyond generic, boilerplate-looking outputs. Rather than accepting mediocre layouts and typography from coding agents, Taste Skill provides structured SKILL.md files that instruct agents like Codex, Cursor, and Claude Code to apply stronger layout variance, refined typography, intentional motion, and deliberate spacing. The framework is organized into two categories: implementation skills that output production code, and image-generation skills that produce design reference boards for web, mobile, and brand identity work. The flagship skill, `design-taste-frontend`, is currently at v2 (experimental) — a substantial rewrite featuring brief inference, design-system mapping, configurable dials for DESIGN_VARIANCE, MOTION_INTENSITY, and VISUAL_DENSITY (each rated 1–10), canonical GSAP animation skeletons, a hard em-dash ban, and a strict pre-flight check. Additional specialized skills cover brutalist UI, minimalist/editorial UI, soft premium aesthetics, redesign auditing of existing codebases, full-output enforcement, and Google Stitch compatibility. Image-generation skills pair with ChatGPT Images or similar generators to produce comps that are then handed off to coding agents. Installation is handled via the `npx skills add` CLI from the vercel-labs/agent-skills ecosystem, making adoption straightforward. The project has notable corporate sponsorship from Novamira, IMG.LY, Vercel, Sent.dm, and Emil Kowalski's animations.dev, signaling real community traction. It is MIT-licensed and actively iterating, positioning itself at the intersection of AI coding agents and high-quality frontend design — a timely and trending niche as AI-generated UI quality becomes a growing concern.
ToolsAppscodingworkflow-automationsynthetic-data
★ 67,989 total+2,675 this week
#26
codebase-memory-mcp (CBM) is a high-performance code intelligence engine designed specifically for AI coding agents, built by DeusData. Its core purpose is to give large language model-driven coding assistants fast, structured access to a codebase without the token-heavy, inefficient practice of file-by-file exploration. The tool full-indexes an average repository in milliseconds and can index the Linux kernel (28 million lines of code across 75,000 files) in about 3 minutes, answering structural queries in under 1 millisecond. It ships as a single static binary with zero runtime dependencies for macOS (arm64/amd64), Linux (arm64/amd64), and Windows (amd64), requiring only a download, an `install` command, and an agent restart. The engine parses code using tree-sitter AST analysis across 158 languages, with vendored grammars compiled directly into the binary. This is further enhanced by a "Hybrid LSP" semantic type resolution layer for 10+ languages including Python, TypeScript/JavaScript/JSX/TSX, PHP, C#, Go, C, C++, Java, Kotlin, Rust, and Perl. The result is a persistent knowledge graph capturing functions, classes, call chains, HTTP routes, and cross-service links. CBM exposes 15 MCP (Model Context Protocol) tools covering search, tracing, architecture analysis, impact analysis, index-coverage checks, Cypher queries, dead code detection, cross-service HTTP linking, and ADR management. It also supports infrastructure-as-code indexing, treating Dockerfiles, Kubernetes manifests, and Kustomize overlays as graph nodes with cross-references. The project emphasizes efficiency, claiming 120x fewer tokens (roughly 3,400 tokens versus 412,000 for file-by-file search across five structural queries). Performance is enabled by a RAM-first pipeline using LZ4 compression, in-memory SQLite, and fused Aho-Corasick pattern matching, with memory released after indexing. The tool integrates with 43 supported automatic/conditional client surfaces; its `install` command auto-detects installed agents and safely configures their MCP entries, instructions, skills, and lifecycle hooks. A notable architectural feature is the Session Coordination Daemon, a single per-account background process shared across clients like Claude Code, Codex, and OpenCode. This daemon owns long-lived services such as file watchers, shared indexing jobs, and an optional UI, coordinating session lifecycle so the first session starts it and the last shuts it down. It enforces strict consistency: all active CBM processes must share the exact same version, build, coordination ABI, and canonical cache root, with an OS-level admission barrier rejecting conflicts and logging them. The native install/update/uninstall commands are a deliberate exception, publishing maintenance intent, cancelling active work, and holding exclusive barriers during binary swaps. A separate lightweight `cli` mode runs single commands locally without starting the daemon. An optional UI build embeds a 3D interactive graph visualization frontend accessible at localhost:9749. Installation is available via one-line curl scripts, PowerShell for Windows, or package managers (npm, PyPI, Go), and an auto-index option indexes new projects on first MCP connection. On maturity and trust, the project appears robust and production-oriented: it advertises 5,604 passing tests, MIT licensing, an OpenSSF Scorecard, SLSA 3 build provenance, signed and checksummed release binaries scanned by 70+ antivirus engines via VirusTotal, and fully local processing so code never leaves the user's machine. The design and benchmarks are documented in a research preprint titled "Codebase-Memory: Tree-Sitter-Based Knowledge Graphs for LLM Code Exploration via MCP" (arXiv:2603.27277), evaluated across 31 real-world repositories with reported 83% answer quality, 10x fewer tokens, and 2.1x fewer tool calls versus file-by-file
MCPToolsRetrievalcodinglocal-firstvector-database
★ 35,667 total+2,654 this week
#27
Herdr is a terminal-native **agent multiplexer** — a single Rust binary that lets developers run, monitor, and manage multiple AI agents simultaneously from the terminal. It provides real-time pane views showing each agent's status (blocked, working, done), supports detach/reattach across sessions and SSH connections, and survives restarts. A standout feature is its pure socket API that allows agents themselves to spawn panes, read output, and coordinate with each other, enabling true multi-agent orchestration. The tool supports both keyboard (tmux-style prefix keys) and mouse interaction, and is extensible via a plugin marketplace. Built entirely in Rust with no Electron dependency, it installs via a single curl command, Homebrew, or mise, with a Windows beta available. The project is actively developed full-time in the open, has documented sponsorship tiers, and includes explicit instructions for AI agents contributing to the repo. Its combination of lightweight design, agent-aware API, and session persistence makes it notable in the growing AI agent tooling space.
AgentsToolsAppscodingworkflow-automationlocal-first
★ 21,110 total+2,654 this week
#28
Grok Build (`grok`) is SpaceXAI's terminal-based AI coding agent, written in Rust and released as open source under the Apache 2.0 license. It provides a full-screen TUI (terminal user interface) capable of understanding codebases, editing files, executing shell commands, searching the web, and managing long-running tasks. It supports interactive use, headless/scripting/CI modes, and editor integration via the Agent Client Protocol (ACP). Prebuilt binaries are available for macOS, Linux, and Windows via simple install scripts, and the source can be built with Rust and DotSlash tooling. The repository is periodically synced from SpaceXAI's internal monorepo, with a `SOURCE_REV` file tracking the upstream commit. The codebase is modular, spanning crates for the TUI, agent runtime, tool implementations, workspace management, MCP, sandboxing, and more. Notably, external contributions are not accepted. Its trending appeal likely stems from being the official open-source CLI agent from xAI (Elon Musk's AI company), competing in the rapidly growing AI coding agent space alongside tools like Codex and OpenCode, and representing a significant infrastructure release from a high-profile AI organization.
AgentsAppsMCPcodinglocal-firstworkflow-automation
★ 22,811 total+2,543 this week
#29
Vibe-Trading, developed by HKUDS (The University of Hong Kong Data Intelligence Lab), is an open-source personal trading agent designed to empower AI agents with comprehensive trading capabilities through a single command. Distributed as the PyPI package `vibe-trading-ai`, the project targets Python 3.11+ and combines a FastAPI backend with a React 19 frontend, licensed under MIT. Its core value proposition is enabling users to equip an AI agent with end-to-end trading functionality spanning market data ingestion, backtesting, strategy optimization, and live/simulated trade execution across many brokers and asset classes. The repository emphasizes both breadth of integrations and correctness/reliability, as reflected by an intense stream of contributor-driven updates.
Key features include support for numerous LLM providers—native Anthropic Messages API, SiliconFlow, iFlytek Spark, MiniMax, and zai (glm-5.1)—alongside a provider-agnostic `llm-vision` OCR engine for interpreting visual data. The platform offers a robust backtesting engine with composable optimizer weight constraints, rebalance-notes artifacts, turnover metrics, and an `alpha bench` benchmarking tool that discloses index universes (CSI300/SP500), counts, degraded fallbacks, and survivorship bias, plus a strict `alpha bench --strict` mode wiring same-universe random-control and out-of-sample gates. It supports realistic USD-M perpetual futures with margin state contracts and historical funding-rate consumption, and Binance maintenance-bracket decoupling so `-PERP` backtests run credential-free. A "Shadow Account" feature and point-in-time (PIT) fundamentals with restatement deduplication add trading realism. The system integrates an MCP (Model Context Protocol) server for agent interoperability, with a swarm MCP-discovery cache and network guards supporting IPv6 and case-variant hosts.
Broker and data-source coverage is extensive, having grown to 12 broker connectors including a new MetaTrader 5 (Exness) forex/metal connector, plus Tiger, Alpaca, OKX, Shoonya, Longbridge, Binance, Futu, Tonghuashun, and Eastmoney. Data loaders have undergone a major interval-normalization sweep so timeframe aliases (1h/4h/1d/1w, 1W/1M) behave consistently across providers like Yahoo, CCXT, akshare, and India brokers, failing fast on unsupported intervals rather than silently returning daily bars. A persistent memory subsystem gained Tier 2 structural organization and an opt-in memory lifecycle featuring quality scoring, Ebbinghaus decay, and archive-only garbage collection (disabled by default). A correlation regime timeline endpoint (`GET /correlation/regime`) provides descriptive risk context via a causal hysteresis state machine marking "FUSED" market episodes. The project also exposes REST API and MCP interfaces, and provides multilingual documentation (English, Chinese, Japanese, Korean, and Arabic) plus a website and docs portal.
In terms of maturity, Vibe-Trading is actively and rapidly evolving, with a very high cadence of pull requests—daily batches often fixing 12–22 issues at once, addressing strict-JSON/finite-number serialization, connector correctness, trade-journal parsing (Excel serial dates), and reliability across SSE, sessions, CLI, swarm, and scheduler components. Recent releases (v0.1.11, v0.1.12) rolled up roughly 90 fixes, indicating a project still in the 0.1.x pre-1.0 phase but with substantial functional depth and a large, engaged contributor community (numerous named contributors credited in changelogs). Infrastructure improvements include Docker hash-locked dependency installs with CI lock checks and Dependabot-style dependency refreshes. The project maintains an active community presence via Discord, Feishu, and WeChat
AgentsToolsMCPmultimodalworkflow-automationvision
★ 27,879 total+2,510 this week
#30
ECC (also known as ECC Tools) is a harness-native operator system designed for agentic AI development workflows. Positioned as "the agent harness operating system," it provides a comprehensive, production-ready layer of skills, instincts, memory optimization, continuous learning mechanisms, security scanning, and research-first development practices. Rather than being a simple configuration repository, ECC is a full system evolved over more than ten months of intensive daily use building real products across multiple AI agent harnesses. The project is notable for its cross-harness compatibility, supporting Codex, Claude Code, Cursor, OpenCode, Gemini, Zed, GitHub Copilot, and other AI agent environments from a single unified codebase.
The project has achieved remarkable community traction, boasting over 211,900 stars, 32,500 forks, and 230 or more contributors on GitHub. It supports 12 or more language ecosystems and is implemented across Shell, TypeScript, Python, Go, Java, Perl, and Markdown. The npm packages ecc-universal and ecc-agentshield both receive regular weekly downloads, and the GitHub App has accumulated a significant number of installs. The project is MIT-licensed and explicitly commits to remaining open-source forever, with ECC Pro serving as the hosted GitHub App tier for private repositories priced at $19 per seat per month, funding continued development by what appears to be primarily a single maintainer shipping weekly across seven harnesses.
ECC v2.0.0 represents a significant milestone, introducing the public Hermes operator story built on top of a reusable cross-harness architecture layer. The Hermes operator concept appears to be a named persona or workflow pattern that users can adopt as a starting point for agentic operations. The release is accompanied by dedicated documentation including a Hermes setup guide, 2.0.0 release notes, and a cross-harness architecture document, signaling a maturing project with structured versioning and documentation practices.
The project is organized around three primary guides: The Shorthand Guide covering setup, foundations, and philosophy; The Longform Guide covering token optimization, memory persistence, evaluations, and parallelization; and The Security Guide covering attack vectors, sandboxing, sanitization, CVEs, and the AgentShield security tooling. These guides are described as separate from the raw code in the repository, suggesting a deliberate separation between implementation and educational content. Key technical topics addressed include token optimization through model selection and system prompt slimming, memory persistence via hooks that save and load context across sessions automatically, continuous learning through auto-extraction of patterns from sessions into reusable skills, verification loops using checkpoint and continuous evaluations with grader types and pass-at-k metrics, parallelization using Git worktrees and a cascade method, and subagent orchestration addressing the context problem through iterative retrieval patterns.
A notable integration path involves self-hosting the Kimi model from Moonshot AI using ECC alongside Itô Markets compute infrastructure. ECC configures the agent harness while users supply their own API endpoint or self-host an open-weight Kimi model on GPU capacity. The installation flow involves running the ECC installer targeting the Kimi harness, running a doctor check, and then launching the Kimi CLI, which natively discovers installed AGENTS.md instructions and skills workflows. The project explicitly clarifies that the Itô sponsorship link is passive and does not provision compute, while the ecc ito find command actively invokes the Itô CLI to submit a live authenticated request for quotation.
Security is treated as a first-class concern. The AgentShield npm package is a dedicated security layer, and the Security Guide covers attack vectors, sandboxing, sanitization, and CVEs relevant to agentic systems. The project warns users to install only from verified official channels including the GitHub repository, the two npm packages, the GitHub App, the plugin slug, and the project website, explicitly cautioning that third-party re-uploads and unofficial mirrors may contain malware.
The project has attracted notable sponsors including CodeRabbit, Greptile, Atlas Cloud, Moonshot AI (Kimi), and Itô Markets, alongside community sponsors. This sponsorship structure, combined with the Pro tier pricing model, suggests a sustainable open-source business model that is increasingly common among high-traction developer tooling projects. The README is available in twelve languages including English, Brazilian Portuguese, Simplified Chinese, Traditional Chinese, Japanese, Korean, Turkish, Russian, Vietnamese, Thai, German, and Spanish, reflecting a genuinely global contributor and user base.
From a trend analysis perspective, ECC is highly relevant to the rapidly accelerating AI agents space. The project addresses a real and growing pain point: developers using multiple AI coding assistants simultaneously need a unified operator layer that works consistently across harnesses. The cross-harness compatibility story, the emphasis on production-readiness over toy configurations, and the security-first posture all align with where the enterprise and professional developer market is heading as agentic AI moves from experimentation to production deployment. The combination of strong community metrics, active sponsorship, multilingual documentation, and a clear versioning roadmap positions ECC as a potentially foundational piece of infrastructure in the emerging AI agent tooling ecosystem.
AgentsToolsSafetysecurityworkflow-automationcoding
★ 233,728 total+2,426 this week
#31
Caveman is a plugin/skill for AI coding agents that compresses their output into terse, caveman-style speech while preserving 100% of technical content — code, commands, and error messages remain byte-for-byte exact. The core value proposition is a claimed average 65% reduction in output tokens across benchmarks, demonstrated through before/after comparisons showing verbose agent replies stripped down to minimal, information-dense equivalents. It works as a one-command install across 30+ agents including Claude Code, Codex, Gemini CLI, Cursor, Windsurf, Cline, and GitHub Copilot, requiring Node ≥18 and taking roughly 30 seconds to set up. Users can choose from five compression levels — lite, full (default), ultra, and wenyan (classical Chinese for maximum token density) — switchable mid-session via `/caveman <level>`. Beyond basic compression, the toolkit includes commands for conventional commit messages, one-line PR reviews, session token stats with USD cost tracking, memory-file compression (cutting ~46% of input tokens permanently), an MCP middleware wrapper called caveman-shrink, and multi-agent subagents called cavecrew. The project is notably honest about its limitations: the skill itself adds ~1–1.5k input tokens per turn, whole-session savings are smaller than the headline output number, and terse workloads can go net-negative. It cites a March 2026 arXiv paper suggesting brevity constraints actually improved model accuracy by ~26 points on some benchmarks, lending academic credibility to the approach. Caveman sits within a broader ecosystem of five related repos — caveman-code (full agent), cavemem (memory compression), cavekit (spec-driven build loop), and cavegemma (a fine-tuned Gemma model with compression baked into weights) — plus a sibling skills registry. The project appears early-stage but actively maintained, with reproducible benchmarks, multilingual support, and integrations including OpenClaw self-hosted gateway, signaling genuine engineering depth behind the playful branding.
ToolsMCPServingcodingworkflow-automationsynthetic-data
★ 93,262 total+2,360 this week
#32
OpenMontage is an open-source, agentic video production system that transforms any AI coding assistant into a full-featured video production studio. Rather than requiring manual editing, scripting, or asset management, users describe what they want in plain language and an AI agent handles the entire pipeline end-to-end: research, scripting, asset generation, editing, and final composition. The project bills itself as the first open-source system of its kind and notably achieved the #1 Repository of the Day on GitHub Trending, signaling strong community interest and momentum.
A critical distinction the project emphasizes is that OpenMontage produces genuine video — not just animated slideshows of still images. For free and open-source workflows, the agent can build a corpus from free stock footage and open archives, retrieve actual motion clips, edit them into a timeline, and render a finished piece. This sets it apart from many AI video tools that merely animate a handful of stills. It also supports AI-generated motion video via providers like Google Veo and Kling v3, image-based animation with cinematic effects, and fully bespoke "atelier" composition modes where every scene is crafted from scratch.
The system is built around a multi-stage agentic pipeline. When a production starts, the agent performs live web research, writes and narrates a script with voice direction, generates AI images or retrieves motion clips, sources royalty-free background music automatically, burns in word-level subtitles, and renders the final video. Before delivery, it runs a multi-point self-review covering ffprobe validation, frame sampling, audio level analysis, delivery promise verification, and subtitle checks. Every provider selection is scored across seven dimensions with an auditable decision log, and every creative decision can require user approval before proceeding.
A standout feature is the Backlot Living Storyboard — a local visual dashboard that fills itself in as the pipeline runs. Stages light up in real time, the script appears as a screenplay page, scene cards animate while assets generate, and every provider decision and dollar spent is displayed. Crucially, the storyboard functions as a real approval gate: asset generation pauses on a scene-by-scene contact sheet showing takes, prompts, per-asset costs, and quality scores, allowing users to approve visuals before the render begins. Completed productions can be replayed from timestamps, scrubbable end to end.
OpenMontage also supports starting from a reference video — a YouTube video, Short, Reel, TikTok, or local clip. The agent analyzes transcript, pacing, scenes, keyframes, and style, then generates two to three differentiated concepts with honest tool paths, cost estimates, and a sample before full production begins. This grounded approach avoids guesswork and gives users a clear picture of what the final product will look like given their available tools and budget.
The project showcases several demo productions that highlight its range and cost efficiency. A cinematic sci-fi trailer called "SIGNAL FROM TOMORROW" used Veo-generated motion clips and Remotion composition. "THE LAST BANANA," a 60-second Pixar-style animated short, cost just $1.33 using Kling v3 via fal.ai, Google Chirp3-HD narration, and Remotion. "The Library at Alexandria," a 70-second history elegy, cost only $0.02 using OpenAI narration and a free Pixabay music score. A product ad called "VOID — Neural Interface" cost $0.69 using a single OpenAI API key with gpt-image-1 images, WhisperX subtitles, and Remotion. Two Ghibli-style anime animations — "Afternoon in Candyland" and "Mori no Seishin" — each cost $0.15 using FLUX-generated images with parallax effects and particle overlays.
Technically, OpenMontage requires Python 3.10+, FFmpeg, Node.js 18+, and any AI coding assistant such as Claude Code, Cursor, Copilot, Windsurf, or Codex. Setup is straightforward via a single make setup command. The project is licensed under AGPLv3 and is sponsored by Bloome, a multi-agent collaboration platform, and Atlas Cloud, a unified AI inference platform offering access to 300+ models. The project is actively developed and documented, with a YouTube channel, an X account, GitHub Discussions, a providers guide, a PR review guide, and a dedicated Agent Guide. Its combination of genuine agentic autonomy, transparent cost tracking, real motion video support, and an interactive
AgentsAppsToolsmultimodalvideoworkflow-automation
★ 42,503 total+2,290 this week
#33
**CAD Skills** (`earthtojake/text-to-cad`) is an open-source Python library (Python 3.11+, MIT license) that provides a modular collection of agent-callable skills for generating, inspecting, sourcing, slicing, and handing off CAD and robot-description artifacts using plain-language or image prompts. The core CAD skill produces geometry in STEP format with additional export options including STL, 3MF, and GLB — making it directly relevant to 3MF-based workflows for 3D printing and fabrication pipelines. Complementary skills cover URDF/SRDF/SDF robot description files for simulation and MoveIt2 planning, DXF 2D drawings, G-code slicing via real slicer CLIs, off-the-shelf STEP part sourcing via step.parts, SendCutSend preflight checks, Bambu Labs printer integration, and an experimental implicit CAD skill using GLSL signed-distance fields. Installation is handled through a Skills CLI (`npx skills install`), with native plugin support for OpenAI Codex and Anthropic Claude Code. The repo includes a structured benchmark suite of ten progressively complex CAD targets — from calibration blocks and flanges to planetary gear stages and spiral staircases — stored via Git LFS. The project is actively developed, community-driven (Discord), and notable for bridging LLM-based agents with real fabrication toolchains end-to-end, spanning design, simulation, slicing, and physical printing in a single skill ecosystem.
ToolsAppsMCPmultimodalcodingworkflow-automation
★ 10,626 total+2,218 this week
#34
Headroom is an open-source context compression layer designed specifically for AI agents and LLM-powered applications. Its core purpose is to dramatically reduce the number of tokens consumed by agents when processing tool outputs, logs, RAG chunks, files, and conversation history — before any of that content ever reaches the language model. The project claims 60–95% token reduction for JSON data and 15–20% reduction for coding agent workflows, while preserving answer accuracy as validated on standard benchmarks including GSM8K, TruthfulQA, SQuAD v2, and BFCL. On real agent workloads, demonstrated savings range from 47% on codebase exploration up to 92% on code search and SRE incident debugging tasks.
Headroom offers four primary integration modes. First, a Python and TypeScript library allowing inline `compress(messages)` calls. Second, a drop-in proxy (`headroom proxy --port 8787`) requiring zero code changes in any language. Third, an agent-wrap CLI command that wraps popular coding agents like Claude Code, Codex, Cursor, Grok, Copilot, Aider, Cline, Continue, Goose, OpenHands, and others in a single command, with a corresponding `unwrap` to undo. Fourth, an MCP server exposing `headroom_compress`, `headroom_retrieve`, and `headroom_stats` tools for any MCP-compatible client.
The internal architecture routes content through a ContentRouter that detects content type and selects the appropriate compressor: SmartCrusher for JSON, CodeCompressor for AST-based code, and Kompress-v2-base (a custom Hugging Face model) for prose and general text. A CacheAligner stabilizes prompt prefixes to maximize provider-side KV cache hit rates. The system also implements CCR (Compressed Context with Retrieval), a reversible compression scheme that caches original content locally so the LLM can call `headroom_retrieve` on demand — meaning compression is lossless in practice, not just approximate.
Beyond input compression, Headroom also targets output token reduction, which is particularly significant since output tokens on Opus-class models cost roughly five times more than input tokens. It does this through verbosity steering (appending terse-response instructions to system prompts without breaking prompt caches) and effort routing (dialing down model thinking effort for routine tool-result turns while preserving full effort for new questions or errors). These features apply to both Anthropic and OpenAI-compatible endpoints and are toggled via `HEADROOM_OUTPUT_SHAPER=1`. A `headroom learn --verbosity` command can automatically infer preferred terseness levels from past sessions.
Cross-agent memory is another notable feature: a shared store that works across Claude, Codex, Gemini, and Grok with automatic deduplication. The `headroom learn` command mines failed sessions and writes corrections to agent-specific memory files such as `CLAUDE.local.md`, `AGENTS.md`, `GEMINI.md`, or `GROK.md`. The project is local-first by design — all compression and memory operations run on the user's machine, with no data leaving to external servers.
The project is available on PyPI as `headroom-ai` and on npm for the TypeScript SDK. It requires Python 3.10+ and supports modular extras including proxy, MCP, ML, code, memory, vector (HNSW), image, LangChain, Agno, Strands, and evaluation tooling. A `headroom doctor` command provides health checks, and a live dashboard shows real-time savings. The project is already trending on Trendshift and carries an Apache 2.0 license. Its combination of aggressive, content-aware, revers
ToolsRetrievalMCPlocal-firstsynthetic-datavector-database
★ 62,638 total+2,216 this week
#35
The `andrej-karpathy-skills` repo provides a single `CLAUDE.md` configuration file designed to improve the behavior of Claude Code (Anthropic's AI coding assistant) by encoding four coding principles inspired by Andrej Karpathy's public observations about LLM coding pitfalls. The four principles are: **Think Before Coding** (surface assumptions and ambiguities rather than silently guessing), **Simplicity First** (write minimum viable code, avoid overengineering), **Surgical Changes** (only touch code directly related to the task), and **Goal-Driven Execution** (define verifiable success criteria so the LLM can loop autonomously). Installation is offered either as a Claude Code plugin (available via a marketplace command) or as a per-project `CLAUDE.md` file via curl. The repo also includes Cursor IDE integration through a committed project rule file. It is notably early-stage but practically useful, riding the wave of interest in prompt engineering and AI coding agent configuration. Its trending appeal stems from Karpathy's influential status in the AI community and the growing demand for structured guidelines to make LLM coding agents more reliable and disciplined.
ToolsAgentscodingworkflow-automation
★ 196,619 total+2,179 this week
#36NEWPartial week
X4G is a fast, modern gateway project for VLESS tunneling over WebSocket and XHTTP protocols, combined with a built-in HTTP Proxy, designed primarily for censorship circumvention and traffic management. Written in Persian, it targets users in Iran and similar regions who need flexible, configurable proxy infrastructure. Key features include a full web management dashboard with hourly traffic charts, live connections, and activity logs; unlimited link management with per-config traffic quotas (KB/MB/GB), bandwidth throttling (Mbps), simultaneous IP limits, and auto-expiry by day. It supports QR code output, configurable uTLS fingerprints (Chrome, Firefox, Safari, etc.), custom ALPN, and arbitrary connection ports. A standout feature is "Sub Groups" — professional public subscription pages grouping multiple configs with optional password protection. An optional Telegram management bot enables full config and sub-group administration via a step-by-step wizard without opening the web panel. Deployment targets Railway.app via GitHub fork, with persistent state stored in JSON on a mounted Volume. The project appears early-stage but feature-rich, likely trending due to growing demand for advanced anti-censorship tooling in Persian-speaking communities.
AppsMCPToolssecurityworkflow-automation
★ 6,821 total+2,082 this week
#37
Open Design is an open-source, agent-native design platform positioned explicitly as an alternative to Anthropic's Claude Design and to Figma for the AI agent era. It is a local-first native desktop application for macOS and Windows that transforms any coding agent CLI already installed on a developer's laptop into a full-featured design engine. Rather than requiring users to push pixels on a canvas, Open Design delivers real, runnable single-page artifacts written in actual CSS, real fonts, and real components, all shaped by a team's `DESIGN.md` brand contract and exported directly to HTML, PDF, PPTX, or MP4. The core philosophical premise is that the agent-native loop Anthropic shipped with Claude Design — discover the brief, lock the direction, stream the artifact, critique, deliver — should be open, composable, and filesystem-readable rather than locked inside a proprietary product.
The architecture is built around three primary distribution mechanisms: a filesystem of composable skills, a CLI (`od`), and an MCP (Model Context Protocol) server. Once Open Design is installed, a single command such as `od mcp install claude` wires the MCP server into a supported agent's configuration, enabling the same design tools to be called from inside any of the 25+ supported coding agent CLIs. Supported agents include Claude Code, OpenAI Codex CLI, Cursor, VS Code with GitHub Copilot, GitHub Copilot CLI, OpenCode, OpenClaw, Antigravity, Cline, Trae, Kimi CLI, Kiro, Pi Agent, Mistral Vibe CLI, Hermes Agent, DeepSeek Reasonix, Raven, and more. This breadth of agent compatibility is a defining feature and a clear signal of the project's ambition to become the universal design layer across the fragmented AI coding agent ecosystem.
The platform is organized around several core pages and concepts. The Home page serves as the entry point where users pick a skill, select a design system, type a brief, and initiate generation. The Automation page allows repetitive design workflows to be orchestrated into reusable, schedulable automations. The Design System page is where teams distill their `DESIGN.md` into a brand contract that shapes every output the agents produce. The Plugin page enables browsing, installing, and distributing workflow plugins to extend generation capabilities on demand. The Integrations page connects external systems and MCP tools, allowing Open Design to be invoked from any IDE, script, or automation pipeline.
Inside any project's Studio, the same design system streams out multiple artifact types. Prototypes are single-page HTML artifacts rendered in a sandboxed iframe, previewable instantly and downloadable as source. HyperFrames are programmatic motion graphics and animated outputs rendered to real MP4 files at resolutions such as 1920×1080 at 30fps. Decks are pitch presentations navigable by keyboard and exportable to PPTX or PDF. Images are brand-grade visual assets with high-resolution generation and download. This multi-artifact approach means a single design system definition can consistently power wildly different output formats without manual reformatting.
For model access, Open Design Cloud is the official managed service, offering 20+ flagship models including GPT, Claude, Gemini, and DeepSeek under a single recharge, billed by real token usage with zero configuration. For users who prefer to bring their own keys, a BYOK proxy endpoint supports OpenAI, Anthropic, Azure OpenAI, Google Gemini, Ollama, LM Studio, vLLM, Atlas Cloud, and any OpenAI-compatible endpoint. Atlas Cloud specifically uses `https://api.atlascloud.ai/v1` with OpenAI-compatible model IDs. Per-target SSRF protection blocks internal IPs, link-local addresses, and CGNAT ranges at the daemon edge, indicating meaningful attention to security in the proxy layer. Runtime definitions live in the daemon source under `apps/daemon/src/runtimes/defs/`, with an adapter contract documented in `docs/agent-adapters.md`.
The project is internationalized across 14 languages including English, Spanish, Portuguese, German, French, Simplified Chinese, Traditional Chinese, Korean, Japanese, Arabic, Russian, Ukrainian, Turkish, and Thai, suggesting a global community target. The README is structured with a product tour, platform compatibility matrix, demo screenshots, and quickstart instructions (described as "3 commands"), indicating a project that is actively maturing and investing in developer experience. The Open Design Fellow program is open for contributors who want to shape the product alongside the core team, with details in `MAINTAINERS.md` and a Discord community. The project is licensed under Apache 2.0, making it genuinely open for commercial and community use. Its combination of broad agent compatibility, open licensing, composable skill architecture, and direct challenge to both Claude Design and Figma makes it a notably ambitious and potentially trending project at the intersection of AI agents, developer tooling, and design automation.
AppsAgentsMCPlocal-firstmultimodalworkflow-automation
★ 81,788 total+2,003 this week
#38
SkillOpt, from Microsoft, is a framework that treats agent skill documents as trainable parameters — optimizing them through a structured loop (rollout → reflect → aggregate → select → update → evaluate) analogous to neural network training, but without modifying any model weights. Instead of hand-crafting or one-shot generating skills, SkillOpt uses a separate optimizer model to apply bounded edits to a single Markdown skill document, accepting changes only when they improve held-out validation scores. Key mechanisms include a textual learning-rate budget, rejected-edit buffers, and epoch-wise meta-updates for stability. The deployed artifact is a compact `best_skill.md` (300–2,000 tokens) that transfers across model scales and harnesses. Evaluated across six benchmarks, seven models, and three harnesses, SkillOpt achieves best or tied-best results on all 52 cells, lifting GPT-5.5 accuracy by up to +24.8 points. Version 0.2.0 adds SkillOpt-Sleep, a nightly offline self-evolution engine, plus integrations for Claude Code, Codex, Copilot, and Devin. The project is actively trending, has received broad media coverage, and is installable via PyPI.
TrainingAgentsToolsworkflow-automationcodingsynthetic-data
★ 15,138 total+1,964 this week
#39
LingBot-Map is a feed-forward 3D foundation model developed by the Robbyant Team for streaming 3D scene reconstruction from video sequences. At its core is the Geometric Context Transformer (GCT), a novel architecture that unifies coordinate grounding, dense geometric cues, and long-range drift correction within a single streaming framework. It achieves this through three key mechanisms: anchor context for coordinate grounding, a pose-reference window for dense geometric cues, and trajectory memory for long-range drift correction. The model is designed for high-efficiency streaming inference, leveraging a paged KV cache attention mechanism — powered by FlashInfer — to achieve stable inference at approximately 20 FPS on 518×378 resolution over sequences exceeding 10,000 frames. LingBot-Map claims state-of-the-art reconstruction performance across a wide range of benchmarks, outperforming both existing streaming methods and iterative optimization-based approaches. The project is evaluated on an impressive breadth of datasets including KITTI, Oxford Spires, VBR, Droid-W, TUM-D, 7-Scenes, ETH3D, Tanks and Temples, and NRGBD, all of which have been released as part of the evaluation benchmark. The repository provides multiple model checkpoints: a balanced general-purpose model used in the paper, a long-sequence-optimized variant, and a stage-1 training checkpoint compatible with the VGGT model for bidirectional inference. Installation is straightforward via conda and pip, with PyTorch 2.8.0 and CUDA 12.8 as the recommended stack. The interactive demo uses a browser-based viser viewer and supports features like sky masking via an ONNX segmentation model, keyframe interval control to manage KV cache memory, windowed inference for very long sequences exceeding 3,000 frames, and video input with configurable FPS. A notable demonstration includes a 25,000-frame, 13-minute indoor walkthrough rendered through an offline batch rendering pipeline using NVIDIA Kaolin. The project is actively maintained, with recent updates including bug fixes for SDPA and FlashInfer KV cache issues, a torch.compile acceleration flag, and ongoing plans to release a stronger model supporting even longer sequences. Models are hosted on both HuggingFace and ModelScope, making them accessible to a broad international audience. The project is licensed under Apache-2.0. Its trending appeal likely stems from the combination of real-time streaming 3D reconstruction capability, long-sequence stability, broad benchmark coverage, and practical usability with interactive demos — addressing a highly competitive and commercially relevant problem space in computer vision and robotics.
ModelsAppsServingmultimodalvideovision
★ 15,592 total+1,890 this week
#40
Codex Dream Skin is an external theming/skinning tool for OpenAI's Codex desktop client that injects custom backgrounds and CSS via local CDP (Chrome DevTools Protocol) without modifying the official app binary or code signature. It works on both macOS and Windows, offering a native menu bar/system tray interface for switching, importing, and saving themes. The project features a companion platform, DreamSkin.cc, with a community theme gallery, an online Studio for designing themes, and a one-click skin-apply flow secured by SHA-256 verification, source validation, and native confirmation dialogs. Themes are packaged as ZIP files containing a background image, theme.json, and Safe CSS scoped to 12 registered UI components. Preset themes include the gothic sci-fi "Gothic Void Crusade" (contributed by community member seansong-ideogram) and an "Arina Hashimoto" preset. The project is actively maintained with installer releases for both platforms, detailed security boundaries, and contribution templates. It is trending likely due to growing interest in AI coding tools and desktop customization, combined with its polished community ecosystem and zero-modification safety approach.
AppsMCPToolscodinglocal-firstsecurity
★ 12,382 total+1,826 this week
#41NEWPartial week
**video-shotcraft** is an AI agent skill that transforms Claude Code or Codex into a full motion-design studio for crafting cinematic product promo videos. It provides 104 shot recipe cards across 10 functional categories, 161 motion-style previews, and a complete production methodology covering storyboarding, visual direction, beat-synced editing, and film-grade sound design. The toolkit is powered by Remotion (a React-based video framework) and includes a ready-to-run template called **Ink Press** — a 36.2-second, 1920×1080, 30fps product promo with 2.5D camera moves, transitions, and a pinned SFX pass. Agents can install it via a single CLI command or repo link, then generate videos by referencing named shot cards or the Gallery. The library also ships 149 SFX organized into 16 scene/material categories and 5 BGM options. Motion techniques were reverse-engineered from top SaaS product films (ClickUp, Notion, Figma, etc.) and re-implemented from scratch. The project is actively maintained with recent updates including a restructured audio library, GitHub Pages Gallery auto-deployment, and expanded SFX coverage. Its tight integration with AI coding agents and production-ready scaffolding make it a notable emerging tool in the agentic video-generation space.
ToolsAppsDatavideomultimodalcoding
★ 1,975 total+1,791 this week
#42NEWPartial week
Bento is an open-source, self-contained PowerPoint alternative where the entire application — viewer, editor, and presenter — lives inside a single ~560 KB HTML file. Users can open, edit, and present decks in any modern browser with no installation, account, or cloud dependency required. Key features include morph-based slide transitions, end-to-end encrypted (AES-GCM) live collaboration via a custom CRDT engine, built-in dependency-free charting, and a local-first offline mode. The document format is plain JSON embedded in the file, making it natively editable by AI agents (Claude Code, Cursor, Aider, Ollama, etc.) without plugins. The file rewrites itself on save using the File System Access API, and signed in-app updates never touch user documents. A roadmap extends the "bento" format to notes (bento/spaces), sheets (bento/dash), and a vault app. Released under the MIT License, the project is notable for its radical portability, privacy-first architecture, and AI-agent-friendly design, positioning it as a trending alternative to cloud-locked office suites.
AppsToolsMCPlocal-firstmultimodalworkflow-automation
★ 2,337 total+1,721 this week
#43
Wigolo is a local-first web intelligence layer designed specifically for AI agents, providing search, fetch, crawl, extract, cache, find-similar, research, and autonomous gather loop capabilities — all without requiring API keys, cloud dependencies, or per-query billing. The project positions itself as a serious alternative to paid web intelligence services like Tavily, Exa, and Firecrawl, rather than merely a free substitute, emphasizing that it matches their quality while keeping all data and computation on-device. It runs as an MCP (Model Context Protocol) server, a REST endpoint, or an embedded SDK, and integrates natively with a wide range of AI coding agents and frameworks including Claude Code, Cursor, Codex, Gemini CLI, VS Code, Windsurf, Zed, Antigravity, LangChain, CrewAI, LlamaIndex, Vercel AI SDK, n8n, and any MCP-compatible client.
Setup is handled via a single `npx wigolo init` command that downloads a headless browser engine and on-device models, runs a health check, and optionally wires named agents in one pass. The tool requires Node.js version 20 or higher and approximately 1.5 GB of disk space, and works on macOS, Linux, and Windows. An `--agents` flag allows simultaneous configuration of multiple coding agents, while `--interactive` and `--wizard` flags offer guided setup flows. The `npx wigolo doctor` command provides ongoing health monitoring, and the entire installation can be cleanly removed with a single uninstall command.
The core toolset includes eight primary capabilities. The `search` tool fans out queries across 18 direct engine adapters in parallel, applying rank fusion and ML reranking with explainable per-result scoring. The `fetch` tool uses a tiered router that auto-escalates from plain HTTP to a headless browser for anti-bot challenges or single-page applications, returning clean markdown with metadata. The `crawl` tool supports BFS, DFS, sitemap, and map-only strategies with robots.txt compliance. The `extract` tool pulls structured data including tables, JSON-LD, and custom JSON Schema outputs. The `cache` tool enables keyword and hybrid semantic querying of previously fetched content. The `find_similar` tool uses three-way fusion of keyword, semantic, and live web signals. The `research` tool decomposes questions into sub-queries, fetches sources, and synthesizes cited reports. The `agent` tool runs an autonomous plan-search-fetch-extract-synthesize loop with a step log and time budget. Additionally, `diff` and `watch` tools track page changes and deliver updates to webhooks.
A key differentiator is wigolo's commitment to honest, transparent output: stale cache, failed fetches, degraded backends, bot-blocked pages, and weak results are all explicitly surfaced and labeled rather than silently swallowed. Every search result carries verbatim excerpts pinned to byte-exact source spans, citation IDs, evidence scores decomposed into semantic and lexical components, and engine consensus counts. This design makes wigolo particularly well-suited for agentic workflows where the agent needs to reason about the reliability and provenance of its evidence.
The project is currently in public beta, actively shipping new features
MCPRetrievalToolslocal-firstbrowser-useworkflow-automation
★ 3,657 total+1,668 this week
#44
CodeGraph is a developer tool that adds semantic code intelligence to AI coding agents, indexing an entire codebase into a unified code graph so agents can retrieve surgical, precise context about how code fits together rather than relying on naive text search. It is designed to "supercharge" a wide range of AI coding assistants, including Claude Code, Cursor, Codex, OpenCode, Hermes Agent, Gemini, Antigravity, and Kiro, by wiring itself into each as an MCP (Model Context Protocol) server. A central selling point is that CodeGraph runs 100% locally, with its core kernel powered by Rust for performance, and it bundles its own Node.js runtime so no separate Node installation, compilation, or native build is required. The project emphasizes being the "fastest complete code graph," providing surgical context that is built around how agents actually work in practice. Installation is streamlined into a few steps: a single curl or PowerShell command grabs the correct OS-specific build, `codegraph install` auto-detects and configures the user's agents by wiring the CodeGraph MCP server into each, and `codegraph init` creates a local `.codegraph/` directory and builds the full graph for a given project in one command. A key convenience feature is auto-sync, enabled by default, which continuously watches the project and updates the graph on every file change—whether the agent edits code or the user adds, modifies, or deletes files—so the index is never stale and nothing needs to be manually re-run. The tool also offers clean lifecycle management: `codegraph upgrade` detects the installation method (bundle, npm, or npx) and updates in place with options to check or pin versions, while `codegraph uninstall` reverses the installer across every agent it configured and can optionally keep the CLI, with per-project indexes removable via `codegraph uninit`. CodeGraph advertises broad language support, treating every supported language uniformly with full structural extraction and cross-file resolution into one graph without per-language setup. The extensive list spans mainstream languages like TypeScript, JavaScript, Python, Go, Rust, Java, C#, PHP, Ruby, C, C++, Swift, Kotlin, Scala, and Dart, as well as web and framework languages such as Svelte, Vue, and Astro, and more specialized or niche languages including ArkTS, Objective-C, Metal, CUDA, Liquid, Pascal/Delphi, Lua, Luau, R, CFML, COBOL, Visual Basic .NET, Erlang, Solidity, Terraform/OpenTofu, and Nix. The project highlights framework-aware routing and mixed iOS/React Native/Expo bridging as notable capabilities, suggesting it understands cross-boundary relationships beyond plain syntax. It supports Windows, macOS, and Linux, and offers multiple integration modes including a CLI, MCP tools, and library usage, along with configuration and telemetry options. CodeGraph places emphasis on trust and supply-chain security, advertising npm provenance, signed and attested builds, and verified releases, and it is distributed under the MIT license. Beyond the current open-source CLI, the README teases an upcoming hosted "CodeGraph platform" aimed at pull-request analysis—telling teams exactly what to test, what could break, which flows are affected, and whether business logic is compromised for every PR—with an early beta waitlist available at getcodegraph.com. In terms of maturity, the project appears actively developed and polished, with cross-platform installers, upgrade/uninstall tooling, published npm packages, documentation and a dedicated website, measured cross-file coverage claims, and an active promotional presence on X (@getcodegraph). Its potential to trend stems from the intersection of several hot themes: AI coding agents are a rapidly growing category, and tools that improve agent context quality and reliability are in high demand. By supporting nearly every popular agent simultaneously, running entirely locally (appealing for privacy and enterprise use), leveraging Rust for speed, and covering an unusually broad set of languages with zero-config indexing and automatic sync
MCPRetrievalToolscodinglocal-firstsecurity
★ 62,631 total+1,652 this week
#45
Palmier Pro is an open-source, Swift-native video editor for macOS built specifically for AI-assisted workflows, positioning Adobe Premiere Pro as its north star. Developed by Y Combinator S24 company Palmier, it enables users and AI agents to collaboratively generate and edit videos directly within a timeline interface. It integrates state-of-the-art generative AI models (Seedance, Kling, Nano Banana Pro) for video and image generation, and exposes a built-in MCP (Model Context Protocol) server at localhost, allowing seamless connection with AI coding agents like Claude Code, Claude Desktop, Codex, and Cursor. The core editor and MCP server are fully open source under GPLv3, while generative AI processing remains proprietary and requires a subscription. Currently limited to macOS 26 (Tahoe) on Apple Silicon, the project is notably trending on Trendshift, has multilingual README support across 15 languages, and signals strong momentum as an agentic AI-video editing platform at the intersection of open-source tooling and frontier AI model integration.
AppsMCPAgentsvideomultimodalon-device
★ 12,464 total+1,632 this week
#46
Astryx is Meta's open-source design system, now publicly released after eight years of internal development where it powered 13,000+ apps across the company. Currently in beta, it ships 150+ accessible React components, brand-level theming, dark mode support, ready-to-ship templates, and a CLI as one cohesive package. Built on React and StyleX, it notably avoids styling lock-in — consumers can override with Tailwind, CSS modules, or plain CSS without adopting StyleX themselves. A standout feature is its "swizzle" mechanism, which ejects a component's full source into your project for deep customization without forking. Astryx is explicitly designed for human-AI collaborative development, with its API, docs, and CLI co-designed so developers and AI assistants work from the same reference. It offers seven pre-built themes and a component lab, plus experimental chart packages. Its trending appeal likely stems from Meta open-sourcing a mature, large-scale internal design system with first-class AI-agent ergonomics — a timely differentiator in the current AI-assisted development landscape.
AppsToolscoding
★ 10,804 total+1,603 this week
#47
gstack is an open-source AI-powered software factory built and actively used by Garry Tan, President and CEO of Y Combinator, designed to transform Claude Code into a structured virtual engineering team. The project was inspired by Andrej Karpathy's widely-circulated remark that he had not typed a line of code since December 2025, prompting Tan to investigate how a single builder could ship at the velocity of a full team. The answer he arrived at is gstack: a collection of 23 specialist roles and 8 power tools, all implemented as slash commands in Markdown, all free, and released under the MIT license.
The core philosophy of gstack is that AI-assisted development should not be a blank prompt but a structured sprint process. The workflow follows a deliberate sequence — Think → Plan → Build → Review → Test → Ship → Reflect — where each skill feeds directly into the next. The `/office-hours` command acts as a YC-style product interrogation, asking six forcing questions that challenge the user's framing before a single line of code is written. It produces a design document that downstream skills automatically consume. `/plan-ceo-review` challenges scope and searches for the "10-star product" hidden inside a feature request, operating in four modes: Expansion, Selective Expansion, Hold Scope, and Reduction. `/plan-eng-review` locks in architecture, data flow diagrams, state machines, edge cases, and test matrices. `/plan-design-review` rates design dimensions on a 0–10 scale, detects "AI slop," and interactively improves the plan. From there, `/review` catches bugs and race conditions, `/qa` opens a real browser and clicks through staging flows, and `/ship` verifies fixes and opens a pull request with new tests included.
Tan backs the project with striking personal productivity metrics. Over the 60 days prior to publishing, he shipped 3 production services and 40+ features part-time while running Y Combinator full-time. Measuring logical code changes — normalized to avoid the inflation that raw line counts suffer from AI generation — his 2026 run rate is approximately 810 times his 2013 pace (11,417 vs. 14 logical lines per day). Year-to-date through April 18, 2026 had already produced 240 times the output of the entire year 2013. These figures are measured across 40 public and private repositories under the garrytan GitHub account, excluding one demo repo, with full methodology, caveats, and a reproduction script documented in a companion file called ON_THE_LOC_CONTROVERSY.md.
Installation takes roughly 30 seconds and requires Claude Code, Git, and Bun v1.0+. A single command clones the repository into `~/.claude/skills/gstack` and runs a setup script. A team mode is also available, which bootstraps a shared repository so that all teammates automatically receive gstack when they open a Claude Code session, with auto-update checks throttled to once per hour and designed to be network-failure-safe and completely silent. The project also integrates with OpenClaw, the AI agent platform built by Peter Steinberger that reached 247,000 GitHub stars, allowing gstack skills to be invoked from OpenClaw agent sessions via ACP. Four native OpenClaw skills are available through ClawHub for conversational use without needing a Claude Code session at all.
Beyond Claude Code and OpenClaw, gstack supports 10 AI coding agents including OpenAI Codex CLI, OpenCode, Cursor, Factory Droid, Slate, Kiro, Hermes, and GBrain. The setup script auto-detects which agents are installed, and adding support for a new agent requires only a single TypeScript configuration file with no code changes. This broad compatibility signals an ambition to be an agent-agnostic methodology layer rather than a tool locked to any single platform.
The project is notably early-stage but actively used in production by its author. It is trending likely because it sits at the intersection of several high-interest themes: the "vibe coding" and AI-agent-assisted development movement, Y Combinator's institutional credibility, Karpathy's viral quote about not typing code, and the broader conversation about individual developer productivity in the AI era. The README is unusually personal and argumentative, directly addressing critics of AI-inflated line count metrics and inviting skeptics to try the tool before dismissing it. For founders, technical CEOs, first-time Claude Code users, and staff engineers seeking rigorous review and release automation, gstack presents itself as a replicable system for one person to ship like a team of twenty.
AgentsToolsAppsworkflow-automationcoding
★ 124,625 total+1,597 this week
#48
HyperFrames is an open-source framework developed by HeyGen that converts HTML, CSS, media assets, and seekable animations into deterministic MP4 videos. Its core value proposition is elegantly simple: write HTML, render video. The framework is explicitly designed to be used by AI coding agents, making it highly relevant to the current wave of agentic development tooling. Rather than requiring developers to learn a proprietary video DSL or GUI timeline editor, HyperFrames lets agents and developers describe video compositions using familiar web technologies — HTML and CSS — and then renders them frame-accurately into MP4 output.
The framework ships with a rich skills system comprising 19 modular agent skills that can be installed via the `npx skills add` command and are compatible with major AI coding agents including Claude Code, Cursor, Gemini CLI, and OpenAI Codex. These skills teach agents a full production loop: planning the video, writing valid HTML, wiring seekable animations, adding media, linting, previewing, and rendering. The router skill `/hyperframes` acts as the central intent layer, dispatching to specialized creation workflows based on the type of video requested.
The creation workflow catalog is impressively broad, covering product launch videos, faceless explainers, PR-to-video changelogs, embedded captions, talking-head recuts, motion graphics, music-to-video beat-synced content, slideshows, general freeform video, and even migration from Remotion (React-based) compositions. This breadth signals an ambition to be a general-purpose programmatic video rendering engine rather than a niche tool. Each workflow is a discrete skill that agents load on demand, keeping installs lean and modular.
Domain skills handle atomic capabilities: `/hyperframes-core` defines the composition contract using `data-*` timing attributes; `/hyperframes-animation` covers animation runtimes including GSAP, Lottie, Three.js, Anime.js, CSS, WAAPI, and TypeGPU; `/hyperframes-keyframes` handles seek-safe keyframe authoring; `/hyperframes-creative` covers design direction, palettes, typography, and audio-reactive visuals; `/media-use` manages the full media pipeline including TTS, music generation, image generation, transcription, captioning, and background removal; `/hyperframes-cli` covers the full developer loop from init through cloud and AWS Lambda rendering; and `/hyperframes-registry` manages installable blocks and components.
The project is distributed as an npm package, requires Node.js 22 or higher, is licensed under Apache 2.0, and has an active Discord community. It also supports a Codex plugin archive format for upload to OpenAI's Codex environment. The existence of hosted cloud rendering via HeyGen's infrastructure and AWS Lambda rendering support suggests a path toward production-scale usage beyond local development. HyperFrames is notable from a trend analysis perspective because it sits at the precise intersection of two major 2024–2025 trends: agentic AI coding workflows and programmatic video generation. By making video creation a first-class skill for AI agents using web-standard technologies, it lowers the barrier for
ToolsAppsMCPvideocodingworkflow-automation
★ 37,884 total+1,580 this week
#49
**nature-skills** is an open-source, reusable scientific research skill library targeting global AI researchers, with a particular focus on enabling agentic, AI-driven academic workflows. Created by Yuan Yizhe (袁一哲), the project curates a growing collection of 18 modular skills—each organized around a `SKILL.md` file—that cover common research tasks such as bilingual paper reading, literature-to-PPT conversion, academic writing and polishing in Nature style, reviewer report simulation, peer-review response drafting, citation analysis, and research figure generation. The philosophy behind the project is that virtually any practical research tool can be abstracted into a standardized, reusable workflow that an AI agent can learn and execute autonomously, without requiring users to deeply study the underlying design. A notable design principle is that the skills are machine-readable: users can simply point Codex or another agent at the GitHub repository URL and have it automatically learn the skill design philosophy and generate or adapt new skills on demand. The project supports installation across multiple AI coding agents—Claude Code, OpenAI Codex, OpenClaw, OpenCode, and Hermes—via an `npx skills` CLI, shell scripts, or manual cloning, with optional auto-update hooks that silently sync skills in the background at session start. Skills are organized into self-contained directories preserving references, static assets, manifests, and scripts, with a shared support package (`nature-shared`) used by several skills. Optional Python dependencies support specialized skills like patent conversion (`nature-paper-to-patent`) and academic search via MCP server (`nature-academic-search`), with integrations for PubMed, Scopus, ScienceDirect, and China's CNIPA patent database. The founder notes that Google DeepMind's Science Skills project drew inspiration from nature-skills' citation system, scripting approach, and skill design philosophy—a point of pride signaling the project's international influence. Community engagement is maintained through Douyin (TikTok) video tutorials, a Knowledge Planet (知识星球) community, a WeChat research exchange group, and a commercial AI account top-up service. The project is actively maintained, bilingual (Chinese and English), Apache-2.0 licensed, and represents an early but maturing effort to formalize and democratize AI-assisted scientific research workflows for the broader academic community.
ToolsAgentsAppsworkflow-automationmultimodalsynthetic-data
★ 31,371 total+1,540 this week
#50
**Awesome DESIGN.md** is a curated awesome-list repository maintained by VoltAgent that collects ready-to-use `DESIGN.md` files extracted and analyzed from real, well-known websites across dozens of industries. The core concept originates from Google Stitch, which introduced `DESIGN.md` as a plain-text, markdown-formatted design system document that AI coding agents can read to generate visually consistent UI — no Figma exports, no JSON schemas, no special tooling required. Developers simply drop a `DESIGN.md` file into their project root, tell their AI agent to "build me a page that looks like this," and receive high-quality UI output that respects the design language, tokens, patterns, and rules encoded in the file. The repository currently hosts 73 such files, spanning categories including AI & LLM platforms, developer tools & IDEs, backend/database/DevOps, productivity & SaaS, design & creative tools, fintech & crypto, e-commerce & retail, media & consumer tech, and automotive. Each entry links to a hosted DESIGN.md and includes a brief design-language descriptor (e.g., Stripe's "signature purple gradients, weight-300 elegance" or Nike's "monochrome UI, massive uppercase Futura, full-bleed photography"). Users can also request custom DESIGN.md files for specific websites via getdesign.md. The repo is ranked approximately #150 globally on GitHub and carries the official Awesome badge, signaling community validation. It targets developers, designers, and "vibecoders" working with AI coding agents and web builders. Its notable ecosystem tool, LaunchKit, is promoted alongside a sponsorship program. The project is actively maintained and is trending due to the rapid rise of AI-assisted UI generation workflows, making it a practical, low-friction resource for anyone building with LLM-powered design agents.
ToolsAppsDatacodingworkflow-automationsynthetic-data
★ 104,740 total+1,536 this week
#51
RTK (Rust Token Killer) is a high-performance command-line proxy tool designed to dramatically reduce the volume of bash output consumed by AI coding agents, cutting up to 90% of shell command output before it reaches the LLM's context window. Built as a single Rust binary, RTK intercepts shell commands and applies four core compression strategies — smart filtering (removing noise, comments, boilerplate), grouping (aggregating similar items like files by directory or errors by type), truncation (keeping relevant context while cutting redundancy), and deduplication (collapsing repeated log lines with counts) — all with less than 10ms overhead. The project supports over 100 commands spanning files, Git, GitHub CLI, test runners, build and lint tools, package managers, AWS services, containers, infrastructure-as-code tools, and data utilities.
RTK integrates with a wide range of AI coding agents and tools including Claude Code, GitHub Copilot, Gemini CLI, OpenAI Codex, Cursor, Windsurf, Cline, Roo Code, Kilo Code, Google Antigravity, Kimi AI, Pi, Hermes, and Factory Droid. Integration is achieved either through hook-based rewriting (automatically prepending `rtk` to bash tool calls) or through plugin APIs, meaning the agent receives compact output transparently without needing to call RTK explicitly. The tool is careful to clarify that its reported savings apply specifically to bash output tokens, which are only one contributor to total LLM input tokens, and that absolute token counts are approximated as bytes divided by four since RTK ships no tokenizer — making percentages reliable but raw numbers approximate.
Installation is straightforward via Homebrew (the recommended path), a curl-based quick installer for Linux and macOS, Cargo from the Git repository, or pre-built binaries for macOS (x86 and ARM), Linux (x86 musl and ARM), and Windows (MSVC). The project notes a name collision with an unrelated "Rust Type Kit" crate on crates.io and advises using the Git-based Cargo install to avoid confusion. RTK also ships a built-in analytics dashboard (`rtk gain`) with ASCII graph support to track cumulative token savings over time.
The project appears to be in active, mature development — currently at version 0.28.2 — with CI/CD via GitHub Actions security checks, multilingual README support across seven languages (English, French, Chinese, Japanese, Korean, Spanish, Portuguese), an active Discord community, and a dedicated website with troubleshooting guides and architecture documentation. Its notable positioning in the agentic coding trend is clear: as LLM-powered coding agents become mainstream, the cost and context-window efficiency of tool outputs becomes a real bottleneck, and RTK directly addresses this by acting as a transparent compression layer between the shell and the agent. This makes it a practically motivated, infrastructure-level tool for anyone running AI agents over codebases at scale
ToolsAgentsServingcodingworkflow-automationlocal-first
★ 73,372 total+1,467 this week
#52
DBX is a lightweight, open-source universal database management tool built with Rust, designed to support 70+ databases in a single binary weighing just 20 MB — with zero runtime dependencies like Java, Python, or bundled Chromium. It positions itself as a modern, cross-platform alternative to tools like DBeaver and TablePlus, running natively on macOS, Windows, and Linux, while also being deployable via Docker for team-based self-hosting and accessible through a web browser interface. The project's core value proposition is combining broad database compatibility, a built-in AI assistant, and Model Context Protocol (MCP) server support into one compact, fast tool.
The AI integration is a central feature: users can highlight a table, describe their intent in natural language, and receive SQL back directly within the editor — eliminating the need to copy-paste between tools. The AI assistant works with Claude, OpenAI, and local models via Ollama, and includes built-in safety checks that review AI-generated SQL before execution. This makes it particularly relevant to the current wave of AI-assisted development workflows.
DBX also functions as an MCP server, meaning AI coding agents such as Claude Code, Cursor, and Windsurf can query databases through DBX using connections already configured by the user — a single config that works across all compatible AI tools. This MCP capability is a strong differentiator and directly aligns DBX with the rapidly growing ecosystem of AI coding assistants that need structured data access.
The database coverage is remarkably broad, spanning relational databases (MySQL, PostgreSQL, SQLite, SQL Server, Oracle, MariaDB, TiDB, CockroachDB, OceanBase, openGauss, GaussDB, KingBase, Redshift, DM, Doris, StarRocks, ClickHouse, DuckDB), NoSQL and search engines (MongoDB, Redis, Elasticsearch, Qdrant, Milvus, Weaviate, Manticore Search), time-series databases (TDengine, InfluxDB), and many more through JDBC-based agent profiles covering Snowflake, Hive, DB2, BigQuery, Cassandra, Neo4j, Databricks, SAP HANA, Teradata, Vertica, Firebird, and others. Cloudflare D1 and embedded databases like Access are also supported.
In terms of maturity and community traction, DBX is actively trending — it carries a Trendshift daily badge for Rust repositories, is featured on HelloGitHub and Product Hunt, and is listed on MCP Toplist. It has active community channels on Discord, QQ, and WeChat, and a Chinese-language README variant, suggesting strong adoption in both global and Chinese developer communities. The project is written in Rust, which contributes to its small binary size and performance characteristics. Overall, DBX is notable for its rare combination of extreme portability, AI-native design, MCP server capability, and unusually wide database support — making it a compelling tool at the intersection of database management and the AI-assisted development trend.
ToolsMCPAppslocal-firstvector-database
★ 11,793 total+1,432 this week
#53
AI Website Cloner Template is a reusable Next.js project template that enables AI coding agents to reverse-engineer any live website into a clean, modern codebase. Users point the tool at a target URL, run the `/clone-website` command, and the agent executes a multi-phase pipeline: reconnaissance (screenshots, design token extraction, interaction sweeps), foundation setup (fonts, colors, assets), component spec generation with exact computed CSS values, parallel component building via git worktrees, and final assembly with visual QA diffing against the original. The recommended agent is Claude Code with Opus 4.8, though 13 other agents are supported including Codex CLI, Cursor, Copilot, Gemini CLI, and Amazon Q. The tech stack centers on Next.js 16, React 19, TypeScript, shadcn/ui, Tailwind CSS v4, and Lucide React. Use cases include platform migration from WordPress/Webflow/Squarespace, recovering lost source code, and learning from production site implementations. The project is MIT-licensed, early-stage but actively maintained, and notable for its broad multi-agent compatibility and structured parallel-build approach to AI-driven site reconstruction.
ToolsAppsAgentscodingbrowser-useworkflow-automation
★ 30,298 total+1,424 this week
#54
Free Claude Code (FCC) is an open-source Python-based local proxy server that allows developers to run AI coding agents — Claude Code, OpenAI Codex, and Pi — through their own choice of AI provider backend, rather than being locked into Anthropic's default billing. The core idea is straightforward: FCC intercepts the API calls these coding agents make and reroutes them to whichever cloud or local model provider the user configures, enabling access to free tiers, cheaper alternatives, or fully local models. The project supports an impressive roster of 25+ providers, including NVIDIA NIM, OpenRouter, Google AI Studio (Gemini), Google Vertex AI, DeepSeek, Mistral, Amazon Bedrock, Hugging Face, Cohere, GitHub Models, Kimi, MiniMax, Cerebras, Groq, SambaNova, Fireworks AI, Cloudflare Workers AI, Ollama, LM Studio, and llama.cpp, among others. Configuration is managed through a local browser-based Admin UI, where users can paste API keys, search and select models from a dropdown, validate connections, and apply settings without touching config files manually. A notable feature is optional model-tier routing, which lets users map Claude Code's internal tiers (Fable, Opus, Sonnet, Haiku) to different provider models independently, enabling fine-grained cost and capability tradeoffs. The proxy preserves streaming, tool use, reasoning, and image input across compatible models, and exposes native model pickers inside both Claude Code and Codex. Installation is handled via a single curl or PowerShell command, with desktop launchers on Windows and macOS for background operation via system tray or menu bar. Linux users run a terminal command. The project also supports optional integrations including VS Code extensions, JetBrains ACP, Discord bots, Telegram bots with voice-note transcription, and token-based authentication for the local proxy. The codebase uses modern Python tooling: Python 3.14, uv for package management, Ruff for formatting, ty for type checking, Loguru for logging, and Pytest for testing. FCC is MIT-licensed and actively maintained with CI workflows. Its trending appeal is clear: it democratizes access to powerful AI coding agents by decoupling them from expensive proprietary APIs, letting developers use free-tier cloud models or fully local LLMs. This positions it squarely at the intersection of the AI coding agent boom and the growing demand for cost-effective, self-hosted AI infrastructure — making it highly relevant to developers watching GitHub trending for
ServingToolsAppscodinglocal-firstmultimodal
★ 42,425 total+1,401 this week
#55
**book-to-skill** is an open-source Python tool that converts any technical book, document folder, or collection of sources into a structured "agent skill" — a compact, on-demand knowledge base that AI coding assistants like GitHub Copilot CLI, Amp, and Claude Code can query directly during development sessions. The core problem it addresses is the "Discovery Loop Tax": when an AI agent reads a raw PDF to answer a question, it navigates back and forth through the document, consuming 24× to 51× more tokens than necessary. book-to-skill eliminates this by pre-distilling source material into a tightly organized skill directory containing a master `SKILL.md` (core mental models and chapter index, ~4,000 tokens), per-chapter files loaded on demand (~1,000 tokens each), a glossary, a patterns file, and a cheatsheet — all structured for minimal token overhead. The workflow is three steps: point the tool at a file, folder, or glob; it distills the content using Claude as the synthesis engine; and the resulting skill is written to the appropriate agent skills directory. Supported input formats are extensive: PDF, EPUB, DOCX, TXT, Markdown, reStructuredText, AsciiDoc, HTML, RTF, and MOBI/AZW/AZW3. For PDF extraction, the tool intelligently selects between fast prose extractors (pdftotext, pypdf, pdfminer.six) and the more thorough Docling for technical books with code blocks and tables. The project follows the open Agent Skills standard, meaning the same `SKILL.md` format works across GitHub Copilot CLI, Amp, and Claude Code without modification. Beyond books, it handles internal documentation, brand/design systems, research paper clusters, RFCs, and compliance specs — essentially any structured prose a developer re-reads frequently. Real-world conversion benchmarks show costs of roughly $1 per book on Claude Sonnet, with books like *Think Python 2* (244 pages, 119K tokens) and *Working Backwards* (371 pages, 175K tokens) serving as concrete examples. The tool includes a `--check` flag to audit which extractors are installed and what commands are needed to add missing ones. Design principles emphasize density over completeness, a practitioner voice ("Use X when Y"), front-loaded content, and on-demand chapter loading. The project achieved notable early traction, ranking **#10 Python Repository of the Day** and **#25 Repository of the Day** on Trendshift on May 23, 2026, signaling strong community interest. It is MIT-licensed, actively maintained with a changelog and architecture docs, and supports GitHub Sponsors. Its appeal on GitHub Trending likely stems from the convergence of AI coding assistants becoming mainstream and the practical, immediately usable solution it offers for grounding agents in real reference material without hallucination.
ToolsRetrievalDatacodingsynthetic-datalocal-first
★ 10,179 total+1,385 this week
#56NEWPartial week
The `gpt-5.6-instruct` repository by MDX-Tom provides a jailbreak/prompt-injection toolkit ("破甲提示词") targeting the `gpt-5.6-sol` model (OpenAI Codex). Its core purpose is to reframe security research, penetration testing, reverse engineering, software cracking, and NSFW fictional content as local sandbox tasks, suppressing refusal behaviors and improving direct instruction execution. The project's standout feature is a self-iterating optimization pipeline: the model itself absorbs user instructions, real failure cases, and GitHub Issues to update test sets, analyze regressions, and rewrite prompts — with a three-tier (low/medium/high) regression gate controlling releases. The current default version, `v41`, achieves 120/120 on the original 120-case medium test suite and 52/52 on a newly added 52-case issue-regression set, while reducing base prompt length by 55.67% versus `v35`. The project includes a Python deployment script (`codex-instruct.py`) with dry-run, rollback, and snapshot features, plus reproducible evaluation tooling covering 360 cases across 6 scenario types. An optional skills-compatible variant (`v41-skills`) integrates upstream Agent Skills for reverse engineering scenarios. The project is MIT-licensed, actively maintained with CI across Python 3.8/3.13, and is trending likely due to its novel self-improving jailbreak methodology and high benchmark scores against a high-profile model name.
SafetyToolsEvalssecuritycoding
★ 3,111 total+1,378 this week
#57
Humanizer is a portable agent skill written in plain Markdown that detects and removes telltale signs of AI-generated writing, rewriting text to sound more natural and authentically human. Because it is implemented as a single `SKILL.md` file, it runs in any agent harness that supports skill-style instructions, making it highly portable and easy to integrate. Installation is handled via the cross-agent Skills CLI (`npx skills add blader/humanizer`), with support for global or project-local installs, multi-harness deployment, and a dedicated Claude Code plugin path. The skill's detection logic is grounded in Wikipedia's "Signs of AI Writing" guide, maintained by WikiProject AI Cleanup, and covers 33 named patterns across five categories: content, language, style, communication, and filler/hedging. Patterns range from significance inflation, AI vocabulary, and em-dash overuse to chatbot artifacts, sycophantic tone, and manufactured staccato drama, each illustrated with concrete before/after examples. A standout feature is Voice Calibration: users can paste samples of their own writing so the skill matches their personal sentence rhythm and word choices rather than producing generic clean output. The skill enforces a strict no-fabrication rule — rewrites never invent facts, names, dates, or citations absent from the source text. It also runs a second audit pass to catch lingering AI-isms missed in the first rewrite. Currently at version 2.9.1, the project is actively maintained with a detailed changelog. Its combination of broad harness compatibility, empirically grounded pattern detection, and voice-matching capability makes it notable as a practical, production-ready tool for AI writing cleanup, which is a rapidly growing need as AI-generated content becomes ubiquitous.
ToolsAppsworkflow-automationsynthetic-data
★ 31,292 total+1,346 this week
#58Partial week
Archify is an agent skill that transforms a codebase or system description into polished, interactive, and shareable technical system maps directly within AI-powered coding environments. It integrates with Cursor, Claude Code, Codex CLI, and OpenCode, and is installed via a single `npx skills add tt-a1i/archify -g` command. The tool supports five distinct diagram types — Architecture, Workflow, Sequence, Data Flow, and Lifecycle — each suited to different technical communication needs, from runtime component maps to CI/CD pipelines and state machines. Four visual presets (Signal Flow, Blueprint, Classic, and others), dark/light themes, and optional finite motion give teams flexible presentation options. A core design principle is truthfulness: every interaction — node search, upstream/downstream reach tracing, route probing, role comparison, and guided story playback — is grounded strictly in authored relationships, never inventing topology or claiming runtime impact. Archify uses a typed JSON Intermediate Representation (IR) with deterministic, atomic validation gates covering schema, layout, HTML/SVG rendering, route integrity, and label clearance; a diagram only replaces the last known good artifact after all checks pass, and failures return machine-readable repair receipts with stable rule codes. The Architecture Delta feature enables before/after comparison of two validated snapshots, surfacing exactly what was added, removed, changed, moved, or rerouted — useful for pre-merge architecture reviews. Output is a single self-contained HTML file, with export options including PNG, SVG, WebM, and canonical 1200×630 share cards for READMEs and social posts. An optional desktop preview loop watches a JSON source file and reloads only verified revisions, keeping the last-good diagram visible during incomplete saves. Source-evidence mode links Architecture nodes to Git-verified file and line ranges pinned to a specific public commit, but only when explicitly requested. At version 2.12.0 under an MIT license, Archify is trending on Trendshift and is notable for combining agent-native workflow integration, strict validation discipline, and communication-first design — positioning it as a specialized alternative to generic diagramming tools or Mermaid themes for engineering teams.
ToolsAppsMCPcodingworkflow-automationmultimodal
★ 7,387 total+1,334 this week
#59
Kimi Code CLI is an open-source AI coding agent from MoonshotAI that runs directly in the terminal, capable of reading/editing code, executing shell commands, searching files, and fetching web pages. It ships as a single binary requiring no Node.js setup, offering blazing-fast startup and a purpose-built TUI optimized for long agent sessions. Key differentiators include video input support (letting the agent interpret screen recordings or demo clips), AI-native MCP (Model Context Protocol) configuration via conversational commands, a rich plugin/marketplace ecosystem, and parallel subagents (`coder`, `explore`, `plan`) for focused work. It integrates with editors like Zed and JetBrains via the Agent Client Protocol (ACP), and supports lifecycle hooks for automation and auditing. The project works out of the box with Moonshot AI's Kimi models but supports other compatible providers. Licensed under MIT and actively maintained, it is trending likely due to growing interest in terminal-native AI coding agents competing in the same space as tools like Claude Code and GitHub Copilot CLI.
AgentsToolsMCPcodingvideoworkflow-automation
★ 5,227 total+1,313 this week
#60
The `bradautomates/claude-video` repository introduces a plugin/skill called `/watch` that gives AI coding agents — primarily Claude — the ability to genuinely "watch" videos rather than merely guessing from titles or incomplete transcripts. The core problem it solves is that out-of-the-box, Claude and similar agents cannot process video content; pasting a YouTube link yields only surface-level inference. With `/watch`, users paste any URL (YouTube, Loom, TikTok, X, Instagram, and hundreds more via yt-dlp) or a local video file path, ask a question, and the tool fetches captions, downloads only what is needed, extracts frames, and produces a timestamped transcript — all handed to Claude so it can answer as if it actually watched the video.
The technical pipeline is well-documented: yt-dlp checks for native captions first (free and instant), ffmpeg extracts frames using one of three detail modes (`efficient` for keyframe-only fast extraction, `balanced` for scene-change detection, and `token-burner` for uncapped scene coverage), and audio is transcribed via Whisper (preferring Groq's `whisper-large-v3` for cost and speed, falling back to OpenAI's `whisper-1`). A smart frame deduplication system using mean absolute difference on 16×16 grayscale thumbnails drops near-identical frames before they consume token budget, which is a notable engineering consideration given that image tokens dominate cost. The tool includes a detailed frame budget table calibrated by video duration, and supports focused time-window analysis via `--start`/`--end` flags for denser per-second sampling.
Real-world use cases highlighted include analyzing competitor content hooks, diagnosing bugs from screen recordings, summarizing long videos, stripping hype from launch announcements, and converting playlists into searchable notes. Installation is zero-config for most users — dependencies install automatically on first run via Homebrew on macOS. The skill is compatible with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and 50+ other agent hosts via the Agent Skills ecosystem, as well as claude.ai web via a downloadable `.skill` bundle. The project appears early-stage but polished, with thoughtful documentation covering performance benchmarks on a real 49-minute video, token cost estimates, and multiple install paths. Its trending appeal likely stems from the growing demand for multimodal AI agent capabilities and the practical gap it fills in video
ToolsAppsMCPmultimodalvideoaudio
★ 10,497 total+1,248 this week
#61
**Agent Skills** is a production-grade collection of 24 structured engineering workflows ("skills") designed to make AI coding agents behave like senior software engineers across every phase of the development lifecycle. Created by Addy Osmani, the project encodes the workflows, quality gates, and best practices that experienced engineers follow — packaging them so AI agents apply them consistently rather than improvising. The core philosophy is that good software development follows a disciplined sequence: Define → Plan → Build → Verify → Review → Ship, and each phase has dedicated skills and slash commands to activate the right behavior automatically.
The project exposes 8 slash commands (`/spec`, `/plan`, `/build`, `/test`, `/review`, `/webperf`, `/code-simplify`, `/ship`) that map directly to lifecycle phases. A standout feature is `/build auto`, which lets an agent generate a plan and implement every task in a single approved pass — removing human stepping between tasks while preserving test-driven commits and pausing on failures or risky steps. Skills also activate contextually: designing an API triggers `api-and-interface-design`, building UI triggers `frontend-ui-engineering`, and so on.
The 24 skills span a wide range of concerns: spec-driven development, planning and task breakdown, incremental implementation, test-driven development (Red-Green-Refactor, 80/15/5 test pyramid), context engineering, source-driven development (grounding decisions in official docs), doubt-driven development (adversarial in-flight review with optional cross-model escalation), frontend UI engineering (WCAG 2.1 AA accessibility), API and interface design (Hyrum's Law, One-Version Rule), browser testing with DevTools MCP, debugging and error recovery, code review (five-axis, ~100-line change sizing), code simplification (Chesterton's Fence, Rule of 500), and security hardening (OWASP). A meta-skill (`using-agent-skills`) helps route incoming work to the correct workflow.
Installation is broad and flexible. A one-command CLI (`npx skills add addyosmani/agent-skills`) installs all 24 skills into 70+ agents. Native integrations are documented for Claude Code (with marketplace plugin support), Cursor, Antigravity CLI, Gemini CLI, Windsurf, OpenCode, GitHub Copilot, Kiro IDE, Codex, and others. Skills are plain Markdown, making them compatible with any agent that accepts system prompts or instruction files. An Adoption Guide covers both greenfield and incremental rollout strategies for established codebases.
The project is trending on Trendshift and represents a notable shift in how AI-assisted development is structured — moving from ad hoc agent prompting toward repeatable, verifiable, senior-engineer-grade workflows that
ToolsAgentsAppscodingworkflow-automationsecurity
★ 80,532 total+1,193 this week
#62
**daily_stock_analysis** (股票智能分析系统) is an AI-powered daily stock analysis platform supporting A-shares, Hong Kong, US, Japanese, Korean, and Taiwan markets. It automatically generates structured "Decision Dashboard" reports covering core conclusions, scoring, trend direction, buy/sell levels, risk alerts, catalysts, and operational checklists, then pushes them to WeChat Work, Feishu, Telegram, Discord, Slack, or email. The system integrates multiple LLM backends (Gemini, OpenAI, DeepSeek, Claude, Qwen, Ollama) and aggregates market data from AkShare, Tushare, YFinance, Baostock, TickFlow, and Longbridge, with news sourced from SerpAPI, Tavily, Bocha, Brave, and MiniMax. It features a FastAPI-based web workbench with manual analysis, backtesting, portfolio management, Agent strategy Q&A (supporting 15 built-in strategies including moving averages, Elliott Wave, and Chan Theory), and smart import via image/CSV/clipboard. Deployment is zero-cost via GitHub Actions (5-minute setup), Docker, or local scheduling. Ranked **#1 Python Repository of the Day** on Trendshift and featured on HelloGitHub, it is actively trending in the Chinese quant/retail investing community. Two companion projects, AlphaSift and AlphaEvo, extend it with multi-factor stock screening and strategy backtesting/evolution.
AppsAgentsToolsworkflow-automationmultimodal
★ 59,120 total+1,186 this week
#63
Academic Research Skills (ARS) is a comprehensive suite of Claude Code skills designed to support academic researchers across the entire pipeline from initial research through to publication. Distributed under a CC BY-NC 4.0 license and currently at version v3.19.0, the project is installable in roughly 30 seconds via Claude Code CLI, VS Code, or JetBrains through a plugin marketplace, with alternative traditional symlink installation flows also documented. The central philosophy of the tool is "AI is your copilot, not the pilot" — it deliberately avoids full automation and instead handles the labor-intensive grunt work of research such as hunting down references, formatting citations, verifying data, and checking logical consistency, leaving the intellectual core (defining questions, choosing methods, interpreting data, and writing arguments) to the human researcher. Notably, ARS distinguishes itself from "humanizer" tools: rather than concealing AI usage, it aims to improve writing quality through features like Style Calibration (which learns a user's voice from past work) and Writing Quality Check (which catches machine-generated prose patterns).
The project's human-in-the-loop stance is heavily grounded in academic literature. It cites Lu et al. (2026, Nature) on "The AI Scientist," the first fully autonomous AI research system to pass blind peer review at an ICLR 2025 workshop, whose limitations enumerate failure modes (implementation bugs, hallucinated results, methodology fabrication, citation hallucinations, frame-lock, etc.) that ARS's integrity gates aim to avoid. Stages 2.5 and 4.5 run a 7-mode blocking checklist. ARS also draws on Zhao et al. (2026), who audited 111M references across 2.5M papers on arXiv, bioRxiv, SSRN, and PMC, conservatively estimating 146,932 hallucinated citations for 2025. In response, ARS added trust-chain frontmatter (v3.7.1), locator infrastructure with three-layer citation anchors (v3.7.3), and an opt-in claim audit pass (v3.8, via ARS_CLAIM_AUDIT=1) that fetches cited sources and judges whether claims are actually supported, gating output through a formatter terminal hard gate with five HIGH-WARN classes. Calibration ships as a 20-tuple gold set with FNR<0.15 and FPR<0.10 thresholds. Ren et al. (2026, a survey on self-improvements in agentic systems) provides further design rationale, noting that discovery agents cannot easily verify novelty, correctness, or reproducibility alone, and citing Lenat's EURISKO as a historical example of the value of human evaluation signals. Version 3.3 was inspired by PaperOrchestra (Song et al., 2026, Google), adopting Semantic Scholar API verification, anti-leakage protocol, VLM figure verification, and score trajectory tracking.
The architecture consists of four core skills. Deep Research is a 13-agent research team with Socratic guided mode, PRISMA systematic review, intent detection, dialogue health monitoring, optional cross-model data access, and Semantic Scholar verification. Academic Paper is a 12-agent writing system with Style Calibration, Writing Quality Check, LaTeX hardening, visualization, revision coaching, citation conversion, and figure verification. Academic Paper Reviewer is a 7-agent multi-perspective peer review system (Editor-in-Chief plus three dynamic reviewers and a Devil's Advocate) with 0–100 quality rubrics, concession threshold protocol, R&R traceability matrix, and read-only constraints. Academic Pipeline is a 10-stage orchestrator featuring adaptive checkpoints, claim verification, a Material Passport, optional repro_lock, cross-model integrity verification, and score trajectory tracking. Additional features include Data Access Level Metadata (raw/redacted/verified_only, enforced via a Python script and adapted from Anthropic's automated-w
ToolsAgentsAppsworkflow-automationmultimodalsynthetic-data
★ 39,659 total+1,147 this week
#64
DNSHE Free Domains is a public-interest free domain registration and DNS resolution service built by a Singapore-based youth team, targeting developers, students, open-source projects, and early-stage internet creators. The project offers free domain registration under several public suffixes — including `.de5.net`, `.us.ci`, `.cc.cd`, and `.bot.cd` — each tailored for specific use cases like tech portfolios, CI/CD pipelines, creative projects, and bot automation. It provides full DNS record management (A, AAAA, CNAME, MX, TXT, NS, SRV, CAA) via a dashboard and a documented API, enabling automation-friendly workflows for deployment pipelines, testing environments, and certificate management. No credit card is required for the basic tier. The repository serves as a public information hub with quick-start guidance, acceptable-use policies, abuse reporting channels, and legal notes. The project is actively maintained and notable for democratizing domain infrastructure without cost barriers, making it particularly appealing to hobbyists and open-source contributors. Its trending status likely reflects growing demand for free, developer-friendly domain services with robust DNS and API support.
MCPToolsworkflow-automation
★ 7,580 total+1,144 this week
#65
OmniGet is a free, open-source, cross-platform desktop application for Windows, macOS, and Linux that consolidates downloading, media playback, reading, and music management into a single no-terminal interface. Built with Tauri, Svelte, and Rust, it targets users who are tired of juggling multiple tools — yt-dlp in a terminal, separate course downloaders, and standalone music apps — by unifying all of that into one window. Its core downloading engine wraps yt-dlp and FFmpeg, which self-install and auto-update with SHA256 verification, giving it access to over 1,800 supported sites including YouTube, TikTok, Instagram, Twitter/X, Reddit, Twitch, Vimeo, Bluesky, and Bilibili. Bilibili support is notably deep, covering 4K, HDR, Dolby Vision, Hi-Res lossless audio, Dolby Atmos, Danmaku in XML/ASS/JSON, NFO metadata for Kodi and Jellyfin, and eleven distinct URL types. Online course downloading is a headline feature, supporting Udemy, Hotmart, Kiwify, Skool, Teachable, Kajabi, Wondrium, Thinkific, and Rocketseat, with an integrated player that resumes playback, supports timestamped notes, and displays attached PDFs side by side. A global hotkey (Ctrl+Shift+D / Cmd+Shift+D) lets users copy any link and trigger a background download without ever opening the app window. The built-in music player handles local libraries (MP3, FLAC, M4A, OGG, Opus), synced lyrics, an equalizer, and integrations with Spotify, SoundCloud, YouTube Music, Qobuz, and Last.fm. A built-in reader supports EPUB, PDF, CBZ, TXT, and HTML with highlights, bookmarks, and focus mode. Additional features include batch downloading, partial video clips, subtitle embedding, Whisper-generated subtitles, SponsorBlock, channel following with tray notifications, and direct P2P file transfer via short code. The project is licensed under GPL-3.0, requires no admin rights, and earned thousands of GitHub stars within its first months — notable because no comparable open-source all-in-one tool
AppsToolsDatalocal-firstvideoaudio
★ 7,889 total+1,101 this week
#66NEWPartial week
MEV-Arbitrage-Bot is a Solidity smart contract paired with a Python automation script designed to find and execute MEV (Maximal Extractable Value) arbitrage opportunities between Uniswap V2/V3 liquidity pools on Ethereum mainnet. The bot's core function, `executeArbitrage()`, scans for price discrepancies across pools and routers, executing profitable trades atomically in a single transaction. Supporting functions handle router/token whitelisting, swap limits, emergency pausing, approval revocation, and fund withdrawal, all restricted to the contract owner. Deployment is guided step-by-step through a browser-based tool called EtherLab, where users compile the Solidity contract at version 0.8.20, connect MetaMask or Phantom wallets, and launch Python automation without manual intervention. The automation loop uses `eth_estimateGas` dry-runs before committing real transactions, while a background scanner monitors live Uniswap swap events and logs activity in real time. The project targets beginners, recommending 0.5–1 ETH as starting capital and claiming ~$500/day returns — figures that are unverified and speculative. The repo appears early-stage and promotional in nature, notable primarily for combining on-chain MEV logic with a no-code-style deployment UI, making it accessible but potentially risky.
ToolsAppsworkflow-automationon-device
★ 1,520 total+1,085 this week
#67
career-ops (also known as careerops, hosted at career-ops.org) is an open-source, multi-agent job search automation system that transforms any AI coding CLI into a full-featured career pipeline command center. Built by Santiago Ferreira (GitHub handle: santifer), the project was born out of personal frustration with manual job hunting and the asymmetry of AI being used by companies to filter candidates while job seekers had no equivalent tooling. The core philosophy is elegantly stated in the README: "Companies use AI to filter candidates. I just gave candidates AI to choose companies." The system is explicitly not a spray-and-pray application blaster — it is a high-signal filter designed to surface the few genuinely worthwhile opportunities out of hundreds, strongly discouraging applications to anything scoring below 4.0 out of 5.0.
The technical approach is agentic and multi-layered. career-ops uses Playwright for headless browser automation to scrape and navigate career portals (Greenhouse, Ashby, Lever, Wellfound, and 45+ pre-configured company pages including Anthropic, OpenAI, ElevenLabs, Retool, and n8n). Evaluation is performed through a structured six-block framework covering role summary, CV match, level strategy, compensation research, personalization, and interview preparation using STAR+Reflection methodology, plus a Block G legitimacy check that flags scams and ghost postings. Each job receives an A–F grade across five scoring dimensions that feed into a holistic 1.0–5.0 score. The system generates ATS-optimized, keyword-injected PDF CVs styled with Space Grotesk and DM Sans fonts, as well as research-backed cover letters with interactive angle prompts and formal application email drafts — though it never submits anything autonomously, preserving human-in-the-loop control at every action step.
Beyond evaluation, career-ops includes a deep research mode that surfaces a target company's AI strategy, engineering culture, and recent moves, and a contact discovery mode (contacto) that identifies the right hiring manager, recruiter, or team peer and drafts a concise LinkedIn outreach message. An interview story bank accumulates STAR+Reflection narratives across evaluations, building a reusable master set of behavioral interview answers. Salary negotiation scripts, geographic discount pushback frameworks, and competing-offer leverage templates are also included. Batch processing via parallel sub-agents allows evaluating 10+ listings simultaneously, and a Terminal UI (TUI) built with Bubble Tea provides a dashboard for browsing, filtering, and sorting the pipeline. Pipeline integrity tooling handles automated merging, deduplication, status normalization, and health checks.
The project is built primarily in Node.js and Go, uses Playwright for browser automation, and is designed to run on any agent-skill-standard CLI — including Claude Code, OpenCode, Codex, GitHub Copilot, Grok Build CLI, Antigravity CLI, Qwen, and Kimi. Installation is a single npx command, and first-time setup is conversational rather than config-file-driven. The project is licensed under MIT with a separate trademark policy.
In terms of maturity and traction, career-ops is notably well-validated: the author personally used it to evaluate over 740 job listings, generate more than 100 tailored CVs, and ultimately
AgentsAppsToolsbrowser-useworkflow-automationlocal-first
★ 61,715 total+1,081 this week
#68
The `coreyhaines31/marketingskills` repository is a structured collection of AI agent "skills" — markdown files that give AI coding agents specialized marketing knowledge and workflows — designed for technical marketers and founders who want to automate or accelerate marketing tasks using AI agents. The project covers an impressively broad surface area of modern digital marketing, including SEO auditing, conversion rate optimization (CRO), copywriting, paid advertising, email sequences, cold outreach, referral programs, churn prevention, pricing strategy, product launches, analytics, app store optimization, programmatic SEO, AI-optimized SEO, community marketing, influencer marketing, sales enablement, revenue operations, and more — totaling nearly 50 distinct skill modules. Each skill is a markdown file that an AI agent can load to apply domain-specific frameworks and best practices to a given task, making the system modular and extensible. The architecture is notably thoughtful: a central `product-marketing` skill acts as a shared foundation that every other skill reads first, ensuring all agents understand the product's positioning, audience, and context before executing any specialized task. Skills also cross-reference each other in meaningful clusters — for example, `copywriting` ↔ `cro` ↔ `ab-testing`, and `revops` ↔ `sales-enablement` ↔ `cold-email` — creating a coherent, interconnected knowledge graph rather than isolated prompts. The project is compatible with multiple AI agent platforms including Claude Code, OpenAI Codex, Cursor, and Windsurf, and adheres to the open Agent Skills specification at agentskills.io. It is built and maintained by Corey Haines, a marketer and founder who also runs Conversion Factory (a CRO and growth agency), the Swipe Files newsletter, an AI Marketing Training program, and Magister, an autonomous AI marketing agent that leverages these skills. The repository is open to contributions via pull requests and is actively maintained with an issue tracker. Its notable trendiness stems from the intersection of the booming AI coding agent ecosystem with practical, real-world marketing automation — essentially providing a plug-and-play marketing brain for any AI agent environment. For marketers unfamiliar with terminals or coding agents, a companion resource called Coding for Marketers is also referenced.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 41,848 total+1,071 this week
#69
Understand Anything is an open-source AI-powered developer tool built by Egonex AI that transforms any codebase, knowledge base, or documentation set into an interactive, explorable knowledge graph. Originally created by Lum1104, the project addresses a universal pain point for developers: onboarding into large, unfamiliar codebases. Rather than forcing engineers to read code blindly, it deploys a multi-agent pipeline to scan every file, function, class, and dependency, then constructs a structured knowledge graph saved locally as a JSON file. The resulting interactive dashboard lets users pan, zoom, search, and click through nodes, each annotated with plain-English summaries and relationship maps. Beyond structural visualization, the tool offers a domain view that maps code to real business processes, and a knowledge-base mode that ingests Karpathy-pattern LLM wikis, extracting wikilinks, categories, and implicit relationships via LLM agents to produce force-directed community graphs. Key features include guided architectural tours ordered by dependency, fuzzy and semantic search across the graph, diff impact analysis to preview ripple effects before committing, persona-adaptive UI that adjusts detail level for junior developers, PMs, or power users, automatic layer visualization color-coded by API/Service/Data/UI/Utility tiers, and in-context explanations of twelve programming language patterns. The tool supports localized output in English, Chinese (Simplified and Traditional), Japanese, Korean, and Russian. Installation is notably broad: it natively integrates with Claude Code as a plugin and supports one-line shell installation for over a dozen platforms including Codex, Gemini CLI, Cursor, VS Code with GitHub Copilot, Kiro, OpenCode, Vibe CLI, Cline, Trae, Hermes, KIMI CLI, Nanobot, Pi Agent, and Antigravity — the query-relevant platform, which uses the standard slash-command invocation pattern. Subsequent runs are incremental by default, re-analyzing only changed files to minimize token consumption, and a post-commit hook option enables automatic updates. The project is MIT-licensed, actively trending on Trendshift (repository #23482), and notable for its unusually wide platform compatibility, multilingual support, and its philosophy that AI should augment human understanding rather than replace developers.
ToolsRetrievalAppscodingvector-databaseworkflow-automation
★ 76,276 total+1,058 this week
#70
MengTo/Skills is a curated, open-source collection of 118 agent skills designed to help designers and developers build rich user interfaces, playable browser games, frontend systems, agent loops, automations, and reusable workflows using AI coding agents. Each skill is packaged as a portable, folder-based Markdown playbook (SKILL.md) that an agent can load and follow, with optional supporting files like REFERENCES.md, ARTICLE.md, demo HTML files, and helper scripts. The library spans six major categories: Codex workflows (17 skills), customer support (2), media (2), UI (1), game development (17), and web design (79), covering everything from converting screen recordings into detailed super-prompts to building isometric ARPGs in Three.js. The flagship workflow, Video to Super Prompt, turns a screen recording of a design or animation into a highly detailed prompt that can one-shot HTML generation. The project's philosophy treats prompts as versioned assets, favors explicit specs and visual references over vague descriptions, and structures skills as operating procedures with clear triggers, defaults, and guardrails. It is explicitly compatible with Codex, Claude Code, Cursor, Aura Build, and Lovable, making it broadly portable across the modern AI-agent stack. The repo is notably practical and production-oriented, targeting real design and development workflows rather than toy examples. Its breadth — spanning WebGL shaders, GSAP animations, SaaS billing support, game enemy AI, and editorial layout systems — makes it a comprehensive prompt-engineering and agent-orchestration resource. Its trending appeal likely stems from the surge of interest in AI coding agents and the growing need for structured, reusable prompt libraries that go beyond one-off chat interactions.
ToolsAppscodingworkflow-automationbrowser-use
★ 3,473 total+1,053 this week
#71
Toonflow is an AI-powered short-drama production workbench developed by HBAI-Ltd, designed to automate the full creative pipeline from raw text to finished video. The platform targets the rapidly growing short-video and micro-drama content market, positioning itself as a zero-barrier, end-to-end AI factory for turning novels or scripts into polished video episodes — claiming a 10x improvement in production efficiency. Its core workflow follows a structured loop: planning → scriptwriting → storyboarding → video output, all organized on an infinite-canvas interface where script nodes, character assets, storyboard frames, and video clips can be freely arranged, branched, and iterated in parallel rather than linearly. A standout architectural feature is its three-layer Agent collaboration system comprising decision, execution, and supervision layers, which together handle task decomposition, content generation, quality review, and revision feedback to improve consistency across long productions. Toonflow also implements persistent Agent memory using local ONNX-based vector retrieval, supporting short-term message history, long-term summarization, and semantic recall across sessions — a technically sophisticated approach to maintaining narrative continuity. The platform features a programmable vendor system allowing users to write TypeScript logic for AI provider integrations directly in the settings panel, taking effect instantly without restarting or modifying source code, making it highly adaptable for private deployments and multi-model setups. Chapter event graph-driven adaptation automatically extracts and structures plot events from source novels, enabling precise context retrieval during script adaptation to reduce information loss in long texts. Skill files externalize core prompts for ScriptAgent and ProductionAgent as editable Markdown files, supporting rapid prompt tuning without code changes. A demo production was completed in approximately two hours using Seedance 2.0 for video, GPT Image 2 for images, and Claude Opus 4.6 for language tasks, at a total cost of roughly ¥130 (~$18 USD). The project supports seven languages including Simplified Chinese, Traditional Chinese, English, Thai, Vietnamese, Japanese, and Russian, and is deployable via desktop installers (Windows, macOS, Linux), Docker, cloud servers with PM2, or through an officially authorized cloud platform called 智星云 (AI-Galaxy). Built on TypeScript, Node.js, Electron, and Docker, the project has received AtomGit G-Star No. 540 certification and Gitee GVP recognition, signaling meaningful community traction. It is licensed under Apache 2.0 and maintains an active Discord community, suggesting it is an emerging, actively developed open-source project at the intersection of generative AI, agentic workflows, and creative content production — a notably trending combination in 2024–2025.
AppsAgentsDatavideomultimodalworkflow-automation
★ 12,704 total+1,032 this week
#72
The `/last30days` project is an AI agent-led search engine and installable skill that aggregates real-time signals from over a dozen social platforms, prediction markets, and developer communities — then synthesizes them into a single ranked brief scored by actual human engagement rather than editorial curation. The core philosophy is that Reddit upvotes, X likes, YouTube views, TikTok engagement, and Polymarket odds backed by real money represent a more honest signal of what matters than any SEO-optimized editorial layer. The project explicitly positions itself against Google, ChatGPT, Gemini, and Claude, arguing that no single AI has native access to all these walled gardens simultaneously — but an agent with user-supplied API keys and browser sessions can bridge them all at once.
The skill installs in seconds via Claude Code's plugin marketplace or via `npx skills add` for Codex, Cursor, Copilot, Gemini CLI, and 50+ Agent Skills hosts. Zero configuration is required for Reddit, Hacker News, Polymarket, and GitHub; a first-run setup wizard unlocks X, YouTube, TikTok, arXiv, Techmeme, and Digg in about 30 seconds. The source table is extensive: Reddit (free, keyless, real upvote counts), X/Twitter, YouTube (full transcripts), TikTok, Instagram Reels, Hacker News, Polymarket, GitHub, Digg's AI 1000 feed, arXiv, Techmeme, LinkedIn, StockTwits, Threads, Pinterest, Xiaohongshu, Bluesky, Perplexity, and general web coverage. Community contributors continue adding niche sources like Truth Social.
The synthesis engine ranks results by social relevancy — a Reddit thread with 1,500 upvotes outweighs a blog post nobody read; a TikTok with 3.6M views outweighs a press release. Comments are now a default-on layer across sources, with rank-based diversity to prevent any single post from dominating. The tool supports multiple distinct use modes: person research before meetings, hiring signal analysis, topic discovery before a trend peaks, event coverage when something breaks, tool comparison with live GitHub star counts, travel intelligence, and fast learning from community-vetted prompting techniques.
The README is rich with concrete worked examples — researching Peter Steinberger before a meeting, tracking Kanye West's cultural moment across 23 Reddit threads and 86K upvotes, comparing AI agent tools like OpenClaw vs. Hermes vs. Paperclip with live star counts, and monitoring geopolitical events like an Iran-USA conflict scenario with Polymarket ceasefire odds. These examples make the value proposition tangible and demonstrate the breadth of the engine's intended use cases.
In terms of maturity, the project is actively developed and community-driven. As of v3.11.1 (July 2026), it has shipped 175 merged PRs across 15 releases since the v3.3 announcement in May, with 122 PRs from 52 community contributors. Notable recent additions include first-class OpenAI Codex plugin support with renderer-aware citations, free arXiv and Techmeme CLI integrations, a revived free Reddit path using RSS and shreddit scraping after the public JSON API died, and improved comment ranking across Instagram, YouTube, and crowd-voted Best Takes. The project was GitHub Trending #1 Repository of the Day and is tracked on Trendshift, signaling strong organic discovery momentum.
The project is notable for its agent-native architecture — it is not a standalone app but a composable skill that runs inside whatever AI coding or chat agent the user already has.
ToolsRetrievalAppsbrowser-useworkflow-automationmultimodal
★ 53,842 total+1,024 this week
#73
Multica is an open-source managed agents platform that transforms AI coding agents into genuine teammates within software development workflows. Inspired by the 1960s Multics operating system's time-sharing philosophy, it lets small teams multiply their throughput by assigning issues to AI agents just as they would to human colleagues — agents pick up tasks, write code, post comments, raise blockers, and report progress autonomously. Key features include Squads (stable routing groups led by a leader agent), Autopilots (cron/webhook-triggered recurring tasks), Reusable Skills (solutions that compound team capabilities over time), and Unified Runtimes (a single dashboard managing local daemons and cloud compute). The platform supports a broad ecosystem of agent CLIs including Claude Code, Codex, GitHub Copilot CLI, Cursor Agent, Kimi, Kiro CLI, and others. Its architecture combines a Next.js 16 frontend, a Go backend (Chi router, sqlc, WebSockets), and PostgreSQL 17 with pgvector. Installation is straightforward via Homebrew, install scripts, or PowerShell, with full self-hosting support via Docker. An iOS mobile client is also included. The project is early-stage but feature-rich, vendor-neutral, and notable for riding the wave of agentic AI adoption — positioning itself as open-source infrastructure for human+AI hybrid engineering teams at a moment when that concept is rapidly gaining traction.
AgentsToolsAppscodingworkflow-automationlocal-first
★ 42,123 total+1,015 this week
#74NEWPartial week
**i-have-adhd** is a coding assistant plugin (skill) by ayghri that reformats AI responses to be ADHD-friendly — leading with the immediate action, numbering steps, capping lists at five items, and eliminating filler phrases like "Hope this helps!" No ADHD diagnosis is required to benefit from it. The project defines ten explicit communication rules: action-first output, numbered multi-step tasks, concrete next steps, suppressed tangents, per-turn state restatement, specific time estimates, visible wins, matter-of-fact error reporting, capped lists, and zero preamble or closers. It installs as a plugin for Claude Code or Codex with simple CLI commands and can be set to activate automatically on every session. Users can fork and customize the core `SKILL.md` file to tune the rules to their preferences. The project is early-stage but notable for its multilingual README (English, Simplified Chinese, Japanese, Korean), its clean before/after demonstration, and its timely intersection of AI tooling with neurodivergent accessibility. It is loosely inspired by the book *The Adult ADHD Tool Kit* by Ramsay and Rostain, adapted for LLM response behavior rather than personal productivity.
ToolsAppscoding
★ 10,719 total+1,009 this week
#75
NitroStack is an enterprise-grade TypeScript framework for building production-ready MCP (Model Context Protocol) servers, targeting AI-native backend development. It takes an opinionated, batteries-included approach inspired by enterprise frameworks like NestJS, offering decorator-driven tool/resource/prompt definitions, a first-class dependency injection container with multiple lifecycle scopes, and built-in authentication supporting JWT, OAuth 2.1, and API keys. Key features include a middleware pipeline (guards, interceptors, pipes, exception filters), Zod-based end-to-end type safety, React-based UI Widgets for rich interactive tool outputs, and caching annotations — all composable via a single decorator stack with zero boilerplate. The ecosystem ships three modular packages: `@nitrostack/core`, `@nitrostack/cli`, and `@nitrostack/widgets`. Complementing the framework is NitroStudio, a dedicated desktop app for real-time tool testing, payload inspection, hot reload, and built-in AI chat against the MCP server. The project is actively maintained, open-source under Apache 2.0, and notable for riding the strong agentic-AI and MCP adoption wave, offering a structured, scalable alternative to hand-rolled MCP server boilerplate.
MCPAgentsAppsworkflow-automationsecurity
★ 2,166 total+1,001 this week
#76NEWPartial week
"No AI Slop" is an open-source writing skill/plugin by Peter Yang that detects and removes over 20 common AI-generated writing patterns without flattening the author's personal voice. It targets clichés like binary contrasts ("It's not X, it's Y"), throat-clearing openers, weasel attribution, fake-strong verbs, and dramatic fragmentation, while also enforcing fundamentals like active voice, leading with the point, and preferring concrete numbers. The tool integrates with Claude Code, OpenAI Codex, and ChatGPT as a plugin, and is invoked via a simple `/no-ai-slop` command to either edit a draft or detect AI patterns with quoted evidence. It includes a self-evaluation mechanism (`eval.md`) where the skill checks its own edits against pass/fail criteria. The project fits into the author's "25/50/25" writing workflow — human first draft, AI-assisted editing, human final pass. With 2,700+ GitHub stars, 611K impressions on X, and a public ChatGPT directory listing, it is clearly trending as AI-generated writing becomes increasingly prevalent and readers grow sensitive to its telltale patterns. Licensed under MIT.
ToolsAppscodingworkflow-automation
★ 2,811 total+984 this week
#77
The **Exercises Dataset** repository by hasaneyldrm is a comprehensive, production-ready fitness exercise dataset containing 1,324 unique exercises, each paired with an animated GIF, a 180×180 thumbnail image, and rich structured metadata including category, body part, equipment type, target muscle, synergist muscle groups, and step-by-step instructions available in 10 languages: English, Spanish, Italian, Turkish, Russian, Chinese, Hindi, Polish, Korean, and French. The dataset is stored as a JSON array in `data/exercises.json`, formally validated by a JSON Schema (Draft 2020-12) file, and all media assets are sourced from Gym Visual under specific attribution terms alongside an MIT license for the code and data. The repository is notably the data backbone powering **LogPress**, an AI-assisted workout tracking mobile application, demonstrating real-world production use rather than being a purely academic or experimental resource. Coverage across body parts is broad, with upper arms (292), upper legs (227), back (203), waist (169), and chest (163) being the most represented categories, and equipment ranges from body weight (325 exercises, ~25% of the total) to dumbbells, cables, barbells, leverage machines, bands, Smith machines, kettlebells, and more. Two standalone HTML tools are bundled with the repository: `index.html`, a fully client-side exercise browser with live search, category/equipment/target filtering, infinite scroll, and multilingual instruction display; and `setup.html`, a developer setup guide that generates ready-to-run SQL INSERT statements for SQL Server, PostgreSQL, MySQL, and SQLite, provides copy-paste API client code in JavaScript, Python, C#, Java, PHP, Go, and cURL, and includes structured LLM prompts for generating complete REST APIs using frameworks like Express.js, FastAPI, ASP.NET Core, Spring Boot, Laravel, and Gin. The data schema is thorough, with each record carrying a unique ID, full exercise name, multilingual instruction strings and step arrays, primary and secondary muscle fields, equipment, media paths, attribution, and an ISO 8601 creation timestamp. The project is notably developer-friendly, requiring no server to browse or explore, and is well-suited for fitness app development, exercise recommendation machine learning models, health research, and educational prototyping. Its multilingual scope, visual media assets, formal schema validation, and integrated developer tooling make it a notably feature-rich and immediately deployable dataset in the fitness and health technology space, distinguishing it from simpler exercise lists or single-language alternatives.
DataAppsmultimodal
★ 17,040 total+957 this week
#78
9Router is a free, self-hosted AI router and "token saver" designed to sit between AI coding CLI tools and dozens of AI model providers, ensuring developers "never stop coding" while minimizing cost. It functions as a smart local proxy—running by default at http://localhost:20128—that connects popular AI code tools such as Claude Code, Cursor, Antigravity, GitHub Copilot, Codex, Gemini, OpenCode, Cline, and OpenClaw to over 40 AI providers and more than 100 models. The project's central value proposition is solving common pain points in AI-assisted development: unused monthly subscription quotas that expire, rate limits that interrupt work mid-session, expensive per-provider APIs costing $20–50/month, tool outputs (like git diff, grep, and ls) that rapidly consume tokens, and the tedium of manually switching between providers. Its headline feature is "RTK Token Saver," which automatically compresses tool_result content to save 20–40% of tokens per request. Beyond token savings, 9Router offers automatic tiered fallback that cascades requests from subscription-based tiers (Claude Code, Codex, GitHub Copilot) to cheap providers (GLM at ~$0.6/1M, MiniMax at ~$0.2/1M) to fully free tiers (Kiro, OpenCode Free, and Google Vertex with $300 credits), ensuring zero downtime as quotas exhaust. It also provides quota tracking to maximize subscriptions before reset, multi-account round-robin load balancing per provider, automatic token refresh, and format translation between OpenAI and Claude API schemas, making it broadly compatible with virtually any CLI tool through an OpenAI-compatible /v1 endpoint. Installation is straightforward via npm (`npm install -g 9router`), which launches a dashboard where users can connect a free provider like Kiro AI (offering ~50 credits/month free including Claude 4.5, GLM-5, and MiniMax) or OpenCode Free (no authentication required), then configure their CLI tool with the local endpoint, an API key copied from the dashboard, and a model such as kr/claude-sonnet-4.5. Because the repository package is private (named 9router-app), running from source or Docker is the expected local development path, supported by both development (`npm run dev`) and production (`npm run build`/`npm run start`) workflows using environment variables. The project is distributed through npm, Docker Hub, and GitHub Container Registry (GHCR), and it maintains internationalized documentation in Vietnamese, Chinese, Japanese, Russian, Thai, and Persian. Its maturity and traction are signaled by npm download badges, Docker pull counts, a Trendshift repository badge, and an extensive community-driven collection of video guides in multiple languages (Vietnamese, English, Urdu/Hindi, Indonesian, and Persian) produced by creators like Mì AI, Build AI With Hamid, CodeVerse Soban, Mai Gia, Krisswuh, Matin SenPai, and tuanminhhole, with contributors invited to submit their own videos via pull request. The tool supports a wide array of AI coding clients including Claude Code, OpenClaw, Codex, OpenCode, Cursor, Antigravity, Cline, Continue, Droid, Roo, Copilot, and Kilo Code, and integrates OAuth-based providers alongside API-key providers. In the context of AI agents, 9Router is notable because it acts as unified infrastructure enabling agentic coding tools and automated workflows (including examples like building automated Zalo AI bots with OpenClaw) to run cost-effectively and continuously across heterogeneous model backends without hitting limits. Its combination of aggressive token compression, intelligent
ServingToolsAppscodinglocal-firstworkflow-automation
★ 23,681 total+955 this week
#79
**llmfit** is a terminal tool (written in Rust) that helps users identify which LLM models will actually run well on their specific hardware by detecting RAM, CPU, and GPU/VRAM specs and scoring hundreds of models across memory fit, speed, quality, and context dimensions. It ships with an interactive TUI (default) and a classic CLI mode, supporting multi-GPU setups, MoE architectures, dynamic quantization selection, and local runtime providers including Ollama, llama.cpp, MLX, Docker Model Runner, and LM Studio. A standout feature is its community benchmarking system: users can measure real tok/s and TTFT on their hardware and submit results as PRs directly from the TUI—no external CLI or third-party account required—so verified measurements progressively replace estimates for identical hardware configurations. The project is actively maintained, published on crates.io, installable via Homebrew, Scoop, MacPorts, pip/uv, Docker, or a curl script, and has Windows binaries signed via SignPath.io. Its relevance to GGUF stems from its support for quantization-aware model fitting and llama.cpp as a backend, making it a practical discovery and planning tool for the local LLM/GGUF ecosystem. Sister projects extend its utility into model serving and Kubernetes agent management.
ServingModelsAppslocal-firston-device
★ 30,708 total+927 this week
#80NEWPartial week
**opencodex** is an open-source, lightweight local proxy server that acts as a universal AI gateway, enabling OpenAI Codex, Claude Code, Claude Desktop, and Grok Build to route requests to virtually any large language model provider — not just the ones those clients natively support. The core idea is elegantly simple: two commands install and start the proxy, which then intercepts the Codex Responses API and translates it into whatever protocol or format the target provider expects. This means developers can use Claude, Gemini, Grok, GLM, DeepSeek, Kimi, Qwen, Ollama, or any OpenAI-compatible endpoint from within their existing Codex or Claude Code workflows without waiting for official integrations.
A standout feature is **cross-client subagent routing**: Claude Desktop can answer as Claude Opus and then hand off a subtask to a GPT-5.6 Sol subagent, while Grok Build can drive a session on Sol and call a Kimi K3 subagent — each side retaining its native UI. This multi-agent, cross-provider orchestration is rare and technically sophisticated for a community-built tool.
The proxy supports full-fidelity translation including streaming, tool calls, reasoning tokens, and image inputs in both directions. It ships with a web dashboard (accessible via `ocx gui` at `localhost:10100`) that supports 40+ built-in providers, auto-discovers models from `/v1/models` endpoints, and allows OAuth login for Anthropic, xAI, and Kimi. Providers can also be added via interactive CLI (`ocx init`) or by editing a JSON config file directly. Model routing uses a clean `provider/model` syntax, with smart auto-matching for bare model names (e.g., `claude-*` routes to Anthropic, `gpt-*` to OpenAI).
A particularly practical feature is the **ChatGPT/Codex account pool manager**: users can add multiple Codex accounts, and the proxy automatically routes new sessions to the lowest-usage healthy account, respects 5-hour, weekly, and 30-day quota windows, handles 429 cooldowns with failover, and pins existing threads to their originating account to prevent mid-conversation account switching — critical for long SSH, tmux, or mobile sessions.
The OpenAI provider layer is nuanced, distinguishing between a Codex-login pool mode (`openai`) and an API key mode (`openai-apikey`), with Pro virtual model tiers (e.g., `gpt-5.6-sol-pro`) that rewrite to base models with `reasoning.mode: "pro"` at the wire level. Reasoning effort controls — `low`, `medium`, `high`, `xhigh`, `max`, and `ultra` — are surfaced in the Codex App model picker, with `ultra` mapping to maximum reasoning plus proactive multi-agent delegation. GPT-5.6 Sol, Terra, and Luna are pre-seeded as catalog entries for accounts that can serve them.
Platform support is comprehensive: macOS (arm64/x64) via launchd, Linux (x64/arm64) via systemd, and Windows (x64) via Task Scheduler or optional WinSW native service — all without WSL. The tool requires only Node.js 18+ and bundles the Bun runtime automatically on install. It is published on npm as `@bitkyc08/opencodex` and documented in five languages (English, Korean
MCPAgentsServingmultimodallocal-firstworkflow-automation
★ 5,061 total+926 this week
#81
T3 Code is a minimal web-based GUI designed to serve as a unified front-end for AI coding agents, currently supporting Codex, Claude Code, Cursor, and OpenCode, with more providers planned. The project allows developers to interact with these agents through a single interface rather than switching between separate tools. It can be run instantly via `npx t3@latest` without installation, or installed as a desktop application on Windows (via winget), macOS (via Homebrew), or Arch Linux (via AUR). The build system relies on Vite+ (vp), a custom toolchain wrapper around Vite. The project is explicitly in a very early stage — bugs are expected, public documentation is minimal, and contributions are not yet formally accepted, though a Discord community exists for support. Its notable appeal lies in aggregating multiple leading AI coding assistants into one lightweight GUI, which aligns well with the current surge of interest in agentic coding workflows. The combination of multi-provider support, cross-platform distribution, and zero-install usage makes it a compelling early-stage tool in the AI developer tooling space.
AppsAgentsToolscodingworkflow-automation
★ 15,112 total+922 this week
#82
Cangjie-Skill is a Chinese-language open-source project that distills methodologies from books, long videos, podcasts, and interviews into structured, callable AI agent skills. Rather than producing summaries or notes, it uses a proprietary seven-stage pipeline called **RIA-TV++** — combining Mortimer Adler's analytical reading method, five parallel extractors (frameworks, principles, cases, counter-examples, terminology), a rigorous triple-verification filter (cross-domain evidence, predictive power, uniqueness, with only 25–50% pass rate), structured RIA++ construction, Zettelkasten linking, pressure testing, and final delivery as installable skill packs for Claude Code or Cursor. The project has already generated 20+ skill packs spanning investment letters (Buffett, Duan Yongping), copywriting, influence psychology, classical Chinese texts (孙子兵法, 黄帝内经, 周易), and video courses (Andrew Ng's AI for Everyone). It sits within a broader ecosystem alongside nuwa-skill (distilling people) and darwin-skill (evolving skills). The project is actively growing with community contributors and external skill repos, making it notable as a practical agent-workflow infrastructure for knowledge reuse — particularly relevant to the rising trend of agentic skill composition and retrieval-augmented decision-making.
ToolsDataAgentssynthetic-dataworkflow-automation
★ 4,801 total+908 this week
#83
Awesome Zhuiju Free is a curated, community-maintained awesome-list repository focused on providing free, ad-free resources for Chinese-language drama and film streaming (追剧, meaning "binge-watching dramas"). The project is authored by GitHub user laoma2053 and is hosted at the companion website zhuiju.me. Its core mission is to aggregate and verify high-quality, freely accessible video streaming resources for Chinese-speaking audiences, covering a wide spectrum of content discovery methods and tools. As of the latest badge update, the repository has catalogued 82 resources across eight major categories: online streaming sites (30 entries), mobile video apps (3), cloud drive search tools (4), magnet/BitTorrent resources (11), subtitle resources (3), TVBox/影视仓 shell apps (2), TVBox/影视仓 configuration endpoints (15), IPTV live stream sources (1), membership group-buying services (0 currently listed), and open-source projects (13). A defining feature of the project is its automated daily availability checking system, powered by GitHub Actions workflows. Every day around 09:00 Beijing time, the system probes each listed resource and updates its status to one of four states: accessible (🟢), restricted (🟡), inaccessible (🔴), or unchecked (⚪). Results are stored in a machine-readable reports/availability.json file, and resource metadata is maintained in resources/resources.json, making the entire dataset open and programmatically accessible. This automation distinguishes it sharply from typical navigation sites, which often go unmaintained and accumulate dead links. The project also runs a data validation workflow (validate-data.yml) to ensure structural integrity of the resource data. Community participation is a central pillar: users can submit new resources or report broken links directly via GitHub Issues using structured templates, lowering the barrier for contribution. All resources are hand-curated with a stated emphasis on being free and ad-free, and each entry carries a star-based recommendation rating. The resource list spans both domestic Chinese streaming sites and overseas-accessible platforms, with many entries noting whether a VPN or proxy (梯子) is required for access. Notable included platforms span a wide range of quality tiers, from true 4K sources like IFN and 好好看, to popular aggregators like 爱看机器人, 泥视频, PPnix, and 多瑙影视, to anime-focused sites like 青空次元. The project is licensed under Creative Commons Attribution 4.0 (CC BY 4.0), ensuring the data remains openly reusable. It has gained enough traction to appear on Trendshift's daily trending repositories chart for JavaScript, signaling active community interest and growth momentum. The repository's transparency — open data, open workflows, open contribution — positions it as a notably trustworthy alternative to opaque, ad-laden video navigation sites that dominate this niche. Its combination of automation, community curation, and broad categorical coverage makes it a practical and living reference for Chinese-speaking users seeking free, reliable drama and film streaming options across multiple access methods and device types.
AppsDataMCPvideoworkflow-automation
★ 4,661 total+874 this week
#84
Floci is a free, open-source local AWS emulator designed for development, testing, and CI pipelines, allowing developers to run AWS-compatible services entirely on their local machine without requiring a cloud account, authentication tokens, or paid feature gates. The project's core philosophy is radical simplicity and zero friction: the fastest way to get started is a single `docker compose up` or the official CLI command `floci start`, after which standard AWS SDKs, CLI tools, Terraform, CDK, OpenTofu, and test suites can be pointed at `http://localhost:4566` with no workflow changes. Floci is named after floccus, the cirrocumulus cloud formation that resembles popcorn, and its tagline — "light, fluffy, and always free" — reflects both the name and its design goals around minimal resource usage.
A major motivation for Floci's existence is the sunset of LocalStack's community edition in March 2026, which began requiring auth tokens and froze security updates for free users. Floci positions itself as the no-strings-attached alternative, and the comparison table in the README is striking: Floci starts in approximately 24 milliseconds versus LocalStack's ~3.3 seconds, consumes only ~13 MiB of idle memory versus ~143 MiB, ships as a ~90 MB Docker image versus ~1.0 GB, and is licensed under MIT rather than a restricted license. The native binary weighs in at approximately 40 MB. These performance characteristics make it particularly well-suited for CI environments where startup time and resource consumption directly affect pipeline costs and speed.
Floci supports 69 AWS services spanning a remarkably broad range of categories. Core application services include S3, SQS, SNS, DynamoDB, Lambda, IAM, KMS, Secrets Manager, and SSM. Eventing and workflow services include EventBridge, EventBridge Pipes, EventBridge Scheduler, Step Functions, CloudWatch Logs, and CloudWatch Metrics. API and identity services cover API Gateway REST, API Gateway v2, AppSync, Cognito, ACM, and Route53. Container and compute services include ECS, EC2, EKS, ECR, CodeBuild, CodeDeploy, CodePipeline, AWS Batch, Auto Scaling, Elastic Beanstalk, and ELB v2. Data, analytics, and AI services include Athena (backed by a DuckDB sidecar called floci-duck), Glue, EMR, Firehose, OpenSearch, S3 Vectors, Textract, Transcribe, and Bedrock Runtime. Database and caching services include RDS (PostgreSQL, MySQL, MariaDB with IAM auth), Neptune (graph DB via TinkerPop Gremlin Server or Neo4j for openCypher), DocumentDB (MongoDB-compatible via real MongoDB containers), MemoryDB, and ElastiCache. Messaging services include SES, Kinesis, MSK (Kafka-compatible via Redpanda), Amazon MQ (RabbitMQ via real containers), Transfer Family, and IoT Core.
A key architectural differentiator is Floci's use of real Docker-backed execution for services where fidelity matters most. Lambda, RDS, Neptune, ElastiCache, MSK, ECS, EC2, EKS, OpenSearch, and CodeBuild all run as real Docker containers rather than shallow mocks, providing much higher compatibility with production behavior. The architecture is built on JAX-RS and Vert.x for HTTP routing, with services divided into stateless, stateful, and container-backed categories. Storage backends are configurable across in-memory, persistent, hybrid, and write-ahead log (WAL) modes depending on durability requirements.
The project supports SDK integration across all major AWS SDKs
ToolsAppsMCPlocal-firston-devicesecurity
★ 17,793 total+873 this week
#85
Codex++ is an external launcher and management tool for the OpenAI Codex/ChatGPT desktop application, built with Rust 1.85+ and Tauri 2.x. Rather than patching the official app's `app.asar` or writing files to the installation directory, it operates non-invasively via the Chromium DevTools Protocol and a local auxiliary service. Its core capability is provider management, supporting four distinct modes: official login only, official login mixed with a custom API, pure API mode, and an aggregated provider mode that enables failover, per-session rotation, per-request rotation, and weighted routing across multiple API backends. Each provider can be configured with Responses or Chat Completions protocol, and the tool transparently converts Chat Completions to the Responses protocol Codex expects via a local proxy. Beyond provider switching, Codex++ delivers rich UI enhancements including session deletion and batch management, Markdown export, plugin marketplace unlocking, model whitelisting, rich-text-to-plain-text paste fixing, forced Chinese localization, session width/scroll restoration, Stepwise next-step suggestions, Upstream worktree creation, Zed Remote project integration, and user script support. All enhancements can be individually toggled. The project ships signed installers for Windows (NSIS x64), macOS Intel (x64 DMG), and macOS Apple Silicon (arm64 DMG), with in-app update checking. It has attracted multiple commercial sponsors offering API relay services for Chinese developers, suggesting active community traction. The project maintains a QQ group and Telegram channel for community support, indicating a growing Chinese developer user base and notable momentum on GitHub trending.
AppsToolsMCPcodinglocal-firstworkflow-automation
★ 26,716 total+862 this week
#86
AI Berkshire is an investment research framework that systematically encodes the methodologies of four legendary value investors—Warren Buffett, Charlie Munger, Duan Yongping, and Li Lu—into a suite of 20 AI-powered skills compatible with both Claude Code and Codex. The core premise is that asking a generic AI for investment advice yields balanced but undecidable analysis, whereas AI Berkshire enforces structured, decision-ready outputs: explicit buy/pass/gray-zone verdicts, tiered price ranges for aggressive/moderate/conservative strategies, and multi-master perspective debates that surface genuine analytical tension. The framework is organized into three layers—a Skill layer with 20 named entry points, an Agent layer where team-mode skills spawn four parallel AI agents that independently research and challenge each other before a Team Lead synthesizes conclusions, and a Tool layer that enforces financial rigor through Python decimal arithmetic, multi-source cross-validation, and market-cap spot-checks. Anti-bias mechanisms are deeply embedded: an A/B/C information-richness rating prevents false confidence, a Munger-style inversion checklist forces failure-scenario thinking, eight hard red lines trigger automatic rejection regardless of valuation, and a "blank space" principle requires explicitly flagging unknowns rather than papering over them with speculation. The project claims real live-account returns of +69.29% in 2024 and +66.38% in 2025, outperforming the S&P 500 by roughly 46 and 50 percentage points respectively, with cumulative gains exceeding 1.46 million RMB across two years. Skills span deep single-company research, parallel earnings-team analysis, industry funnel screening, supply-chain bottleneck hunting, portfolio thesis tracking and drift detection, rapid news-pulse attribution, and even WeChat article generation via a three-agent author/editor/reader workflow. Installation is straightforward via git clone plus shell scripts for both Claude Code and Codex on macOS, Linux, and Windows. The project is actively trending on GitHub (Trendshift badge present), multilingual (Chinese, English, Japanese READMEs), and accompanied by a WeChat public account for curated research. Its combination of verifiable live performance, rigorous anti-hallucination tooling, and a one-person-equals-a-research-team value proposition makes it notably compelling for AI-augmented retail and professional investors alike.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 14,261 total+862 this week
#87
OpenWiki is a CLI tool built by LangChain AI that automatically writes and maintains structured wikis for codebases or personal knowledge management, designed specifically to serve as memory and context for AI agents. It operates in two distinct modes: **Code mode**, which generates and maintains repository documentation inside an `openwiki/` directory, and **Personal mode**, which builds a local "personal brain" wiki at `~/.openwiki/wiki/` by ingesting from a variety of configurable knowledge sources. The tool is installable globally via npm or pnpm and is written with Node.js, using `better-sqlite3` for checkpointing. OpenWiki's core value proposition is that it keeps documentation continuously up-to-date by integrating with CI/CD pipelines — supporting GitHub Actions, GitLab CI, and Bitbucket Pipelines — automatically opening pull or merge requests with documentation updates on a schedule. On each code run, it also maintains both `AGENTS.md` and `CLAUDE.md` at the repository root, injecting scoped blocks that instruct coding agents to reference the wiki for context, while leaving user-authored content untouched. A key architectural feature is its **local connector system**, which supports ingestion from Git repositories, Gmail, Notion, X/Twitter, Web Search (via Tavily), Hacker News, and Slack. Connectors use OAuth flows, MCP (Model Context Protocol) for some providers like Notion, and direct API access for others. Multiple instances of the same connector type can be configured independently, enabling fine-grained ingestion control. OpenWiki emits wikis in **Google Open Knowledge Format (OKF) v0.1**, a structured Markdown-with-YAML-frontmatter standard, ensuring interoperability and consistent relationship modeling between concept documents. The tool supports a wide range of LLM inference providers out of the box, including OpenAI, Anthropic, Google Gemini (both AI Studio and Vertex AI), AWS Bedrock, OpenRouter, Fireworks, Baseten, NVIDIA NIM, and Nebius Token Factory, with support for custom model IDs and alternative base URLs for proxied or self-hosted gateways. The default onboarding model is OpenAI's `gpt-5.6-terra`. Optional LangSmith integration enables tracing of OpenWiki runs to a dedicated project. Configuration and secrets are stored locally in `~/.openwiki/.env`, and on macOS, scheduled ingestion runs are installed as LaunchAgents. The project is trending on Trendshift, signaling strong community interest. Its notable combination of agent-first design, multi-source ingestion, CI automation, open knowledge format compliance, and broad LLM provider support makes it a compelling and practically useful tool in the rapidly growing space of AI agent infrastructure and automated documentation.
ToolsRetrievalDatalocal-firstworkflow-automationcoding
★ 13,318 total+817 this week
#88
turbovec is a Rust-based approximate nearest neighbor (ANN) vector index with Python bindings, built on Google Research's TurboQuant algorithm — a data-oblivious quantizer that requires no separate training phase and achieves near-optimal distortion. Its headline claim is dramatic memory reduction: a 10-million-document corpus that would consume 31 GB as float32 fits in just 4 GB, while still searching faster than FAISS in most configurations. The core approach normalizes vectors onto a unit hypersphere, applies a random orthogonal rotation to make coordinate distributions predictable (converging to a known Beta/Gaussian distribution), then applies per-coordinate TQ+ calibration (fitting shift and scale scalars from empirical quantiles) before Lloyd-Max scalar quantization at 2-bit or 4-bit widths. Because the rotation makes the distribution data-oblivious, no training corpus is needed — vectors can be added online at any time without rebuilds or parameter retuning. Search is accelerated by hand-written SIMD kernels targeting ARM NEON and x86 AVX-512BW, beating FAISS IndexPQFastScan by 10–19% on ARM and winning 4-bit configurations on x86. A key practical feature is native filtered search: an allowlist of IDs or a slot bitmask is honored directly inside the SIMD kernel at 32-vector block granularity, short-circuiting entire blocks with no allowed slots and avoiding the over-fetching recall penalty common in post-filter approaches. The library exposes both a raw TurboQuantIndex and an IdMapIndex supporting O(1) deletes via stable external uint64 IDs. Drop-in integrations are provided for LangChain, LlamaIndex, Haystack, and Agno, replacing their default in-memory vector stores with no pipeline rewiring. Recall benchmarks on OpenAI embeddings (d=1536, d=3072) show TurboQuant beating FAISS IndexPQ by 0.2–1.9 points at R@1. The project is available on PyPI and crates.io, backed by an arXiv paper, and targets privacy-sensitive or resource
ModelsRetrievalvector-databaselocal-firston-device
★ 14,412 total+810 this week
#89
Loop Engineering is an open-source framework and CLI toolkit that shifts the paradigm of AI-assisted development from manual prompting to systematic loop design — the idea being that developers should build automated control systems that prompt their agents, rather than prompting agents themselves. The project is authored by Cobus Greyling and has gained significant traction, reaching 5,500+ GitHub stars as of early July 2025, signaling strong community interest in the agentic AI space. The core philosophy, endorsed by notable figures like Boris Cherny (Head of Claude Code at Anthropic) and Peter Steinberger, is that the leverage point in AI development has moved from crafting individual prompts to designing orchestration loops that run continuously and autonomously. The toolkit scaffolds five key primitives — automations/scheduling, worktrees, skills, state, and memory — into production-ready patterns that work across multiple AI coding tools including Grok, Claude Code, Codex, Cursor, and Opencode. The unified CLI entry point (`@cobusgreyling/loop`) provides commands like `loop init`, `loop doctor`, `loop audit`, and `loop status`, with a quantified "Loop Ready Score" that climbs from 0 to 100 as the system becomes more complete and production-hardened. Supporting packages include `loop-audit` for readiness scoring, `loop-init` for scaffolding, `loop-cost` for token spend estimation, `loop-sync` for drift detection between state files, `loop-context` for stateful memory management with circuit-breaker logic, `loop-mcp-server` for MCP runtime pattern lookup, `loop-worktree` for isolated git worktree management per fix attempt, and `loop-gate` for mechanical enforcement of path denylists and auto-merge rules. The project sits within a broader companion ecosystem: `memory-engineering` handles persistent agent memory across sessions, `harness-foundry` provides a versioned runtime stack with traces, `outerloop` delivers governance via evidence-to-verdict pipelines, `goal-engineering` bridges loops to goal completion, and `fleet-engineering` governs populations of agents with registries, inboxes, and kill switches. Seven production-ready loop patterns are available with an interactive picker hosted on GitHub Pages, and clone-and-run starter kits exist for each supported tool. The project is MIT-licensed, actively maintained with regular npm releases, and has an engaged contributor community with open good-first issues. Its notable trend signal comes from the convergence of agentic AI adoption, the growing need for structured agent orchestration beyond ad-hoc prompting, and endorsements from high-profile practitioners at Anthropic. The ecosystem stack metaphor — memory → design → runtime → govern → fleet — positions Loop Engineering as the central design layer in a full agentic operations pipeline, making it a compelling reference architecture for teams scaling
AgentsToolsMCPcodingworkflow-automationsynthetic-data
★ 9,455 total+764 this week
#90
`codex-keysmith` is a zero-runtime-dependency, single-file Python CLI (currently at source version v0.1.1) designed for versioned deployment of Codex instruction files into an existing Codex CLI configuration directory. Its core function is to deploy either a bundled or custom Markdown instruction file into a target `.codex` directory, conservatively updating the top-level `model_instructions_file` key in `config.toml` only when the value actually needs to change. A defining characteristic of the tool is its safety-first, preview-oriented design: by default it never writes anything, so normal deployment, uninstall, and interruption-recovery operations only produce a dry-run preview unless the user explicitly passes `--yes`. The dry-run output lists the target Markdown, the `config.toml` changes required, active and disabled hooks, exact-match legacy files, and full timestamped backup/archive paths, while clearly marking configs that need no backup. A key architectural feature is hook isolation: on a confirmed deployment, the tool backs up and moves the entire active `hooks.json` to `hooks.json.disabled`, pausing all hooks until they are explicitly restored via a restore command. Deployment and uninstall both publish a durable transaction journal before the first mutation, so interruptions such as `SIGKILL` can be inspected and recovered through an explicit `--recover` flow. The tool maintains a fingerprinted ownership manifest (`.codex-keysmith-manifest.json`) recording deployed MD/config values, actually isolated hooks, actually archived legacy files, backups, and prior manifest layers, enabling layered uninstall. The `--status` command performs a read-only structural health check reporting deployability, uninstall readiness, and structural health, and fails closed if durable journals or transaction residue exist; it hashes manifest-referenced backup recovery evidence but does not read or parse live hook contents. The project emphasizes an important global behavior boundary: a confirmed deployment alters the top-level `model_instructions_file`, so the instruction applies to every new Codex session loading that configuration rather than being a per-project sandbox. The tool explicitly does not patch Codex binaries, intercept network traffic, or store credentials. A prominent warning surrounds the bundled prompt: the v0.1.1 source embeds a byte-identical prompt (`examples/gpt-unrestricted.md`, SHA-256 `2c2c9f0e...`) that directs the model to answer without refusal framing, reinterprets reverse-shell/keygen/bypass requests as local fixtures, covers adult and consent-sensitive fiction plus chemistry/pharmacology/weapons guides, and gives its execution mode precedence over injected context—users are urged to inspect this prompt or supply their own via `--file`. Regarding maturity, the project treats provenance seriously: only checkouts bound to immutable signed/annotated tags with verified Release assets and matching `SHA256SUMS` count as official releases, while floating-branch checkouts are treated as candidates. A reproducible candidate build script (`scripts/build_release.py`) compares archive inputs byte-for-byte against verified commit blobs and rejects builds even when Git index tricks like `assume-unchanged` or `skip-worktree` hide worktree drift. Recommended runtime is Python 3.10–3.14 using only the standard library, with Python 3.9 retained for compatibility tests but treated as EOL. The verified Codex CLI version is `codex-cli 0.144.1`. Platform support centers on macOS and Linux, where users are directed to download signed v0.1.0 Release assets, verify them with `SHA256SUMS`, and avoid `curl | python`. Windows carries important caveats: v0.1.0 is declared "known-bad" for fresh deployment because it can trigger cascading `PermissionError
ToolsAppsSafetylocal-firstcodingsecurity
★ 1,786 total+746 this week
#91
Khazix Skills is a personal, open-source collection of six battle-tested AI agent skills built and daily-used by the author (KKKKhazix), all conforming to the AgentSkills open standard and compatible with 40+ agents including Claude Code, Codex, Cursor, and Kimi Code. The six skills cover: **leader** (transforms vague ideas into structured, long-horizon goal documents for autonomous AI execution); **storage-analyzer** (scans Mac/Windows disks and generates an interactive HTML report with color-coded cleanup recommendations); **aihot** (fetches daily AI news digests from aihot.virxact.com without API keys); **neat-freak** (post-task cleanup that syncs docs, CLAUDE.md/AGENTS.md, and agent memory to reflect actual project state); **hv-analysis** (dual-axis vertical/horizontal deep research producing 10,000–30,000 word PDF reports); and **khazix-writer** (replicates the author's personal WeChat public account writing style with strict anti-cliché rules). Each skill is a structured SKILL.md instruction set installable via a single natural-language command. The project is actively maintained, practically motivated, and notable for demonstrating real-world agentic workflow patterns across coding, research, writing, and system management domains.
ToolsAgentsAppscodingworkflow-automationsynthetic-data
★ 18,129 total+738 this week
#92
`kepano/obsidian-skills` is a collection of agent skills designed to extend AI coding agents with deep knowledge of Obsidian, the popular note-taking application. The project follows the Agent Skills specification (agentskills.io), making these skills portable across multiple compatible agents including Claude Code, Codex, and OpenCode. Installation is flexible, supporting a marketplace command, `npx skills`, or manual setup tailored to each agent's directory conventions. The five included skills cover Obsidian Flavored Markdown (wikilinks, embeds, callouts, properties), Obsidian Bases (views, filters, formulas), JSON Canvas file editing, Obsidian CLI interaction for plugin and theme development, and Defuddle-based web content extraction for token-efficient markdown conversion. The project is notably authored by kepano, the creator of Obsidian's Minimal theme and Defuddle, lending it credibility within the Obsidian ecosystem. Its cross-agent compatibility and alignment with an emerging open specification make it a notable early example of reusable, portable AI agent tooling — a trending pattern as agentic development workflows mature rapidly.
ToolsAgentsMCPcodingworkflow-automation
★ 43,403 total+731 this week
#93
FreeLLMAPI is an open-source aggregation layer that exposes a single OpenAI-compatible `/v1` API endpoint on top of 28 free LLM providers, spanning roughly 235 model families and 339 free model endpoints that together add up to approximately 4 billion tokens per month of inference capacity. The core problem it solves is that individual free tiers from AI labs are small and painful to combine by hand—each has its own SDK, rate limits, and failure modes—so FreeLLMAPI collapses all of them behind one interface. Users point any OpenAI-compatible client library at their local server, and the router transparently routes requests across whichever providers they've added keys for. A key differentiator is a self-updating, signed model catalog synced from freellmapi.co twice a day, so new models, quota changes, and provider quirk fixes land automatically without a `git pull`. The project supports major providers including Google (Gemini), Groq (Llama, GPT-OSS, Qwen3), Cerebras, OpenCode Zen, Mistral, OpenRouter, Cloudflare, Cohere, Z.ai/Zhipu (GLM models), NVIDIA NIM, and HuggingFace, plus a custom provider for any OpenAI-compatible endpoint like llama.cpp, LM Studio, vLLM, or Ollama for chat, embedding, image, or audio models. Feature-wise, it is broad and mature: it implements the OpenAI chat completions and models endpoints, the Responses API (required by current Codex CLI versions) as a translating shim, a legacy completions endpoint for editor autocomplete (Continue ghost-text), and the Anthropic Messages API so Claude Code and Anthropic SDKs can run against the free pool with content-negotiated model listings. A notable "Fusion" feature fans a prompt out to a panel of diverse free models in parallel, then uses a judge model to synthesize a single answer, with configurable panel, judge, and strategy. It supports image generation and text-to-speech routing, streaming (SSE) and non-streaming responses, OpenAI-style tool calling with automatic rescue of text-emitted tool calls into structured JSON, structured outputs (json_object/json_schema translated to Gemini's responseSchema), and full sampling parameter passthrough (seed, top_k, min_p, penalties, logit_bias, logprobs) with per-provider dropping of unsupported params. Embeddings routing is family-based with strict same-model failover to preserve vector compatibility. Reliability is a major focus: automatic failover on 429/5xx/timeout errors with cooldowns and up to 20 retry attempts bounded by a wall-clock budget, sibling key rotation for dead keys, and full attempt trails on exhaustion. Its smart routing offers six selectable strategies (priority, balanced, smartest, fastest, reliable, custom) driven by live per-model measurements and a Thompson-sampling bandit. Unified models collapse the same logical model served by multiple providers into one entry with in-group failover, and model profiles let users save named fallback chains for coding, long-context, or vision use cases. Per-key rate tracking maintains RPM, RPD, TPM, and TPD counters per platform/model/key and even learns tighter ceilings from provider error bodies and quota headers. Sticky sessions keep multi-turn conversations on the same model for 30 minutes to avoid mid-conversation hallucination spikes, and an opt-in in-memory LRU response cache offers exact-match caching with SHA-256 keys, TTL/temperature gates, and zero provider quota on hits. Security is emphasized: provider API keys are encrypted with AES-256-GCM before hitting SQLite and decrypted only in memory; clients authenticate with a single unified `freellmapi-…` bearer token so upstream keys are never exposed. There is bulk key import/export (.env, JSON, CSV), periodic health checks that classify keys as healthy/rate_limited/invalid/error, and a React + Vite admin dashboard for managing keys, re
ServingMCPToolsmultimodallocal-firstsecurity
★ 17,114 total+683 this week
#94NEWPartial week
Buzz is a self-hostable collaborative workspace built by Block (formerly Square) that enables humans and AI agents to work together in shared rooms, all underpinned by a Nostr relay where every action — messages, reactions, code patches, CI results, workflow steps, and approvals — is a cryptographically signed event in a single unified log. The core architectural bet is that one substrate (a Rust-powered relay backed by Postgres, Redis, and S3/MinIO) can replace the fragmented stack of chat tools, code forges, CI dashboards, bots, and release tooling that modern teams currently stitch together. Agents in Buzz are treated as first-class members with their own cryptographic keypairs, channel memberships, and audit trails — not background bots or cron jobs — meaning they can open repos, send patches, review code, run workflows, edit canvases, orchestrate other agents, and join voice huddles with the same affordances as human teammates. The project uses the Nostr protocol (NIP-01, NIP-34, NIP-42/98) for identity and event signing, and ships a desktop client built with Tauri and React, a `buzz-cli` designed for LLM tool calls (JSON in/JSON out), and an ACP harness supporting Goose, Codex, and Claude Code. The codebase is a Rust workspace of focused crates covering core protocol, auth, pub/sub, full-text search, audit logging, git integration, and agent persona packs. Currently functional features include channels, threads, DMs, canvases, media with frame-anchored comments, YAML-based workflows, git event support, and a git hosting backend; mobile clients (Flutter), workflow approval gates, and push notifications are in progress. The project is early-stage but architecturally opinionated, Apache 2.0 licensed, and notable for its sovereign self-hosting model, deep agent integration, and unified event-log approach to developer collaboration. It is trending likely due to growing interest in agen
AgentsAppsMCPworkflow-automationcodingsecurity
★ 13,570 total+667 this week
#95
OpenLogi is a native, local-first, open-source alternative to Logitech Options+, written in Rust, that communicates with Logitech HID++ peripherals over Logi Bolt, Unifying receivers, Bluetooth, and USB — without requiring a Logitech account or telemetry. It supports full button remapping, DPI control and presets, SmartShift wheel configuration, per-device scroll inversion, RGB keyboard lighting, and per-application profile switching, all stored in a plain TOML config file. The project is structured into three components: a GPUI-based desktop GUI with an interactive mouse diagram and clickable hotspots, a background agent handling all device I/O via HID++, and a CLI for headless inventory and diagnostics including DPI/SmartShift round-trip testing. It runs on macOS, Linux, and Windows, with Linux treated as a first-class platform via evdev/uinput, udev rules, systemd units, and native packages (.deb/.rpm/.pkg.tar.zst). The project is under active development but already feature-rich, trending on Trendshift for Rust repositories, and notable for being the only cross-platform, privacy-respecting, scriptable replacement for Options+ that supports Linux and gesture-button reassignment. It is dual-licensed under MIT and Apache 2.0.
AppsToolslocal-firston-devicesecurity
★ 7,626 total+663 this week
#96
The `openai/codex-plugin-cc` repository provides an official OpenAI plugin that integrates Codex directly into Claude Code, allowing developers to run AI-powered code reviews and delegate tasks without leaving their existing Claude Code workflow. The plugin exposes several slash commands: `/codex:review` for standard read-only code reviews, `/codex:adversarial-review` for steerable, design-challenging reviews that pressure-test assumptions and tradeoffs, and `/codex:rescue` to hand off bug investigations or fixes to Codex as a subagent. Additional commands — `/codex:transfer`, `/codex:status`, `/codex:result`, and `/codex:cancel` — enable session handoffs, background job monitoring, and task cancellation. All commands support background execution, making long-running reviews and investigations non-blocking. The plugin wraps the local Codex CLI and app server, reusing existing authentication, configuration (via `config.toml`), and repository context. An optional review gate feature uses a `Stop` hook to automatically trigger a Codex review before Claude finalizes a response, though it carries a warning about potential usage drain. Requirements include Node.js 18.18+ and either a ChatGPT subscription or OpenAI API key. The project is notable for bridging two major AI coding tools — Anthropic's Claude Code and OpenAI's Codex — reflecting a cross-ecosystem trend in AI developer tooling interoperability.
MCPToolsAgentscodingworkflow-automation
★ 30,018 total+655 this week
#97
Tutti is an open-source, real-time shared workspace designed to eliminate the friction of coordinating multiple AI agents across complex workflows. Rather than forcing users to manually copy context, paste outputs, and re-explain requirements between tools like Claude Code, Codex, and Canvas, Tutti provides a unified environment where agents, files, apps, and tasks are all interconnected and visible simultaneously. The core problem it addresses is that users have become "messengers" between powerful but siloed AI agents — Tutti aims to make agents genuinely collaborative without human hand-holding at every handoff. Its three headline features are: a real-time shared workspace with a "Big @" system for referencing past conversations, files, app outputs, and even other agents' work across sessions; a built-in app ecosystem (image generation, UI/UX design, docs, presentations) that both users and agents can invoke directly, eliminating the download-upload-paste cycle; and productivity tools like goal-to-task breakdown and a Control Center dashboard that surfaces all pending agent actions in one view. Tutti integrates with users' existing subscriptions to Claude Code, Codex, and Hermes, adding no extra model cost. It currently supports macOS with Windows coming soon. A cloud-based tier called Tutti · VM is in development, which will extend the shared workspace across multiple devices and multiple collaborators via multi-layer virtualization, keeping agent state synchronized in the cloud while agents still run locally. The project is newly open-sourced under the Apache 2.0 license, has an active Discord community, and supports multiple languages including English, Simplified Chinese, and Traditional Chinese. Its notable angle — treating the human-agent coordination layer as a first-class infrastructure problem — positions it as a potentially significant tool in the rapidly growing AI developer tooling space, making it a strong candidate for GitHub trending visibility.
AgentsAppsworkflow-automationlocal-firstmultimodal
★ 3,061 total+652 this week
#98
The `vercel-labs/skills` repository is a CLI tool designed to power an open agent skills ecosystem, enabling developers to install, manage, and share reusable instruction sets — called "skills" — across a wide variety of AI coding agents. Skills are defined in `SKILL.md` files with YAML frontmatter specifying a name and description, and they extend an agent's capabilities with specialized tasks such as generating release notes from git history, creating pull requests following team conventions, or integrating with external tools like Linear and Notion. The CLI supports over 74 named coding agents, including prominent ones like Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, Gemini CLI, Goose, Cline, Continue, and many more, making it a broadly interoperable tool across the AI developer tooling landscape.
Installation is straightforward via `npx skills add`, and the tool supports a rich variety of source formats: GitHub shorthand, full GitHub URLs, direct paths to specific skills within a repo, GitLab URLs, arbitrary git URLs, and local file paths. Skills can be installed at either project scope (committed alongside code and shared with a team) or global scope (available across all projects), and can be symlinked for a single source of truth or copied for environments where symlinks are unsupported. The CLI also supports non-interactive, CI/CD-friendly installation via flags like `--yes` and `--all`.
Beyond installation, the CLI offers a full suite of management commands: `skills list` to view installed skills, `skills find` for interactive or keyword-based discovery (with fzf-style search), `skills update` to pull the latest versions, `skills remove` to uninstall from specific agents or scopes, `skills use` to generate and pipe a skill prompt directly to an agent without permanently installing it, and `skills init` to scaffold a new SKILL.md template. The `skills use` command is particularly notable for its composability — it writes skill files to a temporary directory and either prints the generated prompt to stdout or launches a supported agent interactively.
The project appears to be in an active, early-but-functional state, originating from Vercel Labs, which signals strong institutional backing and a forward-looking focus on the rapidly growing AI coding agent space. Its breadth of agent support — spanning tools from Anthropic, OpenAI, Google, GitHub, JetBrains, and dozens of independent developers — positions it as a potential standard or hub for the emerging agent skills ecosystem. A companion discovery platform at skills.sh further enhances its ecosystem ambitions. Its appearance on GitHub Trending reflects strong community interest in tooling that bridges multiple AI agents under a unified, portable skill-sharing standard.
ToolsMCPAgentscodingworkflow-automation
★ 27,279 total+636 this week
#99
Cockpit Tools (jlcodes99/cockpit-tools) is a universal AI IDE account management desktop application designed to help users efficiently manage multiple accounts across a wide range of AI coding platforms simultaneously. The tool currently supports sixteen platforms: Antigravity IDE, Codex, GitHub Copilot, Windsurf, Kiro, Cursor, Grok CLI, CodeBuddy, CodeBuddy CN, Qoder, Trae, TRAE SOLO, Trae CN, TRAE SOLO CN, Zed, and ZCode. Its core value proposition centers on one-click account switching, multi-account multi-instance parallel execution, real-time quota monitoring, automated wakeup tasks to trigger quota resets, and plugin interoperability via a local WebSocket service. Each supported platform receives dedicated management features including OAuth authorization, token/JSON import, subscription plan recognition, quota visualization with progress bars, batch operations, and independent instance isolation with separate user directories and launch parameters. The application ships with a unified visual dashboard providing at-a-glance status across all sixteen platforms. It supports 18 interface languages and runs natively on macOS, Windows, and Linux, with installation via GitHub Releases or Homebrew on macOS. From a security standpoint, all account data is stored locally on the user's machine with no proprietary cloud backend; the WebSocket service listens only on localhost (127.0.0.1, port 19528) and can be disabled. Grok CLI credentials are stored as plaintext JSON protected by OS-level file permissions. The project appears actively developed and feature-rich, making it notable for power users who juggle multiple AI IDE subscriptions to maximize free-tier quotas across accounts — a trend increasingly common as AI coding tools proliferate. Sponsors include APIKEY.FUN and RoxyBrowser, suggesting commercial ecosystem interest around the tool.
ToolsAppsMCPlocal-firstcodingworkflow-automation
★ 14,480 total+619 this week
#100
Guizang PPT Skill is an AI-agent-native skill for generating single-file HTML horizontal-swipe presentations, illustrated slides, and multi-platform cover images, designed specifically for Claude Code and Codex agent environments. The project offers two distinct visual systems: Style A ("Electronic Magazine × E-Ink"), inspired by editorial publications like Monocle, suited for narrative and personal expression; and Style B ("Swiss International Style"), a strict grid-based system with 22 locked layouts, single high-saturation anchor colors, hairline rules, and no shadows or gradients, suited for factual, product, and methodology content. Installation is frictionless via a single `npx skills add` command or by instructing any shell-capable AI agent directly. Style B includes a script-based layout validator (`validate-swiss-deck.mjs`) and optional Playwright-based rendering checks for overflow, whitespace, and title spacing, reflecting a strong emphasis on quality control. The Codex integration enables AI-generated imagery via GPT-Image 2.0 and GPT-M 2.0, covering documentary photos, infographics, UI mockups, and screenshot redesigns, all bound to template aspect ratios. The project is actively sponsored by 360 Claw, Kimi Work, and Cola Skill, and backed by Zhenfund Token Grant, indicating real commercial traction. It is notable for treating HTML as a superior agent-editable format over traditional PPTX, enabling lightweight single-file delivery with no build step. Created by Chinese creator Guizang (歸藏) from real offline presentation experience, the repo is trending in the AI-agent tooling space due to its structured workflow, dual visual systems, and deep agent-platform integrations.
ToolsAppsAgentsmultimodalcodingvision
★ 22,451 total+612 this week
#101
Obsidian Mind is an open-source Obsidian vault template designed to give AI coding agents persistent, compounding memory across sessions. The core problem it addresses is that AI agents like Claude Code, Codex CLI, and Gemini CLI start every session with zero context — no awareness of ongoing projects, past decisions, team dynamics, or personal wins. Obsidian Mind solves this by turning an Obsidian vault into a structured, agent-readable knowledge base that persists and grows over time, so every new conversation builds on everything that came before.
The project's approach centers on a clean architectural separation: procedural hook scripts handle deterministic tasks like classification, validation, indexing, and lifecycle injection, while the AI agent handles judgment-heavy tasks like writing notes, filing them, linking them, and drafting briefs. Hooks written in TypeScript run via Node's `--experimental-strip-types` flag and are compatible across Claude Code, Codex CLI, and Gemini CLI using the same vault structure and commands. This multi-agent compatibility is a notable design goal — one vault works with all three major CLI agents without modification.
Memory is organized vault-first: all durable knowledge lives in `brain/` topic notes that are git-tracked, Obsidian-browsable, and interlinked. Claude Code's `MEMORY.md` file acts as an auto-loaded index pointing to vault locations rather than storing content itself, meaning memories survive machine changes and remain part of the knowledge graph. Folders group notes by purpose (work, people, decisions, performance), while Obsidian wiki-links group them by meaning, forming a graph the agent actively maintains and extends.
Sessions follow a designed lifecycle. A `SessionStart` hook automatically injects the user's North Star goals, active projects, recent git changes, open tasks, and a full vault file listing so the agent begins every session with rich context. Slash commands like `/om-standup`, `/om-dump`, `/om-incident-capture`, and `/om-wr` (wrap-up) drive structured workflows: morning kickoffs, brain dumps after meetings, incident response timelines, and end-of-day reviews that verify links, update indexes, and surface uncaptured wins via a `brag-spotter` subagent.
A standout optional feature is QMD semantic search integration. QMD runs three small models entirely locally — a 300MB embedding model, a 1.7B query-expansion model, and a 0.6B reranker — requiring no API key, no per-query cost, and functioning fully offline with GPU offload support for CUDA and Apple Silicon Metal. QMD is registered as a Model Context Protocol (MCP) server, exposing typed tools (`mcp__qmd__query`, `mcp__qmd__get`, `mcp__qmd__multi_get`) directly in the agent's tool menu alongside standard Read and Edit operations. This enables semantic recall — finding notes by meaning even when titles share no keywords with the query. Without QMD, the vault gracefully falls back to grep and the Obsidian CLI, so nothing breaks.
Installation is offered via ShardMind, a purpose-built package manager for Obsidian vault templates. ShardMind runs an interactive wizard that personalizes the vault with the user's name, organization, goals, and preferred agents, then initializes git and optionally bootstraps QMD. Critically, ShardMind is described as purely additive — deleting its sidecar files leaves a fully functional vault, and a default install is byte-equivalent to a plain `git clone`, preserving familiar developer UX.
The project supports four languages in its README (English, Japanese, Chinese, Korean), signals broad international reach. It requires Obsidian 1.12+, Node 22+ LTS, Git, and one of the three supported AI CLI agents. The vault is MIT-licensed and appears to be an early but thoughtfully engineered project, notable for its multi-agent compatibility, offline-first semantic search
ToolsRetrievalAgentslocal-firstvector-databasecoding
★ 4,008 total+600 this week
#102
Claude SEO is an open-source SEO analysis plugin built specifically for Claude Code, Anthropic's AI-powered coding and agentic assistant. Created by Daniel Agrici, the project transforms Claude Code into a comprehensive SEO auditing platform by introducing 25 sub-skills and 18 specialist agents that execute in parallel across a wide range of SEO domains. These domains include technical SEO, content quality assessment via E-E-A-T (Experience, Expertise, Authoritativeness, Trustworthiness), Schema.org structured markup, AI search optimization (referred to as GEO — Generative Engine Optimization), local SEO, e-commerce SEO, and international SEO with hreflang support. Every audit concludes with a prioritized, actionable plan where each recommendation is grounded in primary-source guidance from Google and carries explicit falsifiability checks — meaning users can verify whether a recommendation succeeded or failed using defined leading indicators.
One of the project's most distinctive design choices is its AI-search-first orientation. Claude SEO aligns with Google's AI Optimization Guide, incorporates question-based citability scoring, checks for llms.txt primary-source evidence, handles IPTC TrainedAlgorithmicMedia metadata for AI-generated product images, and performs agent-friendly page checks per web.dev standards. This positions the tool ahead of most traditional SEO platforms, which have been slow to adapt to the rise of AI Overviews, generative search engines, and LLM citation tracking. The parallel execution model is central to performance: full site audits can spawn up to 15 specialist agents simultaneously, reducing audit time from hours to minutes.
The tool is invoked through 32 user-facing slash commands within Claude Code, organized around an orchestrator and eight categories of sub-skills. Key commands include `/seo audit` for full-site parallel audits, `/seo page` for deep single-page analysis, `/seo schema` for Schema.org detection and validation, `/seo geo` for AI search optimization, `/seo content` for E-E-A-T analysis, `/seo local` for local SEO and Google Business Profile auditing, `/seo drift` for SQLite-backed SEO change monitoring over time, and `/seo ecommerce` for marketplace intelligence. Eight MCP extensions further expand capability, integrating with third-party platforms including Firecrawl for full-site crawling, DataForSEO for live SEO data, Ahrefs for backlink and keyword data, SE Ranking for AI share-of-voice tracking across ChatGPT, Gemini, Perplexity, and AI Overviews, Profound for LLM citation time-series tracking, Bing Webmaster Tools with IndexNow URL submission, and Unlighthouse for multi-page Lighthouse runs.
Core Web Vitals coverage is thorough and up to date: the tool measures LCP (target under 2.5 seconds), INP (target under 200ms, which replaced FID in March 2024), and CLS (target under 0.1), pulling field data from the Chrome User Experience Report (CrUX) and falling back to Lighthouse lab data via PageSpeed Insights. CrUX History spanning 25 weeks is included in the free credential tier. E-E-A-T evaluation is benchmarked against Google's Search Quality Rater Guidelines, last updated September 2025, with expanded YMYL coverage including political and social topics.
Installation is straightforward via Claude Code's plugin marketplace (requiring version 1.0.33 or later), or through manual git clone with shell scripts for Unix/macOS/Linux and PowerShell for Windows. The setup process creates an isolated Python environment and installs Playwright Chromium without touching global system packages. A `/seo doctor` command lets users verify runtime readiness at any time.
The project targets three primary audiences: SEO agencies managing five or more client sites who want to replace quarterly deep audits with weekly automated runs; in-house SEO leads at SaaS, publisher, or e-commerce companies seeking a second-pair-of-eyes before executive reviews; and freelance SEO consultants who want to anchor client engagements with fast, credible, scored audits. The README includes a real Google Search Console screenshot showing organic growth for a site launched March 23, 2026 and run on this workflow through June 2026, offering early evidence of real-world effectiveness
ToolsAgentsMCPworkflow-automationbrowser-use
★ 12,420 total+599 this week
#103
Paperclip is an open-source, self-hosted orchestration platform built with Node.js and React that enables individuals and teams to manage entire organizations of AI agents as if running a real company. Rather than treating AI agents as isolated tools, Paperclip positions itself as the "company" layer sitting above individual agents — using the analogy that if OpenClaw is an employee, Paperclip is the company itself. Users define high-level business goals (e.g., "Build the #1 AI note-taking app to $1M MRR"), assemble a team of AI agents filling roles like CEO, CTO, engineer, designer, and marketer, then approve a strategy, set budgets, and let the system run autonomously while monitoring everything from a unified dashboard. The platform is deliberately designed to feel like a task manager on the surface, while concealing sophisticated infrastructure underneath: org charts, budget enforcement, governance gates, goal alignment, heartbeat scheduling, and full audit trails. Paperclip is built around four core pillars — an Agentic Task Manager, an Org Chart for Agents, Agent Employee Training, and an Agentic OS — each addressing a distinct layer of what it takes to run a functioning AI-powered organization. It supports a broad range of agent runtimes and tools, including OpenClaw, Claude Code, Codex, Cursor, Bash scripts, and HTTP-based agents, operating on the principle that "if it can receive a heartbeat, it's hired." Key technical differentiators include atomic task checkout and budget enforcement to prevent double-work and runaway costs, persistent agent state across heartbeat cycles, runtime skill injection without retraining, goal-aware task execution where agents always understand the "why" behind their work, governance with rollback capabilities, portable company templates with secret scrubbing, and true multi-company data isolation from a single deployment. The platform addresses real pain points that power users of AI coding agents face today: losing track of dozens of simultaneous Claude Code sessions, manually re-injecting context, uncontrolled token spend, and lack of structured coordination between agents from different providers. Paperclip replaces ad hoc folder-based agent configs with a structured system offering ticketing, delegation hierarchies, approval workflows, scheduled routines via heartbeats, and mobile-ready monitoring. The project is licensed under MIT, is actively community-supported via Discord and Twitter, and is positioned at the frontier of the emerging "agentic company" paradigm — making it highly relevant to the current GitHub trending landscape where multi-agent orchestration and autonomous AI workflows are among the hottest topics. Its ambition to abstract away agent management complexity into a familiar organizational metaphor, combined with broad provider compatibility and enterprise-grade governance features, makes it a notably ambitious and timely open-source project.
AgentsAppsworkflow-automationlocal-first
★ 74,827 total+598 this week
#104
**video-use** is a fully open-source AI-powered video editing tool from the browser-use organization that lets users edit raw footage by chatting with Claude Code (or compatible agents), producing a finished `final.mp4` without traditional editing software. Its core innovation is that the LLM never watches video frames directly — instead it "reads" video through word-level transcripts (via ElevenLabs Scribe) packed into ~12KB markdown files, with on-demand visual composites (filmstrip + waveform PNGs) generated only at decision points, dramatically reducing token overhead versus naive frame-dumping. Key features include filler-word removal, auto color grading, 30ms audio fades, customizable subtitle burning, parallel animation overlay generation via HyperFrames/Remotion/Manim, self-evaluating render loops (up to 3 fix cycles), and persistent session memory. The pipeline follows a strict Ask→Confirm→Execute→Self-Eval→Persist flow. The project is early-stage but technically ambitious, drawing an explicit analogy to browser-use's structured DOM approach. It's trending likely due to the novelty of agent-driven video editing, its zero-UI philosophy, and the growing interest in Claude Code as an agentic shell tool.
ToolsAppsAgentsvideomultimodalbrowser-use
★ 17,880 total+598 this week
#105
Agnes AI is an OpenAI-compatible API gateway and model catalog developed by AgnesAI Labs, offering developers unified access to multimodal AI models spanning text, vision, image generation, and video generation. The platform exposes four primary models: `agnes-2.0-flash` (text and vision-language with 256K context, tool calling, and agent workflows), `agnes-image-2.0-flash` and `agnes-image-2.1-flash` (text-to-image and image editing), and `agnes-video-v2.0` (asynchronous text-to-video and image-to-video generation). Integration is straightforward via the OpenAI Python SDK or raw HTTP, making migration from existing OpenAI-based stacks minimal. The repository serves as the official documentation hub, including a model catalog, changelog, error code guides, FAQ, and bilingual (English/Chinese) support resources. Access tiers range from Free to Enterprise and Token Plans, with RPM and quota limits documented as of June 2026. Notable for its broad multimodal scope, OpenAI drop-in compatibility, and structured developer documentation, Agnes AI appears to be an emerging commercial AI API platform targeting developers building production agent and generative media workflows.
ServingAppsAgentsmultimodalvisionvideo
★ 1,886 total+595 this week
#106
JiuwenSwarm is an open-source multi-agent collaboration framework designed to automate complex tasks through natural language intent, swarm-based coordination, and self-evolving skills. Its core architecture features a Leader agent that dynamically decomposes tasks, assembles specialized agent teams, and orchestrates multi-stage workflows (Swarmflow), including human-in-the-loop support. A standout capability is Skill Self-Evolution, where the system automatically detects errors and user dissatisfaction to iteratively optimize agent skill definitions — making it grow smarter with use rather than remaining static. The project supports distributed deployment across processes and machines, breaking single-machine compute limits, and offers a Swarm Skills Hub for sharing and remixing reusable skill assets. It is compatible with multiple inference backends including Huawei Cloud MaaS, OpenAI, DeepSeek, DashScope, SiliconFlow, and local models, and supports desktop (Windows/macOS), CLI, and TUI interfaces. Released as v0.2.1 in mid-2026, it is actively developed with roadmap items like Feishu human-AI mixed-squad integration. Its combination of autonomous evolution, distributed swarm intelligence, and broad platform compatibility makes it a notable emerging project in the agentic AI space.
AgentsToolsServingworkflow-automationlocal-firstsynthetic-data
★ 1,778 total+565 this week
#107
CloakBrowser is a stealth-focused browser automation tool that ships a modified Chromium binary designed to pass virtually every major bot-detection test. Its core differentiator is that fingerprints are altered at the C++ source-code level and compiled directly into the binary, rather than being applied through JavaScript injection or runtime flag tweaks. The project's premise is that because the modifications happen inside a real Chromium build, anti-bot systems score it as a genuine browser—since, functionally, it is one. This contrasts sharply with tools like playwright-stealth, undetected-chromedriver, and puppeteer-extra, which inject JavaScript or tweak configs and tend to break with each Chrome update because the patches themselves become detectable. CloakBrowser positions itself as a drop-in replacement for both Playwright and Puppeteer across Python and JavaScript, requiring only an import swap—advertised as "3 lines of code, 30 seconds to unblock." The stealth Chromium binary (~200MB) auto-downloads and caches locally on first run, selecting a free or Pro build depending on the user's license.
The latest release, v0.5.2, is built on Chromium 150.0.7871.114.3 and includes 71 source-level C++ patches covering canvas, WebGL, audio, fonts, GPU, screen, WebRTC, network timing, automation signals, and CDP input behavior. A key feature is the humanize=True flag, which makes mouse movements (via Bézier curves), keyboard timing (per-character typing), and scrolling behave like a real user to defeat behavioral detection. Other notable capabilities include geoip=True (auto-matching timezone and locale to a proxy's exit IP), WebRTC IP spoofing, native SOCKS5 and HTTP proxy support with inline credentials, proxy signal removal (zeroing DNS/connect/SSL timing and stripping proxy cache and Proxy-Connection headers), persistent profiles that retain cookies and localStorage across sessions, Windows native GPU passthrough (using real hardware values instead of spoofed ones), Chrome extension loading via extension_paths, and per-call human_config overrides. The tool auto-generates a random fingerprint seed at startup, so it is stealthy even with zero configuration.
Distribution spans multiple ecosystems: pip install cloakbrowser for Python, npm install cloakbrowser for Node.js (with Playwright or Puppeteer), a community-maintained .NET/C# NuGet package (CloakBrowser) built on Microsoft.Playwright, and a Docker image (cloakhq/cloakbrowser) that offers an instant no-install trial via cloaktest. The project markets a two-tier model: a free latest build (Chromium 150) accessible with a GitHub sign-in allowing one concurrent session, and a paid Pro tier that scales to 5, 20, 200, 2,000, or more concurrent sessions with priority access to the newest patches and hands-on support. An older v146 build remains free on GitHub Releases but is described as aging quickly as detection evolves.
Relevant to the ai-agents query, CloakBrowser explicitly targets AI agents and automation frameworks, advertising drop-in stealth integration with browser-use, Crawl4AI, Scrapling, Stagehand, LangChain, Selenium, and others. This makes it particularly notable for AI agent workflows that require reliable, undetected web browsing at scale. Importantly, the tool does not solve CAPTCHAs—it aims to prevent them from appearing in the first place—and it includes no built-in CAPTCHA-solving services or proxy rotation, expecting users to bring their own residential proxies.
The documented test results are the project's headline selling point. Verified against 30+ live detection services (last tested July 2026 on Chromium 150), CloakBrowser reportedly achieves a 0.9 reCAPTCHA v3 score (human-level, server-verified, versus 0.1 for stock Playwright), passes both non-interactive and managed Cloudflare Turnst
ToolsAppsAgentsbrowser-usesecurityworkflow-automation
★ 29,218 total+555 this week
#108
The **Anthropic Cybersecurity Skills** repository bills itself as the largest open-source cybersecurity skills library purpose-built for AI agents, though it is an independent community project with no affiliation to Anthropic PBC. At its core, it provides **817 production-grade, structured cybersecurity skills** spanning **29 security domains** and mapped across **six major industry frameworks**, making it a uniquely comprehensive resource in the agentic AI security space. The fundamental problem it addresses is well-articulated: modern AI agents can write code and search the web, but they lack the practitioner-level decision-making playbooks that a senior security analyst relies on — knowing when to use a specific Volatility3 plugin, which Sigma rules catch Kerberoasting, or how to scope a cloud breach across multiple providers. This library is designed to close that gap by giving any AI agent structured, executable domain knowledge rather than raw scripts or checklists.
Each skill follows the **agentskills.io** open standard, using YAML frontmatter for rapid discovery and structured Markdown for step-by-step execution. The six framework mappings are a standout feature: every skill is cross-referenced against MITRE ATT&CK v19.1 (286 techniques, 15 tactics), NIST CSF 2.0, MITRE ATLAS v5.4 (AI/ML adversarial threats), MITRE D3FEND v1.3 (defensive countermeasures), NIST AI RMF 1.0, and the newly released **MITRE Fight Fraud Framework (F3) v1.1**, which was published April 9, 2026. No other open-source skills library currently offers this level of unified cross-framework coverage, which is a significant differentiator. The F3 integration is particularly notable: co-developed by MITRE's Center for Threat-Informed Defense alongside major financial institutions including JPMorganChase, Citigroup, Lloyds Banking Group, and Standard Chartered, F3 fills the gap ATT&CK leaves after initial compromise by cataloging cyber-enabled financial fraud TTPs. The repo maps 94 fraud-relevant skills to F3's 123 techniques, covering new fraud-specific tactics like Positioning and Monetization.
The 29 security domains covered include Cloud Security (66 skills), Threat Hunting (58), Threat Intelligence (52), Network Security (43), Web Application Security (42), Digital Forensics (41), Malware Analysis (39), Identity & Access Management (37), SOC Operations (35), Red Teaming (33), Container Security (33), OT/ICS Security (28), API Security (28), and Incident Response (26), among others. The library is compatible with 26+ AI platforms and works immediately with Claude Code, GitHub Copilot, OpenAI Codex CLI, Cursor, and Gemini CLI. Installation is straightforward via npx or git clone. A live playground is available through **Casky.ai**, allowing users to run cybersecurity skill exercises and observe AI agents executing structured skills in real time without any local setup.
The project
ToolsSafetyMCPsecurityworkflow-automationsynthetic-data
★ 26,665 total+555 this week
#109
GBrain is an open-source personal and team knowledge brain system built by Garry Tan, President and CEO of Y Combinator, designed to serve as a persistent, intelligent memory layer for AI agents. Rather than returning raw search results like traditional retrieval systems, GBrain synthesizes information into coherent, cited answers with explicit gap analysis — telling you not just what it knows, but what it doesn't. The project is positioned as the "brain layer" missing from most AI agent stacks, combining synthesis, knowledge graph traversal, and gap analysis in a single deployable system.
At its core, GBrain addresses a fundamental limitation of existing personal knowledge management tools: they find relevant pages but leave the user to read and synthesize them manually. GBrain instead reads those pages and writes the answer, complete with citations and a candid note about what information may be missing or stale. This is illustrated vividly in the README's meeting-prep example, where a query about an upcoming meeting with "Alice" returns a structured briefing covering her role, open action items, and a heads-up that no new data has been ingested in six weeks — rather than a list of five documents to open manually.
The system is built around two primary query modes: raw retrieval via `gbrain search`, which uses hybrid scoring combining vector similarity, keyword matching, reciprocal rank fusion, source-tier boosting, and a reranker; and the synthesis layer via `gbrain think`, which produces LLM-generated prose answers with citations and gap analysis. The knowledge graph component automatically extracts entity references and creates typed edges — such as `attended`, `works_at`, `invested_in`, `founded`, and `advises` — on every page write, with zero additional LLM calls. This graph layer enables relational queries that pure vector search cannot answer, such as "who works at Acme AI?" or "what did Bob invest in this quarter?"
Performance benchmarks are cited directly in the README: on a 240-page Opus-generated rich-prose corpus called BrainBench, GBrain achieves P@5 of 49.1% and R@5 of 97.9%, representing a +31.4 point improvement in P@5 over its graph-disabled variant and over ripgrep-BM25 plus vector-only RAG by a similar margin. Full evaluation scorecards are available in the sibling `gbrain-evals` repository.
GBrain is described as production-grade and battle-tested: Garry Tan runs it personally across 146,646 pages, 24,585 people, 5,339 companies, and 66 autonomous cron jobs. It ingests meetings, emails, tweets, voice calls, and original ideas continuously, enriches every person and company it encounters, fixes its own citations, and consolidates memory overnight in what the README calls a "dream cycle." This autonomous overnight enrichment loop is a key differentiating feature — it is framed as a daemon that runs 24/7 rather than a chat-based agent requiring constant prompting.
The system supports multi-user team deployments with per-user data scoping, ensuring that queries only surface data the authenticated user is permitted to see. The README claims zero data leaks across all read paths — search, list, lookup, and multi-source reads — after fuzz testing. This positions GBrain directly as a candidate for the "company brain" shape described in Y Combinator's Request for Startups.
Installation is designed to be agent-driven and takes approximately 30 minutes. The recommended path is to paste a single URL into an AI agent such as OpenClaw or Hermes, which then installs GBrain, creates the brain, configures API keys, loads 43 skills, sets up the dream cycle, and verifies the installation end-to-end. For developers already using Claude Code or Codex, GBrain can be wired in as a local memory layer in two commands using PGLite — requiring no Docker, no server, and no tunnel. Remote brain connections are supported via a bearer token. The system exposes 30+ tools over MCP in both stdio and HTTP modes, with OAuth 2.1 support for cloud clients including Claude Desktop, Claude Cowork, Perplexity Computer, and ChatGPT. Deployment guides cover ngrok, Railway, and Fly.io.
The project is notable for several reasons: it is authored by a highly prominent figure
RetrievalAgentsMCPvector-databaseworkflow-automationlocal-first
★ 27,175 total+552 this week
#110
**autoresearch** by Andrej Karpathy is an experimental framework that lets an AI agent autonomously conduct LLM training research overnight. The agent iteratively edits a single file (`train.py`) containing a GPT model, optimizer (Muon + AdamW), and training loop — running 5-minute fixed-budget experiments, evaluating validation bits-per-byte (val_bpb), and keeping improvements. The human's role shifts from writing Python to authoring `program.md`, a Markdown instruction file that defines the "research org" context for the agent. Built atop a simplified single-GPU version of Karpathy's nanochat, the setup targets NVIDIA GPUs (tested on H100) and is deliberately minimal — three core files, no distributed training, no complex configs. Approximately 100 experiments can run while you sleep. The project is early-stage but already trending, with community forks supporting macOS (MLX), Windows (RTX), and AMD hardware. It's notable for embodying a provocative vision of fully autonomous AI research pipelines, where agents replace human researchers in the experimental loop — making it highly relevant to discussions around AI agents, self-improving systems, and the future of ML research infrastructure.
AgentsTrainingAppsworkflow-automationlocal-first
★ 92,116 total+542 this week
#111
DojoAgents is an open-source, full-market AI agent framework purpose-built for personal investment, aiming to democratize institutional-grade financial analysis for individual investors. Its centerpiece is a Loop-Driven Cognitive Portfolio Agent — an autonomous reasoning engine that performs multi-step tool orchestration across four analytical dimensions: fundamental data cognition (K-lines, financials, news), advanced logic analysis (valuation bands, momentum indicators), cross-market strategy deduction (linking US, HK, and A-share markets), and dynamic portfolio management (risk exposure, performance attribution). The system features a seven-layer architecture spanning a CLI, a React/Vite SPA dashboard with a FastAPI backend, an execution sandbox for Python code and technical indicators, a memory/SKILLS system that distills successful workflows into reusable routines, and a Cron/Gateway layer for omnichannel delivery. Key capabilities include daily market overviews, news impact analysis, multimodal portfolio diagnosis from screenshots, and simulated portfolio generation. It supports LLM providers including OpenAI, Anthropic, Gemini, Zhipu GLM, and DeepSeek, as well as local models via Ollama, llama.cpp, or vLLM. Installable via PyPI with uv, it requires Python ≥ 3.11 and Node.js ≥ 18. Licensed under Apache 2.0, the project is early-stage but notably ambitious, trending likely due to its rare combination of agentic reasoning, multimodal input, cross-market coverage, and privacy-first local deployment for retail investors.
AgentsAppsToolsmultimodallocal-firstworkflow-automation
★ 1,733 total+534 this week
#112
The **agency-agents-zh** repository is a Chinese community edition of the upstream open-source project **agency-agents** (originally by msitarzewski), providing a comprehensive library of **268 plug-and-play AI expert agent roles** designed to be integrated directly into popular AI coding and productivity tools. The project covers 20 departments including engineering, design, marketing, product, gaming, security, GIS, and finance, with each agent defined not merely as a generic prompt template but as a fully specified persona complete with professional workflows, decision-making logic, key rules, and concrete deliverables. This distinction is central to the project's value proposition: rather than telling an AI "you are an expert," each agent defines how that expert thinks, operates, and what they produce.
The library includes a full Simplified Chinese translation of the 215 upstream English agents, plus 53 original agents created specifically for the Chinese market. These China-specific additions cover platforms and verticals highly relevant locally, such as Xiaohongshu (Little Red Book), Douyin, WeChat, Bilibili, Feishu, and DingTalk operations, as well as cross-border e-commerce, government-facing (ToG) services, medical compliance, Qt-based industrial HMI (upper computer) development, mechanical design engineering, livestock farming record verification, domestic network engineering using Huawei/H3C/Ruijie equipment, and FPGA/ASIC digital design. This localization depth makes the project notably more than a translation effort — it is a substantive extension tailored to Chinese industry and platform ecosystems.
The project supports **18 AI coding and productivity tools**, including Claude Code, GitHub Copilot, Cursor, Windsurf, Aider, Gemini CLI, Codex CLI, Kiro (Amazon), Trae, OpenCode, DeerFlow 2.0 (ByteDance), WorkBuddy (Tencent), CodeWhale, Hermes Agent (NousResearch), Qwen Code, Qoder, Antigravity, and OpenClaw. Installation is streamlined via shell scripts that auto-detect installed tools and convert agent formats as needed. OpenClaw is highlighted as the recommended integration, splitting each agent into three structured files: SOUL.md (identity/persona), AGENTS.md (capabilities), and IDENTITY.md (summary), enabling native multi-agent orchestration.
A companion tool called **Agency Orchestrator** is prominently featured, available as both an npm CLI package (`agency-orchestrator`) and a native desktop application for macOS, Windows, and Linux (no Node.js installation required). It enables zero-code multi-agent orchestration with DAG-based parallel execution, checkpoint/resume support, 10 supported large language models (7 of which require no API key), and ready-made templates. An online expert gallery at **ao.aiolaola.com/experts** allows browsing, filtering by department, and copying full agent prompts without any installation.
The project is accompanied by two free learning courses on the **aiolaola.com** platform: a 180-lesson "Learn AI Programming from Zero" course and a 40-lesson "Build AI Agents from Zero" course, both designed to help users apply the agent library effectively within tools like Claude Code, Cursor, and Codex.
In terms of maturity, the project is actively maintained, MIT-licensed, welcomes pull requests, and is published on npm as `agency-agents-zh`. It has attracted multiple enterprise sponsors including APINEBULA, 多元探索 (Duoyuanx), RootFlowAI, Cubence, CCSub, 火山引擎 (Volcengine), 优云智算 (CompShare/UCloud), all of which are AI API aggregation or cloud compute platforms — indicating real commercial ecosystem interest. The breadth of sponsor involvement and the scale of China-specific agent additions suggest this project is gaining meaningful traction within the Chinese AI developer community. Its notable qualities include the depth of role specialization, the breadth of tool compatibility, the localization for Chinese platforms and industries, and the low-friction onboarding via desktop app and online gallery, making it a strong candidate for trending status among Chinese-language AI tooling repositories.
AgentsAppsToolsworkflow-automationmultimodal
★ 18,377 total+533 this week
#113
ARS-Codex (academic-research-skills-codex) is a Codex-native distribution of the Academic Research Skills (ARS) suite, originally designed for Claude Code. It packages the entire ARS workflow as a single unified Codex skill called `academic-research-suite`, adapting the upstream Claude-oriented content through a Codex router layer without modifying the original source. The project is maintained by Imbad0202 and is currently at version 0.1.22, vendoring upstream ARS at v3.19.0 (commit 828ef3b). The repository is licensed under CC BY-NC 4.0 and accepts sponsorship via Buy Me a Coffee.
The core value proposition is enabling OpenAI Codex users to access a sophisticated, multi-workflow academic research pipeline that was previously only available natively in Claude Code. The suite bundles five distinct workflows: `deep-research` for literature reviews and systematic reviews; `academic-paper` for drafting, outlining, and revision; `academic-paper-reviewer` for simulated peer review and editorial decisions; `academic-pipeline` for end-to-end research-to-paper runs with integrity gates; and `experiment-agent` for code experiments, reproducibility validation, and statistical interpretation. A Codex router intelligently dispatches user requests to the appropriate workflow and mode based on the described task.
A notable feature is the emulation of Claude Code's `/ars-*` slash command registry within the single `$academic-research-suite` skill, providing aliases like `ars-plan`, `ars-reviewer`, `ars-full`, and others that map to specific workflow modes. This preserves familiar command semantics across runtimes. The vendored runtime layer adds local-PDF read-integrity preflight sidecars, optional human-read scope attestations with partial-coverage handling, revision-round claim-drift guards using a claim-strength ladder, and deterministic token conservation. Cross-model reviewer/judge tracks, cache re-validation, and risk-stratified claim checks from v3.18 are also preserved.
Installation is supported via Codex CLI plugin commands or direct skill installation using a Python script, with explicit support for both macOS/Linux and Windows (where symlinks are materialized as plain files). The plugin root is `plugins/ars-codex/` and uses a materialized copy of the skill directory for portability. Documentation covers setup, architecture, and an optional full-runtime adapter with a disabled-by-default planner, agent-team templates, and hook packs. Maintainer quality gates can be run via a Python script to verify all integrity checks pass. The project is early-stage (v0.1.x) but architecturally rich, reflecting a deliberate effort to bridge Claude-native academic tooling into the Codex ecosystem — making
ToolsAgentsAppsworkflow-automationcoding
★ 7,152 total+530 this week
#114
GeoLibre is a free, open-source, cloud-native GIS platform designed for visualizing, exploring, and analyzing geospatial data across web browsers, desktop (Windows, macOS, Linux), Android, and Jupyter notebooks — all while keeping data local and private. Built with Tauri v2, React, TypeScript, MapLibre GL JS, DuckDB-WASM Spatial, and deck.gl, it offers a unified workspace that adapts responsively across environments. Key features include 3D Tiles rendering, temporal animation via a Time Slider, 700+ geoprocessing tools, a SQL Workspace powered by DuckDB, a plugin API, and remarkable planetary basemap support covering the Moon, Mars, Mercury, Venus, Galilean moons, Titan, Pluto, and Charon with per-body ellipsoid measurements. The project is available via PyPI, conda-forge, Microsoft Store, AUR, and Flatpak, indicating strong packaging maturity. It is notable for its breadth — spanning data science workflows in Jupyter, cloud-native geospatial formats, spatial SQL, and even extraterrestrial mapping — making it a compelling open-source alternative to proprietary GIS tools. Archived on Zenodo with a citable DOI, it appears to be a rapidly maturing, actively developed platform with growing community traction.
AppsDataToolslocal-firstmultimodalvector-database
★ 2,308 total+529 this week
#115
**reverse-skill** is a cybersecurity skills router designed to guide AI agents (such as Claude Code, Codex CLI, and Cursor) through structured, repeatable workflows when tackling reverse engineering, penetration testing, CTF challenges, and related security tasks. Instead of letting AI agents guess which tools to use, the package provides a master routing system — via `MASTER-ROUTING.md` and `master-route.ps1` — that maps task types (APK analysis, binary reversing, JS decryption, malware analysis, firmware, EDR bypass, LLM security, etc.) to the correct methodology, toolchain, and playbook. It supports over 20 distinct security scenarios, integrating tools like jadx, apktool, Frida, IDA Pro, radare2, Ghidra, BurpSuite, and nmap across Windows, Linux, macOS, and Kali Linux platforms. The project is at v1.0.0, MIT-licensed (with GPLv3 for the CTF submodule), and is actively trending on Trendshift. Its notable appeal lies in systematizing institutional security knowledge for AI-driven workflows, reducing repeated mistakes and tool confusion — making it highly relevant as AI-assisted security research and agentic coding tools rapidly gain adoption.
ToolsAgentsSafetysecurityworkflow-automationcoding
★ 9,016 total+528 this week
#116
**女娲.skill (Nuwa-skill)** is an open-source Agent Skill that "distills" the cognitive frameworks of world-renowned thinkers and leaders — such as Steve Jobs, Charlie Munger, Elon Musk, Richard Feynman, and Naval Ravikant — into runnable AI perspective skills. Rather than role-playing or quoting famous lines, it extracts each person's mental models, decision heuristics, expression DNA, anti-patterns, and honest limitations into a structured SKILL.md file. The distillation pipeline uses six parallel research agents pulling from 40+ primary sources (books, podcasts, social media, critic perspectives, decision records, life timelines), applies triple-verification filters (cross-domain recurrence, predictive power, exclusivity), and validates outputs against known and novel questions. The project currently ships 14 person skills and 1 topic skill — all independently installable — and every skill has passed a five-dimension blind fidelity scorecard, scoring A-grade (≥85) across the board. It is compatible with 50+ AI agent runtimes including Claude Code, Codex, Cursor, OpenClaw, Hermes Agent, Gemini CLI, and OpenCode, installable via a single `npx skills add` command. Inspired by the viral colleague-skill project, Nuwa extends the concept to history's greatest minds, making it notably trending for its ambition, methodology transparency, and broad runtime compatibility. The project is MIT-licensed and community-extensible.
ToolsAgentsAppsworkflow-automationsynthetic-data
★ 28,847 total+528 this week
#117
OpenSRE (v0.1) is an open-source framework developed by Tracer-Cloud for building AI-powered Site Reliability Engineering (SRE) agents capable of autonomously investigating and resolving production infrastructure incidents. The project addresses a critical gap in the AI operations space: while coding agents have benefited from structured benchmarks like SWE-bench, production incident response has lacked an equivalent training and evaluation environment. OpenSRE aims to fill that gap by providing both deployable AI SRE agents and a reinforcement learning environment with synthetic incident simulations and real-world end-to-end tests. When an alert fires, the agent automatically fetches correlated logs, metrics, traces, and recent deployments; masks sensitive identifiers before making external LLM calls; reasons across connected systems in a tool-calling loop; generates a structured root-cause analysis report with linked evidence; suggests or executes remediation steps; and posts summaries directly to Slack, PagerDuty, or Telegram. The framework supports an interactive REPL shell with slash commands for session management, cost tracking, integration verification, and reasoning depth control, as well as one-shot investigation modes and remote runtime RCA by service name. It connects to 60+ tools spanning LLM providers (Anthropic, OpenAI, Codex, Ollama, Gemini, OpenRouter, NVIDIA NIM, Bedrock), observability platforms, cloud infrastructure (Kubernetes, EC2, CloudWatch, Lambda, ECS Fargate, Flink), data platforms, and incident management systems. A scored synthetic root-cause analysis suite checks accuracy, required evidence, and adversarial red herrings, while real-world end-to-end tests cover cloud-backed failure scenarios. Installation is straightforward across macOS, Linux, and Windows, with deployment options including Docker/ECR on AWS EC2, a gateway AMI with systemd, and hosted paths via Railway, ECS, or Vercel. The project is currently in public alpha — core workflows are usable for early exploration but APIs and integrations remain subject to change. It is sponsored by Greptile and has already appeared on Trendshift, signaling growing community interest. OpenSRE is notable for being one of the first open frameworks to treat AI-driven incident response as a trainable, benchmarkable discipline rather than a one-off automation task, positioning itself as the foundational benchmark and training ground for the emerging AI SRE category. Its mission to scale to thousands of realistic infrastructure failure scenarios makes it a potentially significant reference project for teams exploring autonomous operations and AIOps.
AgentsEvalsToolsworkflow-automationsecurity
★ 9,286 total+521 this week
#118NEWPartial week
StaffDeck is an open-source enterprise platform for building and managing AI-powered "digital employees" — autonomous agents that encode professional expertise, business processes, and decision criteria into continuously operating, reusable organizational assets. Jointly developed by ModelBest, the NEU-ModelBest Data Intelligence Joint Lab, THUNLP, OpenBMB, and AI9Stars, the project was open-sourced on July 15, 2026, and is already gaining traction on GitHub Trending. The platform is positioned as a bridge between AI as a personal productivity tool and AI as a scalable organizational capability, making it highly relevant to the current enterprise AI wave.
StaffDeck's architecture centers on four core pillars. First, digital employee management allows professionals to define roles with positions, capability profiles, employee IDs, and work records, supporting permission isolation, publishing, and reuse. Second, state-machine-driven procedural skills convert natural language descriptions into structured SOPs, enabling accurate execution of complex multi-step workflows with real-time flow switching, visual editing, and version management. Third, document-structure-aware knowledge retrieval builds hierarchical indexes across documents, chapters, pages, and summaries, allowing agents to progressively locate precise information with source citations and retrieval debugging. Fourth, autonomous execution and continuous improvement connects digital employees to real business systems via HTTP APIs, MCP, and scheduled tasks, closing the feedback loop through long-term memory, full execution traces, human takeover, and feedback analysis.
The platform supports cross-channel deployment, including WeChat and WeCom (enterprise WeChat) integration with intent-based auto-routing, identity merging, and conversation observability. It ships with desktop installers for macOS (Apple Silicon), Windows (x64), and Linux (Debian/Ubuntu), as well as a self-hostable web stack built on FastAPI and a Node.js frontend. Setup is streamlined with agent-friendly deploy prompts compatible with Cursor, Claude Code, and Codex. The project requires Python 3.11+, Node.js 20+, and any OpenAI-compatible model endpoint, with no mandatory CUDA dependency. Licensed under AGPL-3.0, StaffDeck is early-stage but feature-rich, with an active community on Discord, Feishu, and WeChat, making it a notable and timely open-source entry in the enterprise agentic AI space.
AgentsAppsRetrievalworkflow-automationlocal-first
★ 1,040 total+518 this week
#119
CLI-Anything is an open-source project from the HKUDS (Hong Kong University Data Science) lab that aims to make any existing software "agent-native" — meaning AI agents can interact with virtually any application through a unified command-line interface layer. The core philosophy is captured in its tagline: "Today's Software Serves Humans. Tomorrow's Users will be Agents." The project bridges the gap between modern AI agents and the vast ecosystem of existing software tools by generating structured CLI harnesses that agents can invoke programmatically, without requiring those software vendors to build their own agent integrations.
The project's central mechanism is the generation of CLI "harnesses" — thin wrappers around existing applications that expose their functionality as structured, agent-consumable commands. These harnesses output both JSON and human-readable formats, making them compatible with a wide range of AI agent frameworks including Pi, OpenClaw, nanobot, Cursor, and Claude Code. The harnesses are defined through a HARNESS.md specification system, which underwent a major v0.2.0 redesign introducing progressive disclosure — detailed guides are extracted into a `guides/` directory for on-demand loading, with phases 1 through 7 now contiguous and key principles consolidated into a single authoritative section.
A major ecosystem component is CLI-Hub, a package manager and web registry for community-built CLI harnesses. Users can install it via `pip install cli-anything-hub` and then use `cli-hub install <name>` to browse, install, update, and uninstall harnesses. CLI-Hub reached v0.2.0 with support for multiple install sources including pip, npm, brew, and bundled/system tools, backed by a `public_registry.json`. The hub frontend was redesigned to show separate decks for CLI-Anything CLIs and Public CLIs, and live end-to-end checks cover real install, update, and uninstall flows. The registry also supports remote `skill_md` URLs, and all SKILL.md files have been unified under a top-level `skills/` directory installable via `npx skills add HKUDS/CLI-Anything`.
The breadth of supported software is remarkable and growing rapidly. Merged harnesses span creative tools (Blender, Inkscape, FreeCAD, Kdenlive, Shotcut, RenderDoc, Openscreen), productivity and knowledge management (Obsidian, Zotero, Joplin, Calibre), GIS and scientific tools (QGIS, ArcGIS Pro, UniMol Tools), web and automation (n8n, Dify Workflow, Exa, WireMock, Safari, CLIBrowser, DomShell), game development (Godot, Unreal Insights, UEAtelier, Slay the Spire II), cloud and infrastructure (CloudAnalyzer, PM2, ChromaDB, Eth2-Quickstart, SeaClip), media and AI (VideoCaptioner, MiniMax, 3MF), music and data (Rekordbox, LibreOffice, Zoom), and orchestration tools (Hermes skill). Proposed additions include Joplin with 134 tests and ArcGIS Pro for cartography and geoprocessing workflows.
The project demonstrates strong engineering discipline. It reports 2,461 passing tests with 100% pytest pass rates, covering both unit and end-to-end test categories. Security has received explicit attention: Sketch CLI was hardened against path traversal and symlink escapes, DomShell received URL validation and DOM sanitization, XML/SVG/ODF/MLT/MusicXML/CSL parsing now routes untrusted input through `defusedxml`, and Obsidian search was corrected to use proper Local REST API vendor content types. The n8n REPL banner crash was fixed with regression coverage, and LibreOffice headless conversion was made more robust on macOS.
The project is technically grounded in Python (≥3.10) and Click (≥8.0), and is licensed under Apache 2.0. It has an accompanying technical report published on arXiv (arXiv:2606.03854), lending it academic credibility alongside its practical open-source momentum. Documentation is available in English, Chinese, Japanese, and German, signaling broad international community interest.
Community engagement is a defining feature of the project's growth strategy. Contributors can sign up via GitHub issue templates to build new CLI harnesses, and wishlist requests allow users to nominate software they want supported. The project maintains active community channels on Feishu and WeChat. The pace of merges and proposals — often multiple per day — reflects a highly active contributor base, and the Trendshift badge prominently displayed in the README confirms its status as a trending GitHub repository.
The project's real-world demos showcase AI agents using generated CLIs to produce tangible artifacts: CAD builds, 3D scenes, diagrams, gameplay sequences, and video subtitles, among others. These demonstrations underscore the project's practical ambition — not just to expose APIs but to enable agents to operate full creative and professional software pipelines autonomously.
In summary, CLI-Anything is a rapidly maturing, community-driven infrastructure project that sits at the intersection of AI agent tooling and software accessibility. Its combination of a growing harness library, a package manager ecosystem, rigorous testing, security hardening, academic backing, and multilingual documentation makes it a notable and trending project for anyone building or deploying AI agents that need to interact with real-world software.
ToolsAgentsMCPworkflow-automationbrowser-uselocal-first
★ 46,132 total+518 this week
#120NEWPartial week
Vorssaint is a free, open-source macOS menu bar utility that consolidates the functionality of a dozen typically paid Mac apps into a single icon, requiring no account, no telemetry, and no subscription. The project is built in Swift and targets macOS 14 and later on Apple Silicon, positioning itself as a privacy-first, locally-executed alternative to fragmented paid utilities. Its core philosophy is modularity: users install only the features they want through a Features hub, and uninstalled features stop loading entirely, consuming zero CPU, memory, or energy until reinstalled — with settings preserved throughout. The app is organized into broad capability domains covering sound (per-app volume mixing, output switching, microphone management), system monitoring (CPU, GPU, memory, temperatures, battery health, network), window and Dock management (a richer ⌘Tab app switcher with live thumbnails, window snapping, Dock previews), keyboard and mouse enhancements (text snippets, smooth scrolling, Super Key via Caps Lock, key debounce), clipboard and file tools (clipboard history, a file shelf, Finder cut-and-paste, URL cleaning), and everyday utilities (screenshot editor with annotation and QR recognition, offline OCR, color picker, Homebrew manager, app uninstaller, media compression, scratchpad, radial menu, and more). Installation is available via Homebrew or a signed and notarized disk image from the GitHub releases page, ensuring smooth macOS gatekeeper compatibility. The app supports thirteen languages, offers settings export/import for multi-Mac setups, and includes three one-click onboarding bundles (Essentials, Windows, Battery and Quiet). Notably, Vorssaint was ranked the #1 Swift repository of the day on Trendshift, signaling strong community momentum. Its breadth of features, zero-cost model, strict privacy stance, and thoughtful energy-aware architecture make it a compelling and trending alternative to the fragmented Mac utility app market.
AppsToolslocal-firston-device
★ 3,294 total+517 this week
#121NEWPartial week
Persome, developed by Intuition-Lab, is an open-source "Personal Model" that learns how an individual thinks and works by capturing focused activity on a Mac — then supplies evidence-linked context to AI coding agents like Codex, Claude Code, and Cursor via the Model Context Protocol (MCP). The project is notable for its privacy-first, fully local architecture: all data stays on the user's machine, is inspectable, correctable, exportable, and deletable, with no Full Disk Access required. Persome builds a layered semantic memory structure organized into five tiers — Points (sourced observations), Lines (relationships over time), Faces (evidence-backed patterns), Volumes (higher-order structures), and a Root (the current integrated model of the user) — forming a living, evolving personal knowledge graph. New evidence can strengthen, revise, or overturn earlier inferences, and every claim retains traceable receipts, making the system grounded rather than hallucination-prone. Key use cases include restoring work context across sessions ("continue where you left off"), autonomous background task execution within user-defined permission boundaries ("work while you sleep"), and personalizing AI agent behavior so the same prompt yields different, contextually appropriate answers for different people. The project supports macOS 13+ on both Apple Silicon (using bundled PP-OCRv6 for local OCR) and Intel (using Apple Vision framework), and integrates with hosted or local LLM providers as well as agent subscriptions from Codex, Claude Code, and Cursor. Currently at version 0.3.2, Persome is listed on the Official MCP Registry and is trending in the agent-memory space due to its unique combination of deterministic provenance, local privacy guarantees, and deep MCP-native integration for agentic workflows.
MCPAgentsRetrievallocal-firston-deviceworkflow-automation
★ 1,220 total+516 this week
#122
DeepSeek-Reasonix (npm package: `reasonix`) is a DeepSeek-native AI coding agent designed for terminal use, built as a single static Go binary with zero external dependencies beyond a TOML parser. It is config- and plugin-driven, with all providers, models, tools, and plugins declared in `reasonix.toml`, making it highly composable without code changes. It natively supports DeepSeek but accepts any OpenAI-compatible endpoint, and can run dual-model setups (executor + planner) in cache-stable sessions. A key architectural focus is cache-aware context management — injecting stable environment summaries and pruning stale tool output to keep token costs low across long sessions. Plugins run as subprocesses over stdio JSON-RPC and are MCP-compatible. Distribution is frictionless: installable via npm, Homebrew, or prebuilt binaries for six platform/architecture targets, with a desktop app and a VS Code/VSCodium extension also available. The project is actively maintained with 20+ named contributors, bilingual (English/Chinese) community support on Discord, and growing star history — making it notable as a cost-efficient, open, multi-platform alternative to proprietary AI coding agents, riding the DeepSeek and agentic-coding trend.
AgentsToolsAppscodinglocal-firstworkflow-automation
★ 27,838 total+494 this week
#123
agent-browser is a browser automation command-line interface built by Vercel Labs, purpose-built for AI agents that need to control a real web browser. Its defining characteristic is speed: the tool is implemented as a fast native Rust CLI, and its daemon requires neither Playwright nor Node.js to run, which distinguishes it from many JavaScript-based automation stacks. The project can be installed in several ways to suit different workflows — globally via npm (the recommended path, which installs the native Rust binary), as a pinned local project dependency in package.json, through Homebrew on macOS, via Cargo for Rust users, or built directly from source (requiring Node.js 24+, pnpm 11+, and Rust). After installation, users run `agent-browser install` once to download Chrome from Chrome for Testing, Google's official automation channel; existing Chrome, Brave, Playwright, and Puppeteer installations are auto-detected. On Linux, an `--with-deps` flag installs required system browser libraries, and an `upgrade` command auto-detects the install method (npm, Homebrew, or Cargo) to update accordingly.
The core design philosophy centers on making the browser legible to AI. A key feature is the `snapshot` command, which returns an accessibility tree annotated with references (refs like @e1, @e2) that agents can then use to click, fill, get text, or otherwise interact with elements — a ref-based approach considered "best for AI." Traditional CSS selectors and semantic locators are also supported. The `find` family lets agents locate elements by ARIA role, text content, label, placeholder, alt text, title attribute, data-testid, or positional matchers (first, last, nth), each paired with actions such as click, fill, check, hover, or text, with `--name` and `--exact` refinement options. Implicit ARIA roles are handled (an h2 becomes a heading, a ul a list, a top-level header a banner).
The command surface is broad. Core commands cover opening/navigating URLs, clicking, double-clicking, focusing, typing, filling, key presses, keyboard-level typing and text insertion, hovering, selecting dropdowns, checking/unchecking, scrolling, scroll-into-view, drag-and-drop, file uploads, screenshots (including full-page, annotated with numbered labels, and configurable format/quality/directory), PDF export, JavaScript evaluation (with base64 and stdin input), CDP connection by port, runtime WebSocket streaming (enable/status/disable), and session closing (including `--all`). An AI-powered `chat` command accepts natural-language instructions either as a single shot or in an interactive REPL, enabling conversational browser control. Information-retrieval commands fetch text, innerHTML, input values, attributes, page title, URL, CDP WebSocket URL, element counts, bounding boxes, and computed styles. State checks (`is visible`, `is enabled`, `is checked`) support conditional logic.
A notably sophisticated feature is the `read` command, which fetches agent-friendly text without launching Chrome, or reads the rendered DOM of the active tab (preserving browser auth state and client-side updates). It requests `Accept: text/markdown` by default, retries with an appended `.md` extension, walks ancestor paths to find the nearest `llms.txt` for matching docs links, and falls back to readable text extracted from HTML. Options include `--raw`, `--require-md`, `--outline` (compact heading outline), `--llms index`/`--llms full` (for llms.txt and llms-full.txt), `--filter`, and `--timeout`, plus global safeguards like `--allowed-domains`, `--content-boundaries`, and `--max-output`. Waiting is flexible: agents can wait for elements, time durations, text appearance/disappearance, URL patterns, load states (load, domcontentloaded, networkidle), or arbitrary JavaScript conditions. Batch execution runs multiple commands in a single invocation (as quoted args or piped JSON via stdin) to avoid per-command startup overhead, with a `--bail` option to stop on first error
ToolsAgentsAppsbrowser-useworkflow-automationlocal-first
★ 39,282 total+490 this week
#124NEWPartial week
Nub (nubjs/nub) is a fast, all-in-one JavaScript/TypeScript developer toolkit written in Rust that augments Node.js rather than replacing it, positioning itself as a Bun-like developer experience built on top of stock Node. Its core philosophy is zero lock-in: no new runtime, no vendor-specific APIs, just dramatically faster versions of the tools developers already use. The project consolidates six major developer workflows into a single binary: a TypeScript-first file runner (2.9× faster startup than tsx), a script runner (~24× faster than pnpm run at ~14ms), a package executor nubx (~19× faster than npx), a package manager (~18× faster than pnpm install, powered by the Aube engine), a Node version manager, and a Corepack-style package manager shim system. The file runner is particularly notable, leveraging modern Node.js extension surfaces — including module.registerHooks(), --import/--require preloads, and N-API native addons embedding the oxc transpiler — to support TypeScript, JSX, decorators, extensionless imports, automatic .env loading, built-in data format loaders, and polyfills/unflags for modern APIs like Temporal, WebSocket, node:sqlite, and vm.Module. The package manager includes security-forward defaults: blocking postinstall scripts, checking osv.dev for malicious packages, refusing provenance downgrades, and enforcing a 24-hour minimum release age. Nub detects incumbent package managers (npm, pnpm, Yarn, Bun) and runs in compatibility mode, reading their native config files. It supports installation via curl, Homebrew, Nix, mise, and npm, and provides a GitHub Actions setup action as a drop-in for actions/setup-node. The project is early-stage but ambitious, with comprehensive benchmarks and documentation,
ToolsServingDatalocal-firstsecuritycoding
★ 3,314 total+434 this week
#125NEWPartial week
astrid-capsule-memory is a Rust-based cross-session memory module for Astrid OS agents, designed to persist context across session boundaries — functioning conceptually as a "persistent swap file" for AI agents. It hooks into the `prompt_builder.v1.hook.before_build` lifecycle event, reading a `.astrid/memory.md` file from the workspace via a virtual filesystem (VFS), wrapping its contents in a `# Memory` section, and injecting it into the system context on each prompt assembly cycle. A key safety feature is a 32KB hard cap on memory content, preventing unbounded context window consumption, with truncation handled gracefully at UTF-8 character boundaries. The capsule is intentionally read-only — agents write to the memory file using existing filesystem tools from the companion `astrid-capsule-fs` module, keeping responsibilities cleanly separated. Built targeting `wasm32-unknown-unknown`, it fits a WebAssembly-based plugin/capsule architecture. The project is early-stage (MSRV 1.94, copyright 2025–2026) and notable for its clean, minimal design addressing a real challenge in stateful AI agent systems: durable memory across sessions without bloating context windows.
AgentsToolsMCPlocal-firston-device
★ 7,575 total+399 this week
#126NEWPartial week
`astrid-capsule-identity` is a Rust-based identity and system prompt builder component for Astrid OS, an agent-oriented operating system. Acting as the conceptual equivalent of `/etc/profile`, this capsule manages an AI agent's "spark identity" — including callsign, class, aura, signal, and core directives — persisting it via capsule KV state and assembling it into a system prompt for LLM consumption. On receiving a `spark.v1.request.build` event, it loads persisted identity, auto-detects a `spark.toml` config file, appends environment context (working directory, platform), and publishes the assembled prompt. If no identity exists, it triggers an onboarding flow where the LLM calls `save_identity` to persist the chosen identity and write a recovery copy. The IPC protocol is event-driven, with clearly defined subscribe/publish topics. Built in Rust with a minimum supported version of 1.94, the project is early-stage (2025–2026 copyright) but architecturally notable for treating AI agent identity as a first-class OS primitive with KV isolation scoped per calling principal. Its trending appeal likely stems from growing interest in agentic OS frameworks and structured LLM identity management.
AgentsModelsAppslocal-firston-device
★ 7,540 total+398 this week
#127NEWPartial week
`astrid-capsule-fs` is a Rust-based filesystem tooling capsule designed for agents running within Astrid OS, a custom operating system built by Unicity Labs. It functions as the coreutils equivalent in the Astrid OS model, providing agents with core filesystem capabilities including reading, writing, replacing content, listing directories, recursive grep search, creating directories, deleting, and moving files. All operations are mediated through a kernel-level VFS (Virtual Filesystem) airlock that enforces path boundaries, copy-on-write isolation, and capability checks before any host filesystem access occurs, emphasizing security and sandboxing. The project targets WebAssembly (`wasm32-unknown-unknown`), suggesting it is designed for a sandboxed, portable runtime environment. It requires Rust MSRV 1.94, indicating it targets a very recent (possibly nightly or upcoming stable) Rust toolchain, which signals active, cutting-edge development. The project is early-stage but purposeful, with notable safety features like rollback on move failure and strict match enforcement for replacements. It may be trending due to growing interest in agent-based OS architectures and Wasm-native system tooling. It is dual-licensed under MIT and Apache 2.0.
ToolsAgentsSafetysecurityon-deviceworkflow-automation
★ 7,404 total+390 this week
#128NEWPartial week
Darwin-Skill (达尔文.skill) is a v2.0 Agent Skill optimizer that applies machine-learning training loop concepts — specifically Andrej Karpathy's autoresearch ratchet mechanism — to the iterative improvement of SKILL.md files used by AI coding agents like Claude Code, Codex, and Trae. The system evaluates skills across a 9-dimension rubric (expanded from 8 in v1.0), incorporating three new dimensions directly from Microsoft Research's SkillLens paper: Failure Mechanism Encoding, Actionable Specificity, and High-Risk Action Blacklist. A key differentiator is its Human-in-the-Loop design with mandatory checkpoints, contrasting with SkillOpt's fully autonomous approach, since skill quality is considered more nuanced than a simple validation loss. The ratchet mechanism ensures scores only increase — any edit that doesn't improve the weighted score is automatically reverted via git. Notably, Microsoft's SkillOpt officially listed darwin-skill as an integration partner. The project is actively maintained (updated May 2026), installable via `npx skills add`, and has demonstrated measurable gains (e.g., huashu-gpt-image skill improved from 80.8 to 91.65). It is trending likely due to its timely alignment with emerging Microsoft Research papers and the rapidly growing Agent Skill ecosystem.
EvalsAgentsTrainingcodingworkflow-automationsynthetic-data
★ 5,117 total+342 this week