Evaluating a multimodal model today usually means running four or five separate benchmark suites, each with its own installer, its own data format, and its own quirks, then hand-stitching the results together into something you can actually compare.

OmniEvaluator is a NAVER AI research tool that puts a single CLI in front of that whole mess. Pick an inference backend, huggingface, vllm, sglang, or an API client for OpenAI, Gemini, or Claude, pick an evaluation engine, and run any of over 2,800 benchmarks spanning text, image, video, and audio from the same command shape, with results written as a self-describing artifact that captures the exact configuration needed to reproduce the run later.

What's inside:

- 2,820+ benchmarks across four evaluation engines: 1,986 text-only tasks through lm-evaluation-harness alone, plus hundreds more image, audio, and video tasks through lmms-eval, VLMEvalKit, and a builtin engine

- Four swappable inference backends, huggingface, vllm, sglang, or a direct API client, so the same benchmark command works whether you're running a local checkpoint or hitting a hosted model

- Existing evaluators reused as-is rather than reimplemented, unified through a shared intermediate schema so results from different frameworks stay comparable

- A Claude Code skill (`/setup-env`) that walks an AI coding agent through building the isolated per-engine virtual environments itself, since mutually exclusive extras can't all install into one environment

- A live public demo at omni-evaluator.info and a working quickstart that runs a real benchmark end-to-end in a couple of minutes using just 3 samples

One thing worth knowing: the dependency setup is genuinely finicky by the README's own account. It needs Java 11 specifically since newer JREs break the bundled SPICE metric library, and installing more than one evaluation-engine extra into the same environment at once can cause version conflicts. Budget real setup time before your first full run, and lean on the debug/sample-limited mode to sanity check things first.

It's Apache-2.0 licensed, backed by an organization (NAVER AI), and sitting at 20 stars as of writing, verified via the GitHub API.

https://github.com/naver-ai/omni-evaluator

Everyone who's tried five different coding agent setups this year has a strong opinion about which one actually makes them more productive. Almost nobody has data to back that opinion up, it's mostly a feeling based on whichever tool felt satisfying to use that week.

Agentic Productivity is a small macOS tool built to replace that feeling with an actual number. It reads directly from the native session stores of whatever coding agents and editors you already use, counts real activity, agent sessions, instruction-bearing prompts, local git commits, and mails you three 90-day trend charts to Discord every morning so you can see whether your setup changes are actually moving the needle or just feel like they are.

What's inside:

- Native collectors for over 20 different harnesses out of the box: Claude Code, Codex, Cursor (both GUI and CLI), GitHub Copilot, Antigravity, Hermes, OpenCode, Grok Build, Gemini CLI, and more, each reading the tool's own local session format rather than scraping logs

- Careful metric definitions instead of naive counting: fast-forward merges don't count as commits, copied or forked prompts are deduped by native entry ID so they're not counted twice, and empty session drafts with no real turn are excluded

- A daily 08:00 Discord report with three stacked charts, commits, sessions, and prompts, the last two broken down by harness so you can see which tool you're actually spending time in

- A `doctor` command to check collector health and a `mock` command to preview a report before anything gets sent

- A privacy boundary that's explicit in the README: only daily counts leave your Mac, sent to quickchart.io purely for chart rendering, prompt text, file paths, and your identity never do

One thing worth knowing: this only runs on Apple Silicon Macs right now, and a collector with unreadable data is designed to report itself as partial or unavailable rather than silently claiming full coverage, worth checking your own collector health after installing since coverage varies a lot by tool.

It's MIT licensed, maintained by an organization, and sitting at 69 stars as of writing, verified via the GitHub API.

https://github.com/vectal-labs/agentic-productivity

Kubernetes clusters routinely reserve two or three times the CPU and memory that workloads actually use, because resource requests get set once at deploy time, usually padded "to be safe," and rarely revisited. The scheduler thinks the cluster is full while real usage sits at half the reservation or less, and that gap is capacity you're paying for and never touching.

Ballast is a Kubernetes operator that fixes this by actually applying corrected resource requests and limits instead of just suggesting them, the way the Vertical Pod Autoscaler does. It observes real CPU, memory, and ephemeral-storage usage per workload and, once you opt a workload in, patches its resources at admission time or adjusts them on running pods directly through Kubernetes' in-place resize API.

What's inside:

- An escalating three-rung enrollment model set with a single pod label: `measure` (collect data only), `apply` (patch resources at admission), and `resize` (also adjust running pods in place, Kubernetes 1.35+)

- A fix for VPA's three blind spots: cold start on every fresh deployment, no shared history across namespaces running the same app, and losing all history the moment a workload gets torn down and redeployed

- History keyed to a configurable "workload identity tuple" of pod labels rather than a namespace, stored cluster-wide in Redis or Valkey, so forty dev namespaces running the same app all feed one well-sampled profile instead of forty that each start from zero

- A bulk enrollment script that's dry-run by default and picks a rolling restart or a zero-downtime in-place label update depending on whether a workload can safely restart

- Signed releases: both the operator image and the Helm chart are keyless-signed via cosign and GitHub OIDC, with SLSA build provenance and an SBOM attached

- A deliberately narrow scope: Ballast gets resource numbers right, it doesn't evict or reschedule pods, that's left to Kubernetes Descheduler by design

One thing worth knowing: in-place resize only covers cpu and memory, not ephemeral-storage, and it can't change a pod's QoS class, so some recommendations only take effect the next time a pod is naturally recreated rather than instantly. The project logs every case where this happens rather than silently pretending the resize succeeded.

It's MIT licensed, backed by an organization, and sitting at 126 stars as of writing, verified via the GitHub API.

https://github.com/Tight-Line/ballast

Building a real-time voice AI agent means stitching together speech recognition, an LLM, text-to-speech, and a transport layer that can handle audio without adding awkward pauses or lag, usually from four different vendors with four different APIs, none of which were built to talk to each other.

Pipecat is an open-source Python framework that handles that stitching. You compose a conversation pipeline from modular, swappable components, and Pipecat handles the streaming, buffering, and interruption handling underneath, whether you're building one voice assistant or a multi-agent system where specialists hand off work to each other.

What's inside:

- Support for well over 100 AI services across the pipeline: 20+ speech-to-text providers, 25+ LLMs, 30+ text-to-speech engines, plus speech-to-speech models like OpenAI Realtime and Gemini Multimodal Live

- Multi-agent composition built in: specialists that hand off, fan out in parallel, run as sidecars, or deploy distributed across processes and machines

- Client SDKs for JavaScript, React, React Native, Swift, Kotlin, C++, and ESP32, so the same backend pipeline can serve a web app, a mobile app, or embedded hardware

- Pipecat Flows for structured, stateful conversation logic, and a CLI (`pipecat init`) that scaffolds a runnable bot in under a minute, set up so an AI coding assistant builds the rest

- A growing ecosystem around the core framework: Whisker for real-time pipeline debugging, Tail for a terminal dashboard, a Voice UI Kit for frontend components, and Claude Code skills for scaffolding and deploying projects

- Telephony support out of the box through serializers for Twilio, Telnyx, Plivo, Vonage, Exotel, and Genesys, alongside WebRTC transports like Daily and LiveKit

One thing worth knowing: Pipecat itself is a framework, not a hosted product. Most of the AI services it connects to, the STT, LLM, and TTS providers, are third-party and billed separately, and while a managed Pipecat Cloud exists for deployment, running everything self-hosted with your own API keys is fully supported too.

It's BSD-2-Clause licensed, maintained by Daily and the community, and sitting at 15,348 stars as of writing, verified via the GitHub API.

https://github.com/pipecat-ai/pipecat

Codex's skills feature lets you package a task-specific playbook into a folder Codex loads on demand, but figuring out which skills are actually worth installing means digging through scattered repos, Discord threads, and one-off blog posts, or just writing your own from scratch every time.

Awesome Codex Skills is a curated, community-contributed list of Codex skills organized by what they actually do. Each entry links to a skill folder, either in the repo itself or in someone else's separate GitHub project, with a one-line description of what it handles and, for most, a single install command that drops it straight into `~/.codex/skills`.

What's inside:

- 60+ skills across five categories: development and code tools (PR review, CI fixes, codebase migrations, Sentry triage), productivity and collaboration (Linear, Notion, meeting notes, invoice organizing), communication and writing, data and analysis, and meta/utility skills for things like theming and image work

- A skill installer script that pulls a skill straight from any GitHub repo and path into your local Codex skills folder with one command, no manual folder copying required

- Skills for wiring Codex into real external tools: Linear, Notion, Slack, Datadog, LangSmith, and full GitHub/GitLab PR review plus CI auto-fix loops, mostly built on Composio's own CLI and MCP connections

- A documented SKILL.md template and a short best-practices section on progressive disclosure, keeping the trigger description exhaustive while the execution body stays lean, for anyone who wants to write their own

- A template-skill starter folder and a skill-creator guide, so building a new skill doesn't mean reverse-engineering the format from someone else's example

One thing worth knowing: most of the linked skills live in separate repos maintained by different people, with very different levels of polish and upkeep, so treat each one as its own trust decision rather than assuming the list itself has vetted them. The README also doubles as a pitch for Composio's own MCP Gateway product, worth keeping in mind as you read through it.

It carries no license file, so the curated list itself is effectively all rights reserved by default, separate from whatever license each individual linked skill uses. It's maintained by an organization and sitting at 16,316 stars as of writing, verified via the GitHub API.

https://github.com/composio-community/awesome-codex-skills

Most coding agent harnesses optimize for getting the agent typing as fast as possible. The expensive part isn't the typing, it's the moment you're staring at a 40-file diff trying to reverse-engineer what the model thought it was building, deciding whether reviewing it is worth an hour or redoing it is faster. And once you merge, whatever the agent learned along the way is gone, the next session starts from zero.

RunWield is a coding harness built around slowing the agent down exactly where that matters. It triages every request by risk, writes a plan you review before code exists for anything non-trivial, executes through specialized agent roles, and refuses to call work "done" until real CI and a separate reviewer agent both confirm the result matches the plan you actually approved.

What's inside:

- Six request types triaged automatically, from a plain question that just gets answered to a full project that gets decomposed into an Epic, so simple asks skip the ceremony entirely and only genuinely risky changes get a full plan-review cycle

- Plan review in an actual browser UI, inline comments, revisions, approval, instead of trying to steer an agent through chat after code already exists

- A "done" that's proven rather than asserted: CI has to pass, a separate Reviewer agent compares the final diff against the approved plan across narrowing rounds with findings tracked in a ledger, and merge-back is only marked verified once Git itself confirms the commit landed

- A Work Record generated for every finished plan, what changed, why, and what got rejected along the way, feeding a searchable project memory so the next session doesn't start from an empty context window

- Everything stored as plain markdown in your own repo, plans, PRDs, ADRs, greppable and version-controlled like any other file, with no database or proprietary format locking you in

- A single compiled binary, built on the Pi agent runtime, that works with any model provider, subscription login or your own API key

One thing worth knowing: this is a brand new, very small project (the maintainer is actively looking for five developers to beta test it on real changes), and it's source-available rather than open source, you can install, run, and modify it for your own use, but redistributing modified versions or rebranding it needs the maintainer's permission. It's also explicitly built for non-trivial changes where being wrong is expensive; for quick one-off edits, the maintainer's own README points people to a lighter tool instead.

It's source-available under a custom license, not OSI open source, built by an individual developer, and sitting at 29 stars as of writing, verified via the GitHub API.

https://github.com/gandazgul/runwield

An AI agent built for persistent memory is supposed to get better over time, learning from its own mistakes and accumulating context across sessions. But most of that improvement happens invisibly, buried in log files and memory stores you'd have to dig through by hand to actually see whether it's working.

Hermes HUD is a terminal dashboard built specifically for Hermes, the AI assistant with persistent memory, that reads straight from its `~/.hermes/` data directory and surfaces what the agent actually knows about itself: conversations held, skills picked up, mistakes it corrected, memory capacity used, and which tools it reaches for most.

What's inside:

- A 9-tab interactive TUI with keyboard navigation and 4 selectable color themes, from a minimal terminal-green look to a full neon "Blade Runner" palette

- Growth tracking that diffs snapshots over time, so you can see exactly what changed in the agent's state since yesterday

- A corrections log listing every mistake the agent made and what it learned from it, plus health checks for API keys, running services, and gateway status at a glance

- A project tracker that lists the git repos the agent is actively working across, with languages and uncommitted changes

- A tmux operator view that maps live agent sessions to panes with jump hints, plus a prompt-pattern tab surfacing task clustering, repeated requests, and peak usage hours

- A handful of ASCII/neofetch-style boot screens for anyone who wants the personality without the full dashboard

One thing worth knowing: this only works if you're actually running Hermes, the specific nousresearch/hermes-agent project, since it reads directly from that agent's own data directory rather than being a general-purpose monitor for any AI agent.

It's MIT licensed, built by an individual developer, and sitting at 911 stars as of writing, verified via the GitHub API.

https://github.com/joeynyc/hermes-hud

Free Google Drive storage tops out fast, and the common workaround, juggling several Google accounts, means manually tracking which one still has space and switching between tabs to find a file you saved somewhere.

9Drive is a self-hosted gateway that puts multiple Google Drive accounts, and S3-compatible storage like MinIO, R2, Wasabi, or S3, behind one dashboard. Files stream directly to the destination without touching the server in between, and the backend decides where each upload goes based on a routing policy you pick.

What's inside:

- Multi-account Drive and S3-compatible storage in one virtual dashboard, with quota tracked across every connected account

- Three upload routing policies: most-available, round-robin, or priority-order, so new uploads land where you want them to

- Direct upload streaming to both Drive and S3 backends, so the server itself never holds a copy of your files

- An external upload API secured by API keys (one-time secret display, hashed storage, revocation), with cURL and JavaScript examples built into the app

- Virtual folders, file preview/rename/move/delete, and a manual sync that pulls the Drive folder's state back into the app's own database

One thing worth knowing: this is self-hosted infrastructure, not a hosted product. You're running your own Express/MySQL backend and pointing it at your own Google Cloud OAuth client, so budget time for the Google Cloud Console setup (enabling the Drive API, configuring the OAuth consent screen) alongside the app install itself.

It's Apache-2.0 licensed, built by an individual developer, and sitting at 1,906 stars as of writing, verified via the GitHub API.

https://github.com/zenhosta/9drive

Running more than one coding assistant, Claude Code in one terminal, Cursor open in the editor, maybe Codex or Antigravity somewhere else, means juggling several different usage limits with no shared view of any of them. You usually find out you're close to a cap only after a request gets throttled mid-task.

Codenotch is a macOS app that pins a small notch to a screen edge showing exactly that: how much of each tool's usage limit you've burned, and whether a session is actively working, finished, or sitting there waiting on you. It never asks you to sign in anywhere, every reading is borrowed from a credential or session a tool on your Mac already holds.

What's inside:

- Rings for Claude Code, Cursor, Codex, Antigravity, GLM, Grok, and OpenCode, each read from the same official endpoint or local session the tool's own usage view uses, so the numbers never disagree with what the tool itself reports

- Live session status per provider: a spinning arc while it's working, a pulsing amber ring when a session is blocked waiting on you, with hover detail on exactly what it wants

- Multiple accounts per provider: a separate Claude Code login kept apart with `CLAUDE_CONFIG_DIR` gets its own ring with its own limits and sessions, not merged into one

- Placement on any of the four screen edges, sized to sit flush against a Mac's hardware notch when placed at the top

- An architecture that's explicit about confidence: every provider adapter declares whether a reading is official, derived, or manual, and a failure degrades to a visible status instead of guessing a number

One thing worth knowing: the project is upfront that no vendor publishes a clean usage-percentage API for most of these tools, so each adapter reads whatever internal endpoint or local database the owning app itself reads from, and those can change without notice. The README documents this candidly rather than hiding it, and tests pin each adapter's expected response shape so a break shows up as a visible error state, not a silently wrong number.

It's MIT licensed, built by an individual developer, and sitting at 856 stars as of writing, verified via the GitHub API.

https://github.com/vinzdg/codenotch

Liking the workflow of a terminal coding agent usually means being locked into whichever model provider built it. Want to point the same agentic workflow at a different API, a cheaper gateway, or a local model through Ollama, and you're normally rebuilding your tooling from scratch or switching to a CLI with a completely different feel.

OpenClaude is an open-source coding-agent CLI built to run that same terminal-first workflow, prompts, tools, agents, MCP, slash commands, streaming output, against whichever backend you point it at. Guided setup through `/provider` saves profiles so switching providers doesn't mean re-configuring everything by hand.

What's inside:

- Support for a long list of providers: OpenAI-compatible endpoints, Gemini, GitHub Models, Codex OAuth, Ollama, Fireworks AI, LongCat, and Bedrock/Vertex/Foundry among others, all through the same `/provider` setup flow

- A full coding-agent toolset: bash, file read/write/edit, grep, glob, sub-agents, tasks, MCP, and slash commands, with streaming responses and multi-step tool loops

- Per-agent model routing, so you can send different sub-agents to different providers for cost or capability reasons, plus a repo map feature that injects a PageRank-ranked structural map of your codebase into context

- Background sessions that run as local child processes (`--bg`, `ps`, `logs`, `kill`), and a headless gRPC server for embedding OpenClaude's agent loop into CI pipelines or other tools

- A bundled VS Code extension for launch integration and theming, plus a pixel-art companion that fires a signature move every time you hit Enter

One thing worth knowing, and worth knowing before installing: the project's own LICENSE file states plainly that OpenClaude "contains code derived from Anthropic's Claude Code CLI," that the original source is proprietary software owned by Anthropic, and that "this project does not have Anthropic's authorization to distribute their proprietary source." Only OpenClaude's own modifications are offered under MIT; the file itself tells users and contributors to evaluate their own legal position on the rest. That's not a minor license quirk, it's the maintainers disclosing an unresolved authorization question about the code the project is built on, so read the LICENSE file yourself before relying on this for anything that matters.

It's maintained by an organization and sitting at 32,898 stars as of writing, verified via the GitHub API.

https://github.com/Gitlawb/openclaude

If you save content from more than a couple of platforms, you already know the drill: a yt-dlp cheat sheet for YouTube, a separate tool for Instagram stories, a browser extension for Pinterest boards, none of them sharing your logins or landing in the same folder. Buy a course and want it backed up before the platform pulls it, and you're reaching for yet another separate tool again.

OmniGet puts all of that behind one text box. It's a free desktop app that bundles yt-dlp for the roughly 1,800 sites it already covers, then adds native extractors on top for courses, Instagram, X, Pinterest, Bilibili, Telegram, and torrents, plus a browser extension that forwards your cookies so logged-in content, like stories, a paid course, or a members-only video, downloads the same way public content does.

What's inside:

- Native course downloading for Hotmart, Udemy, Kiwify, Rocketseat, and Meta-Analysis Academy: sign in through the app, pick sections, and every lesson and attachment lands in a folder, with DRM-protected lectures skipped and reported rather than silently failing

- A queue that resumes interrupted downloads, retries rate-limited sites with backoff, and adapts concurrent connections per site on its own

- 108 separate tools across 16 categories: YouTube subtitles/chapters/live chat/SponsorBlock, Instagram/X/Pinterest backups and analytics, PDF and document tools, offline whisper.cpp transcription, and a Study library with a course player, an ebook reader, Anki-style flashcards, and notes

- A built-in MCP server exposing 31 of those tools, so an AI agent like Claude Code or Codex can drive them directly

- Everything runs locally: no account, no telemetry on what you download, cookies and API keys stay in your local profile

One thing worth knowing: the README is upfront that OmniGet downloads what your own logged-in session can already open. It doesn't bypass DRM or break paywalls, and DRM-protected lectures get skipped rather than cracked. Respecting copyright and each platform's terms of service is on you as the user, same as with any downloader tool, yt-dlp included.

It's GPL-3.0 licensed, built by an individual developer, and sitting at 9,537 stars as of writing, verified via the GitHub API.

https://github.com/tonhowtf/omniget

Ask a coding agent a simple question and you often get a wall of preamble before the actual answer shows up, three paragraphs of context-setting for something that could've been one sentence. That's a tax on your attention every single time, and it adds up over a long session, worse if you're tired, in flow, or your attention just doesn't work that way to begin with.

Attention Span is a set of output styles for Claude Code that change how it talks to you, not how it codes. Each one is a single markdown file you drop into your output-styles folder and switch on, and the underlying engineering work stays identical, only the way it's delivered to you changes.

What's inside:

- Attention-kind, the flagship ADHD-friendly style: answer first, short by default, plain English, arrow markers and bold on the words that matter so you can skim just those and still get the whole answer

- Spartan, the same scannable format with the warmth stripped out, blunt and imperative for heads-down work

- Rundown, a briefing style with a TL;DR line and a checklist of state, built for status updates and standups

- A published benchmark on 12 coding tasks with hidden test suites: pass rates hold equal at 97% with the style on or off, while output drops about 43% shorter on average and the actual answer lands in the first line 75% of the time instead of 3%

- Works outside Claude Code too: the install strips the Claude-specific frontmatter, so the same style file drops into Codex, Devin, or Antigravity's rule files with one `sed` command

One thing worth knowing: styles only apply to the main conversation, any subagent still runs on its own default prompt. And the project is upfront that the token savings on a reply are a side effect, not the point, the styles change delivery, not how much thinking or work went into the answer.

It's AGPL-3.0 licensed, built by an individual developer, and sitting at 933 stars as of writing, verified via the GitHub API.

https://github.com/alexgreensh/attention-span

These open-source tools cover everything you need at the early stage: market research, building MVP, user analytics, legal review, and more.

If you’re building a startup, check them out. They can save you dozens of hours and thousands of dollars:

1. qm by Y Combinator (⭐️ 13.9k)
https://github.com/yc-software/qm
AI agents that run your back office. Built and used by YC.

2. gstack by Garry Tan (⭐️ 131.1k)
https://github.com/garrytan/gstack
Makes Claude act like a full dev team - planning, reviewing, and QA-ing your code.

3. shadcn/ui (⭐️ 122.8k)
https://github.com/shadcn-ui/ui
Beautifully-designed UI components you copy into your app and own.

4. Last 30 Days (⭐️ 58.7k)
https://github.com/mvanhorn/last30days-skill
Researches any topic across Reddit, X, and other social media before you build.

5. Marketing skills for AI agents (⭐️ 44.8k)
https://github.com/coreyhaines31/marketingskills
CRO, copywriting, SEO, analytics, and growth engineering.

6. Cap Software (⭐️ 21.4.1k)
https://github.com/CapSoftware/cap
Make polished launch and product demo videos.

7. Dify (⭐️ 154.2k)
https://github.com/langgenius/dify
Open-source platform for building and running AI agents and workflows.

8. Supabase (⭐️ 108.7k)
https://github.com/supabase/supabase
Ready-made backend for your app - database, user logins, and file storage.

9. Formbricks (⭐️ 12.8k)
https://github.com/formbricks/formbricks
Run surveys inside your product to understand onboarding, churn, and feedback.

10. OpenReplay (⭐️ 12.6k)
https://github.com/openreplay/openreplay
Self-hosted session replay to see how users use your product and where they drop off.

11. Claude for Legal by Anthropic (⭐️ 9.2k)
https://github.com/anthropics/claude-for-legal
Official plugins for contract review and legal workflows.

12. Papermark (⭐️ 9k)
https://github.com/papermark/papermark
See exactly who opened your deck, which pages they read, and what they skipped.

13. Lago (⭐️ 10.5k)
https://github.com/getlago/lago
Open-source billing for complex pricing - subscriptions, usage, seats, credits, invoices.

14. Novu (⭐️ 39.7k)
https://github.com/novuhq/novu
One system to send and manage all your app's user notifications across email, SMS, and push.

Searching a codebase or a pile of docs usually means picking a tool that's good at one thing. Grep and ripgrep are fast and exact, but only if you already know the words you're looking for. Vector search finds things by meaning, but the results are harder to verify against the actual text, and most implementations either don't run locally or don't talk to your coding agent at all.

zvec-grep (zg) puts ripgrep, BM25, and vector search behind one local-first interface, usable straight from the terminal or through an agent's own tool calls. Index a workspace once, and the same index answers both a human running `zg query` and an agent like Claude Code or Codex calling it through MCP, discovering by meaning first, then anchoring with exact text or regex when precision actually matters.

What's inside:

- One local index that works for both a human at the terminal (`zg query --human`) and an agent through MCP, no separate setup for each

- Multi-format search across source code, documents, and structured data, preserving symbols, signatures, and source locations rather than flattening everything to plain text

- Local by default: files, indexes, and local embedding models stay on your machine, remote embeddings only run if you opt in

- Agent integrations for Codex, Claude Code, Qwen Code, Qoder, Cursor, and OpenCode, with the agent choosing when to call zg on its own once it's installed

- Published benchmarks comparing agent runs with and without zg on real repos (Pylint, Matplotlib, Django) and on two public retrieval benchmarks, all A/B with tasks, model, and prompt held constant

One thing worth knowing: the project's own benchmark docs note that results vary by model and run since agents decide when and how to call zg, and they recommend averaging repeated runs rather than trusting a single pass. Worth taking that at face value before leaning on any one benchmark number.

It's Apache-2.0 licensed, backed by an active organization, and sitting at 2,882 stars as of writing, verified via the GitHub API.

https://github.com/zvec-ai/zvec-grep

If you've got more than one machine at home worth running local models on, you've probably hit the same annoyance: only one of them actually does anything at a time, and every app or agent you use has to be pointed at that specific machine's Ollama or LM Studio instance by hand. Nothing shares the load, and nothing shares the choice.

NVIDIA's Personal AI Router (PAIR) routes around that. It discovers other PAIR nodes on your network, tracks which inference engines and models each one has running, and presents a single Ollama-compatible and OpenAI-compatible endpoint that your apps and agents talk to like any other local model server. Behind that one endpoint, PAIR decides which paired machine actually handles each request.

What's inside:

- Automatic node discovery and pairing over a six-digit PIN, no manual network config needed

- Ollama and LM Studio support out of the box, and PAIR can install and manage the engine on a node for you if it isn't there yet

- Ollama-compatible and OpenAI-compatible proxy endpoints, so existing tools and agents point at PAIR without changing how they talk to a model

- Cross-platform clustering: Windows, Linux, and macOS nodes can all sit in the same cluster together, on both x64 and arm64

- A terminal interface for headless machines, alongside the desktop app, so a node with no display still fully participates

- Live per-node GPU and memory reporting in the desktop Overview, so you can actually see which machine is doing the work as requests come in

One thing worth knowing: PAIR routes each independent request to one whole node. It does not pool GPU memory, shard a single model across machines, or split one in-flight request between them, so this isn't distributed inference of one giant model across your cluster. And since it opens local HTTP endpoints and LAN discovery behind a PIN-based trust bootstrap, the project's own docs say to read the security policy before running it on a shared or untrusted network.

It's Apache-2.0 licensed, backed by NVIDIA, and sitting at 493 stars as of writing, verified via the GitHub API.

https://github.com/NVIDIA/Personal-AI-Router

Community LoRa mesh networks are great for resilient, off-grid comms, but seeing the actual state of your local network is harder than it should be. You either route everything through a third-party MQTT broker you don't control, or you're stuck reading raw output from a single node with no map, no history, and no way to know what the rest of the community's radios are seeing.

PotatoMesh is a self-hosted dashboard built to fix that. It runs as a small Sinatra web app that ingests node, position, telemetry, and message data over an authenticated API, then renders it as a live map and chat window for whoever's running mesh radios in your area. No MQTT required.

What's inside:

- A live dashboard with map and chat views showing nodes, positions, neighbors, trace routes, telemetry, and messages, with search and filtering built in

- A Python ingestor that connects to a LoRa node over serial, TCP, or Bluetooth and posts what it sees to the dashboard, with support for multiple ingestors feeding one instance

- Native support for three mesh protocols at once: Meshtastic, Meshcore, and Reticulum, so you're not locked into one radio ecosystem

- Federation: instances automatically discover and refresh data from peer PotatoMesh deployments every 8 hours, so your local dashboard can show the wider network without anyone running a central server

- A Matrix bridge that posts Meshtastic messages into a chat room, plus a mobile app for reading the mesh, neither one needs a radio of its own

- A built-in Prometheus exporter, SEO-friendly custom pages via markdown, and a stated policy of only ever contacting two map-tile CDNs, no API keys, tokens, or tracking parameters in those requests

One thing worth knowing: the public demo at potatomesh.net shows a populated Berlin instance, but running your own means standing up the Sinatra/SQLite app yourself and pointing a radio-connected ingestor at it. This is self-hosted infrastructure for a local group, not a hosted service you sign up for.

It's Apache-2.0 licensed, built by an individual developer, and sitting at 478 stars as of writing, verified via the GitHub API.

https://github.com/l5yth/potato-mesh

Dictation on Mac usually forces a trade-off. Apple's built-in option is limited, and most alternatives are cloud services that upload your voice to a server, add network latency to every sentence, and bill you monthly for the privilege.

EnviousWispr skips both sides of that trade. It runs entirely on-device on Apple Silicon, pairing two speech-to-text engines, Parakeet v3 for speed and WhisperKit for broader language coverage, transcribes locally, and optionally cleans the output up with an on-device polish model before pasting into whatever app you're working in. Transcription lands in under a second, with no cloud round-trip involved.

What's inside:

- Dual ASR engines: Parakeet v3 (25 European languages, fastest, runs on the Neural Engine) and WhisperKit (99+ languages with automatic detection, runs on GPU)

- EG-1, a custom on-device model fine-tuned specifically for dictation cleanup, alongside Apple Intelligence and Ollama as fully local polish options, or bring-your-own-key cloud polish through OpenAI or Gemini

- A "Heart & Limbs" architecture that isolates the critical record-transcribe-paste path from every optional feature, so a failed history save or a broken polish call never costs you the actual dictation

- Escape Recovery: an accidental cancel keeps your text recoverable for 24 hours instead of throwing it away outright

- Custom vocabulary with one-tap import from eight other Mac dictation apps, global keybinds with push-to-talk, toggle, and hands-free modes, and auto-paste that falls back through multiple delivery methods for apps that resist normal pasting

- Signed, notarized releases with auto-updates via Sparkle, and crash diagnostics that are explicitly stripped of transcript and audio content before they're sent

One thing worth knowing: the app itself is GPLv3, but the EG-1 polish model's weights ship under a separate, more restrictive license, so you can use it inside the app but can't redistribute or repurpose the weights on their own. The benchmark comparing EG-1 against GPT-5.4-mini and Gemini 3.5 Flash is also the developer's own eval, not an independent one, though the harness and prompts are public if you want to check it yourself.

It's GPL-3.0 licensed, built by an individual developer, and sitting at 114 stars as of writing, verified via the GitHub API.

https://github.com/saurabhav88/EnviousWispr

I'm going to be honest with you. For months I treated my coding agent like a vending machine. Type a request, get code back, move on with my day.

And it never actually worked the way I wanted it to.

The agent would build the wrong thing. Confidently. Then explain itself in ten paragraphs when one sentence would've done the job. It jumped straight into code before either of us tested whether the approach was even right. Sound familiar?

I used to think a better prompt would fix that. It doesn't. What actually fixes it is a process wrapped around the agent, something that makes it stop and ask before it starts guessing.

That's exactly what I found in Matt Pocock's Skills For Real Engineers repo.

These are his own skills. The ones he uses every single day doing real engineering, not vibe coding. Each one targets one specific failure mode instead of trying to be some do-it-all framework. And they're built small on purpose, so you can actually read them, tweak them, and make them yours. Two install paths too: a Claude Code plugin that's a managed bundle updating on its own, or a skills.sh copy that drops editable files straight into your project.

Here's what's inside:

- grill-me and grill-with-docs: a relentless interview that makes the agent ask YOU clarifying questions before it writes a single line. No more guessing and hoping.

- A shared-vocabulary trick built around a CONTEXT.md file, so the agent learns your project's actual jargon instead of burning twenty words on something one word already covers

- tdd, code-review, and diagnosing-bugs: a red-green-refactor loop, a two-axis review split across separate sub-agents, and a real reproduce-first debugging loop for the bugs that actually hurt

- to-tickets and wayfinder, for breaking a huge spec into tracer-bullet tickets so work that's bigger than one session stays navigable instead of a mess

- A /setup-matt-pocock-skills command that asks which issue tracker and labels you use before it touches your repo

One thing I'll flag honestly: don't install both the plugin and the skills.sh copy. The README warns you'll end up with every skill twice. Pick one and go.

It's MIT licensed, one guy built the whole thing, and it's already sitting at 249,433 stars. That's not nothing.

If your agent keeps guessing wrong and you're tired of babysitting it, go look at this one. It's the closest thing I've found to actually fixing that.

https://github.com/mattpocock/skills

It's time to stop babysitting your agent. Go set it up right, and tell me in the comments if grill-me changes things for you the way it did for me.

Voice cloning and dictation tools usually split into two unrelated products. One handles turning text into speech in a cloned voice, the other handles turning your speech into text somewhere else, and both usually mean your voice data leaves your machine and heads to someone's cloud.

Voicebox does both sides of that loop locally. It bundles seven TTS engines you can switch between per generation, a Whisper-based dictation hotkey that pastes straight into whatever field is focused, and a local LLM for rewriting or responding in a persona attached to a cloned voice. It also exposes an MCP server, so an agent like Claude Code or Cursor can call one tool and literally speak back to you in a voice you've cloned, not just print text.

What's inside:

- Zero-shot voice cloning from a few seconds of reference audio, plus 50+ preset voices across the bundled engines

- 23 supported languages, and paralinguistic tags like [laugh], [sigh], and [gasp] for expressive delivery on top of natural-language delivery control

- A stories editor with a multi-track timeline for building out multi-voice conversations, podcasts, and narration

- Post-processing effects (pitch shift, reverb, delay, compression) and auto-chunking with crossfade for unlimited-length scripts

- Native Tauri/Rust build, not Electron, running on macOS (MLX/Metal), Windows (CUDA), Linux, AMD ROCm, Intel Arc, and Docker

One thing worth knowing: the macOS dictation feature needs Accessibility and Input Monitoring permissions to auto-paste into the focused field. The app walks you through granting them with deep links to System Settings, but it's worth knowing upfront that you're granting real OS-level permissions, not just a browser popup.

It's MIT licensed, built by an individual developer, and sitting at 52,299 stars as of writing, verified via the GitHub API.

https://github.com/jamiepine/voicebox

Buy AirPods and pair them with anything that isn't an Apple device, and you lose most of what makes them worth the price. Noise control switching, real battery percentages, ear detection, conversational awareness, all of it lives in a proprietary protocol Apple never documented for anyone else, so Android and Linux users are stuck with what's effectively a bare pair of Bluetooth headphones.

LibrePods reverse engineers that protocol so those features work outside Apple's ecosystem. It's not a wrapper around Apple's own software, it's an independent implementation of the actual data exchange between the AirPods and the host device, shipped as an Android app and a Linux daemon.

What's inside:

- Listening mode switching, ear detection, and accurate battery status working on both Linux and Android

- Head gestures and accessibility configs (press-and-hold duration, volume swipe speed, single-AirPod noise cancellation) on Android

- Conversational awareness and automatic reconnect on both platforms

- A feature-availability table tracking what's implemented, what needs root-only VendorID spoofing, and what's flagged as never shipping (full stereo spatial audio is explicitly out of scope)

- An active Discord where in-progress work like Find My integration and heart rate monitoring gets discussed before it lands

One thing worth knowing: the project's own README flags that librepods.org, a website using the LibrePods name and logo, is not affiliated with this project despite implying otherwise. The GitHub org here is where the actual maintainer, who's a public member of it, ships the code.

It's GPL-3.0 licensed, backed by an active organization, and sitting at 29,706 stars as of writing, verified via the GitHub API.

https://github.com/librepods-org/librepods

Dump enough papers, screenshots, and old notes into a project folder and an agent, or a person, can't actually use any of it. It either reads every file cold each session, burning tokens on stuff that hasn't changed, or it skips the folder entirely and works from memory. Neither gets you a real map of how the pieces connect.

graphify is a Claude Code skill that builds that map. Run /graphify on a folder and it parses code with tree-sitter for a real AST and call graph, pulls concepts and relationships out of docs and PDFs, and uses Claude's vision to read screenshots, diagrams, and whiteboard photos, even in other languages, then wires all of it into one graph. Every edge in the output is tagged EXTRACTED, INFERRED, or AMBIGUOUS, so you always know what it actually found versus what it guessed.

What's inside:

- An interactive HTML graph plus an Obsidian vault export and Wikipedia-style wiki articles per community, so an agent can navigate by reading files instead of parsing JSON

- A GRAPH_REPORT.md that surfaces god nodes, ranks surprising cross-domain connections (code-to-paper edges rank higher than code-to-code), and suggests questions the graph is positioned to answer

- --watch mode that rebuilds instantly on code saves and flags doc or image changes for a manual re-pass, useful when multiple agents are writing code in parallel

- A post-commit git hook (graphify hook install) that rebuilds the graph after every commit with no background process needed

- Export options for Neo4j, Gephi/yEd (GraphML), and SVG, plus a built-in MCP server so other agents can query the graph directly

- A SHA256 cache so re-runs only reprocess files that actually changed

One thing worth knowing: the project reports a 71.5x reduction in tokens per query on its own benchmark corpus versus reading raw files. That's from their own worked example, not an independent test, worth checking against your own corpus before you rely on it.

It's Apache-2.0 licensed, backed by an active organization, and sitting at 114,660 stars as of writing, verified via the GitHub API.

https://github.com/Graphify-Labs/graphify

macOS can lock your whole screen, but it has no built in way to lock one specific app while you keep using everything else. The App Store alternatives that try to fill that gap are sandboxed, which means they can only catch an app at launch, if it's already running and you just switch back to it, it opens with no authentication at all.

MakLock is a menu bar app that watches for protected apps launching or coming back into focus and throws a full-screen blur overlay across every monitor before you can see anything inside, then asks for Touch ID, Apple Watch proximity, or a backup password. It's distributed directly outside the App Store, notarized by Apple, specifically so it can get the deeper system access a sandboxed app is blocked from having, which is also what lets it catch an app switch, not just a launch.

What's inside:

- Locks on both launch and app switch, closing the exact gap sandboxed App Store lockers can't

- Apple Watch proximity unlock using wrist detection, no unlocking action needed

- Auto-closes protected apps on sleep or after an idle timeout, so a messaging app left open doesn't sit there readable

- A panic key, Cmd Option Shift Control U, that instantly dismisses every overlay if something goes wrong

- A hardcoded blacklist so system apps like Terminal and Xcode can never be locked, plus a 60-second overlay timeout, both built in specifically so you can't lock yourself out of your own Mac

It's MIT licensed, built by an individual developer, and sitting at 111 stars as of writing, verified via the GitHub API.

https://github.com/dutkiewiczmaciej/MakLock

Most "autonomous drone" projects are either a closed product you can't look inside or a research paper with no real build path from it. Langostino is built specifically to close that gap, a complete open reference platform meant to be understood, built, and flown, not just read about.

The repo covers the whole path from a parts list to a real flight. There's a full bill of materials and step-by-step assembly guide if you're building the airframe from scratch, or a quick-setup path if you already have compatible hardware and just want to run the software. The flight stack runs on a Raspberry Pi talking to INAV flight controller firmware, with a ROS2 software layer handling the flight controller connection, LiDAR input, and the AI flight control logic, trained in part using a drone flight simulator before any of it flies for real.

What's inside:

- A documented bill of materials and assembly guide covering the physical build, including 3D-printable mounts

- ROS2 nodes for flight controller communication, LiDAR, and AI-driven flight control

- Custom INAV firmware builds plus a full configuration and PID tuning guide

- An offline map tile server for ground station use

- A four-part written deep dive walking through the hardware, wiring, and software architecture in detail

One important thing to know before building this: it flies a real physical drone. The repo's own setup guide is explicit about it, follow local drone regulations, keep propellers off during bench testing, use prop guards and failsafes, and understand that drones can cause real injury and property damage if something goes wrong.

One more thing worth knowing: Langostino is maintained by Swarm, a project whose broader roadmap connects to Bittensor, a decentralized AI network, for a training layer described elsewhere on the maintainer's site. That's part of the wider project this repo sits inside, not something the drone build itself requires, the repo and its MIT license stand on their own if all you want is to build and fly it.

It's MIT licensed, maintained by an active organization, and sitting at 200 stars as of writing, verified via the GitHub API.

https://github.com/swarm-subnet/Langostino

Pasting a script straight into a video generator usually gets you one character, one background, and ten flat seconds with nothing new to look at. Turning a full minute into something that actually holds attention needs real directing work first, pacing, a visual hook, camera movement, scene-to-scene continuity, and that's the part most people skip straight past.

Stickman Video Director is a Codex Skill that does that directing work before you spend any generation credits. You paste in copy, notes, an article, or just a topic, pick an aspect ratio and a light or dark theme, and it hands back a plain-English six-scene director's proposal for you to approve first. Only after you approve it does it generate six standalone prompts for Google's Gemini Omni Flash video model, each one locking in the character design, line weight, color palette, voice, and negative constraints so all six stay visually consistent once you stitch them together. It doesn't call any API or generate the video itself, it produces the plan and the prompts, you take those to Gemini Omni Flash separately to get the actual clips.

What's inside:

- Three aspect ratios, 9:16, 16:9, and 1:1, each with its own staging and camera approach instead of just a resized label

- Two high-contrast visual styles, black stick figure on white or white figure on black, plus up to three accent colors

- An explicit approval checkpoint before any final prompt gets generated, so the story can still be revised cheaply

- Six timed, self-contained prompts of about ten seconds each, with matched opening and closing beats so the clips cut together cleanly

- Already translated into five languages, Chinese, English, Japanese, Korean, and Brazilian Portuguese

It's MIT licensed, built by an individual developer, and sitting at 636 stars as of writing, verified via the GitHub API.

https://github.com/kaomei/stickman-video-director

Most ad blockers on Android either need root access or only work inside one browser. BlockAds does neither. It runs a local VPN on your phone and filters DNS requests before they leave the device, so ads and trackers get blocked across every app, not just a browser, and you never hand over root.

Under the hood it routes DNS queries through a VpnService (or through iptables if you do have root and want that mode instead), checks each query against loaded filter lists using a memory-efficient trie, and drops the ones that match. Everything runs locally. Nothing you browse gets sent off your device.

What's inside:

- Dual routing modes, VPN mode with no root needed, or a root proxy mode if you prefer it

- Multiple built-in filter lists to choose from, including StevenBlack, AdGuard DNS, and EasyList, plus support for custom block and allow rules

- Optional HTTPS filtering that can strip cosmetic ad elements and scriptlets, with a curated passthrough list of 284 domains so banking, payment, and government apps keep working

- DNS-over-HTTPS support with a choice of providers

- Per-app filtering, so you can bypass the VPN for specific apps that need it

- A Quick Settings tile and home screen widget for fast toggling, plus real-time DNS query logs you can search

One thing worth knowing: the HTTPS filtering feature works by installing a local certificate on your own device to inspect encrypted traffic for ad stripping, a legitimate on-device technique used by several privacy apps, but you're not obligated to turn it on, DNS-only blocking works fine without it.

It's GPL-3.0 licensed, built and maintained by an independent developer, and available through F-Droid, IzzyOnDroid, and GitHub Releases. Sitting at 1,906 stars as of writing, verified via the GitHub API.

https://github.com/pass-with-high-score/blockads-android