GitHub Trending Weekly Digest — October 19–24, 2026
If last week was about taking software apart, this week was about keeping agents on a leash. Cloudflare's security-audit-skill parked itself at or near the top of the trending list for five straight days, and NVIDIA quietly shipped a runtime whose whole job is to sandbox agent fleets. Around them, the usual flood of harnesses, skills, and plugins kept rising — plus a couple of outsiders: PHP's source tree spent three days on the board, and a Chinese astrology engine shipped a 56-gigabyte dataset.
Here's the deduplicated rundown, ranked by how many days each repo held its spot on the trending list over October 19–24.
Persistent Chart-Toppers (3+ days)
security-audit-skill
🔗 github.com/cloudflare/security-audit-skill
Days on board: 5 · Peak: +2,979 stars/day
What it does: A skill that turns a coding agent into a security auditor. It orchestrates a set of isolated agents through a six-phase audit: recon, coverage-guided vulnerability hunting, candidate validation, structured output, independent verification of each record, and a target-agnostic final report. Cloudflare's own vulnerability-discovery harness grew out of this skill.
Why it matters: This was the week's single biggest story, and the staying power is the tell — five days at or near number one. The design detail that makes it interesting: every finding is written as a machine-readable record (confirmed, needs_validation, or rejected), and each one is verified by a different agent than the one that found it. Run it repeatedly on the same repo and results accumulate, with earlier records used to fill coverage gaps. The author notes that a single run finds roughly half of what many repeated runs turn up combined — so persistence pays.
Tech: Mostly JavaScript, installed through the Skills CLI (npx skills add). You need a coding agent whose model supports tool calls and parallel subagents, plus Node.js to run the zero-dependency validators validate-findings.cjs and validate-coverage-ledger.cjs; findings are checked against the report-schema.json JSON schema. To actually execute target code you need an OS-enforced sandbox with external network turned off — without it, leads stay parked at needs_validation and the target code is never run.
ai-job-search
🔗 github.com/MadsLorentzen/ai-job-search
Days on board: 3 · Peak: +3,890 stars/day
What it does: A Claude Code–based job-application framework. You fork the repo, fill in your profile, and Claude evaluates postings, tailors your CV, writes cover letters, and preps interviews. The core commands are /setup, /scrape, and /apply, with a dozen more around them (/rank, /interview, /outcome, /gmail-sync, /notion-sync, and so on). The core workflow is language- and country-agnostic; the bundled Danish portal skills are meant to be swapped for local job boards, alongside country-neutral linkedin-search and freehire-search. It's an independent project — not affiliated with, endorsed by, or sponsored by Anthropic, and no token or crypto attached.
Why it matters: The author, trained as a geophysicist, built this after being laid off in late 2025 and ran their own search through it — 69 tailored applications, 20 first-round interviews, one signed contract, and an AI-engineering job starting June 2026. What sells it is the attention to the ugly parts: most LaTeX resume templates look fine in the .tex but break in the PDF (titles orphaned to the next page, cover letters spilling onto page two, list fonts silently falling back), so /apply compiles and visually inspects every PDF until the CV is exactly two pages and the letter exactly one. Because ATS systems read the embedded text layer rather than the rendered page, /apply uses pdftotext to verify contact details, reading order, and keyword coverage — logging unsupported keywords as gaps instead of stuffing them. Postings are treated as untrusted input.
Tech: Mostly Python. It needs Claude Code (no free tier — a Pro/Max/Team plan or API credits), Python 3.10+, Bun, and a LaTeX distribution with lualatex and xelatex. The CV uses moderncv's banking style; the cover letter uses a custom cover.cls with Lato and Raleway. ATS parseability checks optionally use pypdf, falling back to Poppler's pdftotext. /notion-sync writes to Notion through the official MCP server over OAuth, /gmail-sync reads Gmail through the connector. MIT.
ponytail
🔗 github.com/DietrichGebert/ponytail
Days on board: 3 · Peak: +1,949 stars/day
What it does: A ruleset for AI coding agents, plugged in as a plugin, hooks, or rule files across Claude Code, Codex, GitHub Copilot CLI, Cursor, OpenCode, Gemini CLI, Grok Build, and more. It exposes /ponytail, /ponytail-review, /ponytail-audit, /ponytail-debt, /ponytail-gain, and /ponytail-help, with four levels (lite, full, ultra, off; default full). Before writing code, it walks the agent down a ladder: does this need to exist, is it already in the codebase, can the standard library do it, is it a platform-native feature, is it an already-installed dependency, can it be one line — and only if none of those fit does it write the minimal working implementation.
Why it matters: It targets agent over-building head on. Ask for a date picker and a bare agent installs flatpickr, writes a wrapper component, adds a stylesheet, and starts debating timezones; with ponytail it just uses the browser-native input type=date. The rule isn't "fewest tokens" — it's write only what the task needs, while never cutting validation, error handling, security, or accessibility. On 12 feature tasks editing the full-stack-fastapi-template repo (Haiku 4.5, n=4), it reports average reductions versus baseline of 54% code, 22% tokens, 20% cost, and 27% time, with security held at 100% — peaking at 94% on heavily over-built tasks and near zero where the code was already lean.
Tech: Mostly JavaScript, shipped as the npm package @dietrichgebert/ponytail. The plugins and Cursor hooks run two Node lifecycle hooks and need node on PATH (Nix and nvm users, mind your non-interactive shell). Rules are delivered through AGENTS.md, .cursor/rules, .github/copilot-instructions.md and friends; OpenCode is configured via opencode.json, and config lives in ~/.config/ponytail/config.json or the PONYTAIL_DEFAULT_MODE environment variable.
ComfyUI
🔗 github.com/Comfy-Org/ComfyUI
Days on board: 3 · Peak: +1,206 stars/day
What it does: A node/graph GUI, API, and backend for diffusion models — you build and reuse image, video, audio, 3D, and text workflows visually, no code required. It ships desktop apps for Windows and macOS, a Windows portable build, a manual install path, and the paid Comfy Cloud. Native support covers Stable Diffusion 1.5, SDXL, Flux.1, Qwen Image, Wan 2.1 and 2.2, Hunyuan3D 2.1, and Qwen3, and partner nodes reach closed models like Nano Banana and Seedance.
Why it matters: It's aimed at visual creators who want control over every model, parameter, and output, and it bills itself as the most optimized diffusion inference engine around, tuned for local consumer hardware. With async weight streaming it claims to run the largest open models on as little as 4 GB of VRAM plus 8 GB of RAM. You get async queueing, partial-graph re-execution, VRAM and RAM management, model offloading, and quantized-model support, and it runs fully offline — it downloads nothing unless you ask, with --offline and --disable-partner-nodes controlling the paid API nodes.
Tech: Mostly Python, with 3.13 well supported. It depends on PyTorch (torch 2.7 is the minimum, newer strongly recommended) and supports NVIDIA, AMD via ROCm, Intel Arc, Apple Silicon, and Ascend. You can install comfy-cli through pip to set it up and launch; workflows save and load as JSON, and extra model paths go in extra_model_paths.yaml. The repo splits into three linked projects: Core, Desktop, and Frontend.
php-src
🔗 github.com/php/php-src
Days on board: 3 · Peak: +722 stars/day
What it does: The source repository for the PHP interpreter — the general-purpose scripting language best known for the web. It's distributed under the Modified BSD License (BSD-3-Clause), with the manual at php.net/docs, and it bundles a large set of extensions, with more available through PIE.
Why it matters: It's PHP itself, the thing that powers everything from a personal blog to some of the most popular sites on the planet. Three quiet days on the trending list is a nice reminder that the classics still pull a crowd amid all the agent tooling. You contribute by forking and opening a pull request — new features need an accepted RFC, bug fixes don't.
Tech: Mostly C. A minimal build from Git needs autoconf, bison, and re2c; the default build also wants libxml2 and libsqlite3 (plus pkg-config and build-essential on Ubuntu, make and ccache on Fedora). The flow is ./buildconf to generate configure, then ./configure (add --enable-debug for development) and make; test with make test and install with make install.
knowledge-work-plugins
🔗 github.com/anthropics/knowledge-work-plugins
Days on board: 3 · Peak: +643 stars/day
What it does: Anthropic open-sourced 11 plugins for knowledge workers, built for Claude Cowork and compatible with Claude Code. Each one bundles the skills, connectors, slash commands, and sub-agents for a particular role — productivity, sales, customer-support, product-management, marketing, legal, finance, data, enterprise-search, bio-research, and cowork-plugin-management. You install them from Cowork's plugins page, or in Claude Code by adding the marketplace and running claude plugin install.
Why it matters: The idea is to tell Claude how you want work done, which tools and data to pull from, how key workflows should go, and which slash commands to expose. These are pitched as a generic starting point that gets far more useful once you tune them to your own company's tools, terminology, and processes. They split into Skills (domain knowledge Claude calls automatically when relevant), Commands (explicit triggers like /finance:reconciliation or /product-management:write-spec), and Connectors (MCP links to CRMs, trackers, warehouses, and design tools).
Tech: Nominally Python, but really all markdown and JSON — a .claude-plugin/plugin.json manifest, a .mcp.json for tool connections, plus commands/ and skills/, with no code, infrastructure, or build step. The declared connectors span Slack, Notion, Asana, Linear, Jira, HubSpot, Snowflake, Databricks, BigQuery, and Figma, alongside life-sciences sources like PubMed, bioRxiv, ClinicalTrials.gov, ChEMBL, and Benchling.
Multi-Day Appearances (2 days)
orca
🔗 github.com/stablyai/orca
Days on board: 2 · Peak: +1,565 stars/day
What it does: A tool for managing a whole batch of coding agents at once, running any CLI agent off your own subscription, with desktop, mobile, and remote runtimes. It calls itself "The AI Orchestrator for 100x builders" and lets you run Codex, Claude Code, OpenCode, or Pi side by side, each in its own worktree, tracked in one place. The supported list runs long — Claude Code, Codex, Grok, Cursor, GitHub Copilot, Devin, Goose, Cline, Qwen Code, and more — and the rule of thumb is: if it runs in a terminal, it runs in Orca. MIT.
Why it matters: The headline use is fanning one prompt out to five agents in isolated git worktrees, then comparing the results and merging the winner. Mobile lets you monitor and steer agents from your phone, with notifications when they finish and follow-up instructions any time. On top of that it browses PRs, issues, and boards in-app and opens a worktree from any task; reviews diffs line by line and sends comments back to the agent; runs agents on remote machines over SSH with auto-reconnect; uses Design Mode to feed a clicked UI element's HTML, CSS, and cropped screenshot straight into the prompt; tracks Claude and Codex usage and rate-limit resets with login-free account switching; and even drives real desktop apps through Computer Use.
Tech: Mostly TypeScript. The terminal is a Ghostty-class, WebGL-rendered one with infinite splits and scrollback that survives restarts; Design Mode runs on a real Chromium window; file editing uses VS Code's editor with full autosave. Parallel work runs on git worktrees, remote work over SSH, with native GitHub and Linear integration. It's distributed as macOS dmg builds, a Windows installer, a Linux AppImage, a Homebrew cask, and an Arch AUR package.
OpenShell
🔗 github.com/NVIDIA/OpenShell
Days on board: 2 · Peak: +1,119 stars/day
What it does: NVIDIA's runtime for fleets of autonomous AI agents, billed as secure and private. It governs agents two ways: at runtime it instruments the kernel to enforce policy on every file access, syscall, and network connection; and before a policy change takes effect, it uses formal verification to check exactly what new access that change would open up. The 0.1.x release brings a stable release cadence, new isolation primitives, an expanded extension surface, and a new API.
Why it matters: The framing is that agents are most useful precisely when they can read files, install packages, call APIs, and use credentials — so OpenShell grants all of that without handing over unlimited access to data, secrets, and network. You declare in policy what each agent may touch, and OpenShell enforces it: each agent runs in an isolated sandbox with kernel-level limits on files and syscalls, and every outbound connection passes a policy check on the way out. Agents never see real credentials — OpenShell attaches them only for requests to approved endpoints. And before a policy change is approved, formal verification flags any risky new access it would grant (credentialed access to a new host, say, or a new API method) for human review.
Tech: Mostly Rust, also published as the openshell package on PyPI, under Apache License 2.0. It runs on Linux, macOS on Apple Silicon, or Windows with WSL 2 (flagged experimental), and needs Docker, Podman, or host virtualization. The install script sets up the CLI and a local gateway; on Kubernetes you deploy the gateway via Helm, with a CNI that can enforce NetworkPolicy. SDKs cover Python, TypeScript, Go, and Rust, and telemetry can be disabled at runtime or compiled out entirely.
ziwei-doushu
🔗 github.com/Renhuai123/ziwei-doushu
Days on board: 2 · Peak: +547 stars/day
What it does: A Zi Wei Dou Shu (Purple Star astrology) chart-casting system based on Ni Haixia's Tian Ji teaching system, bundling the chart algorithm, the four-transformations system, a pattern knowledge base, and classical source texts. It also ships a 13-dimension interpretation dataset, v4.0: 674,976 charts times 13 dimensions equals 8,774,688 interpretations, roughly 20.4 billion characters, 56.6 GB uncompressed — generated deterministically by the engine plus a verdict library, with no AI involved. The included UI is a minimal runnable sample; the commercial UI, the verdict library, the AI interpretation prompts, the backend API, and the user system stay closed.
Why it matters: The project's stance is that "the algorithm is public traditional wisdom and shouldn't be locked behind walls," so it open-sources the chart math and knowledge base to let more people learn the craft. The engine handles the edge cases that trip up common chart libraries: true-solar-time correction (by birthplace longitude plus the equation of time, which the author says avoids being off by a whole two-hour period east-to-west), China's 1986–1991 daylight saving, four leap-month conventions, the late-midnight day rollover, and a seven-level star-brightness scale with switchable brightness schools. The dataset is pitched as fine-tuning corpus for small models, a RAG source for AI chat, and an A/B baseline.
Tech: Mostly TypeScript, on Next.js 16 (App Router), styled with Tailwind CSS and a CSS-variables design system, with charting built on iztro plus lunar-javascript and animation via Framer Motion. npm run typecheck does a full type pass and npm test runs the chart-engine regression suite, both on every push and PR through GitHub Actions. The v4.0 dataset ships as JSON Lines, split into 77 files by year and compressed with zstd (decompress with the --long=27 flag).
Single-Day Appearances (1 day)
graphify
🔗 github.com/Graphify-Labs/graphify
Stars: +1,407 in a day
What it does: A command-line tool and installable /graphify skill that maps a whole project — code, docs, PDFs, images, video — into a knowledge graph. Run /graphify . and you get three files: graph.html (clickable, filterable, searchable in the browser), GRAPH_REPORT.md (key concepts, surprising connections, suggested questions), and graph.json (the full queryable graph). Out of the box it detects god nodes, partitions communities with Leiden and labels them without an LLM, links calls, imports, inherits, and mixes_in across files, and promotes NOTE and WHY comments plus ADR/RFC references into first-class nodes.
Why it matters: It replaces grepping through files with querying a graph: graphify query returns a scoped subgraph for a natural-language question, graphify path A B traces how two things connect, and graphify explain walks through a single concept. Code is parsed locally with tree-sitter — no LLM, nothing leaves the machine; only the semantic processing of docs and media calls a backend, and only if you've configured one. It's explicitly not a vector index: every edge is confidence-tagged as EXTRACTED (explicit in source) or INFERRED (derived by graphify). Graphify Cloud keeps the graph live, adding cross-repo links, formal verification, and SDLC-level review, and claims to cut an agent's token spend by 80%.
Tech: Mostly Python, needing Python 3.10+ and uv (recommended) or pipx; the PyPI package is graphifyy though the CLI stays graphify. It parses around 40 languages via tree-sitter AST, with community detection on Leiden (graspologic below Python 3.13, a native backend on 3.13+). Optional extras cover PDF, .docx and .xlsx, video/audio transcription, Neo4j and FalkorDB push, live PostgreSQL introspection, Terraform/HCL extraction, and backends from Ollama to OpenAI, Gemini, Anthropic, Bedrock, and Azure. It installs into 20-plus assistants across macOS, Linux, and Windows.
opencode
🔗 github.com/anomalyco/opencode
Stars: +1,310 in a day
What it does: An open-source AI coding agent with a terminal interface and a beta desktop app, available for macOS (Apple Silicon and Intel), Windows, and Linux. It ships two Tab-switchable agents plus a general subagent you can call in a message with @general.
Why it matters: The split is the point: build is the default full-permission agent, while plan is read-only — it refuses file edits by default and asks before running bash, which makes it good for exploring an unfamiliar codebase or planning a change before touching anything. The general subagent handles complex searches and multi-step tasks under the hood.
Tech: Mostly TypeScript. The CLI ships as the npm package @opencode/cli and installs via npm, bun, pnpm, or yarn, or through a curl script, scoop, choco, brew, pacman, mise, or nix; the desktop build comes through a Homebrew cask or Scoop. The install script picks its path by walking OPENCODE_INSTALL_DIR, XDG_BIN_DIR, HOME/bin, and HOME/.opencode/bin in order.
ai-memory
🔗 github.com/akitaonrails/ai-memory
Stars: +666 in a day
What it does: A long-term memory system for AI coding agents. Lifecycle hooks automatically record prompts, tool calls, and session boundaries, then at session end organize them into git-versioned markdown wiki pages — which the next session can retrieve, complete with a handoff note. It supports 20-plus tools (Claude Code, Codex, Cursor, Gemini CLI, OpenCode, and more), shares memory across agents, machines, and teammates, and bundles multi-user auth, write attribution, and audit logs.
Why it matters: The author's gripe is that an agent's built-in memory lives on one machine and belongs to one agent, so the moment you switch tools or teammates it's useless. ai-memory is built so you can quit Claude Code mid-task, start Codex in the same directory, and keep going — no re-explaining the architecture, the approaches you already tried and abandoned, or the open questions. The default mode calls no LLM at all: capture, search, and handoff need no API key, and plugging in a provider only improves summary quality and unlocks semantic search.
Tech: Mostly Rust, compiled to a single binary that runs an MCP/HTTP server. The primary data is git-versioned markdown, with the index kept in SQLite (FTS5, entities, and embeddings) and retrieval that fuses FTS5, entity matches, graph neighbors, and optional vector RRF. Optional curation providers include Anthropic, OpenAI, Gemini, and OpenAI-compatible endpoints like Ollama, LM Studio, and vLLM; it deploys via Docker or Podman, and runs on Linux, macOS, and WSL2 (native Windows is experimental).
ruflo
🔗 github.com/ruvnet/ruflo
Stars: +564 in a day
What it does: An agent meta-harness for Claude Code and Codex, formerly Claude Flow. It has two install paths: a Claude Code plugin (just slash commands, a few skills, and agent definitions, with nothing dropped into your workspace), and the npx ruflo init CLI install (98 agents, 60-plus commands, 30 skills, an MCP server, hooks, and a daemon, writing into .claude/, .claude-flow/, and CLAUDE.md). Its 35 plugins cover swarm coordination, federation, vector memory, learning, test generation, security audit, and cost tracking, and the console can run standalone through npx ruflo tui.
Why it matters: The framing is "Agent = Model + Harness": the model writes, and the harness provides the tools, memory, loops, sandbox, and control. Ruflo sits around Claude Code and Codex as an execution layer that adds 100-plus specialized agents, coordinated swarms, self-learning memory, cross-machine federation, and enterprise guardrails, so agents collaborate rather than just run. After init you keep using Claude Code as normal while the hooks route tasks, learn from successful patterns, and coordinate agents in the background. Credit where due: the README is refreshingly upfront that several of its flashy diagrams are conceptual illustrations, not real execution traces.
Tech: Mostly TypeScript, distributed as the npm package ruflo and usable as a local stdio MCP server; the Claude Code plugin needs Claude Code 2.1.287 or newer. Under the hood it's driven by Cognitum.One's agentic architecture running a Rust AI engine, embeddings, memory, and a plugin system. The plugins reach into GPU-accelerated search and Graph RAG, a vector database, Playwright browser testing, local LLMs via Ollama, and a local WASM sandbox. MIT.
Themes of the Week
Agent security and sandboxing took the top spot
For once the loudest story wasn't a new way to write code faster — it was how to let agents run dangerous operations without handing over the keys.
- security-audit-skill turns an agent into a multi-stage security auditor, with every finding cross-checked by a second agent. It held number one for five straight days.
- OpenShell is NVIDIA's kernel-enforced, formally-verified runtime for agent fleets — it grants file, syscall, and network access only within a declared policy.
- ruflo and orca both lean on the same instinct, isolating work in per-agent WASM sandboxes and separate git worktrees.
The harness and skills layer keeps expanding
"Make your coding agent better at one thing" is now a full-blown genre, and this week it stretched from role-specific plugins to whole control surfaces.
- knowledge-work-plugins is Anthropic's 11 role-based bundles, from finance to bio-research.
- ponytail is a ruleset that stops agents from over-building.
- orca and opencode are two takes on running agents — a whole fleet versus a single disciplined terminal.
- ai-memory and graphify hand agents persistent memory and a queryable project graph.
- ruflo is the meta-harness trying to wrap all of it at once.
Doing more with less
A quieter thread, but a consistent one: the breakout utilities this week sold restraint, not output.
- ponytail reports 54% less code and 22% fewer tokens by refusing to build what the task doesn't need — without cutting validation, error handling, security, or accessibility.
- graphify claims an 80% cut in an agent's token spend by querying a knowledge graph instead of grepping through files.
Takeaway
The center of gravity shifted this week. For months the trending list has rewarded whoever could bolt one more capability onto a coding agent; this week the repos that stuck around were the ones worried about what happens when those agents actually run — Cloudflare auditing code with agents, NVIDIA sandboxing the agents themselves. That's a healthy sign of a field growing up: once a tool is powerful enough to be trusted with your files and credentials, "is it safe" stops being a footnote. Underneath that, the skills-and-harness genre kept compounding, and the most interesting entries were the opinionated ones — ponytail telling agents to build less, graphify telling them to query instead of grep. And it's worth noticing that PHP's source tree can still spend three days on the chart in the middle of all this. The classics aren't going anywhere; the leash is just new.
Compiled by Tommy Zhang | October 25, 2026