GitHub Trending Weekly Digest — August 10–15, 2026

This week on GitHub Trending was, once again, all about agents — but with a twist. Instead of "here's another chatbot," the projects climbing the charts were about managing agents, packaging expertise for them, and shrinking models down small enough to run on the device in your pocket. We also saw a quiet resurgence of OSINT and security tooling.

I pulled the daily Top 5 from August 10 through 15, deduplicated by repository, and ranked everything by how many days it held a spot. Fourteen distinct projects made the cut. Here's the rundown.

Chart-Toppers (4 Days on the List)

These three refused to leave. Each held a Trending spot for four straight days.

diagram-design

🔗 github.com/cathrynlavery/diagram-design

What it does: A Claude Code skill that generates 29 kinds of editorial-quality diagrams — architecture, flow, sequence, and more — as self-contained HTML + SVG files with zero external dependencies.

Why it matters: AI-generated diagrams usually look generic and cheap — those telltale rounded boxes and that unmistakable Mermaid-slop. The author's old workflow was "fight with Figma for 30 minutes, or just skip the diagram entirely." This skill closes the gap between fast and good-looking: it reads your website, extracts your brand colors and fonts, and swaps hard-coded hex values for semantic roles (paper / ink / accent). It deliberately dodges the AI-generated look — a single accent color, coordinates all divisible by 4, and a built-in WCAG AA contrast check. It can even redraw your existing draw.io or Mermaid diagrams.

Tech: Standalone HTML + SVG (no build step), Python scripts for parsing draw.io / Mermaid, Playwright for PNG export, Google Fonts, and a progressive-disclosure architecture that loads reference files on demand. Installs via the Claude Code marketplace, Codex, and Pi. It was the runaway star of the week, peaking at +4,475 stars in a single day.

The Agency (agency-agents)

🔗 github.com/msitarzewski/agency-agents

What it does: A ready-to-hire "AI agency" — 230+ specialized AI agent personas, each with its own personality, domain expertise, and measurable deliverables, organized across 18 departments spanning engineering, design, marketing, sales, product, security, and testing.

Why it matters: Generic prompts like "act as a developer" only get you so far. This project fills the gap between vague general-purpose assistants and true specialist agents. Every persona ships with a defined identity, workflow, and success metrics, so you get reliable expert-level output without actually staffing a team. Definitions are battle-tested and portable — write once, run across any tool.

Tech: Agents are defined as Markdown files with YAML frontmatter (identity + mission + workflow + domain rules + success metrics), plus shell scripts for format conversion and installation. Natively compatible with 14+ platforms including Claude Code, GitHub Copilot, Cursor, Aider, Windsurf, OpenCode, and Gemini CLI. No runtime dependencies, MIT-licensed, platform-agnostic.

Semantica

🔗 github.com/semantica-agi/semantica

What it does: An open-source, self-hostable, graph-native infrastructure layer for building accountable AI — turning raw enterprise data into a structured, queryable knowledge graph where every decision is traceable, explainable, and auditable.

Why it matters: The classic "vector store + RAG" stack is essentially a black box. It can do similarity recall, but it can't tell you why the AI decided something, and it leaves no provenance trail. In regulated industries like lending, healthcare, and government, that gap is a compliance risk, not a minor inconvenience. Semantica records a source and a causal chain for every fact, replaces black-box LLM reasoning with a deterministic inference engine, and exports audit records in the W3C PROV-O format — all while keeping your data on your own infrastructure.

Tech: Python 3.8+, MIT-licensed. The reasoning layer uses forward chaining, Rete networks, Datalog, and SPARQL. Graph storage supports both RDF triple stores (Oxigraph, Blazegraph, Jena) and property graphs (Neo4j, FalkorDB, Neptune); vector backends include FAISS, Qdrant, Weaviate, and Pinecone. It ships a Python SDK, REST API, MCP server, CLI, and a Knowledge Explorer visualization panel, with LiteLLM as the LLM abstraction layer.

Multi-Day Appearances

Projects that trended for two or three days.

macro (3 days)

🔗 github.com/macro-inc/macro

What it does: A unified team workspace that pulls email, chat, docs, tasks, AI agents, calls, and CRM into a single interface — all @-linked together and sharing one common AI memory.

Why it matters: Most teams run on a pile of disconnected tools (Slack, Linear, Notion, HubSpot, Superhuman) glued together with MCP and Zapier. Information ends up siloed, task tracking goes stale because the real conversations happen elsewhere, and the company becomes, in the project's words, "not computable." Macro collapses those core operations into one system with shared institutional memory that refreshes every night, so context stops leaking out.

Tech: SolidJS + TypeScript on the front end; Rust on the back end (167 libraries across 42+ deployable services); PostgreSQL for persistence; CRDTs for real-time collaborative editing running on Cloudflare Durable Objects; hexagonal architecture, deployed with Pulumi + Docker. Open source under AGPLv3.

orca (2 days)

🔗 github.com/stablyai/orca

What it does: An Agent Development Environment (ADE) for orchestrating a fleet of coding agents in parallel — fan one prompt out to five agents, each running in its own isolated git worktree, then compare the results and merge the best one.

Why it matters: It tackles the mess of juggling multiple AI coding agents at once. Instead of swapping between tools or running them one at a time, Orca lets you compare Claude Code, Codex, OpenCode, and Pi side by side, all on your own subscription accounts. You can even monitor and drive it from your phone, with code review and version control living in a single interface.

Tech: TypeScript + Electron on the desktop (macOS/Windows/Linux), Node.js, Vite bundling; a WebGL-rendered terminal (Ghostty integration) with infinite split panes; SSH remote connections; native GitHub and Linear integration. Version control is built on native git worktrees, and the codebase spans desktop, mobile (iOS/Android), and CLI — 8,500+ commits and counting.

Needle (2 days)

🔗 github.com/cactus-compute/needle

What it does: A 14MB, 45-million-parameter open foundation model that runs from a single binary, purpose-built for tool calling, device control, and structured data extraction on tiny devices — phones, wearables, smart home gear, and robots.

Why it matters: It brings AI inference to resource-constrained hardware, fully offline, with no giant model file and no network dependency. It's 5 to 70 times smaller than comparable models (like FunctionGemma 270M or LFM2.5 230M) while staying close in capability. Thanks to a 256-token sliding window, memory stays flat at roughly 28MB no matter how long the conversation runs, and a confidence-gated mechanism keeps it from blurting out nonsense.

Tech: Built on a Simple Attention Network architecture (Hadamard MLP replacing the standard FFN, GQA grouped-query attention, engram key-value memory) with CQ2 2-bit quantization. Byte-level grammar constraints guarantee structured output; trained with JAX (GPU/Metal support). The Python package uses decorators to define tools and supports Pydantic; fine-tuning is done with LoRA adapters that merge back into a single .cact file.

Agent Skills (2 days)

🔗 github.com/addyosmani/agent-skills

What it does: 24 production-grade engineering skills for AI coding agents, splitting the full software lifecycle into six stages — Define, Plan, Build, Verify, Review, Ship — each with its own slash command.

Why it matters: AI coding agents love to cut corners — racing to "done" while skipping specs, tests, security review, and code review. This set bakes Google-flavored engineering best practices (Hyrum's Law, the test pyramid, Chesterton's Fence, trunk-based development) directly into the agent's workflow, forcing it to work to a production standard through mandatory verification gates.

Tech: Pure Markdown skill files (with process steps, anti-corner-cutting checklists, red-flag warnings, and verification requirements), plugged in through a standardized CLI (npx skills). Compatible with 70+ agents including Claude Code, Cursor, Codex, Copilot, Cline, and Gemini CLI.

MediaCrawler (2 days)

🔗 github.com/NanmiCoder/MediaCrawler

What it does: A multi-platform social media scraper covering China's major platforms — Xiaohongshu, Douyin, Kuaishou, Bilibili, Weibo, Tieba, and Zhihu — for keyword search, targeted post scraping, comment collection, creator-profile analysis, and comment sentiment visualization.

Why it matters: Scraping these platforms normally means reverse-engineering complex encryption and signature algorithms — a very high bar. MediaCrawler sidesteps that entirely with browser automation and a preserved login session, so developers with zero reverse-engineering experience can collect public data cheaply.

Tech: Python + Playwright (or CDP mode) for browser automation and session persistence; FastAPI / Uvicorn backend, Vue.js + Vite WebUI; data can be stored as CSV / JSON / Excel / SQLite / MySQL, with IP proxy rotation. Dependency management via UV. Douyin and Zhihu support leans partly on Node.js.

Paperclip (2 days)

🔗 github.com/paperclipai/paperclip

What it does: An open-source AI agent orchestration platform where you hire, assign, and monitor multiple agents from different vendors in one unified dashboard — and track their spend. Its own tagline: "If agents are employees, Paperclip is the company."

Why it matters: Running 20+ Claude Code tabs at once is chaotic and easy to lose track of. Paperclip addresses context fragmentation, multi-agent coordination, runaway token costs, missing governance and approvals, and broken task tracking — with persistent task management, budget/token tracking, approval flows, and an audit trail. It also auto-maintains goal context so agents don't lose the thread.

Tech: Node.js + PostgreSQL backend (embedded by default, external optional), React front end (mobile-responsive), pnpm workspace monorepo. Tested with Vitest + Playwright, deployable via Docker. Connects to Claude Code, Codex, Cursor, HTTP bots, and CLI agents through an adapter pattern, with multi-tenant data isolation and portable "company templates."

Single-Day Appearances

Quick hits that flashed onto the list for a day.

cordis

🔗 github.com/cordiverse/cordis

What it does: A "Spatiotemporal Composability" meta-framework for Node.js, built on a plugin architecture.

Why it matters: It lets developers compose components across two axes — space (structure) and time (lifecycle) — with a structured approach to managing side effects and component interactions. There's even a peer-reviewed paper on the underlying paradigm. Note the API is still unstable and under active development.

Tech: Node.js runtime, TypeScript, plugin architecture, Vitest + NYC for testing and coverage, Yarn for package management.

unsloth

🔗 github.com/unslothai/unsloth

What it does: A desktop app plus web UI for running, training, and deploying AI models locally — covering LLMs, diffusion models, embedding models, and audio and vision models.

Why it matters: It keeps your models private on your own hardware instead of the cloud, while speeding training up — the official claim is "2× faster training, 70% less VRAM." It drops the barrier to fine-tuning and deployment low enough that you don't need to write much code to get started.

Tech: PyTorch, Hugging Face (transformers, TRL), and llama.cpp; training methods span LoRA / QLoRA / full fine-tuning / reinforcement learning (GRPO, DPO) / FP8. The desktop app is built on Tauri; exports to GGUF, NVFP4, and MLX, with an OpenAI-compatible API and MCP support.

SpiderFoot

🔗 github.com/smicallef/spiderfoot

What it does: An OSINT automation platform that gathers and correlates data from a huge range of sources for threat intelligence and attack-surface mapping — figuring out what assets an organization exposes to the outside world.

Why it matters: Organizations want to know what they've exposed online and where the risks are, but manually querying hundreds of data sources is hopeless. SpiderFoot automates the whole recon flow — collecting, correlating, and visualizing — across target types including IPs, domains, hostnames, emails, phone numbers, usernames, and crypto addresses.

Tech: Python 3.7+, MIT-licensed, Docker-ready. 200+ built-in modules (most needing no API key), a YAML-configured correlation engine (37 preset rules), a SQLite backend, and both a web UI and CLI. It can search the dark web over Tor and integrates external tools like Nmap, DNSTwist, and Nuclei. Maintained since 2012, with a commercial SpiderFoot HX edition.

holehe

🔗 github.com/megadose/holehe

What it does: An OSINT tool that takes an email address and checks whether it's registered on 120+ websites.

Why it matters: Security researchers and investigators often need to map which platforms an email is tied to. holehe cleverly uses each site's "forgot password" flow to infer whether an account exists — and does it without alerting the target, since no notification email gets sent. Non-intrusive recon.

Tech: Python 3, async via trio + httpx (concurrent async/await requests). Installable via PyPI, git clone, or Docker; runs from the command line (holehe test@gmail.com) or embeds into Python code, and plugs into Maltego. GPL-3.0, educational use only.

plugins (Cursor)

🔗 github.com/cursor/plugins

What it does: Cursor's official plugin repository — a marketplace of plugins for dev tools, frameworks, and SaaS products, backed by a manifest format and a centralized registry.

Why it matters: It offers standardized, reusable plugins to extend Cursor across common workflows — code review, docs, testing, team collaboration — and hooks into third-party services like Gmail, Salesforce, and HubSpot through MCP (Model Context Protocol).

Tech: MCP, TypeScript / Node.js (Cursor SDK), and a .cursor-plugin/plugin.json manifest that declares skills / rules / MCP. MIT-licensed.

This Week's Themes

A few clear currents ran through the week's Trending list:

Managing agents, not just building them. The Agency, Paperclip, orca, and macro all point the same direction — the interesting problem is no longer "make one agent," it's orchestrating, budgeting, and governing a whole fleet of them without losing your mind.

Packaging expertise as reusable skills. diagram-design, Agent Skills, and Cursor's plugins repo are all about encoding senior-level know-how — design taste, engineering discipline, workflow steps — into portable, tool-agnostic definitions that any agent can pick up.

Shrinking AI down to the device. Needle and unsloth pull in the same local-first direction: tiny models and easy fine-tuning that run offline on your own hardware, no cloud round-trip required.

Accountable, auditable AI. Semantica stood out by treating explainability and provenance as first-class requirements — a signal that regulated industries are starting to shape what open-source AI infra looks like.

OSINT and security tooling made a comeback. holehe, SpiderFoot, and (in its own way) MediaCrawler show steady demand for reconnaissance and data-collection tools that lower the technical barrier to entry.

Takeaway

If last year was about proving agents could code, this week was about the plumbing that makes them usable at scale — orchestration dashboards, skill libraries, budget tracking, and audit trails. The most striking single story, though, was diagram-design: a focused Claude Code skill that solves one annoying problem beautifully, and got rewarded with the biggest star spike of the week. Small, sharp tools still win. Meanwhile, Needle is a reminder that the frontier isn't only bigger models — sometimes it's a 14MB one that runs on your watch.

---

Compiled by Tommy Zhang | August 16, 2026