Open-source (Apache-2.0) framework from UiPath to evaluate and benchmark coding agents and their skills: declarative YAML tasks run in a sandbox against Claude Code, Codex or Antigravity, weighted 0.0–1.0 scoring, A/B experiments and a CI gate via GitHub Action.
Why it matters: I picked it because it answers the question nobody asks after writing a skill or an MCP server: "does it actually fire?". The `skill_triggered` criterion reads the agent's traces and hands you a confusion matrix with precision and recall — you stop eyeballing it and start measuring.
Open-source (MIT) multi-model orchestration layer for Claude Code: the frontier model plans in the main session, Sonnet and Haiku execute the volume work through global subagents, and fresh-context Opus verifiers guard quality — three config files, zero runtime code.
Why it matters: I picked it because it turns the pattern Anthropic itself benchmarked — frontier orchestrator + Sonnet workers at 96% of the performance for 46% of the cost — into a setup you install in ten minutes. And the README is a lesson in technical honesty: it even documents when automatic delegation does NOT kick in.
Open-source Office suite built for AI agents: a single binary (no Office install) that creates, reads and edits Word, Excel and PowerPoint from the command line, with built-in HTML/PNG rendering, an Excel formula engine, template merge and an MCP server.
Why it matters: I picked it because it fixes agents' blind spot with Office documents: without rendering, an agent generating slides flies blind — here the render → look → fix loop lives inside the binary and works headless in CI too. And the core is written in C#/.NET, which I quite like.
Local-first dashboard showing what your coding agents actually did and what it cost: it reads the session logs Claude Code and Codex already write locally, joins them with work recorded over MCP and presents tokens, estimated costs, tasks and evidence — all on 127.0.0.1, no account, no cloud, no telemetry.
Why it matters: I picked it because it answers the question I hear most from teams adopting agents: “what is this costing me, and what did it actually do?”. And I like the honest design: every number is labeled by provenance and confidence — a passing test is verified evidence, an agent's own claim stays a claim.
xAI's terminal coding agent, now open source (Apache 2.0): a Rust harness with a fullscreen TUI that reads your codebase, edits files, runs commands and extends via skills, plugins, hooks, MCP servers and subagents — interactively, headless for CI, or inside editors via the Agent Client Protocol.
Why it matters: I picked it because it's a rare chance to read the full source of a production agent harness: how context is assembled, how tool calls are dispatched, how skills and MCP servers are loaded. And you can compile it yourself and point it at local inference, all from config.toml.
A Python command-line tool that turns documentation sites, GitHub repositories and PDFs into ready-to-use Skills for Claude (and other LLMs), with automatic detection of the mismatches between the documentation and the real code: in three commands you bring a library's up-to-date knowledge into a Skill.
Why it matters: I picked it because it solves a practical, everyday problem in agent work: giving Claude a library's up-to-date knowledge without pasting it by hand. It scrapes the docs, categorizes them and generates a SKILL.md with examples, while conflict detection flags where the docs no longer match the code.
A tool that gives Claude Code (and any agent) a real browser to drive with Playwright scripts run inside a QuickJS WASM sandbox: pages stay alive across scripts, it connects to your running Chrome or a fresh Chromium, and it offers two control tiers — pixel-level and DOM-id.
Why it matters: I picked it because it hits the right spot in agent work: giving them a browser to test and verify what they build themselves, instead of declaring «done» without looking. And it does it in a measured way — in the author's benchmarks it closes the same task as Playwright MCP with fewer turns and lower cost, keeping the host safe with the sandbox.
A community distillation of how Claude Fable 5 approached problems, packaged as skills any model can run: classify the ask, define what «done» means with an explicit verification, gather evidence, decide, make the smallest correct change, verify by observation and report the outcome honestly. Three words: think, act, prove.
Why it matters: I picked it because it makes a discipline portable, not a tool: the same habits a frontier model applies on its own, written as steps with thresholds a smaller model can follow literally. Its core — verifying work against real output, not the model's self-report — targets the most common agent flaw: the confident «done» that isn't true.
An AI meeting assistant that captures, transcribes and summarizes meetings entirely on-device: Whisper or Parakeet for transcription, Ollama (or a model of your choice) for summaries, with zero audio sent to the cloud.
Why it matters: It records at the system-audio level — no bot joins the call — and works with Zoom, Teams and Meet: the minutes stay on your device, a serious starting point when meeting data can't leave the company. I picked it because it makes «local AI, GDPR by design» concrete.
Autonomous code auditor that orchestrates Claude (and optionally Gemini) to analyze a codebase, trace data-flow, and write a working proof-of-concept for every confirmed vulnerability — no API key required.
Why it matters: It doesn't stop at flagging: eight recursive verification passes and an attacker-control filter prove exploitability before the report is written. It has already led to two public CVEs in Spring AI — a tougher test than any demo.
Official plugin that brings the Compound Engineering method — strategy, brainstorm, plan, work, review, learning note — to Claude Code, Codex, Cursor and six other agents.
Why it matters: Not a single skill but a loop that closes on itself: every /ce-compound writes down what it learned, and the next /ce-brainstorm reads it back. With 23k stars and native support on nine tools, it's one of the most complete attempts to give agent-based engineering an actual method.
Open source React design system built over eight years inside Meta (13,000+ internal apps): 90+ components, StyleX as the styling engine, and a CLI with a JSON manifest built to be read by coding agents too.
Why it matters: The JSON manifest and MCP server turn the CLI into a machine-readable contract: an agent no longer has to guess component props, it reads them from one structured payload.
Go CLI that runs Claude Code or Codex inside a disposable Linux VM: repo mounted in, root in the guest, allow-listed network — while your host files, keys and keychain stay out of reach.
Why it matters: It solves the full-auto dilemma: no per-command prompts and no --dangerously-skip-permissions on your real machine. The boundary is a hypervisor, not a prompt — and if the agent wrecks the VM, destroy && clawk starts fresh.
Rust hook that intercepts AI agents' shell commands and blocks destructive ones — rm -rf, git reset --hard, DROP TABLE — before they execute, with an explanation and safer alternatives.
Why it matters: Anyone using coding agents has risked an unwanted reset --hard at least once. dcg puts a pre-execution guardrail on Claude Code, Codex, Gemini CLI and more: sub-millisecond, 50+ optional packs, one command to install.
Composable skills framework that gives coding agents a complete methodology — brainstorming, planning, TDD, review — with automatic triggers on Claude Code, Codex, Cursor and other harnesses.
Why it matters: Not yet another prompt collection: it's the agent's working method, shipped as a plugin from the official Claude marketplace. I use it every day: brainstorming before code and verification before 'done' genuinely change the results.
Local proxy that translates the Codex API to any provider: Claude, Gemini, DeepSeek, Kimi or a local model via Ollama, inside Codex CLI/App/SDK and even Claude Code.
Why it matters: It decouples the harness from the model: same Codex workflow, your choice of 'brain' — including a local LLM for confidential projects. One of the freshest projects this month: born in June, updated daily.
Everything Claude Code (ECC): an open-source layer of skills, instincts, persistent memory, hooks and security scanning that supercharges Claude Code, Codex, Cursor and other harnesses — 211k+ stars.
Why it matters: It's the most talked-about project in the Claude Code ecosystem: it distills 10+ months of daily use into a reusable system. I find it instructive even just to read, to learn how to structure skills, hooks and rules.
An open-source multi-agent framework that turns the AI coding agent you already run — Claude Code, Codex or a local model — into an autonomous red team: recon, exploit and report on authorized targets, from a browser «War Room» or the CLI.
Why it matters: Flagged to me by one of the most respected IT people I know, and you can see why: benchmark numbers reproducible with one command, keyless/offline use, and serious safety rails (scope containment, a human gate on dangerous tools). Great for grasping where security is heading in the agent era — for your own or authorized systems only.
An MCP plugin that gives Claude Code and other agents semantic search over your whole codebase: it indexes the project in a vector database and returns only the relevant snippets, instead of loading entire files on every request.
Why it matters: It fixes a real Claude Code bottleneck: on large projects the agent no longer has to read whole files to figure out where to act, and — per the authors' evaluation — you get around 40% fewer tokens. It's built by Zilliz (the Milvus team), with 11,800+ stars and active development.
A Python package that gives programmatic access to Google NotebookLM: an nlm CLI and an MCP server with around forty tools to create notebooks, add sources and generate podcasts, videos, mind maps and summaries from the terminal or an AI agent.
Why it matters: It turns NotebookLM into an automatable building block: your agent creates notebooks, imports research and spins up a podcast without opening the browser. And it's an honest vibe-coding case — the author says he isn't a developer — with around 5,100 stars and active development.
Open source alternative to Semrush and Ahrefs: a self-hosted SEO suite (Docker or Cloudflare) for keywords, rank tracking, backlinks and audits, exposing an MCP server and skills so an AI agent works directly on your SEO data.
Why it matters: It brings SEO into the agentic flow instead of leaving it in a separate dashboard: the agent queries real keywords and backlinks via MCP. Self-hosted and pay-as-you-go (data via DataForSEO), with control and predictable costs for SMEs and freelancers.
GitHub's open-source toolkit for spec-driven development: the specify CLI turns a spec into a plan and tasks that AI agents (Claude Code, Copilot, Gemini, Codex) execute, instead of starting from the prompt.
Why it matters: It shifts the center of gravity from the prompt to the spec: you describe what and why, the agent builds from a verifiable plan. A concrete way to bring discipline to vibe coding.
Tool that discovers exposed AI services on a network: it maps reachable model endpoints and LLM services, built for red teams and security assessments.
Why it matters: With LLMs everywhere, forgotten endpoints are the new attack surface: aimap is the first step to knowing what you've actually exposed.
Open-source workspace (formerly MindsDB, now MindsHub Cowork) where you delegate whole tasks — research, reports, scheduled operations — to agents that connect to your data and return publishable artifacts.
Why it matters: Hits the sweet spot for data-conscious SMEs: MIT license, on-prem/VPC deployment and a model router across frontier and open models, to automate processes with no lock-in.
Production-ready development workflows for Claude Code, powered by specialized AI agents for code quality and automation.
Why it matters: A plugin that takes Claude Code from 'assistant' to 'process': useful for borrowing battle-tested workflow and agent patterns instead of reinventing them.
Python utility that converts PDF, Office files, images and audio into clean Markdown, built for LLM pipelines.
Why it matters: If you build RAG or feed agents with company documents, pre-processing is half the job: MarkItDown turns it into one line of code, maintained by Microsoft.
Autonomous cybersecurity agent: pairs a self-hosted LLM (Ollama) with a Kali-style Docker sandbox and a TUI to automate recon and bug bounty — no API keys, no cloud.
Why it matters: The most tangible way to see a local LLM actually work a target: runs offline, sends nothing to the cloud, and shows how to orchestrate security tooling with an agent.
Open-source, locally running MCP server that maps a coding agent's execution plan (Claude Code, Codex, Cursor…) as an interactive flowchart before it writes any code.
Why it matters: Seeing an agent's steps as a graph before it acts is the fastest way to understand — and correct — what it's about to do: fewer surprises, more control.
Coding-assistant skill (Claude Code, Codex, Gemini CLI…) that turns a folder of code, SQL schemas, scripts and docs into a queryable knowledge graph — without sending your code anywhere.
Why it matters: For code-sensitive teams it's the right promise: GraphRAG over the whole repo while staying local, with app code, DB schema and infra in one graph.
Hierarchical document index for 'vectorless' RAG: instead of embeddings and similarity search, the LLM reasons over a tree structure to decide which section to open.
Why it matters: It challenges the 'RAG = vector database' default: no vector indexing, less infrastructure and more traceable answers over long documents.
One command to find which models — out of hundreds, across providers — run on the hardware you have: it weighs RAM, VRAM and format to tell you what's realistic to run locally.
Why it matters: The number-one question for local-LLM users is 'will it run on my machine?'. llmfit answers instantly, without trial-and-error downloads of tens of gigabytes.
Optimized Ollama server setup for Mac Studio and other Apple Silicon Macs: headless configuration, automatic startup, resource tuning and remote management over SSH.
Why it matters: Turns a Mac Studio into your always-on inference server: a ready recipe for hosting local models at home or in the office without days of tinkering.
COOL 
Python
Claude Code
Docker
TypeScript
Markdown
.NET
MCP
Shell
Rust
Playwright
JavaScript
Ollama
React
Go
Apple Silicon
Node.js
Kali Linux