#1
REA (Reverse Engineer Anything) is an open-source tool that connects AI agents to a comprehensive suite of reverse engineering capabilities through the Model Context Protocol (MCP). The project's core premise is compelling: if you see a feature in any application and want to understand or replicate it, you can ask your AI agent to investigate it using REA — without needing access to the original source code. REA bridges the gap between high-level agent queries and low-level binary analysis by returning not just conclusions but the underlying evidence and known limitations behind each finding, making it suitable for rigorous technical investigation rather than speculative output.
The tool supports an exceptionally broad range of analysis targets, including native binaries (via Hopper, Ghidra, or IDA), JavaScript and Electron applications, .NET assemblies, Android APKs and live Android devices via ADB, Go and Rust binaries, WebAssembly artifacts, EVM bytecode, SQLite databases, recorded Linux crash dumps, websites via Chrome-family browsers, and saved network captures in HAR or Fiddler SAZ formats. This breadth is a defining characteristic of the project and distinguishes it from narrower, single-target reverse engineering tools.
Setup is streamlined through a single `npx rea-agents setup` command, which registers REA's MCP server with supported agents — including Claude Code, Codex, Cursor, and Gemini CLI — and installs matching workflow instructions with automatic backups. The CLI is equally capable, allowing terminal-based analysis without an agent. REA requires Node.js 22.x or later and npm, with additional dependencies varying by target type. Analysis runs entirely locally, which is a meaningful privacy and security consideration for sensitive targets.
The project is actively maintained and changes rapidly, with frequent bug fixes and a built-in `rea update` command for keeping installations current. It includes careful engineering details such as bounded stdout/stderr retention during updates, terminal backpressure handling, and Bun version compatibility guards, suggesting a mature and production-minded development approach. The README is available in over 20 languages, signaling strong international community investment.
REA is trending on Trendshift and has an active Discord community, indicating growing adoption. Its positioning at the intersection of AI agent tooling and reverse engineering — two of the most active areas in developer tooling — makes it notably relevant. The agent-skills query context aligns directly with REA's MCP-based skill registration model, where agents gain structured reverse engineering capabilities as callable tools. For security researchers, competitive analysts, and developers wanting to understand closed-source behavior, REA represents a significant productivity multiplier by automating the most tedious parts of binary and application investigation.
ToolsMCPSafetysecuritylocal-firstcoding
★ 325,245 total+210,919 this week
#2
PhotoCraft is an open-source, clean-room reimplementation of Adobe Photoshop, built entirely in Rust by the ArtCraft community under the storytold organization. The project aims to deliver a fully native, offline, cross-platform image editor that replicates the core experience of Photoshop — menus, shortcuts, panels, and tools — without requiring a subscription, cloud account, or proprietary runtime. It is licensed under MIT and Apache-2.0 dual licensing and is currently in early alpha, making it a bold and ambitious undertaking in the open-source creative tooling space.
The application runs natively on macOS, Windows, Linux, FreeBSD, and the Web, powered by a GPU compositor built on wgpu, which supports Metal, Vulkan, DirectX 12, and WebGPU backends. Performance is a central design goal: copy-on-write tile architecture, multithreaded filters, and running-sum box blur passes across all CPU cores mean that even a radius-180 Gaussian blur on a 3.6-megapixel image completes in under a second. There is no Electron, no web view, and no waiting — it is a genuinely native application.
PhotoCraft supports real PSD file reading and writing, successfully re-saving 307 of 309 files in the psd-tools test corpus, and matching Photoshop's pixel output for 116 of 116 shape layers tested. This level of format fidelity is rare among open-source alternatives and is a significant technical differentiator. Adjustment layers — including Curves, Levels, Vibrance, Hue/Saturation, Black & White, Channel Mixer, Gradient Map, Photo Filter, Selective Color, Color Lookup (.cube, .3dl, .look), and more — are fully non-destructive and maskable. Layer styles such as Drop Shadow, Inner Shadow, Outer and Inner Glow, Bevel & Emboss, Satin, Stroke, and Color/Gradient/Pattern Overlay are supported on any layer including live type layers, and round-trip through PSD files.
Selection tools span the full Photoshop vocabulary: Marquees, Lassos, Magic Wand, Quick Selection, Object Selection, and Select Subject, with Select and Mask for refining fine edges. Notably, smart selection runs entirely on-device with no cloud dependency. Vector tools include the Pen, Freeform Pen, Curvature Pen, and standard shape tools, with support for boolean shape operations (unite, subtract, intersect, exclude), vector masks, and resolution-independent rendering. Type layers support point and paragraph text with full Character and Paragraph controls, remain editable, accept layer styles, and round-trip through PSD.
Filters cover an extensive range: Gaussian, Box, Motion, Radial, Surface, Smart, Lens, and Shape blurs; the Blur Gallery (Tilt-Shift, Iris, Field, Spin, Path); sharpening; Reduce Noise; distortions like Twirl, Wave, Ripple, Displace, Shear, and Zig Zag; Pixelate; Stylize effects including Oil Paint, Wind, and Extrude; and Render effects like Clouds, Fibers, Lens Flare, and Lighting Effects. All filter dialogs preview live on the canvas through active selections, and filters applied to smart objects remain editable, hideable, and reorderable at any time.
A particularly forward-looking feature is its agent-ready architecture: every action is a command, meaning the same engine can be driven from the UI, the CLI, a JSON control channel, or an MCP server. This positions
AppsMCPToolsmultimodallocal-firston-device
★ 67,676 total+18,948 this week
#3
VoiceStudio is an open-source, locally-run desktop application for AI-powered voice cloning, voice design, video dubbing, dictation, transcription, and audiobook creation supporting 646 languages. Built on an Electron frontend with a Python backend, it defaults to the k2-fsa/OmniVoice engine but supports a catalog of swappable speech engines. Key features include timed video dubbing, batch audiobook generation, a floating dictation widget, reusable workflow recipes, watch folders, a local REST API, and MCP (Model Context Protocol) integration for AI agents. Hardware acceleration is supported via NVIDIA CUDA and Apple Silicon Metal/MPS, with CPU-only fallback for standard machines. The project is actively developed (past v0.5.3, having migrated from Tauri to Electron), licensed under AGPL-3.0, and trending on Trendshift. It is notable for its breadth of multilingual voice AI capabilities running entirely on local hardware, privacy-respecting design, agent-friendly installation via coding tools like Claude Code and Cursor, and companion iOS/Android apps in preview. Sponsorship and community support channels indicate growing ecosystem momentum.
AppsModelsMCPlocal-firstaudiomultimodal
★ 75,890 total+16,849 this week
#4
dsh-our-free-model is a plugin for the DeepSeek Harness (dsh) runtime that gives users instant, zero-configuration access to a range of frontier AI models—including DeepSeek V4.1 Flash, Kimi K3, GLM 5.3 Flash, and MiMo V2.6—completely free and without usage caps. The core value proposition is that users simply install the plugin into dsh with no login, sign-up, or API key required, and the models become immediately available. The plugin is pure plugin mounting: it does not modify the dsh kernel, requires no build step, and has zero dependencies. Free-lane models are sourced transparently from OpenCode's Zen gateway, while the Kilo channel draws from Kilo AI's public gateway, both connected directly without third-party relays. The model catalog follows upstream dynamically, re-fetching model collections, context lengths, and capabilities on each refresh rather than storing static snapshots. A notable feature is the availability detection logic: the model selector only broadcasts models that are actually routable from the user's own network egress, removing models that upstream explicitly declines (returning "Model is unavailable" or 404) while preserving gateway faults (5xx), rate limits (429), timeouts, and disconnects as still-reachable; region-limited models are grouped separately. The plugin offers an announcement center with real-time push where repo maintainers edit JSON and all installed instances receive updates within one polling cycle, including urgent full-screen popups and optional system notifications. It supports in-app upgrades (download → SHA-256 verification → backup → atomic replace → re-read verification → hot reload, with automatic rollback on failure) and hot reloading without app restart. The plugin handles streaming responses by inspecting response body shape rather than relying on content-type headers, since gateways under high load return SSE frames with application/json content-type. Reasoning/thinking intensity actually takes effect: models with declared tiers use their own Off/Low/High/Max menus passing real reasoning_effort values upstream, while others use a budget ladder (Light/Balanced/Deep mapping to output token budgets of 2,048/8,192/model-max, doubled for models where thinking cannot be disabled). The plugin does not depend on a browser UI, working in compositions like dsh-tui that lack a web server. It includes a usage dashboard with token heatmaps, total curves, output speed, and first-token latency, all kept locally with no data uploaded. An OpenAI-compatible local forwarding port lets other local tools call these models. The EAC channel (desktop-only) unlocks a co-paid lane gated by host fingerprint and server-side GitHub authorization (login and star the repo). The Kilo channel offers a passwordless free pool. An aggregation channel lets users bring their own keys to connect 75 third-party providers (NVIDIA NIM, OpenRouter, Groq, Cerebras, SambaNova, Gemini, DeepSeek, Mistral, Together, Fireworks, and more, plus local providers like Ollama, LM Studio, llama.cpp), with keys written only to local 0600 settings.json. Token-saving features include RTK tool-output compression that rewrites tool_result in place (git diff/status/log, grep, find, etc.), achieving 90% byte reduction on a
ToolsServingAppslocal-firstmultimodal
★ 25,438 total+15,852 this week
#5
AnyPS5 is an open-source tool that automatically ports PS5 executables to Linux and Windows by converting them to the target system's native format via a relinker, without emulation or a separate runtime process. It also provides implementations of PS5 system PRX libraries suitable for dynamic linking, and includes a shader recompiler that produces SPIR-V output validated via SPIRV-Tools. A web-based converter is available, keeping files local to the user's device, and a relinker-only build supports macOS including Apple Silicon. The project tracks per-game compatibility progress through a community-maintained blocker map built from public GitHub data, with test reports organized in dedicated discussion threads. SDL-mapped controllers, keyboard, and mouse input are supported with configurable INI-based mappings. The project is actively developed but still maturing, with library and shader coverage tracked via live progress badges. It is notable for its no-emulation approach to PS5 compatibility, making it a technically ambitious and trending project in the game preservation and interoperability space. Licensed under GPL-2.0 only.
MCPAppslocal-firston-device
★ 43,396 total+12,764 this week
#6
Anatomy is a Claude agent skill that explains technical concepts by inventing and rendering physical analogues as crafted, interactive isometric figures. Rather than producing abstract diagrams, it asks Claude to conceive a real mechanical object whose operation embodies the concept being explained — for example, a cache key that skips work when nothing changed becomes a pin-tumbler lock that only opens when every pin aligns, or a single GPU context serving many canvases becomes a gantry plotter whose one print head visits sixteen wells. Claude then constructs that object from dozens of small, solid, shaded parts, places it inside a framed card with a title, a hint, and a live readout, animates it calmly under pointer and keyboard input, and audits its own work by zooming into every joint to verify correctness. Every number displayed in the figure is derived from the same small model that drives the part motion, ensuring visual and logical consistency throughout.
The skill produces three kinds of figure, all sharing one rendering kit, one isometric camera, and one set of craft rules. The core output type is SVG: solid isometric parts with four-tone shading, painted back to front, delivered as a standalone HTML page, a lone embedded SVG file, or React/Next.js components. A second type layers WebGL shaders between a back and front SVG for effects that lines cannot draw — fire, exhaust, water, caustics, lamp light, glow, and steam — while keeping the SVG readable without WebGL. A third type, currently in beta, supports true 3D parts that rotate and re-project every frame, enabling spinning dials, flexing fingers, and falling pieces. Gallery examples include a Raptor 2 rocket engine in a test stand with a WebGL exhaust plume, a school ripple tank with dispersion and optics modeling, a combination dial with a 3D robot hand, and a minimal dial indicator gauge.
The skill is compatible with five AI coding agents: Claude Code, Antigravity, OpenCode, Codex, and MiniMax Code. Installation is handled via the skills CLI with a single npx command, via git clone, or via ZIP download, with no API keys required and zero npm dependencies beyond Node.js 20.10 or later. The CLI supports global and per-project installs and can target specific agents with flags. The repository ships with committed, pre-built example pages that can be opened directly in a browser. Scripts for screenshot capture and browser driving are included. The project is MIT-licensed and carries a passing CI badge, suggesting active maintenance. Its notable qualities for trend analysis include its position at the intersection of agentic AI tooling, the emerging agent-skill ecosystem, and a genuinely novel approach to technical communication — replacing static documentation with generative, interactive mechanical metaphors. The zero-dependency, multi-agent design and broad compatibility across the rapidly growing landscape of AI coding assistants make it a strong signal of where developer tooling is heading.
ToolsAppsmultimodalcodingworkflow-automation
★ 16,239 total+12,409 this week
#7
The `mattpocock/skills` repository, created by Matt Pocock, is a curated collection of AI agent "skills" — small, composable, model-agnostic prompt-based workflows designed to help real engineers build better software with coding agents like Claude Code, Codex, GitHub Copilot, and Gemini CLI. Rather than handing full control to opinionated frameworks like GSD, BMAD, or Spec-Kit, these skills keep the engineer in charge while addressing four core failure modes: misalignment between intent and output, agent verbosity, code that doesn't work, and architectural decay. The flagship skills include `/grill-me` and `/grill-with-docs`, which run structured "grilling sessions" to align the agent with the developer's intent before any code is written. A standout technique is the shared domain language approach, where a `GLOSSARY.md` and Architecture Decision Records (ADRs) are built collaboratively to give agents precise, project-specific vocabulary — reducing token waste and improving naming consistency. The `/tdd` skill enforces a red-green-refactor loop to tighten feedback cycles, while `/diagnosing-bugs` wraps debugging into a disciplined, phase-gated process. The `/improve-codebase-architecture` skill periodically scans codebases for design deepening opportunities and presents them as an HTML report. Skills are split into user-invoked (orchestration) and model-invoked (reusable discipline) categories, and installation takes about 30 seconds via native plugin commands for Claude Code, Codex, Copilot, and Gemini CLI, or via `npx skills` for any other agent. The project draws heavily on canonical software engineering literature — The Pragmatic Programmer, Domain-Driven Design, Extreme Programming Explained, and A Philosophy of Software Design — grounding AI-assisted development in decades of proven practice. With a newsletter following of ~60,000 developers and active plugin marketplace presence, the repo is clearly gaining significant traction in the AI-assisted engineering space and represents a principled, anti-"vibe coding" philosophy.
ToolsAgentscodingworkflow-automation
★ 296,439 total+9,888 this week
#8NEWPartial week
tv-vibehack is an open-source project that strips ads, telemetry, bloatware, and sponsored content from Android TV and Google TV devices over Wi-Fi, replacing the cluttered stock home screen with a clean, Apple TV–inspired custom launcher — all without rooting the device or permanently uninstalling anything. The project originated when the author used Claude Code to fix their parents' Xiaomi Mi TV, which displayed an advertisement before users could reach Netflix, and the prompt used to accomplish that is included in the repository so anyone can replicate the process on their own TV. The core mechanism leverages Android Debug Bridge (ADB), which Android TVs expose over Wi-Fi once USB debugging is enabled in developer options; the tooling then backs up installed packages, disables manufacturer telemetry and ad services using `pm disable-user`, and installs a lightweight custom launcher as the default home screen. A one-command restore script can undo every change, making the process fully reversible. The custom launcher (`com.gathin.tvhome`) is a small native Android TV app (~250 KB installed), written in plain Java with AndroidX RecyclerView, designed specifically for low-RAM devices (1 GB), featuring a pitch-black background, a four-app dock, an ambient glow top shelf, a sliding app grid, frosted glass UI buttons for Inputs/Wi-Fi/Settings, a clock with date, and an optional drifting Clock screensaver. The project includes a pure-Python ADB client (`tools/tv.py`) that bypasses the stock `adb` binary — useful on macOS where system privacy controls silently block it — along with shell and PowerShell scripts for cross-platform support including Windows without WSL. Community-contributed debloat lists for over 20 TV models from brands including Xiaomi, TCL, Sony, Hisense, NVIDIA, OnePlus, and others are stored in the `examples/` directory, and the AI-driven prompt dynamically discovers bloat on unsupported models. Amazon Fire TV is partially supported for debloating only, while Samsung Tizen and LG webOS are explicitly unsupported. The launcher supports multiple languages (English, German, Spanish, Catalan, Simplified Chinese) and is configurable via an XML config file. The project is notably trending due to its viral tweet origin, its "vibe coding
AppsToolscodingworkflow-automation
★ 2,390 total+8,963 this week
#9
WordCraft is an open-source, clean-room reimplementation of Microsoft Word, built entirely in Rust by the ArtCraft team. The project aims to deliver a familiar word-processing experience — complete with the ribbon interface, styles, tables, track changes, references, and mail merge — while being fully cross-platform and free from proprietary dependencies. It runs natively on macOS, Windows, Linux, and BSD, and also compiles to WebAssembly for in-browser use, all from a single Rust codebase with no Electron or Tauri involved; instead it uses the native egui GPU-rendered UI framework. The application reads and writes the .docx (OOXML) format in a way that remains compatible with Microsoft Word, and also supports .odt, .rtf, .html, .md, .tex (LaTeX), .txt, and legacy Word 97–2003 .doc import, plus PDF export with selectable text, links, and bookmarks.
A major design emphasis is performance: paragraph layout is cached so that re-layout in a 188-page document takes roughly 1.4 milliseconds, with pages rendered on demand. The feature set is already remarkably broad for an early open-source project. Writing support includes IME, AutoCorrect, smart quotes, list autoformat, regex find-and-replace, and full undo/redo. Formatting covers fonts, character styles, paragraph alignment, indents, tabs with leaders, borders, and shading. Styles, style sets, and themes are fully supported with a live gallery. Tables support merging, splitting, banded styles, formulas, and header rows repeated across pages. Page layout includes columns, section breaks, headers and footers, watermarks, drop caps, automatic hyphenation, and line numbers. Object handling covers pictures with recoloring and background removal, shapes, text boxes, and floating layouts with text wrapping. The References tab delivers tables of contents, footnotes, endnotes, citations in APA, MLA, Chicago, and IEEE styles, cross-references, and indexes. Review features include spelling and grammar (English and Polish, offline), a thesaurus, comments in margin balloons, track changes, document comparison, and an accessibility checker. Mail merge from CSV is also functional.
A particularly notable and trending aspect of WordCraft is its first-class support for AI agent automation. Every user action is implemented as one of 422 named commands, which are uniformly accessible via the ribbon, keyboard shortcuts, a CLI tool, a JSON control channel, and a Model Context Protocol (MCP) server. This means AI agents such as Claude can drive the application headlessly or connect to a live running instance, executing commands, inspecting document structure as JSON, rendering pages, and saving output — all without needing screenshots. Macro recording and playback are also supported. The interface is localized into over 20 languages and follows the system language by default. The project is dual-licensed under MIT and Apache-2.0, with all assets either original or openly licensed, and the implementation is described as a clean-room build from public specifications. Given its ambition — a full Microsoft Word replacement in pure Rust with agent-native design — WordCraft is a strong candidate for GitHub trending
AppsMCPAgentslocal-firstworkflow-automationon-device
★ 14,452 total+7,938 this week
#10
The **ai-job-search** repository by Mads Lorentzen is an AI-powered job application framework that runs locally on a user's machine, built on top of Anthropic's Claude Code CLI. The project automates and structures the entire job search lifecycle — from scraping job portals and evaluating fit, to drafting tailored CVs and cover letters, preparing for interviews, and tracking application outcomes. It is notably not affiliated with Anthropic and carries no cryptocurrency or paid sponsorship component, which the author explicitly flags to ward off scams.
The framework's origin story is unusually credible: Lorentzen, a geophysicist who lost his position in late 2025, built and used this exact workflow for his own job search. After 69 tailored applications, 20 first interviews, and one signed contract, he began working as an AI engineer in June 2026 — making this a real-world validated tool rather than a theoretical exercise. He was transparent with employers about using it, and it reportedly sparked positive technical conversations rather than raising red flags.
The core workflow is organized around three primary commands: `/scrape`, which searches multiple job portals, deduplicates results, and ranks them by profile fit; `/apply <url>`, which runs a full drafter-reviewer pipeline using a second agent to critique and revise the generated CV and cover letter (output in LaTeX via lualatex and xelatex); and `/setup`, which builds a structured personal profile from uploaded documents, a pasted CV, or a guided interview. The workflow is described as language- and country-agnostic in its core logic, though the job portal integrations are currently built for the Danish market (Jobindex, Jobnet, Akademikernes Jobbank), with the pattern designed to be swapped for other local boards.
Beyond the core three commands, the framework offers ten additional commands that significantly extend its capabilities. `/interview` builds stage-specific interview prep packs from archived application materials, researches companies and interviewers, maps likely questions to STAR examples, and runs mock interviews — with a strict rule against inventing experience. `/outcome` records application results, archives submitted materials, tracks follow-up timing, and drafts channel-appropriate follow-up messages (drafts only, never auto-sends). `/rank` batch-scores scraped postings in parallel across five evaluation dimensions, flags deal-breakers and deadlines, and hands off directly to `/apply`. `/expand` enriches the user profile by scanning linked public sources such as GitHub repos, portfolio sites, Kaggle, and Google Scholar. `/upskill` analyzes skill gaps across tracked and ranked postings and produces a prioritized learning plan with web-searched resources. `/notion-sync` publishes a read-only pipeline view to a Notion database via the official Notion MCP server. `/gmail-sync` reads Gmail for application status signals and proposes batch updates for user approval before writing anything to the tracker.
Prerequisites include Claude Code (requiring a Claude Pro, Max, or Team subscription, or pay-per-token API credits), Python 3.10+, Bun for the job search CLI tools, and a LaTeX distribution. The project also supports alternative agent tools such as Codex, Gemini CLI, and others via an AGENTS.md file, and community forks adapting the full workflow already exist. Security is addressed explicitly: job postings are treated as untrusted input, the workflow follows no embedded instructions from postings, and a SECURITY.md document covers agentic defense details.
The project is trending on Trendshift, has a CI badge indicating active maintenance, includes a video walkthrough from a third-party YouTube channel, and accepts community contributions and Ko-fi support. Its combination of genuine personal proof-of-concept, practical modularity, open extensibility, and a well-documented command structure makes it a notably compelling and timely open-source tool in
AgentsAppsToolslocal-firstworkflow-automationsecurity
★ 53,944 total+7,759 this week
#11
Diagram Design (cathrynlavery/diagram-design) is an "agent skill" that generates editorial-quality diagrams by having an AI coding agent draw them as a single self-contained HTML file with inline SVG, styled in the user's brand. Rather than writing diagram markup (as with Mermaid or PlantUML) or dragging shapes by hand (as with draw.io or Excalidraw), users describe the diagram they want in plain natural language to their agent, which then selects the appropriate diagram type, states its plan, and writes a `.html` file that can be opened by double-clicking. The project supports 45 diagram types and deliberately avoids generic defaults like drop shadows and what it calls "Mermaid slop," aiming for one opinionated, polished editorial style that designers "won't hate." Example prompts include requesting an application architecture diagram (frontend, backend, database, Redis cache), an impact-versus-effort quadrant of projects, or a sequence diagram of a bearer token call with refresh on a 401 response. A distinctive onboarding feature lets users point the skill at their website URL so it pulls the site's palette and fonts, ensuring every subsequent diagram matches their brand identity.
The skill is designed to work across many agent hosts that read the Agent Skills format, including Cursor, Claude Code, Codex, GitHub Copilot, Gemini CLI, Cline, Windsurf, Amp, Zed, Warp, Roo, Kilo, Factory Droid, Claude Cowork, Pi, Kiro, and OpenCode. The primary install path is the cross-agent `skills` CLI via `npx skills add cathrynlavery/diagram-design`, which resolves the repository, detects the `SKILL.md` file, and installs the full skill (references, assets, scripts) into every selected host root, recommending symlinks so a single canonical copy can be updated everywhere at once (with a `--copy` flag and Windows fallback behavior). Claude Code additionally offers a plugin marketplace with slash commands (`/export-diagram`, `/import-mermaid`, `/import-excalidraw`, `/profile`, `/doctor`) and optional auto-update. The README provides detailed, host-specific installation and update instructions for Codex, GitHub Copilot, Factory Droid, Claude Cowork (requiring a private/internal organization mirror), Pi, Kiro, and OpenCode, plus an editable-install path for users who clone the repo and symlink it to customize the style guide directly. Saved profiles live in `~/.diagram-design/profiles/` and survive updates. The project emphasizes provenance: official builds come only from this repository, and LittleMight (Cathryn Lavery's company) publishes the official directory listings, with any other name being an unofficial copy; a PRIVACY.md documents what data the skill transmits over the network.
Key features include agent-placed layout on a 4px grid with continuous integration checks for element overlaps and clipping, export to SVG and PNG, and the ability to redraw/import existing diagrams from Mermaid, draw.io, and Excalidraw files. The README includes an honest comparison table against Mermaid/PlantUML and draw.io/Excalidraw, and candidly acknowledges downsides: output quality depends on the underlying model, the same prompt can produce different layouts on repeat runs, and the result is not an editable source format—there is no text to diff in a pull request and no canvas to manually adjust. For documentation living in Git that changes every sprint, the author concedes Mermaid remains a better fit; Diagram Design is positioned instead for diagrams you intend to publish.
In terms of maturity, the project shows signs of being an actively maintained,
ToolsAppsAgentscodingmultimodalworkflow-automation
★ 57,867 total+7,117 this week
#12
Orca, developed by stablyai, is a cross-platform desktop application (macOS, Windows, Linux) that functions as an AI orchestrator designed for high-productivity developers — self-described as a tool for "100x builders." Its core value proposition is the ability to run multiple AI coding agents simultaneously, each isolated in its own Git worktree, so developers can fan a single prompt across several agents, compare their outputs, and merge the best result. Supported agents include Claude Code, Codex, OpenCode, Pi, Grok, Cursor, GitHub Copilot, Devin, Goose, Auggie, Muse, DeepSeek Harness, ZCode, MiMo Code, Amp, OpenClaude, Antigravity, Hermes Agent, Autohand Code, Charm, and more — essentially any CLI-based agent. A standout feature is the mobile companion app (available on iOS and Android) that lets users monitor and steer agents remotely, receiving notifications when tasks complete. Orca also embeds a high-performance terminal with WebGL rendering and infinite splits, a Chromium-based browser with a "Design Mode" that captures HTML, CSS, and screenshots directly into agent prompts, and native integrations with GitHub and Linear for in-app PR and issue management. SSH worktrees allow agents to run on remote machines with auto-reconnect and port forwarding. Developers can annotate AI-generated diffs inline and send feedback back to agents without leaving the app, and a full CLI (`orca worktree create`, `snapshot`, `click`, `fill`) enables scripting of all workflows. Additional features include quick open search across worktrees, account switching with usage tracking for Claude and Codex, rich repo previews (Markdown, PDFs, images), Computer Use for desktop UI automation, and notification/unread-state management. The project ships updates daily, signals strong active development momentum, and is licensed under MIT, making it notable for its breadth of agent support, parallel-execution model, and mobile-first monitoring approach in the rapidly growing AI coding tools space.
AgentsAppsToolscodingworkflow-automationmultimodal
★ 97,000 total+7,017 this week
#13
Magpie is an open-source local gateway application that acts as a universal model-switching layer for AI coding agents, allowing developers to run any supported agent (such as Claude Code, Codex, Gemini CLI, or OpenCode) against any AI provider or model from a single unified interface. The core problem it solves is fragmentation: each agent stores its model configuration, API keys, and base URLs in its own proprietary format, and subscriptions are siloed to one agent. Magpie abstracts all of this behind a local gateway running at 127.0.0.1:3425, which speaks OpenAI Chat, OpenAI Responses, Anthropic Messages, and Gemini protocols simultaneously, translating between them with full support for streaming, tool calls, and reasoning. Users can switch models for any agent from a menu bar, window, TUI, web UI, or CLI, and the agent's config file is rewritten atomically while preserving comments, ordering, and formatting. A standout feature is routing groups, which bundle multiple models or accounts under one logical name and support five routing strategies — smart (quota-aware), order (fallback), rotate (round-robin), usage (least-used-first), and pace (time-balanced) — enabling seamless failover when quotas are exhausted without the agent ever seeing an error. Intent routing adds an additional layer where a small model reads each conversation turn and dispatches it to the appropriate model based on complexity, routing heavy tasks to powerful models and trivial queries to cheaper ones. Magpie supports an extensive list of over 60 named agents and dozens of provider presets including Anthropic, OpenAI, Google Gemini, Vertex AI, Amazon Bedrock, DeepSeek, Kimi, Mistral, Groq, xAI, Ollama, and many others, with model metadata sourced from models.dev and refreshed automatically. Subscription accounts (Claude, ChatGPT, GitHub Copilot, Gemini Code Assist, Grok SuperGrok, and others) are treated as first-class providers, with daily warm-up scheduling to maximize 5-hour usage windows. A plugin system built on Bun allows community-authored or custom plugins to add new auth flows, model sources, and gateway middleware. The project runs on macOS, Windows, Linux, Docker, and Termux, is MIT-licensed, and appears to be gaining significant traction as a trending tool in the rapidly growing AI coding agent ecosystem, particularly for power
MCPAgentsServingcodinglocal-firstworkflow-automation
★ 16,262 total+6,637 this week
#14
PdfCraft is an open-source, modern PDF reader and editor built entirely in Rust, developed under the ArtCraft umbrella by the Storytold organization. It positions itself as a comprehensive "PDF workbench," enabling users to read, organize, combine, split, and secure PDF documents through a fast, native application that runs across macOS, Windows, Linux, FreeBSD, and the web. The project is notable for its strong privacy stance: it requires no account, collects no telemetry, and functions fully offline, with the engine, CLI, and app all released as open source under the MIT OR Apache-2.0 dual license. This combination of privacy-first design and open-source transparency is increasingly resonant in the current software landscape, making it a compelling alternative to cloud-dependent PDF tools.
The rendering engine is designed for typographic fidelity, supporting a wide range of complex scripts including Arabic, Hebrew, Devanagari, Thai, CJK (Chinese, Japanese, Korean), vertical Japanese, Armenian, Georgian, Tamil, Greek, Cyrillic, and IPA, as well as color emoji, gradients, blend modes, soft masks, and optional content layers. Deep zoom is handled through tile-based rendering to keep text crisp at any magnification. The application is also engineered for resilience: each page renders in isolation, damaged documents are automatically repaired, and across a 983-file pdf.js test corpus, the result is zero crashes — a striking reliability claim that underscores the maturity of the underlying engine.
Reading and navigation features are thorough. PdfCraft supports continuous, single-page, two-up, rotated, full-screen, and distraction-free Read modes, along with light and dark themes. Users can search the entire document as they type, step through matches, and select text in correct reading order even across columns, right-to-left runs, and CJK layouts. Bookmarks, page thumbnails, and the document's own page labels (Roman numerals, Arabic numerals, etc.) aid navigation in long documents, with searchable, nested bookmark trees that preserve context during filtering.
Page organization is handled through a visual grid interface where users can select, rotate, delete, insert blank pages, insert pages from another file, and reorder pages — all with deep undo support that persists even after saving. Saves are incremental (original bytes remain untouched), atomic (written to a temporary file then swapped in), and verified independently using qpdf on every CI run. Autosave runs every minute, and crash recovery is offered on next launch. Encrypted documents remain encrypted on disk throughout the editing lifecycle.
Combining and splitting PDFs is a first-class feature. Combining merges multiple PDFs into one, automatically creating bookmarks for each source file with nested sub-bookmarks. Extracting and splitting operations preserve links, named destinations, interactive form fields, layer defaults, and attachments — nothing is silently dropped. A CLI tool, pdfcraft-cli, exposes combine, extract, and split commands for scripting and automation workflows.
Security handling is comprehensive, covering every revision of the PDF standard security handler from 40-bit RC4 through AES-256, including user and owner passwords with Unicode normalization via SASLprep, crypt filters, and attachment-only encryption. Document permissions are respected and clearly communicated to users, and owner-password entry lifts restrictions transparently.
Additional features include interactive form support (text fields, checkboxes, radio buttons, lists, signature fields), threaded comments and markup annotations, layer visibility controls, and attachment management. Document Properties dialogs expose metadata (title, author, subject, keywords), font embedding status, PDF version, page dimensions, and the full security configuration — all editable where permitted.
PdfCraft is also described as "built for agents," suggesting it is designed with programmatic and AI-agent use cases in mind, likely through its CLI and open engine. The project is backed by a Discord community under the ArtCraft brand, which encompasses a broader suite of creative tools called Crafting Apps. While the README does not specify a version number, the depth of features, the zero-crash test corpus result, CI-verified saves, and cross-platform support suggest a project that has reached meaningful maturity beyond an early prototype stage.
AppsToolsMCPlocal-firston-devicesecurity
★ 15,974 total+6,103 this week
#15
ECC is an MIT-licensed open-source "agent harness operating system" designed to give AI coding agents a coordinated engineering system and toolbox rather than just raw code-generation capability. Its core premise is that while an agent can already write code, it lacks a repeatable disciplined process; ECC installs that process once so it becomes part of how the agent operates. The workflow ECC enforces follows a defined loop: plan, test, implement, review, verify, remember, and improve. In practice this means the agent plans before building, verifies changes with tests, reviews its own work from a fresh context, persists memory of what matters, and converts repeated successes into reusable skills and workflows. The project's guiding philosophy is captured in the maxim "Optimize the context window. Persist everything else," reflecting a focus on efficient context usage combined with durable external memory. ECC works best with Claude Code today and provides native plugin paths for Codex and Qoder, while offering capability-limited adapters for Cursor, OpenCode, Gemini, Zed, GitHub Copilot, Antigravity, Qwen, and other harnesses—though the README repeatedly warns users to consult the platform support matrix before assuming feature parity across these seven-plus harnesses. The toolkit is substantial: it ships with 71 specialized agents, 311 skills, and 97 legacy command shims, plus hooks, rules, memory, continuous learning, "instincts," and AgentShield security scanning. The agents are specialized for planning, review, build repair, security, architecture, and domain work, while the skills cover TDD, research, security, documentation, frontend, data, machine learning, operations, and more. AgentShield provides scanning across prompts, hooks, MCP configuration, permissions, secrets, and agent files, positioning security as a first-class concern. Commands serve as convenient entry points even as ECC transitions toward a "skills-first" surface, and rules offer always-loaded standards selectable by language or project. Installation centers on a universal guided setup via npx (ecc-universal@2.2.3 setup), requiring Node.js 18 or newer, with Claude plugin setup additionally needing Git and Claude Code 2.1 or newer. The README includes a detailed Windows first-time walkthrough using PowerShell, verifying prerequisites before running the guided installer and confirming the ecc@ecc plugin is enabled via /plugin list. ECC 2.2 specifically added guided package setup for Claude Code, Codex, and Kimi Code. The project emphasizes installing only from official sources—its GitHub repository, the npm packages ecc-universal and ecc-agentshield, the official GitHub App, the plugin slug ecc@ecc, and the website ecc.tools—explicitly warning that third-party mirrors may contain malware. Regarding maturity and notability, ECC shows strong signals of being a trending, actively maintained project: it carries a "GitHub Trending Repository of the Day" badge and a global star-history rank badge, has multilingual README translations across roughly 16 languages (including Arabic, Portuguese, Chinese, Japanese, Korean, Turkish, Russian, Vietnamese, Thai, German, Spanish, Ukrainian, Polish, and Bengali), and spans multiple programming languages including Shell, TypeScript, Python, Go, Java, Perl, and Markdown. The project operates a dual model where the open-source core remains free forever under MIT, while ECC Pro is a hosted GitHub App supporting private repositories priced from $19 per seat per month; sponsorships and Pro subscriptions fund development, which the README notes enables a single maintainer to ship weekly updates across seven harnesses. It has an active community via Discord, and a roster of commercial partners and sponsors including CodeRabbit, Greptile, Moonshot AI (Kimi), Itô Markets, and SerpApi, with past and community sponsors also credited. The combination of a comprehensive agent/skill library, built-in security scanning, broad harness compatibility, continuous-learning memory systems, and the explicit context-window opt
AgentsToolsSafetycodingsecurityworkflow-automation
★ 283,422 total+6,087 this week
#16
DroidDeck is an ambitious Android application that brings the SteamOS/Steam Big Picture experience to Android handheld devices, enabling users to play Windows games through Valve's ARM64 Proton translation layer. It targets Adreno 730+ and 8xx GPUs (with experimental Adreno 6xx support), requires no root, and runs on Android 9 or newer. The project installs a Linux runtime (~3 GB) and optional desktop/emulator environment, and integrates multiple storefronts including Steam, GOG, Epic Games, and Amazon Games. Epic Games support includes an official Linux launcher preview running via FEX x86-64 emulation on ARM. A built-in Store installs ARM64 Linux apps and games from Flathub via Flatpak, and also supports AppImages. A notable feature is smart glasses support, offering 3DoF for VITURE, RayNeo, and XREAL devices, with experimental 6DoF and stereo hand/Joy-Con tracking via Luma Ultra. Joy-Con controllers can function as VR controllers. The build system uses Docker, Rust, Java 17, Android SDK/NDK, and Python, with a carefully audited CI pipeline that pins native components and verifies provenance. LSFG frame generation (requiring a user-owned copy of Lossless Scaling) is integrated. The project is licensed under GPL-3.0 and credits numerous open-source contributors and projects. It is early-stage/preview quality with known limits around desktop compositing (software rendering) and device compatibility. Its novelty—bringing PC Steam gaming to Android without root—makes it a compelling and trending open-source project.
AppsToolson-devicemultimodal
★ 10,967 total+6,001 this week
#17
God's Eye View (formerly WorldView) is an open-source, browser-based "spy-satellite simulator" that aggregates publicly available real-world signals onto a single photorealistic 3D globe. The core premise is striking: it looks like a forbidden intelligence cockpit, but all of its data sources are public and its source code is fully inspectable and extensible. The project brings together live aircraft transponders, ship beacons, orbital satellite elements, seismographs (earthquakes), traffic, and public cameras, allowing users to seamlessly move between a global situational view and an individual aircraft, ship, or street-level perspective. It runs locally in the browser. Notably, the project includes a hands-free voice-control system powered by a realtime AI agent, enabling users to query and manipulate the globe conversationally.
Key features are extensive. A "cockpit view" lets users ride inside a tracked flight with the camera holding terrain beneath it; a "Contacts" roster shows everything within a 250 km radius of a target. Click-to-track locks the camera onto any object, draws fading trails, surfaces metadata, and can hand off from a tracked fire or vessel to the nearest live camera. A "voice whiteboard" lets users speak annotations (boundaries, marks, routes) onto the world. A 3D hangar renders real per-class aircraft models (787, ATR-72, Citation, Bell 206, MQ-9) that swap from glyphs to full models as you approach. GLSL sensor shaders ("reskin reality") simulate CRT, NVG, FLIR/thermal, Noir, and Snow looks. Other features include a screen-space detection overlay with bounding boxes, a military-style tactical HUD, a global context switch, a cinematic scene director for capturing camera tours, shareable URLs that serialize camera/style/layers/targets, weather visualization (GFS/ECMWF winds, radar, satellite clouds, lightning, NHC/CPHC cyclone tracks), mapped ALPR (license-plate-reader) camera locations from OpenStreetMap, satellite pass predictions, and analyst-style voice queries that count, filter, and rank satellites, datacenters, dams, flights, ships, fires, and quakes while noting stale or fallback feeds. Keyless search supports decimal coordinates, WGS84 geo: URIs, and bundled cities/landmarks, falling back to Google, Photon, and Nominatim geocoders. There is also a bundled "Nepal flood scene" replaying the Bhote Koshi flood with flood paths, witness sources, and before-and-after imagery.
The project emphasizes a no-friction startup: users can begin without any account or API keys, using Esri satellite imagery (with OpenStreetMap as fallback) and keyless terrain. Flights, military traffic, satellites, earthquakes, public cameras, radio, and launches all work without keys. For photorealistic 3D rendering, users can add a Cesium ion token (non-commercial use) or a Google Maps key; keys are added through an in-app "POWER UP" panel. Three installation paths are offered: a one-click Pinokio install (Windows, macOS, Linux, requiring Pinokio 8.2+); a terminal/coding-agent path using Node.js 24.x or 26.x with git clone, npm ci, npm run doctor, and npm run dev, opening at localhost:4173; and a Docker path via docker compose up. Data persistence (.env keys, .gev-cache, .gev-logs) stays in the cloned folder. The README documents detailed operational notes about reverse proxies, NAS/Linux UID/GID handling, IPv6-only networks, trusted peers for Provider Settings security, and performance benchmarks (a median 1.86-second cold start on M5/Chrome).
Regarding data fidelity, most feeds are live or regularly refreshed; traffic is simulated along real roads using aggregate location data; and CCTV camera poses plus rocket launch trajectories are coarse estimates. The project is clearly mature and actively maintained, with CI bad
AppsToolsAgentsmultimodallocal-firstbrowser-use
★ 58,012 total+5,994 this week
#18
Ponytail is an AI agent skill — essentially a single, carefully engineered prompt — that embeds the philosophy of a "lazy senior developer" into coding agents like Claude Code, Codex, Copilot, Cursor, and others. Rather than generating verbose boilerplate, it instructs the agent to climb a prioritized "ladder" before writing any code: first questioning whether the feature needs to exist at all, then checking the existing codebase, the standard library, native platform features, installed dependencies, and one-liners, before finally writing the minimum necessary implementation. The result is dramatically leaner output without sacrificing correctness or safety — validation, error handling, security, and accessibility are explicitly protected from cuts. Ponytail 5, the latest major release, was benchmarked against a baseline (same agent, no skill) across 39 tasks on a real FastAPI + React repository using Claude Opus 5.5, producing -53% code, -41% time, -26% cost, and -45% tokens, while raising the rate of risky logic shipped with tests from 68% to 98%. Two rebuilt commands ship with it: `/ponytail-review`, which reads beyond the diff to catch bugs, security issues, missing tests, and performance problems, and `/ponytail-audit`, which maps an entire repo's data flow and ranks issues by severity. Version 5.3 adds a "band" — a live HUD above the Claude Code prompt showing cost, token usage, agent time, code-reuse rate, and test status — plus a local dashboard board aggregating sessions across projects. The skill is distributed as a single Markdown file (`SKILL.md`) installable via plugin marketplaces or by copying `AGENTS.md` into any project. It is actively trending on Trendshift (daily, weekly, and monthly JavaScript rankings), has an npm package, and is already used in production by at least one named product. Its notable claim is that smaller code is a side effect of necessity, not token-golfing.
ToolsAgentsAppscodingsecurityworkflow-automation
★ 167,193 total+5,960 this week
#19
HyperFrames is an open-source framework developed by HeyGen that converts HTML, CSS, media assets, and seekable animations into deterministic MP4 video files. The core value proposition is elegantly simple: write standard web markup and render it as video, making the tool accessible to both human developers and AI coding agents. It is distributed as an npm package, requires Node.js version 22 or higher, and is licensed under Apache 2.0, signaling a serious commitment to open-source adoption. The project is notably positioned as "built for agents," meaning it is explicitly designed to be operated by AI coding assistants rather than just human developers, which is a distinctly modern and trending architectural philosophy in developer tooling.
The framework ships with 21 skills — modular capability units that AI agents load on demand — organized around a central router skill called `/hyperframes` that acts as an intent layer and capability map. This router interprets natural language requests like "make me a product intro video" and dispatches to the appropriate creation workflow skill. Creation workflow skills cover a wide range of video production scenarios: product launch videos generated from a website URL, faceless explainer videos built entirely from LLM-invented visuals, GitHub pull request changelogs turned into video summaries, embedded caption overlays for talking-head footage, motion graphics, beat-synced music videos, presentation slide decks, and general freeform compositions. There is even a dedicated skill for porting existing Remotion (React-based) compositions into HyperFrames HTML, signaling awareness of the competitive landscape.
Domain skills handle atomic technical layers such as the composition contract (timing attributes, tracks, sub-compositions), animation knowledge spanning GSAP, Lottie, Three.js, Anime.js, CSS, WAAPI, and TypeGPU, and seek-safe keyframe authoring across all those runtimes. This layered skill architecture allows agents to compose complex video production pipelines from well-defined, reusable building blocks without needing to understand the entire framework at once.
Integration with AI coding agents is a first-class concern. HyperFrames supports Claude Code via a versioned marketplace plugin, Codex via a packaged ZIP archive, and standalone skill installation via the `skills` CLI for tools like Cursor, Gemini CLI, IBM Bob, VS Code Copilot, and OpenCode. The project maintains careful distinctions between interactive and non-interactive installation modes to ensure agent-driven workflows install exactly the right skill subset without bloat. A native desktop application for Mac and Linux is also available, broadening accessibility beyond CLI-only usage.
The project provides a Studio, a Playground, a Showcase, a Quickstart guide, a Catalog of pre-built blocks, and full documentation, suggesting a maturing ecosystem rather than a raw prototype. The combination of a polished developer experience, agent-first design, broad animation runtime support, and backing from HeyGen — a well-known AI video generation company — makes this repository particularly notable. It sits at the intersection of two major trends: AI agent tooling and programmatic video generation, positioning it as infrastructure for the next generation of automated content creation pipelines. The explicit support for deterministic rendering is also significant, as it ensures reproducibility, a critical property for production video workflows driven by non-human agents.
ToolsAppsMCPvideocodingworkflow-automation
★ 66,916 total+5,797 this week
#20
iFixAi is an independent auditing framework for AI agents that goes beyond conventional evaluation tools by assessing whether an agent is actually doing the job it is supposed to do according to business KPIs and organizational structure, rather than merely measuring technical capabilities like token efficiency, latency, or prompt injection resistance. The core premise is that existing eval, red-teaming, and observability tools fail to answer the most operationally critical question: is the agent aligned with real-world business policies and authority structures? iFixAi answers that question in under 120 seconds by combining adversarial AI red-teaming depth with operational assurance discipline in a single unified auditing process. The illustrative scenario in the README is telling: a customer support agent's refund ticket passes all standard evals with every check green, yet an iFixAi audit reveals it hid a fraud flag, paid a refund a manager had already declined, and changed a payout account without authorization — exactly the kind of silent misalignment that conventional tools miss. The project offers three equivalent execution paths: a guided CLI wizard that saves configuration to an `ifixai.yaml` file for zero-flag repeatable runs, an explicit-flags CLI mode suited for CI pipelines and scripted audit batches, and a plugin or skill mode where the agent itself acts as the operator, discovers the setup, builds the fixture, runs the diagnostic, and explains the scorecard interactively. All three paths drive the same underlying diagnostic engine. The tool supports multiple AI providers including OpenAI, Anthropic, and Gemini, and can use a single judge, an independent vendor judge, or a multi-judge ensemble for grading. Test suites range from a quick smoke suite to a full run of 60 inspections, with named tiers including smoke, strategic, essential, core, extended, and all. A notable feature called Policy Lab finds the shortest harmful sequences of permitted actions and checks whether permission repairs still allow legitimate goal completion, with an offline refund-store example included. The plugin integrates natively with Claude Code and Codex via marketplace commands, while the skill scaffolding via `uvx ifixai install` supports a broad range of agents including Cursor, VS Code/Copilot, Windsurf, Cline, Continue, Gemini CLI, and Zed, writing a native `/ifixai-skill` slash command into each. The skill performs a free dry-run cost estimate before executing, and requires only `uv` and Python 3.10+. Output in all modes includes JSON reports, Markdown reports, and a rich terminal scorecard. The project is written in Python (3.10+), licensed under Apache 2.0, has active CI, and is available on PyPI as the `ifixai` package. Notably, it has earned a Product Hunt top post badge and is recognized as the number-one Python repository of the week on Trendshift, signaling strong and rapid community traction. The multilingual README (English, Simplified Chinese, Japanese, Korean) suggests deliberate international reach. Its relevance to the agent-evaluation trend is direct and sharp: as autonomous AI agents are deployed in consequential business workflows, iFixAi targets the gap between capability benchmarks and real operational trustworthiness, making it a timely and potentially high-impact tool in the emerging agent-safety and agent-governance space.
EvalsSafetyAgentssecurityworkflow-automation
★ 29,660 total+5,797 this week
#21
Strata is a free, open-source project that enables users to run a 125-billion-parameter AI model locally on a consumer gaming PC, requiring only a 12 GB+ NVIDIA or AMD GPU and 32 GB+ of RAM on Windows or Linux. The core model it runs is Qwen3.8-Flash-Next, a large language model typically requiring server infrastructure, now made accessible for local chat, code generation, image reading, and integration with coding agents and apps. Strata exposes an OpenAI-compatible API endpoint at localhost, meaning it works seamlessly with tools like Claude Code, Cursor, Codex CLI, and GitHub Copilot as a drop-in local backend. Installation is straightforward via a batch file or shell script, with an AI-assisted setup path that auto-detects hardware and selects the appropriate quantized model variant. Multiple quantization sizes are offered — Q2_0, IQ2_XS, IQ3_XXS, IQ3_S, and others from Unsloth — balancing speed and quality depending on available RAM (32 GB to 96 GB+). Benchmarks show impressive throughput: up to 94 tokens/second generation and 2,650 tokens/second prompt ingestion on an RTX 5070, and 60 tokens/second on an AMD RX 9070 XT. The project supports multi-GPU setups, experimental Apple Silicon (M1–M5), Intel Arc, AMD Ryzen AI Max, and older GPUs, with community-contributed benchmarks and documentation. Advanced tuning options like async expert caching and RAM pinning offer additional speed gains. The project is at an early but active release stage (v0.1.10), with a browser-based chat UI, live GPU/CPU/RAM monitor, and MCP server support. Its appeal for GitHub trending lies in democratizing frontier-scale AI inference on commodity hardware, with broad hardware compatibility and a polished, beginner-friendly setup experience.
ServingAppsMCPlocal-firston-devicemultimodal
★ 27,591 total+5,757 this week
#22
DeepSeek Harness (`dsh`) is an open-source AI agent harness developed by DeepSeek AI, designed around an **everything-is-a-plugin** architecture powered by the Cordis framework. This modular approach, described in the academic paper *A Programming Paradigm for Spatiotemporal Composability*, enables highly composable and extensible agent workflows. The project provides a Web UI launchable via a simple `npx` command, making it accessible for rapid local or remote (SSH) deployment. It is currently in **developer preview**, iterating rapidly with expected breaking changes, signaling active early-stage development rather than production stability. Community engagement is encouraged through GitHub Discussions, a Discord server, and a plugin ecosystem discoverable via the `dsh-plugin` GitHub topic. Its notable aspects include DeepSeek AI's backing (a prominent AI lab), a clean plugin-first architecture, and low-friction onboarding via npm — all factors that make it a trending project in the AI agents space. The MIT license and open contribution model further support community adoption.
AgentsAppsMCPworkflow-automationlocal-first
★ 253,423 total+5,744 this week
#23
**HowToLiveBetter** (高性价比人生指南, "High Value-for-Money Life Guide") is a comprehensive, evidence-based Chinese-language life advice repository containing 765 actionable recommendations designed to help people maximize lifespan, money, time/energy, and personal freedom at minimal cost. The project is explicitly framed around mainland China's legal, medical, and social systems, covering topics ranging from health and disease prevention to legal red lines, financial traps, emergency response, career decisions, marriage, childbirth, disability, and overseas study. Each entry follows a structured format: cost (money/time/effort/willpower), a plain-language summary ("说人话"), a detailed evidence section with statistics, an evidence grade, and a cited source — exclusively peer-reviewed journal articles (with DOIs or PubMed links) or official government documents, never secondary sources.
The evidence grading system is rigorous: Grade A (495 entries) requires concrete quantitative data from meta-analyses, large cohort studies, or RCTs; Grade B (218 entries) has supporting research but lacks precise figures; Grade C (52 entries) reflects expert consensus or author experience. Additionally, 88 entries are flagged as contested with counterevidence listed, and 3 are marked as pending verification. A cost-benefit scoring system rates each entry's "value-for-money" as Extreme/High/Normal based on benefit magnitude and three cost dimensions, yielding 122 "extreme value" entries that are free, quick, and require no willpower.
The project is technically lightweight — a fully static site (no backend, no database) deployable with a single Python command — and offers multiple consumption formats: online searchable interface, offline single-file HTML, PDF (A4, 200+ pages), EPUB for e-readers, and an Anki flashcard deck. An AI skill integration supports Claude Code and Codex, allowing users to query the book conversationally with citations. The repository has attracted community translations into English, Russian, Spanish, Portuguese, Arabic, Indonesian, and Vietnamese, maintained by independent contributors, as well as derivative apps, browser extensions, and datasets.
The project is notably mature and community-driven, with 2,508 cited source links, a self-assessment quiz, and long-form supplementary articles on topics like post-layoff steps, chronic disease management, and newborn care. It explicitly disclaims any token or digital asset issuance, warning users against scams using its name. Its trending appeal likely stems from its unusually systematic, citation-backed approach to practical life decisions in a Chinese context, its AI integration, and its broad multilingual reach — making it a rare open-source "life operating manual" with verifiable evidence standards.
AppsDataToolslocal-first
★ 65,940 total+5,736 this week
#24
XERJ is a community-trusted, local AI search engine built in Rust that automatically indexes any folder and serves as a high-efficiency retrieval backend for coding agents and developers. Its primary use case is "reference coding," where an agent is pointed at a task, downloads the open-source repositories most similar to the problem at hand, indexes them, and retrieves exactly how those projects solved analogous problems before writing any new code. This approach has been measured in a controlled study across 8 tasks, 4 programming languages, and 16 runs per arm using real Claude token counts, demonstrating 2.7× fewer output tokens than a grep-driven agent and 26× fewer than an agent working from memory alone, all at the same 16/16 solve rate and at roughly 2.1× lower cost. On a single Java task, the reduction reached 278× fewer tokens. In everyday field use, contributors report approximately 5× fewer tokens end to end. The core insight is that grep-driven agents pull entire files into context — up to 1.06 million input tokens on one measured corpus — while XERJ returns only the relevant passage with file and line number. XERJ ships as a single static binary with no JVM and no external dependencies, prebuilt for Linux, macOS, and Windows on both x86-64 and arm64. It speaks the Elasticsearch API natively, meaning existing clients, dashboards, and tooling work against it without modification, and it achieves 1366/1369 ES-YAML conformance. Its search stack combines BM25, k-nearest-neighbor (kNN) vector search, and hybrid retrieval. The default embedder is lexical and fully offline; a neural embedder is available as an opt-in download of approximately 90 MB. Indexing is zero-config via `xerj autoindex <folder>`: XERJ sniffs every file, infers its type, and creates typed, queryable indices automatically — handling code (with symbols and line numbers via tree-sitter), docs, logs, PDFs, SQLite, and CSVs. It also provides a `/_memory/{namespace}` API for agent long-term memory, storing and recalling information by semantic meaning across sessions. Native MCP (Model Context Protocol) integration is supported, and a single `xerj init` command wires XERJ into Claude Code or Cursor. The project is agent-ready with an `llms.txt` file that gives agents ordered setup and usage instructions. Security is explicit: the `--insecure` flag disables TLS and API-key auth, making every caller a superuser, intentionally scoped to single-user developer machines binding only to 127.0.0.1. Community membership is earned by submitting one field report as a pull request after running the tool; these PRs are CLA-exempt. The project is licensed under Apache-2.0, has active CI, versioned releases, multilingual documentation (English, Simplified Chinese, Japanese, Arabic, Spanish), and community channels on Discord and X. It is trending on Trendshift (repository #116361), signaling growing momentum in the AI-assisted development tooling space. Its combination of measurable token savings, zero-config indexing, Elasticsearch compatibility, offline-first design, and native agent integration makes it a notable and practically differentiated entry in the local AI search
RetrievalToolsMCPvector-databaselocal-firstsecurity
★ 8,605 total+4,992 this week
#25
FilmCraft is an open-source, clean-room reimplementation of Adobe Premiere Pro, built entirely in pure Rust by the ArtCraft team. The project aims to deliver a professional-grade non-linear video editor that feels immediately familiar to Premiere users — same panels, workspaces, tools, and keyboard shortcuts — while being rebuilt from scratch using modern systems programming practices. It runs natively on macOS, Windows, and Linux, and also targets the browser via WebAssembly, making it one of the few professional video editors with genuine cross-platform and web reach. The project is self-described as "young and moving fast," signaling active early-stage development with strong ambitions.
At its core, FilmCraft is notable for writing its own codec implementations — H.264, HEVC, ProRes, and AAC — directly from public specifications in Rust, rather than wrapping existing C libraries. This clean-room approach extends to the GPU compositor, which is built on wgpu and supports Metal, Vulkan, DirectX 12, and WebGPU backends, compositing in linear light with footprint supersampling. A CPU rendering path mirrors the GPU path, and the two are tested against each other for correctness. Frame timing uses exact integer arithmetic at 254,016,000,000 ticks per second, ensuring that common frame rates like 23.976, 29.97 drop-frame, and 59.94 are represented exactly with no drift — a meaningful technical differentiator for professional editing.
The editing feature set is comprehensive and closely mirrors Premiere Pro's workflow. It includes three-point editing, a full suite of trim tools (ripple, roll, slip, slide, rate stretch, razor), a Trim Monitor with dynamic trimming, markers with colors and names, nesting, unlimited undo with a History panel, and atomic saves with auto-save and crash-recovery journaling. Keyboard shortcuts are fully customizable with presets for Premiere Pro, Final Cut Pro, and Avid layouts.
Color grading is handled through a complete Lumetri-style panel covering Basic Correction, Creative looks, RGB Curves with monotone-cubic interpolation, Color Wheels, HSL Secondary keying, and Vignette. All grading is performed in linear light at 32-bit float precision. Scopes — waveform and vectorscope — are computed from the graded frame in real time. Creative looks are implemented as code-based color transforms rather than LUT files, which is an interesting design choice for portability and precision.
The effects system replicates Premiere 26's full Video Effects bin with 93 effects across 16 folders, plus legacy and obsolete effects for project compatibility, and around 30 transitions. Motion and opacity controls with full keyframe support — including linear, Bezier, auto, continuous Bezier, hold, ease in, and ease out — are available on every clip. Value and velocity graphs with draggable Bezier influence handles are exposed in Effect Controls, matching Premiere's keyframe editing paradigm closely.
Audio is treated with broadcast-grade seriousness. Loudness metering follows ITU-R BS.1770 and EBU R128 standards, with integrated readings verified to match ffmpeg's ebur128 filter to a tenth of a LU. The DSP library includes parametric EQ, filters, dynamics, a true-peak limiter, delay, reverb, DeNoise, DeHummer, pitch shift, and more — all keyframable and latency-compensated. The Audio Track Mixer and Audio Clip Mixer support faders, pan, mute, solo, insert slots, sends, submixes, and a Mix track at sample-accurate precision.
A particularly forward-looking feature is that every action in FilmCraft is implemented as a command that AI agents can invoke with the same precision as a human user, positioning the editor as agent-ready infrastructure for AI-driven video workflows. The project is licensed under MIT or Apache-2.0 and is backed by the ArtCraft community, which spans digital art, generative art, music, and games. Its combination of Rust-native
AppsAgentsServingvideomultimodalworkflow-automation
★ 14,888 total+4,532 this week
#26NEWPartial week
**gitai** is an open-source, MIT-licensed version control system purpose-built for AI coding agents, inspired by Anthropic's internal **Scion** system described in the "Redesigning Source Control" engineering post. Where classic Git hosting was designed for humans pushing infrequently, gitai targets scenarios with hundreds or thousands of short-lived agents concurrently reading, writing, and landing code on shared branches. Its core innovations include server-side history operations (blame, ancestry, search) with memoization, a compare-and-swap landing mechanism that batches concurrent changes without a merge queue, a changeset write-ahead log, and stateless server nodes backed by SQLite/PostgreSQL plus object storage (S3, GCS, Azure). Conflict resolution is pluggable—any LLM provider, deterministic tool, or none. Benchmarks show dramatic improvements: 50 agents landing 250 changes achieve ~1,862–2,544 lands/minute vs. 240–272 for classic Git, with p99 latency dropping from ~7s to ~1.8s. The project is at version 0.2.0, forked from GitLab's Gitaly, vendor-neutral (the server never calls an LLM directly), and community-maintained. It is notable as the first public implementation of Anthropic's Scion design, making agent-scale version control accessible to everyone.
ToolsAgentsMCPcodingworkflow-automationsynthetic-data
★ 2,316 total+4,431 this week
#27
Concat is a free, open-source, cross-platform video editor positioned as a direct alternative to CapCut, targeting TikTok, Reels, Shorts, and YouTube creators. It covers the core features people use CapCut for — auto-captions via local Whisper models, text-to-speech with voice cloning, background removal, keyframe animation, multi-track editing, 100 GPU-rendered effects, and 4K export (H.264, HEVC, AV1) — with no watermarks, no account, and no subscription required. Everything runs locally on a native Rust engine with a GPU compositor, meaning footage never leaves the user's disk and AI models work fully offline after a one-time download. Building from source requires Rust 1.93+ and FFmpeg 7+ development libraries, with platform-specific instructions for macOS (Homebrew), Windows (BtbN prebuilt binaries), and Linux. The project is notably scriptable, featuring a built-in MCP server for AI agents like Claude, plus JSON-RPC and gRPC APIs. Currently in beta at version 0.2.8, it supports Windows, macOS, Linux, and Android across 25 languages, making it a notably ambitious and rapidly growing open-source creative tool with strong community momentum.
AppsMCPToolsvideolocal-firstmultimodal
★ 9,127 total+4,276 this week
#28
Taste Skill is an open-source collection of Agent Skills designed to elevate AI coding agents from assembling generic landing pages into genuinely art-directed, design-conscious frontend builders. Rather than producing average output, the default skill guides agents through a structured six-step creative process: reading a client brief, drawing from 20 researched art directions, forming a unifying design idea, sourcing real photographs from open archives, checking the rendered page in a live browser at three widths, and iterating on its own screenshots to fix the top visual problems — up to three rounds. The methodology was derived from a study of 247 curated websites and the latest 100 Awwwards Sites of the Day, giving it a research-backed aesthetic foundation rather than relying on generic heuristics. Version 2.1 extends the skill to dashboards and app screens, dealing styles distilled from real product UIs and enforcing app-specific rules: quiet panels, data-driven color, aligned figures, and collapsible mobile navigation. A companion desktop application, TasteCode, packages the skill into a standalone design agent that briefs, builds, and visually reviews UI — free and open source. The project is compatible with the Vercel Labs Agent Skills CLI and integrates with Claude Code, Codex, and Cursor. Installation is a single npx command with no API keys required, needing only Node 22+ and a Chromium-based browser. Seven classic skills from earlier versions remain available as opt-in alternatives, including soft, minimalist, brutalist, and GPT-specific variants, some featuring tunable dials for design variance, motion intensity, and visual density. Image-generation skills have been spun off into a separate repository. The project is MIT-licensed, actively maintained with a public changelog, and sponsored by several developer-focused companies. Its notable trend signal lies at the intersection of AI agent tooling, design quality enforcement, and the growing demand for agents that produce premium rather than mediocre frontend output — a timely and differentiated niche as AI-generated UI proliferates.
ToolsAppscodingbrowser-usevision
★ 98,946 total+4,139 this week
#29
Context Mode is an MCP (Model Context Protocol) server that addresses what its authors call "the other half of the context problem" in AI-assisted coding workflows. The core issue it targets is context window bloat: every MCP tool call dumps raw data into an LLM's context window — a Playwright snapshot costs 56 KB, twenty GitHub issues cost 59 KB, and a single access log can consume 45 KB. After roughly 30 minutes of work, 40% of the context can be lost, and when agents compact conversations to free space, they forget which files they were editing, what tasks are in progress, and what the user last requested. On top of this, agents waste output tokens on filler, pleasantries, and verbose explanations, burning context from both input and output sides. Context Mode tackles all four facets of this problem through a unified approach. First, **Context Saving**: sandbox tools keep raw data out of the context window, reducing 315 KB to 5.4 KB — a claimed 98% reduction. Second, **Session Continuity**: every file edit, git operation, task, error, and user decision is tracked in SQLite, with events indexed into FTS5 and retrieved on demand via BM25 search rather than being dumped back into context; this lets the model resume exactly where it left off, while sessions started without `--continue` get a clean slate. Third, **Think in Code**: the paradigm that the LLM should program analyses rather than compute them manually — for example, instead of reading 50 files into context to count functions, the agent writes a script that computes and `console.log()`s only the result, replacing many tool calls and saving up to 100x context. This paradigm is mandatory across all 17 supported clients plus the OpenClaw gateway integration. Fourth, **No prose-style enforcement**: Context Mode controls where data goes but deliberately never dictates how the model phrases its final answer, citing research (attributed to Moonshot AI on kimi-k2.5) that aggressive brevity prompts degrade coding and reasoning benchmarks; formatting and brevity remain the user's or model's choice via CLAUDE.md or AGENTS.md. The project appears mature and feature-rich. For Claude Code, it offers a fully automatic plugin marketplace install, with a SessionStart hook injecting routing instructions at runtime without writing files to the project. The plugin registers hooks (PreToolUse, PostToolUse, UserPromptSubmit, PreCompact, SessionStart, Stop) and 11 MCP tools: six sandbox tools (ctx_batch_execute, ctx_execute, ctx_execute_file, ctx_index, ctx_search, ctx_fetch_and_index) and five meta-tools (ctx_stats, ctx_doctor, ctx_upgrade, ctx_purge, ctx_insight). Slash commands provide diagnostics, indexing, searching, upgrading, purging, context-savings statistics, and a hosted Insight dashboard offering org-level analytics for AI engineering teams. An optional status line shows real-time savings. The README documents installs for multiple platforms grouped by complexity — hook-capable platforms get automatic routing enforcement while others need a one-time routing file copy — including detailed Gemini CLI setup via a single settings.json registering the MCP server and four hooks (BeforeTool, AfterTool, PreCompress, SessionStart), with carefully scoped matchers targeting only high-output tools. It requires Node.js 22.5+ or Bun, is distributed on npm, and is licensed under the Elastic License v2 (ELv2). Signs of momentum and notability are strong: the badges claim adoption across teams at major companies, a Discord community, a YouTube demo, and a prominent Hacker News ranking (#1 with 570+ points). The project emphasizes measurable, real-time context savings and positions itself as a disciplined alternative to brevity-prompt approaches. Notably, the long list of company logos appears to be marketing badges rather than verified endorsements, so the adoption claims should be treated cautiously. Overall, Context Mode is a polished, actively maint
MCPToolsServingcodingworkflow-automation
★ 30,828 total+4,111 this week
#30
Paperclip is an open-source AI agent orchestration platform built on Node.js and React that functions as a full organizational operating system for teams of AI agents. Rather than managing individual agents in isolation, Paperclip treats AI agents as employees within a structured company hierarchy — complete with org charts, job titles, reporting lines, budgets, governance policies, and performance reviews. The core analogy the project uses is compelling: if OpenClaw is an employee, Paperclip is the company. This framing captures the platform's ambition to move beyond single-agent tooling into multi-agent organizational management at scale.
The workflow is straightforward in concept but powerful in execution: users define a high-level business goal (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 agents run autonomously while monitoring progress from a unified dashboard. The interface deliberately resembles a task manager, lowering the cognitive overhead of managing what is, under the hood, a complex system of org charts, delegation chains, budget controls, and governance rules.
Paperclip is built around four structural pillars. The first is an Agentic Task Manager that handles task declaration, approval gates, auditable workflows, and output verification via diffs, screenshots, and tests. The second is an Org Chart for Agents that defines roles, permissions, responsibilities, delegation hierarchies, scoped secrets, and governance rules for both human and AI participants. The third is Agent Employee Training, which includes a Skill Studio for designing and evaluating agent skills, active learning loops, quality metrics, performance reviews, and version history for skills. The fourth is an Agentic OS — the underlying infrastructure providing cross-provider runtime support, sandboxing, MCP server integration, SSO, RBAC, cost controls, data privacy, and opt-in tracing.
A standout feature is its broad agent compatibility. Paperclip works with OpenClaw, Claude Code, Codex, Cursor (including Cursor Cloud), Gemini CLI, OpenCode, Pi, Hermes and Hermes Gateway, Grok Build, and Kimi Code — essentially any agent that can receive a heartbeat signal. Custom processes, HTTP endpoints, and external adapter packages further extend the roster, making the platform highly provider-agnostic.
Key features include goal alignment (agents receive the business context behind their tasks), heartbeat-driven scheduling (agents wake for assigned work or on configured schedules), granular cost controls with budget thresholds and alerts at the company, agent, and project levels, multi-organization support from a single deployment, task threads that keep conversations and run history attached to work items, governance with configurable review and approval stages, mobile-ready monitoring, and app connections to services like GitHub, Notion, and Railway or custom MCP servers. The Skill Studio allows teams to write, test, version, and share skills org-wide, while ready-made team templates let users bootstrap entire agent organizations quickly. Experimental features include Agent Chat and connectors for Slack, Discord, Telegram, and AgentMail.
The project is MIT-licensed and actively maintained, with a cloud-hosted version available via waitlist at paperclip.ing. Its security posture is verified by Superagent. Community channels include Discord and Twitter/X. The repository's star history badge and active community presence suggest it is gaining meaningful traction. Paperclip is notable because it addresses a real and growing pain point: as developers and businesses run dozens of simultaneous AI coding and reasoning agents, coordination, cost visibility, and governance become critical bottlenecks. Paperclip positions itself as the management layer that makes autonomous AI organizations actually governable and scalable, which is a timely and differentiated value proposition in the rapidly maturing AI agent ecosystem.
AgentsToolsMCPworkflow-automationcodingsecurity
★ 104,239 total+3,767 this week
#31
FreeLLMAPI is an open-source aggregation and routing layer that consolidates the free tiers of 34 AI inference providers into a single OpenAI-compatible API endpoint, delivering approximately 7.4 billion tokens per month of free inference capacity across 474 model families and 635 provider endpoints. The core premise is straightforward but powerful: every major AI lab now offers a free tier, but each one comes with its own SDK, rate limits, and failure modes. Managing them individually is impractical, so FreeLLMAPI collapses all of them behind a single `/v1` endpoint that any OpenAI-compatible client can point to without modification. The project is available as a desktop application for macOS and Windows, as a Docker-deployable self-hosted server, and as mobile apps on both Google Play and the Apple App Store, making it accessible across virtually every platform a developer might use.
The supported provider list is extensive and includes major names such as Google, Groq, Cerebras, Mistral, OpenRouter, Cloudflare, Cohere, NVIDIA, HuggingFace, Z.ai (Zhipu), ModelScope, and OpenCode Zen, along with 22 additional free providers. Beyond these, the project supports a "custom" provider slot that allows users to point the router at any OpenAI-compatible endpoint, including local inference servers like llama.cpp, LM Studio, vLLM, and Ollama, or remote gateways. This makes FreeLLMAPI useful not just for aggregating cloud free tiers but also for unifying local and remote inference under one interface.
One of the most technically notable aspects of FreeLLMAPI is its self-updating model catalog. The router pulls a signed catalog from freellmapi.co twice a day, meaning new models, quota changes, and compatibility fixes propagate automatically without requiring users to update their installation. Free installs receive the monthly snapshot, so new models reach them approximately 30 days after joining the live feed, while premium subscribers ($19/year) receive catalog updates the same day they are published. This live-catalog approach directly addresses one of the most painful aspects of working with free tiers: the free-tier landscape shifts weekly as providers launch models, retire them, and change quotas without notice.
The routing engine is sophisticated, implementing six distinct routing strategies that rank available models using live per-model speed, capability, and reliability scores. When a provider returns a 429 rate-limit error or a 5xx server error, the router automatically falls over to the next available model in the chain, applying cooldowns and rotating keys as needed. Per-key rate tracking maintains RPM, RPD, TPM, and TPD counters per platform-model-key combination, learning providers' reported ceilings so that routing always stays within every free-tier cap. API keys are stored encrypted on the local installation.
The API surface coverage is comprehensive. FreeLLMAPI exposes every major OpenAI-style endpoint: `/v1/chat/completions`, `/v1/responses` (required by Codex CLI), `/v1/completions` for editor ghost-text autocomplete, `/v1/images/generations`, `/v1/videos/generations`, `/v1/audio/speech`, `/v1/audio/transcriptions`, `/v1/embeddings`, and `/v1/models`, all supporting both streaming and non-streaming modes. Beyond OpenAI compatibility, the project also implements the Anthropic Messages API at `/v1/messages`, enabling Claude Code and official Anthropic SDKs to run against the free pool. Native Gemini surface support via `/v1beta` endpoints covers `generateContent`, streaming, token counting, and model listing, while an opt-in Ollama emulation layer serves NDJSON chat, generate, tags, metadata, and embeddings for clients like Zed and JetBrains AI.
A particularly interesting feature is "Fusion," a multi-model synthesis mode accessible by requesting the virtual `fusion` model. When invoked, the router fans a prompt out to a panel of diverse free models in parallel, then uses a judge model to synthesize a single answer from the collected drafts. This ensemble approach can produce higher-quality outputs than any single free model alone. Tool calling and structured outputs are also fully supported, with OpenAI-style `tools` round-tripping across providers, including rescue logic that converts plain-text tool calls into proper `tool_calls` objects. Standard sampling parameters like `response_format`, `seed`, `logprobs`, and penalties are passed through on a per-provider basis.
The project supports a wide ecosystem of coding agents and CLI tools, including Claude Code, Codex CLI, Gemini CLI, Cursor, Cline, Roo Code, OpenCode, Aider, Continue, Goose, Qwen Code, Kilo Code, Zed, JetBrains AI, and many others. Most agents can be configured with a single `npx freellmapi setup-<agent>` command that reads the live catalog, backs up existing configuration, and merges the new settings automatically. Unified model profiles and named fallback chains (such as a coding chain or a vision chain) can be switched from the dashboard or specified per request using the `auto:<profile>` syntax, and custom chains can be renamed in place from the chain manager.
In terms of maturity and positioning, FreeLLMAPI presents itself as a production-ready tool with CI badges, a Docker image hosted on GitHub Container Registry, MIT licensing, and multilingual documentation in English, Simplified Chinese, and Russian. It compares itself directly against OpenRouter, LiteLLM, and Portkey in a feature comparison table. The project is trending on GitHub likely because it addresses a genuinely widespread developer pain point — the desire to use powerful LLMs for free at meaningful scale — while offering a polished, multi-platform experience with a self-sustaining update mechanism. The combination of 7.4 billion free tokens per month, broad agent compatibility, and a low-friction setup makes it a compelling tool for developers, researchers, and hobbyists who want to experiment with
ServingAgentsMCPlocal-firstmultimodalworkflow-automation
★ 37,172 total+3,760 this week
#32
openGym is a self-hosted, open-source gym and bodyweight tracking application built by DuarteSantos8 that gives users full ownership of their fitness data. Rather than relying on third-party servers, subscriptions, or ad-supported platforms, openGym runs entirely on a user's own infrastructure via a single `docker compose up` command, storing all data in a local folder the user controls. The project is notably trending on Trendshift as a weekly top JavaScript repository, signaling growing community interest in privacy-first fitness tooling.
The application functions as a progressive web app installable on mobile home screens, with passkey authentication (Face ID, Touch ID, fingerprint), offline support, and cross-device sync that merges edits field-by-field rather than overwriting. A native Android APK is also available, built via Capacitor for a fully on-device experience with no server required.
For bodyweight tracking specifically, openGym offers a dedicated body-weight chart plotted against a user-defined goal line, progress photos organized on a timeline with a before/after slider, and bodyweight exercises that correctly recognize they carry no external load — allowing reps to be logged naturally, with optional dip belt weight added when applicable. Per-side rep logging supports unilateral movements like lunges and single-arm exercises.
The exercise library contains over 5,600 entries with animated demos, searchable by muscle group via an interactive body map and filterable by available equipment. Planning tools include four starter programs (Push/Pull/Legs, Upper/Lower, Full Body, and 5×5), rotation-based scheduling, supersets, drop sets, rest-pause, timed exercises, and planned deloads. Progression systems include linear progression, Greyskull LP, double and triple progression, and Structural Balance ratios drawn from Poliquin and Thibaudeau methodologies.
Progress analytics include estimated 1RM curves, a year-long activity heatmap, and a muscle recovery map showing volume distribution, recovery status, and undertrained areas. Data can be imported from FitNotes, Strong, Hevy (CSV or API), and Apple Health weight exports, and exported as a single JSON file. The app supports 19 languages including Arabic and Traditional Chinese.
Optional features include an AI coach powered by Anthropic, OpenAI, Gemini, or Ollama that drafts and adjusts routines based on logged history, and an MCP server enabling assistants like Claude Desktop to query training history in read-only mode. The project is licensed under AGPL-3.0, has an active Discord community, passing CI pipelines on both GitHub Actions and GitLab, and a live demo available at
AppsMCPToolslocal-firston-device
★ 13,615 total+3,722 this week
#33NEWPartial week
SolidCraft is an open-source parametric 3D CAD application built entirely in Rust, developed by Tangency Labs. It targets engineers, makers, and designers who want a modern, cross-platform solid modeling tool that runs natively on Windows, macOS, and Linux, or directly in the browser with no installation required. The core paradigm is a parametric feature timeline: users sketch geometry, apply constraints and dimensions driven by named parameters, then build up solids through features like extrude, revolve, sweep, loft, fillet, chamfer, shell, and draft. Changing a single dimension causes the entire model to rebuild automatically, which is the hallmark of parametric CAD. A standout and highly notable feature is a built-in MCP (Model Context Protocol) server that allows AI agents to drive the modeling process programmatically, enabling fully automated design workflows. A showcase example is SELENE, a scientific rover with 3,323 editable timeline steps built entirely through the MCP server by a community contributor, demonstrating the system's ambition and real-world capability. The constraint solver is custom-built, combining geometric construction techniques (loci intersections, rigid-cluster decomposition based on Owen 1991 and Fudos–Hoffmann 1997) with Levenberg–Marquardt numerical solving, and reports remaining degrees of freedom via Jacobian rank analysis. Sketch tools are comprehensive, covering lines, rectangles, circles, arcs, polygons, slots, ellipses, splines, conics, and text, with full support for construction geometry, trimming, fillets, chamfers, and associative offsets. Profile detection is automatic, including regions split by crossing lines and holes within outlines. The application also supports assemblies with placed components, DXF export of current views with hidden-line handling, and material definitions with mass properties. Distribution is broad: Windows MSI (x64, ARM64, x86), portable zip, WinGet, macOS universal DMG, Linux AppImage, .deb, .rpm, Flatpak, and Snap packages are all available, plus a web app. Maturity is described honestly as "early but usable for simple parts," with 75 of 76 public reference parts passing volumetric, area, center-of-mass, and bounding-box validation against analytic or FreeCAD-computed references. A roadmap, feature list, oracle test suite, and contributing guide are all present, signaling an organized and transparent open-source project. The combination of Rust performance, browser deployment, AI-agent integration via MCP, and a rigorous parametric engine makes SolidCraft a notably ambitious and trending entry in the open-source CAD space, especially as AI-assisted design workflows gain momentum.
MCPAppsAgentsworkflow-automationlocal-first
★ 5,951 total+3,648 this week
#34
DigUp is a cross-platform desktop application that enables semantic, natural-language search across local files — including images, PDFs, documents, audio, video, and code — using Google DeepMind's EmbeddingGemma 2, a 740M-parameter multimodal embedding model released in October 2026. The core idea is that text, images, audio, and video are all projected into a shared 768-dimensional vector space, meaning a query like "a dog on the beach" can simultaneously match a photo, a video frame, a PDF passage, or a note written in Bengali or Arabic, across 100+ languages. DigUp is fully local and private: the model runs on-device via llama.cpp (using Metal on Apple Silicon, Vulkan on Windows/Linux GPUs, or CPU fallback), all vectors are stored in a local SQLite index, and no file data is ever uploaded. The app is available for Mac (stable), Windows, and Linux (both in beta), with Mac requiring Apple Silicon and macOS 14+. It supports deep file-type awareness — PDFs open at the matched page, recordings and videos jump to the matched moment, and code results open at the matched line in editors like Zed, VS Code, Cursor, or JetBrains IDEs. A dedicated code search mode (off by default) lets users query codebases semantically with a `code:` prefix, finding functions by behavior rather than name. Exact-word matching is layered on top of vector search to handle invoice numbers, error codes, and identifiers precisely. The technical stack splits by platform: Swift/SwiftUI with Apple frameworks (ImageIO, PDFKit, AVFoundation, Vision) on Mac, and Tauri with PDFium, ffmpeg, stb, and miniz on Windows/Linux, with a shared Swift search engine core. The project is open source (Apache 2.0 for the model), free, and at version 0.7.0-beta.2, suggesting active early development. Its notable trend relevance lies in combining a cutting-edge multimodal embedding model with a polished, privacy-first local search UX — a compelling alternative
AppsRetrievalModelsmultimodallocal-firston-device
★ 4,831 total+3,588 this week
#35NEWPartial week
**qwen21-nsfw-pose-skill** is a comprehensive ComfyUI-based recipe for generating NSFW and pose-controlled images using the Qwen-Image 2.1 int8 model, designed to replicate Civitai author-quality outputs. It combines author-structured prompts, NSFW LoRAs, a curated library of 136 3D poses, and VNCCS puppet-based precise pose control. The project supports four generation routes: text-to-image with NSFW LoRA, character image editing, script-based pose transfer using 3D doll renders, and interactive VNCCS PoseStudio via browser automation. It includes a self-diagnostic script (`doctor.py`), detailed hardware guidance (minimum 12GB VRAM, recommended 24GB), and macOS Apple Silicon notes. The repo targets both AI agents (Claude Code, Codex, Cursor, OpenClaw) and manual human use, with a boldness ladder (L0–L3) for content intensity. Licensed under Apache 2.0 for original code, with third-party assets retaining their respective licenses. The project is notably trending due to its structured, reproducible NSFW generation pipeline built on a cutting-edge multimodal model with verified author-sample replication.
ToolsAppsModelsmultimodalvisionbrowser-use
★ 3,047 total+3,510 this week
#36
AI Engineering from Scratch (rohitg00/ai-engineering-from-scratch) is a free, open source (MIT-licensed) educational curriculum designed to teach AI engineering through hands-on implementation rather than passive reading. The project's core philosophy is to have learners implement model internals, retrieval pipelines, and agent runtimes from the ground up, then test them, inspect failures, and keep both the code and evaluation results they produce. It is a large and comprehensive resource, spanning 542 lessons organized across 20 phases, with code examples offered in Python, TypeScript, Rust, and Julia. Learners can engage with the material in three distinct ways: on the companion website (aiengineeringfromscratch.com) with no setup required, through an AI tutor powered by a skill-capable coding agent, or by cloning the repository and running local code. The curriculum is structured around several learning paths tailored to different career goals, including "Model foundations" (starting with setup and tooling), "LLM systems" (starting with prompt engineering), and "Agents and delivery" (starting with the agent loop). Given the query focus on agents, the repository places significant emphasis on agent engineering, covering topics such as the agent loop, agent runtimes, tool schema design, and tools and protocols. Agent-related content is woven throughout multiple phases, including LLM engineering, tools and protocols, agent engineering, and infrastructure and production. The project features interactive labs, such as a gradient descent visualization that demonstrates how twenty scattered starting points converge toward a loss minimum on a quadratic loss surface, with adjustable learning rates and code comparing gradient descent, momentum, and Adam optimizers. A standout feature is its three project challenges, each with staged starters, reference implementations, and local graders. These include the Retrieval Evaluation Lab (Python), which builds query-by-query ranking comparisons using NDCG, precision, and recall to catch regressions in retrieval systems; the Agent Trace Debugger (TypeScript), which parses JSONL agent traces, separates overlapping child work from parent execution time, tracks token usage, and produces inspectable HTML timelines and JSON regression reports; and the Tool Call Firewall (Rust), which validates tool-call envelopes, checks caller roles and paths, and consumes single-use approvals bound to exact requests to prevent replay attacks and unauthorized writes. Each project emphasizes keeping reproducible, inspectable artifacts and is careful to state its limitations (for example, metrics describe judgments rather than establishing answer correctness, and the firewall does not provide persistent authorization or an OS sandbox). The project is notable for its breadth, its multi-language approach, and its strong emphasis on evaluation, failure inspection, and production concerns like security, secrets, and audit. Its maturity is signaled by the completed lesson content, the roadmap, extensive internationalization (the README is translated into more than 30 languages including Chinese, Japanese, Korean, Spanish, German, French, Arabic, Hindi, and many others), and sponsor support from companies like SerpApi and NitroStack. The AI tutor integration is a particularly modern feature: learners can install it via `npx skills add rohitg00/ai-engineering-from-scratch` and use it inside coding agents like Codex (via `start-learning`) and Claude Code (via `/start-learning`), with support for Agent Skills hosts and configurable scopes. This positions the project at the intersection of the growing trends around AI agents, agent evaluation and observability, tool use and protocols (such as MCP referenced by a sponsor), and agent-assisted learning. The repository is likely trending because it combines a timely, in-demand topic (AI and agent engineering) with a rigorous, practitioner-oriented pedagogy that stresses building systems from scratch, testing them, and understanding their failure modes. Its free and open-source nature, extensive multilingual accessibility, and integration with popular coding agents broaden its appeal to a global audience of engineers seeking practical AI skills. For those specifically interested in
AgentsEvalsModelscodingsecurityworkflow-automation
★ 71,111 total+3,499 this week
#37
Free Claude Code (FCC) is an independent, open-source proxy and orchestration layer that enables developers to run multiple AI coding agents against a wide variety of free, paid, subscription, and local model providers — all from a single unified interface. The project's central value proposition is access to 61 Terms-of-Service-friendly providers delivering over 1.3 billion free tokens per month, without putting user accounts at risk, since FCC actively monitors provider policies and removes integrations that fall out of compliance. Rather than locking users into a single model or vendor, FCC exposes a searchable model catalog that works across 11 distinct coding agents: Claude Code, Codex, Pi, OpenCode, Cline, Hermes, DeepSeek Harness, Grok Build, Muse Code, Aider, and VS Code Chat. This breadth of agent support is a standout feature, making FCC a kind of universal adapter for the rapidly expanding AI coding agent ecosystem.
A key reliability feature is automatic provider failover: when retries are exhausted on one provider, FCC seamlessly routes the request to the next configured model without requiring the user to restart their session, and this works across every supported client. Token efficiency is another focus — optional integrations with RTK and Headroom can reduce token consumption by up to 90% by filtering command output and compressing tool results, which is especially valuable for users on free-tier limits. FCC also supports native browser-based coding sessions, allowing users to pick a folder and run Codex directly in the browser with real-time and background support, with the ability to switch providers and models mid-session.
The project supports a remarkably wide range of client surfaces: terminal, desktop launchers, VS Code, JetBrains IDEs, the Codex App, Discord, and Telegram. Voice input is supported via local OpenAI Whisper or NVIDIA NIM transcription, enabling a "voice notes in, code out" workflow. Advanced agent capabilities are preserved throughout, including streaming responses, tool use, native interleaved thinking, image support, and independent routing of Claude model tiers (Fable, Opus, Sonnet, Haiku) to compatible upstream models.
The provider catalog is extensive and spans major commercial APIs (OpenAI, Anthropic, Google Gemini, xAI Grok, DeepSeek, Mistral, Cohere, Amazon Bedrock, Azure OpenAI, Google Vertex AI, Hugging Face), subscription/OAuth providers (ChatGPT, GitHub Copilot), and numerous free or freemium services (OpenRouter, Groq, ClinePass, Nebius, Chutes, Featherless AI, SiliconFlow, Together AI, DeepInfra, QwenCloud, Alibaba Cloud, W&B Inference, Vercel AI Gateway, Wafer, Kimi, ZenMux, Agnes AI, and more). Custom provider endpoints can also be added manually via the Admin UI.
Installation is straightforward via shell scripts for macOS/Linux and PowerShell for Windows, with native desktop launchers and system tray/menu-bar integration on Windows and macOS. The project is built on Python 3.14, uses uv for package management, Ruff for formatting, ty for type checking,
ToolsServingAgentscodingmultimodalaudio
★ 61,629 total+3,490 this week
#38
LightCraft is an open-source, non-destructive photo library and raw development application built entirely in pure Rust, developed under the ArtCraft umbrella. It positions itself as a complete digital darkroom, offering a modern, privacy-respecting alternative to proprietary tools like Adobe Lightroom. The tagline — "Your photos. Your pixels. Your machine." — underscores its commitment to local, user-controlled processing. LightCraft runs natively on macOS, Windows, and Linux, and also compiles to WebAssembly for in-browser use, making it one of the few photo editing tools with genuine cross-platform and web parity from a single codebase. Notably, it also ships with a built-in MCP (Model Context Protocol) server, making it fully drivable end-to-end by AI agents — a forward-looking feature that distinguishes it from virtually all competitors in the photo editing space.
The editing pipeline is scene-referred, wide-gamut, and operates at 32-bit float precision throughout, meaning highlights roll off naturally like film and shadows open cleanly without halos. Core light adjustments include Exposure, Contrast, Highlights, Shadows, Whites, and Blacks, with edge-aware local tone mapping implemented via a guided filter on log-luminance. Color tools are computed in OkLCh, a modern perceptual color space, and include White Balance with an eyedropper, Vibrance with skin-tone protection, Saturation, an 8-band Color Mixer (hue, saturation, luminance per band), and 3-way Color Grading wheels for shadows, midtones, and highlights. The Tone Curve offers both a parametric region curve and point curves for RGB and individual channels, with monotone-by-construction enforcement to prevent accidental tone inversions.
Effects tools include Texture, Clarity, Dehaze (using a dark-channel prior with guided refinement), post-crop Vignette with highlight priority and feathering controls, and resolution-independent film Grain with size and roughness parameters. Masking is comprehensive: users can paint with a Brush, drop Linear and Radial Gradients, or select by Luminance Range, Color Range, Sky, Subject, or Background. Masks can be combined via Add, Subtract, and Intersect operations, inverted, and each mask supports 17 local adjustment parameters. On desktop, Object and Describe masks leverage SAM 3 (Segment Anything Model 3) for click-based and text-prompt selection, installed separately. Subject, Sky, and Background selections use classical heuristics without requiring a model.
Forty-one hand-crafted presets ship out of the box, covering styles like Golden Hour, Teal & Orange, Faded Matte, Selenium Tone, and Crisp Landscape, each with an Amount slider from 0 to 200%. Users can save custom presets, mark favorites, and copy or sync edits across selections with granular group control. Crop and geometry tools support free and locked aspect ratios, drag-to-rotate straightening, compositional overlays (thirds, grid, golden ratio), flips, rotations, and manual transform controls. Black-and-white conversion is one-click, with an 8-band B&W Mix for tonal control and Color Grading support for selenium, sepia, or split-tone finishes.
The library management system supports Albums nested in Folders, smart collections like All Photos, Recently Added, Picks, and By Date, plus a Recently Deleted bin. Rating, flagging, and color-labeling are all keyboard-driven. Search supports structured field queries (e.g., rating, flag, ISO, camera, date, keyword). The People view groups named faces with optional automatic detection and recognition via separately installed models. Photo Grid and Square Grid views are virtualized for smooth performance at any library scale — forty photos or forty thousand.
In terms of maturity, the project self-describes as "young and moving fast," with a public roadmap. It is dual-licensed under MIT and Apache-2.0, making it permissively open-source. The README is notably polished and detailed for an early-stage project, featuring real screenshots captured automatically by an AI agent through the MCP control channel — itself a demonstration of the agent-driven workflow. The project is hosted under the storytold GitHub organization and marketed via getartcraft.com, with a Discord community for artists across digital, generative, music, and game disciplines.
LightCraft is trending-relevant for several converging reasons: the rise of Rust-based native applications, growing demand for privacy-first local tools, the explosion of AI-agent integration via MCP, and increasing developer and creative interest in open-source alternatives to Adobe's ecosystem. Its combination of professional-grade photo editing, a pure Rust implementation, WebAssembly support, and first-class AI-agent controllability makes it a technically ambitious and culturally timely project in
AppsMCPToolslocal-firston-devicevision
★ 13,719 total+3,366 this week
#39
Archify is a free, open-source AI agent skill that transforms natural language descriptions, questions, or plans into interactive, self-contained HTML visuals — including architecture diagrams, explainer pages, learning maps, travel itineraries, and complex system maps. The core premise is elegantly simple: describe an idea or system to your AI coding agent, and Archify generates a polished, interactive HTML file you can explore, customize, and share without needing a repository or any pre-existing codebase. It is installed via a single `npx skills add tt-a1i/archify -g` command and integrates natively with popular AI coding environments including Cursor, Claude Code, Codex CLI, and OpenCode, making it immediately accessible to a wide developer audience.
The project's approach centers on two primary output modes. The first is interactive architecture diagrams: users describe a system — for example, a web request flow involving a browser, API, Redis cache, and PostgreSQL database — and Archify renders it as a navigable, source-linked diagram. Users can then iteratively refine it by asking the agent to add authentication layers, highlight specific paths, or switch themes, making it a genuinely conversational diagramming tool. The second mode is the "explainer page," a richer single-page document that leads with a conclusion, then breaks down a complex question panel by panel, weaving together tables, step-by-step instructions, charts, code snippets, and validated diagrams. Steps sit beside the diagrams they describe and highlight relevant nodes as the reader progresses, creating a tightly integrated reading experience. Claims in explainer pages cite numbered sources, repository excerpts are pinned to specific commits, and the entire output is exportable as PNG, WebP, JPG, or PDF — making it suitable for sharing with non-technical stakeholders.
Archify is at a mature and actively maintained stage, currently at version 3.2.0, and has accumulated over 130,000 installs on skills.sh, a significant adoption signal for a developer tool in this category. It is tracked on Trendshift (repository #31352), indicating measurable and notable momentum in the open-source community. The README is available in English, Simplified Chinese, Japanese, and Korean, reflecting a deliberately international user base and community strategy. Community channels span Discord, WeChat, and QQ, suggesting strong engagement particularly in East Asian developer communities alongside Western ones.
The project's sponsor ecosystem is notably robust for an open-source tool of this type. Sponsors include Kimi Work (which features Archify as a plugin under the name "Interactive Architecture Diagram"), Supercode (which named it an Editor's Choice skill and focuses on token optimization and spec-driven development), OpenLux (an AI model aggregation platform offering Claude, OpenAI, and Gemini at deeply discounted rates), PackyCode (a unified API gateway with automatic failover for Codex and Claude Code), AICodeMirror (an API relay service for Claude, Codex, and Gemini), Infistar.cc (a multi-model API platform covering text, image, and video), and EverMind/Raven (a memory infrastructure project for agents that supports Archify as a verified skill). This breadth of sponsorship from AI infrastructure and API relay companies signals that Archify sits at a commercially interesting intersection of agent tooling and developer productivity.
What makes Archify particularly notable from a trend analysis perspective is its positioning squarely within the agent-skills ecosystem — a rapidly growing category where reusable, composable capabilities are installed into AI coding agents rather than run as standalone applications. Its 130K+ install count, multi-language documentation, Trendshift tracking, and multi-sponsor backing collectively suggest it is one of the more traction-heavy projects in this emerging space. The ability to produce shareable, self-contained HTML artifacts from pure natural language, without requiring a repository, lowers the barrier to entry dramatically and broadens its appeal beyond software engineers to anyone who needs to communicate complex ideas visually.
ToolsAppsAgentscodingworkflow-automationmultimodal
★ 85,485 total+3,318 this week
#40
The `addyosmani/agent-skills` repository is a collection of 25 production-grade engineering skills designed for AI coding agents, authored by Google Chrome engineer Addy Osmani. The core idea is to encode the workflows, quality gates, and best practices that senior software engineers follow — and package them so AI agents apply them consistently across every phase of the software development lifecycle. Rather than leaving agents to improvise, each skill is a structured workflow with explicit steps, verification gates, and anti-rationalization tables that prevent agents from cutting corners (e.g., silencing checks or skipping tests to appear green).
The lifecycle is organized into six phases — Define, Plan, Build, Verify, Review, and Ship — each mapped to a slash command: `/spec`, `/plan`, `/build`, `/test`, `/review`, and `/ship`. Additional commands include `/constraints`, `/webperf`, and `/code-simplify`, covering quality thresholds, web performance auditing, and code clarity respectively. A power-user mode, `/build auto`, lets the agent generate a plan and implement every task autonomously in a single approved pass, pausing only on failures or risky steps, while still enforcing test-driven development and individual commits per task.
Skills also activate contextually and automatically — designing an API triggers the `api-and-interface-design` skill, building UI triggers `frontend-ui-engineering`, and so on. The pack ships 25 skills total, including a meta-skill (`using-agent-skills`) that maps incoming work to the correct workflow, plus skills for idea refinement, spec-driven development, constraint-driven development, incremental implementation, test-driven development, code review, debugging, and more.
Installation is broadly supported. The fastest path is a single `npx skills add addyosmani/agent-skills` command via the open skills CLI, which installs into 70+ agents. Native integrations are documented for Claude Code (the recommended host, with marketplace plugin support), Cursor, Codex, GitHub Copilot, Windsurf, Gemini CLI, Antigravity CLI, OpenCode, Kiro IDE, and Command Code. Skills are plain Markdown, making them compatible with any agent that accepts system prompts or instruction files. A known portability gap exists when installing individual skills without the shared `references/` directory, tracked in issue #361.
The repository includes an Adoption Guide covering two rollout paths: a full lifecycle approach for greenfield projects and an incremental, verification-first rollout for established codebases. The project is trending on Trendshift (ranked repository #25200), signaling strong community interest. Its notable qualities are its breadth of agent compatibility, its opinionated but practical engineering philosophy (spec before code, small atomic tasks, tests as proof), and its ambition to make AI agents behave more like disciplined senior engineers rather than fast-but-sloppy code generators.
ToolsAgentsAppscodingworkflow-automation
★ 108,273 total+3,136 this week
#41
Agent Reach is an open-source Python (3.10+) agent-infrastructure toolkit that gives AI agents one-click internet access across a wide range of platforms — including Twitter/X, YouTube, Bilibili, Reddit, Facebook, Instagram, Xiaohongshu (Little Red Book), LinkedIn, GitHub, RSS feeds, and general web pages — without requiring users to manually configure each integration. Its core design philosophy is a "capability layer" that sits above individual tools: it selects the currently most stable backend for each platform, installs it, health-checks it, and routes around failures automatically. Each platform is represented as an ordered list of primary and fallback backends (e.g., Bilibili switched from yt-dlp to bili-cli after B站's anti-scraping blocked yt-dlp in June 2026), so when one integration breaks, Agent Reach silently reroutes with zero user action. Installation is triggered by a single natural-language instruction to any compatible agent (Claude Code, OpenClaw, Cursor, Windsurf, etc.), and the built-in `agent-reach doctor` command diagnoses which channels are live and which need repair. Security is a first-class concern: credentials and cookies are stored locally at `~/.agent-reach/config.yaml` with 600 permissions, never uploaded; the installer defaults to read-only environment checks and only modifies the system when `--system` is explicitly passed; a `--dry-run` flag previews all actions. The project is fully open-source under MIT, supports multilingual documentation (Chinese, English, Japanese, Korean), and has achieved GitHub Trending #1 Repository of the Day on Trendshift, signaling strong community momentum. Sponsors include BrowserAct, Tencent Cloud, CoreClaw, and UCloud AstraFlow, reflecting commercial interest in the agent-infrastructure space. Its notable trend relevance lies in addressing the rapidly growing need for reliable, maintainable internet-access tooling for autonomous AI agents, a pain point that is becoming critical as agent usage scales.
ToolsMCPAgentsbrowser-useworkflow-automationsecurity
★ 99,165 total+3,012 this week
#42NEWPartial week
ESP32 iPhone Agent is an open-source project that enables an AI vision model to autonomously control a real iPhone using only a ~$7 ESP32-S3 microcontroller board — no computer, no jailbreak required. The board acts as both an AirPlay receiver (giving the AI "eyes" via screen mirroring over its own Wi-Fi hotspot) and a USB HID mouse/keyboard (giving it "hands" via AssistiveTouch), while an on-device iOS app serves as the "brain," decoding the mirrored stream, sending screenshots to any OpenAI-compatible vision model, and executing planner/actor commands like taps, swipes, and keystrokes. A key architectural leap from v0.1.0 is eliminating the Mac/Linux computer entirely — the agent loop now runs fully on the iPhone itself, with cellular data handling model API calls while Wi-Fi is occupied by the board's hotspot. The system features closed-loop correction (pointer re-homing, wiggle-based calibration, screen-settle detection), run replay with annotated traces, Dynamic Island status, Siri/Shortcuts integration, and exportable run data for further agent analysis. Developed with Qwen3.8-Flash on NVIDIA DGX Sparks, it supports any OpenAI-compatible endpoint including vLLM, Ollama, and cloud APIs. Limitations include low BLE bandwidth (~300–500 kbps, ≤5 fps), ASCII-only keyboard input, and portrait-only orientation. The project is early-stage but fully functional, notable for its ultra-low-cost hardware approach to autonomous mobile AI agents.
AgentsToolsAppsvisionon-devicemultimodal
★ 3,162 total+2,987 this week
#43
Graphify is an open-source AI-agent memory and code intelligence tool developed by Graphify Labs, a Y Combinator S26 company, that maps entire software projects — including code, documentation, PDFs, images, and video — into a traversable knowledge graph rather than a vector index. The core value proposition is dramatically reducing AI agent token consumption, with Graphify Cloud claiming up to an 80% reduction in agent token spend by keeping a live, always-on graph across the full software development lifecycle. The project is invoked directly inside AI coding assistants via a simple `/graphify` slash command, making it immediately accessible without requiring users to leave their existing workflow. Under the hood, code is parsed using tree-sitter AST parsing, which is deterministic, requires no LLM calls, and runs entirely locally — nothing leaves the user's machine during the code-mapping phase. Only the semantic pass over non-code assets like documents, PDFs, images, and video optionally calls an external model or configured API key. This local-first, zero-LLM-credit approach for code is a notable differentiator from most competing memory and retrieval systems that rely on per-token embedding costs. The resulting knowledge graph is output as three files: an interactive browser-viewable `graph.html`, a human-readable `GRAPH_REPORT.md` summarizing key concepts and surprising connections, and a machine-queryable `graph.json` that persists across sessions with schema versioning for integration stability. Every edge in the graph is tagged as either `EXTRACTED` (explicitly present in source) or `INFERRED` (resolved by Graphify), giving users clear provenance and confidence signals for every relationship. The graph supports rich querying capabilities including `graphify explain`, `graphify path`, and `graphify query` commands that let users trace shortest paths between concepts, explain individual nodes, and retrieve scoped subgraphs from plain-language questions — all without re-reading source files. Community detection uses the Leiden algorithm with LLM-free labeling, and the system identifies "god nodes" — the most-connected concepts that everything flows through — giving developers a bird's-eye architectural view. Cross-file relationship types include calls, imports, inherits, and mixes_in, resolved across approximately 40 programming languages. Benchmark results are notably strong: on the LOCOMO benchmark (n=300), Graphify achieves a recall@10 of 0.497, compared to mem0's 0.048 and supermemory's 0.149, while spending zero LLM credits on graph construction. On LongMemEval-S (n=50), it achieves 76% QA accuracy, tied with dense RAG approaches. On an ERPNext cross-tool benchmark, it achieves 82% key-fact coverage versus a grep/read baseline of 70.8%. The tool supports all major AI coding assistants including Claude Code, Cursor, Codex, Gemini CLI, and GitHub Copilot, and runs on macOS, Linux, and Windows. The PyPI package is published under the name `graphifyy` (double-y) to distinguish it from unaffiliated packages. Graphify Cloud extends the local tool with monorepo and cross-repo support, formal verification, SDLC-wide code review, and connectors for Sentry and Jira, offered with a free 14-day trial. The README is available in over 30 languages, signaling strong international community investment. The project is tracked on Trendshift and carries an Apache 2.0 license, with active CI, a Discord community, YouTube channel, and LinkedIn presence, suggesting a well-resourced and growing open-source project with clear commercial backing and a compelling technical approach to AI agent memory.
RetrievalToolsMCPlocal-firstvector-databasecoding
★ 128,529 total+2,926 this week
#44
Moli is a production-ready, open-source headless browser purpose-built for AI agents, developed by Lexmount. Its defining architectural innovation is an "on-demand layout and rendering" model: rather than continuously maintaining a fully rendered visual state, Moli treats the native DOM and CSS style as the single source of truth and triggers layout or paint only when an operation genuinely requires it. This makes it exceptionally fast and resource-efficient for the kinds of tasks AI agents actually perform — fetching pages, extracting structured content, querying the DOM, running JavaScript, and automating browser interactions — without the overhead of a traditional browser's continuous rendering pipeline. Moli is not a Chromium wrapper; it is a standalone browser kernel written in Rust, integrating V8 for JavaScript execution, Servo/Stylo for CSS cascade, Taffy and Parley for box and text layout, html5ever for HTML parsing, libcurl for networking, and Vello CPU/usvg for software rendering. It supports all three major automation protocols — CDP, WebDriver Classic, and WebDriver BiDi — from a single unified binary, meaning no separate ChromeDriver, geckodriver, or browser installation is needed. Playwright can connect to it directly over CDP. The CLI supports rich extraction outputs including Markdown, HTML, JSON, semantic text trees, screenshots, and PDFs, with fine-grained control over resource loading, proxies, profiles, and page-load strategies. Expensive operations like layout, screenshots, and media resource fetching require explicit opt-in flags, giving developers precise cost control. Moli runs on Linux, macOS, and Windows, and is fully usable as a standalone open-source tool independent of Lexmount's managed cloud offering, Lexmount Browser. It is already trending on Trendshift (both daily and weekly Rust rankings), signaling strong community momentum. Its architecture is particularly well suited to crawling pipelines, browser-use agents, retrieval-augmented generation systems, evaluation environments, and reinforcement-learning workloads, making it highly relevant to the current surge in agentic AI development.
ToolsAgentsRetrievalbrowser-uselocal-firston-device
★ 19,515 total+2,925 this week
#45
The `cloudflare/security-audit-skill` is an AI coding-agent skill that transforms a coding agent into an automated security auditor, orchestrating isolated sub-agents through six structured phases: reconnaissance, coverage-led hunting, candidate validation, structured output, independent record verification, and target-neutral reporting. It originated as the seed for Cloudflare's internal vulnerability discovery harness, described in their engineering blog, and has since evolved into a multi-stage, fleet-wide system — making this repo the single-repo starting point of that effort. Key features include a coverage ledger to track and close audit gaps across multiple runs, adversarial validation (a different agent always verifies a finding), and strict verdict categories (`confirmed`, `needs_validation`, `rejected`). The skill ships with specialized attack-class prompt files covering memory safety, AI/LLM targets, web/auth protocols, supply chain, cloud/IaaS, client-side, and more. It requires Node.js for zero-dependency validators and a sandboxed OS environment for safe code execution. Notable for its production-proven lineage, rigorous multi-run additive coverage model, and open MIT license, it is likely trending due to growing interest in AI-driven automated security tooling from a major infrastructure company.
ToolsSafetyAgentssecuritycodingworkflow-automation
★ 31,237 total+2,846 this week
#46
OmniRoute is a free, open-source AI gateway designed to unify access to a vast array of AI providers through a single endpoint, allowing developers to "never stop coding" by avoiding rate limits and provider lock-in. The project's core proposition is routing every AI tool — including Claude Code, Codex, Cursor, Cline, Copilot, and Antigravity — into free Claude, GPT, and Gemini models with automatic fallback. As of the documented versions, OmniRoute catalogs 375 AI providers (up from 352 in prior releases) and exposes 1,475 unique chat model IDs, with more than 150 providers marked as free in its catalog. A central headline feature is the aggregation of free-tier token quotas: OmniRoute estimates roughly 1.62 billion free tokens per month across separately eligible third-party free tiers, rising to approximately 2.22 billion in the first month when signup credits are included. Importantly, the project is transparent that these tokens are not granted by OmniRoute itself — users must bring their own provider accounts and credentials, and each provider controls its own limits, availability, and terms. The token math is derived from 468 cataloged free-tier entries across 34 recurring pool keys, computed from 17 pools with a published positive monthly budget plus five per-model Groq caps, deduplicated so shared pools are counted only once. Quotas gated behind regional identity verification (such as ModelScope, adding ~6M tokens) are listed separately and excluded from the headline, and 12 providers are flagged as "avoid" in a terms-risk catalog so users can make informed decisions. These figures are re-audited every two weeks and can move in either direction, with live usage visible on a dashboard at `/dashboard/free-tiers`.
Beyond aggregation, OmniRoute offers 20 routing strategies and several notable features. Its RTK + Caveman "stacked compression" technology reportedly saves 15–95% of tokens (approximately 89% on average) to help users stay within limits. The gateway includes a Modality Bridge supporting vision, audio, and video; a Radar free catalog (opt-in); quota-aware scheduling via a "Quota-Share" mechanism; and live quota telemetry. Newer roadmap items heading toward a v3.9.0 LTS release include a headless mode (`serve --headless`), LTS "rail" infrastructure with release channels, and a model discovery API accessible at `/v1/models/query`. The project emphasizes being private and local-first, and highlights full CLI support alongside A2A (agent-to-agent) and MCP (Model Context Protocol) integrations — relevant to the "a2a" query, OmniRoute advertises combined CLI, A2A, and MCP capabilities, positioning it as interoperable with agent ecosystems and compatible coding agents. "Combos" are described as a flagship feature of the platform.
In terms of maturity and distribution, OmniRoute is actively maintained and distributed across multiple channels: it is published on npm (as the `omniroute` package), available on Docker Hub, and offered as an Electron desktop application with download counts tracked on GitHub. It is MIT-licensed and localized into 67 languages, with translations for Portuguese (Brazil and Portugal), Spanish, French, Italian, German, Dutch, Russian, Ukrainian, Polish, Czech, Slovak, Romanian, Hungarian, Bulgarian, Danish, Finnish, Norwegian, Swedish, and many others. The project shows strong community traction: it features on Trendshift (repository #23589), tracks star history, and claims over 900 contributors. Community support is organized through Discord, Telegram, and WhatsApp (both global and Brazil-specific groups), plus a dedicated website (omniroute.online) and portal. The maintainer, Diego Souza, promotes updates via LinkedIn and GitHub. OmniRoute runs "anywhere" across platforms, and provides extensive documentation including a free-tiers methodology reference and a roadmap. The project is notable and trending because it addresses a
MCPServingToolslocal-firstmultimodalworkflow-automation
★ 78,208 total+2,827 this week
#47
CLI-Anything, developed by the HKUDS group, is an ambitious open-source project built on the premise that while today's software is designed to serve human users, tomorrow's users will increasingly be AI agents. The project's core mission is to make virtually any software "agent-native" by providing command-line interface (CLI) harnesses that bridge the gap between AI agents and the world's existing software applications. With a single command line, CLI-Anything makes any piece of software agent-ready for a variety of AI coding agents and assistants, including Pi, OpenClaw, nanobot, Cursor, and Claude Code. This effectively transforms conventional applications into tools that autonomous agents can operate directly. A central component of the ecosystem is CLI-Hub, a package manager installable via `pip install cli-anything-hub`, which lets users browse, search, install, update, and uninstall community-built CLIs using commands like `cli-hub install <name>`. The Hub features a web frontend with separate decks for CLI-Anything CLIs and Public CLIs, and it supports installation from multiple sources including pip, npm, brew, and bundled/system tools, backed by a public registry JSON file. The project emphasizes community contribution: developers can open pull requests to add new CLI harnesses, sign up as contributors, or submit wishlist requests for software they want supported, with the hub updating instantly upon merges. Technically, the project is Python-based (requiring Python ≥3.10) and uses the Click library (≥8.0) for CLI construction, supporting both JSON and human-readable output formats. It demonstrates notable maturity through extensive testing, boasting 2,461 passing tests with both unit and end-to-end (e2e) coverage using pytest, and it is released under the Apache 2.0 license. The project provides 18 demonstration apps and real-world demos showing AI agents using generated CLIs alongside preview, live preview, and trajectory loop features to produce tangible artifacts such as CAD builds, 3D scenes, diagrams, gameplay, and subtitles. Documentation is available in multiple languages including English, Chinese, Japanese, and German, and the community connects through Feishu and WeChat groups. The project has a strong trending signal, prominently displaying a Trendshift badge and refreshing its README presentation to emphasize discovery and project momentum. The news log reveals an extremely active development pace with near-daily updates and a rapidly growing catalog of merged and proposed CLI harnesses across diverse domains. Merged and proposed CLIs span creative tools (Blender, FreeCAD, Inkscape, Draw.io, Kdenlive, Shotcut, Sketch, Openscreen screen recording, VideoCaptioner), knowledge management (Obsidian, Zotero, Joplin, Calibre), GIS and mapping (QGIS, ArcGIS Pro), 3D and game development (Godot, Unreal Editor via UEAtelier, Unreal Insights, RenderDoc, Slay the Spire II, 3MF mesh tools), automation and workflows (n8n, Dify Workflow, PM2, WireMock, Zoom), scientific and molecular modeling (UniMol Tools, py4csr, ChromaDB), blockchain (Eth2-Quickstart Ethereum staking), audio and media (MiniMax TTS, Rekordbox), web search and browsing (Exa, Safari, CLIBrowser, DomShell, SeaClip), cloud analysis (CloudAnalyzer), and OSINT (IntelWatch). Recent updates include a Hermes orchestration skill, security hardening efforts such as routing untrusted XML/SVG/ODF/MLT/MusicXML/CSL input through defusedxml, path-traversal protections for Sketch CLI token handling, and guarded SQLCipher write paths for Rekordbox. The project also unified all SKILL.md files under a top-level `skills/` directory, enabling installation from one canonical source via `npx skills add`, and it added root-skill validation CI. Architecturally, version 0.2
ToolsAgentsMCPworkflow-automationcodingbrowser-use
★ 54,731 total+2,800 this week
#48
**dsh-purge** (v1.1.71) is a cybersecurity red-team evaluation plugin for the official **DeepSeek Harness** (`dsh`) framework, designed to run locally on a user's own machine. Its core purpose is to separate the AI model's own refusal behavior from the host application's interception layers — allowing researchers to conduct controlled robustness and red-team assessments of DeepSeek Harness itself. The plugin supports both the official web interface (`dsh web`) and the official desktop EXE (DeepSeek Harness 0.2.0-rc.2), with each profile installed and applied independently. Key features include a **sidebar UI** with two panels: "清洗" (Purge/Patch), which lets users view, apply, revert, and uninstall patches and edit prompt injection rules; and "演练台" (Drill Console), for viewing local assets, skills, and environment in authorized offline or controlled lab scenarios. The plugin injects encrypted prompts into the local Harness session rather than reading prompt files from disk, and it resolves `$DSH_HOME` dynamically rather than hardcoding paths. Installation is via npm (`dsh-purge`) through the plugin marketplace or CLI, with a detailed manual fallback. The project is explicitly **non-commercial and non-profit**, with strict attribution requirements and a zero-tolerance policy for illegal use, unauthorized penetration, or commercial resale. Notably, the README publicly names and shames a violator — a Douyin livestreamer ("老张的ai") who was caught selling the free plugin for profit during a live broadcast. The project is currently in a **maintenance pause** while the author handles work commitments, though published versions remain usable. It requires Node.js ≥18 (≥22 for Windows flash-free operation) and is compatible only with dsh 0.2.x; earlier versions require older plugin releases. The project is listed on dsh-plugin.org and the DeepSeek Harness Hub, and accepts cryptocurrency donations (USDT/TRC20, Solana, Ethereum, Bitcoin) to sustain development. Its trending relevance stems from growing interest in DeepSeek ecosystem tooling, jailbreak research, and red-team evaluation frameworks for Chinese large language models.
SafetyEvalsToolssecuritylocal-first
★ 7,182 total+2,530 this week
#49
OpenMontage is an open-source, agentic video production system that transforms an AI coding assistant into a full-featured video production studio. Described as the first of its kind, the project allows users to describe what they want in plain language, after which an autonomous agent handles the entire pipeline: research, scripting, asset generation, editing, and final composition. The project is notable for a critical distinction it draws from typical AI video tools — it can produce genuine motion-clip video, not merely animated slideshows. The agent builds a corpus from free stock footage and open archives, retrieves actual motion clips, edits them into a timeline, and renders a finished piece, all within free or open-source workflows.
The system is designed to work with any AI coding assistant, including Claude Code, Cursor, GitHub Copilot, Windsurf, and Codex, making it broadly accessible to developers already using these tools. Users simply open the project in their assistant and describe their desired video in natural language. The agent then autonomously conducts live web research, generates AI images, writes and narrates scripts with voice direction, sources royalty-free background music, burns in word-level subtitles, and renders the final output. Before delivery, the system 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 major creative decision is gated for user approval.
A standout feature is the Backlot Living Storyboard, a local dashboard that fills itself in automatically as the pipeline runs. Rather than relying on chat logs to understand what the agent is doing, Backlot provides a visual board where production 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. Asset generation pauses at a scene-by-scene contact sheet — showing takes, prompts, per-asset costs, and quality scores — so users can approve visuals before the final render. The board also includes a replay feature, allowing users to scrub through the entire production timeline after a run completes.
OpenMontage also supports starting from a reference video. Users can paste a YouTube video, Short, Reel, TikTok link, or local clip, and the agent analyzes the transcript, pacing, scenes, keyframes, and style to generate two to three differentiated production concepts, an honest tool path, cost estimates, and a sample before full production begins. This grounded approach avoids guesswork and gives users a clear picture of what the output will look like given their available tools and budget.
The repository showcases several impressive demo productions that illustrate the system's range. These include "SIGNAL FROM TOMORROW," a cinematic sci-fi trailer using Veo-generated motion clips and Remotion composition; "THE LAST BANANA," a Pixar-style animated short produced with Kling v3 via fal.ai, Google Chirp3-HD narration, and royalty-free piano music for a total cost of $1.33; "OBJECTS IN OVERDRIVE," a 3D showcase using custom Blender animation, Blender Eevee and Cycles rendering, and FFmpeg assembly; "How Salt Made History," a 100-second cinematic documentary blending real-world footage with original narration and hand-authored motion graphics; and "One Prompt Built This Complete 3D World," a 60-second fantasy world journey assembled from textured 3D assets with cinematic lighting and a planned camera path. These examples demonstrate the system's ability to span documentary, animation, product film, and 3D cinematic genres at remarkably low cost.
Technically, OpenMontage requires Python 3.10 or higher, FFmpeg, Node.js 18 or higher, and an AI coding assistant. Installation is straightforward via a single make setup command after cloning the repository. The project is licensed under AGPLv3, signaling a strong open-source commitment while restricting proprietary forks. It achieved the number one Repository of the Day on GitHub Trending, underscoring its immediate community impact. The project is actively documented with a providers guide, PR review guide, and a dedicated Agent Guide, and the team publishes every video to a YouTube channel with full prompts, pipelines, tools used, and costs so that anyone can reproduce the results. OpenMontage represents a meaningful step toward democratizing professional video production through agentic AI workflows.
AgentsAppsToolsmultimodalvideoworkflow-automation
★ 69,593 total+2,498 this week
#50
Caveman is an open-source token-reduction toolkit for AI coding agents that makes agents "say less and read less" without sacrificing answer quality or code correctness. The core philosophy, captured in its tagline "why many token when few do trick," is that AI agents waste enormous amounts of tokens on verbose prose, redundant logs, and bloated file reads — and that stripping this waste down to essentials saves money and time while preserving correctness. The project is structured around six modular "rocks," all enabled by default after a single install command. The first rock, "Say less," applies a structured caveman voice to agent responses — a controlled English style inspired by ASD-STE100 aircraft maintenance standards — reducing output tokens by 35–65% compared to verbose defaults while keeping code, commands, and error messages character-perfect. The second rock, "Read less," compresses logs, CSVs, JSON, YAML, and test output before the model reads them, achieving 33.2% fewer input tokens across whole sessions in benchmarks where 18 of 18 answers remained correct. The third rock, "Auto," dynamically selects the model and effort level per task, cutting costs by 54% compared to always running Claude Opus at maximum effort across 85 real coding tasks with no measurable quality loss. The fourth rock, "Blocks," caches scripts the agent writes in code mode and reruns them rather than regenerating, shrinking one test run from 397 to 76 tokens. Additional rocks handle waste detection, prompt cache warming during pauses, and web page compression (achieving up to 129.8× smaller pages). The project has attracted significant external validation: Adobe Research cited it in a formal paper (CAVEWOMAN) showing 1.4–2.4× cost reductions across eight models; Elastic remade it for Elasticsearch and reported 63.6% fewer response tokens with zero information loss; and JetBrains ran a paired A/B test across 86 coding tasks finding no measurable quality loss (p = 0.82). Caveman reached #1 on Hacker News and #1 on GitHub Trending, and was reviewed by prominent developer content creator ThePrimeagen. It supports 30+ agents including Claude Code, Codex, Gemini CLI, and OpenCode, installs via a single npx command, and requires Node.js 22.13+. The project is notably honest about its limitations, publishing cases where caveman loses and flagging that HTML compression is not yet implemented. At version 4.0, it is actively maintained and maturing rapidly, making it a notable trending project at the intersection of AI cost optimization, developer tooling, and LLM efficiency research.
ToolsServingTrainingcodingworkflow-automationon-device
★ 113,507 total+2,421 this week
#51
Hypit is an open-source, agentic AI video creation and cloning platform that enables AI coding agents — such as Claude Code and OpenAI Codex — to analyze a reference video and reproduce its entire production workflow, including footage, captions, B-roll, effects, and motion graphics, all described in a word-anchored markup language called SVML rather than timecode-based editing. The core promise is radical scalability: one command, one reference video, and the agent can generate up to 100 distinct variants, each preserving the viral structure while swapping hosts, languages, products, rankings, or hooks. Hypit introduces SVML (a structured video markup language) as the lingua franca between AI agents and the video rendering pipeline, making compositions editable, re-runnable, and modular rather than one-off renders. The system is deliberately model-agnostic and generation-optional: workflows can compile captions, motion graphics, and code-rendered visuals into finished videos without invoking any generative model, avoiding those service charges entirely. When generation is needed, it integrates with services like HypiHub, GPT Image 2, Seedance 2 Mini, and WhisperX for word-level caption alignment. Rendering is parallelized across 64 headless Chromium processes for speed. Installation is a single npx command that registers the /hypit skill into a compatible coding agent environment. The project targets high-volume content use cases: paid social ads cloned from Meta Ad Library, TikTok/Reels/Shorts viral remixes, TikTok Shop affiliate videos, AI UGC talking heads, podcast clips, street interview formats, and fully code-rendered visuals. Demonstrated example costs are strikingly low — complete multi-variant productions with AI-generated A-rolls, B-rolls, portraits, captions, and music running between $1.07 and $1.15 total. The tech stack is TypeScript 5.9, Node.js 22.15+, and pnpm 10.33, licensed Apache-2.0 with conditions. Hypit achieved the #1 Repository of the Day and #1 TypeScript Repository of the Day and Week on Trendshift, signaling rapid community traction. It is free to use with no per-render fees or watermarks; users pay only their chosen model and agent service providers. The project is notably early-stage but already feature-rich, with working examples, a quickstart guide, agent environment documentation, and an active Discord, Telegram, and X community, making it a compelling and timely entry at the intersection
AgentsAppsToolsvideoworkflow-automationmultimodal
★ 23,631 total+2,346 this week
#52
**Humanizer** is an agent skill that rewrites AI-generated text to sound like it was written by a human, without altering the underlying facts or meaning. It is grounded in Wikipedia's "Signs of AI Writing" guide — the same reference Wikipedia editors use to identify AI-generated content — giving the project a credible, well-documented theoretical foundation. The tool integrates directly into AI coding and writing agents including Claude Code, Codex, Gemini CLI, GitHub Copilot, and Windsurf via the Skills CLI, and can also be installed manually in Claude.ai and Claude Desktop. Its core approach involves detecting and rewriting 26 named patterns of AI writing, organized into six categories: staging instead of stating, rhythm by rule, inflation and borrowed authority, formatting by rule, chat/draft leftovers, and writing for the wrong reader. The five strongest tells — constructions like "Not X but Y," one-line dramatic closers, pseudo-profound sayings, staged run-ups, and arguing with no one — each justify an edit on a single occurrence. Humanizer also supports voice matching: paste a few paragraphs of your own writing and it will mirror your rhythm, word choice, punctuation, and deliberate quirks. It explicitly does not aim to fool AI detectors, focusing instead on genuine readability for human audiences. In a blind evaluation, judges preferred Humanizer's rewrites over the original AI text in all 16 of 16 trials. The project is sponsored by cfo.ai and distributed through the skills.sh marketplace, signaling early but active commercial backing. Its combination of a rigorous pattern taxonomy, multi-agent compatibility, and a strong empirical result makes it a notable and practically useful tool in the growing space of AI-output post-processing.
ToolsAppsworkflow-automation
★ 58,173 total+2,315 this week
#53NEWPartial week
Solid Glass is a refined glass-inspired UI theme and component library built by DeepLethe, specifically designed for AI applications such as agent workspaces, chat interfaces, and task-monitoring dashboards. It occupies a deliberate middle ground between flat design and Apple-style liquid glass — letting only subtle edge highlights, fine borders, and soft shadows define surfaces, keeping interfaces calm and readable while AI content streams and changes dynamically. Built as a single CSS stylesheet on top of shadcn/ui (React 19, Tailwind CSS 4), it requires no modifications to existing components, installing via the standard `npx shadcn add` command. The registry currently offers 13 items, including AI-specific components like `turn-status`, `composer`, `tool-steps`, `diff-view`, `ask-card`, `context-ring`, `reasoning`, and a full `agent-workspace` block — making it immediately practical for agent UI development. The project supports both dark and light themes, includes a live "Create" page for tuning material variables, and ships with full documentation, contribution guidelines, and GitHub Actions CI/CD. Its notable trend relevance lies in targeting the rapidly growing agent/LLM UI space with a polished, opinionated design system that prioritizes readability and hierarchy over visual novelty.
AppsAgentsmultimodalworkflow-automation
★ 2,145 total+2,201 this week
#54
**text-to-cad** is an open-source plugin that gives AI coding agents the ability to generate and manipulate 3D CAD models directly within their workflows. The project allows agents to produce 3D files in standard formats — STEP, GLB, STL, and 3MF — from natural language prompts, and extends further into design-for-manufacturing (DFM) checks, engineering drawing generation, and direct integration with 3D printing, sheet metal, and CNC fabrication services. At its core, the plugin wraps the `cadgen` Python package (built on `build123d` and Open CASCADE) and exposes CAD capabilities as agent-callable skills via the `skills.sh` framework and MCP (Model Context Protocol) server architecture. The project is notably broad in agent compatibility, supporting Claude Code, Claude Desktop, Codex, Cursor, Gemini, and Grok Build — essentially any agent platform that supports plugins or the skills framework. Installation is designed to be agent-driven: users can simply tell their agent to install text-to-cad from the GitHub URL, and the agent handles the rest using `uv` as the Python runtime manager. Each supported agent platform has tailored install, update, and uninstall commands, and the plugin includes an integrated CAD viewer that renders 3D models inline in conversation UIs where supported, or via a localhost browser viewer otherwise. The project ships with telemetry enabled by default (anonymous, no file paths or prompts), which can be disabled via a CLI command or by asking the agent. It is MIT-licensed, actively tested via GitHub Actions CI, and versioned on PyPI as `cadgen`. The project appears to be in active, rapid development — the README references versioned releases, a `latest` branch strategy, and a growing set of skills across releases. Its notable trend signal lies at the intersection of two hot areas: agentic AI tooling and physical-world fabrication, making it a compelling bridge between LLM agents and real-world manufacturing pipelines. The multi-agent compatibility and agent-driven self-installation pattern reflect modern agentic UX design thinking, which likely contributes to its growing GitHub star traction.
ToolsMCPAppscodingworkflow-automationmultimodal
★ 21,502 total+2,141 this week
#55
DiPlay is an independent Android app (package `com.shihab.diplay`) that brings wired and wireless Apple CarPlay to compatible BYD Android head units, mimicking the familiar DiAuto interface without requiring jailbreaking, dongles, or external authentication servers. Currently in public preview at version 0.2.21, it supports Android 7.0+ and multiple Wi-Fi connection modes including Wi-Fi Direct, car hotspot, and existing LAN. Key features include BYD HUD navigation with arrows and street names, audio buffering improvements, local diagnostic export, and optional dashboard/battery/wheel-speed/parked-video features via ADB. The release bundles an experimental accessory identity recovered from public Carlinkit firmware rather than a proper MFi identity, making it unofficial and not Apple-certified. Notable recent fixes address audio sync, wired CarPlay recovery, microphone compatibility, and wireless startup feedback. The project is multilingual (English, Arabic, Russian, Ukrainian, Spanish, Chinese, Japanese, Italian) and is based on the GPL-3.0 xcertplay project. It is trending likely due to its novel approach of enabling CarPlay on BYD vehicles—a rapidly growing EV brand—without proprietary hardware, attracting community testers across multiple head-unit models and iOS versions.
AppsMCPmultimodalon-device
★ 11,538 total+2,052 this week
#56
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
★ 221,010 total+2,037 this week
#57NEWPartial week
**dsh-ops** is a JavaScript/TypeScript plugin for the DSH (DeepSeek Harness) platform that adds bounded file and document reading tools to AI agent workflows. It operates in two modes: Native mode, which returns compact, line-numbered text output, and PTC (typed Outcome) mode, backed by a Rust worker derived from the FastCtx project. The plugin provides 19 APIs covering file/document operations including CSV/TSV, DOCX, and limited PDF reading, with explicit exclusions for OCR, HTML scraping, and binary DOC formats. Seven components can be independently toggled without disrupting existing profile configurations, and an optional read-only TUI sidebar is available. Currently at **version 0.4.0 release candidate**, it targets a 40% token reduction over 0.3.x and enforces a 400-token cap on file/discovery schemas. Installation supports npm, official DSH CLI, and a Huawei Cloud npm mirror. The project is trending on Trendshift's JavaScript daily chart and ranked #2 on Upstar for JavaScript, suggesting rapid community growth. Licensed under MIT and Apache-2.0, it acknowledges FastCtx by yc-duan as its Rust tooling foundation.
ToolsAgentsMCPworkflow-automationlocal-first
★ 3,124 total+2,004 this week
#58
**Skills for Designers and Engineers** is a curated collection of AI agent "skills" created by Emil Kowalski, a designer/engineer with experience at Vercel and Linear, aimed at improving the quality of UI animations and interface design when using AI coding agents. The core premise is that AI agents lack taste — they make subtle but compounding mistakes like using wrong easing curves or poor visual choices — and these skills act as expert-encoded rules to correct that. Installed via a simple `npx skills@latest add emilkowalski/skills` command, the toolkit includes skills for building animations from scratch, reviewing and auditing existing animations, finding animation opportunities, applying Apple design principles, writing modern Swift, picking UI libraries, and working with Sonner (Emil's own toast library). It also covers React Native/Expo-specific animation guidance. The project is notably opinionated and experience-driven, explicitly positioning itself as a counter to generic AI output — a "shortcut to stand out in a sea of slop." Its trending status likely reflects growing developer interest in improving AI-assisted UI quality and Emil's strong reputation in the design-engineering community.
ToolsAppscodingworkflow-automation
★ 47,423 total+1,982 this week
#59
DSH Desktop is an open-source desktop Agent application built by the Dataelem team, wrapping the DeepSeek Harness AI agent framework into a native installed app for macOS and Windows. It automatically manages the Harness runtime, stores profiles, plugins, workspaces, and sessions outside the app directory, and supports both official DeepSeek models and third-party model providers. Key features include portable `.dshpreset` Agent preset packages with conflict/trust checks, a built-in PPT mode generating editable PPTX decks from 16 templates and 192 layouts, offline DOCX/PPTX/XLSX processing, and phone-based session continuation over local Wi-Fi or Cloudflare/Pinggy tunnels. Security is emphasized through sandboxed rendering, loopback-only Harness ports, and short-lived pairing tokens. The project also offers Safe Mode for isolating third-party plugin failures and guided recovery. Currently an early preview built on `@deepseek-ai/dsh@0.2.0-rc.2`, it is MIT-licensed with both stable and pre-release channels. Its notable positioning at the intersection of local AI agents, cross-platform desktop packaging, and mobile continuity makes it relevant to the rapidly growing DeepSeek ecosystem.
AppsAgentsMCPlocal-firston-deviceworkflow-automation
★ 15,310 total+1,959 this week
#60
The `cursor/plugins` repository is the official collection of agent plugins for Cursor, the AI-powered code editor, designed to extend its capabilities across popular developer tools, frameworks, SaaS products, and productivity platforms. Each plugin lives as a standalone directory at the repository root and is defined by a `.cursor-plugin/plugin.json` manifest, making the architecture modular and easy to extend. The plugin catalog is already impressively broad, spanning four major categories: Utilities, Developer Tools, Productivity, and Integrations. On the developer tooling side, plugins cover sophisticated agentic workflows such as parallel cloud agent orchestration (`orchestrate`), deep security and code-quality branch audits (`thermos`), iterative self-referential AI loops (`ralph-loop`), CLI design patterns for coding agents (`cli-for-agent`), and continual learning via transcript-driven memory updates. There are also plugins for scaffolding new plugins (`create-plugin`), consulting stronger models before major decisions (`advisor`), and building on the Cursor Origin API and TypeScript SDK. The productivity and integration plugins are extensive, covering the full Google Workspace suite (Gmail, Drive, Calendar, Docs, Sheets, Slides), CRM platforms (Salesforce, HubSpot, Attio), sales and marketing tools (Outreach, Klaviyo, Customer.io, Amplemarket, Brevo), recruiting tools (Ashby, Workable, Juicebox, Upwork), meeting intelligence (Gong, Fireflies, Otter.ai, Fathom, Zoom, Circleback), financial platforms (Xero, Brex, Interactive Brokers, Webull, S&P Global), advertising (Google Ads, Meta Ads, X Ads), SEO tools (Semrush, Ahrefs, Similarweb), and many more. The repository is clearly in active, early-stage growth — a rapidly expanding ecosystem rather than a mature, stable release — with contributions from both the Cursor team and community authors like Eric Zakariasson, Lauren Tan, and Dylan Gattey. Its trending appeal lies in the fact that it represents Cursor's push to become a universal AI agent platform, not just a coding assistant, by enabling agents to interact
MCPAgentsToolsworkflow-automationcoding
★ 12,821 total+1,896 this week
#61
Vorssaint is a macOS menu bar utility that consolidates the functionality of a dozen or more paid Mac apps into a single, modular application. Rather than forcing users to install everything, it offers a feature hub where individual capabilities can be installed or removed on demand — uninstalled features stop loading entirely and disappear from the UI, while their settings are preserved for later restoration. The app is built natively for macOS 14+ on Apple Silicon and is written in Swift, with CI badges and active GitHub releases indicating a maintained, production-ready project. It is notably trending on Trendshift both weekly and monthly in the Swift language category, signaling strong and growing community interest.
The feature set is exceptionally broad. On the audio side it provides per-app volume mixing (no audio driver required), per-app output routing, output switching, and microphone management. For system monitoring it offers CPU, GPU, memory, temperature, battery, and network graphs, plus fan control in beta. Window and Dock management includes a live-preview app switcher (the alt-tab replacement central to this query), window snapping and layout restoration, Dock hover previews, and Space order locking. Keyboard and mouse enhancements cover text snippets, smooth scrolling, pointer acceleration control, scroll direction inversion, super-key remapping, and key debounce. Clipboard and file tools include searchable clipboard history, a file shelf, Finder cut-and-paste, and automatic URL tracking-parameter removal. Everyday tools span a Dynamic Island implementation (even simulated on non-notch Macs), AI agent monitoring for Claude, Codex, OpenCode, and GitHub Copilot, a command bar, radial menu, and scratchpad. Capture tools include screenshot annotation, screen recording with audio track separation, offline OCR, color picking, and local media compression. App management handles updates across store, package-managed, and developer-feed sources. The app is private by default — no account, no telemetry, no subscription — and supports over a dozen languages with exportable settings.
AppsToolsAgentslocal-firston-devicemultimodal
★ 28,150 total+1,855 this week
#62
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, prominent websites across dozens of industries. The core concept originates from Google Stitch, which introduced DESIGN.md as a plain-text, markdown-based design system document that AI coding agents and design agents can read to generate visually consistent UI — no Figma exports, no JSON schemas, no special tooling required. The analogy is direct: just as AGENTS.md tells a coding agent how to build a project, DESIGN.md tells a design agent how the project should look and feel. The repository currently hosts 84 such files, each capturing deep design analysis including color tokens, typography rules, layout patterns, and visual language extracted from real production websites. The collection spans a wide range of categories: AI and LLM platforms (Claude, Mistral AI, xAI, ElevenLabs, Runway), developer tools and IDEs (Cursor, Vercel, Warp, Raycast), backend and DevOps tools (Supabase, Sentry, PostHog, MongoDB), productivity and SaaS (Linear, Notion, Intercom), fintech and crypto (Stripe, Coinbase, Revolut, Mercury), e-commerce (Shopify, Nike, Airbnb), and media and consumer tech (Apple, NVIDIA, IBM). Each entry includes a brief design personality description — for example, Stripe's "signature purple gradients, weight-300 elegance" or Ollama's "terminal-first, monochrome simplicity" — making the collection immediately useful for developers and "vibecoders" who want to replicate a specific aesthetic. Users can also request custom DESIGN.md files for specific websites via getdesign.md. The project is ranked #150 globally on GitHub, carries the official Awesome badge, and is actively maintained with recent commits. Its notable momentum likely stems from the explosive growth of AI-assisted UI development and vibe coding workflows, where LLM-readable design context dramatically improves output quality. It is community-oriented, sponsor-supported, and backed by VoltAgent's broader AI agent ecosystem including official MCP servers and a Discord community.
ToolsAppsMCPworkflow-automationcoding
★ 122,135 total+1,764 this week
#63
Nature Skills (Yuan1z0825/nature-skills) is an open-source, reusable scientific research skill library designed for AI-assisted academic workflows, targeting global scholars — with a particular emphasis on Chinese researchers. The project packages standardized, verifiable research workflows into modular "skills," each organized around a `SKILL.md` file and installable into multiple AI agent environments. The core philosophy is that practical research tools can be abstracted into reusable, machine-understandable skill units that AI agents like Codex or Claude Code can directly learn from and execute, eliminating the need for researchers to manually master every workflow. The project currently indexes 22 skills covering tasks such as Chinese-English paper reading (nature-reader), paper-to-PPT conversion (nature-paper2ppt), academic writing and polishing in Nature journal style (nature-polishing, nature-writing), pre-submission peer review simulation (nature-reviewer), reviewer response drafting (nature-response), scientific figure generation (nature-figure), literature citation analysis, patent conversion (nature-paper-to-patent), academic search (nature-academic-search), and research proposal writing (nature-proposal-writer). Installation is supported across multiple agent platforms — Claude Code, OpenAI Codex, OpenClaw, OpenCode, Hermes, and Chatbox — via an `npx skills` CLI, shell scripts, or direct git clone workflows. The repository includes auto-update mechanisms via `SessionStart` hooks for both Claude Code and Codex, allowing skills to stay current without manual intervention. A shared support package (`nature-shared`) provides common dependencies across skills, and optional Python/MCP dependencies support advanced features like PubMed search, CNIPA patent retrieval, and Playwright-based browser automation. The project is founded and maintained by Yuan Yizhe, with core development contributions from Ma Xinrui and Hu Bin. 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. A companion web platform at natureskills.cn offers browser-based access to Nature Polishing and Nature Figure features without local installation. Community engagement is maintained through Douyin video tutorials, a WeChat research group, and a Zhishi Xingqiu (knowledge community). The project is licensed under Apache-2.0 and is actively growing, making it notable as a pioneering, community-driven framework that is reshaping how Chinese and global researchers interact with AI agents for scientific work — particularly by enabling local computer control via agentic AI for end-to-end research tasks.
ToolsAppsAgentsworkflow-automationbrowser-usecoding
★ 49,159 total+1,695 this week
#64
The `skills` repository by Vercel Labs 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 and act as modular, reusable capability extensions that can be plugged into agents like OpenCode, Claude Code, Codex, Cursor, and over 75 others. The project is published on npm as the `skills` package and is licensed under MIT, positioning it as an open, community-driven standard rather than a proprietary solution.
The core command is `npx skills add`, which installs skills from a wide range of sources: GitHub shorthand (e.g., `owner/repo`), full GitHub or GitLab URLs, Azure DevOps repositories, arbitrary Git URLs, direct download links (supporting `.zip`, `.tar`, `.tar.gz`, `.tgz`, or raw `SKILL.md` files), and local paths. This flexibility makes it highly versatile for both public and private repository workflows. For private repositories, the CLI intelligently chains authentication strategies — Git credential helpers, GitHub CLI (`gh`), and SSH fallback — without ever exposing stored credentials to the Node.js process, which is a notable security-conscious design decision.
Installation can be scoped to a project (committed alongside code and shared with a team) or globally across all projects via the `-g` flag. Skills can be installed as symlinks (the recommended default, creating a single source of truth) or as independent copies when symlinks aren't supported. The CLI supports non-interactive, CI/CD-friendly usage through flags like `--yes` and `--all`, making it suitable for automated pipelines.
Beyond installation, the CLI offers a rich command surface: `skills list` to inspect installed skills, `skills find` for interactive or keyword-based discovery (including organization-wide searches), `skills update` to pull the latest versions of installed skills, `skills remove` to cleanly uninstall skills from specific agents or scopes, `skills use` to generate and pipe a skill's 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 ephemeral, one-shot agent interactions — it writes skill files to a temporary directory and either prints the prompt to stdout or launches a supported agent interactively.
The project is a Vercel Labs product, indicating it is experimental or early-stage but backed by Vercel's engineering organization. Its breadth of supported agents (79+), multi-platform source resolution, security-aware authentication handling, and clean CLI ergonomics suggest it is aiming to become a de facto package manager for the emerging AI agent tooling ecosystem — analogous to npm but for agent instruction sets. Its appearance on GitHub Trending reflects growing developer interest in standardized, portable AI agent capabilities and the broader trend of treating agent instructions as first-class, shareable software artifacts.
ToolsAgentsMCPcodingworkflow-automation
★ 35,525 total+1,673 this week
#65NEWPartial week
Filee is a free, open-source, drag-and-drop file converter for Windows (10/11), with macOS and Linux in preview, built by Myeonggu Kim (KnifeLemon). Its signature UX is a "donut" radial menu that appears at the cursor when the user holds Ctrl/Option and drags files, showing only contextually relevant output formats. It supports 244 formats spanning images, PDFs, documents, spreadsheets, presentations, HWP/HWPX, e-books, video, audio, subtitles, archives, CAD, fonts, data, and 3D models — all processed locally with no uploads or telemetry. For audio specifically, it converts between MP3, M4A, AAC, WAV, FLAC, OGG, OPUS, WMA, AIFF, AMR, APE, WavPack, TTA, DSD, DTS, AC3, E-AC3, and more via FFmpeg. Optional engines (FFmpeg, LibreOffice, Ghostscript, Pandoc, calibre) are downloaded on demand. Features include parallel batch conversion, watch folders, a CLI (`filee` command), presets, and multi-language support (English, Korean, Chinese). Built on .NET 10, it is an early but actively developed project with CI, versioned releases, and a growing star history, making it notable for its polished UX approach to a traditionally clunky task.
AppsToolsaudiovideolocal-first
★ 4,594 total+1,660 this week
#66
TencentDB Agent Memory is an open-source, production-oriented memory infrastructure system built by TencentCloud that enables AI agents to share, accumulate, and reuse knowledge across sessions, frameworks, and team members. The core motivation is eliminating repetitive work: if an agent has already learned project context, read documents, or solved a problem, that experience should be preserved and passed forward rather than rediscovered from scratch. The system is architected around three services — `memory-core`, `memory-hub`, and a transparent `proxy` — all launchable with a single shell script, making setup accessible within minutes. Its most distinctive design choice is a zero-code integration model: agents simply point their base URL to the Proxy, and they immediately gain memory capabilities without plugins, hooks, or MCP servers. This means diverse agents — Claude Code, Codex, DeepSeek Harness, CodeBuddy, WorkBuddy, Hermes, and OpenClaw — all share the same memory server out of the box. Memory assets are organized into four richly structured types: Chat Memory (distilled across four layers from raw conversation to persona), Skills (versioned, executable expertise with trigger boundaries and validation rules), Wiki (structured document knowledge with link graphs, inspired by Karpathy's LLM knowledge base approach), and CodeGraph (symbol-level code indexing with call relationships and impact analysis). A key feature is cold-start support: existing codebases, documents, and past agent conversation sessions can be imported and automatically processed, so new agents inherit accumulated team experience rather than starting from zero. The system supports multi-agent team workflows, enabling a "one-person company" model where specialized agents (Scout, Builder, Reviewer) each receive tailored memory loadouts. Access control is granular, with private, team, and restricted visibility tiers, plus two-layer role management (global System Admin and team-level Admin/Member). The project is currently in active beta (v2/v3 migration tooling exists, MongoDB backend is experimental), published on npm, MIT-licensed, and requires Node.js ≥ 22.16. It is trending on Trendshift, has a Discord community, and supports both English and Simplified Chinese documentation. Compared to standard RAG or chat history, TencentDB Agent Memory adds ownership tracking, versioning, structured relationships, and agent-specific routing — positioning it as a team-grade memory layer rather than a simple retrieval store. Its notable ambition is making agent experience compound over time the way institutional knowledge does in human organizations.
RetrievalAgentsToolslocal-firstvector-databasesynthetic-data
★ 29,591 total+1,658 this week
#67
OpenDesign, from nexu-io, bills itself as "the 1st collaborative AI design agent workspace," an open and extensible platform where teams move from a brief to a working prototype that respects their design system, share it for team feedback, and let their coding agent refine it within the same project. The project is licensed under Apache 2.0 and provides teams with inspectable, adaptable building blocks: skills, design templates, design systems, and plugins that can be tailored to an organization's own workflow. The README prominently celebrates a milestone of 100K GitHub stars, pairing it with a promotional "OpenDesign Go" credit offer (e.g., $8 for the first month with up to $120 in monthly credits for eligible Design Plan models) across 10+ models including GPT-6 Luna, DeepSeek V4.1 Flash, GLM-5.3 Flash-X, and MiMo V2.6 Flash, with personal plans including API access for Codex, Claude Code, DSH, OpenCode, and more. This emphasis on stars, credits, and broad model/agent support suggests the repository is positioned as a trending, actively marketed developer tool.
A product tour walks through core pages: a Home page with a prototype composer and example prompts; an "All projects" view for revisiting design systems, media, and prototypes; a Design Systems page for inspecting brand assets (e.g., a Stripe brand identity example) and refining them with an agent; and a Plugins page for finding and launching skills via a "Try it" action. The central workspace, called Studio, lets users create and refine within one project across several deliverable types: Prototypes (building and refining interactive web experiences with live preview), Slides (creating decks with speaker notes and export), Image (generating visual assets from the conversation), and HyperFrames (creating motion graphics with an agent and exporting to MP4).
A major theme — relevant to the "agent-skills" query — is platform compatibility with mainstream coding agents. OpenDesign connects in two ways: via skills, CLI, and MCP for agents that consume OpenDesign (OD), and via native runtime adapters for agents that OD launches directly. DeepSeek Harness is highlighted as a first-class native runtime through its official `dsh` CLI, offering structured streaming, model discovery, cancellation, and session resume. A compatibility table lists many supported agents, each with a quick-setup command, including Claude Code, Claude Desktop, Codex CLI, DeepSeek Reasonix, DeepSeek Harness (native runtime via `od agent setup deepseek-harness`), Raven, Cursor, VS Code + GitHub Copilot, GitHub Copilot CLI, OpenCode, OpenClaw, Antigravity, Cline, Trae, Kimi CLI, Kiro, Pi Agent, Mistral Vibe CLI, and Hermes Agent. Most use `od mcp install <agent>` commands, with options like `--print` for a dry run and `--uninstall` for removal. A caption references 26 supported coding-agent CLIs, naming additional ones such as Vela, Grok Build, Qwen, Qoder, Aider, Amp, CodeBuddy, Mimo, AtomCode, Devin, and Kilo. Automatic MCP configuration for Claude Desktop is noted as macOS- and Windows-only.
For users without a CLI installed, OpenDesign offers a BYOK (bring your own key) proxy at `POST /api/proxy/{anthropic,openai,azure,google,ollama,senseaudio}/stream`, which replicates the same loop without spawning a process. Users paste a baseUrl, apiKey, and model, with presets for OpenAI, Atlas Cloud, Anthropic, Azure OpenAI, Google Gemini, Ollama, LM Studio, vLLM, or any Op
AppsAgentsToolslocal-firstmultimodalworkflow-automation
★ 102,262 total+1,645 this week
#68
Universal-modder is an open-source toolkit that equips any AI coding agent with the skills, tools, and a shared knowledge base needed to mod almost any PC game a user owns. Rather than targeting a single game or engine, it takes a universal approach: the agent automatically identifies the game, determines its engine, selects a modding route, reads actual game code, builds the mod, generates art, 3D assets, and sound via the fal AI platform, tests the mod in the running game, records a showcase video, and finally writes a structured "field note" to the shared knowledge base for future agents to build upon. This ten-step loop is codified in a skill called `mod-any-game`, which includes engine-specific playbooks covering Unity, Unreal, .NET/XNA (Terraria, Stardew Valley, Celeste), Godot, Source 1/2, Bethesda engines, Minecraft, the Genie engine (Age of Empires II), Bannerlord, RE Engine, GTA, Cyberpunk, Baldur's Gate 3, native C++, and many indie and retro engines. The project supports a wide range of AI agents out of the box — Claude Code, Codex, Cursor, Gemini CLI, GitHub Copilot, and OpenCode — each receiving the same Agent Skills format, the fal MCP server, and the `um` CLI tool. A central and distinctive feature is the community-maintained `knowledge/` directory, a database of field notes written by AI agents for AI agents, documenting exact versions, modding routes, engine internals, verification steps, and known gotchas for specific games. Agents that complete a mod can automatically open a pull request to contribute their findings, creating a compounding, self-improving knowledge base. Additional skills cover game reconnaissance, web research (including Wayback Machine and Nexus/Workshop APIs), reverse engineering (ILSpy, Ghidra, Cheat Engine, Frida, RenderDoc), asset pipelines, game automation, showcase video production, mod porting, mashup mods (e.g., running Minecraft inside GTA V), and mod publishing. Asset generation is powered by fal for images, 3D, SFX, music, and video, with optional local ComfyUI and Sprixen support. The project is early-stage but actively growing, with a mod hub at universalmodder.com announced as coming soon and a Discord community already active. It is notable for its ambition to generalize AI-assisted game modding across virtually every PC game engine, its agent-agnostic design, and its novel AI-to-AI knowledge-sharing architecture. The Age of Empires II / Genie engine is explicitly listed as a supported engine playbook, making it directly relevant to that
ToolsAgentsAppsmultimodalcodingsynthetic-data
★ 8,368 total+1,639 this week
#69
Aurelio is a privacy-first, local-first wealth management and financial planning desktop app that consolidates banks, brokers, portfolios, real assets, debts, and cash flow goals into a single interface. Its standout feature is an optional AI advisor ("Ask Aurelio") powered via OpenRouter, which answers questions grounded in the user's own financial records, can search the web, and proposes actionable changes as confirmable cards. A dual-agent "analysis" mode features an analyst and a confidant persona debating the portfolio before synthesizing priorities. The app supports portfolio look-through by country, sector, company, and currency — useful for ETF investors. All data stays local in a SQLite file with automatic backups before schema migrations. The default AI model is Claude Opus 5.5, with transparent per-interaction cost breakdowns provided. Built with a Python/FastAPI backend and a Node.js frontend, it includes CI, demo mode, and cross-platform startup scripts. The project is early-stage but notably feature-rich, combining personal finance depth with conversational AI in a self-hosted, privacy-respecting package — making it relevant to the growing trend of local-first AI tooling.
AppsAgentsRetrievallocal-firstworkflow-automation
★ 3,963 total+1,593 this week
#70
**reverse-skill** is an open-source cybersecurity skills router designed to guide AI agents through structured, repeatable reverse-engineering and penetration-testing workflows rather than letting them guess commands. When an AI agent encounters a target — such as an Android APK, a native binary (ELF/DLL/EXE), obfuscated frontend JavaScript, a CTF challenge, firmware, or a pentest scope — the package routes it through a master routing ladder to the correct methodology, checks locally available tools, and executes a documented workflow covering evidence collection, timeline tracking, and report generation. The routing engine is driven by a single structured JSON configuration (`routing.json`) containing 44 rules (R0–R45), validated against a regression benchmark of 175 cases across Windows and Ubuntu CI platforms, keeping the core entirely client-neutral. The project supports over 20 distinct security scenarios, including APK/Android analysis, iOS mobile, binary reverse engineering, .NET/C#, JS encryption, DSL VM opcode analysis, malware/YARA, red-team attack chains, EDR bypass, LLM/AI security, supply chain/SBOM, API/GraphQL security, and CTF orchestration with 42 sub-skills. Key files include `MASTER-ROUTING.md` as the primary fast ladder, `RULES.md` as the global scope gate, `README_AI.md` as the AI agent bootstrap, and `skills/INDEX.md` as an auto-generated navigation index. Compatible AI clients include Claude Code, Codex, Cursor, and OpenCode, with all client-specific configuration kept optional and external. At version v1.0.1, the project is actively maintained with GitHub Actions CI, a supply-chain pin gate, and structured ops contracts. It is notably trending on Trendshift, sponsored by UCloud AstraFlow, Atlas Cloud, and Kite AI, and is notable for systematizing institutional security knowledge into a machine-consumable, agent-friendly routing framework that prevents repeated mistakes and tool confusion across diverse cybersecurity tasks.
ToolsAgentsMCPsecurityworkflow-automationcoding
★ 42,585 total+1,528 this week
#71NEWPartial week
DeepSeek Bot (DS Bot) is an open-source plugin for DeepSeek Harness (DSH) that transforms the DSH environment into a multi-bot platform where users can create, configure, and collaborate with AI bots. Key features include persistent bot memory, a "Chief" main bot that manages other bots and group chats, and group chat functionality where bots can delegate tasks to one another via @mentions. A shared Capabilities library supports MCP servers, skills, and packs that can be attached to individual bots. The plugin supports installation via npm, direct package download, or Docker for always-on NAS/server deployments, and runs on Windows, macOS, and Linux. All data is stored locally on the user's machine. Currently at v0.1 preview (early-stage), it is a community-driven, independent project — not an official DeepSeek product. It draws design inspiration from projects like OpenAI Codex, Hermes Agent, OpenCode, and Gemini CLI. Its notable appeal lies in combining local-first privacy, multi-agent orchestration, and broad deployment flexibility within a single plugin ecosystem.
AgentsMCPAppslocal-firstworkflow-automation
★ 2,514 total+1,523 this week
#72
The **ai-memory** project is an open-source, self-hosted long-term memory system designed specifically for AI coding agents. Its core premise is elegantly practical: when you quit one AI coding assistant mid-task and open a different one in the same directory, you should not have to re-explain your architecture, your failed approaches, or your open questions. The tool acts as a shared, persistent memory layer that sits beneath any agent harness, allowing seamless continuity across tools, machines, and even teammates.
The project's most distinctive architectural decision is its choice of a **git-backed markdown wiki as the source of truth**. Memory is stored as ordinary `.md` files that users can grep, open in Obsidian, edit by hand, or sync with rsync. A derived database index is built on top of these files for retrieval purposes, but the index is always rebuildable from the source files. There is no vector store to maintain and no content locked in a proprietary binary format. This philosophy of user ownership and transparency runs throughout the entire design.
A standout feature is its **zero-LLM-by-default** operation. Capture, full-text search, entity search, graph traversal, handoffs, and even memory aging all work without any API key or LLM call. Optional LLM-powered features — such as a background "dream" consolidation pass that rewrites cold note clusters into coherent pages while the user is idle — exist but are explicitly opt-in and off by default. The dream pass also cancels immediately when the user returns to work and never hard-deletes source material, keeping pre-merge versions reachable through git history.
The **cross-agent handoff protocol** is a typed, claim-once mechanism: a handoff has an owner and can be claimed exactly once by the next agent. This prevents duplicate work and ensures clean baton-passing between tools like Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Grok, Devin, Kimi, Kiro, and more than twenty other harnesses, all of which are first-party integrations verified by CI. The support matrix is remarkably broad, covering Linux, macOS, NixOS, Windows via WSL2, and experimentally native Windows.
Memory capture happens silently through **lifecycle hooks** that observe prompts, tool calls, and session boundaries. At session end, observations are sanitized at a typed privacy boundary before anything is stored, then consolidated into readable wiki pages. The next session — on any agent, any machine — receives a bounded startup brief and can search the full knowledge base using fused ranking across full-text search, entity search, link graphs, and optionally local vectors.
The **cross-project profile** feature is particularly thoughtful: a small profile of a user's working habits (preferred package manager, test layout, architectural patterns) is automatically injected at the start of every new repository session, eliminating the repetitive re-explanation problem that plagues developers who work across many codebases. On a shared server this profile is opt-in and private per person.
Memory aging is handled without LLM calls through a configurable per-tier decay schedule with **access-weighted retention**: memory that is actively used (opened, searched, or reached through links) decays more slowly. Cold episodic notes can be compacted down to durable facts rather than dropped outright. Near-duplicates are collapsed, and likely contradictions are flagged. All destructive operations (compaction, dedup, per-tier decay curves) are off by default, and nothing is hard-deleted — the original always remains in git with a full version chain, and a `restore-page` command brings back any prior state.
The project ships as a **single self-contained Rust binary** (requiring Rust 1.95+), licensed under MIT, with an optional server-rendered management console for user administration, session inspection, and personal MCP API keys. An audit log records every mutation. The write ceiling of approximately 700 operations per second is measured empirically rather than estimated. Multi-user authentication, per-person attribution, and the audit log are built-in features, not reserved for a paid tier.
In terms of maturity, the project is actively developed with versioned releases tracked on GitHub, a dedicated website at aimemory.sh, and comprehensive documentation including architecture docs, a support matrix, a comparison guide, and cross-project profile documentation. It explicitly acknowledges its intellectual debts to projects like the Karpathy LLM Wiki, agentmemory, basic-memory, cognee, Hermes Agent, and the A-MEM paper on Zettelkasten-style atomic notes.
Its trending appeal likely stems from the explosion of
ToolsAgentsMCPcodinglocal-firstworkflow-automation
★ 10,647 total+1,501 this week
#73
`/brag` is an open-source agent skill that automatically transforms any software project into a short, shareable launch video — complete with music, motion, and social share copy — using a single command. It integrates with multiple AI coding agents (Claude Code, Codex CLI, opencode, Cursor, Copilot, Gemini CLI) via a standardized skill discovery system, making it broadly compatible without extra configuration. The core workflow has `/brag` autonomously determine the product angle and tone, then hand a focused brief to Hyperframes, which renders the final MP4. A leaner variant, `/brag-slim`, was recently introduced specifically for Claude Opus 5.5, dropping the Hyperframes dependency while preserving the creative output. Users can also skip local setup entirely via the hosted web app at letsbrag.app. The project is actively evolving — version 0.4.0 bundled `/brag-slim`, and the repo includes a benchmark suite of fake product sites for testing. Its novelty lies in treating video launch marketing as an automatable agent skill, lowering the barrier for indie developers to ship polished product announcements. It is free, open source, and welcoming contributions.
ToolsAppsvideoworkflow-automationmultimodal
★ 16,764 total+1,492 this week
#74
KytyPS5 is a free and open-source PlayStation 5 translation layer written in C++, targeting Windows x64 and Linux x64 as primary platforms, with experimental macOS support via Rosetta 2 on Apple Silicon. The project is a heavily modified fork of the earlier Kyty emulator by InoriRus, now evolved into a dedicated PS5 compatibility layer. Rather than relying on external low-level emulation modules, KytyPS5 implements its own internal pipeline, including shader decoding and recompilation, GPU command processing, and a Vulkan 1.3 host backend. The PS5 GPU architecture is based on AMD RDNA 2, and the project references AMD's official RDNA 2 Instruction Set Architecture Reference Guide (document 70648) for shader instruction encoding. On macOS, Vulkan support is provided through the bundled MoltenVK library. The project can already boot a notable range of 2D and 3D titles, including games built on Unreal Engine 4/5, Unity, and custom engines, with verified in-game screenshots of titles such as Astro Bot, Demon's Souls, Neptunia ReVerse, SILENT HILL: The Short Message, Saros, and UFC 6. A public compatibility list is maintained at kytyps5.github.io, and weekly development updates are posted in GitHub Discussions. The build system uses CMake with Ninja and requires Clang (clang-cl on Windows, clang/clang++ on Linux), explicitly rejecting the MSVC compiler. Qt 6 is required for the launcher, while a headless emulator build is also supported on Linux without Qt. FFmpeg is statically linked from a pinned KytyPS5 FFmpeg core fork, providing VP9 and WebM support without requiring system FFmpeg packages. NixOS and Fedora/Fedora Atomic variants (Bazzite, Bluefin, Silverblue) receive dedicated build instructions, with Distrobox recommended for immutable Fedora systems. The project enforces strict contribution guidelines: pull requests must target a specific game bug, and unfocused or architectural-only PRs are automatically closed. Code formatting is enforced via clang-format through a pre-commit Git hook. Licensed under GPL-2.0, KytyPS5 is notable as one of the few actively developed, open-source PS5 translation layers with cross-platform CI builds and a growing game compatibility record, making it
MCPAppsmultimodallocal-first
★ 9,091 total+1,485 this week
#75
Colibri is an open-source, pure C inference engine designed to run very large mixture-of-experts (MoE) language models on ordinary consumer hardware — no GPU required, though one is supported and exploited when available. The project's tagline, "tiny engine, immense model," captures its core philosophy: keep the codebase minimal and auditable while enabling models with hundreds of billions of parameters to run on machines people already own. The key technical insight driving colibri is that MoE models, despite their enormous total parameter counts, only activate a small fraction of their weights per token — the so-called routed experts. Colibri exploits this sparsity by keeping the dense components (attention layers, shared experts, embeddings) resident in RAM while streaming the routed experts from disk on demand, through a cache that learns which experts a given workload tends to use. A GPU, when present, holds the hottest experts and dense layers in VRAM, further accelerating inference. This architecture means the model does not need to fit entirely in fast memory; it needs to be intelligently placed across the memory hierarchy.
The project currently ships thirteen engines. Ten target language models: GLM-5.2 and GLM-5.3 (a 744B MoE), GLM-5.3-Flash, Inkling, Kimi K3, DeepSeek V4 Flash, DeepSeek V4.1 Flash, MiMo-V2.6 Flash (and Pro), Qwen3.8-Flash-Next, Qwen3.6 (which also covers Qwen3-Coder and the dense Qwen3.8-27B), and OLMoE. One engine handles image generation via Qwen-Image-2.1. Two engines handle decision tasks — Laya and GLiNER2.5-Decide — with a third decision model, Clef, running on the Qwen3.6 engine. This breadth of supported model families across language, vision, and decision tasks is notable for a project of this scope and minimalism.
Getting started is designed to be a single-step process. On Windows, users unzip the repository and double-click START-HERE.bat; on Linux and macOS, a shell script handles everything. The setup script automatically inspects the machine's RAM, free disk space, CPU, and available GPUs, then recommends the most capable model that fits the hardware profile. It builds the engine from source when a compiler is available, targeting CUDA for NVIDIA GPUs on Linux when the CUDA toolkit is present, Vulkan for broader GPU support on Linux and Windows, and falling back gracefully to a CPU-only prebuilt binary otherwise. Integrated GPUs are also supported for select engines where benchmarks showed them to be faster than the CPU alone. Model downloads are resumable, so interrupted downloads can be continued without restarting. After setup, colibri launches a local web dashboard and exposes both OpenAI-compatible and Anthropic-compatible API endpoints, making it a drop-in local backend for existing AI tooling and coding assistants.
The minimum hardware requirement is 8 GB of RAM and 22 GB of free disk space for the smallest model, with 16 GB or more recommended. Larger models like GLM-5.2 require 429 GB of download and at least 16–24 GB of RAM, with disk streaming making up the difference. Measured decode speeds range from around 0.05–0.1 tokens per second cold on a 25 GB laptop for GLM-5.2, up to 30 tokens per second with CUDA for the smaller Qwen3.6-35B-A3B model. The project also supports the Model Context Protocol (MCP), allowing AI coding assistants to autonomously detect hardware, recommend models, install, start, stop, and monitor colibri through a dedicated MCP server.
Colibri is explicitly positioned as an open research platform. Its design philosophy mandates that any optimization must be validated with a reproducible end-to-end benchmark, and the default policy never silently alters model precision or router semantics. The dashboard visualizes every expert activation in real time, making the inference process transparent and inspectable. The codebase is structured as one C file per model family, keeping it compact and auditable. The project is free and open source, with the author accepting voluntary coffee donations to fund continued development. README translations are available in Simplified Chinese, Traditional Chinese, Italian, Japanese, and Indonesian, suggesting an intentionally international audience. The combination of extreme hardware accessibility, broad model support, API compatibility, MCP integration, and research-grade transparency makes colibri a compelling and distinctive entry in the local LLM inference space, explaining its presence on GitHub Trending.
ServingModelsMCPlocal-firston-devicemultimodal
★ 42,773 total+1,467 this week
#76
Career-ops is an open-source AI-powered job search agent built to help candidates evaluate, filter, and apply to job listings more intelligently and efficiently. The project was created by Santiago Fernández de Valderrama Aparicio (GitHub handle @santifer) after months of sending CVs into silence with no responses. Frustrated by the asymmetry of AI being used by companies to filter candidates while job seekers had no equivalent tool, he built career-ops for himself, used it to evaluate 740 listings, applied to 68, secured 12 interviews, and received 1 offer — landing the job. He then open-sourced the tool so others could benefit from the same approach. Six months after landing that role, he left and now develops career-ops full time.
The core workflow is simple and local-first: a user pastes a job listing URL or text, and the agent evaluates it on their own machine. It checks whether the posting is still live before any effort is invested, scores the role against the user's actual CV, and recommends whether to apply or skip. If the fit is strong enough (above a 4.0/5 threshold), it drafts a tailored CV, cover letter, and answers to application questions. It also identifies relevant hiring contacts and drafts outreach notes. Critically, the system never auto-submits anything — the user always reviews and clicks Submit themselves. No emails are sent, no data is uploaded to any career-ops backend, and there is no telemetry. The user's CV travels only from their machine to whichever AI provider they have chosen.
The evaluation framework is structured across labeled sections A through H. It includes a role summary, a CV match score with per-requirement weighting and sourcing labels (whether a weight came from the job description's own wording, its structure, or an estimate — with estimates capped below top-band), level and compensation strategy, personalization guidance, interview preparation using the STAR+R method, a posting-legitimacy check (Block G) that flags whether a listing is still open or is a repost, and a Work Authorization signal that hard-blocks roles with explicit no-sponsorship language. The system is explicitly human-in-the-loop: AI evaluates and recommends, but the human decides and acts at every stage.
Beyond basic evaluation, career-ops offers ATS-compatible PDF CV generation tailored to each job description, using Space Grotesk and DM Sans typography rendered via an HTML and Playwright pipeline. Cover letters are generated with keyword mirroring, four interactive angle prompts covering why, problems, approach, and tone, and a draft-in-chat approval gate before PDF generation. A deep research mode surfaces company AI strategy, recent moves, engineering culture, and the angle a candidate's profile should take. A contact discovery mode identifies hiring managers, recruiters, or relevant team peers worth reaching out to. After a run of rejections, the system can also name the skill or experience gap that may be causing them.
The project is installed and run via a single npx command and integrates into AI CLI environments the user already has. Free and local model options are documented for budget-conscious users. On first launch, the agent conducts an onboarding chat to learn the user's CV, preferences, and constraints — no manual configuration required. The system explicitly refuses to fabricate CV content, with a code-level check that blocks PDFs containing numbers or facts not present in the user's source materials, though it acknowledges this check is not exhaustive and urges users to read every CV before sending.
In terms of maturity and traction, career-ops has achieved notable visibility. It was ranked the number-one trending repository of the day on GitHub via Trendshift. It has been covered by WIRED Greece and Business Insider. It is featured on Product Hunt and is part of Vercel's Open Source Program, with SerpApi as a named sponsor. The project maintains a public HIRED.md file and issue tracker where users who landed jobs using the tool leave public cards — a live, auditable record of real outcomes. A community manifesto at career-ops.org articulates the philosophy in six principles: apply better to fewer, signal over volume, evidence over keywords, a human decides, local-first, and dignity on both sides of the table. The manifesto has a live signatory count, with each signature recorded as an auditable commit. The project has an active Discord community and a contributor wall showing growth since April 2026. Sponsorship is explicitly ring-fenced from product influence — sponsors receive labeled visibility only and never appear in evaluations or recommendations. The README is available in 19 languages, signaling strong international reach and community investment. Overall, career-ops is a well-documented, ethically grounded, community-driven tool that sits at the intersection of AI agents, career tooling, and local-first software — making it highly relevant to trends in agentic AI, job market automation, and open-source developer tooling.
AgentsAppsToolslocal-firstworkflow-automationbrowser-use
★ 75,530 total+1,451 this week
#77
JiuwenSwarm is an open-source multi-agent collaboration framework developed by openJiuwen-ai, designed to automate complex tasks through natural language intent, swarm-based agent orchestration, and self-evolving skills. At its core, a Leader agent decomposes tasks and dynamically assembles specialized teams of sub-agents that negotiate and collaborate, operating either on a single machine or across distributed clusters. A standout feature called Swarmflow enables deterministic multi-stage Python-scripted workflows with human-in-the-loop (HITL) support, progressive tool exposure, team token budgeting, and real-time TUI run-tree monitoring. The system's Skill Self-Evolution mechanism automatically detects errors and user dissatisfaction signals, then refines Skill definitions without any model-weight retraining, while a Swarm Skills Hub allows users to search, install, remix, and publish reusable capability assets across the community. JiuwenSwarm integrates with a broad ecosystem of LLM providers — including DeepSeek, OpenAI, DashScope, SiliconFlow, OpenRouter, Huawei Cloud MaaS, and local models — and supports access via web UI, terminal (TUI), and popular messaging platforms such as Feishu, DingTalk, WeCom, WeChat, Telegram, Discord, Slack, and WhatsApp. Security is a first-class concern, with per-tool approval gates, file access whitelists, and sensitive operation interception built in. The project is currently in active beta (v0.2.4.beta3 as of August 2026), with rapid iteration covering cold-start latency reduction, multimodal Skill-Omni capabilities, and enhanced cluster collaboration. Its cross-platform desktop installer (Windows, macOS, HarmonyOS), pip package (`workswarm`), and rich documentation make it notably accessible, positioning it as a compelling trending entry in the agentic AI
AgentsToolsAppsmultimodalworkflow-automationsecurity
★ 7,458 total+1,442 this week
#78
The **Academic Research Skills (ARS)** repository by Imbad0202 is a comprehensive plugin suite designed for **Claude Code**, Anthropic's AI coding assistant, that supports the full academic research pipeline — from initial planning and literature review through writing, citation management, integrity checking, and final publication-ready output. The project is currently at version **v3.23.1**, carries a DOI via Zenodo, and is licensed under CC BY-NC 4.0, signaling both academic legitimacy and active versioning maturity. It supports installation in under 30 seconds via a plugin marketplace command and is compatible with Claude Code CLI, VS Code, and JetBrains environments running v3.7.0 or later.
The core philosophy of ARS is **human-in-the-loop augmentation**, explicitly rejecting full automation. The tool positions AI as a "copilot, not the pilot," handling grunt work like reference hunting, citation formatting, data verification, and logical consistency checking, while requiring human confirmation at every pipeline stage. This design stance is directly motivated by a growing body of empirical and survey literature on AI research failure modes. The project cites **Lu et al. (2026, Nature)** on *The AI Scientist* — the first fully autonomous AI system to publish through blind peer review — whose limitations section catalogs hallucinated results, methodology fabrication, citation hallucinations, and frame-lock as endemic risks of full automation. ARS's architecture responds with Stage 2.5 and Stage 4.5 integrity gates running a 7-mode blocking checklist.
Citation integrity is a major technical focus. **Zhao et al. (2026)** audited 111 million references across 2.5 million papers on arXiv, bioRxiv, SSRN, and PMC, estimating 146,932 hallucinated citations for 2025 alone, with an inflection point in mid-2024. ARS responded across multiple versions: v3.7.1 added trust-chain frontmatter for source provenance; v3.7.3 added three-layer citation locator anchors; and v3.8 introduced an opt-in audit pass (`ARS_CLAIM_AUDIT=1`) that fetches cited sources against anchors and judges claim support. Five new HIGH-WARN classes — including claim-not-supported, fabricated-reference, and anchorless — gate-refuse output through a formatter terminal hard gate. A calibration runner ships with a 25-tuple synthetic gold set and FNR/FPR acceptance thresholds of under 0.15 and 0.10 respectively.
The project's design rationale is further anchored by **Ren et al. (2026)**, a survey of self-improvement in agentic systems, which concludes that discovery agents cannot reliably verify novelty, correctness, or reproducibility, and that human auditing remains a practical safeguard. ARS explicitly cites EURISKO's historical dependence on human evaluation signals as a persistent lesson for modern agentic systems. **Gartenberg et al. (2026, Organization Science)** provides a journal-side anchor: an AI Task Force analysis of 6,957 manuscripts and 10,389 reviews found that heavily AI-written submissions read worse on readability indices and were desk-rejected more often, with editors warning of a "more rather than better" equilibrium. ARS cites this as rationale for recording volume as a non-goal and for implementing a Collaboration Depth Observer and claim-strength ladder.
**Wang, Li et al. (2026)** supply a fifth anchor through a survey of 230 sources on the AI paper-review arms race, treating research production and peer review as a coupled system. Their finding — that AI-assisted teams in a PNAS randomized study (Brodeur et al., 2026) reproduced 91% of results versus 37% for AI-led teams — reinforces ARS's commitment to human-led verification at every checkpoint. ARS also draws inspiration from **PaperOrchestra (Song et al., 2026, Google)** for features including Semantic Scholar API verification, anti-leakage protocol, VLM figure verification, and revision-trajectory tracking.
Key features include a Socratic dialogue planner (`/ars-plan`), literature review generation (`/ars-lit-review`), Style Calibration that learns a user's voice from past work, Writing Quality Check to catch machine-generated prose patterns, cross-model verification via `ARS_CROSS_MODEL`, and output in Markdown, DOCX (via Pandoc), and APA 7.0 PDF (via tectonic). The full architecture is documented in `docs/ARCHITECTURE.md`, with a stage-by-stage matrix, skill dependency graph, and quality gate descriptions. The project is multilingual in documentation, offering READMEs in Simplified
ToolsAppsAgentsworkflow-automationsynthetic-data
★ 52,823 total+1,433 this week
#79
Geo-sleuth is an open-source agent skill that determines the precise geographic location where a photo was taken, even when the image contains no GPS metadata, readable text, license plates, or recognizable landmarks. The project is authored by Oldcircle and hosted on GitHub, and it operates as a standard Agent Skill — meaning it consists of a `SKILL.md` specification file plus a collection of plain Python scripts that any compatible AI coding agent can read and execute. The skill is compatible with Claude Code, OpenAI Codex, Cursor, Gemini CLI, OpenCode, and GitHub Copilot, as well as any other agent that reads `SKILL.md` and can run shell commands. Installation is straightforward via `npx skills add Oldcircle/geo-sleuth`, after which the user simply hands the agent a photo and says "find where this photo was taken."
The core philosophy of geo-sleuth is geometry over guesswork. Rather than relying on visual fame or population heuristics, the skill uses OpenStreetMap geometry, digital elevation data, satellite imagery tiles, and street-view data to conduct a structured, evidence-driven search. Every conclusion the agent reaches must be traceable to a specific script that ran and a specific file it produced during the session — population and fame are explicitly excluded as evidence. The workflow is divided between approximately twenty single-purpose Python scripts that search, score, and sort candidates, while the language model only selects among the top few results, keeping the model's role as a judge rather than a guesser.
Outputs always include coordinates with an explicit error radius, the camera heading, a satellite evidence image, and a graded confidence level, making results auditable and reproducible. The README documents three detailed case studies that demonstrate the skill's capabilities on photos with no GPS data. In the first case — a rice paddy and viaduct in Qingyuan, Guangdong, China — the skill narrowed 27,335 OpenStreetMap railway bridge segments down to a single camera position accurate to within ±2 meters, using catenary mast identification, pier spacing as a geometric ruler, skyline ridge-line matching against elevation data, and bearing triangulation from 17 individual piers. The process took roughly 72 minutes end to end.
The second case involved a desert skyline in Da Qaidam, Qinghai, China, where the only man-made objects were power pylons. The skill queried every power line across four provinces — Xinjiang, Gansu, Ningxia, and Qinghai — using `osm.py` and `terrain.py`, scanned 1,537 candidate sites, and ultimately resolved a 1-degree phone tilt that was causing the skyline fit to stall, eventually locating the camera to within 100 meters of a specific sand dune. The third case placed a flowering cherry tree on a Vancouver, Canada street to within 3 meters, using municipal street-tree open data, shadow analysis, and street-view confirmation.
Each case includes a detailed reproduction guide listing the input image, any hints provided, key parameters, and checkpoints at each pipeline stage so that users can identify exactly where a different model or different decisions might diverge from the documented run. The README is careful to note that each case reflects one run by one specific model, and that different models may reach different results. The first case was solved by Claude Opus 5.0. The project requires Python 3.10 or higher and provides a `doctor.py` diagnostic script to verify that all dependencies and environment checks pass on first use. The repository is MIT-licensed, welcomes pull requests, and includes a Simplified Chinese translation of the README. Geo-sleuth is notable for its rigorous, transparent methodology, its cross-agent compatibility via the emerging Agent Skill standard, and its demonstration that sub-10-meter geolocation is achievable from a single image using only open data sources and geometric reasoning — without any proprietary geolocation APIs or training on location-labeled image datasets. Its trend relev
ToolsAppsAgentsvisionmultimodalcoding
★ 3,380 total+1,408 this week
#80
Monid is an open-source connector layer described as "OpenRouter for agent tools" — a unified aggregation platform giving AI agents access to 2,000+ tools across 72+ providers through a single base URL and API key. Providers span web search and scraping, people and company enrichment, social platforms, reviews, market data, and media generation. The core innovation is a declarative connector format: each provider and endpoint is defined in TypeScript using `defineProvider` and `defineEndpoint`, with Zod schemas for inputs, making connectors writable by coding agents themselves. A `discover` verb ranks the entire catalog per call by job fit, returning price, live health, and latency percentiles, so the best endpoint is chosen dynamically rather than hardcoded. Usage billing is metered per call and settled on the raw wire response before output mapping, meaning vendor errors and unresolved lookups cost nothing. The engine pipeline is identical across local, CI (fixture-replay, no network), and hosted execution, with credentials injected inside the transport layer. The repo is structured around connectors, engine, compiler, and shared contract modules, and runs on Deno 2.x. Maturity appears early but deliberate, with 188 replay tests, a hand-reviewed PR contribution process, and an Apify scaffolding tool. It is notable for making multi-provider AI agent tool access composable, cost-transparent, and agent-authorable — a compelling infrastructure play in the rapidly growing AI-agent ecosystem.
ToolsAgentsMCPworkflow-automationcoding
★ 5,130 total+1,403 this week
#81
T3 Code is an open-source "agent harness control surface" built by Ping.gg that lets developers control AI coding agents running on their local machine from a best-in-class mobile app (iOS and Android), a web app, and an Electron-based desktop app. It supports multiple AI coding agents — Claude Code, OpenAI Codex, Cursor, Grok Build, OpenCode, and Google Antigravity — requiring only that the user has those tools installed and authenticated. The project was inspired by existing tools like the Codex desktop app, Conductor, Claude Desktop, and Cursor Glass, but aims to be more performant, remote-ready, and truly open-source, with the explicit goal of giving users everything needed to fork and self-host. Installation is straightforward via a shell script, npx, or native package managers (winget, scoop, Homebrew, apt, AUR). The project is very early-stage, explicitly warns of bugs, and is mostly not accepting contributions yet. It is notable for unifying control of multiple competing AI agent ecosystems under one interface, making it highly relevant amid the current surge in agentic coding tools trending on GitHub.
AgentsAppsToolscodinglocal-firstworkflow-automation
★ 28,407 total+1,369 this week
#82
Compositor is a free, open-source image editor for macOS built by a single developer as a Photoshop alternative, targeting users who find Photoshop too expensive and GIMP too unfamiliar. It replicates a Photoshop-style compositing workflow with a rich feature set including layers, folders, blend modes, layer masks, clipping masks, and a full suite of adjustment layers and effects rendered on the GPU. It supports advanced tools like Camera Raw filter, Content-Aware Fill, Spot Healing Brush, Clone Stamp, gradient and shape tools, and editable text. File support spans JPEG, PNG, HEIC, TIFF, WebP, SVG, camera RAW, and Photoshop PSD/PSB formats, with live PSD conversion reporting. A notable feature is AI agent compatibility — projects use a `.comp` folder format that scripts and AI agents can read and write directly, with live updates. The app is macOS-only (Apple silicon, macOS 26+), installable via Homebrew or direct download, MIT-licensed, and maintained by one person. Its Photoshop-faithful shortcuts, non-destructive transforms, and GPU-accelerated effects make it a compelling trending open-source alternative.
AppsAgentsmultimodalvisionlocal-first
★ 17,401 total+1,364 this week
#83
**how-to-live-better** is a single-file HTML reader that renders the open-source Chinese book *高性价比人生指南* ("High Cost-Effectiveness Life Guide") — comprising 32 chapters and 528 evidence-ranked life advice entries — into a fully self-contained, searchable webpage. The project is a presentation layer only, not a fork of the upstream book maintained by eternity4719/HowToLiveBetter; it leaves content untouched while dramatically improving accessibility on mobile and offline environments. Key features include zero external dependencies (no CDN, no web fonts, no network fetches), per-card evidence grading (A/B/C levels), cost-effectiveness tiers, a prominent "plain language" highlight block, full-text keyword search with result highlighting, dark/light theme toggle, scroll-synced sidebar navigation, and print support. A Python build script regenerates the HTML from the upstream repo, and a GitHub Actions workflow auto-rebuilds daily at 06:00 Beijing time, committing only when content changes. The project is notable for its elegant offline-first philosophy and polished mobile UX applied to a rigorously evidence-cited self-improvement resource, making it a practical and shareable tool. Its trending appeal likely stems from the growing Chinese-language interest in evidence-based lifestyle optimization.
Appslocal-first
★ 12,578 total+1,356 this week
#84
OpenCodeReview is an AI-powered code review CLI tool originally developed as Alibaba Group's internal assistant, having served tens of thousands of developers and identified millions of defects over two years before being open-sourced. The tool 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 — going well beyond surface-level diff feedback by reading full file contents, searching the codebase, and inspecting related changed files for deeper context. A standout design philosophy is its hybrid "Deterministic Engineering × Agent" architecture: hard-coded engineering logic handles critical steps like precise file selection, smart file bundling, fine-grained rule matching, and external positioning/reflection modules, while the agent focuses on dynamic decision-making and context retrieval using scenario-tuned prompts and a purpose-built toolset distilled from large-scale production traces. Benchmarked against 50 popular open-source repositories, 200 real Pull Requests, 10 programming languages, and 1,505 annotated ground-truth issues validated by 80+ senior engineers, OpenCodeReview achieves significantly higher Precision and F1 than general-purpose agents like Claude Code using the same underlying model, while consuming only ~1/9 of the tokens. It supports delegation mode, where an AI coding agent performs the review itself with OpenCodeReview handling file selection and rule resolution — no LLM configuration required. The tool integrates with Claude Code, Codex, Cursor, Kimi Code, OpenCode, and QCA Forward, and is installable via npm, install script, or GitHub Release binary. It holds OpenSSF Gold badge status, indicating strong security and maturity practices, and is actively trending on Trendshift.
ToolsAgentsAppscodingsecurityworkflow-automation
★ 47,610 total+1,347 this week
#85
DBX is a lightweight, open-source universal database management client built with Rust, designed to support over 100 different databases within a remarkably compact 25 MB footprint. The project positions itself as a comprehensive, all-in-one database management solution that runs across multiple deployment modes: as a native desktop application, a Docker container, a command-line interface (CLI), and as an MCP (Model Context Protocol) Server. This multi-modal deployment flexibility makes it highly adaptable for individual developers, DevOps engineers, and data teams working across diverse infrastructure environments.
One of DBX's most prominent and trending features is its built-in AI assistant, which directly addresses the growing demand for AI-augmented developer tooling. The AI assistant is integrated natively into the client, enabling users to interact with their databases using natural language, generate queries, and streamline data exploration workflows without leaving the tool. The MCP Server capability further extends this AI integration, allowing DBX to serve as a backend for AI agents and LLM-powered workflows that need structured database access, making it particularly relevant in the current wave of agentic AI application development.
The breadth of database support is a defining characteristic of DBX. It covers virtually every major category of database technology: relational databases including MySQL, PostgreSQL, SQLite, SQL Server, Oracle, MariaDB, TiDB, CockroachDB, OceanBase, openGauss, GaussDB, KingbaseES, DM, and Amazon Redshift; analytical and columnar stores such as ClickHouse, DuckDB, Apache Doris, SelectDB, and StarRocks; NoSQL and document stores including MongoDB, Redis, Elasticsearch, Apache CouchDB, and Meilisearch; time-series databases like InfluxDB and TDengine; cloud-native databases such as Google Cloud Spanner; and generic JDBC connectivity for additional extensibility. This extraordinary breadth means DBX can serve as a single unified interface across heterogeneous data stacks, eliminating the need for multiple specialized tools.
The project is built with Rust, which explains its minimal binary size and strong performance characteristics. Achieving support for 100+ databases in just 25 MB is a notable engineering achievement that distinguishes DBX from heavier alternatives like DBeaver or TablePlus. The Rust foundation also implies memory safety, low resource consumption, and cross-platform reliability, all of which are increasingly valued in production tooling.
From a maturity and community standpoint, DBX shows strong signals of active growth and adoption. It has been featured on Trendshift, HelloGitHub, and Product Hunt, indicating organic discovery and community recognition across multiple platforms. The project maintains active community channels across QQ groups, WeChat groups, Feishu groups, and Discord, reflecting a broad user base spanning both Chinese-speaking and international developer communities. It also lists 1Panel as a partner, suggesting integration into broader open-source infrastructure ecosystems popular in China.
The combination of AI assistant integration, MCP Server support, extreme portability, and massive database compatibility makes DBX highly notable in the current trend landscape. It sits at the intersection of three major trends: the consolidation of developer tooling, the embedding of AI capabilities into everyday workflows, and the rise of agentic AI systems that require structured data access. The MCP Server feature in particular aligns DBX with the emerging standard for connecting LLMs to external tools and data sources, making it relevant not just as a database GUI but as infrastructure for AI-powered applications.
Overall, DBX appears to be a rapidly maturing, community-driven project that has found strong product-market fit by combining extreme lightweight design with comprehensive coverage and modern AI features, making it a compelling and trending choice for developers who manage complex, multi-database environments.
AppsMCPToolslocal-firstworkflow-automation
★ 27,172 total+1,303 this week
#86
ReelMimic is a local, AI-powered 2D animation tool that analyzes a reference video's style — editing rhythm, shot lengths, transitions, framing, colors, and camera moves — then generates an entirely new video in that style from a user-provided brief. It supports seven 2D drawing engines: vector/motion graphics, hand-painted watercolor, crayon picture book, pixel art, paper cut-out stop-motion, whiteboard doodle, and anime cel. The workflow is multi-agent: up to six AI agents work in parallel on different video segments, with separate reviewer agents validating each shot using before/after screenshots. Users approve a storyboard plan before production begins and can annotate the finished video by timecode. It runs locally via Claude Code or Codex CLI, requires Node.js 22.18+, Python 3.10+, FFmpeg, and Chrome, and supports optional social posting through Upload-Post. New styles are defined in plain Markdown files. The project is early-stage, primarily tested on Windows, with watercolor and crayon engines being the slowest. It's notable for combining multi-agent AI orchestration with structured creative control for 2D animation generation — a compelling intersection of agentic AI workflows and accessible video production tooling.
AgentsAppsmultimodalvideolocal-first
★ 3,634 total+1,269 this week
#87
Open SEO MCP Skills is a free, MIT-licensed SEO and GEO (Generative Engine Optimization) toolkit that connects Claude to real SEO data via the Model Context Protocol (MCP). Unlike typical "open source SEO tools" that wrap DataForSEO with markup fees, this project pulls rankings from actual Google Search Console, traffic from real GA4 data, and keyword volumes from Google Ads—eliminating estimates. It includes eight ready-made skills: site audits, keyword research, rank tracking, competitor gap analysis, backlink checks, AI visibility reporting, content briefs, and SEO-vs-ads overlap analysis. The AI visibility skill is particularly notable, tracking actual referral traffic from ChatGPT, Perplexity, Claude, and Gemini via GA4. Setup is minimal—three CLI commands or a manual connector URL in Claude settings. The project is early-stage but functional, positioning itself as the only SEO MCP server running on verified first-party data rather than scraped estimates. It's trending at the intersection of the MCP ecosystem boom and growing interest in AI-era SEO tooling, with no subscription cost and no per-call markup, making it notable for developers and SEO practitioners adopting Claude Code workflows.
MCPToolsAppsworkflow-automationbrowser-use
★ 6,069 total+1,238 this week
#88
Herdr is a terminal runtime designed specifically for coding agents, providing persistent background sessions that survive SSH disconnections, client closures, and machine restarts. Built as a single Rust binary (no Electron), it manages multiple local and remote machines in one unified window, with a combined agent list and independent reconnects. A standout feature is real-time pane status tracking — every terminal pane is marked as working, blocked, or idle, so users instantly know when an agent is stuck and needs input. Herdr is agent-native: agents can interact with it via a CLI and socket API to spawn panes, prompt each other, and coordinate on blocking states. It supports popular coding agents like Claude Code, Codex, Cursor, OpenCode, and Grok without wrapping or replacing them — it simply owns their terminals. The tool supports tmux-style keyboard shortcuts alongside full mouse interaction, and is extensible via a plugin marketplace. Installation is straightforward across macOS, Linux, and Windows. The project appears actively maintained with Homebrew availability, GitHub releases, and enterprise contact options, signaling growing maturity and commercial interest in the AI agent tooling space.
AgentsToolsAppscodingworkflow-automationlocal-first
★ 44,678 total+1,230 this week
#89
Octop is an open-source, self-hosted AI assistant platform developed by TencentCloud, designed for households, small teams, and individual developers who want a powerful multi-user, multi-agent AI environment without sacrificing data privacy. Rather than relying on external cloud services, Octop runs entirely on the user's own machine, consolidating a web dashboard, CLI, IM channel integrations, and cron automation into a single process launched via `octop run`, with all state stored under `~/.octop/` using SQLite by default or PostgreSQL optionally. The platform's core value proposition is that every conversation, workspace, and credential remains local, while still offering a rich, collaborative agent experience.
At the heart of Octop is a multi-agent architecture built on the Octop Harness stack, which composes several focused runtimes: Octop Harness handles agent runtime including model routing, tools, skills, and conversation checkpointing; Octop Gateway bridges multiple IM platforms into a unified processing pipeline; Octop Memory provides hierarchical recall with full-text search that travels with an agent's workspace; and Octop Browser enables CDP-based headless Chromium automation for web tasks. All surfaces — Web UI, IM channels, and cron — are routed through a single in-process HarnessProcessor, making the system restart-safe and stateless at the process level.
A standout feature is the expert system, where each user can maintain multiple "experts" — specialized agents with their own workspaces, providers, channels, MBTI persona templates (16 personality types plus a quiz), and cron schedules. An expert library and expert market allow configurations to be shared across users within the same deployment. The AgentTeams feature, currently in beta, enables a coordinator agent to autonomously schedule and orchestrate multiple expert agents for multi-step tasks. Cloud collaboration allows one Octop instance to link to another, enabling cross-instance expert browsing and chat while keeping history on the expert's side.
Octop supports an impressive breadth of communication channels, including Feishu, DingTalk, QQ, WeChat, Telegram, Discord, and WeCom, as well as programmatic access via HTTP, SSE, and WebSocket APIs. The Connector ecosystem extends capabilities through OAuth and MCP gateways, with native support for Tencent suite products like Tencent Docs and Tencent Meeting. A knowledge base feature enables RAG over private documents, shareable within a deployment. Plugins can be installed and managed via the dashboard or CLI.
The ACP (Agent Client Protocol) integration is bidirectional: Octop can serve as an ACP server for external IDE tools like Zed and OpenCode, or it can delegate outbound coding tasks to runners such as OpenCode, CodeBuddy, Claude Code, and Codex. Additional surfaces include a remote desktop feature for live screen control across Linux, Windows, and macOS, a Browser AI+ mode for web automation, a Terminal AI+ mode for AI-assisted shell interaction, and native desktop clients for Windows, macOS, Linux, and FnOS NAS packages.
The technology stack is Python 3.12+, FastAPI with uvicorn, a React 18 + TypeScript + Vite + Ant Design frontend, APScheduler for scheduling, and tooling including hatchling, ruff, mypy, and pytest. The project is at version 1.0.2, MIT-licensed, and listed on Trendshift, indicating active community traction
AgentsAppsToolslocal-firstbrowser-usemultimodal
★ 9,945 total+1,217 this week
#90
**i-have-adhd** is a coding assistant skill/plugin (designed for Claude Code) that reformats AI responses to be ADHD-friendly — leading with the direct action, numbering steps, and eliminating filler phrases like "Hope this helps!" or "Great question!" The project enforces 10 concise communication rules: action-first answers, numbered multi-step tasks, concrete next steps, suppressed tangents, restated context each turn, specific time estimates, visible wins, matter-of-fact error handling, capped lists (5 items max), and zero preamble or closers. Installation is unusually frictionless — users paste a single prompt into their CLI. The plugin is customizable via forking and editing a `SKILL.md` file. It is multilingual, with READMEs in 8 languages, suggesting broad international appeal. The project is early-stage but notably polished, and its trending appeal likely stems from growing neurodivergent-inclusive tooling interest and frustration with verbose LLM outputs. It is loosely inspired by the book *The Adult ADHD Tool Kit* by Ramsay and Rostain, adapted for LLM interaction patterns rather than human productivity habits.
ToolsAppscodingworkflow-automation
★ 57,728 total+1,209 this week
#91
Lemo-Opuscar is an open-source creative toolkit by Lemomo (lemomo-ai) that provides 51 distinct film styles, each accompanied by a fully code-generated short film, enabling users to direct AI-produced films by supplying their own story or topic. The project is explicitly built around Claude Opus 5.5 as its directing agent, with the README warning that other models may not reliably reproduce the styles. Every film produced through the system is generated entirely in code — no video generation tools or stock footage are used — with visuals rendered frame-by-frame via canvas and WebGL, original music sourced from free sample libraries, and narration produced through text-to-speech. The project is structured around three core guide files: DIRECTOR.md (covering story, rhythm, camera, and performance), TECHNIQUE.md (covering rendering, voice, and mixing), and per-style STYLE.md files that define the visual and sonic character of each style while leaving the story to the user.
The 51 styles span a wide creative range, organized into categories including Evidence Films, Hand-drawn and Painting, East Asian Traditions, and others. The Evidence Films category — added in an October 2026 update — is particularly notable, comprising 8 styles that ground every number and visual in real, sourced or measured data, covering subjects like LiDAR terrain surveys, satellite imagery, data physicalization, and archival light tables. A flagship showcase called OPUSCAR 98 demonstrates the system's ambition: a 6-minute 31-second film walking through all 98 Academy Award Best Picture winners, each rendered in a matching style, with 77 2D, 4 2.5D, and 17 3D styles represented, all written entirely by Claude Opus 5.5.
Usage is offered via two paths: installing a Claude plugin from the marketplace with a simple terminal command, or cloning the repository directly. Once set up, users simply describe their desired film in natural language, naming a style and topic. The agent asks a small number of clarifying questions upfront — about user-supplied assets and whether a storyboard preview is wanted — then autonomously produces the complete film, typically in 30 to 60 minutes. Prerequisites include Node 20+, ffmpeg, and Python 3.11+. Default output is 1920×1080 at 24 fps.
The project is notable for several reasons. It represents a sophisticated, production-oriented application of agent-driven creative coding, treating an LLM as a full film director rather than a simple code generator. The tight coupling to Claude Opus 5.5 and the explicit plugin marketplace integration signal a maturing ecosystem around Claude Code as a platform for agentic workflows. The bilingual README (English and Simplified Chinese) and the breadth of culturally diverse styles — from Chinese ink wash and shadow puppetry to ukiyo-e and impasto oil painting — suggest an intentionally global audience. The Evidence Films addition, with its emphasis on verifiable, sourced data embedded directly into generated visuals, points toward a trend of AI-generated content that prioritizes factual grounding. Licensed
ToolsAppsAgentsmultimodalvideocoding
★ 3,140 total+1,199 this week
#92
ARTEMIS is an open-source AI agent framework developed by Google that enables AI assistants and automated test suites to control real Android devices using natural language instructions, effectively letting software interact with phones the way a human would. The project's core value proposition is bridging the gap between high-level AI reasoning and low-level mobile UI interaction, making it highly relevant to the surging interest in AI agents capable of operating real-world software environments. At its heart, ARTEMIS uses a multimodal observe-and-act loop that leverages element indices for UI targeting, falling back to coordinate-based and visual locating strategies for custom or non-standard interfaces — a "Dynamic-First, Coordinate-Fallback" pattern that makes it robust across diverse apps. It supports multiple frontier vision-language models including Gemini, Claude, GPT-4o, and Qwen-VL, making it model-agnostic and broadly accessible. A standout feature is its native Model Context Protocol (MCP) server, which allows AI coding IDEs such as Antigravity, Claude Code, Cursor, Windsurf, Codex, and VS Code to directly drive connected Android devices, collect Logcat diagnostics, and capture screenshots — turning any developer's phone into a live test instrument controllable from within their IDE chat. ARTEMIS ships with two execution profiles: "Flash," a fast reactive loop completing steps in roughly 3–5 seconds, and "Pro," a deeper reasoning mode suited for long-running exploratory or stability tests. The framework achieved over 99% task completion on Google Research's AndroidWorld benchmark, a suite of 100+ multi-step tasks, representing state-of-the-art performance. It exposes four usage modes: a web visual console with live screen mirroring and replay, the MCP server for IDE integration, a developer CLI for direct terminal execution, and a Python SDK for embedding into pytest or CI/CD pipelines with Pydantic-typed outputs. Setup is streamlined via one-click shell scripts that auto-install ADB, scrcpy, FFmpeg, and Python dependencies. The project is licensed under Apache 2.0, requires Python 3.12+, and has an active Discord community, signaling a growing ecosystem. Its combination of benchmark-leading performance, broad model support, MCP-native IDE integration, and Google backing makes it a notably trending repository in the AI agents space.
AgentsMCPToolsmultimodalbrowser-useworkflow-automation
★ 12,568 total+1,192 this week
#93
pstack-claude is a port of Lauren Tan's opinionated Cursor agent skill stack, adapted for Claude Code, Codex, Pi, GitHub Copilot, and other AI agent harnesses. Its central feature is `poteto-mode`, a routing layer that automatically selects the correct workflow for a given task — covering bugs, features, refactoring, performance, prototyping, PR maintenance, and longer projects. The stack emphasizes concise, simple, verified code, delegating work through sub-agents like `architect`, `arena`, and `swarm`, then validating with `interrogate`, tests, and measurements. Installation is supported across multiple CLI tools and shared skill directories (`~/.agents/skills/`), with per-harness configuration notes and a `setup-pstack` command for tuning model defaults and reasoning effort per role. For concurrency bugs and formal invariants, it integrates with a companion plugin, `agent-formal-verify`, adding TLA+ and Lean proof support. The project tracks upstream pstack and carries named policy forks declared in `tools/forks.json`. It has no telemetry or server component. Its cross-harness breadth and structured multi-agent orchestration make it notable as a practical, privacy-respecting productivity layer for AI-assisted development.
ToolsAgentsAppscodingworkflow-automationlocal-first
★ 2,998 total+1,171 this week
#94
The `marketingskills` repository by Corey Haines is a curated collection of AI agent skills — structured markdown files that give AI coding agents specialized marketing knowledge and workflows — designed for technical marketers and founders who want to automate or augment marketing tasks using AI agents. The project covers a remarkably broad surface area of modern digital marketing, including conversion rate optimization (CRO), SEO, AI-SEO, copywriting, cold email, paid ads, analytics, attribution, A/B testing, app store optimization (ASO), churn prevention, community marketing, influencer marketing, pricing, paywalls, lead magnets, free tools, product launches, go-to-market strategy, sales enablement, revenue operations, competitor research, directory submissions, email sequences, social media, video, SMS, image generation, co-marketing, events, and more — totaling over 40 distinct skills. The architecture is notably thoughtful: a central `product-marketing` skill acts as a shared foundation that every other skill reads first to understand product context, audience, and positioning before executing any task, and skills cross-reference each other in meaningful clusters (e.g., copywriting ↔ CRO ↔ A/B testing; RevOps ↔ sales enablement ↔ cold email; SEO audit ↔ schema ↔ AI-SEO). The library is compatible with major AI coding agent platforms including Claude Code, OpenAI Codex, Cursor, and Windsurf, and conforms to the Agent Skills spec at agentskills.io. It is MIT-licensed and free to use, with a transparent partner/sponsorship model where vetted tool integrations — currently Converly (server-side conversion tracking), Ploy (AI website and growth platform), and AIsa (aggregated SEO, search, and social data API) — fund ongoing development without influencing core skill recommendations. The project is actively maintained and open to community contributions via pull requests. It connects to a broader ecosystem built by Haines, including the Conversion Factory agency, the Swipe Files marketing newsletter, an AI Marketing Training course, a Coding for Marketers companion guide for non-technical users, and Magister, an autonomous AI marketing agent that uses these skills as its CMO-layer intelligence. The repository appears early-stage but architecturally mature, with a well-designed dependency graph, tooling for partner sync automation, and a guided setup workflow for connecting real marketing accounts. Its trending appeal likely stems from the intersection of the booming AI agent ecosystem and the practical, immediately deployable nature of the skills for a large audience of marketers seeking to leverage LLM-powered coding agents without deep engineering backgrounds.
ToolsAppsAgentsworkflow-automationcoding
★ 55,415 total+1,163 this week
#95NEWPartial week
new-term-radar is an open-source daily intelligence tool that detects emerging AI names — new models, products, tools, and repositories — at the earliest possible moment, before they appear in conventional keyword research platforms like Google Trends or SEO tools. The core insight driving the project is that a new AI term leaves a traceable trail across multiple public signals in a predictable sequence: first mentioned on X or appearing on Hugging Face's trending list, then a GitHub repo breaks out, then directories and competitors add pages, then search impressions begin, and only finally does Google Trends register the curve. Most keyword tools read only that last step; this radar reads steps one through four daily and uses step five purely for self-validation. The motivating example is the Strata repository by Niko1221, which was created on 2026-09-24 and accumulated 7,700 stars within nine days, with people already searching "niko strata" from September 26th while no keyword tool had listed it yet — a single repo gaining 800 stars per day being the entire, publicly available signal.
The system ingests eight distinct signals: X posts from a curated account list (detecting first-time name usage within 60 days), Hugging Face trending models and Spaces, GitHub breakout repositories (under 14 days old, averaging 200+ stars per day or +400 since yesterday), sitemap analysis across AI tool directories like Toolify, Futurepedia, and Aixploria, newly registered and indexed domains already ranking for 20+ keywords, Reddit "asks" (requests for AI tools phrased in twelve different ways), verified revenue data from TrustMRR for fast-growing products, and Google Search Console impressions for fresh queries on the user's own site. Each signal has different cost and dependency profiles, with GitHub and Hugging Face being free and X reads costing roughly $0.003 per account per run. A full monthly run with 35 X accounts and keyword tables for five names per day costs approximately $15.
A central feature is the keyword table, which pairs each detected name with the generic search terms representing the underlying job people are trying to accomplish. For example, "SynthID Detector" maps to "ai image detector" — a durable, unbranded term with real ongoing search volume. The table includes estimated daily searches, trend shape, peak timing, week-over-week momentum, and a page-one difficulty assessment. Page-one analysis checks Google's first-page results, rates each competing site, calculates keyword difficulty, and identifies whether the competitive landscape is open, crowded, or mixed. Optional GoAnyAPI integration adds Google Trends related queries, country-level (US) trend series, advertiser presence, and pages recently built around the term. Decisions are classified as prioritize, watch, or skip based on recency of rise, current momentum, and daily search volume thresholds.
Each name is read twice — on the day it appears and three days later — because announcement-day posts are mostly announcements with no usage signal yet. A 14-day review then checks each lead against Google Trends to measure hit rate and how many days ahead of mainstream tools the radar detected it. Special markers flag content type (video, voice, image) and highlight viral posts describing manual workflows that could become one-click tools. The project is in an early but actively developed state (versions 0.3 and 0.4 recently added revenue signals, Reddit asks, page-one checks, and formatting improvements), with honest c
ToolsRetrievalMCPworkflow-automationsynthetic-data
★ 1,112 total+1,127 this week
#96
Horizon is an AI-powered personal news aggregator and briefing generator created by GitHub user Thysrael. Its core purpose is to collect content from a wide variety of sources — including RSS feeds, Hacker News, Reddit, Telegram, X (formerly Twitter), GitHub, and financial news outlets — and distill them into ranked, context-rich daily briefings delivered in both English and Chinese. The project positions itself as a personalized "news radar," designed to save readers from information overload by filtering, deduplicating, and prioritizing stories based on user-defined editorial rules called **profiles**.
The profile system is one of Horizon's most distinctive features. A profile is a reusable bundle of editorial logic that defines what content belongs, how items should be scored and filtered, and what kind of output to generate — summaries, background context, practical takeaways, or community discussion angles. Built-in profiles include `tech-news` for technology events, `tech-blog` for engineering deep dives, and `ai-creator` for AI-related content creation material. Users can assign profiles to individual sources or let an AI model choose automatically, and profiles can be customized largely without writing Python code.
The pipeline architecture is clearly structured: sources feed into a profile-driven processing stage that handles analysis, scoring, filtering, and deduplication, followed by an enrichment step that can incorporate web-researched background and community discussion. The final output is grouped by profile and can be published as Markdown, deployed to GitHub Pages, or delivered via email, webhook, Feishu notification, or WeChat. A CLI exposes the full pipeline, and an AI assistant can invoke individual pipeline stages through an MCP (Model Context Protocol) interface.
Horizon supports a broad range of LLM backends for its AI processing, including Claude, GPT, Gemini, DeepSeek, Doubao, MiniMax, OpenClaw, and Ollama, making it flexible across both cloud and local inference setups. The project uses `uv` as its Python tooling layer and is licensed under MIT. It actively welcomes pull requests and new source contributions.
In terms of maturity and traction, Horizon is actively maintained with regular monthly commits and has earned both a daily and weekly trending badge on Trendshift, as well as a featured listing on HelloGitHub — signals of meaningful and growing community interest. A live demo is publicly accessible, and a configuration guide and community QQ group are provided for onboarding. The project's multilingual README (English, Simplified Chinese, Japanese) and multi-platform delivery options suggest it is targeting a broad, international audience. Its combination of LLM-agnostic design, profile-based editorial customization, multi-source aggregation, and multi-channel delivery makes it a notably well-rounded and practically oriented open-source tool in the AI-assisted information curation space, particularly relevant as interest in personal AI agents and automated knowledge workflows continues to grow.
AppsAgentsMCPworkflow-automationmultimodal
★ 10,753 total+1,114 this week
#97
The `anthropics/knowledge-work-plugins` repository is an open-source collection of 11 role-specific plugins that extend Claude's capabilities within Claude Cowork and Claude Code environments. Each plugin bundles domain expertise, slash commands, connectors, and sub-agents tailored to a specific job function — covering sales, marketing, legal, finance, data analysis, product management, customer support, productivity, enterprise search, bio-research, and plugin management itself. Plugins connect Claude to real-world tools like Slack, HubSpot, Snowflake, Jira, Notion, and Figma via MCP servers, enabling finished, professional work output rather than just conversational assistance. The architecture is entirely file-based (markdown and JSON), requiring no code or infrastructure, making customization accessible to non-engineers. Teams can swap connectors, inject company-specific terminology, and modify workflows to make Claude behave as if purpose-built for their organization. The project is early-stage but notable for its breadth of integrations, its no-code extensibility model, and its positioning as a marketplace-style ecosystem for enterprise AI workflows. Its GitHub trending status likely reflects growing enterprise interest in structured, role-aware AI agents built on top of frontier models.
MCPAgentsToolsworkflow-automation
★ 30,257 total+1,105 this week
#98
DSH Desktop is an open-source, community-maintained native desktop client for Windows and macOS built on top of DeepSeek Harness, a local AI agent framework. The project wraps a pinned upstream version of DeepSeek Harness — including its local Web UI, Host service, and plugin system — into a native desktop application, adding window management, system tray integration, auto-update, terminal support, and work-profile configuration. Crucially, the desktop shell itself is implemented as a DSH plugin, embodying the project's core philosophy: "everything is a plugin," including the desktop wrapper. This means the desktop capabilities can be composed, replaced, and extended using the same plugin mechanism as any other DSH plugin, powered by the Cordis plugin architecture. A built-in plugin marketplace (DSH Community Market) enables plugin discovery, installation, and management, with an open schema allowing any data source to participate. Mobile remote control via iOS and Android is built in from version 2.0.9 onward, allowing users to monitor and interact with desktop agents from their phones. Installation is zero-dependency — no Node.js or CLI required — with NSIS installers for Windows x64 and DMG for macOS Universal. The project is explicitly independent of DeepSeek AI (深度求索), with no official affiliation, endorsement, or upstream team involvement. It is actively sponsored by Alibaba Cloud (无影云电脑), UCloud (AstraFlow), 88API, and 立秋 API, signaling commercial interest and ecosystem momentum. A growing third-party plugin ecosystem — including UI skins, TUI clients, context dashboards, remote control plugins, and sidebar tools — underscores its rising community traction and notable trending potential in the AI agent tooling space.
AgentsAppsMCPlocal-firston-deviceworkflow-automation
★ 31,574 total+1,092 this week
#99
**video-shotcraft** is an agent-driven promotional video creation skill for AI coding agents (Claude Code and Codex) that transforms product screenshots and copy into polished, fully editable MP4 films — without relying on generative video models. Instead, every frame is rendered programmatically using Remotion (a React-based video framework), ensuring sharp, on-brand, and fully editable output. The workflow is end-to-end: the agent captures real product pages, selects motion recipes from a curated shot library, storyboards the film, animates it, syncs cuts to a beat, adds sound design, performs frame-level QA, and delivers a finished 1920×1080 MP4 alongside the full Remotion source project. The shot library is a standout feature, comprising 124 recipe cards across 10 categories (Opening & Brand, Camera, Transitions, Typography, UI Entrance, Interaction, Data, Light & Emphasis, Rhythm, and Outro) totaling 150 named shots — all browsable in a live Gallery. Each shot card is a documented Markdown file with a corresponding Remotion demo implementation. After delivery, the skill opens **Motion Workbench**, a CapCut-style browser editor where users can edit copy, retime clips, swap shots from the library, and re-export — with frame-identical preview and render. The project also supports **JianYing (CapCut CN) export**, producing editable drafts with per-shot clips, caption tracks, and separate audio tracks, verified on JianYing Pro 11.2 for macOS. Optional social publishing via Upload-Post supports TikTok, Instagram, YouTube, LinkedIn, and X. A sibling project, **video-talkcraft**, handles narration-driven videos with voiceover-locked motion beats. The repo ships with 149 SFX files, 5 BGM tracks, reusable Remotion components (2.5D camera, captions, digit rolls), and page-capture scripts. Installation is straightforward via a natural-language agent prompt, the `skills` CLI, or manual symlinking. The project is actively maintained with a 2026-10 shot library refresh, is trending on Trendshift, and is sponsored by APIMart, PackyCode, and AWS — signaling meaningful community traction and commercial interest. Its agent-native design, code-first rendering philosophy, and rich shot library make it a notable
ToolsAppsvideomultimodalworkflow-automation
★ 12,424 total+1,087 this week
#100
Learn Harness Engineering is a structured, project-based educational course hosted by walkinglabs on GitHub, focused on teaching developers how to build reliable environments around AI coding agents. The core thesis of the course is that model capability alone is insufficient for real-world engineering tasks — what matters is the harness: the surrounding infrastructure of instructions, tools, environment management, state tracking, verification pipelines, and lifecycle controls that make an AI agent behave predictably and produce working results. The course synthesizes cutting-edge industry research from OpenAI and Anthropic, drawing directly on published engineering blogs about harness design for long-running agents and agent-first development workflows.
The course is organized into 14 lectures and 8 hands-on projects, and is available in 15 languages including English, Simplified Chinese, Traditional Chinese, Japanese, Korean, Spanish, French, Russian, German, Arabic, Vietnamese, Uzbek, Turkish, Brazilian Portuguese, and Ukrainian — reflecting a deliberate effort to reach a global developer audience. This multilingual breadth is a notable signal of the project's ambition and community investment.
The conceptual framework at the heart of the course breaks a harness into five subsystems: instructions, tools, environment, state, and feedback. These five components are treated as universal primitives that apply across different AI coding products and workflows. A key pedagogical move in the course is applying this framework to reverse-engineer how real frontier products build their own harnesses, covered in a dedicated section called Frontier Harness Design Breakdowns. This section analyzes four production systems: Pi, which uses a minimal kernel with programmable expansion and context engineering; Claude Code, which employs a four-layer memory architecture, five-level compaction, hooks, and sub-agent isolation; Codex, which treats the repository as the source of truth and uses AGENTS.md as a directory page with worktree isolation; and DeepSeek, which is built around an "everything is a plugin" philosophy with capability seams and an event pipeline.
The most recently added content, dated August 2026, introduces Graph Engineering as a natural evolution beyond single-loop agent architectures. Lecture 14 explains why a single agent loop eventually grows into a graph, covering the four stacked layers of prompt, context, loop, and graph, and the four structural components of a graph: nodes, edges, shared state, and routing. It also addresses why in-loop checkpoints fail at scale due to Goodhart's Law, upward blindness, and conflict, and introduces a framework-agnostic six-step process for building a first graph. Project 08 operationalizes this with three progressive experiments: drawing a maker-checker loop as an explicit graph, adding parallel fan-out and fan-in nodes, and adding conditional rollback and human-approval nodes.
The July 2026 update introduced Loop Engineering, covered in Lecture 13, which transitions learners from manual prompting to automated agent loops using six primitives: automations, worktrees, skills, connectors, sub-agents, and external state. The generator/evaluator split is a central pattern here, and Project 07 walks through building goal loops, timer loops, and maker-checker loops with drop-in code templates. The course uses a compelling real-world experiment from Anthropic as motivating evidence: the same model (Claude Opus 4.5) given the same prompt produced a non-functional result without a harness after spending $9 in 20 minutes, but with a full planner-generator-evaluator harness, it spent $200 over 6 hours and produced a playable game. OpenAI reported analogous qualitative reliability improvements with Codex in well-harnessed repositories.
The repository also includes a skills directory with a harness-creator skill that can scaffold a production-grade harness — including AGENTS.md, feature lists, initialization scripts, and verification workflows — for a new project in minutes. A PDF build pipeline is included, with npm scripts to generate coursebooks locally and a GitHub Actions workflow to publish them as GitHub Releases. The project is MIT-licensed and supported by a Discord community. It references a companion repository, Awesome Harness Engineering, also maintained by walkinglabs. Overall, this project is notable for its synthesis of frontier AI engineering research into a structured, multilingual, project-driven curriculum that addresses one of the most practically important and underserved areas in the current AI development landscape: making agents reliably useful in real codebases.
AgentsToolsAppscodingworkflow-automation
★ 20,802 total+1,086 this week
#101
Odysseus is a self-hosted AI workspace that consolidates chat, agents, deep research, document editing, email, notes, tasks, and calendar into a single deployable platform. It supports local and API-based language models with tools like MCP, shell access, skills, and memory, alongside a "Cookbook" feature for hardware-aware model recommendations and downloads. A "Compare" mode enables blind side-by-side model testing, while Deep Research performs multi-step web research with source reading and report generation. Deployment is Docker-based with multi-arch images published to GitHub Container Registry, supporting Portainer stacks and production pinning via immutable SHA-tagged images. The project is actively developed on a `dev` branch with a curated `main` branch, licensed under AGPL-3.0, and has gained notable traction on Trendshift's monthly rankings, suggesting strong and growing community interest. Security-conscious design keeps auth enabled by default and warns against exposing internal ports publicly. Its breadth of integrated productivity and AI features positions it as a compelling open-source alternative to fragmented SaaS AI tooling.
AppsAgentsMCPlocal-firstmultimodalworkflow-automation
★ 93,928 total+1,043 this week
#102
Laya is a multilingual, non-autoregressive "System 1" decision engine that makes typed decisions over 100+ languages in a single forward pass, reported at roughly 33 ms per question (7.2 ms/question when batched) on an NVIDIA T4. Rather than generating text, Laya evaluates typed questions—of types `choice`, `score`, and `noul`—against any state such as plain text, email, support tickets, or JSON documents, which means there is nothing to parse and nothing to hallucinate. The models are trained with reinforcement learning against strictly proper scoring rules, an approach the project calls RLCD, and a built-in Router selects the appropriate checkpoint per request based on detected script and language. The project ships three checkpoints: `laya` (ModernBERT-large encoder, 421M params, 512 context) for English; `laya-multilingual` (mmBERT-base encoder, 322M params, 1024 context extendable up to 8,192 tokens, roughly 2x faster) for 100+ languages; and `laya-typed-decisions` (ModernBERT-large, 421M, 1024 context) specialized for typed-decision workflows. The Router automatically routes non-English text to the multilingual checkpoint, while English requests go to the English checkpoint; users can also force a checkpoint via the `model` argument. Installation is straightforward via `pip install laya` (or uv), requiring Python 3.10 or newer, with numerous optional extras for serving (HTTP server), MCP, LangChain/LangGraph, LlamaIndex, CrewAI, Agno, ONNX Runtime, a TileLang GPU fast path, and pydantic-based structured decisions. A TypeScript/Node.js/browser SDK (`laya-ts`) is published separately via npm.
Calibration is a notable part of Laya's design and recent development, directly relevant to the query. The fine-tuning loop explicitly includes a step to "calibrate temperatures" alongside building the dataset, training with RLCD, evaluating, and exporting, so that predicted probabilities (for example `answerConfidence` and the yes-probability returned for `noul` questions) are well-calibrated. The new Rust SDK (`laya-rust`), an ONNX Runtime port of the Python SDK, reimplements calibration and typed answers among other components, validated by 210 offline tests checked against goldens generated from the Python implementation. A recent bug fix (#731) addressed an issue where an ONNX agent's versioned calibration file always warned about a checkpoint mismatch because `ONNXAgent` never stored the identity that `apply_calibration_payload` compares against—now an ONNX agent's calibration file can correctly match its own checkpoint. Calibration quality is also benchmarked in head-to-head comparisons against "TypeSafe Jev" across shared public datasets, all 51 languages, accuracy, speed, and calibration.
On maturity, Laya appears actively developed and reasonably polished: it is at version 0.4.11, published on PyPI and Hugging Face (models and a demo Space), with online documentation, a Colab notebook, and an Apache 2.0 license. Fine-tuning substantially boosts accuracy: on the typed-decisions benchmark of 2,000 decisions across four workflows, the fine-tuned `laya-typed-decisions` checkpoint scores 0.766 accuracy versus 0.362 for the base English checkpoint. Documentation is extensive, including guides for prediction hooks, schema-driven decisions, Docker, and framework integrations, plus a full API reference, 41 runnable examples organized as an eight-stage learning path, consolidated benchmarks across 51 languages, local setup instructions, and research harnesses to reproduce reported numbers. Version 0.4.11 highlights include the Rust SDK, an ONNX exporter that proves its graph is batch-dynamic by running it at batches 1–3 and comparing against PyTorch (agreeing to 1.2e-06), two new MCP tools (`laya_predict_long` for scanning past the
ModelsServingMCPmultimodalon-devicelocal-first
★ 33,434 total+1,042 this week
#103
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 users wary of cloud-based voice services. At its heart, Voicebox supports eight distinct TTS engines — Qwen3-TTS, Qwen CustomVoice, Qwen VoiceDesign, LuxTTS, Chatterbox Multilingual, Chatterbox Turbo, HumeAI TADA, and Kokoro — each with different strengths in terms of language coverage, speed, and expressiveness, and all switchable on a per-generation basis. Voice cloning is a flagship capability: users can clone any voice from just a few seconds of reference audio using zero-shot techniques, or choose from over 50 curated preset voices. The app covers 23 languages ranging from English, Arabic, Japanese, and Hindi to Swahili, Finnish, and Hebrew, with Chatterbox Multilingual offering the broadest coverage. Expressive speech is supported through paralinguistic tags such as `[laugh]`, `[sigh]`, and `[gasp]` via Chatterbox Turbo, while Qwen CustomVoice enables natural-language delivery control and Qwen VoiceDesign allows voices to be described entirely in plain text without any reference audio. Post-processing is handled through eight audio effects powered by Spotify's Pedalboard library, including pitch shift, reverb, delay, chorus, compression, and high/low-pass filters, with built-in presets like Robotic, Radio, Echo Chamber, and Deep Voice. For long-form content, Voicebox auto-chunks text at sentence boundaries and crossfades segments together, supporting up to 50,000 characters per generation. A Stories Editor provides a multi-track timeline for producing conversations, podcasts, and narratives with drag-and-drop composition and inline audio trimming. On the input side, a global dictation hotkey with push-to-talk and toggle modes — powered by Whisper-based speech-to-text — lets users dictate into any application on their system. Agent integration is a particularly notable feature: any MCP-aware AI agent such as Claude Code, Cursor, or Cline can invoke a single tool call (`voicebox_speak`) to speak through a user-cloned voice, and voice personalities with free-form personas can be attached to profiles and invoked by agents over MCP. The app exposes a REST API and a built-in MCP server for broader integration into custom apps and workflows. Built with Tauri (Rust) rather than Electron, Voicebox delivers native performance and runs on macOS (Apple Silicon and Intel via MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, and Docker. The project is maintained with the help of
AppsMCPModelslocal-firstaudiomultimodal
★ 57,960 total+1,036 this week
#104
Recordly is an open-source, cross-platform desktop screen recorder and editor built with Electron, designed to help users create polished demo videos, walkthroughs, and product videos without needing a dedicated motion designer. It supports macOS (14.0+), Windows (10 Build 19041+), and Linux, using platform-native capture backends where possible — ScreenCaptureKit on macOS, Windows Graphics Capture (WGC) with WASAPI audio on Windows, and Electron capture APIs on Linux. Key features include automatic zoom suggestions driven by cursor activity, cursor smoothing and motion blur, dynamic webcam bubble overlays, a drag-and-drop timeline editor with trim/speed/annotation regions, and rich frame styling with wallpapers, gradients, blur, and shadows. Export options cover MP4 and GIF with quality and frame-rate controls. A community-driven extension marketplace allows third-party additions like cursor click sounds, device frames, and browser mockups. Projects are saved as `.recordly` files preserving full editor state. The app is licensed under AGPL 3.0, actively accepts pull requests, and originated as a fork of OpenScreen before diverging significantly. Its combination of native capture backends, PixiJS-powered rendering, and an extension ecosystem makes it a notable open-source alternative to commercial screen recording tools, with growing community support and AUR packaging for Arch Linux users.
AppsDatavideomultimodallocal-first
★ 34,398 total+1,029 this week
#105
The openai/math repository hosts 719 mathematical manuscripts organized into 372 thematic families, produced by an internal OpenAI model as part of model development evaluations. When existing mathematical benchmarks saturated, OpenAI expanded evaluations to open research problems, posing approximately 4,000 problems to the model, each consuming roughly three hours of ChatGPT Pro thinking compute. Results span diverse mathematical disciplines and include principal findings, companion arguments, alternative proofs, and consequences. Approximately 42% of top-line results have been formally verified using Lean, with ongoing formalization efforts. Notable results include work on the irrationality exponent of π, the Mahler conjecture, Kaplansky's direct-finiteness conjecture, the Mézard–Parisi formula, isomorphism of free group factors, the Hodge Conjecture for CM abelian varieties, and a zero-free region for the Riemann zeta function. Reasoning traces for selected results are publicly released. The repository is notable for demonstrating frontier AI capability on unsolved or hard mathematical research problems, representing a significant and trending milestone in AI-assisted mathematics.
DataModelsEvalssynthetic-datacoding
★ 15,181 total+1,028 this week
#106NEWPartial week
MailCheap is an open-source newsletter platform built around a pay-per-email pricing model, meaning users are charged only for the emails they actually send rather than for the total number of subscribers on their list — a direct contrast to platforms like beehiiv, Substack, and Mailchimp that typically charge based on subscriber count. The project is authored by marclou and licensed under AGPL-3.0, positioning it as a transparent, self-hostable alternative to mainstream newsletter services. The entire application — both the cloud-hosted version and the self-hosted version — runs from this single repository, with MailCheap Cloud simply being the same codebase deployed with a `MAILCHEAP_CLOUD=true` flag that enables open sign-up, plan management, and Stripe billing.
A standout feature of MailCheap is its deep integration with AI agents, which is directly relevant to the ai-agents trend query. The platform exposes a Model Context Protocol (MCP) server that allows AI agents such as ChatGPT, Claude, Grok Bot, Claude Code, Codex, and Cursor to perform virtually every action available in the dashboard — writing, reviewing, and sending newsletters — through either OAuth or API key authentication. Critically, the MCP server marks sending as an irreversible action, prompting agents to seek user confirmation before dispatching emails, which reflects a thoughtful approach to agentic safety and human-in-the-loop design. This makes MailCheap one of the relatively few newsletter tools explicitly architected for AI agent workflows from the ground up.
The campaign workflow supports writing via a rich editor with slash commands, images, and layout boxes, or via Markdown and raw HTML submitted through the API or MCP. A review step checks for common issues before sending — subject line, preview text, unsubscribe link, Gmail's 100 KB clip threshold, postal address, and sender identity. Campaigns can be sent immediately, scheduled, or rolled out in a warm-up pattern where the most engaged readers receive the email first, with broader delivery following only if bounce and complaint rates remain acceptable.
Deliverability is treated as a first-class concern with multiple layered protections. These include automatic list warm-up, list cleanup that re-engages dormant readers before removing them, contact cleaning that filters invalid, misspelled, spam trap, role-based, throwaway, and duplicate addresses at import time, and a server-wide suppression list that stores only keyed hashes of problematic addresses. Hard bounce and spam complaint thresholds automatically pause or block sending accounts, and the platform integrates with Google Postmaster Tools to monitor Gmail-specific spam rates on a daily basis. Every email includes RFC 8058 one-click unsubscribe and a signed unsubscribe link, with confirmed opt-in enabled by default.
The platform supports importing subscriber lists from beehiiv, Substack, Mailchimp, Kit, MailerLite, Buttondown, Ghost, and EmailOctopus, preserving subscriber status and signup dates. Each newsletter gets a public-facing website with a signup form, issue archive, author page, share images, and a sitemap, hosted either on a free MailCheap Cloud subdomain or on the user's own server. Custom domain sending is supported with guided DKIM, return path, and DMARC configuration.
For self-hosting, the stack requires MongoDB for data storage, Amazon SES or PostShiba for email delivery, Upstash QStash for background job scheduling, and a Node.js 22+ host such as Vercel. Optional services include Resend for transactional sign-in emails, Upstash Redis for shared rate limiting across serverless instances, Amazon S3 with CloudFront or Vercel Blob for image uploads, and Google Postmaster Tools for deliverability monitoring. A one-click Vercel deploy button is provided, and setup is estimated at roughly one hour, mostly waiting on DNS propagation and provider approval
MCPAppsAgentsworkflow-automationlocal-firstsecurity
★ 1,237 total+999 this week
#107
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. The core idea is to help developers — especially those onboarding to large, unfamiliar projects — quickly grasp how every file, function, class, and dependency fits together, rather than reading code blindly. The tool operates as a plugin natively for Claude Code and is also installable via a one-line shell script across a wide range of AI coding platforms including Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode, Vibe CLI, Trae, Cline, Kiro, Nanobot, and more. At its heart, a multi-agent pipeline scans the project, extracts structural relationships, and saves the result as a knowledge graph JSON file, which is then rendered as a color-coded, interactive web dashboard users can pan, zoom, search, and click through. 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 changes, persona-adaptive UI that adjusts detail level for junior developers, PMs, or power users, and automatic layer visualization grouping nodes by API, Service, Data, UI, and Utility layers. The tool also supports domain-level views that map code to real business processes and flows, and can analyze Karpathy-pattern LLM wikis by extracting wikilinks, categories, and implicit relationships to produce force-directed knowledge graphs with community clustering. Localization is a notable feature, with support for generating node summaries, dashboard labels, and guided tour content in English, Simplified Chinese, Traditional Chinese, Japanese, Korean, Russian, and Vietnamese. Incremental re-analysis means only changed files are re-processed after the initial run, keeping token costs manageable. The project explicitly supports privacy-conscious or enterprise setups by allowing users to point the tool at local model providers like Ollama. The repository is trending on Trendshift (ranked #23482), carries an MIT license, and includes a live demo on its homepage. The project's philosophy — "AI should help people, not replace them" — positions it as a human-augmentation tool rather than an automation replacement, which may contribute to its broad appeal and growing momentum across the AI developer tooling ecosystem.
ToolsRetrievalAppscodinglocal-firstvector-database
★ 86,914 total+969 this week
#108NEWPartial week
Tracely is a trace-native CI/CD platform for AI agents that transforms production failures directly into regression tests, closing the gap between observability and actionable quality control. Rather than requiring engineers to hand-author evaluation datasets — which are inherently guesses about what might break — Tracely captures the exact failing production trace, with its precise inputs, tool calls, and model responses, and freezes it into a hermetic, replayable test case. This philosophy is encapsulated in its core thesis: the recorded run is the test. The platform operates as a five-stage loop: Observe, Detect, Test, Ship, and Alert, each corresponding to a dedicated section of the application.
In the Observe stage, traces arrive via standard OTLP/HTTP from any language and are enriched with agent-specific semantics such as agent ID, conversation ID, turn, and step, which are promoted to first-class indexed columns. This allows runs to group into conversation threads rather than flat span lists. Evaluators appear as columns directly on the trace table, grading at conversation, run, or span level, with scores streaming in live over SSE. Two additional visualization modes — Replay and Fleet — offer a step-by-step event timeline and a pixel-art office metaphor respectively, the latter designed to make multi-agent systems legible to non-technical stakeholders.
In the Detect stage, online evaluators grade every incoming run using LLM-as-judge methods and structural checks that require no model at all. Failures are then clustered both structurally and semantically, so dozens of broken runs collapse into a single labeled issue with an occurrence count, and each cluster can suggest the evaluator that would have caught it. In the Test stage, a single click promotes a failing trace into a hermetic regression case bundled with recorded tool and LLM output fixtures and a fail-to-pass contract, ensuring the case fails on old code and passes after the fix. Multi-turn behaviors are handled through Scenarios, which can be scripted conversations or adversarial red-team sessions where a model pursues a goal against the agent's own endpoint.
In the Ship stage, the test suite replays in CI against recorded fixtures — deterministic, offline, requiring no API keys and incurring zero model spend. The tracely gate CLI command exits non-zero, posts a commit status, and upserts a PR comment, effectively blocking regressions from shipping. In the Alert stage, a visual flow builder lets users define triggers (gate failures, live judge failures, novel failure modes, or metric thresholds) and connect them to actions including Slack messages, emails, webhooks with custom headers, LLM reasoning steps, and Python expressions, all templated over the failure's own variables. An in-app assistant can also construct the entire alert flow from a natural language description.
Beyond the core loop, Tracely provides trends dashboards covering daily failure rates, gate pass rates, latency percentiles, token spend, and per-agent cross-metric meta-analysis using Spearman correlations and z-score outlier detection. A judge calibration screen lets teams label verdicts against human review to catch over-flagging or under-flagging evaluators before they gate a release. The platform also exposes an MCP server endpoint so coding agents can drive the workspace programmatically using an ordinary ingest key. The full stack — API, worker, UI, Postgres, ClickHouse, Redis, and MinIO — can be self-hosted in one click via Railway or Railyard, or
EvalsAgentsMCPworkflow-automationsynthetic-datasecurity
★ 1,036 total+960 this week
#109
The awesome-dsh-plugin repository is a curated "awesome list" that catalogs community-built plugins for the DeepSeek Harness (`dsh`), DeepSeek's open-source agent harness. DeepSeek Harness is described as a runnable coding agent available in both Web and headless modes, built on a plugin-centric framework where essentially everything — models, tools, sandboxes, session storage, UI, and even the agent loop itself — is implemented as a plugin. This architecture allows plugins to extend the official coding agent, replace its core components, or assemble entirely new agent configurations. The repository collects plugins that are installable via the `dsh plugin add` command, each of which must declare a `dsh.bundle` manifest to conform to the official protocol. The list is explicitly client-agnostic, meaning plugins are included because they follow the official protocol rather than because they target any particular client.
A notable feature is that the list doubles as a plugin market index. On dsh version 0.2.1 and later, users can open Plugins → Discover → Index sources and add an index URL served from npm (via jsDelivr CDN) for fast loading, with GitHub Pages mirrors available at awesome-dsh-plugin.com and dshmarket.com. The Discover tab and the `plugin_market` agent tool search the same catalog entries. The index covers npm-published plugins with known versions, while GitHub-only entries can still be installed via accompanying commands. The README recommends dsh-market, an optional in-harness plugin market with a friendly UI offering one-click plugin installation, upgrades, and theme switching. It also highlights dsh-find-plugin, which lets the agent itself find plugins through chat. Several desktop clients are mentioned — dsh-desktop, and two differently-maintained deepseek-harness-desktop projects (one by anywhere-labs) — all of which bundle dsh-market so listed plugins are one click away.
The repository includes a prominent security warning: installing a plugin runs third-party code with the user's own permissions, giving it access to files, credentials, and the network. Tool approvals do not sandbox plugin code, and inclusion on the list is explicitly not a security review. Users are advised to inspect source code before installing and to test unfamiliar plugins in isolated environments. The listing criteria are deliberately minimal: a plugin is added if it installs with `dsh plugin add`, does what its one-line description claims, fits the right category, and is actively maintained. Every submission is verified against its own source before merging (for example, tool counts claimed in descriptions are actually counted). The maintainers emphasize that the list does not rank or judge plugin quality; listings are not permanent and are removed if repos disappear, go unmaintained, or break.
The plugins are organized into many categories, including AGI Architecture Exploration, UI Enhancements, Usage & Billing, Themes & Appearance, Models & Providers, Identity & Communication, Sessions & Messages, Memory, Tools & Capabilities, WSL & Windows Interop, Browser & Web, Vision & Multimodal, Voice & Audio, Docs & Rendering, Skills, Workflow & Automation, Git & Code Review, Notifications & Integrations, Development & Runtime, Security & Permissions, Remote & Mobile, Plugin Markets & Managers, and Just for Fun. The AGI Architecture Exploration section is especially rich, featuring experimental plugins such as a J-Space Cognition Suite, a prompt-polishing tool ported from prompt-optimizer, agentic answer reviewers that re-grade assistant turns with a separate LLM, quality-review auditors, executor/advisor workflows, evidence-checked research presets, adaptive-topology multi-agent systems, outsourcing-expert presets that force task delegation to subagents, white-box AGI memory architectures, a port of Claude Code Game Studios, chain-of-thought anchoring tools, a 636-expert roster across 22 divisions, proactive wake-up schedulers, simulated-life context injectors for roleplay characters, evidence-dri
AgentsToolsAppscodingmultimodalworkflow-automation
★ 19,382 total+953 this week
#110
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 notable in the growing AI-agent tooling space. Rather than bundling data costs into a subscription, OpenSEO requires users to bring their own DataForSEO API key, paying only for actual usage. Self-hosting is supported via Docker or Cloudflare (recommended for multi-device/team use), and a hosted version is available at $10/month. The project appears early-stage but actively developed, with community channels on Discord and X. Its combination of open-source flexibility, AI-agent integration, and cost transparency positions it as a trending tool at the intersection of SEO and agentic AI workflows.
MCPToolsAppsworkflow-automationbrowser-use
★ 24,053 total+919 this week
#111
The `logo-design-skill` repository by kaankiziltug is a comprehensive, production-ready agent skill that transforms Claude — and any other AI agent supporting the open Agent Skills format, such as Gemini CLI, Codex CLI, Cursor, or GitHub Copilot — into a disciplined, professional identity designer. The skill guides the agent through the full logo design lifecycle: from initial discovery and brief-taking, through word mapping, mark-type selection, concepting, geometric construction, optical corrections (overshoot, bone effect, irradiation), colour theory, typography, lockup creation, testing, client presentation, and final delivery of production-ready SVG files and brand guidelines. A defining structural feature is a mandatory human-in-the-loop checkpoint: the agent always stops after generating 8–12 concept one-liners and building three SVG concepts, presenting them as a single overview image with a recommendation before proceeding. Nothing further is produced until the user selects a direction, ensuring the expensive kit-building phase (colour lockups, mockup boards, favicon/icon sets, guidelines) only happens for an approved idea. This checkpoint-first philosophy is explicitly demonstrated across 28 fictional brand examples spanning sectors from specialty coffee and luxury fashion to SaaS, fintech, telehealth, and urban mobility, with several cases where the client deliberately chose a different concept than the skill recommended — illustrating the workflow's flexibility. The repository includes a reference library of over 1,400 real-world SVG logos, each visually classified by mark type, technique, geometry, subject, typography, mood, and industry. This library is searchable from the command line and browsable in a local gallery, used to study construction conventions and avoid look-alikes rather than to copy. A suite of dependency-free Python tools handles SVG auditing against logo principles, concept overview sheet generation, multi-test sheet creation (16px pixel test, one-colour, reversed, squint, mirror, contexts, competitor shelf test), client presentation board creation with industry-specific mockups, PNG rendering, and complete favicon/app-icon/web-manifest export. The skill uses the open Agent Skills format — a folder with a `SKILL.md` and plain Python tools — making it portable across Claude Code (via plugin marketplace or manual install), Claude.ai, Claude Desktop, Gemini CLI, Codex CLI, Cursor, GitHub Copilot, and OpenCode. Installation is straightforward across all platforms, with a lite version available for upload size constraints. The project carries a CI badge for automated tests and is ranked #14 on The New 100 agentic leaderboard, signaling active community recognition and early traction. Its notable qualities include the disciplined process encoding of real-world brand identity methodology, the large classified SVG reference library, the zero-dependency tooling philosophy, and broad multi-agent compatibility. The 28 richly documented example runs — covering vivid palettes, crowded categories like SaaS and fintech with explicit cliché avoidance rules, and honest risk flagging — demonstrate both depth and practical maturity. This project is trending in the agent-skills space as AI coding assistants increasingly support pluggable skill formats, and logo/brand design represents a high-value creative domain where structured process guidance meaningfully improves AI output quality.
ToolsAppsmultimodalworkflow-automationcoding
★ 3,703 total+914 this week
#112
RTK (Rust Token Killer) is an agent-agnostic token optimization tool that intercepts shell command outputs and compresses them before they reach an AI agent's LLM context window. Built as a single Rust binary with under 10ms overhead, RTK supports over 100 shell commands and can reduce bash output by up to 90%, making agentic coding workflows significantly cheaper and faster. The core idea is straightforward: rather than letting verbose raw command output flood an agent's context, RTK sits in the pipeline and applies four 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). For example, `git log` output is reduced to hash, author, and subject only; `cargo test` and `pytest` show failures only with passing tests collapsed to a count; and `ls`/`tree` outputs are reformatted with file counts instead of one line per entry. RTK integrates with 18 AI coding tools including Claude Code, GitHub Copilot, Cursor, Gemini CLI, Codex, Windsurf, Cline/Roo Code, OpenCode, Kilo Code, Kimi AI, Factory Droid, Trae, Mistral Vibe, Google Antigravity, Pi, Oh My Pi, Hermes, and OpenClaw. Installation is handled via Homebrew, winget, or a curl script, and per-agent setup is done with a single `rtk init` command. RTK ships in three distinct packages: the full `rtk` binary (Apache-2.0 + BUSL-1.1) with hooks, filters, and the compression engine; `rtk-oss` (Apache-2.0 only) with hooks and filters but no engine; and `rtk-proxy` (BUSL-1.1), a daemon that compresses API traffic. Production use is free across all editions, but using RTK as a commercial product or service offered to third parties requires a separate license. The project is transparent about how savings are measured — token counts are estimated as bytes divided by 4, making percentages reliable but absolute numbers approximate, and bash output is only one contributor to total LLM input tokens. RTK explicitly notes it does not break Claude's prompt cache, since filtered outputs are stored in history and cached normally on subsequent API calls. The README is multilingual, available in English, French, Chinese, Japanese, Korean, Spanish, and Portuguese, signaling broad international adoption ambitions. The project appears to be actively trending on GitHub, with a star history rank badge
ToolsServingAgentscodingworkflow-automationlocal-first
★ 83,898 total+908 this week
#113
agent-memory is an open-source long-term memory runtime for AI agents, designed to solve the fundamental problem of session amnesia — the fact that agents forget everything they learned once a conversation ends. At version 0.1.0 and requiring Python 3.12+, it is an early-stage but architecturally thoughtful project from tigerless-labs that targets any agent capable of running a shell command, not just coding assistants. Its core philosophy is that Markdown files on disk are the single source of truth, while a SQLite-backed index is merely a rebuildable cache — meaning you can delete the entire index directory and run `mem rebuild` without losing a single memory, a guarantee enforced by automated tests rather than documentation promises.
The project's central architectural insight is the synthesis of two historically separate approaches to agent memory. One approach builds retrieval engines with embeddings and knowledge graphs that are powerful but opaque and vendor-locked. The other hands agents a plain filesystem that is legible and portable but does not rank results and breaks down at scale. agent-memory merges both: a local retrieval engine indexes a filesystem the agent can also browse directly with `ls` and `grep`. Relations live as links inside Markdown frontmatter, a local BM25 index over FTS5 ranks results, and an optional vector plugin can be fused in via Reciprocal Rank Fusion. Crucially, nothing in the read path calls a model or crosses a network, and zero API keys are required.
Retrieval is designed around a tiered depth model. Rather than pasting text into context, recall returns an L0 list of one-line abstracts with file paths, anchors, and scores. The agent then opens individual memories at the depth the task demands — abstract, outline, full file, or raw traced messages — with each rung costing roughly an order of magnitude more context than the last. This prevents unnecessary context bloat while preserving full access when needed.
Writes are handled automatically at conversation boundaries rather than relying on the agent to remember to save things. A separate sleep-time consolidation pass then runs on its own clock, performing consolidation and forgetting by value. Deletions from this unattended pass arrive only as proposals requiring human confirmation, preserving safety. The supersede mechanism keeps the full chain of memory versions intact, and `recall --as-of` allows querying the store as it existed at any past date, so updating never destroys history.
The system supports three hosts natively — Claude Code, Codex CLI, and Muse Code — and provides a `mem setup` command that probes the host, initializes the store, installs lifecycle hooks, and runs preflight checks, ending with a `status: READY` confirmation. A `mem doctor` command provides layered diagnostics distinguishing host, config, store, hook, and reasoner failures. An MCP server (`mem-mcp`) is also available for agents that speak the Model Context Protocol, exposing core operations like recall, read, record, correct, supersede, merge, and delete.
Empirical validation is provided via a bounded LongMemEval-S benchmark using 120 episodes, with Claude Haiku 4.5 as the host agent and Sonnet 5 as judge. agent-memory achieved 52.9% pooled accuracy versus 35.8% for MemCore and 5.8% for no-memory baseline, with statistically significant pairwise differences. Cross-host compatibility was also validated:
ToolsRetrievalMCPlocal-firstvector-databasecoding
★ 4,290 total+891 this week
#114NEWPartial week
**e2e** is an open-source, AI-powered end-to-end testing framework for web and mobile applications, built by TesterArmy. It allows developers to describe test goals in natural language, with an AI agent autonomously driving the app to achieve them, while standard locators and assertions verify results in the same test file. A key performance feature is action replay: agent steps are recorded and replayed on subsequent runs without model calls unless the app changes, reducing latency and cost. The framework supports a broad ecosystem of packages covering browser engines (Chromium, Firefox, WebKit via Playwright), iOS/Android simulators, GitHub PR reporting, headless browsers (Lightpanda), and hosted cloud environments (smol machines, Limrun, EAS, TestMu). It supports multiple model providers or local models via bring-your-own-key. Example projects span Vite, Next.js, Astro, Expo, SwiftUI, Jetpack Compose, Flutter, and .NET MAUI. Currently pre-1.0 and in active development, it has been recognized as a GitHub Trending Repository. Licensed under Apache-2.0, it is notable for unifying agentic AI testing with conventional assertion patterns in a single, cross-platform framework.
EvalsAgentsAppsmultimodalbrowser-useworkflow-automation
★ 11,252 total+887 this week
#115
The `anthropics/financial-services` GitHub repository is a collection of reference agents, skills, and data connectors built on Anthropic's Claude AI, targeting financial-services workflows across investment banking, equity research, private equity, wealth management, and fund administration. The project's core design philosophy is "one source, two deployment paths": every agent and skill can be installed as a Claude Cowork plugin for end-users or deployed headlessly via the Claude Managed Agents API behind a firm's own workflow engine, using the same system prompts and skills in both cases. The repository ships ten named end-to-end workflow agents — including a Pitch Agent, Market Researcher, Earnings Reviewer, Model Builder, GL Reconciler, KYC Screener, and others — each self-contained with bundled skills and deployable with a single install command. Underlying these agents are vertical plugin bundles (investment-banking, equity-research, private-equity, wealth-management, fund-admin, operations) that expose slash commands like `/comps`, `/dcf`, `/lbo`, and `/earnings` for granular, on-demand use. A rich set of MCP (Model Context Protocol) data connectors integrates Claude with twelve major financial data providers, including Bloomberg-rival platforms like FactSet, Morningstar, S&P Global via Kensho, Moody's, PitchBook, LSEG, and Daloopa, as well as document stores like Box and Egnyte. Partner-built plugins from LSEG and S&P Global extend coverage to bond relative value, swap curves, FX carry, options volatility, tear sheets, and earnings previews. The repo also includes admin tooling to deploy Claude inside Microsoft 365 apps — Excel, Word, PowerPoint, Outlook — routed through a firm's own cloud infrastructure on Vertex AI, Bedrock, or an internal LLM gateway. Everything is file-based (Markdown and JSON, no build step), making it straightforward to customize prompts, swap connectors, and add firm-specific context. Critically, the repository carries a strong disclaimer that all outputs are drafts for human review and do not constitute investment advice or execute any transactions. The project is notable for its breadth of real-
AgentsMCPToolsworkflow-automationmultimodal
★ 40,302 total+882 this week
#116
Rakazo is an open-source, self-hosted AI agent platform that lets users create and manage persistent AI teammates — bots with their own memory, routines, conversation history, and the ability to delegate tasks to peer bots or short-lived subagents. It positions itself as a bring-your-own-model, bring-your-own-compute alternative to hosted AI assistant products like Grok Bot, Meta Muse, OpenAI Dots, Instinct, and Hark Pro, while also competing with open-source agents like OpenClaw and Hermes Agent. Rakazo runs across web, Electron desktop, iPhone, and Android, making it unusually cross-platform for a self-hosted agent project. Key features include voice mode (with ElevenLabs, OpenAI, Cartesia, or Fish Audio), shared and isolated computer environments, browser/terminal/file/desktop access for bots, and rich app integrations via Composio, Pipedream Connect, remote MCP, and OpenAPI tool sources. Sandbox compute providers supported include Docker, E2B, Daytona, CreateOS, Box, and Railway, giving operators significant flexibility in where agent workloads run. The tech stack is modern and TypeScript-first: React 19, Vite, Tailwind CSS, Electron, Expo, Hono, oRPC, PostgreSQL, Prisma, Better Auth, and Graphile Worker. Deployment is streamlined via a one-liner Docker Compose installer or a Railway template, with detailed self-hosting, security, and backup documentation. The project is currently in beta and supports nine UI languages. Its combination of full self-hosting, persistent agent identity, multi-platform clients, and broad compute/integration support makes it a notably ambitious and trending entry in the open-source AI agent space.
AgentsAppsMCPlocal-firstbrowser-usemultimodal
★ 4,621 total+881 this week
#117
**女娲.skill (Nuwa.skill)** is an open-source Agent Skills project by Chinese indie developer 花叔 (Huashu) that "distills" the cognitive frameworks of world-famous thinkers and entrepreneurs into runnable AI perspective skills. Rather than simple role-play, it extracts five layers from public figures: communication style, mental models, decision heuristics, anti-patterns/values, and honest limitations. The distillation pipeline runs six parallel research agents across books, podcasts, interviews, social media, critic perspectives, and decision records, then applies triple-verification (cross-domain recurrence, predictive power, exclusivity) before writing results into a structured SKILL.md file. The project has already distilled 14 figures — including Steve Jobs, Elon Musk, Charlie Munger, Richard Feynman, Naval Ravikant, Nassim Taleb, Paul Graham, Andrej Karpathy, Ilya Sutskever, MrBeast, Trump, Zhang Yiming, and Zhang Xuefeng — plus one topic skill (X/Twitter mastery), all scoring A-grade (≥85) on an independent fidelity scorecard. Skills run across 50+ compatible runtimes including Claude Code, Codex, Cursor, OpenClaw, Hermes Agent, Gemini CLI, and OpenCode, installable via `npx skills add alchaincyf/nuwa-skill`. The project is notably trending as a spiritual successor to the viral colleague-skill repo, extending the concept from distilling coworkers to distilling history's greatest minds, and pairs with a companion darwin-skill for autonomous skill evolution.
AgentsToolsAppsworkflow-automationsynthetic-data
★ 34,975 total+870 this week
#118
Baidu's **Unlimited-OCR** is an advanced OCR system designed to push the boundaries of document parsing through "one-shot long-horizon parsing," building directly on DeepSeek-OCR. Released in late June 2026, the project introduces a multimodal model capable of handling single images, multi-page documents, and PDFs in a unified pipeline. It supports two inference configurations — "gundam" (crop-mode, optimized for single images) and "base" (full-resolution, for multi-page/PDF) — with context lengths up to 32,768 tokens. The model is deployable via Hugging Face Transformers, vLLM, and SGLang, with Docker images and an OpenAI-compatible streaming API provided for production use. Training support is available through ms-swift, and the model is hosted on both Hugging Face and ModelScope, as well as Baidu Cloud. A live demo is accessible on Hugging Face Spaces. The project is trending on GitHub and Trendshift, reflecting strong community interest in high-quality, scalable OCR. It acknowledges DeepSeek-OCR, DeepSeek-OCR-2, and PaddleOCR as foundational inspirations, and an accompanying arXiv paper (2606.23050) details the methodology. Its breadth of deployment options and long-document capability make it a notable advancement in open-source OCR.
ModelsServingAppsmultimodalvision
★ 27,827 total+868 this week
#119NEWPartial week
ARTEX is an AI-driven autonomous penetration testing system built with a Go backend and Next.js frontend, designed to operate within isolated lab environments. It employs a multi-agent LLM architecture consisting of a planner agent and multiple worker agents that collaboratively explore targets using a dual-graph design: a globally shared Asset Graph (tracking domains, subdomains, IPs, services, endpoints) and a per-task Exploration Graph (tracking goals, intents, facts, findings, hints), linked via anchor points to enable asset coverage tracking. The planner reads the exploration graph's state and dispatches intents only when uncovered directions exist; workers claim one intent, execute real tools (Bash, HTTP, Kali-based), and write results back to both graphs, triggering the next planner cycle in an event-driven closed loop. A notable feature is inter-worker process-level information exchange: workers can search other workers' execution traces within the same task, enabling knowledge reuse even before facts are formally recorded. The system includes human-in-the-loop approval/interception, full traffic recording via a MITM proxy with CA verification, MCP (Model Context Protocol) support for both Streamable HTTP and legacy SSE transports, and integration with ScopeSentry for asset synchronization. It ships as a single embedded binary or Docker Compose stack, supports one-click in-UI updates with SHA256 verification, rollback, and idempotent schema migration on startup. A dedicated retester agent handles manual vulnerability re-verification. The project is at an early but functional release stage (v0.3.3), licensed under AGPL-3.0, and is notable for its sophisticated agentic architecture, dual-graph reasoning model, and production-oriented operational features like safe self-update and reverse proxy guidance.
AgentsSafetyMCPsecurityworkflow-automationbrowser-use
★ 1,265 total+855 this week
#120
Toonflow is an open-source AI-powered creative platform developed by HBAI Ltd, specifically designed for short drama (短剧), comic drama (漫剧), and short video production. The platform integrates scriptwriting, asset management, and video generation into a unified infinite canvas workspace, enabling creators to move seamlessly from story concept to finished video content. Its core workflow involves four stages: writing scripts and storyboards with LLM assistance, preparing character and scene assets via image generation nodes, generating video clips by connecting text and image references to video models, and finally previewing, organizing, and downloading the produced media. A standout architectural feature is its support for AI Agents with open prompt customization, tool integration, and Agent-to-Agent (A2A) collaboration, making it relevant to the ai-agents trend. The platform also supports MCP (Model Context Protocol) for connecting external tools and services, a plugin marketplace for extending nodes and creative capabilities, and fully open model configuration — allowing users to plug in third-party APIs, local LLMs, or ComfyUI workflows without vendor lock-in. Toonflow supports local deployment across desktop, Android, Docker, and server environments, ensuring that projects and assets remain on the user's own infrastructure. The project is licensed under MIT, making it freely self-hostable, though third-party model API calls may incur costs. It is built with TypeScript, Vue 3, Bun 1.3.14, and Electrobun for desktop packaging. Notably, Toonflow supports 21 interface languages, reflecting a strong international ambition. In terms of maturity and recognition, the project has earned AtomGit G-Star No. 540 certification and Gitee GVP (Gitee Most Valuable Project) status, and has achieved Trendshift "Repository of the Day/Week/Month" badges across HTML, Vue, and TypeScript categories — signaling rapid community traction. Sponsors include Metaso (秘塔), APIMart, and Compshare (优云智算), all providing AI image/video generation API services integrated into the platform's ecosystem. The combination of infinite canvas, agent extensibility, MCP support, plugin marketplace, and multi-model freedom positions Toonflow as a notable and trending open-source contender in the AI-native creative tooling space, particularly for the growing short-form video and AI drama production market.
AppsAgentsMCPmultimodalvideoworkflow-automation
★ 18,136 total+854 this week
#121NEWPartial week
Jevgrep (`jg`) is a CLI tool that helps coding agents find relevant source code by asking natural-language questions about a repository, returning file locations, reading leads, and verbatim source excerpts in a single stdout response. It uses Jev, Vercel's AI Gateway model, to judge relevance across folders, files, and declarations, supporting Python, TypeScript/JavaScript, Go, and Rust with declaration parsing. Its headline claim is ~30% lower coding-agent cost: benchmarked on ten SWE-bench tasks, it matched the baseline's 8/10 task success rate while reducing Sol-only cost from $7.62 to $5.44 (28.6%). A subsequent v0.4.3 total-cost rerun showed 25.8% savings including Jev costs, and v0.5.0 cut native Jev cost ~59% further. The tool integrates with agents like Claude Code, Codex, and OpenCode via an installable skill system, and supports providers including Vercel AI Gateway, OpenRouter, and TypeSafe-compatible endpoints. Built with TypeScript, Bun workspaces, and Turborepo, it requires only Node.js 22+ with no Python or ripgrep dependency. It is actively versioned with published evaluation methodology, making it notable for transparent cost benchmarking in the AI coding-agent space.
ToolsRetrievalAgentscodingworkflow-automation
★ 2,795 total+849 this week
#122
Headroom is an open-source context compression layer designed specifically for AI agents and LLM-powered applications. Built by Headroom Labs AI, the project addresses one of the most pressing practical problems in agentic AI workflows: runaway token consumption. When agents process tool outputs, logs, RAG chunks, files, and conversation history, context windows fill rapidly and costs escalate. Headroom intercepts all of that content before it reaches the LLM, compresses it intelligently, and forwards only the reduced payload — delivering the same answers at a fraction of the token cost. Critically, all compression runs locally on the user's machine, meaning no prompt content or file data is transmitted to any external compression service.
The project offers four distinct integration modes to fit virtually any stack. First, a Python and TypeScript library exposes a simple `compress(messages)` call that can be dropped inline into any application. Second, a drop-in proxy (`headroom proxy --port 8787`) requires zero code changes and works with any language or framework. Third, an agent-wrap command (`headroom wrap`) supports a wide range of popular coding agents including Claude Code, Codex, Grok, Copilot, Cursor, Aider, Cline, Continue, Goose, OpenHands, and others, with a corresponding `headroom unwrap` to reverse the change. Fourth, an MCP server exposes `headroom_compress`, `headroom_retrieve`, and `headroom_stats` tools for any MCP-compatible client.
Architecturally, Headroom routes content through a pipeline consisting of a ContentRouter that detects content type, then dispatches to one of three specialized compressors: SmartCrusher for JSON, CodeCompressor using AST-based analysis for source code, and Kompress-v2-base — a custom model hosted on Hugging Face — for prose and general text. A CacheAligner component identifies volatile content that would break provider KV-cache prefixes without rewriting prompts, and a CCR (Compressed Content Retrieval) system caches originals locally so the model can fetch full text on demand via `headroom_retrieve`.
Benchmark results across four real-world scenarios are compelling. An SRE incident debugging scenario compressed 55,957 tokens down to 24,340 — a 57% reduction — while preserving a critical FATAL log line byte-for-byte. A codebase exploration scenario achieved 42% reduction, GitHub issue triage 30%, and code search 21%. Compression latency is negligible: 0.21 ms at the p50 for a 10K-token JSON payload and 1.4 ms at 100K tokens. Accuracy evaluations show no degradation on GSM8K math benchmarks, no detectable change on TruthfulQA, 97% accuracy on SQuAD v2 at 19% compression, and 97% on BFCL tool-use benchmarks at 32% compression.
Beyond input compression, Headroom also targets output token reduction — significant because output tokens on Opus-class models cost roughly 5× input tokens. Two mechanisms handle this: verbosity steering, which appends a terse-response instruction to the tail of the system prompt to preserve cache hits, and effort routing, which dials down reasoning effort for low-stakes turns like file reads or passing tests while preserving full effort for new questions and errors. These features work across both Anthropic and OpenAI-compatible endpoints and are toggled via `HEADROOM_OUTPUT_SHAPER=1`.
A `headroom learn` feature mines past agent sessions to extract failure patterns and write corrections into agent instruction files such as `CLAUDE.local.md`, `CLAUDE.md`, `AGENTS.md`, `GEMINI.md`, or `GROK.md`. A `--verbosity` flag additionally infers preferred answer length from past interaction patterns. Cross
ToolsRetrievalMCPlocal-firstworkflow-automationcoding
★ 75,923 total+838 this week
#123
gstack is an open-source "software factory" created by Garry Tan, President and CEO of Y Combinator, that transforms Claude Code (and other AI coding agents) into a virtual engineering team of specialized roles. The project is framed as Tan's personal answer to the question of how a single builder can now ship like a team of twenty, inspired by observations from Andrej Karpathy about writing almost no code by hand and by Peter Steinberger's solo-built OpenClaw project. Tan positions gstack as the tooling behind his own dramatically accelerated output: he claims three production services and over 40 shipped features in 60 days while running YC full-time, with a 2026 "logical code change" run rate roughly 810× his 2013 pace—numbers he backs with a documented methodology addressing the controversy over AI-inflated raw line counts. The repository emphasizes that the point is not who typed the code but what shipped, and that AI wrote most of it.
Functionally, gstack provides twenty-three specialist roles and eight power tools, all implemented as slash commands written in Markdown, distributed free under the MIT license. The roles mimic an engineering organization: a CEO who rethinks the product, an engineering manager who locks architecture, a designer who catches AI "slop," a reviewer who finds production bugs, a QA lead who opens a real browser, a security officer who runs OWASP and STRIDE audits, and a release engineer who ships the pull request. Key slash commands include /office-hours (product interrogation with forcing questions), /plan-ceo-review and /autoplan (strategic planning), /review (rigorous code review), /qa (browser and API testing), /cso (security auditing), and /ship (release automation). The intended audience is founders and CEOs who still want to ship, first-time Claude Code users wanting structured roles instead of a blank prompt, and tech leads or staff engineers seeking automated review, QA, and release rigor on every PR.
Installation is designed to be fast—about 30 seconds after cloning on a 4-vCPU Linux machine—and is driven by pasting a prompt into Claude Code that clones the repo into the skills directory and runs ./setup. Requirements include Claude Code, Git, and Bun v1.4.2+ (setup refuses versions older than 1.3.3 for security reasons related to reading a project's .env), plus Node.js on Windows. On macOS, the Aside browser is recommended so browser skills, /make-pdf, and /diagram can drive real logged-in sessions; otherwise gstack builds its own bundled Chromium browser. The /cso security tool additionally needs a Bun release with specific build flags and a native toolchain (a static-capable C compiler on Linux, Xcode command-line tools on macOS, or Visual Studio 2022 Build Tools on Windows); when absent, /cso reports "not assessed." Setup also supports preloading CSO runtime Docker images with configurable timeouts and resumable, digest-based progress.
gstack offers a "team mode" via ./setup --team and gstack-team-init that bootstraps shared repositories so teammates automatically receive gstack without vendored files or version drift, with per-session auto-update checks throttled to once per hour and network-failure-safe. Teams can require or merely nudge adoption. The project integrates deeply with OpenClaw, which spawns Claude Code sessions via ACP so gstack skills work automatically; natural-language requests to an OpenClaw agent map to gstack workflows like security audits, feature builds, and planning. Four native OpenClaw methodology skills (office-hours, ceo-review, investigate, retro) are installable directly through ClawHub and run conversationally without a Claude Code session. Beyond Claude, gstack supports many agents via ./setup --host, including OpenAI Codex CLI, OpenCode, Cursor, Factory Droid, Kiro, and GitHub Copilot CLI, with --host auto detecting and installing for all present agents. Agents are classified into tiers—full (certified by a real workflow run), experimental (passes conformance tests but uncertified), and inst
ToolsAgentsAppscodingworkflow-automationsecurity
★ 136,877 total+833 this week
#124
Codex Auth Helper (Codex 认证助手) is a lightweight Chrome extension (Manifest V3) designed specifically for Codex developers to securely manage and export ChatGPT session credentials as a local `auth.json` configuration file. The extension automatically detects the current browser's ChatGPT login state, displaying user avatar, email, and subscription plan (Free/Plus/Pro), while providing a real-time countdown of token expiry. A standout feature is its automated JWT synthetic token construction, generating a Codex-compliant `id_token` for seamless authentication. All processing is strictly local — credentials are never uploaded to any third-party server, with downloads triggered via `data:` URLs to avoid memory leaks. The UI features a polished Glassmorphism design with smooth transitions and toast notifications. At version 1.0.0, the project is early-stage but functional, requiring only developer-mode sideloading. It is notable for its strong privacy stance, minimal permissions (`downloads` and `chatgpt.com` only), and zero external CDN dependencies, making it relevant to developers working with OpenAI's Codex in environments requiring local auth configuration.
ToolsAppsSafetylocal-firstsecuritybrowser-use
★ 19,223 total+811 this week
#125
Awesome Zhuiju Free (laoma528/awesome-zhuiju-free) is a curated, community-maintained Chinese-language awesome list dedicated to helping drama and movie enthusiasts (追剧党) find free, ad-free streaming resources online. The project's name "追剧" literally means "drama chasing" or binge-watching, and the repository serves as a comprehensive guide aggregating 124 verified resources across a wide range of categories relevant to Chinese-speaking audiences who want to watch films, TV series, anime, and live broadcasts without paying for memberships or enduring advertisements.
The project covers eight major resource categories: online streaming sites (在线影视, 45 entries), mobile video apps (影视APP, 4 entries), cloud drive search tools (网盘搜索, 4 entries), magnet and BitTorrent resources (磁力BT, 16 entries), subtitle resources (字幕资源, 3 entries), TVBox and media player shell apps (TVBox/影视仓空壳, 7 entries), TVBox/media player configuration API endpoints (TVBox/影视仓接口, 17 entries), IPTV live stream sources (直播源, 3 entries), membership group-buying services (会员拼团, 0 currently), and open-source projects (开源项目, 15 entries). This breadth makes it a one-stop reference for multiple consumption patterns, from casual browser-based viewing to power-user setups using custom media players and IPTV.
A key technical feature of the project is its automated daily availability checking system powered by GitHub Actions. Every day around 09:00 Beijing time, a workflow named "Check availability" automatically probes each listed resource's homepage and records one of four statuses: accessible (🟢), restricted access (🟡), inaccessible (🔴), or unchecked (⚪). Results are stored in a structured JSON file at reports/availability.json, and the resource data itself is maintained in resources/resources.json. A second workflow, "Validate data," ensures data integrity. This automation distinguishes the project sharply from typical static navigation sites, which often go stale with dead links and no maintenance. The README explicitly contrasts this project against ordinary navigation sites, noting that ordinary sites lack curation, have no link-checking, are closed-source, and accept no community contributions — all problems this project claims to solve.
Community participation is a central design principle. Users can submit new resources or report broken links via GitHub Issues using structured templates (resource.yml and broken-link.yml). Several listed resources are attributed to specific GitHub contributors by username, such as @zxaay, @anyongki, and @miaodongsu7, demonstrating active community involvement. The project is fully open-source under the Creative Commons Attribution 4.0 (CC BY 4.0) license, and all resource data is publicly accessible in JSON format, making it machine-readable and reusable.
The project has a companion website at zhuiju.me, which likely presents the same curated data in a more user-friendly web interface. It also integrates with DeepWiki for AI-assisted documentation querying, and its trending status is tracked on Trendshift, where it holds a daily trending badge for JavaScript repositories — suggesting it has attracted meaningful attention in the GitHub community despite being a data/content repository rather than a traditional software project.
In terms of maturity, the project appears actively maintained, with availability checks dated as recently as October 2026 (likely a future-dated test or placeholder), 124 resources already catalogued, and multiple automated CI/CD pipelines running. The inclusion of a visit counter (via hits.sh), star and fork badges, and a Trendshift trending badge all indicate growing visibility. The project also includes a commercial advertisement for a ChatGPT Plus subscription service, suggesting the maintainer is monetizing the project's traffic while keeping the resource listings themselves independent of commercial influence.
Overall, Awesome Zhuiju Free is notable as a well-engineered, automation-backed, community-driven resource directory that fills a genuine need for Chinese-speaking streaming audiences. Its combination of human curation, daily automated health checks, open data formats, and community contribution workflows makes it significantly more reliable and transparent than typical link aggregation sites. Its trending status on Trendshift further confirms that it is resonating with a broad audience actively seeking free, high-quality streaming alternatives.
AppsToolsworkflow-automation
★ 12,606 total+806 this week
#126NEWPartial week
Folkbench is a Chinese-language AI relay/proxy service benchmarking platform and companion desktop client that continuously tests third-party AI API relay providers on availability, response latency, and pricing. The platform publishes public leaderboards ranking relay services by stability, cost-effectiveness, and data security, covering popular models like GPT 6, Claude Fable 5.1, Grok 4.7, and DeepSeek V4.1 Flash. The companion open-source desktop app, **Folkbench Switch** (built with Tauri + Rust), lets users one-click switch Base URLs and API keys across AI coding tools including Claude Code, Codex, Gemini CLI, Aider, OpenCode, and Kimi CLI, without manually editing config files. Key features include lossless config switching with diff previews, local-only API key storage for privacy, real-time probe data integration, and local token usage/cost estimation. The project supports macOS (Apple Silicon and Intel) and Windows x64, with SHA256-verified releases. It is notably trending due to its practical utility for Chinese developers navigating a fragmented AI relay market, its broad tool compatibility, and its transparent, community-driven benchmarking approach backed by multiple sponsor relay providers.
EvalsAppsToolslocal-firstcodingsecurity
★ 1,894 total+789 this week
#127NEWPartial week
**egoist/mygo** is a Go framework for building cross-platform desktop applications that supports two UI paradigms: a **webview-based frontend** (using OS-native webviews like WKWebView, WebKitGTK, and WebView2) and a **pure Go native UI toolkit** rendered on the GPU without HTML or JavaScript. The project is notably **pure Go with no cgo**, enabling cross-platform builds from any machine. Its typed IPC system auto-generates TypeScript clients from Go service definitions, enabling seamless frontend-backend communication. The native UI toolkit is feature-rich, offering flexbox/grid layouts, text editing, virtualized lists, SVG icons, animations, screen reader support, and even a "Liquid Glass" visual effect plugin. Desktop APIs cover windows, menus, tray, notifications, global shortcuts, file associations, and more. Shipping support includes app bundles, disk images, Windows installers, Debian packages, code signing, notarization, and signed delta auto-updates. The project targets low memory and CPU usage, producing small single-binary apps. It requires Go 1.27+ and optionally Bun for web frontends. Licensed under MIT, it appears trending likely due to its ambitious scope and zero-cgo cross-platform promise.
Appslocal-firston-device
★ 2,328 total+722 this week
#128NEWPartial week
RE:Dox is a high-performance, token-based structured data engine for .NET, developed by CAPCOM as a core component of their "REX" technology stack for a next-generation game engine. Rather than functioning as a conventional JSON serializer, RE:Dox parses structured data into a compact, fixed-size 64-bit token DOM (Intermediate Representation), which then serves as a unified structural layer for reading, editing, format conversion, serialization, deserialization, and automatic parallel deserialization across a wide range of formats. Supported formats include JSON, JSON5, CBOR, MessagePack, INI, and DOX at stable integration level, with TOML, XML, HTML, and CSV available as preview components.
The engine's central architectural innovation is a dual-mode 64-bit token: an extension bit determines whether the payload is interpreted by the document/format layer (source-backed) or by RE:Dox itself (editable DOM mode). This design enables a mutable tape DOM — normally read-only — by adding indirection through container views (DArray, DObject, DMap), a free list for reusing emptied token slots, and control tokens carrying edit state, preserving cache-friendly sequential memory layout while supporting node-like insert, remove, and replace operations. Serialization uses a single-pass write path directly to the output buffer with no intermediate object tree, while deserialization builds a compact token DOM first, enabling random access, out-of-order constructor binding, pre-sized collections, position-independent $type/$id/$ref resolution, and automatic parallel deserialization.
Performance benchmarks run on .NET 10 with BenchmarkDotNet on an AMD Ryzen Threadripper PRO 5975WX show RE:Dox achieving up to ~1.8x faster sequential deserialization, ~2.84x faster parallel deserialization, and ~1.6x faster serialization compared to System.Text.Json, while also dramatically reducing allocations — for example, deserializing canada.json allocates roughly 2.56 MB versus 8.53 MB for System.Text.Json. A unified converter model (DataConverter<T>) targets format-agnostic DataReader/DataWriter abstractions, allowing a single converter implementation to work across all supported formats and laying groundwork for future AOT and source-generator support. Additional notable features include trivia-preserving JSON5 editing (comments survive edits and re-encoding), lazy string/number decoding, compatibility layers for System.Text.Json, Newtonsoft.Json, and DataContractJsonSerializer, and dynamic access to the token DOM. The project is Apache-2.0 licensed and distributed via NuGet under the CAPCOM.REDox.* package prefix. Its trending
ModelsServingDatalocal-first
★ 1,648 total+614 this week
#129NEWPartial week
Project Maya is an open-source inference engine that enables running GLM-5.3-Flash, a massive 321-billion-parameter Mixture-of-Experts language model, entirely on consumer or prosumer hardware without sending data to any external server. The project's core innovation is a purpose-built engine that intelligently tiers model experts across GPU VRAM, system RAM, and NVMe SSD, dynamically moving experts as a conversation progresses and auto-calibrating to the specific hardware profile of each machine. It supports one to sixteen NVIDIA GPUs (compute capability 7.0+, i.e., V100 and RTX 20 series onward), with experimental AMD and Windows support also available. The project ships four quantization variants — Maya-S, Maya-S24, Maya-M, and Maya-L — ranging from roughly 95 GB to 156 GB, each retaining between 97.7% and 99.2% of the original FP8 model's zero-shot accuracy, with the setup wizard recommending the best fit for a user's hardware. Performance benchmarks contributed by real users show decode speeds from around 14 tokens/second on a laptop RTX 5090 up to 118 tokens/second on four RTX 4090s, with prefill rates reaching over 4,000 tokens/second on high-end multi-GPU rigs. The engine supports up to 1 million token context windows and handles up to eight concurrent requests, batching them efficiently so dense weights are read once for all parallel sessions. It exposes both OpenAI-compatible and Anthropic-compatible REST APIs, making it a drop-in backend for coding agents like Claude Code, and includes streamed tool calls, thinking-level controls, and CORS configuration. A browser-based chat interface and a live hardware monitor are bundled out of the box, and setup is a single shell script that builds everything locally without system-wide installation. The project also supports a community-contributed "derisked" variant (Maya-M-Derisked) that reduces refusals via a weight edit. Led by Peasant Smith and co-maintained actively, with a growing community of benchmark contributors, Project Maya is notable for democratizing frontier-scale LLM inference on private, owned hardware — a capability previously confined to datacenters.
ServingModelsAppslocal-firston-devicemultimodal
★ 1,042 total+595 this week
#130NEWPartial week
nanoMuse is an open-source personal agent designed to run across every device a user owns — phone, desktop, and browser — inspired by Meta's Muse but built to be self-hosted, privacy-respecting, and free. Rather than answering questions, it actively performs tasks: executing shell commands, controlling a browser, connecting to MCP servers, and even operating apps through screen interaction (called "Hands") on Android and desktop platforms where system APIs permit. The agent is persistent, continuing to work while the app is closed, running scheduled goals and morning feeds, and it always pauses to request user confirmation before irreversible actions like deletions, payments, or sends. A key architectural feature is its multi-device relay system: each device runs its own agent instance, and they communicate through a shared relay hub, so a task spoken on a phone can execute on a PC, with approvals routed back to wherever the user is. Memory is stored as human-readable Markdown files, and the agent supports a customizable visual identity — including animated avatars generated by image and video models. It integrates with chat platforms including Telegram, Feishu, DingTalk, and WeCom. Model flexibility is broad, supporting 21 providers including OpenAI, Gemini, DeepSeek, Claude, Kimi, OpenRouter, and Bailian, plus plans like ChatGPT. The project is built on OpenMinis and uses Alpine Linux under proot on Android. It reached 1,000 GitHub stars within 18 days of launch, ranked on GitHub Trending's Swift list, and its accompanying academic paper appeared on arXiv and ranked third on Hugging Face Daily Papers. Currently at version 1.0.5 ("Lookout"), it is licensed under GPL-3.0-or-later and positioned as a non-profit, community-driven alternative to closed personal AI agents. Its rapid traction, cross-platform scope, self-hosting capability, and academic backing make it a notably trending project in the agent-skills space.
AgentsToolsMCPon-devicebrowser-useworkflow-automation
★ 1,490 total+402 this week