Coding Agents
Plugins, skill layers and runtimes for agentic coding assistants like Claude Code and Codex.

Self-hosted gateway pointing any AI coding CLI (Claude Code, Codex, Cursor, Cline) at 40+ providers, with subscription→cheap→free auto-fallback and tool_result compression for 20-40% token savings.

htop for AI coding agents: every Claude Code, Codex and OpenCode session in one TUI — tokens, context-window %, rate limits, child processes, orphan ports. Read-only, no API keys. Rust.

Live node-graph visualization of Claude Code and Codex sessions — watch agents think, branch into subagents and call tools in real time. VS Code extension or npx web app. Apache-2.0.

Local-first work receipts for coding agents: reads the session logs Claude Code, Codex, OpenCode and Hermes already write and reports what each task did, what it cost, and whether a check proved it.

Persistent memory for coding agents on the iii engine: MCP server with 53 tools, 12 auto-capture hooks, hybrid search + knowledge graph, zero external DBs. Claims 95% R@5 and 92% token cuts.

CLI + agent-skills layer that turns your coding assistant into a Google Cloud agent-lifecycle expert: scaffold ADK projects, run and evaluate them, then deploy and publish to Gemini Enterprise.

36k-star hub of runnable AI engineering tutorials — LLMs, RAG and agent apps as self-contained projects, including build-code-harness: a Claude-Code-style coding harness rebuilt on CrewAI + E2B.

Rust long-term memory server for coding CLIs: lifecycle hooks capture sessions into a sanitized shared wiki, then hand a bounded summary to the next agent so Codex can resume what Claude Code started.

Menu-bar/tray app for macOS and Windows that reads Claude Code, Codex and OpenCode session logs and shows live token spend — per-model pricing with cache reads, plan-limit bars, webhook alerts.

Aider woven into Emacs: AI pair programming with intelligent model selection, Ediff for reviewing AI changes, and file management that stays true to Emacs workflows. MELPA-packaged.

Self-hosted collaboration layer that turns local coding agents (Claude Code, Codex, OpenCode) into an always-on "AI company" — per-agent email, org chart, kanban, shared memory.
Microsoft's dependency manager for agent context — declare skills, prompts, plugins and MCP servers in apm.yml; one install reproduces the setup across 8 clients with lockfile pinning and org policy.
Scriptable skill manager for AI coding agents — install, search, dedupe-audit and security-scan skills across 19 providers, with --json/--yes on every command so agents and CI can drive it.
Karpathy's autoresearch loop as an installable skill for Claude Code, OpenCode and Codex: constraint + mechanical metric + autonomous modify→verify→keep/discard iteration.
Distributed graph issue tracker for coding agents on Dolt: dependency-aware beads replace markdown plans — bd ready/claim/close, cell-level merge, push/pull across machines and agents. CLI + MCP.
One markdown bootstrap file that scaffolds a structured workspace for any coding agent — persistent project docs plus a task tree run through a Think→Task→Execute→Verify cycle with human pacing gates.
File-based durable memory for coding agents: brain-setup scaffolds a BRAIN.md protocol + brain/ directory of decisions, requirements and constraints — plain Markdown in your repo, written via CLI.

npx cc-lens: local analytics dashboard over ~/.claude — sessions with replay, cost and cache breakdowns, insights and budgets, team-adoption mode, a yearly Wrapped card. No cloud, no telemetry.
Visual workflow canvas that exports to the Markdown your agent already understands — design on nodes, ship as skills/agents/commands for Claude Code, Copilot, Codex, Gemini and more.

Local-first dashboard over ~/.claude — sessions, timelines, per-session costs, tool/agent/skill/plugin analytics, live activity via hooks, and ticket linking. No cloud, no telemetry.

Cross-harness session memory: hooks capture what the agent does, an LLM compresses it into observations, and the next session gets the relevant ones back via progressive-disclosure MCP tools.

Claude Code plugin that learns from your corrections — hooks capture them in-session, /reflect syncs approved learnings to CLAUDE.md/AGENTS.md, /reflect-skills mines history into reusable commands.

Local-first cost ledger for AI coding: reads the session files 36 tools already write and breaks every token and dollar down by task, model, project. TUI, web, desktop, menubar — no proxy, no keys.

Desktop cockpit for OpenCode: multi-instance sessions, git worktrees, remote browser access, voice input and a command palette — a workspace for living in AI coding sessions.
Community-maintained Chinese practice guide to OpenAI Codex — learning paths, CLI/App/Cloud/IDE setup, AGENTS.md templates, sandbox/approval safety and team playbooks, published at codexguide.ai.

Local-first CLI + web dashboard for your coding agents — switch providers, browse sessions across Codex/Claude Code/Gemini CLI, share skills, queue tasks, and bridge Codex/Claude to any API.

Zeron: control Claude Code, Codex, Cursor, Grok, Hermes and Pi from a local Rust daemon — sessions live on the device, with optional sign-in to drive them from another machine.

Terminal-first orchestrator for issue-driven AI coding-agent runs — polls Linear/GitHub, runs Codex/OpenCode in git worktrees with retries and verification. Go/Charm rebuild of OpenAI's Symphony.
Anthropic's harness primitives for long-running Claude agents: default-FAIL evidence gates, a fresh-context evaluator subagent and handoff hooks — each one standalone, readable file.
Graph-engineering runtime where TypeScript owns control flow and replaceable coding-agent CLIs — Codex, Claude Code, Pi — do the semantic work inside each node. Pilot for DeerFlow 3.0.
Indexes the session histories your coding agents already wrote — 17 harnesses, months retroactive — and serves recall over MCP. 84.9% hit@1 on LongMemEval-S, no LLM, no embeddings. One Go binary.

Cross-harness 'operating system' for coding agents — 268 skills, 66 agents, hooks, rules, memory persistence, instinct-based continuous learning and AgentShield security scanning. MIT.

Karpathy-style autoresearch on any codebase: /evo:discover instruments the benchmark, /evo:optimize runs tree search with parallel subagents in worktrees. Plugin for Claude Code, Codex & co.
Rust 'software factory' for coding agents: define the SDLC as a graph, agents execute it through verification gates, you intervene only at the stages that matter. Server, runs board, sandboxes.

Hierarchical agent loops: nodes iterate toward a goal in their own git worktree and spawn children for subtasks — the tree grows to fit the problem. Hard caps, SQLite run log, live TUI.
A multi-agent software factory: describe a task, agents plan (PROMPT.md), build, review and merge in isolated worktrees — kanban + graph board, missions, agent chat rooms, any model. Early preview.
General-purpose local AI agent in Rust — native desktop app, full CLI and embeddable API — over 15+ providers and 70+ MCP extensions. Block's goose, now an Agentic AI Foundation project.
Governance-as-code CLI for AI-assisted development: prompts and patches become RFCs, ADRs and work items with executable verification gates — reviewable, traceable, phase-gated delivery.

Context compression layer for agents: squeezes tool outputs, logs, files and RAG chunks 20-95% before the LLM — reversible, local-first; library, proxy, one-command agent wrap, or MCP.

Local-first desktop workbench for orchestrating coding agents: per-repo workspaces, task dispatch, live status and runnable actions — GUI plus CLI, Apache-2.0.

Agent multiplexer for your terminal: every Claude Code/Codex session in real panes — blocked/working/done at a glance, detach and reattach over SSH, plus a socket API agents drive themselves.
Activeloop's shared brain for agent TEAMS: traces from Claude Code, Codex, Cursor & co become reusable skills every teammate's agent can execute — cloud-backed, 25% cheaper on LoCoMo.
All-in-one open-source backend for agentic coding: Postgres, auth, storage, edge functions, model gateway and site hosting — your coding agent operates it over MCP.

Rust coding-agent harness built for footprint: ~28MB per session vs 140-390MB for Codex/Claude Code, instant boot, optional local embeddings — made for running many sessions in parallel.
Reference repo plus npm CLIs (loop-init/audit/cost) for loop engineering: designing scheduled, gated control loops that prompt and orchestrate AI coding agents — Grok, Claude Code, Codex — over time.
Self-hosted LLM gateway wrapping Claude Code, Cursor or Codex with zero code changes — strips unused tools, compresses JSON tool results ~88%, semantic-caches, tier-routes easy work to local models.
Claude Code config pack + optional local harness: TDD-enforcing hooks, 67 skills, quality gates, persistent memory — plus a dashboard routing each task across 13 models by cost-aware blast score.

MCP server that lets a coding agent build and query a typed concept graph of the project — SQLite store, in-process embeddings, merge-conflict resolution and a local web graph explorer.
Zilliz's unified memory for coding agents: one Markdown + Milvus store shared across Claude Code, Codex, OpenCode and OpenClaw — hybrid search, plus repeated workflows distilled into skills.
The 100-line agent from the SWE-bench team: >74% on SWE-bench Verified with no tools but bash, no config sprawl — the reference minimal harness, adopted by Meta, NVIDIA and Ramp.

Unified virtual filesystem for AI agents — mounts S3, Slack, Gmail, Postgres and ~50 backends as one tree so any bash-speaking LLM can grep and pipe across services. Snapshotable, embeddable.

Uncle Bob's strategy as a skill: the agent writes a SPEC you approve, then runs a gauntlet — tests, mutation, property-based, coverage, supply chain — and hands you an evidence report instead of code.
Open-source meta-harness over Claude Code, Codex, Cursor, OpenCode, Hermes, Pi and custom agents: swap harnesses without rewriting, enforce policies and sandboxes, follow sessions from any device.
Alibaba's battle-tested AI code-review CLI: deterministic pipelines + LLM agent, line-level comments, tuned rulesets (NPE, XSS, SQLi) — higher precision than general agents at ~1/9 the tokens.

OpenCode plugin giving coding agents persistent cross-session memory — local SQLite + vector search, automatic memory capture, user-profile learning, and a web UI. Nothing leaves your machine.

Terminal coding agent optimized for low-cost open models — a Rust Codex fork with switchable harness emulation (claude-code, kimi-code, qwen-code…), ACP support and Codex SDK compatibility.

A skill that makes your agent code like the laziest senior dev: YAGNI enforced — ~54% less code, ~20% cheaper, ~27% faster on measured Claude Code sessions. Works with 20 agents.
Self-improving coding/research agent around a Recursive Language Model: persistent IPython as the core tool, programmatic subagents, durable harness state it refines via evidence-backed /refine.
One SQLite store under every Claude Code session: corrections become FTS5-searchable rules that auto-load, research grows persistent wikis, and 37 hook scripts add quality gates.
13 drop-in skills that fix prompt-caching bugs in OSS agent harnesses (Cline, Roo, Continue, OpenCode, Aider) — point your coding agent at the repo, it patches and verifies on the wire.

Open-source, model-agnostic GitHub bot: tag @pullfrog on any issue or PR and your own coding agent (BYOK) runs the task inside GitHub Actions, context via an internal MCP server.

Native macOS menu-bar front-end for CLIProxyAPI: pool your Claude, Codex, Qwen and Copilot accounts behind one local proxy with live quota bars, auto-failover and one-click CLI wiring.
Rust CLI proxy compressing dev-command output 60-90% before your agent reads it — git, tests, linters, docker, 100+ commands; hooks auto-rewrite bash calls. Single binary, <10ms overhead.
The IDE for your coding agent: an MCP toolkit giving symbol-level retrieval, editing, refactoring and debugging over real language servers — or a JetBrains plugin backend.
Package manager for AI agent skills — install from 400K+ skills across 31 sources, auto-translate between 46 agents' incompatible formats, security-scan on install, sync to every agent at once.

Agentic formal verification: coding agents write TLA+ specs and invariants of your distributed system, model-check them, and reproduce violations at code level. arXiv paper + public bug list.

Multi-agent terminal collaboration for AI CLIs: a manager, workers and an inspector — Claude Code, Gemini, Codex, OpenCode — coordinating through one-shot shell commands and SQLite. No daemon.
Claude Code plugin that turns a feature spec into a reviewed PR through a 5-agent pipeline — PA → SWE → Tester → PR-Reviewer → On-Call — with exactly two human gates.

State-machine guardrails for AI agents: define workflow phases once and only that phase's tools unlock — enforced across Claude Code, Codex, Cursor, opencode and Pi. Rust.

Claude Code from any browser via your Tailscale tailnet — streaming chat UI, session history, model switching and cost dashboards; no SSH, no terminal.
Hugging Face's Python port of Pi's minimalist coding agent: a real terminal agent with TUI, sessions and skills — built to be READ, with a clean brain/environment/frontend separation.

A disciplined 3-agent dev process as context files — Architect plans, Builder builds the brief, Reviewer gates — running in one Claude Code session via subagents. Token-frugal by design.
Context-waste hunter for coding agents: hooks compress reads, bash and search output, checkpoint before compaction, and audit waste in configs, skills, MCP and memory — with a local dashboard.

Spec, task and memory layer that lives in your repo: .trellis/ holds conventions, PRDs and journals, auto-injected each session — one workflow across 20 coding-agent platforms.

Executor–verifier orchestration for code changes: a conductor classifies the task, an executor works in an isolated worktree, and a separate verifier must reproduce the evidence — looped to approval.