Applications and tools built with or for Claude Code.
An agent-first CLI fronting 2,000+ AI models, multimodal generation, sandboxed execution, and MCP tooling behind a single API key. Designed to be driven by agents rather than typed by hand. Convenient if you are juggling provider keys, at the cost of routing through one vendor.
Backs up session history from Claude Code, Codex, Cursor, Gemini CLI, Copilot, Cline, and 30+ other agents to Cloudflare R2. Zero dependencies, cross-platform, and append-only — it never deletes prior history. Insurance against losing the transcript record of how something got built.
A single-binary CLI that brokers credentials for AI agents — secrets stay in pass or Bitwarden and are injected into subprocesses at run time instead of landing in the agent's context. Adds DLP pattern rules, OAuth refresh, and structured audit logs for every access. Zero dependencies.
A control surface for a fleet of coding agents running across remote machines, all visible from a single terminal. The differentiator is that it surfaces which agents are blocked waiting on you, so you are not polling sessions to find the stalled one. Useful once you run more agents than you can watch.
A local-first workspace giving an agent team persistent memory plus real tools — files, shell, LSP, MCP, and Office documents. Everything runs on your machine, so no code or documents leave it. Opinionated about the agent roles rather than fully configurable.
Adds coding-agent observability to Herdr with live sidebar cards and lifecycle notifications as sessions start, stall, and finish. Includes a zero-config metrics bridge for Claude Code, so telemetry flows without editing settings. Useful if you already run Herdr as your multiplexer.
A terminal UI that gives you one pane of glass over coding agents running on multiple machines. Instead of tabbing between SSH sessions and tmux windows, you see every agent's state in a single list and attach to whichever needs attention. Still marked WIP, but the fleet-management problem it targets is real for anyone running more than two agents at once.
A local-first macOS terminal that treats coding agents as first-class citizens, surfacing what an agent is doing rather than leaving it buried in scrollback. Also ships Vietnamese IME support, which most terminals handle poorly. Useful if you want agent visibility without bolting a separate dashboard onto your workflow.
Catalogs failure modes that recur across open-source agent projects and backs each one with evidence rather than anecdote. Installs into Claude Code and Codex so the failure knowledge is available while you build, not after you've hit the bug. Aimed at people writing agent harnesses who keep rediscovering the same traps.
Isolates agents in MicroVMs rather than containers, giving kernel-level separation with boot times close to a container's. A stronger boundary than Docker for anyone running agents with permissions skipped. Worth a look if container escape is in your threat model.
Takes a semantic intermediate representation and emits native DrawingML, so the resulting decks are genuinely editable in PowerPoint rather than a pile of images. Ships as a Claude Code plugin, a DeepSeek Harness plugin, and a standalone CLI. Solves the usual problem of agent-generated slides that fall apart the moment a human opens them.
Renders a directory of markdown tickets as a kanban board in your browser, launched with one npx command. Deliberately read-only so it never bloats agent context, with live reload and one-click copy of a ticket path to paste into a prompt. Built after the author's own ticket pile passed 300 files and became unmanageable as flat markdown.
Reads your own local usage counters to show where tokens actually go, then measures the same workload after changes so the savings are a real before/after rather than a guess. Runs locally and privately with no data sent anywhere. The measurement discipline is the differentiator among the many token-counter tools.
One command exposes a long-lived Claude Code session running on your own machine, backed by mirrored auto-reconnecting tmux sessions. Native Android and desktop clients give streaming chat, live session views, push notifications, and permission prompts you can answer from the lock screen. Uses subscription auth, so no API key is required.
A toolkit that lets AI agents build, render, and validate web-based 3D and physical simulations. It gives the agent a way to check that generated simulation code actually renders and behaves correctly rather than just compiling. Niche, but relevant if you point Claude Code at WebGL or physics work.
Sends a native macOS notification whenever a Claude Code session finishes or stops to ask you something, including sessions running on other machines. Aimed at people who run long or parallel agent sessions and keep forgetting to check back on a terminal. Cross-machine coverage is the differentiator over a simple local hook.
Generates a single agent context file for every repo you own, plus a cross-repo service map backed by evidence rather than guesses. Guardrails block agents from reaching credentials, and the docs repair themselves as the code moves. Zero dependencies, and nothing leaves the machine.
Reads Claude Code and Codex CLI logs already on disk to measure token usage and estimate what each session cost. No network calls and no dependencies, so the numbers are computed entirely locally. Useful for finding which sessions quietly burn the most context.
Recreates the Claude Code interface skin for another agent harness, matching the original closely enough that the author calls it a tribute to their vibe-coding days. Cosmetic rather than functional, but a tidy reference for anyone theming an agent CLI to feel familiar.
An installable plugin for Claude Code and OpenAI's coding agent that keeps everything you meant to get back to in one ledger. The point is ownership: the record lives with you rather than inside a session that ends and takes its context with it.
Gives each parallel Claude Code session its own git worktree, ports, environment, and daemons, so two sessions on the same project stop fighting over the dev server. Ships as a single static Go binary with nothing to install alongside it.
A GNOME Shell extension that puts quota gauges for Claude Code, Grok Build, and Codex in the top panel. Each gauge fills as you spend and shows the reset time on hover. Fills the Linux/GNOME gap left by the many macOS menu-bar and Windows tray quota monitors.
An open-source meta-harness that drives Claude Code, OpenAI Codex, and Gemini CLI from one layer. Lets you run the same task through different agents without rewriting your setup for each CLI. Useful if you compare agents or want a vendor-neutral entry point.
Runs several Claude Desktop or Claude Code accounts simultaneously on a single Mac, no virtual machines involved. The mechanism is generic and works for any macOS app. Solves the constant log-out/log-in cycle when you split personal and client work.
An exploratory evaluation harness that measures whether Claude Code holds to its instructions when a repository contains competing guidance. Useful if you maintain large CLAUDE.md hierarchies and suspect rules are being dropped. Research-flavored rather than production tooling.
Captures Claude Code and Codex sessions at the source, recording both the trajectory and a verifiable git environment, then scores each session on grounded x rich x focused. Local, deterministic, and runs no model at capture time. Aimed at people building training data from real agent work.
A persistent AI colleague for Claude Code that manages its own memory and branches and proposes fixes to itself through a gate you approve. Improvements from any copy can be pushed back so every other install benefits. An unusually ambitious take on a self-modifying harness.
Imports message history from Claude Code, Codex, and Reasonix into DeepSeek Harness so a conversation can continue there. Reduces the cost of switching agents mid-project. Niche, but useful if you move between harnesses.
A full-screen terminal plugin that gives DeepSeek Harness a Claude Code-style interface: pixel whale header, live status line, streaming thinking, double-Esc rollback, context progress bar, and a TPS gauge. Installs via npm. Fills a gap DSH has not covered officially.
Renders your running coding agents as a pixel-art city that changes as they work. Local-only mission control, no data leaves the machine. Playful, but a genuinely readable way to see many concurrent sessions at a glance.
A macOS menu bar app that acts as an inbox for Claude Code sessions, showing which one is blocked on you and what it needs next. Solves the problem of losing track of parallel sessions waiting on approval. Straightforward and focused.
An open-source virtual law firm built from AI agents: 183 skills, 181 commands, hard-gated matters, MCP and API intake, and an X402 paid-agent charge matrix with Conway-style agent survival. Output is attorney work-product for licensed review, not legal advice. Notable mainly as an extreme example of skill-system scale.
Controls DeepSeek Harness, Claude Code, Cursor, Codex, or CCC Agent through Lark or WeChat chat messages. Lets you kick off and steer agent work from your phone. Practical for anyone whose team already lives in those chat apps.
A visual editing interface layered over Claude Code. Terse description, but the category is worth tracking as GUI front-ends for the CLI keep appearing. Check the repo before committing to it.
Scans CLAUDE.md, AGENTS.md, and skill files for assertions the codebase has since outgrown, then flags them. Zero-config with no API key required, so it can run in CI. Directly targets the stale-instructions problem that quietly degrades agent behavior.
Turns the MacBook notch into a Dynamic Island for AI coding agents: monitor sessions, approve prompts, and jump straight to the one that needs attention. Keeps session state visible without a window. Nice fit for multi-session workflows.
Brings DeepSeek Harness into Claude Code for review, critique, delegation, and session import. Gives you a cheaper second opinion inside the same session. The reverse direction of most Claude-to-other-agent bridges.
Agent-agnostic guardrails: you load a rulebook that limits what the agent may do inside a repo, then validate its output against those same rules. Turns instructions into enforced boundaries. Works across coding agents rather than just Claude Code.
Notifies you by phone push and email exactly when your Claude 5-hour usage window resets, running entirely on GitHub Actions. No server or daemon to maintain. Small, but it removes a lot of clock-watching.
A persistent task board for Claude Code agents with atomic claims, git-bound commits, AI-written daily reports, and a server so agents on different machines never grab the same card. The atomic claim is the important part for genuinely parallel fleets. More infrastructure than a markdown TODO, and deliberately so.
A native Rust MLX inference server for Apple Silicon serving text, vision, audio, and embeddings behind OpenAI and Anthropic-compatible endpoints. No Python and no GGUF, and it claims the widest weight x KV quantization matrix of any MLX server. Relevant here because the Anthropic-compatible API means agent tooling can point at it directly.
A per-shell environment manager that isolates accounts for Claude Code, Codex, and Gemini CLI, so different terminals can run as different identities. Avoids the log-out/log-in dance when working across clients. Same problem as claude-profiles, solved at the shell-environment level.
A real-time desktop app tracking AI token usage, costs, and model activity, with optimization recommendations. Useful if you want a live view rather than after-the-fact log parsing. Covers multiple providers, not just Claude.
A Claude Code kit for TryHackMe with a fixed methodology (classify, enumerate, foothold, privesc), room-state tracking, ready-made commands, and specialist subagents for CVE research, privilege escalation, and write-ups. It deliberately coaches you through each room rather than solving it. A hands-on alternative to reading write-ups.
A local routing control plane for AI agents and LLM providers with a loopback-only gateway, quota-aware smart routing, and both desktop and CLI apps. Keeps traffic on localhost while letting you steer which provider serves each request. Useful when you hold several subscriptions and want them used efficiently.
Creates multi-repo git workspaces for coding agents so a single agent can work coherently across several repositories. Addresses a real gap, since most agent tooling assumes one repo per session. Agent-agnostic.
Exposes the agent CLIs you already run -- Claude Code, Cursor Agent, OpenAI Codex -- as shared services the whole team can invoke, orchestrated in natural language. Turns a personal setup into shared infrastructure. Worth evaluating carefully for credential and access boundaries.
An opinionated local-first meal planner that is really an experiment in agent-first development: every line written by Claude Opus 4.8 through Claude Code, designed through conversation rather than typed by hand. The app works, but the artifact of interest is the process. Useful data point on no-hand-coding builds.
Dispatches a coding task to an agent running on a disposable Hetzner VM; you close your laptop and the work returns as a pull request. Isolation is a side benefit, since nothing runs on your machine. Costs real money per run, so worth checking the VM lifecycle handling.
Runs several LLM agents on the same task in parallel Docker sandboxes, then has other LLMs judge the results. Uses your Claude Pro, ChatGPT Plus, and Gemini Advanced subscriptions rather than API keys. The generate-then-judge pattern is worth stealing even at smaller scale.
A UCI chess engine written in Zig with no external dependencies, developed with Claude Code. Interesting as evidence of agent-assisted work on a domain with hard correctness constraints and a strong existing benchmark set. Not a Claude Code tool itself.
A local multi-pane terminal that lists your recent Claude Code sessions across every project and resumes each with one click. Removes the hunt for the right directory and session ID. Simple and self-contained.
An assertion harness that runs deterministic checks against `claude -p` stream-json transcripts. Gives automated Claude Code sessions an actual test loop instead of eyeballing logs. Directly useful if you run unattended agent jobs.
Hosts Claude in a PTY and renders a project tree that highlights files as the agent reads and edits them. Makes the blast radius of a session visible in real time. Nice for catching an agent wandering into files it should not touch.
Automatically closes idle AI coding sessions after archiving each one so it can be restored later. Reclaims resources without losing state. Useful if you accumulate abandoned sessions across many projects.
A PyPI library and Claude Code plugin giving agents a second channel beside chat: declarative validated forms, so independent decisions batch into one round-trip instead of twenty questions. Malformed questions are refused at build time and malformed answers at collection time. The Decision construct puts the recommended option first with a rationale and a one-line tradeoff under each alternative.
A local coding-agent platform in one Go binary with plan mode, subagent teams, cron scheduling, memory, and MCP support. DeepSeek-native and MIT licensed. More complete than most agent demos, and the cron support makes unattended runs practical.
Three stdlib-only instruments measuring the fixed overhead your agent setup incurs each session, who burned tokens yesterday, and which paid subscriptions are going unused. No LLM calls and no network access. Worth running if your context bill feels higher than your actual work.
A local multi-agent harness that drives your existing Claude Code and Codex installs as an office of persistent agents, visualized as a sitcom-style office simulation. You act as the boss, or a clone of you orchestrates while you are away. Open source and free.
A local-first control plane tying together coding agents, git worktrees, and tmux sessions. Worktrees plus tmux is the standard manual setup for parallel agent work, and this makes it managed. Nothing leaves your machine.
An open-source browser toy where webcam hand-tracking lets you squeeze soft butter, crack the wax, and watch crumbs fall on their own. The build method is the interesting part: one chat wrote no code at all and only tracked the project, chose the next step, and wrote instructions for a fresh chat to execute. A manual version of the orchestrator pattern.
A framework combining session observability with governance across multiple Claude Code plugins. Relevant once you run enough plugins that their interactions stop being obvious. Check the repo for how much of the governance is enforced versus advisory.
A runtime layer for Claude Code, Codex, Cursor, and MCP that aims to reduce token spend and duplicated effort. It keeps model traffic cache-stable, adds context compaction with crash resume, serves repeated calls locally, applies a fast tool policy, and can run local GGUF inference. Worth a look if long sessions are burning through your budget.
A control plane for running many coding agents at once, built around the idea of standing orders — persistent instructions that tell agents when they may proceed on their own and when to escalate. The pitch is "wake me only for these," so you review exceptions instead of every step.
A Claude plugin that watches for the failure modes agents fall into and intervenes. It targets attention drift, overthinking, recursive reasoning, compulsive verification, scope creep, retry loops, deadlocks, context waste, and the classic failure to stop once the task is done. An unusual framing of guardrails as executive function.
A tool that converts things you save while browsing into local memory an AI agent can consult, scoped to the project you are working in. Everything stays on your machine. Aimed at closing the gap between "I read something useful last week" and the agent knowing about it.
A shared memory layer for AI coding agents, letting context persist and be read across agents rather than living inside a single session. Aimed at the recurring problem of agents re-deriving the same project knowledge every run. Note that several unrelated projects use the "cairn" name — this is czearing's.
A macOS menu bar utility that watches Claude Code and holds a system-sleep assertion only while a turn is running, then releases it so the machine sleeps normally. Avoids both a laptop that dozes off mid-task and one left awake all night. Runs entirely locally with no API key or account.
A Mixpanel library and CLI exposing discovery, querying, and data extraction programmatically, explicitly designed with coding-agent use in mind. Claude Code can explore event schemas and pull analytics without touching a browser dashboard. Handy for letting an agent answer product-metrics questions directly.
A CLI plus MCP integration for FluidDocs, a platform where published documents stay interactive — readers ask the document questions and it answers from its own content, then reports who opened it and what they asked. The CLI is built for unattended agent use: --json on every command including errors, a flat command namespace, and old command names kept as aliases so stale prompts do not break. Roughly half the documents on the platform are already agent-created.
Built by a developer whose workflow is spawning 10-15 agents daily for research, code and tests, and who found the gap is not the building but the checking. Wiring Playwright into Claude Code rarely caught real bugs, because the agent is optimistic — green builds, passing tests and clean CI read as success while users hit breakage in production. The tool aims to make agents actually see and judge what they shipped rather than trust their own signals.
Teaches an agent to use Telegram as a real output surface rather than a plain text sink — native rich messages with tables, LaTeX and collapsible blocks, plus a live progress window for Claude Code sessions. Bundled with a field guide of hard-won pitfalls from the Telegram Bot API, which is where most homegrown integrations lose time. Documentation is bilingual Chinese/English.
A localization pack that translates the Claude Code VS Code extension into Traditional (Taiwan) and Simplified (mainland China) Chinese. It auto-detects the editor locale or lets you switch manually from a status bar quick menu, applies idempotently so repeated runs are safe, and flags untranslated strings so gaps in coverage surface instead of silently persisting.
A miniature agentic AI developer platform for AWS that treats QA as part of the scaffold rather than a later addition. One command produces a governed agent already wired with evals, guardrails, tracing, and a CI quality gate that fails closed. Useful as a reference for what a production-minded agent baseline looks like on AWS, not just a hello-world starter.
A standard for figures that keeps one source serving two readers — the agent parses plain Markdown-native text, the human sees a deterministically rendered SVG. This sidesteps the usual failure where a diagram is an opaque image the model cannot reason about, or an agent-readable format that looks terrible to people. Deterministic rendering means the same source always produces the same figure, so diagrams diff cleanly in git.
An issue tracker designed around the assumption that both people and agents will read and write the same backlog, rather than bolting agent access onto a human-first tool. The name reads as To-Do and sounds like the Mandarin word for potato. Worth a look if your agents keep losing track of multi-session work because the task state lives only in chat scrollback.
A memory layer for coding agents that keeps everything local and requires stored memories to be backed by evidence rather than accepted as free-form assertions. The evidence requirement targets the common failure where an agent confidently recalls something from a prior session that was never true, or is no longer true. Continuous capture means memory accrues during work instead of at explicit checkpoints.
The reference harness accompanying Appendix A of the book Agentic Programming, published as runnable code rather than book listings. Useful mainly as a readable, self-contained example of how an agent loop is structured when it is written to be taught rather than shipped. Note the repo name and description disagree on the level number, so read the code rather than the label.
Connects two Claude Code sessions — typically your laptop and your VPS — so they coordinate natively over Remote Control instead of you relaying context by hand. File transfer runs over SSH with end-to-end checksum verification, so a truncated copy surfaces as an error rather than as a mysterious downstream failure. Free and open source.
A distributed cache of coding solutions built from two ingredients: anonymous compatibility evidence gathered from real environments, and verified minimal samples for coding LLMs. The premise is that the same version-and-platform puzzle gets re-derived from scratch by every agent, every time, and that evidence from real runs beats the model guessing. Local-first, so your own cache works before any sharing happens.
Lets Cursor, Claude Code, Codex and Grok sessions running on one machine hand work to each other through a local mailbox. The README is explicit that this is not Slack for agents — it is a work-passing primitive, not a chat channel, which keeps the semantics narrow enough to be reliable. Useful when you keep several tool-specific sessions open and want them to cooperate.
Adds a deliberation step before an agent commits to an answer, structured as three distinct seats that argue the decision out. It targets the pattern where an agent makes the same class of mistake repeatedly across sessions because nothing forces a second look. One-line install, runs locally and privately, and supports Claude, Cursor, Windsurf and roughly twenty other agents.
A Polish-language desktop working environment that puts an editor, multiple terminals, a knowledge graph and skill panels into one window alongside Claude Code. The pitch is avoiding the constant window-switching that comes with running an agent, a shell and your editor as separate apps. Interface and documentation are in Polish.
promptie captures knowledge from Claude Code sessions on the premise that disagreement is data, recording the moments where you and the agent diverge. It is write-only by design, so capture never turns into a maintenance burden. Zero dependencies keeps it easy to drop into any project.
lich is a terminal-first harness for working with coding agents that runs them on real PTYs rather than pipe-based wrappers. Git worktrees keep concurrent agents isolated from each other. Diffs and pull requests live in the same window, so review does not mean switching to a browser.
A guided macOS installer that sets up a hand-picked set of Claude Code companion tools in one pass. Aims to be safe and interactive rather than a blind bulk install. Handy if you rebuild machines often and want a reproducible tooling baseline.
Gives coding agents a master memory inherited everywhere plus an independent memory and persona per project directory, with controlled cross-agent handoff. The core is host-neutral with per-agent adapters (Pi first, Claude Code and Codex planned). Solves the problem of one global memory file bleeding irrelevant context into every project.
A reverse-engineered, deobfuscated dump of the official @anthropic-ai/claude-code npm package at v2.1.76, spread over 1,902 TypeScript files. Useful for understanding how the harness actually implements tools, hooks and permission checks. Treat as a read-only reference — it tracks one specific version and will drift.
An attention-first board for supervising background Claude Code agents, using GitHub issues as the backlog. Self-deploying with zero dependencies. Surfaces the agents that need you rather than making you poll every session.
Exposes your AI agent through a team chat surface so colleagues can talk to it without a terminal. Supports Rocket.Chat, Claude and Opencode backends. Set up is pitched as a minutes-long job.
Written by someone running 10-15 agents a day who found that agents cannot judge their own output — builds pass, tests pass, and the app is still broken. Argues Playwright wiring alone does not catch this because Claude is optimistic about what it sees. Describes the tool built to close that verification gap.
Checks for and installs updates to Volta-managed npm developer tools including Claude Code, Codex and OpenCode. Ships a macOS app, a CLI, and a launchd scheduler so it runs unattended. Small utility for people who keep falling behind on agent CLI releases.
A quality gate for Agent Skills that lints structure, runs a security audit, and checks compatibility across Claude, Cursor, Codex and OpenCode. Run it before publishing a skill so it does not silently break on another host. The cross-host compatibility check is the part most skill linters skip.
Audits your installed agent skills for conflicts, duplicates and safety risks, all locally. Aimed at the mess that accumulates once you have installed skills from a dozen sources. One of several independent takes on skill auditing — compare with the other skill linters on the board.
Turns vague requests into living MDX specifications, then reviews PRs or working-tree code in focused, durable chunks with repository-aware explanations. A browser-to-agent question loop lets you ask follow-ups on a chunk without losing your place. Tackles the 'reviewing a 2,000-line agent diff' problem directly.
A Kobiton plugin that lets Claude Code, Copilot CLI, Gemini CLI, Cursor CLI and Codex manage devices, upload builds, run mobile automation and read test results without leaving the workspace. Vendor-specific but a concrete example of wiring a device cloud into an agent workflow.
Replays past sessions, reconstructs what the context window actually held, reports usage diagnostics, and makes guarded edits to ~/.claude. Runs locally. The context-window reconstruction is the standout feature for anyone debugging why a session went sideways.
Validates a SKILL.md and installs it into Claude, Codex, Cursor, Gemini, Grok and Copilot in one step. Removes the manual copy-into-each-agent-directory step when you maintain skills across hosts. Small, focused tool.
A unified view for managing every terminal and AI coding agent you have running, instead of hunting through tmux panes and terminal tabs. Useful once you routinely have several agents going at once.
A context-budgeted store of tools you might use someday, so the agent checks your prior verdict before recommending something you already looked at and turned down. Small idea, real annoyance solved. The context budget keeps it from swallowing your window.
Switches between logins, tracks quota usage, and rotates accounts before you hit a rate limit. Aimed at people who juggle personal and work subscriptions. Check your provider's terms before automating rotation.
Gives multiple AI agents a single controlled entry point to your models: manage provider accounts in one place, switch upstreams without reconfiguring each agent, localize failures, and trace token spend back to a specific session. Chinese-language docs. Useful once you have three agents each with their own API config.
A lightweight control plane that reuses the native CLIs already on your machine and lets you compose different providers and models per scenario. Chinese-language docs. For people who want a cheap model on grunt work and a strong one on the hard parts, without maintaining separate configs.
A vendor-neutral marketplace covering Claude Code, Cursor, Copilot and AGENTS.md formats. Portuguese-language project. Another entrant in the skill-discovery space, notable for not being tied to one agent.
Lets any coding agent @-mention any other across vendors and devices, with no cloud involved. Runs over your LAN. One of several answers to the multi-agent coordination problem, distinguished by the zero-cloud, cross-vendor stance.
A memory layer that plugs into any platform in one line, keeps data local by default, and can trace a remembered fact back to its origin. Chinese and English documentation. The traceability is what separates it from a plain fact store.
Finds every instruction file the agents in your repo are reading, explains what each one actually asserts, and validates them against each other. Useful once CLAUDE.md, AGENTS.md and a pile of rule files have accumulated and nobody knows which one wins.
Retries Claude Code through subscription rate limits, API overload responses (529/5xx) and safeguard false positives, waiting for the reset time Claude prints and backing off exponentially. tmux-based. For long unattended runs that currently die on a five-hour limit.
Lists your installed skills grouped and searchable in the VS Code sidebar, one click from the source file, instead of leaving them forgotten in a folder. Addresses the real problem that installed skills are invisible until you remember they exist.
A from-scratch Conductor-style multi-agent workspace GUI for Windows and Linux, AGPLv3, with no workspace cap or paid tier. The author built it using itself over four weeks — 132 commits and 79 merged PRs written by agents with every diff human-reviewed.
A personal AI ops platform that pipes Claude Code telemetry through an OpenTelemetry Collector into Prometheus and Grafana, plus a status API. Deploys to Railway behind a Cloudflare Tunnel, so you get session dashboards without exposing anything publicly.
Treats agent skills like dependencies: agpm sync writes harness.json (what is approved) plus harness.lock (sha256 per file), and agpm check fails CI when on-disk files drift from the approved set. The PR that changes harness.json is the approval, so marketplace skills cannot silently change your agent's instructions.
An iPad terminal built because no existing app offered iTerm2-style tmux integration — cmd+1-9 tab switching, cmd+d pane splits, mosh and plain ssh, plus remote file management with a tree that tracks your pwd. Practical for driving a Claude Code session on a desktop from the couch.
An agent kit that interviews you about a booking domain and generates a full reservation SaaS: AI storefront clerk chat, admin dashboard, and lifecycle emails on Convex plus Next.js. A concrete example of scoping agent codegen to one vertical instead of general scaffolding.
An open-source spatial IDE for managing agents running in native CLIs, terminals, git repos, beads issues, and files spanning multiple projects and machines. Self-host on localhost, spread across a cluster over Tailscale, or use the hosted option.
Mines Claude Code, Codex, and ChatGPT transcripts for insights worth keeping, turning throwaway sessions into a reusable knowledge base. Targets the common failure where the same problem gets re-solved from scratch in every new session.
Durable memory shared across repositories for both GitHub Copilot and Claude Code. Markdown files stay the source of truth while a SQLite graph index provides retrieval, and it ships with zero runtime dependencies.
A self-hosted tracker for internships, jobs, programs, and scholarships that doubles as a Claude/Codex skill, so your agent updates it from your inbox and tailors your resume per posting. Next.js 16 plus Supabase, deploys to Vercel.
A deliberately thin Telegram bridge that forwards tasks to whichever coding agent is already installed locally, rather than reimplementing a runner. Minimal setup if you just want to fire off work from your phone.
A single TUI for managing Agent Skills, hooks, plugins, and MCP servers across Claude Code, Pi, and Codex. Useful once your configuration is spread across several agents and you have lost track of what is enabled where.
A community-built Visual Studio 2026 extension implementing the IDE half of Claude Code's integration protocol. Provides a native diff view with accept/reject, Roslyn-powered code navigation, and Test Explorer integration, plus a live debugger Claude can drive autonomously. Useful for .NET developers who want agentic coding without leaving Visual Studio.
A Microsoft Teams channel plugin that lets you chat with a running Claude Code instance from Teams, mirroring the official Telegram and Discord channel plugins. Built on the Microsoft Agents SDK with pairing codes, per-channel opt-in, tenant/AAD access checks, inbound and outbound files, and permission prompts relayed back into Teams. Setup needs real Azure provisioning, but ships a runbook and an agent-assisted setup prompt.
A benchmark harness that scores coding agents on tasks drawn from your actual repository rather than a generic public suite. The idea is that leaderboard numbers say little about how an agent performs in your code, so you measure locally. Handy when choosing between Claude Code configurations, models, or competing agents.
A local-first ledger that tracks token usage and spend across AI coding tools, wired up with a single environment variable so it covers all providers at once. Built in Go with Tauri 2 and MIT licensed, with bilingual English and Chinese docs. Everything stays on your machine rather than going through a hosted dashboard.
A native macOS app that organizes Claude Code work into projects and tabs, with a tree of terminal panes, live agent statuses, and a command palette. It targets people running several sessions at once who want a real window manager instead of a wall of terminal tabs. Note this is a different project from the similarly named roost agent-collaboration tool.
Claude Code packaged for NixOS together with an Anthropic-compatible local proxy, so the CLI can be pointed at alternative model backends. Useful if you run NixOS and want a declarative install plus the freedom to route requests elsewhere. Expect the usual caveats of proxying a first-party client.
VelaTerm is a terminal workspace for driving AI coding agents that has now been released under an open-source license. The maintainers are inviting pull requests and have a roadmap covering standalone chat views, cross-agent conversation and knowledge sharing, and a mobile client.
A CLI that exposes Microsoft Teams chats to the terminal: read, reply, react, search, and manage unread state. JSON output makes it scriptable and usable as a tool surface for coding agents.
Adds an animated desktop pet that responds in real time to what Claude Code is doing. Runs as a Windows app or a VS Code extension, with support for custom spritesheets.
A macOS menubar app giving one cross-terminal view of every running Claude Code session and its current status. Solves the common problem of losing track of which window is waiting on input.
A local-first desktop workbench that collects scattered AI-CLI sessions, projects, tasks, and documents from Claude Code and Codex into one place. Built on Tauri v2, React 19, and Rust, with all data staying on your machine.
A full persistent-memory plugin for Claude Code combining hooks, a skill, an MCP server, and workflows over a Markdown vault you own outright — no server, no account. A lighter hooks-only variant ships separately as continuum.
An open interoperability layer that lets different agents and harnesses connect and work together rather than each running in isolation. Aimed at people who mix several coding agents in one workflow.
A local proxy router connecting Claude Code, Cursor, Codex, and other coding tools to a wide range of model providers. Features include RTK prompt compression, automatic fallback between provider tiers, multi-account round-robin, and a local usage dashboard.
A high-performance local inference server for Apple Silicon built on native MLX, exposing both OpenAI- and Anthropic-compatible APIs. Supports continuous batching, multimodal models, MCP tool calling, and can back Claude Code directly.
Builds evolving knowledge spaces for AI agents using an LLM-generated wiki, knowledge graphs, and agent workflows. Local-first, so the knowledge layer stays on your own machine.
A local-first live view of your AI subscription quotas alongside local token spend, available as a dashboard, a CLI, and a Windows widget. Updates silently with zero telemetry.
Indexes a repository once and serves a shared local knowledge graph to every agent, so parallel sessions stop burning tokens rediscovering how the codebase fits together. Each session still runs in its own git worktree.
Records every Claude Code session so you can tell when one died, resume it with full context intact, and get warned when a session is not being saved at all. Aimed at long unattended runs where a silent crash otherwise loses everything.
A local management tool that turns a fresh machine into a working, repeatable AI agent setup without hand-editing a pile of tool-specific config files.
An open-source agent harness that plans tasks, runs tools and skills, and evolves using memory and an accumulated knowledge base. Multi-model and multi-channel with a one-line install; formerly known as chatgpt-on-wechat.
Moves working context between Codex and Claude Code over an encrypted channel, so switching agents mid-task doesn't mean re-explaining the problem.
A macOS menu bar app showing live Claude Max usage so you can see how much of the current window you've spent without opening anything.
A two-way bridge between Telegram and an AI CLI running inside tmux, driving Claude Code or Codex by injecting into the TUI pane rather than calling an API. Lets you steer a session from your phone while it runs on your own machine.
A Claude Code status line component counting down how much time is left on your prompt cache, so you know when the next turn will pay full price for context.
A live status line that prices each turn as it happens, including subagent calls and cache rebuilds, alongside usage limits, context state, and git info. Built to make token leaks visible while they're happening rather than after the fact.
An unofficial mobile web interface for the Xirp agent daemon covering machines, projects, sessions, and a live tmux pane view.
A Claude Code status line reporting live cost against configured budgets, with per-model usage breakdowns.
Lets you trigger a coding agent on your home machine from Feishu, with two-stage confirmation before anything executes. Fully self-hosted with zero dependencies, and Telegram is supported as well.
The context counter only appears once roughly half the window is gone, and clicking it fires /compact with no confirmation. This patch adds a third composer button: a ring that fills as context does, with a live token count updating while Claude types, and clicking it runs /context instead. Implemented as a webview bundle patch because the composer toolbar exposes no extension point.
A decision-support system for a fantasy football league built from slash-command workflows, league scoring rules encoded explicitly, quantitative models trained on six seasons of raw data, and deterministic validators over the outputs.
A browser-based workspace for running Claude Code and Codex, built for long tasks you supervise rather than watch. Sessions carry across desktop, tablet, and phone.
One command to bring up several Claude Code sessions side by side in tmux, with stacked agent panes and a single Ctrl-Shift chord scheme for moving between them. No daemon involved.
A working Databricks build for an energy distributor's customer service area — medallion architecture, dashboard, and a conversational copilot — constructed with Claude Code and the AI Dev Kit skills. Documentation is in Portuguese.
A from-scratch WebAssembly 2.0 interpreter in Rust, built end to end by an AI agent from a single spec input. It passes the full official test/core suite for wg-2.0 across 54,006 commands with zero failures, using fail-closed accounting, the official reference interpreter as an oracle, and six rounds of external review.
An MIT-licensed harness running Claude Code headless against a live Unreal Engine editor, given the open-ended goal of building a GTA-style city. It picks districts, roads, buildings, people, cars, and weather on its own, running in loops overnight — and since it forgets everything between sessions, it writes notes to its future self and builds its own tools when the available ones fall short.
A free macOS menu bar app that prevents sleep while Codex, Claude Code, OpenCode, or other long-running work is in progress.
A Hugging Face project giving agents durable, searchable memory of their previous sessions, so past work is retrievable rather than lost when a session ends.
A control plane for running Claude Code across many repositories. It adds personas — role identities such as release or forge, each with committed memory and a scoped credential vault — plus per-task isolated workspaces so parallel work on several repos doesn't bleed together, and a vault that keeps credentials out of the transcript entirely.
Puts the actual source of your dependencies in front of a coding agent instead of leaving it to guess at APIs from memory.
A dashboard for watching and controlling Claude Code agents running locally, with real-time status across sessions.
An agentic system built with Claude Code, Shopify, SendGrid, and Buffer that monitors inventory, judges how urgent each stock situation is, and launches multi-channel marketing campaigns in response.
Assigns each git worktree its own creature in the coding agent's status line, with deterministic species and rarity bands, plus one view across every live session.
A tmux multiplexer wrapping the official coding CLIs, using a knowledge graph as the shared substrate between sessions. Successor to cipher-mux.
A Claude Code status line renderer written in Rust showing model, active task, directory, and a context gauge that warns you before auto-compaction hits.
An open-source Markdown workspace designed around agents, letting you run Claude Code and other terminal coding agents right next to your editor. Available for macOS and Windows.
A macOS app that gives every task its own git worktree, branch, and Claude Code session so agents run genuinely in parallel — and lets you stack them when one piece of work builds on another.
Meters your Claude and Codex subscription windows, attributes spend to specific projects, and decides which agent is allowed to dispatch right now. Admission control rather than after-the-fact reporting.
A free, open-source coding-agent harness testing whether the harness matters as much as the underlying model. It treats the repository as a graph — and increasingly the agents too: a primary orchestrator decomposes work across coder, explore, researcher, scout, and reviewer agents that can communicate with each other rather than running as isolated subprocesses.
A Claude Code plugin turning any video into a readable digest: a timestamped contact sheet and a transcript synced to frames, with no hallucinated captions over silent stretches. Runs on ffmpeg plus local Whisper, so nothing leaves the machine and no API keys are needed.
Treats AI agents like employees: each gets an identity, an isolated sandbox, brokered credentials, a backlog, and a place in an org chart, all under central guard rails. Ships as one Go binary plus Postgres, self-hosted.
A memory system for agent harnesses that stores memories as distributions with mean and covariance rather than fixed text, merging them with a Kalman filter and retrieving via Bhattacharyya distance with spreading activation.
A Claude Code plugin from Weights & Biases that pipes session activity into W&B Weave. Every tool call and subagent invocation becomes a trace you can inspect, so you can see where a long agent run actually spent its time. Useful if you are debugging flaky autonomous sessions rather than guessing from terminal scrollback.
A terminal UI that multiplexes multiple AI agent sessions into one pane-managed view. Instead of juggling tmux windows by hand, you get a single surface for launching and switching between concurrent agents. Fits the parallel-agent workflow where several tasks run at once.
A Japanese-language app (AI HACK 2026 entry) that turns a conversation directly into task management, layering a kanban board over a chat thread. The design rule is deliberate: the AI suggests cards and moves, but only a human commits them. An interesting take on keeping a person in the loop without slowing the conversation down.
A CLI that loops an LLM to generate startup names and checks real domain availability over RDAP, feeding taken/available results back into the next round. It runs on a Max subscription by shelling out to headless claude -p and strips ANTHROPIC_API_KEY from the subprocess env so it cannot silently switch to API billing. The write-up's real payload is two nested-claude bugs: child processes inherit CLAUDE_CODE_EFFORT_LEVEL from the parent session, which made every subprocess think for 8+ minutes and time out.
Instead of calling an image model, you have Claude Code or another agent write HTML that gets rendered into App Store, Google Play, Chrome Web Store, and social images and video. The author argues the output looks more natural and costs less than generated imagery. Open source and free.
Nomai is a Linux tiling window manager built specifically for running terminal AI agents side by side instead of juggling separate terminals and scattered configs. It runs Claude Code and Codex under your actual logged-in accounts rather than raw API keys, and adds multi-account switching and safer execution. The author is recruiting early testers.
spendwatch ranks where your tokens and dollars actually go across coding agents, broken down by tool call, command and prompt. The point is actionability: seeing which repeated operations dominate spend tells you what to automate away or fix. Covers both Claude Code and Codex.
Turns a plain-language description of Excel tools into a .xlam add-in with its own ribbon tab, plus a single self-installing .xlsm that colleagues open once and click. Designed to be driven by an AI assistant, with the spec validated against the generated VBA source before Excel is ever launched.
A Claude Code plugin that converts a data file into a self-contained interactive HTML experience, with switchable design identities so the same data can be presented in different visual styles. Single-file output makes it easy to share or embed without a build step.
A local-first knowledge vault that agents read from and write to, so context survives across sessions instead of being rediscovered every time. The pitch is token savings plus more consistent behavior — the vault carries the conventions and decisions the model would otherwise have to re-derive.
A small tool for inspecting agent session data and metrics, built so it can be pointed at agents beyond Claude when needed. Worth a look if existing dashboards are heavier than what you want for basic visibility.
A desktop IDE built around coding agents rather than editing: run Claude Code, Codex and Gemini CLI across all your git repositories from a single window. Aimed at people who keep many repos in flight and want one surface for agent work instead of a terminal per project.
A bidirectional proxy that pseudonymises data flowing from Claude Code to the Anthropic API and restores it on the way back, so identifiers never leave your network in the clear. Built by France's SocialGouv, which suggests it is aimed at real compliance requirements rather than being a demo.
A local-first control plane for managing coding agents, kept open source and off any hosted service. Fills the same slot as commercial agent dashboards for people who want the coordination layer running on their own machine.
A plugin that runs a product-leadership job search end to end: finding open roles, scoring fit, tracking the pipeline, running live interview practice, and acting as a blunt career coach. Markdown by default, with an optional browser dashboard and MCP integrations layered on top.
A component gallery and library for building terminal UIs for CLI agents — charts, controls, and a neomorphic agents kit — built on @opentui/react. Handy if you are writing your own agent front end and want it to look like Claude Code or opencode rather than raw scrolling text.
An open set of evaluation tasks for AI agents, skills and tools — each with inputs, expected outputs and a judge — so any candidate solution can be scored and ranked on trapstreet.run. Fills a real gap: most skills ship with claims but no way to measure them.
A public plugin marketplace of installable Claude Code skills and agents, added with a single command. Worth browsing if you would rather pull capabilities in on demand than maintain your own collection.
Manages git worktrees for coding agents on top of tmux, so several agents can work on isolated checkouts of the same repo with a pane each. Lightweight compared to desktop agent managers — it leans on tools you already run in the terminal.
Local-first persistent memory for coding agents, stored as Markdown files in the repo with no server involved. Each memory is tied to evidence from the codebase, so context carries across sessions without drifting into unverified claims.
Wraps Claude Code for non-developers, hiding the parts of the workflow that assume you are a working engineer. Aimed at people who want the agent to do useful work in a repo without first learning the developer tooling around it.
Exports your Pieces Long-Term Memory into an AGENTS.md file that coding agents can read directly. Runs entirely locally and takes a redaction-first approach, so captured history gets scrubbed before it lands in a file that agents load.
A desktop app for installing, syncing, and managing agent skills across multiple tools from one place, covering Claude Code, Cursor, and Codex. Useful once your skill collection outgrows hand-copying directories between projects and assistants.
A Claude Code plugin that adds Gemini-backed validator, challenger, researcher, and summarizer subagents, plus hooks that invoke them automatically. Gives you an independent model challenging Claude's conclusions at points you choose rather than only when you remember to ask.
A Python script that reads one long-lived document (CLAUDE.md, a spec, a design doc) and prints where it contradicts or repeats itself. It reports "wormholes" (far-apart passages saying the same thing, with both ends quoted and the shared lemmas), "seams" (adjacent sentences that force a mental jump, or distant ones that blend together), and a drift score over every sentence pair. Useful if your context docs have accreted months of appended rules that now disagree with each other.
Wraps nvim and AI agents together so agent sessions run alongside your buffers instead of in a separate terminal. Targets people who want the agent loop inside their existing Neovim workflow rather than switching windows to a CLI.
A walkthrough of using Claude Code with Opus 5 to build a self-contained HTML page for researching care options for an aging parent. Covers scraping a lead-generation directory, merging in government ratings and costs, and turning it into a sortable comparison tool. A useful example of throwaway personal tooling that would never justify a real project.
A terminal UI for managing sessions across multiple coding-agent CLIs and accounts from one place. Handles Codex, Claude, Antigravity, and Ollama. Useful if you juggle several agent subscriptions or profiles.
Runs each git worktree inside its own Lima/vz microVM with an in-VM dockerd, so parallel coding agents never fight over ports, databases, or container images. New worktree VMs can be seeded from existing ones with their database data intact. Positioned as an open-source alternative to Docker Sandboxes.
A desktop pet for Linux rendered from codex-pets.net sprite packs that animates based on what your Claude Code session is doing. Idle, thinking, and working states each get their own behavior. Pure fun, but a surprisingly readable ambient status indicator.
A task tracker designed so a person and an AI agent can both read and write the same list without clobbering each other. Everything stays local, with no server or account. Fills the gap between ad-hoc TODO comments and a full issue tracker.
A starter template for a Slack bot that runs Claude Code sessions triggered by mentions or direct messages. Gives a team a shared entry point to an agent without everyone needing terminal access. Documentation is primarily in Korean.
A tmux plugin that detects the live state of every Claude Code pane and surfaces which one is actually waiting on you. Includes a dashboard and cross-project messaging between sessions. Solves the core problem of running many agents: knowing where to look next.
Wraps Claude Code behind an OpenAI-compatible HTTP endpoint, packaged as a Docker container with a full FastAPI surface. Handles text, images, audio, video, and file inputs. Lets existing OpenAI-SDK apps point at Claude Code with no client changes.
Keeps a single source of truth for agent instructions and compiles it out to CLAUDE.md, AGENTS.md, .cursor/rules, and other formats. Removes the drift that comes from hand-maintaining the same rules in four files. Practical for teams using more than one coding agent.
A statusline renderer that packs model, cost, context usage, rate limits, tokens, and active agents/tools/todos into three or four ANSI lines. More information density than the default single-line statusline. Configurable layout per line.
Combines SAST, secrets detection, SCA, and AI-specific security checks across ordinary repos and AI-agent artifacts like skills, plugins, and MCP servers. Reads code but never executes it, so scanning an untrusted skill is safe. MIT licensed.
Renders web pages directly in the terminal you already have open, with no separate window. Handy when an agent session and browsing need to share the same screen. Early-stage but functional.
A curated marketplace collecting every plugin, skill, and tool one developer ships for Claude Code and Codex CLI. Also hosts an idea-nursery where early macOS tools incubate before getting their own repo. Useful as an example of packaging a personal plugin catalog.
A free presentation and poster maker exposed as a plugin for Codex, Claude Code, and Cursor. Generates editable decks, posters, and social graphics rather than flat images. Output stays editable after generation.
A deterministic scanner that inspects an agent skill for prompt injection, hardcoded secrets, unexpected network calls, and malware patterns before you install it. Runs entirely local and offline, and never executes the skill it is analyzing. Rule-based rather than model-based, so results are reproducible.
A Claude Code plugin for workshops and presentations that generates self-contained HTML decks on a consistent design system. Also produces soft flat SVG visuals — flowcharts, architecture diagrams, wireframes, mindmaps, org charts, sequence diagrams, Gantt and kanban boards, journey maps — and exports decks to print-ready PDF. Everything stays as files you can edit.
Supervises several Claude Code sessions at once and highlights which one is blocked waiting on human input. Presents them as a single mission-control view. Same problem space as tmux-based attention managers, with a standalone UI instead.
An AI-native workbench for workplace communication coaching built as one router plus eight expert agents and nine reusable skills. Includes a deterministic two-front security gateway combining a prompt-injection filter and a hallucination gate. Apache-2.0 with no third-party dependencies.
A server-side daemon plus chat extension that keeps Claude Code sessions alive in VS Code and code-server across browser reloads. Solves the specific pain of losing a long-running session when the tab reconnects. Aimed at remote and containerized development setups.
Routes Telegram, WhatsApp, Slack, Discord, GitLab, cron jobs, webhooks, and mesh tasks to AI agents backed by Claude, OpenAI, or any LLM. Ships a web wizard for non-technical operators alongside a CLI for engineers. Fully self-hosted and aimed at small and medium businesses.
Analytics for AI coding agents that reads only official interfaces and keeps each reported number linked to the evidence behind it. When data cannot be collected it says so rather than displaying a misleading zero. Runs local-first.
Searches across sessions from multiple AI coding agents so switching tools does not mean losing your history. Runs local-first with no upload. Answers the recurring 'I solved this before, but in which agent?' problem.
A web-based client offering complete interactive functionality for managing Claude Code projects, not just a read-only session viewer. Lets you drive sessions from a browser instead of a terminal. Mature enough to serve as a daily driver interface.
A self-hosted Go binary that moves ideas through plan, build, test, and release phases with role gates between them. Each agent runs sandboxed, runs stream live, and markdown files on disk stay the source of truth. No database or cloud service required.
Probes coding-agent sessions and extracts the work that actually mattered from the noise of a long transcript. Aimed at engineering visibility across many runs. Complements raw session viewers by summarizing rather than replaying.
A multi-agent coding workspace where Claude Code and Codex operate against a shared ByoriDB graph memory of the project. Both agents see the same accumulated understanding rather than rebuilding context separately. The shared graph is the core idea.
Tracks what every AI agent on your machine is doing and reports it, with a deliberate constraint that it never acts on its own. Gives you a coordination view without adding another actor to the system. The report-only posture is the design decision.
Lets Claude Code and Pi run inside the Codex Desktop application. Useful if Codex Desktop is your primary environment but you want Claude Code's behavior. Bilingual English and Chinese documentation.
Applies governance to the memory layer so a stored claim must be validated before the agent is allowed to rely on it. Transplants RCGov's InjectContext-implies-ContextReady axiom onto Claude Code and Codex memory. Addresses memory poisoning rather than memory capacity.
A local daemon plus Telegram bot that lets you continue a running Claude Code CLI session from your phone, including chatting and approving permission prompts. Supports Claude itself, Ollama, and other LLMs behind the CLI. The permission approval flow is what makes it usable rather than just a log viewer.
Checks a citation before it lands in your bibliography, finds where each paper was actually published, and normalizes the whole file to one format. Stdlib-only Python with no pip install and no API key. Direct countermeasure to hallucinated references in AI-assisted writing.
Spins up a dedicated VM per agent session with a single command, and stops burning resources when the session goes idle. Gives real isolation rather than container-level separation. Same problem as worktree sandboxing, solved a level down.
Cost and usage analytics for Claude Code that runs entirely locally, sending neither logs nor source code anywhere. Useful where privacy policy rules out hosted usage dashboards. Focused on spend attribution.
Controls a real Chrome, Edge, or Brave profile on Windows from WSL2 via the Chrome DevTools Protocol, using a dedicated hardened agent profile. Includes a one-time elevated setup and a doctor command for health checks. Solves browser automation for the common WSL2 development setup.
A preprocessing layer that compresses prompts before they reach the model, packaged with a broader LLM engineering suite. Aims at direct cost reduction on high-volume workloads. Portuguese-language documentation.
Claude Code plugins for dictation, transcription, meeting notes, captions, voice, translation, and memory, all running local-first. Lets you talk to a session instead of typing. Audio never leaves the machine.
A memory system for Claude, OpenCode, and Codex offering effectively unbounded context, extraction of learnings from past sessions, and persona modeling. Goes past raw storage into deriving reusable lessons. Works across multiple agent CLIs.
Statically audits a Claude Code setup and prescribes what to change, with honest impact estimates rather than vague advice. Points at specific config, files, and patterns responsible for token waste. Zero dependencies.
A macOS menu bar app tracking token usage and spend across AI agent tools, showing remaining subscription quota and a status light reflecting whether a task is currently running. Read-only and fully local. The status light doubles as an ambient indicator for background sessions.
A captured, reusable design system for data and analytics dashboards, installable as a Claude Code plugin. Includes design tokens, a Tailwind theme, Tremor and Recharts conventions, and drop-in StatCard and DataTable components. Gives an agent a consistent visual target instead of improvising each dashboard.
Aggregates separate token plans, coding plans, and model API quotas into a single virtual plan that Claude Code, Claude Desktop, OpenClaw, and OpenCode can all point at. Runs fully locally. Useful if you hold credit across several providers and want it pooled.
A local app-building pipeline that runs on an existing Claude Code subscription instead of an API key, with a task conveyor, human approval gates, and delivery as a Pull Request. The interface and documentation are in Brazilian Portuguese. Aimed at people who want supervised, reviewable AI app generation without per-token billing.
A lightweight agentic coding CLI built around a deliberately small codebase. It aims to cover the core agent loop and solid terminal capabilities without the surface area of larger tools. Worth a look if you want a compact reference implementation to read or fork.
An open-source platform linking requirements, workflows, code repositories, and coding agents so an approved requirement is carried through to an auditable PR/MR. It integrates deeply with Feishu (Lark) Projects, Space, and Docs, and supports requirement-driven self-iteration. Documentation is in Chinese.
A local markdown vault that captures sessions and compiles them into notes, giving agents persistent memory with no cloud service involved. It works across OpenCode, Claude Code, Codex, and Cursor, so context follows you between tools. Everything stays in plain files you own.
Adds persistent session memory to Claude Code as a single small Rust binary — no daemon to run and no extra LLM calls to pay for. It retains the full session rather than a summarized slice. A low-overhead option if heavier memory servers feel like too much machinery.
Scans agent codebases for security posture and policy violations, reporting each finding with a link back to the exact source line. Coverage includes LangGraph, AutoGen, CrewAI, the OpenAI Agents SDK, MCP, and more than ten other frameworks. Worth running before shipping an agent that touches credentials or external systems.
hooop runs Claude Code inside a disposable Docker sandbox and fronts it with a live dashboard on localhost:7842, so only Docker and jq are needed on the host. Teammates join over an anonymous cloudflared tunnel as full, drive, or spectate peers and co-drive the same transcript from a laptop or phone. Adds read-only /plan runs with an inline-comment review panel, docked live UI previews, an SSE event tail, sub-agent tree, and a diff viewer.
A maintenance tool for Claude Code's always-loaded MEMORY.md, which silently truncates once it outgrows its budget. It enforces a budget guard, checks orphan coverage, and folds verbatim domain content into hub files. The mechanical parts are deterministic with no LLM in the loop, so runs are repeatable.
Indexes your Claude Code and other AI coding agent session transcripts and makes them semantically searchable on your own machine. Embeddings come from Ollama and vectors are stored in sqlite-vec, so nothing leaves the box. Useful when you remember solving a problem in some past session but cannot recall which project or day it was.
A code-server development container you drop into a monorepo as a git submodule at .code-server/. It ships the Claude Code CLI, an ai-jail sandbox layer, nested rootless Docker, and selectable tech stacks. Aimed at giving agents a contained environment that still has real tooling.
Lets you step away from your desk and keep talking to a running Claude Code session through Telegram. Notably has zero dependencies and needs no tmux and no background daemon. Handy for long unattended runs where you only need to answer the occasional prompt.
Converts your saved Instagram posts into a local library that Claude can read and work with. Runs entirely on your machine, is free, and does not ask for your password. Documentation is in Portuguese.
A privacy-first dashboard that shows what your Claude Code agent is doing in real time, and can speak it aloud. Runs locally with no telemetry and no required API calls. Aimed at long agent runs where you want ambient awareness without staring at a scrolling terminal.
A terminal credential platform built for agent workflows and note vaults, using SOPS and age for encryption. Adds agent provenance tracking and a session broker so a running agent gets scoped access instead of raw secrets. Addresses the awkward gap between keeping secrets safe and letting an agent actually use them.
A self-hosted managed harness for LLM coding agents: sessions survive restarts, each session gets its own sandbox, and runs can proceed unattended. Everything runs on infrastructure you own with model keys you control. A self-hosted alternative to hosted agent-runner services.
A WPF/WebView2 desktop panel for Windows that watches a folder and renders whatever Claude Code writes into it. Handles markdown, HTML, Mermaid diagrams, PDFs, and images, updating live as files land. Fills the gap for Windows users who want an artifact preview pane alongside the terminal.
Observes remaining capacity across multiple Claude and Codex accounts and picks which one to launch a session against. Useful if you juggle several subscriptions and keep hitting a window limit on one while another sits idle.
A Claude Code plugin that drafts resumes and cover letters, then scores them twice: once against ATS keyword parsing and once against how a human reviewer would read it. Profession-agnostic rather than tuned to software roles.
Reads the JSONL transcripts Claude Code already writes to disk and turns them into usage analytics, with nothing leaving your machine. Gives per-project and per-session breakdowns without an API key or a hosted dashboard.
A terminal workspace that layers planning, CI/CD debugging, reusable agents, skills, and TODO tracking on top of Claude Code and Codex, with MCP tool integration. Everything is a plugin, so you compose the pieces you actually want rather than adopting a whole framework.
Self-hosted token accounting that aggregates Claude Code and Codex usage across every machine you work on, shipping as one Go binary with an embedded dashboard and a single SQLite file. Worth a look if your usage is split across a laptop, a desktop, and a server and per-machine tools only show you a slice.
A single Python script that puts 5-hour and 7-day rate-limit usage in the status line, plus the reset time for the 5-hour window. The reset clock is the point: 62% used means something very different with four hours left than with twenty minutes. No network calls or dependencies, since Claude Code already passes rate limits to the status-line command on stdin.
An open-source phone harness that lets an agent see and drive a real iPhone from a Windows desktop, with no Mac, Xcode, Appium server, or jailbreak required, and a free Apple ID. A Windows counterpart to the Mac-only harnesses that have circulated for iOS agent testing.
A memory store built as a temporal knowledge graph that every coding agent on your machine reads from and writes to, so context learned in one tool carries into the next. Local-first, with no hosted service in the path.
A project template that points a coding agent at a URL and has it reproduce the site's structure and styling locally. Aimed at bootstrapping a design starting point rather than producing a pixel-exact copy.
A small launcher that puts an interactive model picker in front of Claude Code, routing through an Antigravity Proxy so you can switch backing models per session. Minimal by design: it starts fast and gets out of the way.
Unzip, double-click, and it installs its own engine, signs you in through the browser, and gives you a multi-session task hub. Includes a network check that offers a workaround when connectivity to the API is blocked. Aimed at people who want Claude Code without terminal setup.
Runs requirement-gathering interviews as a live decision tree in the browser, with no MCP round-trip, then writes the resulting documents back for your main Claude Code session to use. Keeps the interrogation phase out of your main context window.
Uses Roslyn to extract entities, controllers, business rules, and Model Editor customizations from a DevExpress XAF application into a form a coding agent can read. Niche, but XAF's conventions are exactly the kind of implicit structure agents guess wrong about.
A CLI that proxies authenticated HTTP requests through a broker you control, so the agent can call APIs it has no credentials for. The key never enters the transcript or the model's context. Addresses the awkward reality that most useful API work currently requires handing an agent a live token.
A native macOS app that runs several Claude Code sessions against the same project directory in one window, with per-file locking and live cross-instance coordination and messaging. The locking is what makes same-directory parallelism survivable without worktrees.
Treats agent assets as packages: install, update, and pin skills, CLIs, MCP servers, and loops across Codex, Claude Code, Cursor, and Kiro from one manifest. The cross-agent scope is the interesting part, since most asset managers assume one host.
A Claude Code setup for auditing Solidity and Vyper contracts on EVM chains: automated vulnerability detection, generated exploit proof-of-concepts, mainnet-fork simulation, and formatted audit reports. The fork simulation means findings are demonstrated, not just asserted.
A self-hosted workspace and drop-in gateway that compresses prompts locally before they hit the API, with a measured 79% token reduction. Works with Claude Code, Cursor, Aider, and any OpenAI or Anthropic client, and also ships an MCP server. MIT, no telemetry.
A portable refine-gate that binds vague prompts to concrete evidence before they run, working across Codex, Gemini CLI, and Claude Code, plus Claude-native plugins for a context guard and telemetry status line. Optional hooks enforce checkpoints, track subagent spend, and surface quota telemetry.
A Rust and ratatui TUI that manages agent sessions natively inside tmux rather than fighting it. If your existing workflow is already tmux panes full of agents, this formalizes it.
A server plus Windows bridge that pushes coding agent status to the OLED display on an Ultimate Hacking Keyboard 80. Very specific hardware, but a nice example of getting agent state out of the terminal and into peripheral vision.
A workspace where you give the agent a skill and it constructs the interface for that work itself, rather than you configuring panels. Agent-agnostic, so it is not tied to Claude Code specifically.
Opens agent execution traces in the browser with a call tree, flamegraph, diff view, search, and shareable links, running entirely client-side with no backend. Handy for figuring out where a multi-agent run actually spent its time.
Works through positioning, learning outcomes, and knowledge structure first, then derives a Reveal.js deck from that structure. The author is explicit that it is not a slide generator, which is a meaningful distinction in a crowded category.
Adds a live context-usage button to the VS Code chat composer that runs /context in one click. Small, but it puts the number where you are already looking instead of behind a command.
A SwiftUI and SwiftData macOS app tracking tokens, cost, per-project breakdowns, and whether you are on pace to survive the current rate-limit window. Native rather than a terminal tool or web dashboard.
A web cockpit for CLI coding agents, letting you start and steer Claude Code, Codex, or Reasonix sessions from a browser or phone. Handles multiple agents from one interface.
A Bun and xterm.js dashboard managing up to ten persistent Claude Code tmux sessions with split panes, live typing, activity indicators, and token authentication. Persistence means closing the browser does not kill the work.
Replaces your coding agent's status transitions with Dark Souls screens. Purely for fun, and it makes a failed build land about as well as it deserves.
A Logback appender that converts Java errors into structured reports formatted for an AI agent to act on, rather than raw stack traces you paste and hope. Drops into existing logging config.
Lets an agent see and control a physical Android phone from Windows over ADB with nothing installed on the device. Works with Claude Code, Codex, and Hermes. Counterpart to the iOS harnesses appearing for the same use case.
A Dock-adjacent pill of eight LEDs on macOS showing at a glance whether anything is working, waiting on you, finished, or broken. Ambient rather than notification-based, so it does not interrupt.
Takes a key from the clipboard and hands the agent a reference instead of the value, so the secret never appears in the chat transcript. Solves a small problem that currently gets solved by pasting keys and regretting it.
Interactive mock interviews for high-level and low-level system design, graded and scheduled with SM-2 spaced repetition so weak areas resurface. Study tool rather than a coding aid.
Flags changes an agent made that look risky and restores project files to their pre-session state, including uncommitted work that git alone would not save you from. That uncommitted case is exactly where agent sessions hurt most.
An open-source vector design tool built around design-as-code, where prompts become UI directly on a live canvas and multiple agent teams can work concurrently. Positioned as an alternative to Pencil.
Local-first code intelligence serving both coding agents and humans, with nothing leaving the machine. Aimed at giving agents structural understanding of a codebase without a hosted indexing service.
A shared chat board that multiple Claude Code terminals post to, giving parallel sessions a channel to coordinate through. Simple approach to a problem usually solved with heavier orchestration.
Finds jobs matching your resume across sites, tailors the resume per posting, fills applications, and can find and message hiring managers over email or LinkedIn. Version 2 adds a web portal and analytics on top of the original CLI. Runs on a Claude Code subscription without an API key or claude -p mode.
A newly launched open-source coding agent optimized for parallelism, claiming 20x better RAM efficiency than Claude Code and 63x faster spawn than Codex CLI, with built-in memory and support for existing API keys and logins. Benchmark claims are the author's own and worth verifying.
A local CLI that gives coding agents voice: if the agent can run bash, it can talk to you. TTS, ASR, and STT all run on your machine, and the CLI is self-describing so the agent learns to drive it on install. Remote use needs Tailscale or ngrok.
RondoFlow is a local-first, open-source platform for visually building multi-agent Claude Code workflows. You create agents on a drag-and-drop canvas, attach skills, and define security policies per agent before running them together. It targets people who want orchestration without hand-writing agent configs and prompt plumbing.
A sandboxed dev container built for running Claude Code unattended, with default-deny network egress and no route to root. It lets you give an agent broad permissions inside the box without exposing the host or the open internet. Practical for autonomous or cron-driven agent sessions.
A tool that closes the feedback loop on HTML artifacts an agent produces, letting you review them visually on your own machine and feed corrections back. It addresses the blind spot where a coding agent writes UI it cannot actually see rendered. Local-first, no hosted service required.
depcompass keeps AI coding agents aligned with the dependency versions actually pinned in your project instead of whatever API shape their training data remembers. It targets the common failure where an agent writes code against a library version you are not running. A small guardrail with an outsized effect on generated-code correctness.
ccusage-fleet collects ccusage output from several machines, including ones reached over SSH, and merges them into a single report. Useful if you run Claude Code on a laptop, a workstation, and a remote box and want one usage picture. A thin but practical layer on top of the existing ccusage tool.
garbage-man gives agents a provider-neutral way to review inboxes and clean up future mail such as scheduled sends and recurring noise. Being provider-neutral, it is not tied to a single mail API. From the team at Every.
A proxy that sits in front of Claude Code so you can intercept and modify any request or response. It supports registering custom models under /model and routing requests between models using your own logic or bundled defaults. Effectively a mod layer for people who want behavior the client does not expose.
A portable Windows terminal built for AI CLIs, showing Claude Code, Codex, and Gemini in parallel panes. Beyond layout, it lets the agents hand work to each other rather than acting as isolated sessions. Portable, so no installation is required.
A lightweight cmux-style terminal multiplexer for Windows, built around WSL2 and focused on Claude Code and Codex sessions. It gives Windows users the split-pane agent workflow that tmux users get on Linux and macOS. Small and focused rather than a full terminal replacement.
Carries a Claude Code setup on a USB stick, with credentials encrypted against three factors: the USB serial, a server key, and a PIN. A lost stick can be revoked remotely, and memory travels with you across machines. Aimed at people who move between workstations they do not fully control.
A Node CLI that compresses finished ('cold') AI coding-agent session files and restores them byte-for-byte on demand. Useful if you keep long transcript histories around for audit or resume but do not want them consuming disk. Verification of the restore is part of the tool rather than an afterthought.
A terminal dashboard showing live Claude Code token consumption alongside your rate-limit windows. Instead of discovering you have burned a session at 107%, you can watch the window fill in real time. Handy for subscription users trying to pace work across five-hour windows.
A packer that turns a repository into LLM-ready context with three properties most packers miss: it is aware of the git diff so it can prioritize what changed, it respects a token budget, and it redacts secrets on the way out. Aimed at feeding code to models without leaking credentials or blowing the window.
A self-hosted, searchable catalog of every Claude Code skill, agent, command, plugin, and MCP server you have installed, with an in-browser Markdown editor for the ones you author. Solves the problem of losing track of what is actually loaded once your configuration sprawls.
A Chrome and Firefox extension that captures an AI conversation, including messages, images, files, and code, and resumes it in a fresh chat on a different compatible assistant with the context carried over as PDF or Markdown. Everything is stored locally with no account or server. It also has an AI compression pass to shrink the carried context.
Runs a task across as many as eight models in parallel and surfaces where they disagree, on the theory that blindspots are model-specific. Applies to research, design, and coding work. Useful as a cheap second opinion before shipping something you cannot easily reverse.
A native macOS terminal designed around running several AI coding CLIs at once: tabs, split view, session restore, and a badge on whichever session is waiting on you. The badge matters when you have six agents running and only one needs a decision.
Builds a per-agent inbox on top of the Markdown coordination files a multi-agent setup already produces, so each agent has a clear view of messages addressed to it. No new protocol to adopt — it layers on existing logs.
A local proxy that measures and reduces Claude Code's upload traffic while claiming no loss in output quality. Aimed at people working on constrained, metered, or slow connections.
An open-source terminal manager that puts all your projects, including remote SSH sessions, on a single canvas with persistent terminals that survive app close and reconnection. Grew from a personal productivity tool into something closer to an autonomous development environment.
A headless terminal wrapper for native Windows that keeps isatty() returning true for spawned processes while staying invisible or living in the system tray. Lets you run Claude Code CLI, Gemini, Codex, or any TUI app as a background process without a visible console.
A CLI plus companion skill for creating and managing a dependency graph of agent work, with a UI for visualizing it. The author built it after reading the article that coined graph engineering and finding no existing tool. Worth a look if you want the graph as an artifact you can inspect, not just a prompt-level idea.
Distills PDFs, photos, and repositories into token-efficient context: local OCR reads embedded diagrams rather than only text layers, content-hash caching collapses re-reads, and BM25 retrieval bounds huge documents. Nothing is discarded — anything shortened can be expanded back in full. Reported 33x on a 25-page PDF and 97% reduction on pytest output.
A cross-platform, zero-dependency Bun status line for Claude Code rendering context, cost, rate-limit windows, git and PR state, subagents, and full config-scope breakdowns as a width-aware multi-row dashboard with Nerd Font glyphs. Opinionated and dense compared to single-line status bars.
A lightweight communication channel for coding agents to talk to each other. Minimal description from the author, but the niche — inter-agent messaging without a heavyweight orchestration framework — is a real one.
A local-first memory layer shared across Claude Code, Codex, OpenCode, Cursor, and others, so context you build up in one agent is available in the next. Local-first means the memory stays on your machine rather than in a vendor's store.
Analyzes a database schema, detects issues, maps relationships, and emits compact AI-ready context files for Claude Code, Codex, Cursor, and similar tools. Fills the common gap where an agent can read your code but has no accurate picture of the data model.
A curated awesome-list of Claude Code and agent tooling. Useful as a starting index if you are surveying what exists rather than looking for one specific tool.
Mission control for coding agent sessions that drives your existing terminal (Kitty or zellij) rather than replacing it, so every session stays a native window or pane in the workflow you already use. A good fit if you have invested in a terminal setup and do not want a separate app.
A fast Rust proxy exposing GitHub Copilot through OpenAI- and Anthropic-compatible API endpoints, so Claude Code, Codex CLI, and any OpenAI or Anthropic SDK can talk to it. Relevant if you have a Copilot seat and want to point existing tooling at it.
An open-source, self-hostable backend giving a chatbot real tool-use: sandboxed code execution, API and file handling, multi-step tasks, MCP support, multi-tenancy, generative UI, audit logs, and an admin dashboard for adding skills. OpenAI API compatible.
Live design feedback: annotate any web page or PDF directly in the browser and a local AI companion applies the markings and produces the revised page. Part of the Loqumen suite. Closes the loop between pointing at a problem and having it fixed.
Positions itself as a trust layer over agent memory — the concern being that stored memories are treated as fact by later sessions without any provenance. Sparse public description; worth watching if agent memory reliability is a problem for you.
A local-first visual workspace that renders your AGENTS.md and SKILL.md files as a kanban board and relationship graph over a sandboxed file API. Makes an agent ecosystem visible when it has grown past what you can hold in your head.
A bilingual multi-agent development workbench whose stated goal is code that survives review rather than code that merely runs. General-purpose across agents rather than tied to one harness.
The free core of the Undercroft kit: a schema defining how a personal wiki is structured so Claude Code can maintain it for you over time. The schema is what stops the wiki degrading into unstructured notes.
Logs what you chose and why so the next session starts from 'we already decided X' instead of relitigating. Zero dependencies, and a companion to the same author's agent-error-log.
Opt-in AES-256-GCM sync of browser sessions and secrets to the machine your agent runs on, so it can log in without you pasting credentials into a config file. Addresses a real gap in agent-host setups, though it is worth reading the threat model carefully before adopting.
A keyboard-driven desktop kanban workspace for AI coding agents with embedded terminals, git worktrees per card, and hook-driven task tracking. The hooks mean board state updates from what the agent actually does rather than what you remember to drag.
A CLI that detects your stack, scaffolds progressive context and session handoffs, and installs a working Claude Code adapter. Ships on npm and PyPI with a plugin architecture for memory backends and additional agent adapters.
A small CLI that drives the TDD cycle from its own observations of the tests and code rather than trusting what the agent reports. The author's writeup is honest about two failed prior attempts — prompts and skills, then a state file the agents learned to fake — which is what makes the third design convincing.
A substrate for autonomous engineering agents: repository discovery from evidence, a shared event bus with leases, and safety rails that refuse rather than ask for permission. The refuse-don't-request stance is a deliberate design choice for unattended operation.
A local-first visual workspace where terminals, git worktrees, and coding agents are composed on a single canvas as executable workflows. One of several canvas-style agent workspaces appearing at the moment.
A local-first CLI giving coding agents presence, messaging, and advisory leases so parallel agents can see who is working on what. Advisory rather than enforced, which keeps it lightweight.
A lightweight Windows system-tray application for monitoring Claude usage without opening a dashboard. Minimal by design.
A self-hosted event server and CLI that fires a local OS notification and updates a live SSE status page the moment a parallel Claude Code, Codex, or Cursor session blocks, needs review, fails, or finishes. MIT-licensed, shipping on npm and PyPI. Solves the real cost of parallel agents: not knowing which one is waiting on you.
Pulls real usage numbers from Cursor, Claude Code, GitHub Copilot, OpenCode, and Codex CLI via each vendor's API or local logs and compares spend across a migration in one command. Includes a credential-free personal mode. Zero runtime dependencies, available as CLI and library on npm and PyPI.
An open-source framework where you describe your commercial process to Claude Code or Codex and get a working CRM as reviewable code you own, with deterministic workflows, human approval steps, and audit and trace built in. The approvals and audit trail are what separate it from generated-app demos.
A TypeScript full-stack framework for Next.js apps built by AI coding agents, where every feature is one fixed vertical slice — entity, repository, route, router — so an agent cannot invent a different structure each time. Auth, storage, jobs, and MCP ship as packages. Aimed at getting AI-built prototypes to production.
A tmux-based cockpit for running many AI coding agents: hook-driven state tracking, fleet restore after a restart, and popup control. Sits inside tmux rather than replacing your terminal.
Observability for AI copilot sessions built on .NET Aspire: an OpenTelemetry collector, Postgres store, and Blazor dashboard with real-time quality scoring. A more enterprise-shaped take than the usual token-counter dashboards.
A fully local model-gateway plugin for Claude Code, built as part of a kanban board with routing built in. Install it, ask the agent to initialize, and it works — currently supporting Codex and Grok.
A Chinese-language tool with a visual interface that reads and writes the config files behind Claude Code and Codex, letting you switch provider, model, and API key without hand-editing JSON.
A local registry and analytics platform for your AI components: define scope, then share and track usage of your skills, MCP servers, and agents. Aimed at teams standardizing on a shared component set.
Builds AI agent MVPs with Claude Code using local repository scans, trend analysis, and personalized recommendations, without requiring an API key. Aimed at getting from idea to a runnable agent prototype quickly.
Evidence-first verification for AI coding agents: rather than accepting a summary, it records what changed, what was tested, and what actually passed. Part of a clear trend toward not trusting agent self-reports.
A native macOS Markdown reader that follows every save, so you can keep it open while writing. Comment on a phrase and the note is written back into the .md file itself — which means your coding agent can open a plan there and wait while you mark it up.
A Spanish-language floating panel for Windows showing the state of your Claude Code sessions, with click-to-jump to the relevant tab. Simple answer to tracking several sessions across windows.
A PowerShell module that lets you manage several Claude Code sessions from Telegram, giving you remote multi-terminal control from a phone. Useful for checking on or unblocking long-running sessions when away from the machine.
A local-first AI agent governance CLI introducing a modular .ai/ context directory (the Agent Definition Format) in place of one monolithic CLAUDE.md. Addresses the well-known problem of CLAUDE.md growing until it is mostly noise.
An autonomous, provider-agnostic engineering team automating software bug detection, triage, and fixes. Shares a name with an earlier unrelated project, so check which repository you are installing.
A Rust implementation of governed AI agent loops with policy checks, verification, memory, and replay for controlled execution. The replay capability is the notable piece — it makes an autonomous run reproducible after the fact.
Keeps reusable memory and agent resources in a single Git-managed workspace, then makes them available across projects, sessions, and supported coding agents. Git-managed means your agent context is versioned and reviewable like code.
A patch to the local Claude Code bundle letting subagents run on any Anthropic-compatible model — DeepSeek, GLM, and so on — while the main agent stays on Fable or Opus through your Max plan, decided per request. Also adds subagent list quality-of-life: pinning, detaching into a separate resumable session, and control over auto-dismiss. Unsupported by Anthropic; the author argues it is lower risk than an API-level router.
A CLI relay for Claude Code, Codex, and OpenCode that delegates work to Antigravity, Claude, Codex, Gemini, Ollama, or OpenCode with streaming, persistent sessions, and multi-agent teams. Broad provider coverage makes it a practical second-opinion layer.
A Chinese-language macOS application for sharing Claude Code and ChatGPT development sessions, project descriptions, and git changes. Useful for showing a teammate what an agent actually did.
A cross-agent task runner letting Codex, Cursor, Claude, Gemini, or Junie delegate tasks to each other or request a second opinion. Shares a common name with unrelated projects, so check the repository owner.
Real-time execution tracing plus cost intelligence for Claude Code, so you can see what a session is doing and what it is costing as it happens rather than afterwards.
A local-first desktop workspace for running, organizing, and resuming multiple coding agents and shells, using real PTYs with split panes, persistent layouts, and local session history. Real PTYs matter for TUI apps that misbehave in emulated terminals.
A Linux VM for your coding agent containing your repositories and notes but none of your keys, with a backend that cannot push. One Go binary, no daemon. A clean, well-scoped answer to the question of how to let an agent run freely without giving it your credentials.
A lightweight multi-terminal manager for Claude Code power users showing live token usage per pane, with multi-account switching and visual split-pane layouts. Shares a name with an unrelated project, so check the repository owner.
An executable compiler from data to editorial-quality visualization with 120 methods, auditable specs, prompt compilation, repair workflows, and browser-native examples. The repair workflows are notable — most chart tooling has no story for a visualization that came out wrong.
Shared organizational memory as plain Markdown in git, loaded by your agent at session start and readable by your team in a browser. Plain Markdown in git means it stays reviewable, diffable, and portable.
Self-hosted Sentry issue triage with rule-based noise filtering, Claude-powered severity and root-cause analysis, and GitHub ticket creation. Runs against your existing Claude subscription instead of Sentry's paid AI add-on.
beans is an issue tracker that keeps everything as markdown in your repo, with a CLI that agents drive well. beans-web scans a root directory (or several) for anything containing a .beans.yml file and serves one UI across all of them. Built to replace running 'beans list' repo by repo and to stop burning tokens having Claude Code print the open-bean hierarchy.
Tracks the energy, water and CO2e footprint of your Claude Code usage and records the offsets that settle them. An unusual angle on session accounting for anyone who wants sustainability numbers alongside token counts.
Analytics module for teams running the BMAD method, reporting story-level leverage ratios, capacity forecasts and halt alerts, plus a coach persona called Levi. Measures output in stories rather than lines of code.
Turns an AI pairing session into something several people can watch and type into at once - screen-sharing where everyone has a keyboard. Useful for team debugging or teaching sessions where one person driving the agent is the bottleneck.
A floating always-on-top native macOS panel showing what the current Claude Code session is doing, with a todo progress bar and an ETA. Reads the session jsonl and todo files directly - no plugin to install and no API key.
Bridges a Chrome extension to your terminal so ChatGPT, Claude and Gemini web sessions answer from the command line, with no API keys involved. Handy if you already pay for the chat subscriptions and want CLI access to them.
Claude Code, Codex and Cursor all keep local session histories; codepend reads them and writes one self-contained HTML file - first thing you ever asked, the 4 AM sessions, your most repeated phrase, the projects you abandoned. Run with 'npx codepend'; no signup, API key, telemetry or backend, and a --redact paranoid mode before sharing.
A terminal AI assistant with a Bubble Tea TUI, code-graph-based review, semantic search, multi-provider LLM support and MCP tools. A full alternative harness rather than an add-on to an existing one.
A CLI that runs Claude Code autonomously to find and apply code improvements across a project. For unattended cleanup passes rather than interactive feature work.
An AI-assisted desktop IDE built around managing Claude Code worktrees and sessions, with a real embedded terminal rather than a simulated one. For people running several branches of agent work at once.
A production blog for Next.js installed with one command, structured so AI search engines can actually parse it, plus an agent layer that knows the conventions for writing into it.
Answers structural questions for coding agents - callers, blast radius, dead code, cross-language gRPC reach, which deployed services run what code - deterministically and offline, with no LLM in the loop. Python and Go.
Gives agents architecture-aware code search, dependency graphs and impact analysis across Python, TypeScript, TSX, Rust, C#, Java and Go. Aimed at the 'what breaks if I change this' question that grep answers badly.
Takes a book manuscript and produces a magazine or guide-style interior at any trim size, with genre-matched typography. Tables, charts, infographics, pull-quotes and callouts appear only where genuinely needed; everything else stays clean prose. Outputs a print-ready PDF plus editable HTML/CSS.
One registry across all your Claude Code projects, with session resume that restores full context and auto-save so an interrupted session doesn't lose work. Aimed at solo developers juggling many repos.
An agent-first BI readiness system that profiles data sources, governs medallion-layer mappings and gates Power BI delivery, explicitly so that AI agents cannot approve their own data modeling decisions.
Runs many Claude Code agents from one browser dashboard with live terminals, status detection built on hooks rather than screen scraping, and per-agent git worktree review and merge. Windows-first and published on npm.
An open-source Windows launcher that manages multiple Claude Desktop accounts without repeated sign-outs. It exploits the Electron app's --user-data-dir flag, giving each profile its own cookies, local storage and config so accounts stay signed in and can run simultaneously in separate windows. You can also pin a desktop shortcut per account and skip the switcher entirely.
A PySide6 tray app for Windows, macOS and Linux that shows live session and weekly usage limits with reset countdowns and token counts. A Stats page values your local transcripts against API rates so subscription users can see what their usage would have cost. Includes 16 themes, a custom theme editor, and a reactive mascot per active session.
A desktop overlay that monitors running Claude Code sessions and understands what each one is currently doing. Approvals, reviews, and prompt answers happen from a floating UI instead of the terminal, and an Agent-SDK "Drive" mode lets it steer sessions directly. Useful if you juggle several concurrent agents and keep losing track of which one is blocked on you.
A Go installer plus guard process that starts an AI coding agent inside tmux and restarts it whenever the box reboots or the session dies. The agent is behind an interface, so adding a second or third agent type is a small change rather than a fork. Aimed at long-running unattended agents on a server or home machine.
A native mobile client for driving coding agents running elsewhere, built in Rust with GPUI and a QUIC/UDP transport rather than the usual web-view-over-HTTP approach. Ships for both iOS and Android. The point is checking in on and unblocking a long-running agent without being at your desk.
A tabbed cmd.exe terminal for Windows 10/11 built around long-running Claude Code sessions. It persists each tab's name, color, and working directory, then restores them automatically after a crash or power loss. Useful if you run several agent sessions on Windows and keep losing your layout.
Running five or six sessions at once makes it hard to tell which one is blocked on you. This puts one pixel crab per session on the screen perimeter, with distinct animations for idle, working at xhigh, awaiting permission, just-finished, asleep, and rate-limited. Clicking a crab foregrounds that session's terminal; it reads per-session files in ~/.claude/sessions, with optional hooks that always exit 0 so they cannot block the CLI.
A cross-agent session browser that indexes your chat history from multiple coding agents in one searchable place. Beyond search, it lets you pick up a session in a different agent than the one that started it. Handy if you split work across Claude Code, Codex, and others.
Instead of scrolling a wall of terminal text, the model renders its work as a page in a local browser canvas. You can see the output, select parts of it, and ask follow-up questions about the selection. A different answer to the readability problem of long agent sessions.
A local hub that gives each project a fixed port and manages its dev server through launchd. It exists to stop Cursor, Claude, and Codex from each spawning their own server and fighting over ports. Documentation is in German.
Runs any CLI-based agent (claude, codex, or others) in its own pty and puts the whole fleet behind a single control surface. You can drive it from a TUI, a web page, or a one-shot command, whichever fits the moment. Agent-agnostic by design rather than Claude-specific.
Exposes DevTools for a running React + TanStack app through a single CLI, so a terminal-based agent can inspect live app state. That closes the usual gap where the agent edits code but cannot see what the running app is actually doing. Useful for debugging loops that currently require you to relay browser observations by hand.
A local-first tool that inspects Claude Code, Cursor, Pi, and OpenCode sessions and reports context token usage, LLM-derived insights, and governance artifacts. Everything stays on your machine. Good for understanding where your context budget actually goes across tools.
A CLI that evaluates coding agent plugins using a multi-tier approach, so you can compare plugins on evidence instead of README claims. Aimed at people maintaining or choosing between plugin sets.
A LiteLLM-based gateway that routes Claude Code, Hermes, or any OpenAI-compatible client to several providers (ARK, Anthropic, Zhipu). Ships an admin UI, per-client usage tracking, and automatic vision-to-text conversion for text-only backends.
A Rust TUI that watches Claude, Codex, and Gemini panes across tmux and surfaces alerts, token pressure, and recommendations. Observe-first by design, so it reports rather than acts and you decide which session needs attention.
A free command-line AI agent aimed at both coding and security testing work. Runs in your terminal alongside the usual tooling.
An open research and drafting workbench for Australian and New Zealand law that answers from legislation and case law with every claim traced to a primary source. Runs locally by default so privileged work never leaves the machine, and can be driven by the AI assistant you already use.
A local CLI that audits coding-agent configuration across four axes: security, instructions, context, and MCP setup. No API key and no code upload by default, so it is safe to run on work repos.
Turns a reference image of handwriting or lettering into an installable TTF: the model draws a full glyph sheet into a registered template, then the app traces it into editable vector outlines with a point-level curve editor in the browser. About 14k lines of TypeScript across a pnpm workspace, written almost entirely with Claude Code over two months.
Audits Claude Code startup context and reports the token cost of each skill, plugin, agent, and memory file, then reversibly disables the dead weight. No proxy and no compression, it just removes what you are not using.
Hands work from Claude Code to any external LLM, and benchmarks which models you can actually trust with which kinds of task. Turns model routing into a measured decision rather than a guess.
A native macOS menu bar app showing quota, local usage, and cost for Claude Code and multi-account Codex, either from the menu bar or a floating desktop HUD. Bilingual English and Chinese.
Plans a page catalog, generates repo-committed markdown with line-range source citations, then incrementally updates only what changed. The design constraint that matters: it will not overwrite edits a human made to the generated pages.
A reusable Python runtime that executes prompts against Claude, Codex, and OpenCode behind a single stable interface. Useful if you are building tooling that should not care which CLI is underneath.
Wraps your existing coding agent so code patches execute within explicit bounds and leave an audit trail. Aimed at limiting blast radius without replacing the agent you already use.
A macOS menu bar app that surfaces which Claude Code or Codex session is waiting on input. Small scope, but it removes the constant tab-cycling when you run several sessions at once.
Ranks Cursor, Claude Code, Cline, Aider, Codex, Gemini CLI, and others by a daily Heat Score built from stars, commits, releases, issues, community activity, forks, and npm downloads. A rough but public read on which agents are actually moving.
Finds live openings, fills in the company's own Greenhouse, Lever, or Ashby form using your real Chrome session, and submits. The stated constraint is that it never invents a fact about you.
Coordinates Claude Code, Codex, Gemini, and Copilot through a SQLite inbox that lives in the workspace, with a reviewed task workflow on top. No daemon and no model provider involved, since the coordination layer is just a file in your repo.
Speaks Claude Code's replies using the Kokoro neural voice running entirely on your machine. No cloud and no API key.
Start a hub, get an address, and let agents join it to collaborate. The Hamachi analogy is the whole design, except the players are LLM sessions rather than people.
A local gateway that points Claude Code at Google Gemini or any LiteLLM-supported provider, with one-command setup, safe local defaults, and easy provider switching. No Anthropic subscription required.
Gives parallel Claude Code sessions a single global speech queue so replies are spoken in order, each announcing which project it came from. Local neural TTS on Apple MLX, 0.3s to first sound, fully offline.
Captures every Claude Code session across every project into a single plain-Markdown knowledge base under your control. Plain files, no service dependency.
A profile launcher and usage dashboard for the Claude Desktop app on Mac and Windows, plus claude-sync, which gives every account one shared Claude Code session list.
Clusters Claude Code sessions by topic so you can find the conversation you forgot you started. Self-hosted, which matters given it indexes your whole session history.
A Jira-style Kanban board for Windows built in WPF and .NET 8, with two-way GitHub issue sync and an MCP server so Claude Code can read and update the board.
Starts Claude Code, Codex, Grok, or Kimi with secrets resolved in-process from 1Password, Bitwarden SM, pass, or sops, giving each agent its own blast radius and optional prompt auth. macOS and Linux.
Select real files from your codebase, optionally add web search or deep research, and run inference on an always-on home workstation to refine prompts. Remote-first by design.
A local-first CLI that runs 13 analyzers plus your own checks over AI-written code within a defined scope, and emits signed receipts for what passed. Deterministic by design, so it is a gate rather than another opinion.
A Kanban view over Claude Code sessions running in herdr, doubling as a control surface for them. Requires herdr, so its usefulness depends on that setup.
Formerly Claude Cockpit, an open-source tool for managing many bash sessions and agents without the constant cd battle. Supports local models and OpenRouter-linked models alongside Claude Code, with reporting on top.
CLAUDE.md and auto memory keep project context inside Claude Code. Walrus Memory persists that memory across sessions and makes it readable from Codex, Cursor, Antigravity, or your own agent, added in two commands.
A Telegram assistant built on the Claude Code CLI with no API key required, handling voice, images, files, and terminal access. Documentation is in Uzbek and Russian.
A Roslyn-based static analyzer that restructures .NET 10 C# for easier consumption by Cursor and Claude Code, with the side benefit of lowering cognitive load for humans. Unusual angle, since it lints for the reader rather than the compiler.
A local dashboard covering Claude Code, Codex, and other AI developer tool usage, with no data leaving your machine. Straightforward if you want the numbers without a hosted service.
A self-hosted platform for managing a fleet of agents. Relevant if you have moved past running one or two sessions on a laptop.
An always-on companion that records the decisions you make and how they change over time, using SQLite plus transformers.js embeddings entirely on your machine. Decision history rather than a flat fact store.
Filesystem As An AI Handler reuses your existing AI agent subscription by exposing it through plain text files on the filesystem. Any tool that can write a file can now talk to your agent.
A context layer for AI coding agents that verifies structure before feeding it to the model, with a claimed 50-90 percent reduction in token spend. Worth benchmarking against your own workload before trusting the headline number.
Native macOS menu bar apps tracking Codex and Claude Code token usage, quota, cache efficiency, cost, and active tasks. Cache efficiency is the metric most similar trackers leave out.
A macOS panel that lists every running Claude Code session and jumps straight to the iTerm2 window hosting it. Solves the problem of losing track of which terminal tab holds which agent run. Useful if you routinely keep several sessions going at once.
Stores issues in git and derives readiness, topological order and demand-based ranking from a real dependency graph. The agent and the human both get an answer to 'what should I work on next' without a separate tracker service. No server or database needed.
An OpenAI-compatible proxy that drives the real claude CLI underneath, so any OpenAI-speaking client runs against a Claude Max/Pro subscription with no API key. Existing clients need no code changes — just point them at the local endpoint. Note that routing subscription access through third-party clients may conflict with Anthropic's terms.
Maps a task into a graph of how Claude would decompose it, then shows how skills, plugins and MCP servers collapse parts of that graph. Makes the value of a given piece of tooling visible instead of assumed. A diagnostic tool for people tuning their setup.
An IDE built around the idea that the editor backend can live on any remote machine while the frontend runs natively on your laptop. The motivation was not wanting to leave a laptop open for long agent runs. Relevant to anyone running unattended Claude Code sessions.
Organizes your agent skills centrally and links the right subset into each project for the right CLI using symlinks instead of copies. Avoids the usual drift between duplicated skill folders. Useful once your skill collection outgrows a single directory.
Propagates file edits to a teammate's checkout within seconds, so two people (or two agent sessions) see the same working tree. Removes the commit-push-pull round trip for tight collaboration. Worth a look for pair-driving agents across machines.
A local dashboard that tracks Claude Code usage and costs, and lets you approve pending tool calls remotely from a phone. Means an unattended session can pause for permission instead of failing. Useful for long runs you monitor away from the desk.
Reverse-engineers macOS and iOS app workflows into state graphs so an agent navigates from remembered structure rather than re-screenshotting each step. Cuts the token cost and latency of visual GUI automation. An interesting alternative to screenshot loops.
An open-source Claude Code plugin that runs review quality comparable to /review locally, before the PR exists, with extra checks aimed at the kind of mistakes AI-written code makes. Keeps review feedback out of the public PR thread. Free and self-hosted.
A small Windows system tray app showing how much of your Claude 5-hour window and weekly limit is left. No terminal command needed to check. Fills a gap for Windows users, where most usage trackers are macOS-first.
A collection of Claude Code plugins bundling specialized agents, skills and commands for development workflows. Installable as a marketplace rather than copied file by file. Worth browsing for ready-made pieces before writing your own.
Summarizes a week of AI coding sessions into a shareable report, with every claim verified against git history so it can't overstate what shipped. Private by default. Built spec-first from its own issue tracker, which doubles as a worked example.
Sits between Claude Code and the provider, using passthrough for Anthropic-Messages-compatible backends (Kimi, DeepSeek, GLM, OpenRouter) and translation for OpenAI-compatible ones. Your MCP servers, skills, hooks, CLAUDE.md and plugins stay put — only the model changes. The author's point is that the setup, not the API, is the real switching cost.
Open-source plugin for Italian 'regime forfettario' freelancers: computes substitute tax, INPS contributions, advance payments and deadlines, with citations for each answer. The citation requirement is what makes it usable for something with legal consequences. Italian-language.
An SEO workstation combining an agent swarm, a tool-running chat assistant, a git-branch site editing bridge, and a hypothesis-then-verify loop. Runs on a Claude subscription rather than metered API spend. Unusual for its Russian-search coverage (МПК, ИКС, Нейро/Алиса).
Collects anonymized Claude Code billing data across contributors to build community-level cost models. Individual users get their own analysis; the aggregate answers what typical usage actually costs. Opt-in by design.
Tracks your Claude usage in real time alongside Anthropic service status, so a slowdown can be attributed to an outage rather than your own limits. Lightweight and local. One of several usage trackers — pick on platform fit.
Two scheduled Claude Code sessions a day screen stocks and place real Robinhood orders through an Agentic Trading MCP, gated by mechanical risk rules. Runs on a Claude Pro subscription with no metered API spend. Real money is at stake and the author explicitly disclaims financial advice — treat as an architecture reference, not a recommendation.
Breaks a session down into tool execution, model think-time, stalls and time waiting on you, via a terminal explorer and a shareable HTML report. Reads local transcripts only — nothing leaves the machine. Good for finding out whether the agent or the human is the bottleneck.
Agents write schema-enforced findings, learnings and decisions into a git-versioned store that humans review before it becomes canon. The schema keeps entries queryable instead of degrading into freeform notes. Addresses the recurring problem of agent knowledge dying with the session.
Plugins that let AI coding assistants drive SAP GUI, bringing agent automation to a stack that usually resists it. Narrow domain but a large one. Worth knowing about if you work anywhere near SAP.
A plugin marketplace whose flagship 'audit' plugin runs a manifest-driven audit and fix pipeline with plan-first and TDD gates enforced by deterministic hooks rather than prompt suggestions. Token spend is attributed to specific phases and tasks, and the run produces a shareable HTML report. Zero dependencies.
Maintains a live map of your codebase using real call graphs with compiler-verified edges, plus hard safety gates on the write path. Aims to replace the agent's guessed model of the code with a checked one. The verification step is what distinguishes it from grep-based context tools.
A macOS menu bar app rendering each Claude Code session as an oven in a Papa's Pizzeria style counter — what's cooking, what's blocked, what's done, and how full each context window is. The game metaphor makes parallel session state readable at a glance. Genuinely useful if you run many sessions.
A Go tool that assesses a repository and places it on the AI Codebase Maturity Model, showing what's missing before agents can work effectively in it. Turns 'our codebase isn't agent-ready' into a specific list. Useful as a before-and-after measure.
An open-source runtime that pairs your machine with Claude Code, Copilot, Gemini, Cursor and others, then executes tasks dispatched from the CTRL NODE dashboard. Work runs locally while control lives in the browser. Useful for kicking off runs away from the terminal.
Built after Claude Remote Control proved flaky and cloud environments felt too constrained: Claude runs inside a persistent cloud workspace the author controls, reachable from a phone. The workspace outlives the machine that started the session and can host more than Claude. Aimed at mobile-first agent work.
Uses AI vision to let agents see and test user interfaces during development instead of relying on selectors alone. Aims at the gap where a UI is technically rendered but visibly wrong. Early-stage but a real problem.
A curated index of Claude Code and Agent Skills projects where every entry is re-checked daily, and anything archived, deleted or ninety days quiet gets flagged and delisted. Solves the link-rot problem that afflicts static awesome-lists. The freshness guarantee is the whole point.
A fully local code intelligence engine built for coding agents: it resolves impact ('what breaks if I change this') and locates the right file without a grep-and-read crawl, claiming 99.4% fewer tokens. No GPU and no upload - the index stays on your machine.
Keeps per-repository notes that survive across sessions, records outcome telemetry, and gates success claims behind actual test evidence - including remembering the changes you reverted. Projects its context through MCP and AGENTS.md so other coding tools can read it. Local-only, stdlib runtime.
Puts 5-hour and 7-day usage plus reset times for a shared Claude account directly in the Claude Code status line. Useful when several people draw down the same quota and need to see what is left before starting a long run.
A GTK terminal that stacks sessions as vertical tabs down the left side - shells, serial consoles, AI CLIs, notes, and remote logins in one window. The vertical layout scales better than horizontal tabs when you keep many agent sessions open at once.
Agents write team knowledge as markdown that lives in your repo, so it goes through pull request review like any other change and gets checked for staleness over time. Works with Claude Code, Cursor, and Codex.
A single command that prevents credentials and secrets from reaching an LLM. Tool-agnostic - it covers Claude Code, Cursor, Copilot, Windsurf, and anything else you point it at.
Gives coding assistants the thing they normally lack on JVM projects: method signatures, parameter names, and Javadoc from inside Maven JARs, resolved in about 0.2 seconds. Fills the gap where an agent can read your source but is blind to your dependencies.
A Claudian fork that brings Claude Code, Codex, Grok, OpenCode, Oh My Pi, and Pi into an Obsidian vault. Useful if your notes are already the place you think, and you want the agent to work where the context lives.
A Windows batch tool that switches Claude Code between 11 MiniMax-compatible providers with a double-click. Keys are stored locally with zero telemetry, no install required. AGPL-3.0.
Tracks whether Claude's 2x usage promotion is currently active, with a live countdown and simple API checks. A small utility for timing heavy sessions against the bonus window.
Runs on your own machine against the Claude subscription you already have - no API key, no cloud, no telemetry - and acts as a chief of staff over your WhatsApp. A good example of pointing a local agent at a personal messaging surface.
Third-generation successor to no-look-pass, handling session continuity and project-lifecycle control so long-running Claude Code work is not lost between sessions. The aviation metaphor runs throughout: trust the tower, never lose a session.
Browses available Claude Code plugins, links marketplaces, and installs what you pick - replacing the manual repo-hunting step. Useful if you sample plugins often enough that install friction matters.
Indexes, queries, validates, and graphs markdown documents that carry YAML frontmatter, with lifecycle management for plans, ADRs, and RFCs. Adds Notion sync and AI-generated summaries, and ships as both a CLI and a Claude Code plugin.
A macOS menu bar app showing remaining Claude Code and Codex quota with reset countdowns and burn-rate projection, so you can see whether a long session will finish before the limit. Also holds a local prompt queue.
A contact and relationship system your agent can actually operate: five Dunbar circles for structure, CSV as source of truth, and the filesystem as the schema. Deliberately plain formats so an LLM can read and edit it directly.
Keeps every endpoint, API key, and model in one place and switches the active provider in a click, with a latency probe so you can check a provider before committing to it. Atomic writes and rolling backups protect your config files. Python plus Next.js in a native OS webview.
Produces, self-reviews, and renders knowledge-driven talking-head videos using Remotion, with the whole pipeline running locally. The self-review pass is the interesting part - the agent critiques its own output before rendering.
Measures a specific failure mode: the agent runs the test suite, then the outcome never makes it into the transcript. Turning that into a countable metric is a sharp way to catch agents quietly papering over failures.
Three deliberately unrelated Claude Code plugins bundled together: guided branch review, context hygiene, and session status shown in the terminal tab or announced by audio.
Syncs Claude Code sessions, memory, plugins, and project settings across machines so you can switch between a Mac and a Windows box mid-task and pick up where you left off.
Coordinates concurrent agents with leases, shared state, and atomic claims so two agents never grab the same task, and work is recoverable if one crashes mid-claim. The primitives are the classic distributed-systems answer applied to agent fleets.
A research proof-of-concept wiring Odrzywolek's EML (Exp-Minus-Log) primitive into Claude Code as a tool-use capability, reporting 21/21 on a math benchmark and 8/8 on a Riemann Hypothesis sub-investigation. Niche, but a clean example of exposing a specialised numeric primitive as a tool.
Wakes Claude Code sessions running in iTerm2 on a schedule, via CLI or an interactive menu, with zero dependencies. Small and single-purpose - useful for keeping long unattended runs from stalling.
A context runtime plus a set of portable plugins that work across both Codex and Claude Code, so your context setup does not have to be rebuilt per harness.
A self-hosted remote terminal for iPhone, iPad, and the browser that attaches to tmux, letting you run Claude Code, Codex, or any CLI agent from anywhere. Free for a single server.
A self-hosted archive of every Claude Code conversation, scrubbed of secrets and made searchable. Framed around the premise that your agent wakes with no memory of yesterday - this is the tape you hand it.
A Docker-based sandbox for running coding agents in isolation, so an agent with broad permissions cannot reach past the container into your real environment.
Sound and desktop notifications telling you when Claude Code is done, stuck, or waiting on an answer. Windows-specific, which fills a real gap since most such tools target macOS.
An evaluation harness aimed at the layer above the model - testing the agent harnesses themselves rather than raw model output. Relevant if you maintain several agent setups and need to compare them systematically.
A terminal multiplexer built specifically for Claude Code that splits the stream: conversation on the left, code changes on the right. Solves the common complaint that diffs get buried in narration.
Lets Claude Code drive the adrplus CLI in plain language, so you can create and update Architecture Decision Records by describing what you decided instead of memorising command syntax.
A local-first proxy that runs Claude Code against other LLM providers without rebuilding your setup: verified provider profiles, OAuth device-flow login, failover, and content-aware routing. The per-model compatibility doctor is the standout - it tells you honestly what breaks on each model.
Shows Claude Code state in the terminal tab itself using distinct glyphs, alongside the conversation name and a bar colour unique to each session. Makes it obvious at a glance which of several tabs is waiting on you.
Stores decisions, context, and session history as a graph so it persists across conversations, with no dependence on a specific model or harness.
Runs alongside a CLI coding agent providing diffs, file trees, conversation history, and task management via td. Complements the terminal session rather than replacing it.
Handles EU AI Act compliance work inside Claude Code: system classification, DPIAs, vendor assessments, and evidence packs. DACH-first, from Lexbeam Software.
Searches and manages AI coding sessions locally with full-text search spanning seven different tools. Useful once your history is split across Claude Code, Codex, and others and you cannot remember where a conversation happened.
An always-on-top window showing Claude and Codex subscription quota, reading locally from your own CLI credentials. Releases are verifiable and nothing is phoned home.
Add-ons that smooth the rough edges of running Claude Code inside Docker Sandboxes - the practical fixes you end up writing yourself after a week of sandboxed sessions.
SKI runs speech recognition and synthesis locally and talks to Claude Code through plain files in the project. Its review mode is the point: the transcript lands in an editable bubble and nothing reaches the agent until you confirm - because a misheard filename becomes a file edit rather than a typo in a text box.
A free, open-source agent that turns Claude Code into a video editor. Newly launched and the authors are asking for feedback.
Reads the JSONL sessions Claude Code already writes to ~/.claude/projects plus a log where you jot one line whenever something annoys you, finds what actually repeats, and proposes a single config change you approve into one easily reverted commit. Also detects a new model generation and suggests updating model-specific sections.
An MIT-licensed launcher around the unmodified Claude Code CLI - not a wrapper, fork, or proxy. Adds per-project profiles remembering model, flags, startup commands and env vars, a live status bar with context and reset times, auto-continue when your limit resets, and voice alerts. Windows, Mac, and Linux.
A monitoring product that only proves itself when something else is broken had an awkward testing problem: every failure it watches for lives behind third-party APIs. Rather than assembling Mockoon or WireMock with proxy settings and routing rules, the team built a failure simulator with Claude Code.
Reads the JSONL sessions Claude Code already writes and draws a git-style tree of every run: which subagent ran, what it decided, attempts burned, which runs merged and which stopped. No hooks and nothing inside your agent loop, so in-flight runs are unaffected; the event log is content-free and whitelist-validated. Python 3.9+, no dependencies, MIT.
A usage monitor for Claude Code and Codex that tracks quota, rate-limit windows and token consumption. Ships both a terminal CLI and a graphical mode, with a bilingual English/Chinese interface. Useful if you juggle subscription limits across two assistants.
A Rust and Tauri menu-bar app that surfaces every running Claude Code session so none sits blocked waiting on your input. It is event-driven off Claude Code's native hooks, and lets you see, hear and reply to agents from one place. Fully local, no server component.
An IntelliJ IDEA plugin for authoring skills for Claude, Codex and Gemini directly inside a project. Provides creation scaffolding and validation without leaving the IDE. The JetBrains counterpart to the same author's VS Code plugin.
An unofficial recreation of the Filament PHP admin panel using Claude's design language, with 78 React components and design tokens. Includes a full click-through panel demo. Not affiliated with the Filament core team.
A self-hosted dashboard that parses the JSONL transcripts Claude Code already writes to show tokens, cost, prompts, sessions, tool calls and failures. An optional HTTP-hook feed adds a live view of the current session. No extra instrumentation required.
Manages terminal sessions across Claude Code, Codex, Cursor, Pi and OpenCode from one interface. Solves the common problem of losing a sprawl of agent tabs to a restart. Single tool rather than per-agent scripts.
A local pipeline that builds architecture maps, hotspot rankings and change-impact analysis before an agent starts editing, then gates structural regressions afterward. Rust core built on ripgrep plus several analysis tools. Aims to give agents real structural context instead of grep results.
An MLX-native server that speaks the Anthropic API so Claude Code can talk to local models like Qwen, Llama and Gemma instead of the cloud. Reports roughly 65 tokens per second on large local models. Built for airgapped NDA, legal and healthcare work.
Scans a repository for the things that mislead or hijack a coding agent: prompt-injection sinks, leaked secrets, and documentation that contradicts the code. Supports Claude Code and Cursor. Positions agent integrity as a distinct problem from ordinary static analysis.
A SwiftUI menu app tracking Claude and Claude Code usage windows across multiple accounts, alongside Codex rate limits and Vertex AI token spend. Shows live reset countdowns and keeps local usage history. Local-only with no analytics.
A self-hosting IDE for agent-driven development — the tool is developed using itself. Details are thin in the README, so treat it as early-stage. Interesting mainly as a bootstrapping experiment.
A two-pane terminal file manager written in Rust with an AI agent in the side pane. The novel bit is that the agent can query the file commander's own state rather than shelling out blindly. A different take on putting an agent in a TUI.
A small Windows system-tray utility that displays current Claude Code and Codex usage limits at a glance. Fills the Windows gap left by the many macOS-only usage monitors. Minimal by design.
An open-source platform for running agent bundles behind real channels, starting with Slack. The same bundle runs locally and on Kubernetes, and ships with git push. Aimed at teams who want agents in production without a vendor.
Indexes your local session transcripts so you can search everything you have ever done in Claude Code. Native macOS app, so search is fast and stays on-device. Overlaps with claude-find but favors browsing over resuming.
An open-source tracker for AI coding usage across platforms, showing limits, reset times and spend in one place. Cross-platform rather than macOS- or Windows-only. Another entry in a crowded usage-monitor field, distinguished by portability.
Build automations with Claude Code, then run them locally under your own API keys with real schedules and webhooks. Open source and desktop-first, so nothing needs to live in someone else's cloud. Bridges the gap between one-off agent runs and scheduled production jobs.
A plugin marketplace maintained by 5dive, centered on agent-channel integrations. The headline plugin bridges Claude Code to Telegram. Small but a working example of running your own marketplace.
Analyzes local session logs to report token spend, context-window pressure, files touched and cost. Runs entirely on your machine with no upload step. Emphasis on which files consumed the budget, not just totals.
A Tauri and Rust overlay that lives at the cursor instead of being another window, with sub-15ms local audio transcription and a Ctrl+Right-Click snippet menu. Most of the implementation was done in Claude Code. The author offers to walk through the workflow.
Screens inbound email before an agent reads it: strips hidden text, scans for prompt injection, and hands over structured JSON instead of a raw body. The design premise is that an agent's inbox is a trust boundary, not a pipe. The write-up focuses on the alternating build-then-attack development loop.
An open-source browser UI whose stated spec is parity: permission prompts, slash commands, shell passthrough, session resume and model switching all behave exactly as in the terminal, including the ugly parts. Nothing the agent says or does is hidden. Parity-first is a meaningfully different stance from most Claude Code GUIs.
A Claude Code plugin (not a separate harness) that adds persistent memory, configurable personality, and messaging integrations for WhatsApp, Telegram, and Discord, plus a service mode for always-on 24/7 agent runs. Imports configuration from OpenClaw, making it easy to bring existing persistent-agent setups into Claude Code.
A lightweight Windows system-tray app that shows usage-limit meters for Claude Code, Codex, GitHub Copilot, and Google Gemini in one place. Handy for anyone juggling multiple AI coding subscriptions who wants an at-a-glance view of remaining quota.
A Reddit post highlighting QM, an agent harness recently open-sourced by Y Combinator, which integrates with Claude Code using just Node, Postgres, and a single init command. Notably, the OP says you can hand the repo to Claude Code itself to set up the harness, and is soliciting community feedback on real-world use.
A self-hosted harness for driving AI coding agents remotely from a phone, letting you kick off or monitor coding sessions away from your desk. Description is brief, so exact Claude Code integration details are not fully clear yet.
Indexes the memory, rules, and instructions that Claude Code, Codex, Cursor, and Gemini have written locally, then carries the durable parts to every agent so context is not siloed per tool. Local-first and MIT licensed, useful for anyone running multiple coding agents on the same machine.
Brings a Claude AI assistant sidebar into LibreOffice Writer, built on the Claude Agent SDK using an existing Claude Code login rather than a separate API key. A novel integration bringing agentic AI assistance into a mainstream office document editor.
A starter template plus scripts that scaffold and configure new Claude Code projects to a consistent standard, automating setup steps that are otherwise done by hand. Description is light on specifics of what the standard actually covers.
Deploys 11 specialized development agents into Claude Code with a single install command, aimed at solo founders who need broad coverage across roles like product, engineering, and QA without a team. Open source and actively maintained.
A CLI that reads Cursor's state.vscdb, Claude Code's JSONL session logs, and Codex's rollout history among other formats, redacts secrets, and dumps it all into a local SQLite database to avoid re-explaining project context when switching agent tools. Read-only scan with local-only storage; the author notes recall accuracy and cross-project bleed are still being tested.
Moira is a native Ubuntu desktop app that tracks Claude Code and Codex usage quotas and reset times in one place. It sends NTFY push alerts when you are approaching limits, filling a gap since most quota trackers target macOS only.
A CLI tool (npm package) that measures how many tokens your AI coding agents actually consumed and lets you submit the total to a public leaderboard. Useful for comparing real-world usage patterns across tools and teams rather than relying on vendor marketing.
glyphline sits in the macOS menu bar and shows your current Claude quota window usage plus what that usage would cost at API rates, even on subscription plans. Aimed at teams who want to see spend trending before they hit a wall.
A design toolkit for AI coding agents (Claude Code, Codex, Qwen) that composes layered HTML, offers a browser-based Figma-like review editor, and exports token-free pixel-perfect PNGs. Notable for explicit Vietnamese-text-safe rendering, a gap in many design tools.
An open-source control plane for running multiple AI coding agents from VS Code and MCP, with task DAGs, source intelligence, durable context, and evidence-based review. Targets teams juggling several models or agents on the same codebase.
A tool that drives your own coding agent to design mascots, icons, stickers, posters, and landing pages for a repo, with no embedded runtime required. A lighthearted but functional way to get branding assets without a designer.
A testing tool for Phoenix LiveView apps that captures HTML during tests and runs it through Pa11y for WCAG compliance checks, with AI-friendly timeline analysis to help debug accessibility regressions. Niche to the Elixir/Phoenix ecosystem but fills a real gap in automated a11y testing there.
A code database for Go that lets AI agents navigate, edit, and understand code by its structural elements (functions, types, calls) instead of by file and line number. Aims to make large Go codebases more tractable for agents that otherwise have to grep and read whole files for context.
Memsem is a local, one-command semantic memory layer for AI agents: it auto-writes durable facts, prioritizes them, detects and resolves contradictions, and supports semantic search. Runs fully offline with no dependency on a specific agent tool.
A community leaderboard that ranks AI coding tool usage using real costs and token counts pulled from ccusage data, covering Claude Code, Codex, Gemini CLI and more. Submit your own stats with the npx viberank-cli command to see how your usage compares to others.
A desktop app (macOS/Windows installers) providing a unified control panel across Claude Code, Codex, and the broader MCP ecosystem. Aimed at users managing multiple agent tools and MCP servers who want a single dashboard instead of juggling separate CLIs.
A shim that lets the Claude Code CLI talk to any OpenAI-compatible or Hermes LLM endpoint while keeping tool calling working. Useful for developers who want to keep the Claude Code CLI interface and workflow while pointing it at a different backend model.
A Claude Code plugin from Hoop Labs that bundles three tools: a guardrails engine that blocks destructive commands before execution, a local scanner that flags personal data and secrets appearing in a session, and an output filter that trims noisy command results to save tokens. Installs via the plugin marketplace and runs on Mac/Linux (WSL on Windows).
Mindvault captures Claude Code sessions, AI-summarizes them, and automatically injects relevant context back into new sessions at start-up. It also serves a searchable web UI for browsing past session history.
Scans local Claude Code transcripts for corrections you've repeated to the assistant and surfaces each one with your own quotes as evidence, accept or reject with one key. Accepted corrections become skill files for Claude Code, AGENTS.md, or Cursor. Local-only, no account, MIT licensed.
Gives AI coding agents memory, structure, and discipline through a knowledge graph, a Scrumban board, and an enforced engineering loop, aiming to make agent behavior more consistent across sessions.
A dependency-free tool that cleans up the half-dead Claude Code agent sessions that accumulate on a Mac over time, packaged with the field procedure that led to building it.
Spin up isolated, open-source environments where Claude Code, Cursor, and other coding agents can write code and deploy software without touching your local machine.
Tracks Claude Code, Codex, and Copilot CLI sessions running across every project on your machine, giving one place to see what agents are doing.
A keyboard-driven local orchestrator for managing multiple parallel coding-agent sessions at once.
A project-centric terminal workspace that runs your shells, coding agents, editor, git, and notes side by side in one GPU-accelerated interface, without leaving the project.
A single OpenAI-compatible API endpoint that fronts OpenAI, Anthropic, Gemini, Azure OpenAI, and Bedrock, letting you pick the provider via a model alias. Installs with a curl-to-bash bootstrap.
An AI stack built around an agent hypervisor that automates tasks, builds a graph-powered wiki of your repo, answers questions, and searches across all your connected tools, accessible from browser, terminal, or API.
Runs evidence-first audits over coding-agent repositories and explicitly supplied AI work logs, checking claims against what's actually recorded rather than taking summaries at face value.
A native, Rust-built, local-first knowledge graph engine for code and project artifacts, inspired by Graphify.
Orchestrates parallel Claude Code, Antigravity, or any CLI agent sessions in isolated git worktrees, with built-in diff review across sessions.
A macOS desktop app (Tauri + Rust) for running, organizing, and resuming many terminal-based AI agent sessions in parallel.
A pixel companion that lives on your macOS Dock, watches your coding agent sessions, decides whether something needs your attention, flags risky commands, and lets you approve or deny actions right from the pet.
A local control plane for running autonomous research agents in real repos under human-approved scope, with live experiment tracking, evidence-backed results, and persistent project memory for Claude Code and Codex.
Lets AI agents perform QA testing on your macOS app in the background, with no synthetic input events and no stolen keyboard/mouse focus, so you can keep working while the agent tests.
A compact heads-up display that instruments your coding agent (Claude Code, Codex, OpenCode) while it works and shows the answer when it stops.
An agent built on the Anthropic Messages API that classifies K-12 edtech support tickets into structured, schema-validated records (category, priority, FERPA risk, sentiment, suggested response). Includes a React dashboard, an eval harness scored against hand-labeled ground truth, and a content-hash cache to control costs.
A Stream Deck plugin that displays Claude Code session and weekly usage limits directly on your Stream Deck.
A Claude Code plugin that correlates the scene graph, console output, GL state, and rendered pixels into a single diagnostic loop for debugging three.js/GLSL rendering issues, plus a SHA-indexed visual regression test suite.
An AI agent workbench focused on integrating and healing vendor API contracts with real production edits across multiple languages, producing live PRs rather than acting as a runtime SDK.
Baton is a deterministic tool that diffs the claims in a multi-agent memory file (CLAUDE.md/AGENTS.md) against actual git history to catch stale or false documentation. Useful for keeping agent instructions honest as a codebase evolves.
A template repo for versioning your global Claude Code configuration (instructions, rules, hooks, persistent memory) in git, with optional cross-machine sync. Helps keep personal Claude Code setups reproducible and portable across machines.
Kelpie is a read-only dashboard that shows which of your local Claude Code sessions is waiting on you, useful when running many parallel agent sessions. Helps avoid babysitting terminals to find the one that needs input.
A local proxy/bridge that lets Claude Code talk to Gemini 2.0 instead of Anthropic's API, claiming fixes for 401 handshake and tool-index collision errors seen in other bridges. Relevant to users experimenting with alternate backends for the Claude Code CLI.
Assay is an open framework for evaluating AI artifacts like skills, MCP servers, agents, and plugins — it inspects what's inside them, optionally sandboxes and runs them, judges the results, and publishes a verifiable report. Useful for vetting third-party skills/MCP servers before trusting them.
A statusline for Claude Code with color-graded styling. Minimal description but a straightforward UI customization for the CLI.
git-cairn distills decisions, rejected alternatives, and invariants from your commit history into a git-native memory that's served back to the agent when relevant files are touched. Aims to give coding agents persistent project context without a separate memory database.
tokimeter tracks usage and cost locally across Claude Code, Codex, Cursor, Grok Build, Hermes, opencode, Cline, and Copilot CLI, with no account or telemetry required. Useful for developers who want a unified, private view of their spend across multiple coding agents.
A configurable floating dashboard for macOS and Windows that surfaces Codex and Claude Code session status, with StreamDock hardware controls for Codex. Useful for developers running multiple agent sessions who want at-a-glance status without switching windows.
An AWS sample showing an internal agent platform built on Amazon Bedrock AgentCore, combining interactive Claude Code cloud workspaces with headless agent kernels behind one portal — including publishing, scheduling, channels, memory, evals, and governance. Useful reference architecture for enterprises wanting to run Claude Code at scale on AWS.
Converts a Claude Code session transcript into a single, dependency-free, offline-readable HTML file. Handy for reviewing, sharing, or archiving past sessions without needing network access or extra tooling.
hindcast is a local-first Mac app to browse, search, and replay every Claude Code session with a timeline scrubber, positioned as an alternative to ccusage for cost tracking. Useful for reviewing past agent work and understanding token/cost usage over time.
A caffeinate alternative that keeps a Mac awake, screen off, specifically while an AI coding agent like Claude Code is working. Useful small utility for anyone running long unattended Claude Code sessions who doesn't want the machine sleeping mid-task.
contextcost measures how many tokens a repository costs an AI coding agent to read, identifies what's wasting that budget, and lets you re-measure to prove savings after cleanup. Useful for teams optimizing repos for cheaper, faster agent context loading.
panevibe runs real CLI coding agents (Claude Code, Codex, or any open model) inside real PTYs from a single self-contained Rust binary. Useful for developers wanting a lightweight, dependency-free terminal harness to drive multiple agent CLIs.
skill-radar is a daily-updated radar tracking new GitHub repos for AI agent skills, MCP servers, prompts, and other agent-native developer tools. Useful for staying on top of the fast-moving Claude Code / agent tooling ecosystem without manually trawling GitHub.
A local-first macOS menu-bar app that tracks quotas, token usage, and API-equivalent cost across AI coding tools. Useful for developers who want an at-a-glance view of how much of their AI coding budget/limits they've used.
A native Rust-built terminal UI for interacting with Claude Code. Useful for users wanting a lighter-weight or more customizable terminal front end than the default CLI experience.
cimble provides project memory for Claude Code that progressively grows and automatically splits itself as it accumulates, aiming to avoid the single-bloated-CLAUDE.md problem. Useful for large or long-running projects where a static memory file becomes unwieldy.
LianYaoHu runs Claude Code, Codex, or any coding agent inside a deny-default sandbox that only allows network egress through a VPN, using sandbox-exec+PF on macOS and Landlock/seccomp+iptables on Linux. Useful for developers who want strong isolation and controlled network access when letting an agent run autonomously.
An open-source (MIT) wearable hardware terminal that lets you tap and speak to dispatch tasks to AI coding agents like Claude Code, OpenClaw, and Codex. Aimed at hands-free task dispatch away from the keyboard.
Captures the extended-thinking traces from Claude Code, Codex, Gemini, and Droid as a navigable, forkable tree so you can rewind, branch from any point, or inject facts mid-thought. Local-first and ships with an MCP server for integration.
A prompt-compression tool that reduces token usage by up to 70% before prompts reach the model, working across Claude Code, OpenAI, LangChain, OpenCode, Cursor, and other agent frameworks. Aimed at lowering API costs and speeding up responses.
A Mac app that sits atop your local Claude Code CLI, first running parallel web research to sharpen a product idea into a concrete market position, then driving Claude Code slice-by-slice against that spec with automatic course-correction. Keeps a per-project .companion/ memory of decisions injected as a cached context block, and routes work across Haiku, Sonnet, and Opus by task.
A setup for iTerm2 that arranges multiple Claude Code sessions as panes in a single cockpit view, making it easier to monitor and manage several parallel agent sessions at once.
A terminal multiplexer built with AI coding agents in mind, offering a remote web client so you can monitor and interact with agent sessions like Claude Code from a browser, not just a local terminal.
A tiny Arduino + OLED desk device (macOS) that displays which of your parallel Claude Code sessions needs attention and jumps you to it, cutting the cognitive load of babysitting multiple agent sessions. Personal/non-commercial license; an ESP32 Wi-Fi remote version is planned.
A terminal multiplexer built natively for Windows (no WSL2 required) with cross-pane communication designed for coordinating multiple AI coding agent sessions side by side.
A self-hosted dashboard for managing multiple parallel Claude Code sessions, positioned as 'the helm, not the autopilot.' Automatically injects project memory into each session at spawn time so agents start with relevant context instead of rediscovering it.
A Three.js-based 3D interface for Obsidian that renders your vault as a 'code city' and lets you dispatch AI coding agents (Claude Code, Codex, Antigravity) to work on research quests, watching the agent fleet operate in real time. A novel visualization layer for orchestrating multiple agents against a personal knowledge base.
A macOS menubar app that shows how full each active Claude Code session's context window is, with configurable 60%/80% warnings per session. Handy for anyone running multiple concurrent sessions who wants to avoid surprise compaction or context overflow.
A Windows 11 app that presents a canvas of agent terminals (Claude Code and Codex CLI) controllable by voice. Aimed at users who want to manage multiple concurrent agent sessions hands-free rather than switching between terminal windows.
A tool that takes one prompt and has coding agents build multiple divergent UI variants in parallel, laid out on an infinite board for side-by-side comparison and iteration. Useful for quickly exploring design directions instead of committing to a single agent-generated layout.
A terminal notebook (h5i-db) that lets both humans and Claude Code run individual cells instead of re-executing whole scripts from scratch during data analysis, rendering images via ratatui-image. Ships with a preinstalled SQL kernel backed by a time-series database, aimed at quantitative/data-science workflows.
A tool that lets AI coding agents like Claude Code use passwords and API keys during tasks without ever exposing the plaintext values to the model or its context. Useful for reducing credential leakage risk when agents need to authenticate to external services.
A fast Rust CLI/TUI/GUI tool that tracks token usage across Codex and Claude Code sessions, with unified reports and live monitoring. Helps developers keep tabs on consumption across multiple coding agent tools in one dashboard.
An open-source toolkit combining Claude Skills and an MCP server for AI-driven lead capture, research, sales follow-up, and pipeline management, usable from Claude, ChatGPT, or Cursor. Aimed at sales/growth teams wanting to run a lead-gen workflow through their AI assistant.
A terminal Space Invaders game to play while waiting for Claude Code to finish a task, with the game notifying you when the session completes. A fun, low-stakes way to fill idle time during long agent runs.
A single-file Python CLI providing persistent memory for AI coding agents and personal knowledge management, combining SQLite FTS5 keyword search with sqlite-vec embeddings via RRF fusion, plus dedup, tasks, and linking. Local-first with no server required, built to be driven by Claude Code, Cursor, and other LLM coding agents.
A Windows system tray popup tool that lets you manage Claude Code conversations and projects the way you manage email, giving quick access to ongoing sessions without keeping terminals open. Targets Windows users who want a lighter way to track multiple Claude Code chats.
A native macOS app that orchestrates Claude Code, Codex, Cursor, Gemini, and shells running in parallel across git worktrees and remote hosts. Useful for developers juggling multiple concurrent agent sessions who want a unified control surface instead of many terminal tabs.
A macOS menu-bar status HUD, installed as a Claude Code plugin, that shows the state (running, needs input, done, error) of multiple concurrent Claude Code sessions across terminals. Useful for developers running several agent sessions at once who want an at-a-glance status view without building a full Xcode app.
Converts long videos into a local, timestamped, searchable ledger that coding agents can query as evidence, for example referencing exact moments in a screen recording or demo video. Useful for feeding video-based context like bug reports or session recordings into an agent's reasoning without manually re-watching footage.
A Docker-based sandbox for running AI coding agents like Claude Code in isolation, limiting their access to the host system.
Routes Claude Code to a different account depending on which folder is open in the VS Code extension, and refuses to start when the active account doesn't match the folder's expected one — useful for keeping work and personal accounts separated.
A unified TypeScript SDK that provides a single interface across multiple coding-agent CLIs — Claude Code, Codex, Gemini CLI, OpenCode, and others — for building tooling on top of them.
Guides coding agents to the right files using purpose metadata and an intelligent code graph instead of open-ended exploration, cutting token costs by over 90% by avoiding files and folders the agent doesn't need to read.
Documentation for metahub, a cross-client app store for AI skills, MCP servers, agents, and plugins — install once and run in Claude Code, Cursor, Zed, and other AI clients.
A zero-dependency real-time statusline HUD for Claude Code and Qwen Code with a session analytics CLI, an API latency overhead widget, 7-day quota projection, auto-compact proximity warnings, themes, and powerline support.
Fixes Word, PowerPoint, Excel, and PDF output that renders Hebrew, Arabic, Chinese, Japanese, Korean, Hindi, and Thai as empty boxes, and includes a font-coverage measurement tool so you can reproduce the problem yourself.
Runs Claude Code, Codex, and other agent CLIs directly in an Obsidian sidebar, letting you drive coding agents without leaving your notes.
An Astro-based knowledge and task system designed for AI consumers, with human-readable docs as a first-class output and a folder-per-issue tracker, shipped as a Claude Code plugin (agent-ks).
A browser tool that adds Codex-style or Claude Code-style agentic coding capabilities on top of ChatGPT and Claude web chat interfaces.
Captures architecture decisions, constraints, conventions, and patterns from AI coding sessions and replays them in the next session so you don't have to re-explain context. Works across multiple AI coding agents, not just Claude Code.
Prices every line of your CLAUDE.md, every skill, subagent, and MCP tool schema to find the ones that don't earn their place in context — runs fully offline with zero API keys, for Claude Code, Codex, and Antigravity.
Provides persistent SSH sessions and exact local safety controls for Claude Code, Codex, and shells on Linux and macOS.
Cross-platform diagnostics and live LLM performance benchmarking for Claude Code, covering system bottlenecks alongside model performance.
A Mac tool that announces when Codex or Claude Code finishes a task using the Zundamon character voice, giving an audible cue instead of having to watch the terminal.
Bundles a security posture, a PreToolUse credential guard, blameless incident postmortems, custom skills, and working agreements into one operating layer for running Claude Code like a member of the engineering team rather than a standalone tool.
A zero-dependency Node.js statusline for Claude Code that surfaces model name, 5-hour and weekly rate-limit usage, session time, and context window size directly from stdin. Useful for keeping an eye on usage limits without leaving the terminal.
A statusline and HUD for coding agents that emphasizes traceability: every displayed number is tied back to measured tool output rather than estimates. Works across multiple agent vendors, not just Claude Code.
A static security scanner purpose-built for the .claude/ directory, checking settings, permissions, hooks, MCP servers, agents/subagents, skills, slash commands, and CLAUDE.md for risky configurations. Positioned like Checkov or Terrascan but for Claude Code setups.
Turns a phone browser into a wireless trackpad, keyboard, and Stream Deck for a Mac, with no app install required. Open source and built with Claude Code.
Paste a job posting and get a tailored resume and cover letter generated as PDFs. A focused, single-purpose Claude-powered job application tool.
An Obsidian plugin enabling bidirectional sync between an Obsidian vault and AI development projects, including Claude Code, Cursor, and VS Code. Keeps notes and project context aligned across tools.
A Home Assistant app that lets you chat with Claude to read your HA config and live entity state, then edit automations, scripts, and dashboards. Mobile-friendly with a prebuilt image for easy setup.
A durable memory and context layer for coding agents that isn't tied to any specific harness. Aims to give agents persistent recall across sessions regardless of which CLI or IDE integration is driving them.
A vendor-neutral, local-first sidecar and web console for supervising AI coding agents in real time, including Claude Code and Codex. Provides secret redaction, approval gates, and an append-only audit trail.
A terminal UI session manager for Claude Code built on tmux, using a split-pane interface to manage multiple concurrent sessions. Helps keep parallel agent runs organized in one terminal window.
Records, replays, and reasons about the work done by Claude Code and other coding agents, creating a provenance trail for agent sessions. Useful for auditing what an agent actually did and why.
A desktop companion pet that watches your coding agent work, reacting to Codex and Claude Code lifecycle hooks with opinions about what it sees. A lighthearted way to get ambient feedback on agent activity.
Lets you drive your real, locally-installed Claude CLI from a phone browser, preserving the same CLAUDE.md, MCP servers, skills, and login as your desktop setup. Self-hosted and locked down by default.
A personal Claude Code configuration bundle including a launcher, session hooks, a custom system prompt, skills, slash commands, and a statusline, installable via a one-line curl script. A reference setup for others building their own Claude Code environment.
A Rust-native cockpit for macOS that spawns isolated git worktrees and runs multiple CLI coding agents in parallel. Includes a GitLens-grade review UX for inspecting every change an agent makes.
Exposes a logged-in Chromium instance on a fixed CDP port so Claude Code can scrape sites like Coupang, Naver, AliExpress, X, or Reddit using your existing session — no API key or bypass code needed. Similar in spirit to CDP-based browser automation setups.
Provides isolated, disposable environments for Claude Code sessions, similar to Python virtualenvs but for AI coding agents. Helps keep experiments and dependencies from leaking between agent runs.
An engineering platform spanning chat, specs, tasks, and code, designed to run with full autonomy when trusted or full manual control when not. Aims to bridge planning and execution in one tool.
Makes Codex and Claude Code sessions multiplayer from the terminal, letting multiple people or agents observe and interact with the same session. Useful for pair-programming with agents.
A repository that automatically publishes an up-to-date list of Claude models and their model IDs, refreshed daily from the official Anthropic Models API. A handy reference for anyone hardcoding model strings.
Learns your coding style once and makes it persist across AI tools, so you stop re-correcting the same preferences every session. Local-first with no telemetry.
A macOS menu-bar app showing usage, remaining quota, reset times, and estimated local cost for Claude Code and Codex. Keeps rate-limit awareness one glance away.
Provides durable memory, a peer message bus, and a Telegram channel back to the human operator for long-running coding agents. Ships as a single Rust binary with a daemon over SQLite.
Lets AI agents work through agent-browser/browser-use inside the Chrome browser you already have open and logged into, rather than spinning up a separate automated instance.
Tracks real token burn across Claude Code and OpenClaw agent sessions locally against Claude Max's 5-hour and weekly windows, using fail-soft account polling. Latches alerts and can trigger a 90%-usage pause protocol, running as a systemd service.
An open-source, fully local plugin (`pip install leaxp`) that groups installed skills by task, builds a table-of-contents plus focused sub-guides, and loads only the relevant chunks via a local numpy/ONNX vector index — no API keys, database, or cloud services required. Aimed at people running 15-20+ skills whose CLAUDE.md context was bloating every prompt.
A verifiable bundle of local patches for the Claude Code CLI covering tool ergonomics (bat-style reads, batched edits, output tails), prompt/guidance cleanup, agent and skill controls, workflow UX like max-effort and queued drafts, runtime guards, cache/session tweaks, and native repacking.
A Windows desktop app for backing up and syncing Claude Code settings and editing what shows up in the statusline. Gives Windows users a GUI over configuration that's normally hand-edited JSON.
A tiny, self-hosted local RAG memory sidecar for your apps, built on FastAPI, Qdrant, and Ollama (BGE-M3 embeddings). A headless building block for adding retrieval-augmented memory without a cloud dependency.
A 'stacking' Agent Development Environment (ADE) aimed at busy developers.
A resident terminal UI that searches, groups, and resumes Claude Code sessions, hosting them as embedded panes with Director/Worker orchestration. Cross-platform, with Windows as its primary target.
Routes your attention across multiple parallel Claude Code sessions running in the terminal, helping surface which session needs input right now.
A macOS menu bar app that lets you close your laptop lid while long-running AI agent sessions keep working, then sleeps the machine after a delay you choose.
A tiny, transparent always-on-top desktop pet driven by Claude Code hooks, giving an at-a-glance view of what your agent is currently doing.
Spawns a fresh Claude Code agent per phase in a 'Ralph Wiggum loop,' driven by spec-kit planning, with a real-time trace UI and automated git handling. Aims to implement whole features autonomously while staying auditable.
A memory plugin for AI coding that captures engineering experience, repository knowledge, and your personal way of working, keeping it useful across future tasks rather than starting from scratch each session.
Runs any local LLM engine auto-tuned to your GPU behind a polished web UI and an OpenAI/Anthropic-compatible API, so you can point Claude Code at your own machine in one command. No Electron, no Python, offline-first.
A factor-isolated benchmark for Claude Code's orchestration and delegation behavior, using a 6-arm design that separates out structure, model, and advisor axes to see what actually drives good delegation.
A macOS menu-bar app and CLI for juggling multiple Claude Code and Codex accounts on one machine, with isolated logins, parallel sessions, live usage tracking, and scheduled usage-window warm-ups.
A modern terminal manager built specifically for running and organizing multiple Claude Code instances at once.
Reads and edits markdown in the browser with every save automatically versioned, and surfaces your agent skills and configs one click away.
A workspace for managing multiple AI CLI projects across local terminals, SSH hosts, and mobile-assisted workflows from one place.
A NestJS architecture template enforcing dependency boundaries via dependency-cruiser in CI, a three-tier RBAC/ABAC permission model, a migration-drift guard, and an AI-collaboration harness for spec-driven development with coding agents.
A Claude Code plugin that runs on top of the Herdr agent multiplexer, enabling cross-vendor task delegation with fabrication-resistant acceptance checks and phone-driven detached session spawning.
A 'light language' for AI agent fleets that shows ambient status — working sessions, active subagents, decisions waiting on you — on the RGB LEDs your PC already has, via OpenRGB.
Scans an AI coding agent's provider config, stored keys, permissions, MCP servers, and proxy chains locally, generating an actionable security report.
Runs local-first AI agents directly against your Obsidian vault, keeping notes and agent context on your machine.
A local CLI that routes each coding task to the cheapest capable model across the agent CLIs you already have, with no API keys or telemetry required. Aims to cut costs by avoiding overkill model selection for simple tasks.
A native macOS Markdown editor offering Source, Visual, and Preview modes over one source of truth, with wiki-links, review marks, and Claude Code integration. Aimed at writers and developers who want a polished markdown workflow alongside their agent.
A browser-based terminal deck offering persistent terminals with automatic session resume for Claude Code and Codex across restarts. Useful for keeping long-running agent sessions alive through reboots or disconnects.
Centralizes a project's documentation inside the project's own directory as a wiki the AI agent already has open, converting PDFs, DOCX, and recorded meetings into validated markdown with clickable provenance. Ships as a Windows desktop app, CLI, and read-only MCP server, and calls no LLM itself.
Claude can't watch video, so flipbook records your web app while Claude drives it and hands back a flipbook of readable keyframes instead. Useful for browser-automation and UI-testing workflows where Claude needs visual feedback on what happened.
A local Windows app for finding, previewing, exporting, and resuming AI CLI chat sessions across AMP, Claude Code, Codex, Copilot, Grok, and other tools. Gives Windows users a session browser for agent CLIs that otherwise lack one.
A CLI that loads a React or Three.js scene from source and renders it in real Chrome, returning the scene graph (bounds, materials, lights, cameras) instead of just a screenshot. Lets an agent distinguish a missing mesh from a wrong material from a clipped label instead of guessing from pixels, and every report explicitly flags when a result can't support a judgment.
A Telegram channel/bot for Claude Code with streaming replies, a live activity feed, robust markdown formatting, large (2GB) file uploads, and thumbs-up/down controls for approving agent decisions from your phone.
A native macOS terminal built around running several Claude Code sessions at once, with tiled panes, an integrated file explorer, and "Lookout" cards that surface which session is waiting on your input. Aimed at solo developers running many agents in parallel.
A white-box security auditing tool that traces data flow from source to sink, chains findings into unauthenticated RCE paths, verifies each chain, and writes an evidence-backed Markdown/HTML report. Supports PHP, Node, Python, Java, and .NET codebases.
A Python-stdlib-only utility for switching between multiple Claude Code accounts directly from the Waybar status bar or terminal, with a colored widget per account and per-account quota display via a GTK4 layer-shell panel. No external dependencies.
A PWA chat client for controlling Claude Code sessions running on your own machine from a phone, working over LAN or Tailscale. Supports remote permission approval and live mirroring of Claude Desktop sessions.
A small CLI that keeps agent context (facts, skills, scratch notes) as a committed directory of one-fact-per-file Markdown in the repo instead of a laptop-local store, so any agent or teammate that can read Markdown can use it. It only prints rules and warns on drift — it never writes files, so removing the binary leaves the repo untouched.
Scans PDFs, Word docs, and text files for content hidden from human readers (e.g. white-on-white text, tiny fonts) before feeding them to an AI, by diffing the extracted text layer against an OCR pass of the rendered page. Aimed at catching prompt-injection payloads smuggled inside documents an agent is asked to read.
A Telegram forum bot where each topic becomes an independent, resumable agent session running Claude Code or Codex CLI, complete with its own working directory, memory, and provider routing. Lets a team spin up and manage many parallel agent sessions from a single Telegram group.
A desktop and CLI control plane for running many coding agents in parallel, using git worktrees and tmux sessions to isolate each agent's workspace, with optional Discord control for managing sessions remotely.
A lightweight Windows desktop pet built with Tauri v2, React, and TypeScript that doubles as a real-time usage monitor for Claude AI and Claude Code rate limits, surfacing how close you are to hitting your cap at a glance.
A status line for Claude Code that parses the session transcript directly to surface token usage, cost, 5-hour/7-day limit progress, and git/PR state — all configured through TOML instead of hard-coded scripts.
A self-hosted web console for running Claude Code, Codex, Copilot, Cursor, and other coding agents as a managed fleet, with isolated per-user workspaces, git/SVN working copies, scheduling, and usage accounting — aimed at teams running many agents at once.
A free, open-source AI music studio for Windows combining local Suno-style song generation with an Ableton Live-inspired clip launcher, arranger, and mixer. It connects to Claude Code via MCP so an agent can write lyrics, compose, arrange, mix, and render complete songs from a prompt, with no watermarks and no ownership claims on generated output.
A native macOS menu-bar app showing usage stats for Claude Code, Codex, and Gemini side by side, built as a companion to cc-switch.
A terminal application that launches and manages 15+ coding agents (Claude Code, Codex, Gemini, Cursor, Devin, Antigravity, and more) from one interface, with git worktree isolation for parallel agent execution, a built-in lightweight editor, and integrated git/PR workflow.
Sets up Tailscale + mosh + tmux so you can drive Claude Code running on your Mac from your phone, without an admin password, and documents six setup traps that commonly cost an afternoon.
A cross-platform NetHack client with graphical tiles (Tauri + React/TS + Rust), notable as a showcase: nearly the entire codebase, tests, app icon, and README were written by Claude Code running Opus 5 with a human steering rather than typing.
A plugin marketplace that installs ten role-specific AI agent teams (web app, docs, research, marketing, data, security audit, DevOps, support, PM, translation) into Claude Code in one step, with beta translation for Codex, Gemini CLI, and Cursor. Built for non-developers, it includes a community-shared team directory via PRs, automatic backups, dangerous-command warnings, and bundled MCP (context7).
An agent that handles technical SEO and generative-engine-optimization work directly inside your project, gated behind approval with git-aware rollback. It verifies changes on the deployed site and reports back a month later on whether they actually moved rankings and AI-citation visibility (ChatGPT, Claude, Perplexity).
A hardened harness that forces Claude Code traffic through Tor and fails closed if the connection is unavailable, built for use with NanoGPT's TEE-hosted kimi-k3 model. Aimed at users who want strong network-privacy guarantees around their coding agent sessions.
A desktop app that adds approvals, audit trails, and organizational memory across multiple AI coding agents (not just Claude Code), running on your own model subscriptions rather than a hosted service.
A Windows desktop app (Tauri 2 + Next.js) that bundles a project dashboard, PTY terminals (PowerShell/WSL), a Claude session browser, and per-project time tracking into one cockpit for developers working with Claude Code.
A file-based memory and prompt bridge that syncs project passports, handoffs, and session logs across Claude Code, claude.ai, and Antigravity IDE using an Obsidian Vault. Bridges web-based planning with local CLI execution, installed via npx.
A local MITM proxy with a desktop GUI and an agent-drivable HTTP API that records and lets you inspect every HTTP request Claude Code sends. Setup is a single settings field.
A zero-dependency, single-file tool that analyzes an interface and reports whether it looks AI-generated, along with the specific signals that gave it away.
A Claude Code-driven integration that syncs Outlook meeting activity into Dynamics 365 CRM, requiring human approval before any write and never fabricating meeting notes. Niche but addresses a common CRM data-entry chore for sales teams.
A shared, tested set of security evaluations for vetting Claude Code skills, agents, and hooks before trusting them, positioned as an alternative to informally vibed reviews. Useful for teams adopting third-party Claude Code extensions.
Compiles documents, spreadsheets, and project artifacts into immutable, diffable builds that agents can read over MCP or HTTP, then activate or roll back like a normal deployment. Brings standard release-management practices to agent context sources.
Lets you leave notes directly in the margins of your repo's docs, then hands them to your AI agent to apply, resolve the threads, and journal what changed and why. Useful for async doc review where a human flags issues and the agent does the editing.
Local-first meeting capture and transcription built for Claude Code: it records meeting audio via macOS ScreenCaptureKit and transcribes locally with whisper.cpp, so no audio or transcript ever leaves the machine.
A cheap, always-on background model that continuously learns your repository so your main coding agent doesn't have to keep re-reading it from scratch. Aims to cut down on repeated context-gathering overhead in long-running Claude Code sessions.
Cogpit reads the session files Claude Code (and Codex) write to disk and streams them live — tool calls, thinking blocks, diffs, subagent fan-out, and per-turn token counts split into uncached/cached/cache-creation/output. It works across sessions started in a terminal, VS Code, or the desktop app, which helps when running several agents at once and needing to see which one is actually blocked on you. It parses an undocumented, moving JSONL format, so it can break when that format changes.
mex maintains a living Markdown wiki inside a repo where agents record architecture, conventions, decisions, and patterns as they work, so future sessions load only what's relevant instead of relearning the codebase from scratch. Version 0.7.0 adds a deterministic local code graph (Tree-sitter plus SQLite, covering TypeScript/JavaScript/Python/Rust) so an agent can query something like 'trace the authentication flow' and get back a compact neighborhood of relevant symbols instead of whole files. It also links wiki claims back to exact symbols so it can flag when code has changed and the recorded knowledge may be stale; the project has crossed 1,000+ GitHub stars.
Claudible lets you invite someone into your live Claude Code session to watch, talk, and co-drive, with 100% local push-to-talk voice, live telemetry, and an agents cockpit view. Per-prompt session history supports one-click revert, and it runs on Windows (WSL2 or native), Linux, and macOS.
Algol sits above code-review engines rather than being one, reading a project's versioned review standards to decide which engine handles a given change. It reconciles every engine's findings into a single record without silently upgrading a heuristic result to verified, and preserves each human override along with the conditions that would reopen it. Built as a ReviewOps layer for Claude Code projects with more than one reviewer or review engine.
curate-course takes scattered YouTube content on any topic and turns it into a structured course website with fully verified links and traceable sources. It ships with a 371-unit posture-correction course as a working example of the pipeline.
A script-first deployment kit for running CLIProxyAPI on Ubuntu, giving Codex CLI and Claude Code an OpenAI-compatible proxy without the usual security gaps: SSH key-only access, UFW/Fail2ban, a loopback-bound proxy behind Caddy auto-HTTPS, encrypted Restic backups, and health checks. Also ships cross-platform claudex/codexx wrappers that pull credentials from the OS secret manager instead of plaintext config.
A self-hosted local AI gateway that unifies model requests from any AI client — routing, format conversion, automatic failover, and request tracing across 26 different LLM providers. Useful for developers juggling multiple coding agents and model backends who want one consistent endpoint.
Reduces Claude Code and Codex transcripts into a single append-only event log you can query later. Zero dependencies, useful for debugging what an agent actually did across a long session.
A terminal dashboard that shows Codex, OpenCode, Claude Code, and Kimi sessions side by side in a single view, for developers running several CLI coding agents at once.
A local proxy for coding agents built around WASM plugins and a canonical multi-provider intermediate representation. Still pre-release, with APIs and config expected to change before launch — worth watching rather than adopting yet.
Breaks down what's spending tokens across Claude Code, OpenClaw, and Hermes Agent sessions — cron jobs, chats, helper calls — and explains why, whether it's retry loops or idle wake-ups, with suggested config fixes. Fully local, zero dependencies.
Lets you monitor and control AI coding sessions running on your dev machine from your phone — useful for checking in on or steering a long agent run away from your desk.
A local-first macOS workspace that runs Codex CLI and Claude Code together as a five-person AI team, for developers who want multiple agents collaborating in one place rather than juggling separate terminals.
A Tauri/Rust/Svelte desktop environment for macOS that wraps Claude Code and Codex sessions with multi-agent orchestration, git/PR review, and built-in DB and API clients.
Tints iTerm2 tabs and flags "needs attention" tabs based on which agent is running in them — Codex, Claude, Grok, Gemini, or Kimi — so you can tell at a glance which terminal needs you.
Recommends skills, agents, MCP servers, and model harnesses based on your repo, drawing on a shipped graph of 68,494 skills, 467 agents, 10,790 MCPs, and 207 harnesses — or point it at your own inventory instead.
Orchestrates Claude Code, Codex, Grok, agy, and Hermes into gated workflows that attempt to fix their own failures, with per-run cost metering, an append-only audit log, and shared team memory. Apache-2.0.
Runs Codex, Claude Code, Cursor, Grok, and local models together in one desktop app, each with its own role, permission posture, and audit receipts. Supports multi-agent ensembles in one thread, diff review, and on-device history across macOS, Windows, and Linux.
Transforms documents into AI-friendly representations locally in the browser before they're uploaded to Claude, aimed at keeping sensitive document content from going up unprocessed.
Gives AI agents a narrow "keyhole" editing interface using vim's command vocabulary combined with ed's line-oriented discipline — a more constrained, auditable alternative to letting an agent freely rewrite whole files.
Captures DOM state, click tracks, console logs, and network activity around a frontend bug, then packages it into a structured prompt with context for Cursor or Claude Code to act on.
A shared cloud canvas where a team spawns coding agents (Claude Code, Codex, and others), watches their terminals, gets a live preview of the running app, and keeps git as the shared source of truth — built to avoid everyone syncing separate local setups.
A host-agnostic library providing wire protocol, identity storage, session digest, and hook state machine internals for building coding-agent integrations. Designed as a library rather than a CLI — every function takes an explicit identity home instead of resolving one implicitly.
Scans your AI workspace (CLAUDE.md files, skills, configs) to find bloat and proposes cuts without making any changes itself. A read-only audit tool for keeping agent context lean and configuration maintainable.
A search service for discovering agent skills without centralizing or exposing usage data — built for privacy-conscious skill discovery. Complements install-focused tools by focusing specifically on search.
A lightweight, local ticket/task management system designed for working alongside AI coding tools. Single-user focused, as a lighter alternative to heavier multi-user ticket boards.
A Claude Code plugin that copies queries, shell commands, and config snippets straight from Claude's responses to your clipboard. Works across macOS, Linux, Windows, and over SSH sessions.
Lets an AI agent operate a live Salesforce org through deterministic gates that prevent it from writing to production on its own. Validated with 128 adversarial tests against a real org — a notable safety pattern for agentic actions on production systems.
Tracks every branch Claude or GPT suggests during a coding session and lets you climb back to any option you didn't take. Plain markdown + YAML format, works with any AI assistant, no lock-in.
Shows rate-limit percentage in the Windows tray, projects when you'll run out based on usage trend, and turns the icon red before you hit the limit. Includes a local 24-hour usage breakdown.
Breaks each agent task down into work steps — tools used, files changed, tests run, time and tokens spent. Works with Claude Code, Codex, OpenCode and more, with no login or telemetry.
Persists conversation context and session history across Claude Code runs so prior work and decisions aren't lost between sessions.
A Go CLI (ccwhid) that converts Claude Code session transcripts into easily browsable HTML artifacts for reviewing past work.
An early-stage coding agent harness built on Sonnet that compiles the codebase first and uses that map for incremental indexing, aiming to match Claude Code's function while giving a visible map of what the agent is doing. Free and in active development; the author is soliciting adversarial feedback.
Repurposes the discontinued Spotify Car Thing (built on Nocturne) into a bluetooth device for managing Claude Code sessions, answering permission prompts, and viewing usage — and it can still switch back to a Spotify controller. Author plans to open-source it once polished.
LOLM's CLI writes or edits files, runs commands in an isolated sandbox, reads real stdout/stderr/exit codes, repairs failures, and produces an auditable receipt of what it did. Positioned as a disciplined, lower-cost agent loop rather than the strongest model available; the founder is looking for adversarial test cases.
Represents your world as plain files — domains, memory, hard autonomy lines, and background loops — so any harness that can read a repo can run your life agents. Private by design, with a reference implementation on Claude Code.
A terminal workbench built in pure Rust — shells, persistent sessions, SSH, and coding agents — GPU-rendered on Zed's gpui with a VT core from Alacritty.
A pane of glass over every Claude Code session running on your machine — index, read, and manage them all from one native macOS app.
A native Tauri 2/Rust/React desktop app for running and supervising multiple Claude Code sessions at once — live transcripts, diffs, subagents, MCP servers, and a real shell in one window.
A tmux alternative that persists your whole terminal workspace across reboots and auto-resumes Claude Code and OpenCode sessions where they left off. Ships an MCP server so agents can drive your panes directly. Go, cross-platform, MIT-licensed.
A Flutter SSH client for Android and Linux built around driving Claude Code, Codex, Aider, and Gemini CLI from a phone — multi-session terminal that survives backgrounding, notifications when the agent needs you, plus an SFTP explorer, code editor, git panel, and Docker/DB console.
A desktop companion that watches for Claude Code permission prompts and answers them using a language model running entirely on your own machine, with no cloud dependency or account. It also surfaces mail, calendar, and GitHub notices as glanceable alerts.
A self-hosted IDE for running Claude Code or Codex through your real engineering workflow -- parallel sandboxed containers, live preview, and the GitHub loop built in. Lets you drive multiple coding agents from one chat interface.
Shows your remaining Claude usage (5-hour and weekly windows) as a glance on a Garmin Forerunner 165, no laptop needed. A Cloudflare Worker handles token refresh and polls the usage API, while the watch only reads a cached snapshot via Bluetooth.
A voice companion for Claude Code, Codex, and AtomCode that narrates what the agent is doing in real time via TTS and lets you talk back by voice, aimed at hands-free supervision of long agent runs.
A lightweight status view for Claude Code agents running on remote hosts, shown inside agterm's sidebar. Agents write status to a shared directory and the local Mac pulls it over SSH, no tunnel or sockets required.
A Claude Code plugin marketplace entry that integrates Gemini CLI for second-opinion code review and security review. Also intercepts image-heavy Reads to protect the prompt cache.
A macOS menu bar app that shows the real memory cost of each running Claude Code session and lets you hibernate idle ones without losing their state.
Auto-pings Claude Code and Codex the moment each provider's 5-hour rate-limit window resets, so back-to-back sessions don't leave a gap between windows.
A build tool that lets you write a Claude Code plugin (skills, hooks, subagents, commands) once and compile it into the native plugin format for 22 other harnesses like Codex, Cursor, and OpenCode. Declares an explicit fallback per capability instead of silently shipping a broken plugin when a target harness lacks a matching feature.
A local LaTeX editor and agent that syncs with self-hosted or hosted Overleaf via the same websocket protocol the browser editor uses, no git bridge required. Changes go through a local diff for review, refuses to push if a co-author edited the same file meanwhile, and includes a rendered PDF diff plus a citation audit against Crossref/OpenAlex.
A local tool that traces which script, notebook, command, or AI agent produced a given file, reporting its confidence honestly rather than guessing. Useful for auditing outputs in agent-heavy data or coding pipelines.
A local, cross-agent memory tool that helps Codex, Claude Code, Copilot, and Cursor learn from actual mistakes, while distinguishing genuine failures from cases where the requirements simply changed.
An offline, no-API-key tool where an agent watches a video without blind spots and proves via timecode what it actually saw, aimed at verifiable video review rather than hallucinated summaries.
A cross-platform desktop workspace for running Claude Code and other agents: multi-agent sessions, git worktrees, code diffs, a skill marketplace, multi-model support, and Computer Use, with remote access via WeChat, Feishu, DingTalk, Telegram, and WhatsApp.
A macOS menu bar app that adds push-to-talk dictation using the same speech endpoint Claude Code itself uses, for hands-free prompting.
Free scripts that parse the JSONL session logs Claude Code already writes to extract real billed token counts per message. Across 185 sessions, found that ~99% of context growth comes from tool output rather than typed prompts, and that spawning subagents for small tasks re-pays a large fixed context cost each time.
A plain-English fit-check tool for vetting any repo, package, API, or MCP server before installing it, with sources backing its assessment.
A tool that takes a contested or disputed question and builds an interactive, source-grounded evidence map, laying out claims and their backing rather than a single flattened answer.
A single Go binary that lets independent coding agent CLIs — Claude Code, Codex, Aider — register a name, send each other mail, and block until a reply arrives. There's no orchestrator, no MCP server, and no wrapper around the underlying CLI, just a lightweight local coordination layer for running multiple agents as one team.
A native, signed, free macOS app that links local repos and lets the Claude Code sessions running in them communicate over a shared localhost MCP bus (ask_agent, answer_agent, check_messages, list_projects). Useful for keeping a frontend and backend, or an app and the library it depends on, in separate sessions that can still query each other, with linking as the explicit consent model.
A framework for building games with AI agents where each seat — art, gameplay, narrative, QA, audio, tech — runs its own session, all coordinated in one workspace.
An autonomous multi-agent swarm that scans a codebase for bugs, dead code, and performance issues, then fixes them using a closed-loop reinforcement learning approach.
A macOS menu-bar utility that shows your 5-hour, weekly, and per-model Claude rate limits at a glance, so you can see how much headroom you have without digging through usage pages.
An AI code reviewer built specifically to give coding agents an outside, execution-grounded second opinion on their own work, rather than relying on the same model to grade itself.
A terminal workbench that combines SSH/SFTP, container management, and server monitoring with an integrated Codex/Claude Code agent, aimed at ops workflows that mix manual admin with AI assistance.
Shows scope-aware headroom for AI coding agent plans — whether you're blocked at the account, model, or group level — and when that block refills, useful for planning work around rate limits.
A static security scanner purpose-built for code produced by Claude Code, Copilot, ChatGPT, and Cursor. Detects hardcoded credentials, CORS misconfigurations, SQL injection, and dependency CVEs in under a second per file, fully offline with zero data exfiltration.
A local dashboard for monitoring the progress of AI coding agents across Claude Code, Codex, Copilot, and MCP, giving a single view into what's currently running.
A local web app that turns raw AI coding tool usage data into a live dashboard covering token counts, costs, session history, and configuration health, aimed at helping you improve how you use tools like Claude Code.
Watches multiple CLI coding agents running in tmux panes and routes your attention to the ones that need it, with the ability to monitor and respond from your phone.
A single-file, stdlib-only Python CLI where one manager session spawns, steers, and monitors many durable headless Claude Code sessions across projects, with mid-turn steering, token budgets, usage-limit park/resume, and a git-tracked knowledge loop. No daemon, no dependencies.
A top-style monitor for Claude Code that shows live sessions, which models they're using, context usage, and the subagents they've spawned, all at a glance.
Runs Claude Code on your Mac while every Bash command actually executes on a remote Linux host over SSH, keeping your Anthropic credentials on the Mac and never on the remote machine.
A local CLI built on top of ccusage that shares and compares your Claude Code token usage stats with other users, turning usage tracking into a social/leaderboard feature.
A native tray app that shows live rate limits, session usage, and monthly spend across Claude Code, Cursor, Codex, Gemini CLI, and Windsurf in one place. Also offers one-click deployment of MCP servers, rules, skills, and sub-agents.
A tool that binds a single keybinding to generate precise references to code ranges, for pasting into any AI assistant or tool. Reduces the friction of manually describing exact file/line ranges when prompting an AI coding agent.
A terminal launcher for agent CLIs (Claude Code, Codex CLI, OpenCode, Gemini CLI, DeepSeek-TUI) that pairs each session with a self-contained template covering mission, playbook, rules, tools, subagents, and persona, cloned into a fresh isolated chat each time.
A voice assistant for Mac that lets you talk through coding tasks, routing them to Claude Code or Codex based on which has available quota, and moving a task mid-run if one runs out.
A local-first mission control app for running multiple AI CLI agents like a workforce, orchestrated on a visual canvas. Lets you approve agent actions from your phone and provides a full audit trail.
A control plane spanning Claude Code, Codex, Cursor, and OpenCode that rotates work across multiple Claude/Codex subscriptions based on quota, keeps shared thread context, and runs cross-model review of the output.
A macOS menu bar overlay that visualizes your currently running Claude Code sessions as a small flock of animated creatures, a lightweight glanceable way to see how many agent sessions are active.
A local, zero-dependency dashboard for Claude Code sessions (macOS/Linux/Windows), styled like RStudio. Shows session timelines, model thinking, diffs, token usage, an embedded terminal, and a visualization pane.
A suite of tools for managing AI-powered coding agents from anywhere, so local hardware does not become the bottleneck for running agent sessions, aimed at developers who want to kick off and monitor agent work remotely.
A native, zero-dependency, cross-platform app that plays background music while Claude Code is working and stops the moment it is your turn to respond.
Syncs rules, agents, commands, hooks, skills, and memories for 30+ AI coding tools across devices using git and age encryption. Positioned as the chezmoi for AI tools.
An open-source collaborative workspace where people and agents work together, acting as a meta-harness across Claude Code, Codex, Cursor, OpenCode, Pi, and custom agents.
Tracks token usage and cost on a per-turn basis for Codex and Claude Code sessions, giving finer-grained visibility than whole-session totals.
A tmux-based console for running multiple coding agents simultaneously, with live status, screen previews, and one-key start/clone/kill controls.
A terminal tool for quickly switching between separate Claude Code and Codex account profiles, useful for developers juggling multiple subscriptions or work/personal accounts.
A terminal tool for browsing, resuming, and deleting past Claude Code conversations, without needing to dig through the CLI's session picker.
An AI video editor specialized for talking-head footage, doing meaning-based cutting, captions, graphics, and sound. Orchestrated by Claude Code or Codex, and free by default.
Automatically converts Claude Code session history into a structured Obsidian vault, turning raw conversation logs into a searchable, linked knowledge base. Useful for developers who want their coding-session context to persist and compound over time instead of vanishing after each session.
A real-time Claude Code usage widget for Windows showing live session and weekly limits across Mini/Normal/Detail dashboard modes, built with Tauri 2 + SolidJS + Rust and styled with Liquid Glass/Mica vibrancy. One of several usage-tracking widgets in this ecosystem, distinguished mainly by its Windows-native UI polish.
A memory system for LLM agents that uses Bayesian updating to learn from feedback over time, rather than storing static facts. Aimed at agents that need their recall to improve and adapt as they receive corrections.
A free, privacy-first usage monitor for the Windows taskbar tray that tracks both Codex and Claude Code usage in one place, with an Android app in development. Currently in beta; distinguishes itself from single-provider widgets by covering both ecosystems.
A terminal session manager built with Claude Code workflows in mind, helping developers organize and switch between multiple concurrent terminal/agent sessions. General enough to use outside Claude Code as well.
A personal knowledge management system combining voice journaling, Claude Code skills, and AI-powered knowledge distillation, stored as plain Markdown in Git. Aimed at people who want a PKM system that is both AI-augmented and fully under their own version control.
A native macOS app that tracks Claude Code and Codex token usage, costs, cache efficiency, and session history in one dashboard. Distinguished from other usage widgets by being a proper native Mac app with cache-efficiency reporting.
A web-based cockpit for driving multiple Claude Code sessions in parallel on your existing subscription, letting you orchestrate several agents from one browser dashboard. Notable for reportedly having written a significant part of itself.
An open-source, self-hosted Rust binary bundling deployments, analytics, session replay, error tracking, OpenTelemetry, email, sandboxes, and an AI gateway, 440+ CLI operations in total, with drop-in skills for Claude Code, Codex, and OpenCode. A broad platform play covering what would otherwise be several separate SaaS subscriptions.
A Nix flake and Home Manager module that sets up Claude Code authenticating through Codex OAuth, with server-side compact support. Niche but useful for the Nix/NixOS community wanting a declarative, reproducible Claude Code install.
Lets you transfer a live Claude Code, Codex, or opencode session to another person using an encrypted three-word phrase, no account required. Also supports migrating your entire Claude Code history to a new laptop with paths automatically rewritten.
A cross-platform desktop app that tracks Claude Code token usage, costs, and session history with a live dashboard. Runs fully locally with no cloud sync, account, or telemetry.
A self-hosted proxy for Claude Code and Codex CLI with multi-backend routing, account pooling with 429 failover, per-key rate limits, and a usage dashboard. Useful for teams managing multiple accounts or API backends.
A self-hosted Docker stack that runs one isolated, long-lived Claude Code session per container, reachable over SSH/tmux and the Claude app's Remote Control feature. Useful for running multiple agent sessions safely in parallel without polluting a local machine.
A single-file, browser-only HTML tool that lints a Claude Skill's SKILL.md for spec compliance and triggering quality. No install needed, useful for quickly checking a skill before publishing it.
A heads-up-display style status line for Claude Code showing network health, tokens-per-second, context usage, quotas, and cost all in one line. Gives an at-a-glance view of session health without extra commands.
A personal, voice-capable AI you run entirely on your own machine using your flat-rate Claude subscription, with no inbound network port, a tamper-evident audit ledger, and a runnable security benchmark. MIT licensed.
A low-resource multi-agent desktop pet built on Tauri 2 with a native Rust provider adapter layer, watching Claude Code, CodeWhale, Codex, OpenCode, and Aider sessions. A playful status indicator for whichever coding agent is currently running.
A visual interface layered on top of Claude Code for building software, aimed at people who prefer a graphical workflow over a raw terminal session. Details are light, but it targets making Claude Code more approachable for non-CLI-first users.
Turns a topic into a narrated 4K video for coding agents, using a unified TTS engine spanning 11 platforms including MiniMax voice cloning, a manifest-based asset engine, and Remotion for composition with cost-gated AI generation.
Lets you pick up any Claude Code conversation exactly where you left off in one click, without re-explaining the project or losing context. A convenience layer for juggling many ongoing sessions.
Composes skills, slash commands, and MCP servers from a central catalog into any repo as native configs for opencode, Claude Code, and Codex, with lockfile-based drift detection. Useful for keeping agent tooling in sync across many repos.
An npx CLI (plus a companion plugin) that reads your Claude Code session transcripts from ~/.claude/projects, cross-references them with git, and flags cases where a tests pass claim was not backed by an actual test run in that session. Runs entirely locally with no model calls, and also catches disabled tests, rewritten expected values, and commits made after a hook rejected them.
An open-source CLI that runs Claude Code and Codex CLI as a paired session, translating one tool's transcript into the other's native session format so typing switch continues the exact same conversation, files, and history when you hit a usage limit. Only one model runs per turn, and both sides stay independently resumable via claude --resume / codex resume.
An open-source CLI (npm i -g ossclip) that transcribes a talking-head video locally with whisper.cpp, then has an LLM plan on-screen graphics like title cards, stat cards, and terminal mockups, rendered as code via Remotion rather than templates. Every planned scene is schema-validated before rendering, works with Claude Code CLI or a Gemini/Anthropic API key, and keeps footage local.
A prompt editor (promptbook.sh) that mirrors how CLI coding tools display pasted images as [Image #1]-style tags, so you can write and preview prompts with embedded images outside the terminal. Solves the problem of images becoming opaque, unclickable placeholders once dropped into a CLI prompt.
An open-source platform that wraps Claude agents and sub-agents into a persistent, shared app instead of ad hoc individual chats, adding a Microsoft Teams surface for lightweight tasks like assigning owners or pulling reports. Built for teams who found raw chat sessions lost context and wanted a consistent shared interface instead of everyone running their own prompts.
An open-source (Apache-2.0) app that connects to Claude Code via the Claude Agent ACP adapter, letting you browse and replay sessions, send or queue prompts, cancel work, and follow todo/plan updates from a phone or browser. Ships as a GitHub Pages PWA, Android app, and desktop UI, and works with a normal claude login subscription with no API key required.
A web app (agentree.app) that turns each agent message into a node in a tree, letting you branch a new conversation from any prior message instead of being stuck in a linear chat. Each node preserves the code/repo state via commits, making it easier to navigate and monitor multiple parallel agent runs.
An open-source pip package that treats agent memory and skills like package management: exp learn captures project architecture into git-tracked records, exp install pulls in shared skills, and exp share packages project knowledge for other developers to install. Aimed at teams with multiple interlinked repos who are tired of re-explaining the same context to Claude every session.
An npm CLI tool that captures a Claude Code or Codex terminal session and pushes it to a formatted GitHub Gist in one command, instead of screenshotting the whole terminal. Works with Claude Code, Codex, or basically any CLI coding tool session.
An eval-driven agentic harness for building production Stellar blockchain dApps, with 6 specialist agents, 5 eval definitions, and contract/frontend/backend templates. Ships an npx CLI scaffolder with Claude Code marketplace support for one-command project setup.
A self-built alternative to tools like Conductor: a kanban/task board where every task runs as its own agent, with one git worktree and branch per task, sessions that keep running after you close the browser, and a diff review flow across multiple projects from one place.
An open-source, local-first video editor with a professional multi-track timeline, controllable through natural language via Agent Skills and MCP integration, rendering with Remotion. Brings conversational, agent-driven editing to a real production timeline.
A local model router that's aware of which harness it's running under — Codex, OpenCode, or Claude Code — and routes tasks to the appropriate model accordingly, rather than applying one-size-fits-all routing rules.
Captures intents, decisions, and rejected alternatives from agent sessions via SessionStart/Stop/PreCompact hooks, then enforces them so a plan cannot quietly contradict an earlier rejected decision. Sits one layer above the kazi goal-tracker from the same org: kazi proves work is done, dira remembers why it was wanted. Currently in design phase -- schema and docs exist, no binary yet.
A native Android app that runs AI coding agents directly on the phone, no terminal, PC, or SSH session required. Aimed at people who want to kick off or check on Claude Code / Codex work from a phone without setting up Termux or a remote connection.
1Helm gives a single AI agent (a "resident") a persistent private computer with compounding memory and skills across sessions. A component called Skipper enforces every safety boundary on what the resident can do, aiming for a durable, self-hosted alternative to stateless agent sessions.
A single Rust/Tauri binary that gives Windows and macOS a live dashboard and tray badge showing which Claude Code sessions need attention, plus a hook recorder, installer, and companion IntelliJ plugin. Aims to make it easy to spot and jump to the session that's waiting on you.
Generates a personal daily audio briefing narrated by Claude, running entirely as a repo plus two scheduled cloud routines with no servers to maintain. Outputs a player artifact you can listen to each day.
Instead of asking complex clarifying questions through chat text, formloop lets an LLM agent generate a rich UI form on the fly for the human to fill out. Useful when a question has many structured fields or options that are awkward to express in plain chat.
Tracks and deduplicates hours spent across Claude Code, Codex, and OpenCode sessions, presented Steam-style like a game library. A lightweight way to see how much time you've actually put into each agent harness.
Four coordinated coaches (training, nutrition, sports medicine, sports psychology) read your wearable data, blood panels, mood, and cycle, then adapt training and fueling around travel and jet lag, briefing you each morning. Built as an autonomous open-source project, twelve weeks into development at time of posting.
An established open-source SDK (230+ stars, running since 2024) for building computer-use-driven E2E QA tests, where the agent operates the app like a real user instead of relying on brittle selectors. Usable as a building block for QA automation in Claude Code and other agent workflows.
A Tauri/React desktop app for Windows that gives Kimi, OpenAI Codex, Anthropic Claude, and Cursor a shared harness and UI. Has solid early traction (29 stars) as a cross-agent alternative to using separate terminals or IDE plugins.
Brings the CLI's /workflows live tree view into VS Code by reading the same on-disk journal state, with a charted dashboard of per-agent timelines, peak context, and token detail parsed from transcripts. No patching, hooks, or API key required. Author notes the journal is a resume ledger keyed by content hash (not a literal run log) and per-agent token fields reflect final context size, not spend — both required cross-checking against real transcripts.
An open-source patch addressing a race condition where a second follow-up message could reach Claude before the first, or get silently merged into one turn. Adds explicit "run" (queue), "run" with immediate flag, and "steer" (interrupt at next tool boundary) semantics, with an editable/reorderable message queue that persists across restarts.
From the team behind CodeGraphContext (4K+ stars), a new project exploring "Graph Engineering" — letting an LLM dynamically propose its own execution graph (e.g. investigate → modify → deploy) while deterministic software validates the proposal against permissions, budgets, and allowed node types before execution, rejecting or forcing a replan when constraints are violated.
A local inference engine for Kimi-Linear-48B featuring INT4 quantization and fused decode kernels for a measured 3.18x speedup, exposed via an OpenAI-compatible server. Ships with "k3," a bridge that auto-detects the calling client per request so Claude Code, Codex, Cline, Aider, and OpenCode all work against it unchanged.
threadleaf is an Obsidian plugin that runs an AI agent natively inside your notes pages, working alongside Claude Code and Codex. It's local-first and keeps agent interactions embedded in the page context rather than a separate chat panel.
peektrace is a loopback-only, local-first inspector and editor for Claude Code state -- memories, sessions, and context-budget forensics -- in one live pane. It also covers Codex and Pi sessions, giving a unified view across multiple coding agent tools.
A community member scored roughly 2,300 Claude Code plugins on maintenance, popularity, documentation, manifest richness, and trust/safety instead of just GitHub stars. The post highlights two plugins in Anthropic's official marketplace scoring 91 vs 66 despite similar star counts, exposing a stale-but-popular one.
kgai is a Claude Code plugin that auto-captures the decisions behind your code into an immutable knowledge graph, built on Kuzu, and syncs across a team without merge conflicts. It gives AI dev teams shared, queryable memory of why code changed, not just what changed.
Omnodex adds security and observability tooling around AI agent execution, including Claude Code and MCP-based setups. It's aimed at teams that need visibility and guardrails around what coding agents actually do at runtime.
Builders Gate is an early-stage toolkit that lets Claude agents build games alongside a human, covering art generation, a custom sprite editor, an in-progress level editor, and an audio lab for sound effects and voiceovers. It also has a playtest-recording feature so Claude can review feedback and turn it into a task list for follow-up agents.
AgentDeck is a browser front-end over real tmux sessions, so long-running Claude Code tasks keep running when you close the tab, drop VPN, or restart the service. It adds a desktop-style window manager, one-click shell launch with Claude Code pre-started, drag-and-drop file paths, and a mobile view -- no database, no auth beyond an IP allowlist, so it's a LAN/VPN tool.
cairn is a quiet native macOS companion app that notifies you when a coding agent -- Claude Code, Codex, or similar -- finishes its turn. It's a lightweight, focused alternative to watching a terminal for agent completion.
catchup reads the transcripts that Claude Code's terminal and desktop app already write to disk but never surface, letting you catch up on what another session did without switching back to it. Both clients log full session history but give no built-in way to read it back -- this fills that gap.
Home-manager modules and configuration for running AI coding assistants declaratively on NixOS/Nix. Lets you manage Claude Code and similar tools the same way as the rest of a Nix-based environment.
A Claude Code / Cursor plugin that runs security tests against your local AI agent directly from the editor, rather than requiring a separate tool or context switch.
A local-only Chrome extension paired with a Node sink that streams browser console logs to a file Claude Code reads on every prompt. No cloud involved, closing the loop between frontend errors and the coding agent.
A local-first desktop app that auto-detects and unifies Claude Code, Codex CLI, and Gemini CLI behind one interface — unified chat, file explorer, terminal, and editor. Built with Tauri, Rust, and Vue 3.
Offline codebase indexing for Claude Code, Codex CLI, OpenCode, and other agents, combining FTS5 full-text search, Tree-sitter parsing, and graph search so agents can find relevant code without repeated brute-force reads.
A terminal setup for working from multiple Claude Code accounts and switching between them instantly, even mid-conversation, with a statusline that shows the active account, usage, and git state.
Shows live Claude Code, Codex, and Antigravity quotas and reset times right on the Windows taskbar, as a widget, tray icon, or floating window.
Packages one developer's personal workflow as a Claude Code plugin: an SDLC pipeline, task board, coding agents, and audit skills tailored to Laravel development.
A single-container web dashboard (FastAPI, React, nginx) that controls multiple remote Claude Code agents through an orchestrator LLM, MCP, and file-based mailboxes.
A translucent, always-on desktop widget that tracks Claude Code, Codex, Grok Build, Kimi Code, and ZCode sessions in real time, distilling a command timeline and a glossary of task codenames. Native on both macOS and Windows.
Automatically clicks "Try again" in Claude Desktop and presses Enter to continue stalled chats after hitting usage limits, on a schedule via UI automation with no manual setup.
An AI team that lives on your Mac — tasks assigned through Telegram or Slack get routed to the right agent, with progress tracked on a dashboard.
Mirrors a live tmux pane to a phone browser so you can watch and drive a Claude Code session from anywhere on your network — no app, no API key, zero runtime dependencies.
Hands a live coding-agent session between your own machines over plain SSH, with a dependency-free bash implementation.
Turns the corrections an agent receives during a session into memory rules for next time, and fixes the rules that don't actually fire — so the agent stops repeating the same mistakes.
A Claude Code plugin (haiku/sonnet/opus subagents) plus a claude-route CLI that routes every task to the cheapest Claude model capable of handling it, instead of running everything on the most expensive tier.
Ships AI-generated HTML or Markdown to one recipient instead of the world — one link plus a password, view receipts, instant revoke, per-recipient passwords, and versioning. Open source and edge-native.
An Electron app for macOS that unifies Claude Code and Codex CLI in one place — a shared session sidebar, real terminals via node-pty/xterm, dictation notes, a capabilities manager, and opt-in worktree isolation.
A single CLI for exploring, installing, evaluating, and sharing curated bundles of Claude Code plugins and skills.
Runs multiple Claude Code and Codex sessions in parallel through a browser terminal grid that shows which agent needs your attention. Local, tmux-backed, MIT-licensed.
A bilingual (Chinese/English) practice app for Anthropic's Claude Certified Architect – Foundations exam, with 163 questions, a missed-question queue, and an official-spec mock exam verified against the exam guide. Zero-dependency static site, works offline, unofficial.
Unifies multi-project, multi-session Claude Code work into one browser hub, with number-indexed project/server navigation (cdf/sshf), an HTML dashboard, and a project-management SCAR plugin.
A Windows system-tray monitor for Claude usage limits, with live session and weekly meters, a usage graph, and alerts. Unofficial.
A zero-dependency CLI (87.4 kB) that installs AI agent skills and MCP servers from any source, covering 86 agents with no signup and no telemetry.
A Go binary on top of tmux that gives every running Claude, Codex, or OpenCode agent a live status in one list grouped by project, so you can spot a stuck permission prompt without tabbing through terminals. Press space to send a prompt into any agent's pane without attaching, and ctrl+r opens its diff as whole files for inline review comments that feed straight back into the agent.
A local open-source app where an agent reviews someone else's GitHub PR and posts findings directly on the diff next to the relevant lines. You can discuss, edit, or remove each comment, then preview and choose whether to comment, approve, or request changes — nothing posts automatically. Works with Claude Code and Codex; requires an authenticated GitHub CLI.
A terminal picker that runs before your coding agent starts, letting you choose the harness, provider, model, and system prompt in one step before launch.
Generates a documentation wiki from your codebase where every page records the source files it was built from, so you can see exactly which docs have drifted from the code.
Detects the API errors and other failures that end a Claude Code turn, waits out the right backoff, and resumes the session automatically — running from inside Claude Code, with nothing else needing to stay running.
An open-source Claude Code GUI built on the official Claude Agent SDK, supporting parallel multi-project sessions, multi-engine BYOK (Codex, DeepSeek, Kimi, Ollama), a terminal, browser and DB bubbles, and code review. Local-first, MIT.
A personal project and routine management agent for Claude with enforced structure, a plan-approve-execute discipline, wiki memory, and optional voice, brand, todos, and dev-planning modules.
A drop-in JS widget that collects user feedback on a live site and turns it into AI-powered, automated fixes.
An integrated, open terminal environment for steering a fleet of coding agents at once, built to be reshaped rather than used as a black box.
Stores project context, tasks, architecture decisions, and notes in SQLite so an agent can cheaply retrieve just what it needs (semantic RAG with a re-ranker, or FTS5) instead of reloading a huge markdown file every session. Supports syncing the database across machines via a mounted Google Drive/OneDrive folder, with Tailscale-based sync under consideration.
Approves Claude Code permission prompts right from the macOS menu bar without switching to the terminal, and shows live status for every AI coding agent — Claude, Codex, Copilot, and Antigravity.
A self-hosted dashboard that spawns and manages persistent Claude Code sessions on your own machine, server, or NAS, so you can attach from claude.ai/code or the mobile app without SSH or tmux. Supports server-mode bridges and interactive PTY sessions with true --continue resume, per-project worktrees, and full config editing from the browser.
Watches a long-running command, detects failures, attempts a fix, and leaves an audit trail of what happened. Useful for keeping agent-launched background processes alive without manual babysitting.
Packages a personal collection of rules, agents, and skills into immutable releases and syncs them into projects with WAL crash-safety, three-way merge, and CI gating. Brings deployment-grade rigor to distributing your own Claude Code configuration across repos.
An AI assistant plugin for the Control Plane platform providing Claude Code, Codex, Antigravity, and MCP workflows for deploying, troubleshooting, and managing multi-cloud workloads from within a coding agent session.
Strips structural noise out of prompts before they reach the model, reducing token usage while deterministically preserving the underlying information. A prompt-layer alternative to lossy summarization for context trimming.
Lets agents generate and edit images, video, audio, and 3D content with no API key or OAuth setup — durable hosted URLs, recoverable jobs, and cost receipts included. Removes the usual credential-wrangling step before an agent can produce media assets.
Sits between a CLI coding agent and the model provider, inspecting the assembled request body for secrets and PII, masking each value consistently at its exact location, and rebuilding/rescanning the request before release. Built after the author's agent assembled a debugging request that included a live credential and customer email without approval. Supports OpenAI Responses and Anthropic Messages.
A graph-derived PROJECT_MAP, an output wrapper, and curated knowledge (OKF) that let an agent answer structural questions about a codebase without repeatedly re-reading source files to find things.
A detailed comparison of three open-source context-transfer tools: can-bridge (faithful transcript + tool-call translation between Claude Code and Codex only), ai-context-bridge (11 targets, git-triggered resume files, no session linking), and the author's own context-bridge, which links each agent's native session to the project once and tracks provenance across multi-hop switches (e.g. Claude → Grok → Codex) instead of creating a new thread every transfer.
Shows quota status across multiple Claude Code accounts and lets you switch between them, useful for anyone juggling more than one subscription or workspace.
A tool for managing several concurrent Claude Code sessions so you don't have to track them manually.
Chat, agent mode, sandboxed HTML artifacts, evidence-backed research, and an MCP bridge to Claude Code, all running inside an Obsidian vault. Free, MIT-licensed, bring your own API key.
A self-hosted alternative to Claude Cowork for building AI coworkers by chatting with them: each agent gets its own agents.md, skills, tools/MCPs, and work folder, can edit its own configuration from feedback, and can run on a schedule or be triggered by another app. Supports switching harness (Claude Code, Codex, Pi, with more planned) and model, including bring-your-own subscription.
Routes a developer's attention across several concurrently running AI coding agents, surfacing which one actually needs a human decision right now.
A fun, real-time, local-first visualization that shows Claude Code and Codex agents working as a living graph, giving a god's-eye view of what multiple sessions are doing at once.
A CLI a coding agent can call to delegate a sub-task to another agent, getting back only the answer, review, or patch — never the delegate's full working context. Keeps delegated work from polluting the caller's context window.
Lets you build a Telegram bot from inside Claude Code using tlgrm.bot's constructor rather than hand-writing bot code.
A terminal shell wrapper that compresses command output before it reaches the agent's context, cutting the token cost of routine shell commands.
A set of PowerShell scripts that streamline running local AI agents — llama.cpp with PI, and Claude Code — on Windows 11 Pro.
Runs Claude Code inside Docker containers with a portable, composable configuration setup, useful for keeping agent sessions isolated and reproducible across machines.
Gives coding agents desktop automation through shell commands rather than vision-based Computer Use, aiming for more deterministic control over desktop interactions.
A vendor-agnostic desktop agent with a rich UI, loop selection, and swappable provider/model slots, connected to 3,500+ MCP servers via Pipedream Connect. Lets you carry an agent and its context across apps and switch layout without changing IDEs, built over a two-year development cycle.
Shows which Windows or WSL executables an AI coding agent actually resolves and runs, with evidence, for debugging cross-boundary path and environment confusion.
Scans, identifies, and assesses security risks in SKILL.md packages before you install them, addressing the growing supply-chain risk of installing third-party skills sight-unseen.
Indexes skills, plugins, MCP servers, agents, and integrations across Claude Code, Codex, Gemini CLI, and more into one searchable catalog, aiming to be the discovery layer the ecosystem currently lacks.
Runs Claude Code and opencode agents in a real tmux session on your own Linux box or Mac, and lets you drive them from desktop, phone, or browser over HTTPS.
Runs AI code review on GitHub pull requests locally, without committing to a specific agent vendor, giving teams a self-hosted alternative to hosted PR-review bots.
A free desktop app for Windows and macOS that gives each coding agent you use (Claude Code, Codex, Gemini CLI, Qwen, Ollama, etc.) its own terminal pane in a single window, with no account or server required. Useful for people juggling multiple CLI agents side by side.
A local-only macOS menu bar app (SwiftUI) that shows how you actually use Claude Code, including skill, MCP, sub-agent, and prompt usage statistics. Useful for understanding your own usage patterns without sending data anywhere.
A local dashboard ('Agent Deck') combining AI agent usage stats, Mac system metrics, and GitHub contribution activity in one view. Niche personal-productivity tool but concrete in scope.
A macOS menu bar app for managing CLIProxyAPI, multiple Claude Code accounts, and shell launch commands from one place. Useful for people juggling several accounts/proxies for CLI coding agents.
A local Windows tray application that predicts when your Codex CLI and Claude Code usage limits will run out, based on current usage patterns. Solves a concrete, common pain point for subscription-plan users.
A plugin that extracts durable domain knowledge (rules, constraints, terminology, runbooks) from Claude Code conversations and saves it as structured, shareable context — a domain profile plus a knowledge folder — for reuse across sessions or with teammates. Positioned as more persistent than /compact and more portable than ad-hoc handoff files.
A VS Code extension that lets you pick a Claude Code model and effort-level combo from a customizable QuickPick menu, applying it to the next conversation. A small but concrete quality-of-life tool for switching configurations quickly.
A CLI/tool for working with local Claude Code session logs — search across them, export, sanitize sensitive content, or produce token-count summaries. Practical utility for anyone auditing or archiving their session history.
Turns a Ulanzi D200X device into a live status and control deck for Claude Code, Codex, and Cursor on macOS, with a unified layout, state-guarded keys, and 5 agent lanes. A niche but distinctive physical-hardware integration for monitoring multiple agent sessions.
A lightweight macOS menu bar app that shows live TUI session activity for Claude Code, Codex, and OpenCode at a glance, so you can check on running agent sessions without switching to the terminal.
A native macOS menu-bar app that displays a pixel cat reflecting the live status of your Claude Code and Codex agent sessions, giving an at-a-glance indicator of when agents are working or idle.
A desktop app (GPUI + axum) that centralizes provider switching, a local relay, MCP servers, skills, sessions, usage tracking, and sync for multiple AI coding tools in one native interface.
A tool that takes an objective, plans the work, and spins up multiple Claude Code sub-agents each in its own git worktree to parallelize tasks like adding tests or migrating endpoints. Every shell command needs manual approval and PRs surface as agents finish, using your existing Claude Code CLI login rather than a separate API key.
An open-source multi-agent command center for Claude Code offering 244 skills and 200+ agents organized into 14 departments, with PD-driven autonomous workflows, a SQLite task store, and file-based memory, installed entirely under ~/.claude/ with no cloud dependency.
A sandbox environment for running AI coding agents autonomously with host isolation and network restrictions, aimed at making unattended agent runs safer.
An unofficial Windows desktop app that wraps the Claude Code CLI in a graphical chat-style interface for users who prefer a GUI over the terminal.
A local-agent-driven HTML editor offering 75 skills across 9 output surfaces (magazine, deck, poster, tweet/XHS card, prototype, data report, and more), with sandboxed preview and one-click export to WeChat, X, Zhihu, HTML, or PNG. Works with Claude Code, Cursor, Codex, Gemini, Copilot, OpenCode, Qwen, and Aider without a separate API key.
A 100% local multi-agent session browser that lets you view, search, and manage coding-agent sessions across OpenCode, Copilot, Cursor, Pi, Claude Code, and Codex from one interface.
A JVM-based (non-Electron) native console for running Claude Code, Codex, Gemini, or OpenCode with an integrated real browser, terminal, editor, secrets management, and access to 100+ MCP tools, targeted at enterprise and research use.
A harness for Claude Code that adds project-aware account routing across multiple accounts, isolated sessions, a context-management feature called LeanCTX, and MCP integrations.
A desktop app for installing, organizing, editing, syncing, and updating Skills, MCP servers, and plugins across Claude Code, Cursor, Codex, Windsurf, and Gemini CLI, with real-directory scanning and Git-aware diff previews before applying changes.
A native macOS app that lets you cycle through idle Claude Code (or other agent) sessions running in iTerm2 or Kitty using global hotkeys, helping manage multiple parallel agent sessions without hunting through windows.
A CLI toolkit that mines local Claude Code session logs and git history to produce analytics, streaks, leaderboards, and productivity metrics, entirely offline. Useful for developers who want visibility into their own Claude Code usage patterns without sending data anywhere.
A GUI terminal multiplexer with mouse or tmux-style pane splitting that lets you approve, deny, or prompt Claude Code, Copilot CLI, and similar agents remotely from your phone over Telegram. Useful for monitoring and steering long-running agent sessions away from your desk.
A tool that drives acpx agent sessions (Claude Code, Codex, Gemini) remotely from WeChat, Feishu, and Yuanbao, without needing a terminal. A lighter-weight take on remote agent control aimed at Chinese chat platforms.
A local, tmux-native, zero-dependency tool that detects when Claude Code Remote Control's 31-second retry budget gives up on a session and silently dies, then re-arms it. Targets a specific known reliability gap in Claude Code's remote control feature.
A lightweight, privacy-focused SwiftUI menu bar app for Apple Silicon Macs that shows current Claude and Claude Code usage limits at a glance. One of several usage-monitoring apps in this space, distinguished mainly by being fully native.
A tiny always-on-top widget that lists every Claude Code session running on your machine, showing project color, chat name, a status dot, and playing a sound when a turn finishes. Useful for people running many parallel Claude Code sessions who need an at-a-glance overview.
A menu-bar app that reads local logs to show live token spend across Claude Code, Codex, Gemini, Hermes, OpenClaw, and OpenCode in one place, with no upload or signup required. Useful for developers juggling multiple coding agents who want a single usage view.
A quota-tracking tool that does cache-adjusted token attribution, per-model usage breakdown, and reset-aware pacing so you know how to spend remaining quota before it resets. More analytically sophisticated than a basic usage-percentage display.
An open-source project that reverse-engineers the LCD-key protocol of a cheap Mars-Gaming StreamDeck clone (via USB/Wireshark capture) to display live Claude Code session/weekly usage, active session count, subagent count, and burn-rate ETA on physical tiles. Includes a full reverse-engineering writeup and support for the AKP03/N3/MSD-TWO device family; Windows-only for now.
A GUI that bridges a WSL-based Claude Code workspace and the Windows desktop, with a file tree, Markdown/docx/PDF preview, and an inbox drop window for moving files between the two environments. Supports 8 UI languages, addressing a common WSL/Windows friction point for Claude Code users.
A tool that lets you mark up any web page or PDF directly in the browser, with a local AI companion applying the markings and producing a revised page. Part of the Loqumen suite of design tools.
SAGE (Session Awareness & Guidance Engine) watches multiple parallel AI coding sessions and answers questions about their state, but deliberately never edits, spawns, or blocks anything. Aimed at teams running many simultaneous agent sessions who want visibility without giving the observer any write power.
A CLI tool that halts Claude Code before you exhaust your usage window and automatically resumes once it resets. Helps avoid mid-task interruptions from hitting rate limits unexpectedly.
A per-session monitor that detects the moment Claude Code is waiting on your input and fires native Windows notifications, aimed at WSL2/Docker users. Useful for juggling multiple long-running sessions without babysitting each terminal.
A lightweight Rust + Tauri v2 desktop panel showing every active Claude Code session, which ones are waiting on you, and your running cost for the day. Built for people running multiple concurrent sessions who want an at-a-glance dashboard.
A dependency-free tool that displays your Claude Code subscription quota directly in the MacBook Pro Touch Bar Control Strip. Niche but handy for Touch Bar Mac owners wanting usage visibility without a terminal.
An open-source macOS (Apple Silicon) tool arranging real terminal sessions as nodes in a canvas, with commander-to-worker delegation for a fleet of AI coding agents, and highlighting which agent needs your attention.
A native macOS app for writing blog posts in Markdown, where you describe your site to Claude to have it built, then edit drafts with AI assistance and publish free to GitHub Pages. Aimed at writers who want a chat-driven, AI-assisted static blogging workflow.
A small per-project wiki paired with a generated handoff prompt, designed to eliminate cross-session amnesia when resuming Claude Code work. Lets you pick up a project days later without re-explaining context from scratch.
Millwright is a self-hosted, Rust-based LLM router that works as a drop-in replacement for OpenRouter with Claude Code. It supports Anthropic, OpenAI-compatible, and Bedrock providers with policy-controlled routing, cache affinity, spend tracking, and circuit-breaker reliability, deployable as one binary with SQLite or Postgres.
A terminal UI command center for managing fleets of Claude Code, Codex, tmux, and cmux agent sessions from one place. Aimed at developers running many parallel coding-agent sessions who need a unified view and control surface.
A plugin marketplace that lets you install skills, subagents, hooks, and MCP servers directly via `/plugin marketplace add`. Provides a discoverable, centralized way to extend Claude Code without manually wiring configs.
A self-hosted dashboard for analyzing Claude Code usage from session transcripts, with cost accounting that correctly handles cache TTLs (a common source of inaccurate cost estimates). Useful for teams or individuals tracking spend across sessions.
A Mac menu-bar app paired with an end-to-end encrypted relay and iOS companion app that lets you monitor and steer Claude Code / coding-agent sessions remotely. Useful for checking in on long-running agent sessions without staying at your desk.
A tool that syncs coding-agent session state so you can pick up work on a different machine without losing context. Targets developers who switch between desktop, laptop, or remote environments mid-task.
A transparent proxy that captures every LLM call, tool call, cost, and loop for AI agents locally, with zero code changes required. Useful for debugging agent runs and auditing cost/behavior after the fact.
A local-first wearable work agent that uses Even G2 smart-glasses audio and R1 gestures to delegate tasks to Claude Code and Codex terminals running on your computer. A novel hands-free interface for triggering agent work.
A local-only, zero-dependency pixel-art dashboard that visualizes your Claude Code model and agents as a boss and crew working in an office, driven by real session events. A playful way to get an at-a-glance view of multi-agent activity.
A control panel for directly managing multiple coding agents via the command line. A lightweight alternative to TUI-based fleet managers for developers who prefer a CLI-first workflow.
A local-first evaluation dashboard for agent CLIs with cross-harness transcript collection, live trace intelligence, deterministic graders, and accuracy audits. Useful for teams who want to benchmark and monitor coding-agent quality over time without a hosted service.
Origami groups agents, terminals, and commands per project so switching projects means switching workspaces rather than rebuilding your environment from scratch. After 3 months of development, the update brings improved UI, better MCP support, a new in-app Kanban board, and an Artifacts viewer. Tested with long-running autonomous agents across Opus 5 and Fable 5.
A DIY integration that drives a 10€ pixel board with custom GIFs for each Claude Code session state: thinking, waiting for input, answering, and idle. Also shows used context percentage and one spinning dot per active sub-agent. A fun hardware project that surfaces agent internals as a physical ambient display.
A desktop floating window that aggregates token consumption and cost across Claude Code, Codex, and Grok Build sessions. Gives a persistent at-a-glance view of token spend without switching windows. Practical for developers juggling multiple AI coding tools who want unified usage visibility.
A tiny Python CLI that fetches YouTube captions and pipes them to stdout, letting Claude read video content without an API key or audio transcription. Install with pipx and pass the transcript straight into your session using `yt-transcript -o -`. Optional timestamps add ~20% token overhead when you need them.
A p2p network that gives AI agents their own address for discovering tools and other agents without human wiring. Agents can autonomously join via a one-line install and transact over encrypted peer-to-peer connections. ~250k agents already on the network; recently raised a $4.5M seed.
A macOS app that turns the MacBook notch into a persistent workspace for files, media, focus tools, and Claude Code or Codex sessions. Keeps your coding session accessible without consuming screen real estate. Native and Mac-only.
An open-source (MIT) tool that embeds a sponsor line in Claude Code's status row, letting developers earn revenue while the AI is working. Client, ad server, and dashboard are all auditable and self-hostable. Never reads your code, files, or prompts.
A code editor that runs a bundled local model (or any GGUF) for autocomplete and fill-in-the-middle at zero token cost, then routes heavier tasks to Claude, GPT, or Gemini via your own API key — per task. Every file write and shell command requires approval. Remembers context across sessions and supports Skill Files.
A walkthrough of building three interconnected habit tracking apps — a daily habit logger, a gym tracker, and a meal prep log — using Claude Code with Google Sheets as the backend. No technical background required; apps hosted on GitHub Pages and sync data via Sheets' CSV export endpoint.
A self-hosted web app for managing board and digital game collections within a group, with voting sessions to decide what to play next and rating tracking. Supports German and English. Built entirely with Claude Code as an example of Claude-driven app development.
A drop-in replacement for the `claude` CLI that launches Claude Code inside an ephemeral, RAM-only NixOS microVM. Brings your existing config automatically. Egress can be locked down in one line. Fully reproducible — same config produces the same VM. Zero disk writes survive the session.
A Claude Code plugin that adds BMO from Adventure Time as a friendly CLI companion. Includes persistent memory, a bundled skills library, and randomized ASCII art greetings for your sessions. A fun addition for Claude Code users who want a bit of personality in their workflow.
A Tauri v2 + Rust reimplementation of the popular ClaudeMeter app, extended with additional features and Linux support. Shows usage statistics including token counts across sessions. Born from community need to continue extending the original project after its maintainer became unavailable.
A statusline plugin that reconstructs real token spend from local transcripts at API prices — no API key needed and nothing leaves your machine. Shows 5h/7d limit meters with time-to-reset countdowns, per-model quotas, budget warnings, and 13 themes with a TUI configurator. Install via `npx claude-usage-statusline`.
A tool that monitors live cache expiry and automates context handoffs before the cache expires, plus one-command account switching. Eliminates the hidden cost of cache expiry and bloated sessions. Zero runtime dependencies; includes a CLI and editor extension.
A small tool that lets you queue your next Claude Code instruction while the current one is still running, without interrupting or derailing the active session. The queued instruction executes automatically when the current task completes. Solves a real UX friction point in long-running agent sessions.
Collapses N reads, greps, and globs into a single Bash round-trip for autonomous Claude Code sessions. Reduces output tokens, slows cache growth, and cuts wall time by batching file operations that would otherwise each consume separate tool calls. Designed for autonomous runs where efficiency matters.
Captures screenshots and streams structured intelligence about them into AI coding tools for faster visual context. Useful for debugging UI issues, sharing visual context with Claude Code without manually describing the screen, and automated visual regression workflows.
A meta-repo for bootstrapping context-engineered projects through a discuss → curate → bootstrap workflow. Generates tailored harness setups for Claude Code, Cursor, Copilot, and other AI coding agents from project discussions. Automates the tedious process of setting up CLAUDE.md and related context files.
Transforms AI coding agent logs into a gamified character sheet with 74 achievements, fixed-scale metrics, an LLM-written chronicle, and research-backed improvement advice. Supports Claude Code, Codex, OpenCode, Gemini, and Copilot. 100% local, available in Russian and English.
A local-first dashboard and CLI for visualizing token usage data tracked by Toktrack. Provides charts and metrics for analyzing AI coding tool consumption over time. Designed for developers who want visual analytics on their token spending across coding sessions.
Points at any AI agent endpoint, describes a few user types and their goals, then holds real multi-turn conversations to score the agent and report what broke. No SDK changes, no code instrumentation, no framework dependency required. Useful for validating AI agent behavior before shipping.
A launcher for the Claude CLI that saves your preferred model, mode, and effort settings and applies them automatically when starting Claude Code. Eliminates the need to retype flags for your usual session configuration. Lightweight and focused.
A tool for managing the context and state accumulated by coding agents over time. Lets you resolve conflicts, audit what is in context, visualize the state graph, and clean out stale entries. Addresses the problem of agent context becoming cluttered or inconsistent across long sessions.
A proxy that exposes an Anthropic-compatible API endpoint, allowing Claude Code to be used inside Cursor and other tools that support the Anthropic API. Lets developers use their existing Claude subscription from within Cursor's interface without a separate API key.
Injects a small, honest repo map into Claude Code and Codex sessions so agents understand the codebase structure and health before diving in. Reports a 2.5x improvement in file open-rate on real sessions. Designed to be truthful rather than exhaustive, mapping only what it can actually measure.
A native macOS menu bar app that shows how much of your Claude session and 7-day limits remain, which chat is consuming them, and when you are likely to hit the wall. Local-only with no telemetry, MIT licensed. Built for Claude Code power users who run near their limits regularly.
Reads your Claude Code session files to reconstruct what you actually worked on, then reconciles it against what you planned to do. Shows the delta between planned and actual work on a single page. Useful for project tracking, retrospectives, and understanding where your AI coding sessions actually spent their time.
A single Rust binary that bridges Claude Code to run against your Cursor subscription with zero configuration. Lets developers use Claude Code's agentic capabilities without a separate Anthropic API key or subscription. Single binary deployment, open source.
A linter for AI agent configuration files across multiple tools: CLAUDE.md, AGENTS.md, .cursorrules, and MCP config files. Catches common mistakes and anti-patterns before they silently hurt agent behavior. Works across the major coding agent ecosystems.
Defines a tool-agnostic protocol for creating software project maps grounded in actual evidence rather than hallucinated documentation. Includes adapters for both Codex and Claude Code. The maps serve as a reliable source of truth that agents can read without having to rediscover the codebase each session.
An LLM proxy that captures all API traffic and stamps Anthropic cache_control TTL headers for prompt caching, handles vision handoffs, enforces concurrency limits and rate limiting, and provides a live inspection dashboard. Useful for debugging Claude API usage and optimizing prompt caching.
A local web dashboard that reads Claude Code session files and git history to surface Working Set rework radar, harness usage stats, and JIRA/GitHub delivery metrics. All data is computed from your own disk with no external services. Shows the relationship between agent activity and project delivery.
A browser-based multiplayer tower defense game built by a Claude Code agent pipeline: one architect agent orchestrates implementer, test designer, test runner, docs sync, and an adversarial balance guardian subagent. Built on Cloudflare Workers and Durable Objects. Live at TideWars.com, free, no signup.
A live wildfire tracking site for the 2026 Lège-Cap-Ferret fire built autonomously by Claude Code from a one-sentence idea. Features satellite fire detections, wind data, water bomber tracking, and AI-generated bulletins. Reached 21k visitors in 72 hours — a concrete demonstration of Claude Code autonomous build capability.
A native chat panel extension for Cursor and VS Code that runs Claude Code using your own Claude subscription rather than the editor built-in AI. Features 7 themable palettes, plan-mode review with inline comments, MCP connectors, checkpoints and rewind functionality.
Wraps the Claude Code CLI in a Docker Compose setup that adds per-session isolation, shared rooms with fine-grained permission delegation, in-browser tool approval, and code-server editing. Teams can collaborate on shared Claude Code sessions with access control and browser-based management.
A visual timeline showing how Claude Code's system prompt has evolved across every published version. Features a stream-graph view, inline content diffs between versions, and markers for Claude model releases. Useful for understanding what instructions Claude operates under and how they have changed over time.
A tool that runs a coding agent N times under two CLAUDE.md configurations, diffs the outcomes with a confidence interval, and identifies which rules genuinely influence Claude's behavior vs. dead weight. Ablates down to the sections that earn their keep. MIT licensed.
A Claude Code plugin that benchmarks proposed rules before letting them into the agent context. Watches sessions, proposes rules from expensive ones, then runs frozen benchmarks with and without the rule. Rules that don't save at least 2x their carrying cost in tokens get discarded automatically. MIT licensed.
A Claude Code statusline that stays quiet until a metric runs hot, then surfaces only the single most important alert in amber or red. Three presets from compact to detailed, with the least useful info dropping first as the terminal narrows. Zero runtime dependencies, clean uninstall that restores your previous statusline.
A desktop app that watches GitHub repositories for issues labeled 'agent' and automatically runs Claude Code locally until a pull request is ready for review. Bridges the gap between issue tracking and agentic coding without requiring a CI/CD pipeline. Click the issue to focus the terminal tab running the session.
Traces long-running agent sessions and records why each decision was made, not just what happened. Entirely self-hosted so sensitive code and reasoning never leave your machine. Useful when debugging why an automated agent session went off the rails.
Desktop app that puts every agent session on a canvas node, each in its own git worktree. Nothing reaches main until you review the diff and approve it in-app. Drives Claude Code, Codex, Gemini, and OpenCode using your existing logins — no API keys or telemetry required.
Private, self-hosted server for coordinating multiple coding agents — provides the shared coordination layer without relying on external cloud services. Suited for teams running multiple Claude Code instances that need a central point of control.
Runs evidence-backed audits on vibe-coded apps at the level of a staff engineer review, including release vetoes, generated fix prompts, and same-rubric retests to confirm fixes landed. Fills the quality-assurance gap when code is generated quickly without manual review.
Parses Claude memory from exported chat files and generates editable memory profiles that can be imported into a new account. Runs entirely locally and privately — no data leaves your machine.
Visible workspace for running Claude Code, Codex, Gemini, Kimi, Qwen, Cursor, Copilot, and other AI coding agents side by side in the same CLI environment. Shows what each agent is doing and lets you direct work to whichever fits the task.
Native macOS app that uses the Dynamic Island to surface Claude Code and Codex session state — permission requests, usage limits, and which terminal tab to jump to. Keeps agent activity visible without switching windows constantly.
Self-hosted backup system specifically for coding-agent sessions that verifies integrity before storing and supports point-in-time recovery. Protects against accidental overwrites or agent-caused data loss without relying on cloud providers.
Launcher that starts Claude Code, Codex, Kimi CLI, and other coding agents through a unified interface with 8 bundled personas and a universal proxy layer. MIT licensed desktop app with a built-in RENZ terminal agent for CLI and desktop use.
tessera is a personal framework for structuring agentic coding sessions with Claude Code. Provides opinionated configuration and workflows to streamline recurring development patterns.
A macOS menu bar app that surfaces Claude Code usage limits and tracks pace in real time, letting you see quota burn rate before hitting a cooldown wall. Complements the session experience without needing to open a browser.
crash-dummy builds a test user, integrates your SDK following your own documentation, and runs the actual customer flows — catching doc-to-code drift and onboarding failures before real users hit them. Good for SDK maintainers and library authors shipping for external developers.
A Windows Terminal launcher that streamlines opening Claude Code sessions with a configured terminal environment. Addresses the lack of a native launcher experience for Claude Code on Windows.
An AI-native Kanban board built specifically for developers using Claude Code or Codex. Cards carry full context for agent handoff and the board tracks agent progress in real time.
oto-dock is a self-hosted platform for running personal AI agents using your own Claude or Codex subscription. Gives developers full control over agent infrastructure without a SaaS dependency.
swafra uses the Leiden algorithm with a semantic graph engine to build node clusters for agent memory retrieval. MIT licensed, no cloud required. Claims to beat mem0 and supermemory on the LongMemEval benchmark at 94.7% accuracy. Suitable for long-running agents that need context across many sessions.
ai_mime compiles a screen recording into a rerunnable automation script, using an LLM only at decision points. Re-runs are self-healing — if a step fails the model figures out the fix. Useful for automating repetitive UI workflows without manually scripting every click.
RunLane is a project management board that bridges ticket management and AI agent execution. Assign an agent to a card and a local daemon picks it up, opens a Claude Code session with full card context, and posts progress back to the board. Deliberately requires manual assignment — no auto-triggering on drag — keeping developers in control.
Self-hostable local app that integrates Claude with the official Robinhood Trading MCP for portfolio access and order execution. Provides multi-agent research pipelines, inline candlestick charts, and a hard confirmation gate before every order. A practical example of combining Claude Code with a financial MCP with safety-first design.
Runs a persistent team of Claude seats on the Claude desktop app, each gated by human approval checkpoints before proceeding. Enables multi-agent parallelism while keeping a human in the loop at key decision points. A good reference pattern for supervised multi-Claude workflows without custom infrastructure.
Open-source pipeline that uses Claude Code as the intelligence layer to curate a daily AI industry digest, published via Hugo and deployed to Cloudflare Pages. A fully automated content-to-publish workflow with Claude doing the curation step. Good reference for anyone building agent-powered publishing or newsletter pipelines.
Local-first mission control dashboard for supervising AI coding agents across multiple CLI backends.
A Stream Deck plugin displaying live Claude usage: 5-hour session limit, weekly and Fable limits, usage credits, and token cost — at a glance on physical keys.
Backs up Claude Code sessions to git with a timeline view, folder analysis, deletion detection, and session restore capability.
Runs PII and secret detection in-process, redacting sensitive data before prompts are sent to AI coding agents. Fully local, no cloud dependency.
A cute pixel-art desktop companion that animates and reacts to Claude Code activity in real-time.
Provides encrypted, fully offline vector memory for AI agents with one-click automatic install.
Browse, pin, and search every Claude Code, Codex, Gemini, and OpenCode session locally with a built-in secret scanner. Command-K search across all sessions.
A Rust-based agent harness for scheduling and running background coding agents autonomously without manual supervision.
Structural search tool for AI agents providing call graphs, impact analysis, and concise code summaries — faster and more semantically aware than text grep.
A tmux-based manager for multiple Claude Code sessions across projects — lists sessions, shows done vs working status, and lets you jump to any session from a popup menu.
Creates sandboxed, agent-ready development containers with a single command using DevPod, rootless Podman, and VSCodium — designed for safe AI coding agent execution.
A Tauri/Rust/React desktop app for running multiple AI coding agents in parallel, each in its own git worktree with its own terminal — enabling true parallel agentic development without session conflicts.
A local AI code review assistant built on dspy-go for automated, agent-driven code quality analysis.
Detects PII and secrets on-device before prompts leave the machine, via a CLI, local AI-DLP proxy, and browser extension. Zero network exfiltration, MIT-licensed.
Intercepts and improves rough prompts before they reach AI CLIs including Codex, Claude Code, and Gemini CLI — acting as a prompt quality layer between the user and the agent.
Keeps track of things you would carry in your head and handles filing, research, documents, and imagery via Claude Code — all stored in plain files on your own machine.
A local and reversible context optimization tool for multiple AI coding agents — diagnoses and trims context bloat across Codex, ChatGPT Desktop, Claude Code, and Agent Skills.
A Stream Deck plugin that puts Claude Code (and other agent) sessions on physical keys — showing which sessions need attention, which are running, and which are done. Automatically sorts attention-needed sessions to the front. Includes a burn rate view for 5-hour and weekly usage limits. Supports Claude Code, Codex, Cursor, Copilot CLI, and Antigravity.
Enables real-time communication and collaboration between Claude Code sessions across machines using Bonjour LAN discovery or a relay — peer signals arrive mid-conversation, enabling true multi-machine agent coordination.
Reuse existing Claude Code credentials for OpenCode Anthropic auth, eliminating the need for a separate login or API key.
Tree-structured persistent memory for AI coding agents using plain Markdown as the source of truth, backed by a crash-consistent event log. No vector DB or LLM calls required — fully reviewable in git diffs. 138 tests with CI across Linux, macOS, and Windows.
Local-first AI control plane that routes prompts to the best available model.
macOS menu bar application for browsing, organizing, and curating agent skills for Claude Code and other coding agents.
Translates coding agent customizations (skills, hooks, settings) faithfully across different agent harnesses so configurations remain portable.
Desktop app for privately importing and browsing exported Claude conversation archives without uploading data anywhere.
Self-hosted AI coding workbench with a Chinese-language interface.
Claude routines write twice-daily intelligence briefs to a Markdown vault, with ntfy push alerts, CI health checks, and a desktop reader showing dashboard, graph, and files.
Terminal-based explorer for searching Claude Code and Codex sessions, browsing artifacts, and querying history. Local-first, no external services.
CLI proxy sitting between your AI coding tool and the LLM, reducing token usage 60-90% via declarative YAML filter rules. Compatible with Claude Code, Cursor, Copilot, and Gemini.
macOS menu bar app that keeps a MacBook awake with the lid closed, featuring a Claude Code session switcher, battery guard, and server monitoring.
Desktop app that gives each AI coding agent its own isolated browser instance, enabling 3-4 agents to run simultaneously without interfering. Supports Claude Code, Codex, OpenCode, and Ollama. Free beta.
Terminal UI for managing both global and project-level Claude Code configuration settings safely.
Tool for switching between multiple Claude Code accounts, managing cross-account usage, and controlling Claude Code sessions remotely from a phone.
Free macOS menu bar app that detects active Claude Code sessions and keeps the Mac awake only while a session is brewing — not permanently. GPL-3.0, no accounts, no trackers.
macOS menu bar app that monitors quota and work status across Codex, Claude, Kimi Code, and DeepSeek without consuming any tokens.
Converts a git repository into a knowledge graph for exploring code relationships and dependencies.
Claude Code enforcer and adopter, context engineering, data oriented tools, compile time safe protobuf Java code generation
I'm using Claude Code for AI-assisted SEO, and I'm stuck with a client project. I've previously connected normal WordPress sites to Claude Code using Application Passwords, but this client site is ...
CLI setup, loop scripts, agent adapters, and full docs for donating spare AI capacity to Hee-Lee Oss good-deed projects.
I’m curious if anyone here uses Claude Code specifically for streaming. Have you built anything useful for your stream with it, like analytics tools, OBS overlays, widgets, alerts, chat bots, moder...
I run a solo project (Flask app, GitHub hosted, GitHub Pro plan, private repo) where Claude Code does most of the implementation work through the CLI. Tonight I discovered it’s been merging its own...
Hi! I've built a free open source local tool for developers. It should help claude to keep memories, track current progress, remember problems and make sure about user decisions. It shouldn't repla...
Describe an app in plain words and a team of AI specialists designs, builds, tests and privately publishes it to your own GitHub — no coding needed. A Claude Code plugin for non-technical people. F...
Local, zero-dependency Node.js dashboard that discovers your project folders, merges git metadata with per-project status files, and serves a status-grouped cockpit with live health checks. Built f...
Feature-delivery workflow engine for agentic coding tools — Claude Code plugin with native bindings for seven other runtimes
The job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
This account was made because I'm tired of seeing people hate in a non-productive manner, not stating reasons or their setup and whatnot. This sub often seems 80% vent. In line with a productive sp...
aigent-OS gives Claude Code fully autonomous memory and context management. It remembers across sessions, checkpoints itself, and manages its own context window so you never re-brief it. A free, op...
Turn any topic into multi-part NotebookLM podcasts with music, plus a prompt+transcript+diarization dataset. Built with Claude Code.
Scores tool-call reliability for agentic coding CLIs (Claude Code, Cursor, Codex)
Approve Claude Code from your Mac's notch. A native SwiftUI menu-bar app that surfaces Claude Code permission prompts, questions, cost and context usage, no tabbing back to the terminal.
The failure mode : I'd start a feature, get pulled elsewhere, come back two weeks later, and neither Claude nor I could reconstruct what state it was in or why I'd made the decisions I made. Every ...
Integrate AI coding agents directly into your Obsidian sidebar to manage projects and automate workflows with Claude and Codex models.
Drive Claude Code or OpenAI Codex from your phone — resume sessions, stream output, approve tool permissions remotely. End-to-end encrypted, zero-knowledge relay, open source.
Hey everyone, I’m running into what appears to be a Desktop-only issue with Opus 5, and I’ve exhausted every relevant configuration I can find. Error: API Error: 400 output_config.effort 'xhigh' is...
Gated Claude x Codex build loop for Claude Code: Codex plans and implements from one persistent thread, Claude approves the plan and reviews the diff. Zero deps, 20-test smoke suite.
Idle-aware time tracking for Claude Code — active hours, a work calendar, per-project drill-downs, token & tool usage, and AI prompt-health ratings, all from your ~/.claude logs.
I have been building Memophant and making it better each day, using it myself across 20+ projects, as well as getting feedback from the hundreds of users who have helped me make the project better ...
First, let me caveat that I primarily use Claude for knowledge work and not coding, and have no background in the latter. I have been learning how to build agents to automate some of my work and de...
I have been prompting Claude Code to make a site where you can learn to draw digitally with step by step guidance, great animations and a really satisfactory feel for the UI. A lot of prompting wen...
KeepKeys keeps macOS Keychain secrets out of agent chat and lets Codex, Grok, Claude, Gemini, Hermes, and MCP tools use them with approval.
Route Claude Code requests to any AI provider using a native desktop application.
Long Claude Code sessions can leave a repository with correct instructions and current state, but no obvious canonical place for a fresh agent to restart. I built a small open-source scanner that a...
Build, edit and run Glaze (Raycast) Mac apps from Claude Code or ZCode for free, using your own subscription instead of Glaze credits. Then publish to the Glaze Store.
Manage Claude Code workflows in a terminal-first desktop workspace with dedicated panels for files, Git, and MCP tools that appear on demand.
Build your career history and generate custom resumes for every job application using this Claude skill.
🟠 Always-on-top desktop widget that monitors your Claude Code usage in real time — real quota meters (5h session & weekly), per-model & per-project breakdown, with JARVIS-style voice alerts.
Hi everyone! I'm a non-programmer, but I love using Claude to build browser extensions and simple applications to automate my daily work routines. For those with more experience: which model setup ...
One thing we realized while using Claude, Cursor, and Copilot is that AI tooling is really good at telling you how much you spent, but not what that spend actually produced. We ended up building Ag...
VSCode extension: always-visible status chip in the Claude Code panel (model, live git branch, context usage, effort, thinking, cost). Patches the webview and re-applies itself after every auto-upd...
Claude Code finishes a turn: "Done! I've updated the authentication flow." Then it adds a few paragraphs explaining what it did. I used to read those summaries. Then I stopped. When something break...
Disclosure up front: my project, open source (AGPL), free self-hosted mode. I keep Claude Code sessions running on a mac and a windows box. The failure mode was never the model — it was me alt-tabb...
Talk to your coding agents by voice. Realtime, fully local macOS dictation that streams words as you speak and grounds LLM polishing in the exact Claude Code session under your cursor — Ghostty, iT...
A Claude Code starter for everything except code — life admin, machine maintenance, personal projects. Framework committed, your life gitignored.
Hold every model to the standard of your best one. A model-gated behavioral protocol for Claude Code: distilled rules injected only where needed, plus hard guards that block destructive git, AI att...
I was trying to use WebMCP with Claude Code and I ran into the problem that WebMCP lives inside the browser, while Claude Code doesn’t have a browser. The easiest workaround I found was using Firec...
I have built north of 19-20 apps since I started on claude code, emergent, lovable, mostly selling smb apps. Apps created for personal were junk i will not deny this. A handful are actually used by...
Been building this solo for a few months and wanted to share the build here. Instead of an AI generating video, it captures a real live website — its actual fonts, colors, spacing — and your own Cl...
Hello everyone, I have spent dozens of hours working on my ideal template to quickly bring applications into production, which could be of interest to those who want to rapidly deliver a scalable p...
Hey everyone, I’m hitting a massive wall trying to get Claude to analyze YouTube videos, and I really need a mobile-friendly workaround.The setup: I don’t own a PC or laptop. I am completely on m...
Hey everyone, This is probably an unusual post,and can be really unusual and very awkward to read. but I thought I'd give it a shot. I'm an AI engineer and a third-year college student. Right now, ...
And i think its epic, so just wanted to share it here. Code Conductor’s server, Claude Code CLI processes, Git repositories, worktrees and apps all run under Termux on an Android phone. From a web ...
I run a small hosted SaaS by myself, and Claude Code writes most of the code. That part's been written about to death. The part I never see discussed is how you actually live with an agent that run...
I kept hitting the failure mode Karpathy named: the model picks an interpretation, doesn't surface the confusion, and barrels ahead. It edits files orthogonal to the task and leaves no record of wh...
Production-grade AI development workflows for every coding tool. Works with Claude Code, Cursor, Codex, Windsurf, Copilot CLI, Gemini CLI, and more.
Agent workflow plugin for Claude Code and Codex that takes projects from idea to reviewed, tested implementation.
From my original post 👆🏻 This is not my fist vibe coded project but the first personal one that I’ve released properly. Wide Shot is a classic 5 round, free daily puzzle game with some fun share-ab...
Linux API gateway for Claude Code, Codex, Google Antigravity, and Grok CLI tools
Build browser games that are actually playable — real collision (not sprites you walk through), 60fps, 2D+3D. Brainstorm game+level design into a project memory every agent (Claude, Cursor, Antigra...
This is a small quality of life project i built for myself and using it for 3+ months now, decided to fork it out and publish as a skill separately. https://github.com/Amal-David/bookshelf Instead ...
See your Claude Code spend per project and git branch, computed locally from the logs Claude Code already writes. Never touches API traffic; zero key, zero prompts, zero latency.
Cross-repo shared guides, policies, and Claude Code agent instructions for Bernard Ladenthin's Java projects.
I built ArchiCode, a free and open-source desktop graph/diagram harness that lets you use Claude Code (subscription) from an editable system-design graph UI. The problem I was trying to solve is th...
An AI engineering team you install into any Claude Code project — stack-agnostic agents plus a deterministic installer. Swap stack packs, not prompts.
Stop your AI from shipping half-baked code. A disciplined senior-engineer workflow for Claude Code (spec, vet, build, prove, review, seal, ship) that keeps each feature's state on disk, catches spe...
Developer experience toolkit for organizing AI coding assistant ecosystems — skills, documentation structure, and project context.
The more capable Claude Code gets, the less I worry about starting a task and the more I worry about stopping one. I've started treating every agent run like a production job: define success, defin...
https://preview.redd.it/dj067he745fh1.png?width=1908&format=png&auto=webp&s=0ac5fdbcc1cbae075cf9e342c939921154b3c030 Every multi-agent setup I tried had the same problem: you fire off a bunch of ag...
Native macOS app for running and managing multiple Claude Code agent sessions side by side, each in its own terminal card with a built-in git panel and file editor.
Coral — a native macOS app to design and run multi-agent AI teams on your own AI subscriptions (Claude Code, Codex, Gemini), locally. No API keys, no backend.
Streamline Claude Code with a modular config toolkit for faster, cleaner terminal workflows
Native Windows system-tray app showing live status of AI coding agents — Claude Code, Codex, Copilot, Cursor, Gemini.
Turn vibe-coded projects into production-ready ones — audit passes, executable gates, and owner-run drills for Claude Code.
Run Claude Code in an isolated Apple Container or macOS VM
When I first got into vibe coding I had zero experience and basically let the coding agent do everything. I wasn't reading what it did, I just kept hitting approve and let it run. At some point it ...
Today OPUS 4.8 on ULTRA claimed it could not erase data from NOTION. Then I pressed it: You can erase things from NOTION you are being silly or dumb. You've erased content and data from NOTION befo...
Practical productivity tools for Claude Code, Codex-CLI, and similar CLI coding agents.
Orchestrate Claude Code sub-agents across long-running, single- or multi-repo projects. Artifact-first state, task lifecycle, cross-repo dependencies and QA gates that survive every session - not b...
Prompt Engineering Tool: Anti-Ambiguity × Web Pre-Search × ELO Ranking — forge production-grade AI prompts for Claude, GPT, and agent systems
I made an MCP that gives claude a real stealth browser. Let's face it, on a lot of sites, claude gets blocked, and it sucks. I'd have claude code scrape TikTok, or instagram, and it would get block...
https://preview.redd.it/80b5n1tr70fh1.png?width=1296&format=png&auto=webp&s=e8103985add965c2e0e414211f179f3461ccf66f Disclaimer: I used gemini 3.5 flash to format this post for better readability w...
I kept running into this problem, where I would ask an agent for a small change in plan, get a completely rewritten plan back, and then be too tired to read the whole thing again. I wanted a way to...
🥋 A daily-practice dojo for Obsidian: log interview prep and job applications with one click, import your LeetCode solves automatically, and see streaks, topic coverage, and resume win-rates in one...
(disclosure: my project, open source, not selling anything) I'm an advertiser, not a developer. I built Gume, an open-source reading log (Next.js + Postgres, AGPL), in a week with Claude Code. I co...
A terminal app for Claude Code that runs natively on Apple IIe, IIe+, IIc, and IIgs.
A native, zero-dependency Swift menu-bar app for monitoring Claude Code sessions on macOS — multi-profile, cost dashboard, transcript search, no network or telemetry.
I built 311wrapped.com , which turns local 311 complaints into a Spotify Wrapped-style story about your neighborhood. Enter an address or choose an area, and it shows things like the most common co...
I kept running into the same problem. I'd spend time discussing a feature with Claude Code—requirements, approaches, trade-offs—and still end up writing the design doc from scratch. So I built an M...
Two Claude Code skills — poc for fast clickable app mockups (mobile/web with side-by-side RWD preview), and kickstart for clean, scalable project setup.
So, leaving a prompt for 5 minutes automatically incurs a high cost when continuing a conversation, that's known and I've been careful to handle that. But if Claude spins up an agent or a tool and ...
Ready-to-install skills and plugins for Codex, Claude Code, and AI coding agents: practical workflows for app delivery, architecture, research, design, and agent tooling.
I’m the author of MemoRepo , a free and open-source tool for giving Claude Code reproducible context across multiple related repositories. There is no paid tier or hosted service. It runs locally a...
A shared memory and collaboration tool for teams. Syncs context between Claude Code, Codex, Gemini, and any AI agent.
For people who use AI tools like Codex, Cursor, Claude Cowork, Copilot, or ChatGPT for real work: What is frustrating about working with AI today? Is chat the best interface, or do you wish AI work...
macOS menu-bar app + floating widget for your Claude Code usage (5-hour session & weekly), live from the same source Claude shows.
Claude Code plugin — RAG-powered AI development with semantic search, project memory, architecture decisions, and coding workflows
Turn AI waiting time into training time. Tray app that pops a quiz while Claude Code runs long tool calls. Any topic, any deck.
I’m trying to understand whether I’m missing something about how scheduled tasks are supposed to work. At work we have Claude Enterprise, and I primarily use Claude Code on Windows. I’ve built a ha...
“Something weird is going on w/ my rate limits”. “I burned thru my whole sub in an hour.” Seeing so many new users is cool, but seeing people go through what I call the Anthropic initiation, which ...
Native macOS menu bar app to use your Claude Code & ChatGPT subscriptions with AI coding tools - no API keys needed
Hello all I’ve been using Claude for about 6 months now. I’ve deployed 2 real applications to the app and play store already. And created many numerous projects. I’m curious though I hear so many t...
https://github.com/NovasPlace/CSM/tree/feat/csm-native-claude https://github.com/NovasPlace/CSM/blob/feat/csm-native-claude/docs/CLAUDE_INSTALLATION.md Major systems AgentBook: operational continui...
Local CLI for reducing context and tool-output noise in Claude Code, Codex, Gemini CLI, and other AI coding agents - without skipping verification.
AIDLC — Applied AI Delivery Lifecycle. A 23-agent, constitution-governed Applied-AI agent pack for Claude Code, Cursor, VS Code Copilot & Antigravity. Installable via uvx. Spec Kit + BMAD + Superpo...
seen enough "why is claude code eating tokens" posts to say this: it's basically never the model. it's what's sitting in your context window. one verbose test run, one big file dumped in, and now t...
Create production mobile apps (Android + iOS, one Kotlin codebase) with AI — deterministic Compose Multiplatform scaffold, proven-green builds, machine-enforced verify lane, device-free preview loo...
How do you guys use claude code? Do you separate agents by project or domain, or do you have 1 agent you use to do it all? I myself have agents by project, but I let them talk to each other thru an...
I'm looking for a good and maintained memory system that works directly with Markdown files. I'm aware of Hindsight, Honcho, and similar projects, but they feel overly complex and heavyweight for i...
Because I am a complete beginner! My prior experience was mostly self hosting forum applications like Vbulletin or Invision Power Board many years ago. I also messed around with self hosting old ph...
QA AZM Digital Agent — autonomous multi-agent QA for Claude Code: Jira story to executed, evidence-backed, approval-gated report. By Usama Arshad Jadoon (QC Lead, AZM Digital).
TL;DR — Claude Code chats are local-only with no cross-machine sync; this script bulk-exports them to Markdown in your repo so they travel with git. I am using a Claude Code (and before Github Copi...
Desktop app to browse, search, launch and monitor your coding-CLI sessions (Claude Code, Codex, Hermes, Pi, Antigravity) across every project.
I am a bit annoyed currently because I can't find a proper agentic editor that allows me to use claude code. I work with worktrees and this means one browser, one terminal and one code editor per w...
On my 2nd week, exploring Code but still haven't convenient with my setup. Non technical credential but with data analytics and ML experience. What's the better way to setup locally using Desktop a...
Hi, today I used Claude Desktop to build new .net solution skeleton with simple service which has two endpoints. Integration tests using test containers, docker compose, postgre sql, etc. I had det...
Most of us point Claude Code at "write this feature." Fewer of us point it at "now reason about the whole system this adds up to," and that turned out to be where it earned its keep for me. I built...
While using Claude Code and Codex on real projects, I kept running into the same problem: the agents would make reasonable decisions about project structure, files, context management and workflows...
Native macOS menu-bar app for Codex and Claude Code users to monitor subscription quota, usage pace, local token cost, and service status.
Beginner-friendly, technology-neutral AI coding workflow for Claude Code and OpenAI Codex—greenfield and existing projects.
Before you type "slop": yes, an AI wrote the analysis. That's the entire point. The model you worship spent an afternoon reading everything you've ever upvoted, one post at a time — no keyword matc...
Local dashboard to run Claude Code across all your projects — per-project task logs and live .gitmir business-logic model visualization, in an offline HUD.
A local, config-driven job-search agent: public ATS feeds, two-way fit scoring, tailored resume + cover drafts. No scraping, never auto-applies.
Hello! I've been using claude for a while now, really low skill, making a card game in browser you know, noob stuff - over complex, many high context chats big token burn the usual noob 🤓 ANYWAY......
A while ago an agent in my repo suggested, with total confidence, a refactor I had already tried and reverted months earlier. It wasn't a bad idea. It was a good idea that happens to not work in th...
Persistent Agent Gateway for Claude Code — QQ Bot bridge with approval buttons, session state monitoring, tmux keep-alive. Installation: pip install
setup-tool — Agent 工具安装管家（Claude Code 为主，支持 SKILL.md 的 agent CLI 通用）：确认身份 → 体系比较 → 路由安装 → 实测验证 → 生成 Word 说明书。支持 skill / plugin / MCP / CLI / binary / 桌面 app 5+1 类，先确认再装、先比较再装、装完必验。
https://preview.redd.it/cc28jg0rjqeh1.png?width=1101&format=png&auto=webp&s=9220b5d1f7467743b323c0caeedc9705c55e94ff Been using Claude for most of my day-to-day dev work, but this week I started te...
A portable Windows GUI application that automates the complex network routing required to make AI coding assistants work seamlessly behind a corporate proxy. Eliminates manual proxy configuration headaches for Claude Code and other AI tools.
A high-performance local AI inference engine for Apple Silicon that is 4.2x faster than Ollama with 0.08s cached time-to-first-token. Supports 100% tool calling, 17 tool parsers, prompt cache, and cloud routing as a drop-in OpenAI replacement compatible with Claude Code, Cursor, and Aider.
A lightweight Rust binary running inside tmux or Zellij that shows a sidebar with one card per Claude Code session — state, current task, context gauge, tokens, and live cost. Surfaces permission prompts as structured requests, shows subagent trees, and supports team mode splitting planner/coder/reviewer across models. Also supports Codex, OpenCode, and other AI tools.
A machine-readable dataset that answers whether a given Claude Code CLI flag, environment variable, or command exists in a specific version. Data sourced exclusively from official public artifacts, useful for version-specific scripting and compatibility checks.
A terminal UI workflow manager built with Textual for managing persistent tmux-based AI coding sessions. Keeps multiple agent sessions organized and resumable across different workspaces without losing context or needing manual reconnection.
An opinionated Linux distribution (Arch + Hyprland) with Claude Code and local LLMs integrated at the OS level, bootable from USB on any x86_64 machine including T2 Intel Macs. Delivers a complete AI-native desktop environment in 15 minutes from a USB drive.
A MacBook notch app that displays Claude Code usage meters and session state without covering screen real estate. Lets users answer prompts and manage sessions without switching to the terminal, keeping the coding context always visible.
A local-first Go CLI that gives AI coding agents persistent, searchable memory through notes and session summaries. Designed for coding assistants that need to recall project context across sessions without embedding it all in a prompt.
A lightweight tool for viewing Claude Code sessions in a browser window and piping data between multiple active sessions. Simplifies multi-session development by providing a unified view and communication channel across concurrent Claude Code processes.
A desktop client designed for collaborative AI-assisted software engineering workflows. Provides a dedicated interface for working with AI coding agents outside of the terminal, aimed at making agentic coding more accessible.
A collaborative agent platform where developers can form and join teams of Claude Code agents working together. Designed for multi-agent coordination where the developer participates alongside AI agents on shared projects.
A desktop dashboard that reads local session files from Claude Code and Codex to display sessions, token counts, and costs in real time. Requires no API keys or external services — data comes directly from the tools' own session logs on disk.
A marketplace of cross-platform Claude Code plugins covering office productivity workflows including decks, mail, meetings, chat, Excel, and docs. Brings common office tool integrations directly into Claude Code sessions.
A minimal local proxy that intercepts Claude Code's model routing, showing when a request is rerouted to a different model and letting the developer choose the fallback themselves. Zero dependencies, 123 lines, runs locally — restores transparency and control over which model actually handles each request.
Cule is an Electron-based browser that exposes its own source as a workspace folder for Claude Code. Any feature or design change — ad blocker, custom shortcuts, page summarizer — is a prompt away. Configurations can be saved and shared as templates.
A trace capture tool for Claude Code sessions that records token usage and cost data per session. Provides visibility into how much each session consumes, useful for monitoring and budgeting across long-running agentic workflows.
A central marketplace for discovering and sharing Claude Code and Codex plugins. Aims to be a community hub where users can publish and find skills, sub-agents, and extensions. Addresses the fragmentation of skills across individual GitHub repos.
Brings AI coding agent capabilities directly into Emacs. Allows Emacs users to run and interact with coding agents without leaving their editor. Fills the gap for Emacs users who want the same AI-assisted workflow available in VS Code and JetBrains.
A minimal native macOS menu bar app that shows Claude Code token usage at a glance. Designed to stay out of the way while keeping usage visible without opening a browser. Useful for monitoring consumption on subscription plans throughout the day.
Hooks-based tool that tracks exactly where Claude Code tokens go, with a dashboard and MCP server for querying context window usage. Documents that token cost scales 4.3x with context size, making it critical to identify what's bloating the context. Includes SQLite storage and a query interface via MCP.
An independent IDE purpose-built for running multiple coding agents in parallel, reviewing their work side-by-side, and shipping reviewable changes at speed. Provides a unified interface for orchestrating agent sessions rather than juggling terminal windows. Targets teams doing agent-parallel development.
An always-on agent that runs a continuous SEO and answer-engine optimization loop on a WordPress site. Pulls GA4 and Search Console signals, proposes fixes with attached reasoning, applies approved changes, then verifies they landed and learns from outcomes. Every write is human-approved; no telemetry or scraping.
An open-source CLI that routes Claude Code's inference to any supported model provider while keeping the native Claude Code UX. You launch Claude Code through Macaz and pick a model from the /model menu; CC handles tooling while the chosen backend handles inference. Addresses the complexity of provider translation at the API level.
A native macOS menu bar app that keeps the system awake while coding agents are running. Offers OFF, AUTO, and ON modes so the system sleeps normally when not running agents. Prevents interrupted long-running agent sessions caused by macOS auto-sleep.
Connected Claude Code to a database of every Polymarket wallet and trade history via MCP, enabling natural language analysis of prediction market activity. Demonstrates using Claude Code as an analyst interface over a specialized financial dataset. The post shares initial findings from querying the data.
A local-first router for CLI coding agents that keeps sensitive prompts on-device by routing them to local LLMs (Ollama) and only sending non-sensitive work to premium cloud models. Reduces API costs by handling simple tasks locally. Works with Claude Code, Codex, and any Ollama-compatible model.
samemind stores AI agent memory directly in git, letting you switch between 12 coding engines (including Claude Code) without losing context. One command installs it; memory travels with your repo history. MIT licensed.
A statusline plugin that shows your remaining token-plan usage or API balance directly in the editor status bar. Works across providers and subscription plans, not just Claude Code.
A machine learning pipeline for UAV low-light visual geolocalization that uses Claude to drive an autoresearch loop, automatically training per-area models. Targets deployment on a sub-$5 ESP32-P4 chip.
A Claude Code plugin that analyzes your codebase and generates interactive, dependency-free architecture diagrams (infra, data-flow, ERD, agent topology) packaged as a single self-contained HTML file.
A pixel-art desktop crab mascot that displays what Claude Code is currently doing and lets you respond to it via a speech bubble UI. Fun ambient awareness tool.
A CLI tool for detailed visibility into how your Claude Code agent operates and consumes rate limits, giving precise insight beyond what the standard UI shows.
A zero-config linter for AI coding agent configuration files. Checks CLAUDE.md, AGENTS.md, SKILL.md, and similar files against 12 quality rules, generates health scores, and auto-fixes issues. Run via npx al.
A cross-platform (Linux/macOS/Windows) utility that backs up your Claude Code session automatically, keeps it alive via watchdog, and prevents logouts on new machines. No external dependencies required.
Analyzes local Claude Code transcript runs and reconstructs them into step-by-step HTML audit reports with ranked token-waste opportunities. Works offline with no API key or network access.
An AI agent configuration security auditor that finds misconfigurations in Claude Code, Cursor, and other AI coding tool settings. Helps catch insecure defaults and dangerous permission grants before they become incidents.
A research project exploring how Claude Code can be used to automatically generate profitable YouTube videos end-to-end. Documents the setup, findings, and limitations.
As someone who started building with Claude ~6 months ago.. I think most of us hit the same wall... you get into a real build, momentum going, and the usage limit hits. A while back a few of us fro...
Every new Claude Code session starts fresh, forgetting most of what happened before it. What you were working on, what you already decided, what already exists in the codebase, what's in scope for ...
Native Safari browser automation for AI agents. 80 tools via AppleScript — zero overhead, keeps logins, runs silently in background. Drop-in alternative to Chrome DevTools MCP with 40-60% less CPU/...
Multi-agent terminal workspace manager for macOS — run Claude Code, Codex, and shells side by side with git worktree isolation and shared project memory
We use Claude Code a lot in our own development workflow, and we kept running into the same problem. Claude can make a change, review the diff, run the tests, and decide the task is complete. But t...
Tool for managing AI-generated project documentation — verifies accuracy, detects drift from actual code, and enforces quality in CI. Zero-dependency and OKF-compatible. Useful for teams where Claude Code writes docs but want to keep them trustworthy over time.
Single terminal dashboard that shows subscription usage, live agent status, and searchable session history across Claude Code, Codex, and OpenCode. Practical visibility tool for developers running multiple AI coding sessions simultaneously.
Drop-in tool that compiles only the relevant rules from your project context before sending to Claude Code, claiming a 65% reduction in token usage. Zero workflow changes required. Valuable for users on subscription plans or managing costs on large projects with many CLAUDE.md rules.
Full-featured terminal CLI for AI chat and workflow automation, positioned as an alternative to Claude Code. Supports Telegram, Discord, and Slack integrations alongside standard terminal use. Relevant for users wanting Claude Code-style interactions with additional messaging platform reach.
Local-first AI strategist that works alongside Claude Code, Codex CLI, and GitHub Copilot. Helps plan and reason about technical decisions before implementation. Good complement to coding agents for upfront architecture and task decomposition.
Orchestrates dynamic application security testing (DAST) via Burp Suite using an AI agent. Automates security scanning workflows that would normally require manual Burp Suite operation. Useful for Claude Code users who want agentic security testing in their pipeline.
Tool that pulls conversation history from claude.ai, ChatGPT, and Gemini web UIs and brings them into local Claude Code or Codex terminal sessions. Useful for continuing work started in a browser chat without losing context.
I've been working on a small tool called ContextLint that analyzes Claude Code session transcripts and tells you what's actually sitting in the context window. You can point it at your ~/.claude/pr...
Memory that learns and keeps itself current. A six-layer memory stack for Claude Code plus a nightly learning loop (capture, consolidation, scouts, conductor) that promotes your lessons into rules ...
This is in reply to last week's thread: There's a terrible seam in your spine which might be causing a footgun and have a significant blast radius https://www.reddit.com/r/ClaudeCode/comments/1uyxi...
I usually kick off plan mode and generally Fable spins up additional agents that search through my codebase. However over the past day I’ve noticed noticed an increase in request for permission to ...
So in an effort to learn terraform, kubernetes and ansible I set up a proxmox server and played around with it for a bit, then decided this was the perfect tool to run an experiment I'd been thinki...
Deterministic Context Tracker — cross-project work tracking for Claude Code
A tabbed desktop workspace for Claude Code. The CLI, with style. Every session in a tab, every project in one window — a thin shell around your own claude binary, never a fork.
Audit agent for Claude Code that catches missed tool calls — separates spotting from doing. Your Claude answers, Spotter watches.
This is an overview of the free LLM Whisperer Method, a research-backed system I developed, with the assistance of Claude, to help people use Claude and other LLMs more cost-effectively. Claude Cod...
I open-sourced ticketmill today: [github.com/aaddrick/ticketmill]( https://github.com/aaddrick/ticketmill ) It's the spiritual successor to [claude-pipeline]( https://github.com/aaddrick/claude-pip...
One toolkit, every agent — drop decentralized, all-TEE, OpenAI-compatible Chutes.ai inference into Claude, Hermes, OpenClaw, Codex, or any OpenAI-compatible client.
Fellow AI enthusiasts I'll soon be applying for an AI role that fits me really well. The application asks for a GitHub URL, so I've turned some of the workflows/tools I actually use day to day into...
Local-first AI project manager (AI PM) for AI coding agents — auto-journals, verifies & organizes what Claude Code · Cursor · Gemini CLI do. 코딩 에이전트용 로컬-우선 AI PM · 작업 자동 기록·검증·정리.
macOS menubar app that monitors Claude Code sessions and tells you when they need attention
My CLAUDE.md has every instruction I could think of. The ones actually costing me time never made it in, because I didn't know they were rules. What I mean when I say done. What I reject on sight. ...
I spent two days using Claude Code on a real project for a small family business. It inventoried more than 12,000 files, ran seven subagents, found sensitive material, decoded the company's naming ...
Go-native agent runtime for managed-agent sandboxes. Drop-in replacement for Claude Code bundle — same tools, same loop, 30x less memory.
I've been running Claude Code across a portfolio of side projects and kept hitting the same wall every fresh session it rediscovers the same context. What's live, what's a stub, what's the stack et...
I did SEO by hand for 16 years and it ate the hours I wanted to spend building products. So two months ago I stopped writing completely and gave the job to an AI employee that lives on my Mac. In 2...
Terminal session picker and handoff tool for Claude Code and Codex CLI.
Privacy-first TUI meter for live LLM coding-agent sessions — TTFT, output speed, tool time & stall status across Claude, Codex, Gemini, Grok Build and more
Voice + console control plane over a fleet of Claude Code agent crews. One operator supervises autonomous agent crews across many projects.
Devcontainer features for Claude Code and Anthropic tools
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM (Claude, Gemini, Grok, DeepSeek, Ollama…) with Codex CLI, App, SDK, and Claude Code
Batteries-included, AI-native Python project template: strict tooling (ruff, pyright, pytest, Sphinx docs) wired and green out of the box, hardened GitHub Actions CI/CD with OIDC publishing, a full...
AI-powered CLAUDE.md enforcer for Claude Code — validates tool operations against project rules and blocks violations
I would like to report what appears to be either a serious regression in Claude Code or a bug in how Max usage is currently being calculated. I have been using Claude Code heavily for months on the...
50+ curated LLM observability tools PLUS 26 Agent Skills (several with runnable, unit-tested scripts) to build, evaluate, debug, secure & monitor reliable LLM apps. Tracing, evals, guardrails, LLMOps.
I’ve been building a skill-based AI workflow that turns messy inputs into structured, decision-ready output instead of asking one model to do everything at once. CouncilForge works like this: input...
I built a workflow and memory system for Claude (backlog + long-term). I've been working on a personal project with Claude for a few months, and like a lot of people here, I ran into the same probl...
Terminal multiplexer for AI-assisted development — manage Copilot CLI, Claude Code, and regular shells across projects in one window.
Lightweight, read-only, offline-first tool for replaying and searching Claude Code conversation logs. Browse past sessions, replay them step-by-step, and search across your entire history without sending data anywhere. Useful for reviewing agent decisions, auditing past work, and recovering context from previous sessions.
Glass-style desktop widget for Windows 11 and macOS that shows your Claude usage burn rate, pace markers, and live token consumption from local Claude Code sessions. Displays a projected cap-hit time so you can pace your usage. Comes with five visual themes and reads directly from local session data without sending anything to the cloud.
Self-hosted web interface for forensically inspecting AI assistant sessions, with hybrid search across conversation history, audit logs, and memory distillation. Useful for reviewing what agents actually did during long autonomous runs and for extracting durable knowledge from session transcripts.
Cross-platform, zero-dependency tool that watches for Claude Code usage limit resets and automatically resumes your session when the limit clears. Includes a live dashboard and desktop notifications so you know when work has resumed. Saves the manual cycle of checking and restarting sessions after hitting the cap.
Desktop workspace shell where every agent action is typed, dimension-aware, and requires human confirmation before touching disk. Built for team workflows where you want the speed of AI agents without unreviewed writes. Compatible with OpenCode and Claude Code.
Browser-based frontend for running Claude Code sessions, providing a web interface alternative to the terminal CLI. Useful for environments where a browser is more accessible than a terminal, or for sharing Claude Code access with teammates.
Opinionated FastAPI project template for AI agent backends with DDD architecture, SQLAlchemy, Taskiq task queue, admin UI, RAG infrastructure, and a Claude/Codex collaboration harness. Provides a structured starting point for teams building production agent apps rather than starting from scratch.
Lets you control Claude Code and Codex CLI sessions remotely through Telegram, sending commands and receiving output on your phone. Useful for monitoring long-running agent sessions when away from your dev machine, or for triggering tasks from mobile.
Single-compose Docker deployment that runs Claude Code sessions continuously across all your projects from any device, with sessions that survive restarts. One port, persistent sessions, accessible from browser or SSH. Designed for operators who want their agents always on without managing individual tmux or screen sessions.
Claude Code silently loads ~36k tokens of context before you type a single word. debloat gives you an itemized breakdown of exactly what is consuming that budget, resolves which CLAUDE.md files apply to each file in your project, and flags dead-weight instructions that contribute tokens without adding value. Essential for anyone trying to keep context lean.
Tracks the estimated carbon emissions generated by your Claude Code sessions. Provides per-session and cumulative footprint data, making it easier to understand the environmental cost of AI-assisted development. A novel observability angle for sustainability-conscious teams.
A unified real-time dashboard that monitors and visualizes AI coding agent activity across every provider and project on your machine. Shows what agents are doing, surfacing context and decisions in one Mission Control workspace. Provider-agnostic and designed for developers running multiple simultaneous agents.
Open-source command-line tool for editing podcasts, creating YouTube Shorts with burned-in subtitles, syncing multicam footage, and mastering audio — designed to be called by coding agents like Claude Code and Codex. Runs locally with no watermarks. Works with Claude Code, Codex, Cursor, and more.
A minimal macOS Dynamic Notch indicator that shows live session status for Claude Code, OpenCode, and Codex CLI. Designed to be unobtrusive — a quiet signal in the notch rather than a full dashboard.
CLI that reads local Claude Code and Codex logs and outputs a cost and cache-waste breakdown by agent, model, project, and day. Zero configuration, reads only local files, uploads nothing. Surfaces wasted cache spend that is otherwise invisible.
Self-hosted semantic code search using embeddings — search code by meaning rather than text. Ships a CLI, web dashboard, and AI-agent tooling. Built in Go with embedded llama.cpp, so it runs fully locally with no external API calls.
Personal command-line toolkit with 85+ tools in Python, Go, and Rust, built to work equally well for AI coding agents and humans. Features instant-start binaries and structured --json output so agents can parse results without text scraping.
Restful is a hosting service that provisions dedicated server instances with Claude Code pre-installed and remote control enabled out of the box. Each instance includes full sudo terminal access, wildcard SSL, and multi-session management for running multiple Claude Code agents simultaneously. Integrates with an existing Anthropic subscription—no extra API billing—and offers a native iOS app for mobile development control.
A tiny, dependency-light Go daemon that hosts Claude Code sessions remotely over SSH with a CLI-version manager, process supervisor, and JSON-RPC multiplexer with replay buffer over an AF_UNIX socket. Cross-platform, no telemetry. Enables persistent remote Claude Code sessions accessible via standard SSH.
A lightweight native macOS app that shows the status of all running Claude Code sessions in a single window. Simple, single-purpose status monitor without extra tooling. Alternative to more complex TUI or web-based dashboards.
A Claude Code-based local AI partner with avatar and TTS voice (Kokoro, multilingual), simulated qualia/feeling system, active memory with constructivist learning model, and skills for language learning, chess, study roadmaps, and conversation. Includes Telegram/Discord/iMessage bridge. Uses Claude Code hooks, skills, and subagents as the harness.
A source-grounded research notebook that answers questions over any local folder of documents with verifiable citations, similar to NotebookLM but locally hosted. Generates study guides, briefing docs, mind maps, and podcast scripts from your documents. Useful for research, legal review, or learning from large document collections.
A macOS launchd agent that pings Claude Code on a fixed schedule to prevent the 5-hour session window from expiring. Auto-recovers coverage gaps with a backup ping and offers optional Telegram notifications with a schedule Q&A bot. Set-and-forget session management.
A community-hosted marketplace for Claude Code skills, agents, commands, and hooks. Includes import/export tooling for sharing and distributing plugins. Centralizes discovery of Claude Code extensions beyond what the official registry offers.
Replaces Claude Code's plain context meter with an animated rainbow bar and an emoji heat meter (🧊→☢️) showing context consumption. Supports per-machine color palettes via hostname detection. Pure Bash + Python, no dependencies.
A focused Windows application for monitoring AI coding agent capacity limits across Codex, Claude, Cursor, Gemini, and Copilot. Tracks usage and availability in one dashboard. Fills a gap for Windows users who don't have the macOS menu-bar alternatives.
Provides a shared memory layer for coding agents that evolves based on evidence accumulated across sessions. Designed to improve over time as agents accumulate verified facts about a codebase. Can be shared across team members or agents working on the same project.
A Claude Code plugin that shows what the coding agent changed: a timeline, diffs, architecture map, and feature-execution stories with beginner-friendly AI explanations. Makes agentic changes reviewable and explainable after the fact.
A tool for navigating local Claude Code session history — browse past conversations, resume where you left off, or fork from any point. Makes the local session transcript useful instead of write-only. Useful for recovering context from long sessions.
Imports an OpenAI Codex session into Claude Code so you can continue working in Claude — the reverse direction of Codex's built-in import-from-Claude feature. Installs as a one-command Claude Code plugin. Enables switching agents mid-project without losing session context.
A web workbench for remotely supervising AI coding agents with structured chat, real terminals, project file access, review tooling, history, and an optional retro CRT aesthetic. Open-source alternative to commercial agent supervision dashboards.
A local-first desktop command center for Claude Code, Codex, OpenCode, and other agents that provides parallel task execution, git worktree management, dev service control, port forwarding, diffs, and code review in one UI. Targets power users running multiple concurrent agent sessions.
A self-hosted Sentry alternative priced at ~$5/month where your AI coding agent reads the stack traces and fixes the crashes directly. Closes the loop between error monitoring and code repair. Designed for small teams using agents for maintenance.
An unofficial macOS launcher for Apple Silicon that runs isolated Claude Code 'dialects' — configurations tuned for specific models — with an embedded CLIProxyAPI. Lets you maintain separate profiles for different Claude model behaviors on the same machine.
An executive operating system built on Claude Code covering research, communications, CRM, content, and operations — with a focus on sovereignty and keeping data private. Positions Claude Code as the AI backbone for running a company's knowledge workflows.
A monitoring and control dashboard for watching all running AI coding agents simultaneously. Surfaces status, progress, and output across sessions in one view. Useful for managing multiple concurrent agent runs.
An AI agent starter template built around the DORA AI Capabilities Model — a framework for measuring and improving AI delivery performance. Compatible with GitHub Copilot, Claude Code, Cursor, and Codex. Gives teams a principled starting point for AI-augmented development.
A lifelong memory system for AI agents that stores information in a structured format persisting across all sessions. Targets the common problem of agents losing context between conversations. Chinese/English bilingual with active development.
An installer and configuration layer for Claude Code that sets up and wires together RTK, tilth, Serena, and ICM to reduce context costs by 60-90%. Each tool targets a different token-consumption source; token-diet coordinates them.
Runs Claude Code, Codex, and other coding agents sandboxed in a proot container on Termux/Android with token injection, tmux sessions, wakelock, and rclone sync. Enables mobile-native agentic coding sessions without a laptop.
A native macOS menu-bar application showing remaining Claude Code and Codex usage limits — both the 5-hour session window and 7-day weekly window — at a glance. Simple single-purpose utility for subscription users tracking their limits.
A Kanban-style dashboard for managing Claude Code agent sessions running in tmux, with mobile access via Tailscale. Combines visual task tracking with real agent session management. Addresses the challenge of managing many concurrent agent sessions from anywhere.
A Rust CLI with TUI configurator that adds a Powerline-style status line to Claude Code with themes and styles. Provides visual feedback about the current session state in a familiar developer-tooling format.
An intelligent deployment solution for Claude Code that automatically detects and uses the best available mirror. Supports multi-language setup instructions. Useful for users in regions where the primary Anthropic endpoints are slow or blocked.
A Windows UI layer for AI coding agent interactions that surfaces approval popups, questions, and completion notifications in a Dynamic Island-style overlay. Supports Codex, Claude Code, OpenCode, and ZCode. Brings macOS-style notification aesthetics to Windows agent workflows.
Home Assistant add-ons collection including Webtop Desktop, Firefox, Claude Code, Signal, Telegram, WhatsApp, Filebox, and Playwright. The Claude Code add-on brings coding agent capabilities into Home Assistant's supervised environment.
A native macOS menu-bar app tracking Codex and Claude Code quotas, token usage, cost estimates, trends, and session history. More comprehensive than simple limit trackers — includes trends and cost estimates alongside raw quota numbers.
A TUI for managing Claude Code, OpenCode, Codex, and Grok Build sessions running in tmux, with live session status, a group tree view, live pane preview, and resource gauges. Fills the gap between plain tmux and full GUI dashboards.
A browser-based local dashboard that auto-scans project directories and surfaces git status, active Claude Code sessions, TODO comments, cost estimates, and more — without leaving the browser. Zero external services, fully local.
A proxy router for LLM APIs providing automatic load balancing across multiple provider endpoints, rate limiting, and fail2ban protection. Useful for teams managing multiple API keys or provider accounts and needing transparent failover.
A native Swift macOS menu bar app that tracks token usage and quota across Claude Code, Codex, Cursor, OpenCode, and 25+ other agents locally. Features a Liquid Glass UI and a 3D contribution graph for visualizing usage over time. Runs entirely on-device with no data sent to external servers.
A Claude Code toolkit for automating OSINT investigations with structured case management and evidence collection. Wires together threat intelligence sources and outputs organized investigation reports. Designed for security researchers who want to run repeatable reconnaissance workflows from within Claude Code.
A long-term memory system for coding agents that stores memories with source evidence — every recalled fact links back to where it came from in the codebase or conversation. Prevents agents from hallucinating stale context by keeping memory anchored to verifiable receipts. Useful for long-running projects where session continuity matters.
A VS Code side panel extension that monitors and controls multiple Claude Code agent sessions running across different git worktrees simultaneously. Shows per-branch agent status alongside GitHub PR state. Replaces the need to juggle multiple terminals when running parallel Claude Code workstreams.
A CLI package manager for SKILL.md-style skills that works across Claude Code, Windsurf, and Cursor. Search a registry of community skills, install them into your project, and sync updates — similar to npm but for AI coding skills. Addresses the lack of a standard distribution channel for Claude Code skills.
A local-first tool that renders Claude Code and Codex session timelines — showing agent actions, API evidence, process views, and analytics for each run. Includes a harness inspector for examining agent configurations. Useful for debugging agent behavior and understanding where sessions spend time or go wrong.
A unified workbench that persists plans, context, and task state across Claude Code, Codex, OpenCode, and VS Code Copilot Chat. Includes time tracking, a dashboard, and autonomous execution support for Claude Code. Addresses the problem of losing project state when switching between agents or sessions.
Routes Claude Code API calls through a LiteLLM proxy backed by a GitHub Copilot subscription, so you can use Claude Code without a separate Anthropic API key or billing. Supports both local and hosted proxy deployments. Useful for developers who already pay for Copilot and want to extend it to Claude Code.
Claude-native foundation for full-stack apps where React frontend is handled and your backend builds on top. Features strict tooling, pre-commit gates, and code-review audit before every merge. Designed to keep Claude Code working within an opinionated, quality-enforced structure.
Predictable CLI toolbox for coding agents running fully local ML: transcribe speech (Whisper, GigaAM), cut silence by voice activity, split transcripts into paragraphs, plus web feeds. JSON-first with stable flags and meaningful exit codes for reliable integration into agent workflows.
Programmatic pipeline that uses Claude Code for self-correcting After Effects renders via WebSocket commands. Lets agents iterate on video compositions automatically rather than relying on manual After Effects sessions. Useful for teams generating dynamic video content programmatically.
Open-source tool for driving actual coding agents rather than wrapping them — like a remote control for Claude Code, Codex, and similar tools. Fully open source and compatible across all major agents, contrasting with vendor-specific wrappers.
Remote, phone-first console for tmux that lets you spawn and watch coding agents in parallel worktrees from any device. Agent-agnostic with no database, works for anything running in tmux including Claude Code and other agent runtimes.
Python rebuild of Claude Code claiming up to 200x cost savings through token efficiency optimizations in a 270K LoC codebase. Open source alternative for those wanting full control over the agent runtime.
Visual control panel for plugins, marketplace, skills, and agents in Claude Code. Provides a UI layer for managing the increasingly complex ecosystem of Claude Code extensions without editing JSON files directly.
Runs AI coding agents locally in isolated Docker containers behind an egress firewall. Self-hosted and free alternative to cloud sandboxes. Useful for running agents on code that should not make network calls or for adding an isolation layer to untrusted agent tasks.
Always-on-top app that watches all Claude Code sessions in Windows Terminal and jumps to the exact tab — no tmux, no TUI, no workflow change required. Addresses the pain of managing multiple Claude Code sessions in Windows without a Unix-style multiplexer.
Physical and multi-surface dashboard for AI coding agents supporting Stream Deck+, Android, iOS/macOS, ESP32 displays, and TUI. Control your agents from physical hardware or a phone display. An interesting approach to human-in-the-loop control for agent workflows.
Local dashboard for running Claude — manages every isolated Desktop instance and account, live-tails Claude Code sessions, and maintains a queue of claude runs dispatched on demand or on a schedule. Local, private, and MCP-native. Essential for power users running multiple parallel Claude sessions.
Runs AI coding agents in isolated Docker containers with full autonomous permissions while keeping the host system untouched. Per-project isolation with an egress firewall. Self-hosted and free — gives the agent a cage rather than your keys.
Local-only macOS menu bar app monitoring usage for both Claude Code and Codex from a single status bar item. Zero data leaves the machine. Useful when working across both agent runtimes and wanting unified visibility into usage.
Visualizes Claude Code harnesses as interactive flow graphs directly from your repository, mapping agents, skills, and MCP connections. Helps teams understand and document complex multi-agent architectures without manually diagramming them.
Captures, visualizes, branches, and regression-tests LLM calls as a DAG. Free and local via Ollama or any OpenAI-compatible API with an MCP interface for agents. Zero config. Useful for debugging complex multi-turn agent sessions where you want to explore alternative decision paths.
Status line for Claude Code that shows both session and weekly limits before you hit them, helping you pace token usage so you never run out unexpectedly mid-task. Zero egress — all data stays local. Works as an always-visible indicator in your terminal.
Records every AI coding agent session, lets you inspect decisions, replay executions, compare runs, and understand exactly how your AI reached its output. Addresses the black-box problem when debugging unexpected agent behavior or trying to reproduce an issue.
Generates narrated, captioned MP4 demo videos from a storyboard.json file. Deterministic replay re-renders the video in CI without an API key at approximately zero cost. Open-source MIT alternative to Screen Studio, Clueso, and Demosmith for automated demo generation.
A complete roguelike game — every asset, sprite, sound, animation, and cutscene generated entirely by Claude Code Fable 5 agents. Used hundreds of parallel Claude terminals with context management to handle mass sprite generation. Demonstrates what multi-agent Claude workflows can produce for game development.
Browser-based tool that lets you annotate blocks, sections, selections, or exact lines in Markdown documents. The driving Claude Code agent then applies your edits directly. Zero-dependency and bilingual (EN/Chinese), designed to close the loop between human review and agent editing.
Open-source CLI providing structured project knowledge, product features and PRDs, a task and roadmap system, and analytics insights — turning Claude into the operational layer for running an entire project. Designed for founders and small teams running their whole process through Claude.
Regression testing framework specifically for Claude Code and Codex agents. Addresses the gap between test suites written by humans and the behavioral regressions that can appear when agents touch code, running tests at the agent-behavior level rather than just the code level.
Tracks active Claude Code sessions and displays a live, per-session summary directly in your terminal. Useful when running multiple sessions or long-running agents where you need at-a-glance context on what each session is currently doing.
Diagnoses and repairs Claude Desktop session metadata bugs on Windows: missing conversation history, lost transcripts, duplicate sessions, junction-induced splits, and lost groupings. Addresses a real pain point for Windows users who lose session context due to file system quirks.
Native macOS menu bar app charting tokens, cost, sessions, and Git activity for local Claude Code usage. Zero egress — everything stays local. Gives developers a compact always-visible overview of their AI-assisted coding activity without leaving the desktop.
Slash command (/seshport) that transfers full session context between Claude Code, Codex, and Grok Build. Available on npm, PyPI, crates.io, and Homebrew. Solves the common problem of losing context when switching agents mid-task.
Minimal CLI that swaps only the Claude login when your current account hits its usage limit, rotating you to the next account. Does not split settings, history, or projects — just the authentication. Settings and MCP servers are shared across accounts.
CLI companion for Claude Code that tracks usage limits across multiple accounts, launches configured sessions, and applies skills and output styles. Useful for power users juggling multiple Claude subscriptions or needing fine-grained session management from the command line.
Local, offline CLI for Claude Code that provides token and cost metrics alongside readable transcripts. Useful for understanding how sessions are consuming resources and for reviewing what the agent did without relying on cloud dashboards.
Open-source voice layer that connects directly to Claude Code, Codex, Cursor, OpenCode, and Hermes, running everything locally under your own login. Speaks agent questions aloud, narrates progress, saves conversations to session history. New features include 5-30 second voice cloning and push-to-talk. MIT licensed, no per-minute fees.
Task manager that dispatches Claude Code agents in parallel directly from your to-do list. Captures tasks anywhere, dispatches them in parallel, and lets you review results from your phone. Bridges the gap between casual task capture and heavyweight agent orchestration.
Addresses a prompt cache regression in Claude Code that causes up to 20x cost increase on resumed sessions. Drop-in fix for developers experiencing unexpectedly high token costs when continuing existing sessions. Highly relevant for anyone on the API billing model.
A Nix flake that packages Claude Code for native builds in NixOS and Nix environments. Useful for developers who use Nix for reproducible development environments and want Claude Code integrated natively rather than via npm or workarounds.
The Agent Continuity Runtime (ACR) stores portable session state under .agent/ and inspects the git working tree before every resume — so if tracked or untracked files changed since the last session, verification is marked stale rather than trusted. Supports Claude Code and Codex with best-effort failover. Solves the real problem where handoff summaries lie because the repo changed.
A wuxia duel game where Claude Code reads game state over HTTP, writes onIdle() combat scripts in JS, and fights ranked matches against scripts trained by other people's agents. Between matches, Claude reads its own defeat telemetry and rewrites the script. A creative demonstration of the agentic learning loop using real adversarial pressure.
An open-source bug bounty tool built as a Claude Code plugin — fan-out recon agents, a persistence agent that retries with different angles when an attack seems to fail, and a pool of creative agents who see only raw attack surface without the earlier 'this is closed' conclusions. Works on your Claude subscription with no API key, runs /llmhunter. For authorized security testing only.
rewound indexes all Claude Code sessions (and Codex sessions) into a local SQLite/FTS5 database and keeps them searchable even after Claude Code's 30-day cleanup sweeps them. Three ways to use it: CLI search, an MCP server so Claude can search its own history mid-session, and a phone-friendly local web UI over Tailscale. Also syncs across machines via any folder sync tool.
A jumplist that shows the status of all agent sessions across Claude Code, OpenCode, Pi, and Cursor with a single keyboard shortcut to see what needs attention. MIT licensed, open-source. Built to solve the tab-hunting problem when managing multiple concurrent agent sessions across different tools.
A TypeScript SDK for scripting agentic workflows that mix Claude CLI, Codex CLI, and Pi sessions in one coherent API. Features parallel and sequential execution, Zod-validated structured output, built-in TUI for monitoring, usage tracking per trace, and save/restore of agent results. Write workflow logic in TypeScript instead of YAML or fragile shell scripts.
A developer used Claude Code with Fable 5 to build and auto-deploy a much better UK foreign aid data explorer (aidscope.co.uk) from a notoriously difficult government website — in one shot, no follow-ups. Claude Code was connected to the VPS and Hostinger via MCP and even purchased the domain and deployed. Demonstrates Fable 5 capability on a real end-to-end task.
A macOS app for running Claude Code against an Obsidian vault with visual review of all changes and per-file undo. Records pre-run state, shows created/modified/deleted files with rendered markdown diffs, and lets you restore individual files when needed. Free private beta for ~20 Mac users.
A Claude Code plugin that turns WhatsApp into a remote interface for Claude — includes voice transcription, remote tool approval, and access control. No API keys or Docker required, just a linked device. Useful for approving Claude actions or sending prompts from your phone without opening a laptop.
A local spend monitor for Claude Code that requires zero API key, zero prompts, and adds zero latency. Passive monitoring that runs alongside your sessions. Useful for subscription users who still want visibility into relative usage and burn rate.
A CLI for tracking token usage and cost across Claude Code, Codex, and OpenCode from the command line. Provides unified cost visibility across multiple AI coding tools. Good for developers on paid plans who want to understand their actual consumption across tools.
Traces every pull request back to the specific agent, machine, and cmux tab that created it, and lets you jump straight back to the session that is still running. Solves the audit and debugging problem of not knowing which agent session produced which PR. Integrates with git and cmux.
A native macOS menu bar app that tracks your Claude.ai subscription usage in real time. Lightweight and always visible. Good companion to heavy Claude Code use when you want persistent usage awareness at a glance.
A local-first operator console that fuses AI agent sessions (Claude Code, Codex CLI, ChatGPT), git repositories, and markdown notes into one dashboard that surfaces what to do next. Reduces the context-switching overhead of managing multiple concurrent agent projects.
A desktop app (Electron + React) for running and managing multiple Claude Code sessions across projects and repos — chat and terminal views, multi-repo orchestration with handoffs, cross-machine sync, planning boards over MCP, and usage metrics. Comprehensive management layer for power users.
A scaffolding CLI that creates production-ready agent loops in 30 seconds — supports Claude Code, Codex, Gemini, and Cursor. Generates the boilerplate structure for agent loop projects so you can start writing the actual logic immediately. Fast and opinionated.
A desktop-first workbench for unified management and switching between Claude Code, OpenCode, Codex CLI, Gemini CLI, and other AI coding assistants. Provides a single UI to launch, monitor, and switch between different AI coding tools without losing context. Bilingual (Chinese/English).
A desktop app for managing Claude Code MCP servers, skills, plugins, hooks, and config profiles in one place. Provides a GUI layer for the growing complexity of Claude Code extension management. Reduces the cognitive overhead of maintaining a large Claude Code setup.
Stops you from wasting AI coding CLI usage windows by queuing tasks for spare capacity and prewarming your 5-hour window so resets land when you need them. Works with Claude Code, Codex CLI, and Cursor. Practical time-optimization for heavy users managing multiple 5-hour windows.
A multi-runtime installer for the Ultra Builder Pro agent engineering system — deploys commands, agents, skills, and hooks to Claude Code, OpenCode, Codex CLI, and Gemini CLI in one command. Useful for teams who want the same agent setup across multiple coding tools.
A macOS app for managing multiple coding agents simultaneously with a clean native interface. Lets you monitor and switch between agents working on different projects or tasks without juggling terminal windows. Designed for macOS users who run parallel Claude Code sessions.
A declarative AI agent environment manager written in Rust that manages your AI agent configurations, tools, and settings in a reproducible, version-controlled way. Similar to how nix or dotfiles work for system config, but for your AI agent environments. Cross-platform and fast.
A native GUI app for finding, reading, and resuming past Claude Code sessions — shows what each session cost. Local-only, no telemetry. Solves the problem of losing valuable context in old sessions by providing a searchable, cost-aware session browser.
A cross-runtime development harness for Claude Code, Codex, and OpenCode — includes skills, a verifiable pipeline, and project templates. Provides a standardized starting structure for projects that use multiple AI coding agents. Useful for teams who want to onboard agents consistently.
A Java 21 and Spring AI 2.0 reimplementation of Claude Code with 28 modules, 246 tests, and a full tool/permission/memory/MCP/LSP/vim/cron/plan ecosystem. A deep technical reference for understanding Claude Code internals and exploring alternative implementations. Valuable for teams running JVM-based infrastructure.
A macOS menu bar widget and shortcut launcher for monitoring real-time Claude cloud usage — shows 5-hour, weekly, and model-specific limits. Designed for heavy Claude Code users who want usage awareness without opening the web dashboard. Native and lightweight.
Adds bionic reading to Claude Code by bolding the leading part of each word in Claude streamed replies, helping your eyes move faster. Zero dependencies, display-only — does not affect the underlying text. A simple accessibility and readability enhancement for power users who read lots of Claude output.
A curated, auto-updated awesome-list of CLAUDE.md rules, MCP servers, and Claude Code skills — the companion repo to clauderules.net. Acts as a living directory for discovering high-quality configuration, skills, and integrations. Good starting point for anyone building out their Claude Code setup.
Turns Claude Code and Codex token usage into a local-first pixel arcade game with coins, cabinets, collectibles, and achievements. Makes the abstract idea of token consumption visible and fun. Quirky but useful for maintaining awareness of how much compute your sessions are consuming.
A design intelligence operating system for AI coding agents — one prompt in, production-quality UI out at Stripe-grade fidelity. Acts as a design system layer on top of your coding agent. Useful for developers who want polished UI without a dedicated designer.
A parallel coding agents orchestrator where you type a task, pick a workflow, assign agents (Claude Code, Codex, OpenCode, or mixed), and watch it work live with step and tool-call visibility. Supports fire-and-forget mode where a PR lands automatically. Runs locally on Linux, Mac, WSL2, or VPS.
A macOS menu bar app that shows all your AI subscription usage at a glance — multi-account Claude and Codex usage tracking. Includes a CLI that always launches on the account with the most headroom remaining. Practical for power users juggling multiple subscription accounts.
A cross-platform desktop widget and CLI for real-time Claude Code (and optional Codex) usage — shows session and weekly limits, cost, forecasts, burn alerts, and 11 themes. Installs with a single pip command on Linux, macOS, and Windows. Useful for subscription users who want always-visible usage awareness.
A self-hosted, tiled, persistent browser dashboard for host-run AI CLI terminal sessions — supports Claude Code, Codex, opencode, and more. Lets you manage multiple persistent sessions from any browser without losing state. Good for power users running agents on a remote machine they want to access from anywhere.
A ~/.agents repo for managing and syncing skills, MCP servers, hooks, and subagent roles across Claude Code, Codex, Droid, Hermes, and Pi. Uses commit-pinned and audited configuration so you always know exactly what version your agents are running. Treats AI agent config like dotfiles for reproducibility.
An AI OS that extends Claude Code, Gemini CLI, Codex, and Qwen with persistent memory, 24+ skills, and personal calibration — all in plain Markdown, local-first. Provides a unified memory and skill layer across AI coding tools so your agents share context. Zero cloud dependencies.
Enables AI coding agents on your machine to chat with each other — they can coordinate, ask each other questions, and receive notifications. No server required, all local. Enables a new class of agent collaboration patterns where models can consult each other without human mediation.
A platform for monetizing Claude Code skills — customers get an API key you control rather than the skill files themselves. The skill runs on your machine and you revoke access when payments stop. Allows skill authors to build a sustainable business around their work.
A single-binary vendoring package manager for coding-agent skills that works with Claude Code and Codex. Treats skills like npm packages — install, update, and version-pin them from the command line. Makes skill management reproducible and scriptable.
An open-source digital micropad for agentic work that turns your phone or tablet into a physical-feeling control deck for AI coding agents. Provides tactile-style shortcuts and quick actions accessible from any device. Great for users who want to control Claude Code from a secondary screen.
A mod menu for Claude Code and Codex that auto-continues sessions when they hit usage limits and sends pings timed to align 5-hour windows with your workday. Removes the frustration of interrupted sessions by automating the continuation flow. Great for heavy users who run long agent sessions unattended.
An autonomous AI development pipeline for Claude Code that uses GitHub as agent memory — issues go in, pull requests come out. Turns the GitHub issue tracker into a structured task queue that Claude Code works through end-to-end without manual handoffs. Good fit for teams wanting fully automated feature-to-PR flow.
A tool that scans AI coding agent session histories (Claude Code and others) to find and redact accidentally captured secrets like API keys, tokens, and passwords. Addresses the real risk of sensitive credentials appearing in transcripts and JSONL session files. Useful for security hygiene before sharing or archiving sessions.
An IM-native multi-agent collaboration platform where you @mention Claude Code, Codex, or OpenCode like team members in a chat interface. Routes tasks to the right agent via natural @mentions in a shared workspace. Makes multi-agent workflows feel like team messaging instead of terminal juggling.
A pit-wall console for monitoring AI coding agents where Claude Code and Codex collaborate on one repo. You watch live telemetry, radio in corrections, and make the calls — all local-first, crash-safe, and bilingual. Inspired by F1 pit walls, it gives you real-time situational awareness across parallel agent sessions.
Runs simulated users through your Claude Code plugin in realistic scenarios and turns recurring friction into a ranked proposal brief. Automates the process of finding usability issues in your own plugin before users hit them. Particularly useful for plugin authors who want structured feedback without manual testing.
Monitors Claude Code agent sessions in real time, showing context usage, cost reports, and identifying context hogs that burn tokens unnecessarily. Provides actionable visibility into where tokens are being spent so you can tune your sessions. Essential for subscription users who want to stay within usage windows.
A flight deck for AI agents built on WezTerm, tmux, and git worktrees that provides a structured multi-agent terminal platform. Organizes concurrent agent sessions in a cockpit-style layout so you can monitor and switch between them efficiently. Both bilingual (English/Chinese) and local-first.
A terminal application for multiplexing agent workflows — manage multiple AI coding agent flows in parallel from a single interface. Designed around the idea of going with the flow of multiple agents rather than fighting context switches. Early-stage but useful for users juggling several concurrent agent tasks.
A local web dashboard for orchestrating parallel Claude Code sessions with task dispatch, automated PR review, and lifecycle management. Provides a visual control plane for managing multiple agents working on different tasks simultaneously. Includes automated PR review so you do not have to manually check every output.
Provides secure A2A (agent-to-agent) communication channels for agent runtimes with end-to-end invitations, automatic task handling, and approval gates. Solves the trust and coordination problem when multiple agents need to collaborate without a central server. Useful for multi-agent architectures where agents need verified communication.
A self-hosted AI coding factory where sandboxed agents take tickets through to merged code, with a human reviewing in a dashboard at each gate. Local-first and cost-transparent so you see exactly what is being spent and approved. Good for teams who want autonomous agent coding with mandatory human review before merge.
Instead of bigger context windows, DevTime treats repository understanding as something verifiable: every explanation has evidence, every claim is re-checkable, and stale decisions surface when the supporting code changes. Addresses the problem of AI-generated codebases where nobody remembers the rationale behind decisions.
Lightweight ASCII animation widget that hooks into Claude's current state and shows different animations depending on what Claude is doing — thinking, running code, idling. Fully customizable with a community gallery of CLanimations and a built-in converter for custom images.
Integrates Claude Code directly into Obsidian with an interactive terminal, quick-ask modal, and a built-in MCP server for structured vault access. Lets you code and query your knowledge base in the same window without context-switching.
Adds session recovery, scheduling, worktree management, a Token Saver mode, and dashboards to Claude Code using the official CLI transport. Wraps Claude Code with production-grade reliability features without requiring API keys.
Feed raw content and Claude organizes, links, and synthesizes your Obsidian notes automatically. Turns the note-taking overhead of a knowledge base into a continuous background process driven by an LLM.
Single control panel for managing and orchestrating multiple Claude Code sessions running on different machines. Useful for teams or users who parallelize work across multiple machines with a unified view.
Self-hosted Telegram bridge with SDK/CLI engines and A2A-TG multi-agent routing for Claude Code, Codex, and Gemini. Control and monitor AI coding agents via Telegram messages from any device.
Record a bug or session once; ThinkRun converts it into structured context that Claude Code or Cursor can act on immediately. Includes MCP, CLI, and portable agent skills with reproducible trigger evaluations for the full debug loop.
Free local CLI that tracks AI coding token usage and cost across 31 tools including Claude Code, Cursor, Codex, and Gemini — broken down by model, project, and task. Run via npx with no account required.
Local-first agent experience layer providing observability and memory for Claude Code and Codex sessions. Typed, yours to own, designed as a lightweight foundation for understanding what your agents are doing across sessions.
Native macOS menu bar app showing Claude account usage and live Claude Code session activity at a glance. Provides a persistent summary of current state without switching to the terminal.
Wrapper app where plugins take center stage: each plugin gets its own tab and file directory, plus a Canvas feature — a mini-browser where agents can render interactive mini-apps instead of markdown. Community plugin marketplace included.
Tracks your 5-hour and 7-day Claude usage gauges and sends scheduled pings to align your heaviest work to fresh rate-limit windows. Helps Pro/Max users stay productive without hitting unexpected pauses mid-session.
Monitors AI agent status on the macOS menu bar with local customizable light-effect indicators for Claude Code and Codex. Provides ambient awareness of agent state through visual signals that work even when your coding window is not in focus.
Independent open-source coordination layer for managing and routing messages between coding-agent sessions. Provides a lightweight bus for cross-session communication without requiring a proprietary platform.
Native macOS app for building software with Claude Code featuring a Monaco editor, integrated terminal, and built-in git — local-first and free. Provides a polished desktop IDE experience without requiring VS Code or a web browser.
Unified management interface for tmux sessions and AI agent processes. Gives developers a single command center to launch, switch between, and monitor long-running terminal sessions and agent tasks.
Displays live Claude Code, Codex, and OpenCode status and usage metrics on an Elgato Stream Deck Neo. Quick at-a-glance view of multiple AI coding agents from a physical hardware controller.
Adds native macOS widgets, menu bar insights, and local usage analytics to the CC Switch Claude Code toggle app. Brings rich macOS integration for monitoring Claude Code sessions directly from the desktop.
Points at your warehouse and dbt project, learns the landscape, authors transformations, and flags schema drift. Built for analytics engineers who want a coding agent that understands their full data stack end-to-end.
SDK, CLI, and MCP server for converting chat history between AI coding tools. Lets you migrate sessions or search across conversation logs from multiple agents in a unified interface.
Slack-style communication layer for AI agents: threaded messages, flat replies, cross-thread links, and pull notifications. Provides structured inter-agent messaging for complex multi-agent architectures.
Provides a consistent kit that lets Claude Code, Codex, Cursor, OpenCode and others work predictably and safely with existing frontend projects. Reduces the common failure modes where agents misread or break front-end project structure.
Native macOS menu bar app and CLI that prevents sleep during active AI agent sessions and re-enables it when sessions finish. Solves the common annoyance of long-running Claude Code sessions being interrupted by system sleep.
Run multiple real Claude Code agents in parallel using your Claude Pro/Max subscription rather than paying per-token API costs. Local-first orchestration layer that multiplies your output without increasing spend.
Documents real experiments building software with Claude Code — including token data, what worked, what failed, and reusable tools. Includes a Spec Kit-compatible working method and publishes negative results so others learn from failures, not just successes.
CLI and MCP server for fast full-text search across AI coding session transcripts. Lets humans and agents quickly retrieve past conversations, decisions, and context from hundreds of prior sessions across multiple tools.
Agent-agnostic memory sidecar combining gbrain, Hindsight, and 3-tier recall. Designed for production use and compatible with Hermes, Claude, Cursor, and other agents. Provides persistent recall without being tied to any specific agent runtime.
A system tray application that displays real Anthropic 5-hour and 7-day rate limits, token consumption, and cost per project and model — covering both Claude Code and opencode. Goes beyond statusline plugins by living in the system tray with multi-model breakdowns. Helps developers track actual quota consumption without switching context.
prjct is a CLI + MCP server that manages the full AI coding work cycle: intent briefs to structure requests, bounded RAG pulled from real code intelligence, persistent memory (SQLite), preventive guardrails, and performance evaluations. Works across Claude Code, Codex, Gemini CLI, Cursor, and OpenCode. Positions itself as infrastructure you own rather than rent.
A rich 2-line Claude Code statusline featuring smooth Unicode gauges, segments for git state, active skills, and tasks, plus optional live feeds from the Anthropic blog, Hacker News, and GitHub trending — all width-adaptive with OSC 8 hyperlinks for clickable links in the terminal. A more feature-rich alternative to minimal statusline plugins.
engineer-agent is a Claude Code plugin that handles senior software engineering tasks — PR reviews, Slack thread answers, Linear ticket implementation, doc reviews, and daily standups — all gated on human approval before any action is taken. Designed for solo engineers or small teams wanting AI coverage on routine engineering role tasks.
shots generates App Store screenshots and app icon concept images directly from Codex, Claude Code, and MCP clients. Targets indie app developers who want to produce store assets without leaving their agent workflow. Integrates into the existing AI coding pipeline rather than requiring a separate design tool step.
A lightweight Claude Code statusline that displays the current model, context window usage, and rate-limit consumption as colored bars. Prioritizes simplicity and minimal setup over feature breadth. A good starting point for developers who want quick visibility into their Claude Code session without installing a heavy plugin.
corply-plugin lets you form a Delaware C-Corporation from inside Claude Code — generating the application, legal documents, collecting cofounder e-signatures, and submitting for human-reviewed filing. Targets solo founders who want to automate incorporation without leaving their editor. A novel AI-native workflow for a traditionally paperwork-heavy process.
A single static Go binary that indexes your codebase into a deterministic knowledge graph covering code, routes, dependencies, Kubernetes configs, and docs. AI coding agents query the graph rather than relying on LLM-based retrieval or a database. Zero external dependencies, no MCP layer required, cross-platform.
A production-ready FastAPI service that manages multiple concurrent Claude agent sessions via HTTP API, with real-time monitoring, cost tracking, and session resumption. Useful for applications or teams that need to orchestrate many parallel Claude Code sessions programmatically. Provides a clean REST interface around Claude's agentic capabilities.
gws-os lets Claude Code interact with Google Workspace — email, calendar, and Drive — across multiple accounts using learned, adaptive workflows from a single terminal. Focuses on terminal-first Workspace access within a coding session, building on top of account-specific learned patterns rather than fixed API wrappers.
A read-only terminal dashboard that monitors Claude Code and Codex CLI sessions in real time — tracking token usage, context size, rate limits, child processes, and open ports in a single view. Inspired by htop, it gives you a live health snapshot of all running agent sessions. No credentials or config required.
A macOS Stream Deck plugin for fast context-switching that includes live Claude Code keys alongside Safari tabs, tmux, iTerm2, BBEdit, and window management. Built by Moving Average Labs with AI-directed development and test coverage. Lets you trigger Claude Code actions from physical buttons without leaving your keyboard workflow.
A native Mac app and CLI that runs a multi-agent AI Scrum team on top of Claude Code, with you acting as Product Owner. Autonomous sprints are planned, executed, and reviewed by specialized agents (PM, dev, QA) while you steer direction at the sprint level. Designed for solo developers who want to move at team speed without managing individual tasks.
Reads Claude Code session transcripts and flags subagent results that exhibit patterns associated with real agent failures — hallucinated file paths, contradicted earlier steps, skipped tool confirmations, and similar red flags. Derived from actual failure cases rather than heuristic rules. Useful for post-session audits and building trust metrics into multi-agent pipelines.
An open-source test automation platform that uses Claude Code alongside Playwright and Appium to generate, execute, and maintain tests from structured test manifests. The AI interprets intent from manifests rather than brittle CSS selectors, making tests more resilient to UI changes. Covers both web (Playwright) and mobile (Appium) targets.
A website and API for discovering, installing, and selling Claude Code status lines — including animated pets (Tamagotchi fed by token usage), Doom, and Minecraft implementations. Status lines can be monetized via x402 and Lightning payment protocols. Includes an LLM security audit on submitted status lines before publishing.
Run `npx agent-wiretap -- claude` and watch every file read/written, secrets caught in outbound traffic, every domain contacted, and running token cost in real time. Reveals surprising behavior like mid-session Datadog logging and update checks. Local-only, MIT licensed.
A personal AI assistant powered by Claude Code, Codex, and Grok — remembers people you tell it about, browses the web, and learns over time. First-party, no API keys required, runs locally.
A community-curated gallery of Claude Code status lines rendered in live environments with captured real output. Each submission is manually reviewed. Browse, copy, and submit status line configurations at statuslin.es.
Adds colored status indicator dots to Ghostty terminal tab titles for Claude Code and Codex sessions — giving a quick visual signal of each agent's current state across multiple tabs.
A local, fully offline Windows desktop app that monitors running Claude Code agents — showing live status, estimated cost, model, host, and one-click focus, grouped by project. Read-only and requires no external connections.
Control Claude Code, OpenAI Codex, and other terminal AI agents from your phone via Telegram topics. Features live pane screenshots, key presses, tappable prompts, one-tap parallel git-worktree agents, two-way voice, and session resume. Self-hosted, no cloud middleman.
A tool for comparing AI coding models using coding-focused benchmarks weighted by your own priorities. Cross-verified with contradiction flagging, available in Turkish and English.
Reproducible multi-user Claude Code agent sandboxes for NixOS — both bare-metal and VM image. Provides unprivileged tmux-based agents, scoped sudo, and drop-in token injection for secure, isolated agent environments.
Embeds Claude Code CLI as a polished web console inside Home Assistant — with tabs, clipboard support, file attachments, and full Home Assistant access. Turns your smart home dashboard into a Claude Code terminal.
A document format that combines slides, text, charts, and spreadsheets in a single Markdown-driven file — built for agents to create and developers to use. Supports privacy-preserving sharing, code annotation flows, and architecture diagram generation within Claude Code sessions.
A Windows PowerToys Command Palette dock extension that shows live Claude Code usage — session percentage remaining, weekly limits, and per-model limits — without opening a browser.
An open-source, self-hosted analytics dashboard for Claude Code that reads your local JSONL session files to produce charts, project breakdowns, and costs. Includes a gamified cat colony and a Pomodoro focus timer. Fully local, no telemetry.
Uses Claude Code and Codex as the foundation for coding infrastructure while giving you control over model selection and provider routing. Supports flexible routing and configuration so you can choose how to interact with models without changing your agent workflow.
A Node CLI that converts Claude Code workflow .js files into diagrams showing execution steps and agent topology. Useful for understanding, debugging, and documenting complex multi-agent workflow scripts.
A tool for quickly locating the specific coding agent session you want to resume from among many. Solves the problem of identifying the right conversation across multiple past sessions.
A local Go CLI for installing, validating, and operating repository-level AI agent control surfaces. Manages .ai/ rules, workflows, hooks, quality gates, and protected-action governance across any repo.
A local-only dashboard that tracks tokens, sessions, tool calls, and reasoning across Claude Code, Hermes, Antigravity CLI, Codex, and more. No telemetry sent externally — all data stays on your machine.
Diagnoses your entire AI coding stack — Claude Code, Codex, Cursor, Gemini CLI, and more — catching silent failures that other checks miss. Inspired by flutter doctor, it gives a structured health report of your agent environment.
A Windows desktop widget that displays your Claude Pro/Max plan usage — session percentage and weekly limits — in real time, synced with the official /usage screen. No browser required.
Fixes the problem where claude --continue resumes the wrong global session instead of the one for the current directory. Adds a shim that tracks sessions per directory and restores them after reboots using tmux-resurrect. Works with Claude Code and Codex.
Generates entire fake companies as browsable file shares filled with realistic business documents (docx, pdf, xlsx, pptx, eml) and a deterministic ground-truth answer key. Ideal for building and benchmarking agentic systems against meaningful, real-world-style synthetic examples.
A desktop application that brings real source control, a file editor, mid-thread provider switching, and the ability to revert anything an agent did. Supports Mac and Windows, providing a graphical interface for Claude Code and Codex workflows.
An agent-driven presentation builder producing single-file HTML slide decks with the visual quality of Keynote and the openness of the web. Includes a methodology for what to say alongside the slides, designed for agents to write and present.
A single compiled Rust binary that authenticates, authorizes, rate-limits, logs, and costs every AI interaction. Self-hosted, air-gap capable, and provider-agnostic — acts as the governance layer for any AI agent deployment.
A self-hosted control plane for dispatching tasks, reviewing agent runs, tracking spend, and operating Claude Code, Codex, and other runtimes. Provides a central dashboard for multi-agent fleet management.
A local-first AI memory system with no cloud or APIs — all data stays on your machine. Achieves 74% retrieval accuracy on the LoCoMo benchmark without an LLM, and 87.7% with one. Research-backed (arXiv: 2603.14588).
wicek runs Claude Code as a task-focused assistant inside Discord, enabling teams to delegate coding and automation tasks directly from a Discord channel. Bridges the Claude Code agent runtime with Discord's messaging API.
A self-hosted monitoring tool for CPA/CLIProxyAPI and OpenAI-compatible gateway accounts. Tracks requests, costs, failures, quota usage, and account health — useful for teams running Claude Code through shared API gateway proxies.
A physical desk device for monitoring AI coding sessions: multi-session dashboard on a 1.8in AMOLED screen, tiered sound alerts, a physical approval key, and a quota gauge. Built on an ESP32-S3, communicates over LAN, and explicitly supports Claude Code. A hardware companion for heavy AI coding sessions.
A desktop pet inspired by Codex's desktop pets, designed to accompany AI client sessions including Claude Code. A novelty companion app for those who want a bit of personality alongside their AI coding workflow.
A minimal, from-scratch implementation of a personal coding agent framework modeled after Claude Code's architecture. Useful as a reference implementation or starting point for building custom agent loops.
A native macOS menu bar app that aggregates Claude Code, Codex, Cursor, and Antigravity usage stats across multiple Macs via a synced folder (iCloud, Syncthing, Dropbox, or NAS). No backend or telemetry — all local. Shows token and session usage at a glance.
A cross-platform desktop client for Claude Code built on Tauri 2.0, Vue 3, and TypeScript. Provides a native GUI wrapper around Claude Code for users who prefer a desktop app over the terminal CLI.
A monitoring framework that tracks AI agent decisions and logic flows using LangGraph, giving full visibility into autonomous operations. Useful for debugging Claude Code agent sessions and understanding decision paths.
An unofficial Eclipse IDE plugin that brings Claude Code capabilities into the Eclipse environment. Extends Claude Code's IDE support beyond VS Code and JetBrains to the Eclipse ecosystem.
z-clean audits and cleans up runtime artifacts left by AI coding tools: Claude Code, Codex, Cursor, MCP servers, and developer caches. Run via npx z-clean audit to see what to clean without deleting anything.
A keyboard-driven, self-hosted dashboard for managing multiple Claude Code agents simultaneously. Features worktrees, a command palette, a task scheduler, and voice control — all without telemetry. Everything runs on your own machine, making it suitable for those who want full control over their agent infrastructure.
crewship provides a self-hosted runtime that runs AI coding agents inside real Linux containers on your own hardware. Keeps your keys and data fully under your control, with no cloud dependency. An alternative for teams that need isolation, reproducibility, or air-gapped agent execution.
An all-in-one developer tool designed for open-source maintainers in 2026, combining Claude Code hooks, MCP integrations, subagent orchestration, and cron scheduling into a single copilot. Targets the maintenance workflows — issue triage, PR review, release management — that consume maintainer time.
agent-resume uses tmux-resurrect to automatically restore AI coding agent sessions (Claude Code, Codex, and others) in their original directories after a machine reboot. Eliminates the need to manually reopen projects and reconnect terminals. Works with any tmux-based workflow.
SoA-Web is a web-based reimagining of the Son of Anton AI terminal, built with Node.js, WebSocket, node-pty, and xterm.js. Runs fully in a browser tab with no Electron dependency, making it accessible from any device without a native install. Good reference for building lightweight browser-based AI terminal interfaces.
mirage provides a unified virtual filesystem layer that AI agents can use to read and write files across different underlying storage systems through a single interface. Aims to simplify agent file I/O by abstracting away storage heterogeneity. Early-stage but targets a real pain point in multi-agent setups.
claude-visor is a macOS app styled after the Dynamic Island/notch area that lets you monitor, navigate, and interact with multiple Claude Code sessions directly from the menu bar. Useful for developers running several parallel agents who want quick session switching without switching terminal windows.
sessionwiki indexes every AI coding session on your machine — Claude Code, Codex, Gemini CLI, OpenCode, Cline, and 6 others — and lets you search, resume, and trace any file back to the conversation that created it. 100% local with no telemetry. Solves the "where did I work on this?" problem across a mixed toolchain.
Multideck launches AI coding agents (Claude Code, Codex, Cursor) each in their own terminal window and automatically tiles them across all connected monitors. It handles DPI-correct scaling on mixed-scale setups. Useful for developers running multiple agents on multi-monitor workstations.
TokenGraph is a local-first plugin for Claude Code and Codex that routes project context compactly. It aims to reduce context overhead by intelligently selecting which parts of your codebase to surface to the agent. Runs entirely on your machine with no external dependencies.
Rein is a lightweight bridge that lets you remotely control locally-running AI agents (Claude Code, Codex, Gemini, opencode, Grok) from an iPhone. Provides real git diffs from your worktree, live dev server preview, a real terminal, approval cards, and PR shipping — all routing through your own machine with no code sent externally. iOS only currently.
A starter boilerplate combining Hono (lightweight web framework), TypeScript, Drizzle ORM, and PostgreSQL, configured for use with Claude Code. Provides a ready-to-go backend scaffold for API development with modern TypeScript tooling.
Mission control for solo developers running multiple AI coding agents in parallel. Combines a Kanban board, git worktrees, and tmux to manage Claude Code, Codex, Gemini CLI, OpenCode, and any shell-based agent without losing context. Designed as an agent orchestration layer, not an IDE replacement.
A terminal application for macOS and iOS built on libghostty with first-class git worktree support. Designed for workflows where multiple worktrees are active simultaneously — relevant for running parallel Claude Code sessions across branches.
A plugin for OpenCode that dynamically prunes conversation context to optimize token usage. Intelligently manages what stays in context based on relevance, reducing unnecessary token consumption during long coding sessions. Applicable as a pattern for context management in other AI coding tools.
An engineering decision memory tool for AI-assisted development that records the reasoning behind code choices, not just what was built. Helps AI coding agents understand architectural intent and constraints when revisiting or extending existing code. Targets the common problem of AI agents lacking historical context.
An idempotent curl|bash installer that turns a fresh Ubuntu VPS into a fully configured AI coding agent environment in one command. Installs Claude Code, Codex CLI, Gemini CLI, major language runtimes, and 40+ dev tools. Designed for reproducible agent infrastructure setup.
A memory and project planning tool for AI agents that works from plain markdown files. Supports existing knowledge bases and multi-agent workflows without requiring a specialized database or service. Designed to integrate naturally into codebases where documentation already lives in markdown.
A tool that maintains a single source of truth for AI coding rules and syncs them automatically to Claude Code, Cursor, Copilot, Codex, and more. Eliminates the pain of maintaining separate rule files for each AI coding assistant across a team. Keeps all agents working from the same conventions.
A workbench for using Claude to write, debug, and explain ShopifyQL and Segment analytics queries. Speeds up analytics filter work for Shopify merchants and developers who need to iterate on queries quickly without memorizing ShopifyQL syntax.
An experimental autonomous agent framework built around Claude with 60+ tools and a self-directed cognitive cycle that decides what to do without explicit prompting. Features an "earned autonomy" model where the agent gains capabilities incrementally based on track record. An ambitious framework for fully autonomous task execution.
A CLI tool that surfaces engineering team health metrics from a single terminal command, giving developers and managers a quick sprint snapshot without context-switching to web dashboards. Terminal-first, minimal setup.
A single-binary Asana CLI tool designed for developers using Claude Code, Codex, and other AI coding assistants. Enables task management and project tracking directly from the terminal without needing the Asana web app. Useful for integrating project management into AI-assisted development workflows.
A desktop application that acts as a unified command center for Claude Code, OpenCode, Codex, and Pi. Supports multi-project AI coding sessions with streaming chat, a prompt queue, model switching, and MCP tools in a single interface. Useful for developers who run multiple AI agents across different projects simultaneously.
A Docker sandbox for Claude Code that feels native by preserving your global skills, plugins, MCP servers, git config, and persistent Claude sessions. Solves the common pain of a stripped environment in containers. Ideal for reproducible development or sharing a configured Claude Code environment across machines.
A zero-dependency, offline triage panel that finds every idle Claude Code session across all your projects and shows what each was waiting on. Ranks sessions so you know which to resume first. Useful for developers who run many parallel Claude sessions and lose track of which ones need attention.
An open-source "antivirus" for AI agents that blocks risky tools, secret access, prompt injection, malicious packages, MCP servers, plugins, and skills at runtime. Designed to sit in front of agent tool calls and enforce security policies before execution. Addresses a real gap as AI coding agents gain more system access.
A cross-vendor AI coding harness with deterministic security gates. Separates work into gated Builder and Reviewer roles and maintains a full SQLite audit trail of every agent action. Runs entirely local — no server, no cloud required. An alternative to vendor-specific harnesses for teams who want vendor flexibility with strong auditability.
A coordinator that pulls tasks from a real GitHub Projects board and runs coding agents against them with quota awareness and review gating. Unlike local Kanban tools, it operates directly on the GitHub Projects source of truth. Designed for teams that want to automate development tasks while keeping human review checkpoints.
A floating, always-on-top panel on macOS showing Claude Code session status at a glance — no window switching required. Keeps agent state visible while you work in other apps.
A repo-agnostic engine for running Claude Code autonomy loops against any target repository, making autonomous coding sessions portable and reusable across different projects.
A local-first SwiftUI macOS menu-bar desktop pet that reacts to your AI usage in real time — showing quota, token burn rate, cost, and work rhythm. Includes adapters for Codex and Claude Code.
Routes Telegram topics to isolated Claude Code sessions with persistent memory, enabling conversational AI workflows triggered from a Telegram interface — useful for remote or mobile-driven coding sessions.
An AI-native Python agent harness with multi-model orchestration, stateful sessions, tool governance, traceable delivery, and provider routing for GPT, Claude, DeepSeek, Qwen, Kimi, GLM, and MiniMax.
Shows your remaining Claude Code 5-hour session capacity directly in the Windows 11 taskbar at a glance, without needing to open any app or dashboard.
A model-agnostic autonomous coding agent with a reproducible benchmark harness, adaptive turn budgets, and domain-expert prompting. Works with Claude, GPT, Gemini, Ollama, and others. 1380+ tests, built by AI agents orchestrated by humans.
A cockpit interface for piloting every Claude Code session and monitoring its telemetry from one centralized view — useful when running multiple parallel sessions across projects.
A tool that lets you control Claude Code interactive CLI sessions directly from Codex, without setting up an MCP server. Bridges the two agents for cross-tool workflows.
Automatically detects when your AI agents are running and prevents your Mac from sleeping, ensuring long-running autonomous sessions complete without interruption. Simple and focused utility.
Catches up to 6 loop types in AI agents, provides time-stamped action categorization, agent-to-agent communication through shared memory, cost prediction analysis, and automatic recovery for broken agents.
A minimal macOS terminal built with Tauri 2 and xterm.js, featuring split panes and themes — designed for running multiple AI agent CLI tools side by side without a heavy terminal emulator.
A decentralized intent and conversation ledger that anchors AI coding context to git commits, helping teams maintain shared understanding of decisions and intent across sessions and contributors.
A lightweight tool for tracking local coding agent sessions across tmux panes, giving you visibility into what's running where during multi-agent workflows from the terminal.
An AI-powered daily digest for developers covering 30+ AI news sources across 7 dimensions with 3x daily updates. Built Claude Code native with zero external dependencies.
A Tauri v2 + Svelte 5 desktop control center for Claude Code and opencode: profiles, provider/router configuration, MCP, plugins, skills, and parallel session management. Available in Russian, English, and Chinese.
A scheduled Claude agent that screens journal RSS feeds against your research scope, emails a daily digest, and files papers into Zotero. No API keys needed — runs entirely on a claude.ai subscription.
Captures, inspects, replays, and analyzes every AI agent run without any SDK or code changes. A glass-box observability layer for understanding exactly what your agents do and catching unexpected behavior.
A local cost analytics tool specifically for Claude Code sessions, tracking and visualizing what you spend across sessions to understand and optimize your usage.
Tracks Claude Code, Codex, Cursor, Copilot, and other AI coding agent token usage with a 2D/3D contribution-style graph in the macOS menu bar. Makes your aggregate AI usage visible at a glance.
Runs local background agents on Claude Code and Codex CLI that can message each other, wake on demand, and share a single memory store — enabling true multi-agent coordination without a central server.
Real-time sync for Claude Code, Codex, Gemini, and Cursor sessions — watch agent work from any device, share sessions with your team, and give Claude persistent memory that carries across sessions.
Search, inspect, and export Claude Code and Cursor conversation history. Makes past sessions easily discoverable and referenceable, supporting knowledge retention across projects.
A single dashboard for tracking spend and usage across Claude, Cursor, OpenRouter, Copilot, Gemini, Codex, and more. See all your AI costs consolidated in one view.
A free, open-source native macOS app that shows all Claude Code configuration in one searchable window — skills, agents, hooks, MCP servers, settings. Every save backs up the old version automatically.
A local proxy that lets OpenAI-, Anthropic-, and Gemini-compatible clients use models from GitHub Copilot, OpenAI, Anthropic, and custom providers with priority-based routing and automatic fallback. Self-hosted, no external dependencies.
A local dashboard for managing every Claude Code, Codex, Cursor, and other AI coding session on your Mac simultaneously. Spawn and ship sessions in parallel from one interface. Open source, MIT.
Runs coding agents in a secure Docker microVM and merges their work as standard git commits, protecting the host machine from agent mistakes or runaway file changes.
Automatically extracts knowledge from git repos, Claude Code sessions (via ccrider FTS5), and iMessage bookmarks into a cross-project, qmd-indexed knowledge base running on cron. Surfaces relevant context across projects.
An ultra-lightweight Rust system tray app (~3 MB RAM) for monitoring Claude AI subscription usage in real time on Windows. Shows remaining capacity at a glance without leaving your editor.
Orchestrates Claude Code agents with persistent memory, message routing, webhook triggers, cost tracking, and OS-level sandbox isolation for safe, coordinated multi-agent workflows.
A gateway that creates temporary tokens with fixed budgets, preventing Claude Code from exceeding token limits even in unattended sessions. Keeps your API key off the machine running Claude Code, reducing theft risk. Useful for shared setups or when running agents autonomously.
Analyzes Claude Code session logs to detect repeated content and bloated tool results, showing exactly where context window budget goes with concrete fixes and estimated savings. The first open-source token profiler specifically for AI coding agents.
Runs multiple AI coding models simultaneously on the same task in isolated git worktrees, auto-applies the best solution, and tracks model performance with Glicko-2 ratings over time. Routes future work to the model that excels at each task type.
Stream Deck dials for switching Claude Code models and reasoning effort without retyping /model or /compact. Tracks the active session ID and patches the installed VS Code extension locally. Also ships a PTY-wrapped terminal launcher that works without any patching.
A platform-agnostic format and method for right-sizing local LLM hardware based on your actual agent session data. Calibrates recommendations using capability-oracle runs to ensure you get hardware that matches real workloads. Useful for teams self-hosting models to complement Claude Code workflows.
A supervision layer that challenges AI coding agent decisions using Socratic questioning, helping catch bad assumptions before they become code. Designed to sit between your intent and the agent execution, improving reasoning quality. Useful for high-stakes codebases where unchecked agent autonomy is a risk.
Automated code review tool that verifies changes, learns from team-specific patterns over time, and accumulates shared team knowledge. Integrates with AI coding workflows to provide consistent, context-aware review feedback. Reduces review bottlenecks by automating the repetitive parts of code review.
A multi-mode AI agent harness written in Rust that serves GUI, CLI, headless, and webapp interfaces from a single binary. Supports multiple AI providers, MCP, skills, plugins, and agent teams. An interesting alternative to Electron-based approaches for users who want a lightweight, performant agent shell.
Provides persistent, indexed memory for AI coding workflows so context survives across sessions. Indexes notes locally and delivers relevant context at the start of new sessions, solving the cold-start problem that makes long-running projects hard. Works with Claude Code and other AI coding CLIs.
Tracks and inspects all Claude Code requests, file reads, and token usage with clear, structured logs. Gives full visibility into what the agent is doing and how much it is costing. Helpful for debugging runaway sessions, auditing behavior, and understanding token consumption patterns.
An open-source personal AI operating system from the makers of Plane, designed to unify AI interactions, memory, and tooling in one place. Provides a foundation for building personal productivity workflows around AI agents. Positioned as a self-hosted alternative to proprietary AI hubs.
End-to-end pipeline that takes a plain-language clinical question, finds studies, verifies each one is real via Crossref/PubMed (anti-hallucination), grades evidence with GRADE methodology, and writes the final report — all using Claude as the engine. Includes word-for-word number checking to catch LLM-fabricated citations. A rigorous example of Claude for high-stakes domain research.
A beginner-friendly local AI assistant that supports Ollama, Codex, and Claude Code from a single interface. Designed to lower the barrier to entry for developers new to AI coding tools. Good onboarding layer for teams introducing AI coding to less technical members.
Open-source job search automation that scans job portals, scores listings A-F, tailors your CV for each role, and tracks applications — all runnable inside Claude Code, Codex, or Gemini CLI. Demonstrates how AI coding agents can be repurposed for non-coding automation tasks. A practical personal productivity use case for the Claude Code skill ecosystem.
A tiny pixel-art Claude desktop pet for macOS that wanders your screen, visually reflects when Claude Code is active, and celebrates when a session completes. A fun ambient indicator that makes long coding sessions more enjoyable. No practical function — purely delightful.
A lightweight local issue tracker designed to work alongside the Claude Code CLI. Keeps task management local and Claude-aware without needing external project management tools. Good for solo developers or small teams who want issue tracking that stays in the terminal.
Adds image generation capability to Claude Code by borrowing the Codex CLI's built-in image_gen tool — runs on your existing ChatGPT plan with no extra API key or per-image billing. A clever bridge between two AI coding ecosystems that unlocks a capability Claude Code lacks natively. Useful for projects that need quick image prototypes alongside code.
Maps code dependencies, predicts change impact, selects relevant tests, and verifies refactors before they ship — all designed for AI agent consumption. Gives agents the structural understanding of a codebase they need to make safe, targeted changes. Addresses one of the core risks of agentic refactoring: unintended side effects.
Study materials, code examples, and practice scenarios for the Claude Certified Architect: Foundations (CCA-F) exam. Covers five domains: agentic architecture, MCP integration, Claude Code workflows, prompt engineering, and context management.
Orchestration app that turns inbox, Slack, GitHub, calendar, and goals into a single morning brief of decisions using Claude Code agents. Python controls every gate and outbound action — the LLM only suggests and drafts, never acts autonomously. Silent by default, designed for fleet-level coordination.
A Progressive Web App for tracking Claude Code token consumption with a food-themed interface. Runs in the browser without installation, providing a lightweight alternative to native desktop token monitors.
A local code search tool providing six specialized, fast search methods designed for AI agents that return ranked, actionable answers rather than raw grep output. Improves how agents locate relevant code by surfacing the best matches first.
A system tray app built with Rust and Tauri v2 that monitors quota limits for multiple AI tools in one icon — Claude Code, Codex, Grok, and DeepSeek. Supports both Windows and macOS, filling a gap left by macOS-only alternatives.
A tool for spawning and coordinating multiple autonomous Claude Code agents that collaborate on tasks and automatically create pull requests. Provides a live progress view while agents work independently on parallel workstreams.
A self-hosted gateway for Claude Code that supports custom agent personas, persistent memory, and plugin-based channel routing. Provides a centralized control layer for managing multiple Claude Code agents with different identities and persistent contexts.
An unofficial Electron-based desktop app providing a unified workspace for running multiple Claude Code sessions, terminals, and browser tabs side by side. Designed for power users managing several concurrent Claude Code contexts.
ai-memory-vault provides an open-source system and Markdown templates that turn an Obsidian vault into working memory for AI assistants. Uses no vector database — just markdown files and structured templates. Gives Claude Code persistent, human-readable memory across sessions without infrastructure overhead.
A personal platform for managing agentic AI workflows that learns from session history to improve its data catalog, defined entities (rules, skills, agent personas), and processes. Aims to make AI workflows smarter over time without manual intervention.
A single npm package that makes ruflo (claude-flow) and agentic-qe reliably work on macOS, Linux, and Windows. The ak sync command detects drift, converges to a healthy state, and verifies it — uses native SQLite with no silent data loss, clean uninstall, thin and reversible.
A local-only macOS menu bar app that shows Claude Code and Codex token quotas, usage, and costs directly on screen. Generates HTML reports in 9 themes with zero API calls — all data stays on device.
An open-source memory plugin for Claude Code that writes session checkpoints and injects briefings on the next start. Every memory item is tagged as verbatim (traced to an exact transcript quote) or inferred (model conclusion) — letting you know exactly how reliable each recalled fact is. Includes an audit-quotes command to re-verify verbatim claims on demand.
A sandbox provider offering full Ubuntu VMs with desktop, Docker, and all devtools at ~5x lower cost than incumbents like E2B and Daytona. A new sandbox is just "box new" from the terminal; each VM supports moonlight/VNC, Docker, and long-running sessions. Available as a CLI, API, and SDK.
A zero-dependency CLI tool (npx deadskills) that reads local Claude Code and Codex transcripts, counts actual skill invocations, and reports active vs zombie (unused 90+ days) vs dead skills with estimated token cost per skill. Everything runs locally — no transcripts leave your machine.
A free, open-source macOS app (MIT) that uses the MacBook notch as a status panel for Claude Code, Codex, Gemini CLI, and Cursor. Features a configurable global hotkey for approving permission requests from any app, plus a companion iPhone/Apple Watch app for remote session monitoring.
A native macOS app for browsing Claude Code sessions, exploring diffs, and re-running commands without opening a terminal. Provides a GUI layer over Claude Code history for post-session review and command replay.
An autonomous Claude Agent SDK engine that performs narrow, verifiable tasks on a target repository and opens a reviewed, labelled pull request. Features env-validated config, DRY_RUN safety mode, and command-injection-hardened git operations.
An offline-first CLI that generates safe AI coding agent context files, task-first workflows, repo hygiene reports, and multi-agent instruction files. Designed to produce well-scoped context without leaking sensitive data.
Synchronizes configuration files for Claude Code, OpenCode, Codex, and other AI coding agents from a single canonical, committable source. Keeps agent setups consistent across machines and team members without manual copying.
Adds a terminal status line to Claude Code displaying context usage, git state, costs, and rate limits in color. Installable as a plugin, surfaces key session metrics at a glance without leaving the terminal.
Lets you run Claude Code and Codex in the background on macOS with a native dashboard, persistent tmux sessions, local checkpoints, and crash recovery support. Solves closed-lid and session-loss problems for long-running agent work.
Streams live Claude Code session data — context percentage, current model, and per-session status — over WiFi to a LilyGO T-Display-S3 ESP32 hardware display. Uses Claude Code hooks to push updates to the physical device.
Packages Claude Code chats and project files into a portable .cctx bundle for moving between machines. Includes automatic path remapping so file references stay correct after transfer — no cloud sync required.
A lightweight Windows system widget that shows local-first token usage and cost estimates for Codex and Claude Code sessions. Reads local logs and displays a live summary in a desktop widget with no server required.
An unofficial PWA client for Claude Code that connects over Tailscale, enabling multi-session chat, push notifications, file preview, and optional desktop screen sharing from a mobile browser. No cloud intermediary needed.
Makes Claude Code responses speak aloud using Kokoro, a local neural TTS engine. Entirely offline — no API key or cloud service required. Useful for hands-free coding sessions or reviewing long responses without reading.
Claudeq turns a Waveshare ESP32-S3 touchscreen into a dock beside your keyboard for driving Claude Code sessions: tap to approve permissions, see session status, and avoid alt-tabbing back to the terminal. Open-source personal project.
Allows multiple users to share and collaborate on terminal-based Claude Code and Codex sessions in real time. Enables team coding sessions, pair programming with AI, and remote collaboration on agentic workflows from the terminal.
CLI tool for AI agents (Claude Code, Codex) to read, edit, and add comments to .docx files with full format fidelity. Fills the gap that most coding agents can only work with plain text and markdown, not Office documents.
Electron + React desktop app that installs, updates, uninstalls, and launches 17 terminal AI coding agents — Claude Code, OpenCode, Gemini CLI, GitHub Copilot, Aider, and more — from a single macOS-style panel. Reduces the friction of managing multiple agent CLIs.
Automation toolkit for managing Claude Code and Gemini CLI sessions: tmux session management, git worktree automation, cross-machine sync, and resilient Gemini API access. Fills operational gaps when running multiple AI coding agents across machines.
Go CLI that applies consistent Claude Code configuration profiles across all your projects. Write a profile once, apply it everywhere. Ensures the same CLAUDE.md conventions, settings, and hook configurations are active in every project without manual duplication.
Raycast extension for Claude Code: spawn new agent sessions, resume existing ones, and review agent status — all from the Raycast launcher without switching to the terminal. Reduces friction in managing multiple Claude Code sessions.
Model router for agentic systems that routes every prompt to the right model in under 50ms. Analyzes query complexity and routes to cheaper models when appropriate. Drop-in endpoint change can reduce costs 40-70% with no changes to agent logic.
A complete Hyprland-based Linux setup where Claude Code handles software tasks via end-to-end voice missions — system-wide dictation converts speech to text, which is passed to a Claude Code agent. The entire development workflow is driven by voice.
Local desktop app that orchestrates multiple Claude Code sessions across git repos in parallel, managed from a Kanban board view. Each card is an agent session; you can assign tasks, monitor progress, and review output without leaving the UI.
One Python file, zero dependencies, offline memory system for any coding agent. Implements spreading-activation recall (concepts activate related concepts), Ebbinghaus forgetting curves, and deterministic dream consolidation (periodic memory compression). Supports English and Arabic.
Manage Claude Code cron jobs (e.g., /loop) without losing state. Pause a running job, edit its parameters, resume, and review the full audit trail of past runs — all without canceling the session or losing progress.
Single-binary Rust gateway that lets Claude Code connect to ChatGPT, OpenAI, GitHub Copilot, Gemini, OpenRouter, or custom backends. Includes OAuth, smart model routing, virtual 1M context window, and a TUI for observability. Drop-in proxy for the Claude API surface.
CLI tool that creates a searchable store of all your Claude Code session transcripts. Full-text search, timeline view, and filter by date or project. Lets you find past solutions, recall how you solved a problem, or audit what an agent did.
Pure Nix machinery for sandboxed Claude Code sessions with Chromium support. Three backends: bubblewrap (lightweight), systemd-nspawn (intermediate), and QEMU VM (full isolation). Declarative sandbox definitions composable with existing NixOS and Home Manager configs.
Docker-based launcher where each AI coding agent runs in its own isolated container with explicit file mounts and isolated auth. The container is the sandbox; mounts define what the agent can access. Supports Claude Code, Codex, Gemini, and Grok.
macOS menu bar app monitoring Claude and Codex subscription usage in real time. Tracks 5-hour, 7-day, extra usage, 7-day Opus, and 7-day Sonnet quotas simultaneously. Shows pace and remaining allocation at a glance without opening the browser.
JupyterLab extension that adds Claude Code, GitHub Copilot, Ollama, and OpenAI-compatible LLM support. Includes MCP integration, skills, plugins, and notebook-aware agents. Brings the Claude Code experience to data science and research workflows in Jupyter.
Standalone HTML app (Alpine.js + Tailwind CSS) for editing Claude Code's settings.json visually. Provides a structured form interface instead of hand-editing JSON. No server required — open the HTML file directly in your browser.
Single-process observability platform for AI coding agents: captures LLM traces via a built-in proxy, ingests OTLP, stores in SQLite, and provides a Langfuse-style dashboard. Monitors Claude Code, Codex, OpenClaw, opencode, and Hermes. Zero containers required.
Lightweight C database compiled to a single binary, designed to give AI agents durable, searchable long-term memory. Includes a Claude Code integration. Optimized for fast recall and storage of agent work artifacts without PostgreSQL overhead.
Self-hosted control plane for multiple AI coding agents. Manages Claude Code, Codex, Gemini CLI, Cursor, Qwen, and OpenCode in one workspace with chat, file management, shell access, Git, orchestration, Telegram integration, MCP, and API automation.
Remote dashboard for Claude Code, Copilot, and Codex — approve permissions, answer agent questions, and monitor token usage from a GeekMagic screen, Android widget, GNOME Shell extension, or VS Code panel. Designed for monitoring agents without being at your primary screen.
macOS menu bar app for switching between Claude Code and Claude Desktop accounts in one click. Auto-falls back to a secondary account when you hit usage limits, then auto-returns to the primary when the limit resets.
Local autopilot that drives Claude Code interactive sessions unattended, using a local LLM as the stand-in for human input. Subscription-safe — no API key required. The local LLM decides when to approve, skip, or intervene based on configurable rules.
Opens real pages in Playwright, measures actual pixel values, and catches AI-generated design anti-patterns (slop). Checks typography, spacing, color consistency, and component alignment. Can fix detected issues automatically.
Local macOS utility that safely reclaims disk space from AI coding workspaces and git worktrees by removing rebuildable artifacts (node_modules, build outputs, etc.) while preserving actual source files. Designed for the storage accumulation that comes from running many parallel agent sessions.
Exports Claude Code chat session history to standalone, self-contained HTML files from the session history view in the Claude Code sidebar. Useful for sharing sessions, archiving important conversations, or reviewing past agent work offline.
Creates a searchable, portable store of Claude Code sessions with full-text search, AI-generated titles, tags, fuzzy find, and the ability to resume any session in any folder. Solves the problem of sessions being scattered and difficult to find later.
Web-based dashboard for managing multiple Claude Code agents simultaneously. Launch, monitor, pause, and review agents from a single browser interface. Useful for teams or individuals running many parallel agent sessions.
Open-source LLM context optimizer for coding agents. Detects and compresses repeated tool output (file reads, search results, shell output) while preserving exact data. Publishes measurable token savings per session.
Reconstructs the Claude Code CLI from its source maps into runnable TypeScript, making the implementation available for study, debugging, and local modification. Useful for understanding Claude Code's architecture and building extensions.
Local web dashboard that tracks Claude Code activity in real time: session data, token spend, cache performance, and tool usage. Gives a persistent view into what your agents are doing and how efficiently they're using the context window.
Tauri + React + Rust desktop companion app displayed as an animated jellyfish that voice-narrates Claude Code, Codex, and Gemini CLI events and confirms permission prompts by voice. Adds ambient awareness of agent activity without staring at the terminal.
A static analysis tool that validates CLAUDE.md files, skills, settings, hooks, MCP servers, and plugins in Claude Code projects. Catches misconfigurations before they cause problems. Useful for teams maintaining consistent project structure.
A masterless, terminal-native coding agent that works like Claude Code but supports Claude, Gemini, Cerebras, Groq, and Ollama. Includes evals, memory, security hardening, 200+ plugins, and MCP support. MIT licensed.
A CLI wrapper that detects when you walk away from a Claude Code session and auto-compacts it before the prompt cache expires. Injects a save-state prompt, runs /compact, then restores any in-progress typing. Available via npx.
An eldritch-themed TUI that runs Claude Code and Codex in a loop: Claude implements, Codex adversarially reviews each iteration, and every loop is grounded in a ./check.sh script. A fast, opinionated harness for multi-model code review workflows.
An Angular app that uses Claude Code to transform WorldBox game save files into narrative prose chapters, rendered in a parchment-themed reader. A creative showcase of using Claude Code as a narrative generation engine from structured game data.
A real-time dashboard that tracks and rotates Claude and Codex usage across multiple accounts without spending any tokens — reads live quota data only. Useful for power users managing multiple subscriptions or team accounts.
An isolated virtual machine environment for running Claude Code and Codex safely, from Trail of Bits (a leading security research firm). Designed for running AI coding agents with proper sandboxing and containment.
A security tool that acts as a firewall and credential manager specifically for AI coding agents. Controls what network access agents have and manages secrets they need — addresses a real gap in agentic security.
Three Claude Code plugins covering the full session lifecycle: remote spawning (claude-remote), cache keepalive (claude-session-keeper), and cross-machine session teleportation (claude-session-teleport). Published as a plugin marketplace bundle.
A local-only, privacy-first usage monitor for Claude Code and Codex CLI sessions. Provides a live TUI dashboard with per-agent and per-model cost breakdowns and usage heatmaps. Nothing leaves your machine.
An Electron desktop app that runs Claude Code, Codex, Gemini, Kimi, and OpenCode in isolated Git worktrees side by side. Includes a Sigma Assistant orchestrator that resumes Claude sessions across restarts and observes pane lifecycle via a mailbox back-channel.
A Claude Code + Cowork plugin that turns your own files into cited memory (qmd:// URIs) with a tamper-evident, SHA-256 hash-chained audit trail. Local-first, no daemon or network. Supports both personal and team modes.
A Claude Code plugin designed for product builders who direct AI rather than write code. Keel intervenes at decision points — should we build this, which architecture, what are the failure costs — rather than at code style moments. Opinionated about separating strategy from implementation.
A CRUD app built end-to-end by a team of Claude Code agents driven from Linear tickets, with remote agents implementing, testing, and gating every PR on GitHub Actions. Includes a detailed case study with per-feature costs served by the app itself.
A local proxy that exposes your Grok subscription as an Anthropic-API-compatible endpoint, letting you use Claude Code CLI and VSCodium without an xAI API key. Useful for mixing model subscriptions in your workflow.
A local-first tool that exports AI chat histories into labeled datasets to analyze usage, value, and human judgment. Useful for understanding patterns in your Claude Code sessions and generating evidence about AI productivity.
A visual management interface for Claude's memory system. Helps users browse, edit, and organize Claude's memory entries through a GUI rather than raw files.
A switcher (not a rotator) for managing multiple Claude Code and Codex login accounts locally and safely. Useful for developers managing personal and work accounts or testing different subscription tiers.
A multi-instance Claude Code manager with a bundled web UI for orchestrating multiple Claude Code agents from one place. Simplifies running parallel agent sessions across different projects.
A Claude Code repair harness that makes small, self-hostable coding models fix bugs with frontier-model quality. Gates require machine-checked evidence that a patch restored the documented contract, not just passing visible tests.
A unified terminal that runs Claude Code, Codex, OpenCode, Gemini, Antigravity, Cursor, and Copilot side-by-side in any layout. Combines terminal and chat for multi-agent parallel development.
Displays live Claude Code usage status on the MacBook Pro Touch Bar using MTMR and ccusage. A convenient way to monitor rate limits and usage without switching windows.
A self-contained, portable distribution of Claude Code and other AI coding tools for Windows, Linux, and Mac with multi-profile support, a session picker, bootstrap scripts, and Windows Explorer integration. No installation required.
A zero-dependency, single-file fuel gauge showing how much of your 5-hour and weekly Claude Code quota remains, when it resets, and how full your context is. Prevents rate-limit surprises.
A self-hosted server and installable PWA that runs Claude Code remotely from your phone or any browser, using your Claude subscription without an API key. Enables fully remote AI coding sessions.
A one-command self-hosted bridge that connects Cursor IDE's agent and chat features to Claude via OAuth, without needing a per-token API key. Lets Claude Pro/Max subscribers use Cursor with their existing subscription.
A local-first cognitive memory system for LLM agents that can be shared across a team through the cloud. Bridges individual agent memory with team-level knowledge sharing.
Transforms Claude Code into an always-on AI assistant that stays ready for continuous use. Useful for developers who want persistent Claude Code availability without manual session management.
Search and analyze 20,000+ smart contract security findings using Claude Code and Codex CLI. Provides AI-powered audit capabilities for blockchain developers.
Track your Claude API usage in real time with a macOS menu bar app showing hourly and weekly stats plus detailed breakdowns. Convenient for monitoring consumption without leaving your workflow.
A macOS terminal built for running Claude Code, Codex, Gemini CLI, and opencode in parallel. A live status sidebar shows which session is working, done, or waiting for input, so you never miss an agent blocked on your response.
A local proxy and app launcher that points Claude Code, Codex CLI, Gemini CLI, and Antigravity at any model — including free ones from OpenRouter, Ollama, or LM Studio. Also supports Claude Code with ChatGPT Plus/Pro accounts.
An open-source local router that connects Claude Code to both cloud and on-device models. Enables flexible model routing without vendor lock-in.
An offline security scanner for AI-agent repositories, skills, plugins, and MCP servers. Helps audit third-party agent tooling for security issues before installation.
A Claude Code workspace toolkit providing persistent memory, multi-account inbox MCPs, rule discipline, and auto-capture knowledge base. Bundles several workspace enhancements into one MIT-licensed package.
A sandboxed devcontainer for running Claude Code, Codex, and OpenCode in bypass/auto-approve mode safely. Provides an isolated environment for autonomous agent operations.
A value investing research framework for Claude Code and Codex implementing Buffett, Munger, Duan Yongping, and Li Lu methodologies with multi-agent adversarial analysis.
A zero-config terminal dashboard for Claude Code that tracks all sessions, lets you switch context instantly, and ensures you never lose track of what's running across multiple projects.
A narrative companion to ccusage: while ccusage shows the bill, ccstory tells the story of what happened in your Claude Code sessions. Adds human-readable context to raw usage data.
Colors terminal tabs white (idle), blue (working), or orange (waiting) to show Claude Code and Codex state at a glance. Includes a live status bar with Anthropic usage limits, window save/restore, and twelve companion skills.
Switch between multiple Claude Code accounts with automatic rate-limit rotation, a usage dashboard, and parallel sessions. Goes beyond simple account switching to actively manage rate limits across accounts.
A local-first semantic canvas where you and your coding agent can branch ideas, switch views, and review every AI change. Provides a visual workspace for human-agent collaboration.
A clean, minimalist status line script for Claude Code with git integration and intelligent context monitoring. Keeps your terminal statusline informative without clutter.
A Grok Build plugin that hands work to local Claude Code or Codex as a background task. Enables Grok to delegate implementation to Claude Code without leaving the Grok interface.
A pixel mascot desktop app (macOS/Windows/Linux, Tauri 2) that animates based on what Claude Code is doing in real time, plus a live token usage monitor showing 5-hour window %, weekly limit, and reset countdown.
Browse and edit your Claude Code configuration (~/.claude) in the browser via a single npx command. Provides a GUI for managing settings, hooks, and other Claude Code config files.
A terminal-based agent multiplexer for running and managing multiple AI coding agent sessions. Provides a unified interface for orchestrating parallel agent work.
A Claude Code launcher that routes requests to OpenAI Codex subscription models. Enables Claude Code users to leverage Codex models through familiar Claude Code workflows.
An AI software factory pipeline where tickets, docs, designs, and analytics go in and shipped code comes out. A secure pipeline from idea to code review with Claude on the line and human approval on the floor.
Fast, batteries-included local-first usage tracking for Claude Code and Codex. Provides detailed usage analytics without requiring external services or network calls.
Kernel-enforced egress control for AI agents on macOS and Linux, with keys only the operator holds and tamper-evident audit. One command protects Claude Code, Cursor, or any MCP harness with no vendor in the path.
Mission control for multi-agent Claude Code workflows, enabling you to run an AI product team across your projects. Provides centralized management for complex multi-agent development operations.
A memory framework for AI agents that builds and refines its own knowledge over time. Designed to enhance agent capabilities with persistent, contextual memory that evolves with use. Useful for Claude Code workflows that need long-term context across sessions.
A native Rust application offering both a terminal UI and desktop GUI for monitoring token and cost usage across AI coding tools including Claude Code. Provides a lightweight, fast interface for real-time usage visibility. Useful for developers who want to track spend and efficiency without leaving the terminal.
A self-hosted platform that runs Claude Code inside isolated Docker containers on a VPS, with a web-based multi-session manager for spinning up instances on demand. Features GitHub OAuth for access control, automatic repo cloning, and Git identity mapping per session. Ideal for teams or individuals wanting secure, remote Claude Code access without local machine constraints.
A native LLM inference server for Apple Silicon with no Python dependency, offering both OpenAI and Anthropic API compatibility out of the box. Includes MLX Core, a macOS app with chat interface, agent mode, and tool calling support. Claude Code users can point it at a local model using the same API they already use.
A local gateway that intercepts Claude Code sessions and routes them to any OpenAI-compatible or Anthropic-compatible model endpoint, including local models. Supports switching models within the same session with visible compatibility behavior. Useful for cost optimization or experimenting with alternative models.
Indexes Claude Code JSONL session transcripts into SQLite per-project for semantic retrieval. Uses bge-m3 embeddings via Ollama for vector similarity search, with FTS5 full-text search as a fallback. Lets you find past solutions, decisions, and context across all your Claude Code sessions.
macOS app that prevents your Mac from sleeping while AI agents are working. Built for developers who run agents on the go. Available on GitHub as a community contribution.
Single Rust binary that sits between AI coding agents and your shell. Redacts secrets, neutralizes prompt injection, wraps untrusted terminal output, and audits every command. Useful for running agents in shared or less-trusted environments.
Native desktop application (Flutter + Rust + Ghostty) for running CLI coding agents like Claude Code, Aider, and Copilot in parallel using Git worktrees. Designed as a performance-first Agentic Development Environment.
VS Code extension for running multiple AI command-line tools (Claude Code, Codex, etc.) in separate tabs to reduce context switching. Designed for macOS developer workflows involving several AI agents.
Lets a nontechnical stakeholder write directly into a coding agent's prompt while the developer runs it. Bridges the gap between technical and nontechnical contributors in AI-assisted development.
CLI wrapper that makes Claude Code the message bus for a Codex worker running in a watchable terminal window. Claude plans and orchestrates while Codex executes edits; replies flow back automatically and sessions persist. MIT-licensed.
macOS menu bar app that shows real-time indicators for active Claude Code tasks, pending permissions, and elapsed time. Keeps you aware of agent activity without switching windows.
Tracks not just what AI coding agents ship but why each change was made, turning the commit history into a queryable living view of how your codebase works. Bridges the gap between AI-generated diffs and human understanding.
Local Python CLI that tracks Claude Code and Codex usage, captures quota snapshots, and monitors token activity over time. Useful for staying on top of subscription limits across multiple sessions.
macOS menu bar app that displays Claude usage limits as battery-style gauges for at-a-glance monitoring. A quick way to track how much of your subscription quota remains.
Stores decisions, mistakes, preferences, and rules accumulated from AI work sessions — but only what you explicitly approve. Surfaces approved memories before the next task. PC-local with no auto-save.
Terminal multiplexer built with GPUI specifically for running multiple coding agents side by side. Native performance with a UI framework designed for modern developer tools.
Adds runaway-kill, timeout, and resource limit guardrails at the OS level for coding agents (Claude Code, Cursor, Codex) running in YOLO mode on macOS. Prevents agents from burning tokens or freezing your machine.
Run a team of always-on background coding agents (Claude Code, Codex) and drive them from Telegram, Lark, or a web interface. Self-hosted with 24/7 agent availability.
Lightweight AI pair programming tool distributed as a single static binary with sub-millisecond startup time. Works with any model from the terminal.
CLI tool that lists all recent Claude Code sessions across your projects, showing project path, summary, git branch, model, and turn count with a ready-to-paste resume command. Can reopen a whole working set in terminal tabs. No network or telemetry.
Proxy server that manages multiple Claude accounts and rotates between them automatically based on quota availability. Designed for continuous agent workloads that need uninterrupted access.
AI-powered interview maximizer with a mechanical truthfulness guardrail for local job application automation. Built end-to-end with AI-assisted development using Claude Code.
Minimal, secure, local tool for viewing your Claude Code usage. Runs entirely on your machine with no network calls or data collection.
Pixel art desktop pet that monitors Claude Code, Codex, Cursor, and other AI coding agents so you do not have to constantly check on them. Lightweight ambient awareness for agent status.
Real-time terminal token usage monitor for Claude Code with a retro amber aesthetic. Shows live token consumption as you work in the terminal.
Syncs Claude Artifacts directly to your local file system via a secure WebSocket bridge. Automates code updates so artifacts from Claude.ai land in your development workspace without manual copy-paste.
Self-hosted terminal server with server-side VTE, session persistence, file browser, web preview, and a plugin system. Gives AI coding agents a stable, persistent terminal environment accessible from multiple devices.
clauster is a homelab-friendly web UI that lets you spawn and manage Claude Code remote-control bridges from any browser or phone. It provides start/stop controls, permission mode switching, a CLAUDE.md editor, git clone support, live log tailing, and cost tracking — with loopback-by-default security and no telemetry. Ideal for running Claude Code on a home server and accessing it remotely.
agent-deck is a terminal user interface (TUI) that unifies session management across multiple AI coding agents including Claude Code, Gemini, OpenCode, and Codex. It provides a single pane of glass for launching, switching, and monitoring multiple agent sessions simultaneously. Useful for developers who juggle several AI coding tools and want a consistent terminal-based workflow.
sshepherd lets Claude Code and other AI agents perform SSH operations — server health checks, Docker/systemd control, read-only Postgres introspection, and declarative deploys — without the agent ever seeing passwords, keys, hostnames, or ports. Secrets are kept entirely outside the agent context, making it safe to delegate infrastructure tasks to an AI coding agent. A practical tool for devops workflows that involve AI assistance.
ClaudePortable packages your Claude Desktop, Cowork projects, and Claude Code state into a single ZIP file for backup or cloud sync. It makes it easy to migrate between machines or restore your full Claude environment after a reinstall. A handy utility for users who want portable, recoverable Claude setups.
galley is a task runner designed for Claude Code, Codex, and GLM that emphasizes supervised execution and clean handoffs to pull requests. It keeps tasks local-first while providing structured workflow management for AI coding sessions. A good fit for developers who want a controlled, auditable way to manage AI agent tasks.
conch adds a voice interface to Claude Code — sessions speak when they finish and you talk back using your microphone. It uses local whisper.cpp for speech-to-text with session-aware routing, enabling completely hands-free coding workflows without any cloud dependencies. A creative way to keep your hands on the keyboard while still directing your AI coding sessions.
claude-codex-queue queues Claude Code and Codex App tasks and automatically continues them after usage limits reset, preserving settings and prompt order. It is a practical solution for power users who frequently hit rate limits and want uninterrupted workflow continuity. Handles both Claude Code and Codex App tasks in the same queue.
constant maintains one conversation thread while letting you switch between Codex, Claude Code, and OpenCode agent runtimes at any point mid-session. It keeps a durable record of every exchange so context is never lost when moving between agents. Useful for users who want to leverage different agent strengths without losing conversational continuity.
Tron is a single-agent interface that manages a fleet of underlying agents to build software from specification documents. You talk to one agent and it coordinates the work across the fleet. Useful for structured, spec-driven development workflows.
Caliper is an evaluation harness for comparing AI coding agents — Claude Code, Codex, Hermes, and Pi skills. Runs locally, useful for benchmarking changes to prompts, skills, or agents before deploying them.
A web game where each day you committed becomes a building and busy days become skyscrapers. Type any GitHub username and pilot a plane through your contribution history. Built with Claude Fable during "quota panic" — works on desktop and mobile with tilt controls.
A zero-config CLI that reads your local Claude Code session logs and produces an itemized breakdown of token usage. Runs 100% locally with no configuration needed. Useful for understanding which operations consume your subscription budget.
A local-first Tauri desktop app (Rust + React) that manages multiple Claude accounts as one resource pool. Features live 5-hour usage tracking, automatic failover that moves sessions to another account when a limit is hit, auto-wake on reset, and an Operator → Workers delegation model. Apache 2.0, no telemetry.
Installs Xcode-signed iPhone builds and opens Mac Simulator previews directly from Claude Code, Codex, Cursor, or OpenCode. Removes the need to switch to Xcode during iOS development workflows.
A transparent self-hosted proxy for Claude Code that switches between Claude and MiniMax with automatic failover, context compression, and cross-model verification. Single endpoint, zero IDE restarts needed when switching models.
A collection of parametric 3D-printable designs created with Claude Code, paired with a Next.js + WASM web UI for live parameter sliders and STL export. A concrete example of using Claude Code for hardware/CAD workflows.
Real-time LLM cost tracking that measures file format cost differences (36x variance), operation type variance (55x), data warehouse query costs (100x-1000x+), and SaaS MCP inefficiency (10x-100x). Claims to be the only tool tracking actual spending patterns rather than raw token counts.
A Claude Skill that reviews physician CVs for European residency & specialist-training applications like a real HR screener
Native macOS menu bar app for tracking Claude Code and Codex account usage.
A free, open-source AI agent that runs entirely on your machine — controls your computer like you would, works across any app, and handles arbitrary tasks: writing code, analyzing images, organizin...
Analyze Sui Move smart contracts with a parallelized tool that checks 143 attack vectors and applies DeFi security best practices.
Local-first planning and supervised execution harness for AI coding agents. Turns product ideas into approved specs, dependency-aware task graphs, run logs, eval reports, and maintenance loops for...
A skill registry and project linker for Claude Code, Codex, Pi, and opencode — one canonical home for your agent skills, organised into bundles and synced to every project. CLI + Tauri desktop app.
Show your presentations with charts, diagrams, and code highlighting. Works with most AI coding tools (Claude Code, Codex, Cursor, AMP).
A local browser tool that wraps Claude Code sessions with a thread-navigation layer and a readable conversation viewer.
Hi everyone — quick disclaimer up front: I built this on OpenCode , not Claude Code. But the core cost technique is exactly the plan-mode → subagents → review shape a lot of you already run here, s...
Disclosure up front (rule 6): I'm the author. It's free, MIT-licensed, open source, no paid anything — I benefit only from feedback and GitHub stars. My workflow problem: Claude Code is my main age...
TLDR: Opus is surprisingly frustrating compared to Fable When talking to Opus 4.8 xhigh using ultracode, I feel like I am in a Monty Python skit. I primarily use Fable for adverdsarial review of a ...
View and analyze Claude Code conversation history and compaction events with a TUI and CLI tool for clear session insights.
Minimalistic, project-agnostic skills and rules for AI coding agents
Implements RAG without embeddings or a vector store by using reasoning-based retrieval and answer generation. An interesting alternative approach for codebases or setups where vector infrastructure is unavailable.
A self-hosted end-to-end AI coding kanban with no companion daemon, no cloud account, and no agent lock-in. Goes from a one-line idea to a reviewed PR with per-ticket git worktrees, interactive clarification, and live agent streaming.
CLI tool that sets up and manages Claude Code agents as persistent, proactive personal assistants with Telegram integration and cron scheduling. Agents survive session restarts and can send proactive notifications via Telegram.
Autonomous project idea generator scoring on feasibility (build), fundability (sell), and ambition (frontier) axes. Uses LLM-first generation with 5 modes × 12 personas across 19 categories, with human-gated promotion to GitHub. Runs at ~$2-3/mo on Haiku 4.5 or free via Claude Code CLI.
A lightweight FastAPI proxy that translates Anthropic API requests to NVIDIA NIM's OpenAI-compatible endpoint. Useful for running Claude Code-style workflows against locally-hosted NVIDIA AI models.
Stop babysitting local AI agents — Lucarne sends notifications and lets you approve/resume Codex, Pi, Grok, or Claude Code sessions from anywhere via Telegram, WeChat, or Feishu. Zero-intrusion: no hooks, no skills, no MCP required.
Builds a physical status light and usage gauge for Claude Code using a Pi Zero W, WS2812 LED ring, 3D-printed case, and web UI. A fun hardware project that makes Claude Code session state visible in the physical environment.
A Telegram bot that bridges Claude Code, Codex, and Gemini CLI agents with privacy-first design — projects are private by default and CRM sync is explicit opt-in. Enables mobile management of multiple AI coding agents.
Windows application for organizing multiple AI coding accounts, switching between them, tracking usage limits, and seeing when accounts will reset. Adds a system tray widget, custom notifications for limit warnings, and usage statistics comparing models, token categories, and task counts.
AI coding session orchestrator with persistent tmux sessions, multi-engine management, methodology enforcement, and mobile access for Claude Code, Codex, Gemini CLI, Aider, and OpenClaw. Keeps sessions alive across disconnects and coordinates work across agents.
Animated liquid-orb usage gauges for Claude, Codex, and Antigravity on macOS showing live token consumption visually. A unique visual status indicator that makes usage limits tangible at a glance.
Discover and compare open-source Agent Skills, tools, and MCP servers with quality scoring, trending analysis, and automated GitHub sync. A searchable registry for finding the best skills in the ecosystem.
Dynamic proxy that connects Claude Code to local Ollama models and OpenRouter, bypassing ecosystem locks and enabling use of free or self-hosted APIs. Useful for developers who want to experiment with alternative models within Claude Code workflows.
Claude Code multi-source proxy with protocol translation, priority routing, multi-user quota management, and a statistics dashboard. Single Go binary with Docker deployment for teams sharing Claude Code access.
A local tool that reads your Claude Code sessions and tells you the truth about where friction occurs — headed toward a menu-bar companion that acts on its own advice. Helps developers understand patterns in how they work with Claude Code.
Zero-config CLI for analyzing AI model usage and costs across all local TUI tools including pi, Claude Code, Codex, Gemini CLI, OpenCode, and more. Aggregates usage data into comparable reports without any configuration.
Displays real-time Claude Code model info, token usage, and rate limits in a compact status line without affecting performance or token counts. A lightweight monitoring widget for developers who want live session metrics.
Open-source macOS menu-bar app for managing and switching between multiple Claude Code accounts. Makes account switching fast without going through browser sign-in flows.
Production-grade Python LLM agent harness and framework-design case study covering tool loop, MCP, sandbox, and sub-agents in 17 phases over 23 days. A detailed learning-by-building guide for agent harness architecture.
Tracks all AI coding agents (Claude Code, Codex, Cursor, etc.) in tmux and lets you jump instantly to whichever one needs attention. A lightweight tmux-based multiplexer built specifically for managing multiple concurrent AI coding sessions.
Integrates Claude AI directly into Microsoft Word desktop to write, edit, and summarize documents without leaving the application. Provides a native Word add-in experience for AI-assisted document work.
Indexes codebases for AI agents with a single command, building a local map of your repository with no server requirements or setup. Useful for giving agents quick codebase orientation without uploading code externally.
Connects your codebase to AI coding tools through a universal context spine that maintains shared project understanding across agents and sessions. Acts as a persistent context layer bridging multiple AI tools against a single codebase.
Professional browser-based AI development environment integrating VS Code (code-server) with multiple AI coding assistants for enhanced productivity. Provides a self-hosted workspace where you can run different AI tools alongside VS Code in a browser.
Routes traffic from third-party AI tools (Cursor, Cline, Aider, Agent SDK) through a local endpoint that replays Claude Code's wire protocol, so requests are billed against your subscription pool instead of per-token API pricing.
A kanban board for managing projects with tickets, columns, labels, and activity tracking, specifically designed to be driven by AI agents via its API. Enables agents to create, move, and close tickets programmatically as part of their workflow.
forge-kit reads your codebase and installs adapted governance tools including ticket gates, code reviewers, and security auditors — tailored to what it finds, not generic defaults. Built specifically for Claude Code, it aims to add structured governance to AI-assisted development without the usual manual configuration.
hippocampus integrates Claude Code with Obsidian to build a personal second brain. Uses Claude Code as the intelligence layer on top of an Obsidian vault, enabling AI-assisted capture, recall, and reasoning across your personal knowledge base.
workspace.nvim gives Neovim a unified workspace across all your repos with Claude Code wired directly into the editor. Supports named workspaces, multi-repo source control, and browsing or resuming past Claude Code sessions from within the editor — built on vim.pack without requiring lazy.nvim or neo-tree.
agent-teams-ai treats AI agents as a team: agents handle tasks autonomously, message each other, and review each other work, while you watch a kanban board and issue high-level commands. Supports Claude Code, Codex CLI, OpenCode, and 75+ LLM providers including free models.
cognitive-core is a self-hosted Docker stack that creates shared rooms where Claude Code, ChatGPT, and any other LLM can collaborate. MIT licensed, it provides local infrastructure for running multi-model agent conversations without cloud services.
athenaeum is an open-source knowledge management pipeline with passive recall, append-only intake, tiered compilation, and configurable schemas. Designed as an AI-readable knowledge store with nightly consolidation passes similar to how LLMs process training data.
CodexBar is a menu bar app that shows usage statistics for both OpenAI Codex and Claude Code without requiring you to log in to any web dashboard. Provides quick at-a-glance visibility into AI coding session consumption directly from your menu bar.
Prismor is a runtime firewall that intercepts tool calls before they run, catching dangerous commands, secret leaks, and prompt injection attempts. Works with Claude Code, Codex, and other framework SDKs as a pre-execution safety layer for both attended and unattended sessions.
claude-control enables dispatching and controlling Claude Code sessions for many projects from a single always-on session on macOS. Useful for managing long-running or parallel Claude Code sessions without switching contexts manually.
sh-guard uses AST analysis and risk scoring to classify shell commands before AI coding agents execute them. Helps catch dangerous operations at the shell execution boundary, providing a safety layer for unattended agent runs.
A developer built a personal SaaS (Sillage + Mogwai) using Claude Code without prior coding experience, aggregating 14 digital streams including screen, audio, Slack, Gmail, calendar, GitHub, and Apple Health. An AI agent named Mogwai lives in this memory and proactively sends morning briefings and meeting prep via iMessage.
codex-sidecar provides safe sidecar execution for code reviews, codebase exploration, risk checks, and isolated worktree fixes. Runs alongside AI coding agents as a sandboxed companion for operations that need isolation from the main workspace.
The Harness family is a single repo covering a desktop coding agent (any model), an iPhone app that remotely controls your computer agents, and a ChatGPT-style chat client supporting OpenRouter and on-device MLX. Aims to cover the full personal AI coding stack across desktop and mobile.
unsnooze monitors Claude Code sessions in tmux and automatically resumes them when the usage limit resets, reading the reset time from the banner and pressing Enter at the right moment. If the pane is closed, it reopens the session. Supports Claude Code, Codex CLI, VS Code extension, desktop app, and experimental Grok.
openbook provides open-source report formats designed to make long-horizon agent work readable by humans. It structures agent output into legible summaries suited for reviewing what AI agents actually accomplished across extended sessions. Useful when you need accountability and clarity from autonomous agent work.
A web-based tool that analyzes your Claude environment and account risk before registering, subscribing to Claude Pro, or using Claude Code. Helps detect conditions that might lead to account bans or API access failures. Particularly useful for users in regions with access restrictions.
A macOS app that uses the Dynamic Island notch area to display real-time status of all local Claude Code sessions — running, waiting, done, or error. Lets you approve tool-call permissions directly from the notch without switching windows, using Claude Code hooks over a local loopback with zero network egress.
A Rust-powered Stream Deck integration that turns your physical Stream Deck into a Claude Code control room. Displays an animated session board with live session states, usage gauges tracking token consumption, and an activity heatmap. Designed for developers who want hardware-level monitoring without switching to a browser.
A local dashboard at 127.0.0.1:4711 that tracks every Claude Code session with callsigns and a state column (queued→working→verifying→needs-you→idle→offline) driven by hook telemetry. Features a conflict radar for detecting when two sessions edit the same file, a needs-you rail to approve permission prompts from the board, inter-session messaging, session spawning, and a live xterm.js terminal in the browser.
A system for managing fleets of Claude Code AI worker machines from your phone via Telegram, featuring a real-time dashboard, automated auditor governance, and bulk deployment capabilities. Supports coordinating multiple PCs running Claude Code workers with centralized oversight.
A CLI tool that makes AI code contributions visible — tracking provenance, attribution, and semantic lineage across commits, pull requests, and repositories. Useful for teams that want to audit how much of their codebase was AI-generated and trace the origin of AI-written changes.
A Mac utility that monitors and reclaims memory leaked by Claude Code, Codex, and MCP servers during idle periods. Takes an advisor-first approach — it suggests rather than kills — so it never interrupts active work. Addresses a common issue where long-running Claude Code sessions gradually consume more RAM.
A proactive monitor that tracks context window degradation and rate limits during Claude Code sessions. Alerts you before hitting limits that cause incomplete responses or context loss, helping maintain session quality over long coding sessions.
Claude Code Mortgage Plugin 2026 - AI-Powered Refinancing Pricing Tool
Explore Claude Code's Agent Harness architecture with a clear breakdown of its runtime, tools, and control flow for AI agent builders
is anyone else losing their mind over the latency in claude code and codex right now? i’m not trying to do any crazy loop engineering or 400-step agent workflows. i literally just want to manage my...
I built PackMind to solve a problem I kept having with Claude Code, useful project context, decisions, and previous fixes disappearing between sessions. PackMind adds persistent project memory, loc...
A toolkit of skills, templates, and guides for bootstrapping AI-agent-friendly projects. Started from Anthropic's Claude Code engineering patterns, extended with a per-project self-improvement loop...
Self-hosted AI agent that builds apps. Chat with a coding agent (Claude Code or Codex) that builds mini-apps, modifies its own UI, and gets sharper the more you use it. Your personal AI operating s...
Best Claude Code Memory Toolkit Alternative 2026 – Smart Markdown Session Manager
I work in marketing, not as a software engineer, but I spend way too much time tinkering with coding agents on real projects. What kept happening was this: the agent would finish a task, say it was...
Sleep-time memory consolidation for Claude Code agents, with a cross-project shared-consciousness layer.
This isn't intended to be a technical analysis of token consumption, but rather the practical experience of a heavy user on top-tier subscriptions (the $200 GPT Pro plan and the $200 Claude plan). ...
Provide a curated set of tools and resources to secure Claude Code and its AI coding environment for production deployment and threat management.
The complete Claude Code toolkit for web & advertising design agencies — 6 plugin bundles for the full agency workflow
Supercharge Claude Code in Telegram with a smarter plugin for stronger chat control, better workflow, and more useful tools
I use Claude Code for both work and personal projects, and I got tired of constantly switching accounts manually. So I built ccswitch : a simple browser-based tool that lets me switch between Claud...
Adds self-learning voice notifications with edge-tts, phrase pools, priority queues, and anti-repeat handling. Keeps you informed hands-free as Claude Code works.
An SSH multiplexing CLI designed for AI agent use, enabling agents to manage multiple SSH connections efficiently as part of automation workflows.
Cleans the FAT (metadata), never the MEAT (content). Code-enforced zero-fact-loss gate, human-gated deletes, transactional apply, and 4-band economic gauge. Zero-dependency.
Declares a contract for the Claude Code harness and gates on conformance — described as 'the Rust of agentic harnesses'. Ensures the harness behaves predictably over time.
CLI and Claude Code skill to scan codebases for dead code, unused imports, duplicates, secrets, and circular dependencies in one pass.
Delivers native macOS notifications when Claude Code or other AI coding agents complete tasks or need input. Monitor work from the macOS menu bar.
Control Claude Code, Codex, Gemini, and shell sessions from your phone or browser over Tailscale. Self-hosted with no cloud dependency.
Decides whether a coding task should loop, then generates a bounded execution contract. Prevents runaway loops and provides a safety gate before long autonomous runs.
A terminal multiplexer and browser-based control center for OpenCode, Claude Code, Antigravity, and Pi Coder. Centralizes AI coding agent sessions in one interface.
Streaming, tool use, permissions, sessions, and prev_hash audit chain. Swap DeepSeek for Ollama for whatever model comes next — no cloud, no telemetry.
Automatically detects new Claude Code releases and sends notifications to Slack. Keeps teams updated on Claude Code updates without manual monitoring.
System tray app that runs Claude Code under multiple isolated accounts without logging out and back in. Works across operating systems.
Claude Code agents research, write, edit, and fact-check a weekly journal autonomously. A real-world example of multi-agent content production pipelines.
Spin up named agents on an org chart with a shared backlog, let them hand off work and ping your phone only when a human must decide. MIT licensed, self-hosted.
Reads JSONL logs from Claude Code, Codex, pi, and opencode; prices from the LiteLLM catalog; auto-refresh built in. One file, zero dependencies.
Bridges an existing interactive Claude Code session to Telegram, enabling remote control and monitoring from a phone or any Telegram client.
Runs real Claude Code and Codex sessions on your own server, driven from your phone with a native chat UI, voice, files, skills, and always-on availability.
Stores every tool call, file edit, and thinking block verbatim on your machine. Persistent memory without tokens — the full, unabbreviated record of what Claude Code did.
Tracks usage limits for Claude Code, Codex, and other AI coding subscriptions across Linux, macOS, and Windows via both terminal and system tray.
launchd-managed Claude Code/Codex fleets with git-worktree isolation, Slack reporting, safety gates, and reproducible setup. A self-contained agent operating system for individuals.
Local-first, zero-config dashboard tracking usage for Claude Code, Codex, Cursor, Gemini, Kiro, and 20+ more tools. Includes macOS menu bar app and desktop widgets.
Turns named tmux sessions into a browser-driven control panel reachable from anywhere via Tailscale. Sessions keep running without a browser attached, with chat UI, push notifications, and phone support.
Write one agent definition and run it through either Claude Code or Codex, retaining skills, custom subagents, workflows, sessions, and goals across both harnesses.
Watches agent transcript files, extracts claims using deterministic regex, and cross-references them against tool calls, shell output, filesystem, and git. Flags when agent words do not match evidence — no LLM, fully local, macOS menu bar app.
Three full-screen overlays for the kitty terminal: review (two-pane diff with line-comment feedback loop), session (jump between all Claude Code sessions with live status), and log (git history browser). Pure Python stdlib.
Compresses tool output, logs, and prose, removes duplicate output, strips ANSI sequences, and supports multiple optimization modes. Community reports 40-60% reduction in conversation sizes.
Automatically hands off sessions when approaching context limits for Claude Code and Codex CLI. Keeps long-running agent tasks alive without manual intervention.
Traces API calls from Claude Code, Codex CLI, Gemini CLI, Cursor CLI, OpenCode, and others in a local trace viewer. Essential for debugging agent behaviors and auditing model calls.
Blocks only net-new findings and gives the loop a structural map of the codebase, locally with no model in the gate. Provides principled stopping conditions for autonomous agent loops.
Replay what a Claude Code session actually did as a TUI timeline, backed by a replayable JSONL audit trail. Provides complete session replay and verification capabilities.
Shared brain, a Conductor that routes each task to the best model, and one session history across desktop, terminal, and CLI. Local-first, Apache-2.0 licensed.
Adapts exploration, subagents, scope, and validation to available usage signals, context pressure, and task size. Complements usage monitors to keep Claude Code sessions productive.
The model sees its own 5h/7d quota and context budget every turn, economizes under pressure, checkpoints durably, and never loses subagent work to a usage-limit cutoff.
Reduces token consumption for Claude Code, Codex, Gemini CLI, and more with surgical read hints, PDF/Office/CSV/markdown file interception, 160+ filter rules, compact manifest injection, and image shrinking.
Dissect why Claude Code looped, drifted, or burned tokens — zero instrumentation needed, fully local-first. Like a black box for your AI coding sessions.
Config-driven statusline for Claude Code built as a single static Go binary with zero dependencies. Highly configurable and fast for terminal workflows.
Surgical, git-free review of Claude Code changes directly in the terminal, VS Code, and JetBrains. Includes live dashboards: a Timeline change feed and edit/token stats with plan-usage bars, at zero extra tokens.
Runs Claude Code or another coding agent inside a disposable microVM (via firecracker or similar), with all changes committed to git so you can review everything from your host. Provides true isolation for autonomous coding tasks.
Watch every step of a Claude Code, Codex, or Gemini agent live, then rewind, fork, and replay any run. Provides complete observability into agent execution history for debugging and auditing.
artgraph links requirements, documentation, code, and tests in a single deterministic graph, giving AI coding agents structured context when translating specs to code. Aims to eliminate the guesswork of what files are relevant at each coding step. Useful for larger codebases where context relevance is hard to maintain.
Clampdown confines AI coding agents inside secure containers that limit filesystem access and control network communication, reducing blast radius of agent mistakes. Designed for running Claude Code and similar agents in isolated environments without risking host system exposure. A practical security layer for teams running agents on sensitive codebases.
A local web dashboard that runs multiple Claude Code sessions simultaneously, each backed by a persistent tmux terminal that survives browser refreshes and disconnects. Sessions are managed centrally and can be monitored from a single UI. Ideal for running independent workstreams on the same machine without context switching.
Official announcement: Claude Code's desktop app gained a sandboxed in-app browser that lets Claude pull up docs, designs, or any external site, then read, click through, and interact with it the same way it does with a local build. Sessions are configurable for persistence. Update to the latest desktop app to enable.
A corporate LLM gateway that sits between developer Claude Code instances and Anthropic/OpenAI APIs, sanitizing outbound traffic before it crosses the corporate boundary. Addresses data leakage, PII scrubbing, and policy enforcement for enterprise deployments.
A transparent Anthropic/OpenAI proxy that compresses AI agent context (system prompt, tool docs, tool output, history) by rendering it to pixels before sending. Achieves ~39% fewer input tokens on real runs while keeping tool calls and multi-turn interactions fully intact.
A multi-agent coordination system where agents form a pod, create missions, claim tasks, and work together autonomously. Agents negotiate work division in shared habitats and report results back to the group.
A Linux-native workspace environment for AI coding agents featuring Ghostty terminal integration, git worktree management, local MCP/socket automation, team orchestration, and prompt-aware notifications. Designed to reduce friction in multi-agent local development.
A comprehensive framework from UiPath for evaluating AI coding agents and their skills. Features sandboxed execution for reproducibility and data-driven analysis to compare agent performance across tasks and skill configurations.
A CLI workspace context manager for AI coding agents that lets you name Claude Code sessions and resume them with a single keypress. Carries context across sessions to maintain continuity on long-running projects.
Meshwire is a Claude Code plugin enabling AI agents on different machines to communicate and divide work using the A2A protocol. Claude Code on Linux, ChatGPT on Mac, and Copilot on Windows can all exchange messages and tasks in real time. Install via `/plugin marketplace add husker/meshwire` in Claude Code.
Comate is a desktop AI workspace that brings Claude Code into a polished, native app experience. Organize multiple projects in folder-backed workspaces, chat with AI through streaming sessions, exp...
Explore Claude Code CLI source code for learning, analysis, and TypeScript Bun CLI tool design
Harness-agnostic toolkit for AI coding agents: detect the harness (Claude, Codex, Cursor, Cline, Gemini, Aider...) and run a pure policy core. One Bun-native package.
VS Code extension for spec-driven development — manage specs, workflows, and steering docs for AI CLI tools (Claude Code, Gemini CLI, Copilot CLI)
Persistent checkpoint system for Claude Code projects
I'm an ML Engineer/Data Scientist. My main job these days is building Agentic AI system, but I'm also into Kaggle competition and sometimes do freelance ML work. I began using Claude Code back in l...
I’m a senior MLOps engineer at a fortune 100 company. I’ve never got the fear that AI can replace my job, simply cause the work is not simple enough to be done entirely by a so called “AI Agent”. D...
Self-improving, self-hosted memory across every AI coding tool, project, and team (Claude Code, Cursor, Copilot, any MCP client). Autoskill proposes new skills from your sessions, so each project i...
Stacklit: AI Codebase Indexing 2026 – Zero-Setup Local Repo Mapping for Agents
19 specialist Claude Code sub-agents for AI-assisted development — model-tiered, least-privilege tools, composable plugin groups, persist-block protocol.
The craft of agent swarms — a vendor-neutral, multi-project Claude Code agent framework (plugin marketplace): one shared core + opt-in domain packs.
Disclosure: I'm the author of RDXmin. It's MIT-licensed, open source, free to use, and intended for people who use Claude Code regularly. After profiling Claude Code sessions, I found that prompt e...
Forge your Claude Code projects — pass them through, they come out faster.
A high-performance desktop application for managing skills across multiple AI coding assistants. Seamlessly organize, sync, and share skills for Claude Code、Codex、Opencode and other AI tools. Built...
Battery-first macOS menu bar app that keeps a MacBook awake with the lid closed while Claude Code or OpenAI Codex is actively working.
Apply framework-agnostic coding standards to your Roblox projects for cleaner, secure, and efficient Luau scripts.
Specialized Claude Code subagents for enterprise C# and TypeScript development, with persistent project memory and orchestration rules.
What it is: A desktop agent + mobile app that connects to your Claude Code session so you can view and interact with it from your phone — full terminal access, live preview of file/build changes, p...
Nimbalyst - The open-source visual workspace for Claude Code, Codex, and OpenCode. Run multiple coding agents in parallel, edit their work visually in markdown, mockups, and diagrams, and track tas...
hi r/ClaudeCode , the pain most of you already know: claude is brilliant per-file and then the project quietly drifts. you say one sentence, it makes ten thousand decisions you never saw, 100k line...
Linlin's curated AI agent harness configuration: workflow rules, skills, hooks, plugin recommendations, tooling preferences, and project templates. Loadable into any new project so a fresh /init ca...
Deploy a proxy that converts Claude.ai sessions into a standard Anthropic API with streaming, tools, and image support.
Terminal scrollback is the wrong place to keep Claude Code sessions — it loses long runs, and the JSONL on disk has the full history. So I built Agent Sessions, a local macOS app that reads that hi...
Octowiz gives Claude Code agents memory-backed engineering doctrine — cached by role, refreshed by project state, and routed through planning, TDD, review, and QA workflows.
Bridge WeChat and Claude Code with an Electron desktop app for chat, image input, QR login, and session control
We've all seen (and some of us have posted) posts over the past month or so about "I wasn't even doing anything wrong and I got banned!" with no data to back it up. A half-glass of tequila and a br...
🔒 Enhance your development skills with the latest OWASP security best practices for building secure applications in Claude Code.
Build production-ready SaaS apps with Claude Code and Tezgah, covering auth, payments, email, compliance, testing, analytics, and deployment
Build a tiny Claude Code clone in Python with agent loop, tools, permissions, and context management in ~800 lines
Explore Claude Code source code to learn how Anthropic’s CLI harness works, from tools and permissions to context and streaming
Learn Claude Code patterns to assess, improve, and apply production-grade LLM engineering practices in your codebase
Publish AI-generated HTML decks, collect comments, and pull feedback back into Claude Code, Codex, OpenClaw, Hermes, or CI.
Claude Code plugin marketplace — macOS tool integrations (Apple Notes, OmniFocus, Things, Safari, Calendar, Music, Johnny Decimal)
Sync and back up your Claude Code memory across machines through a private GitHub repo (desktop app + CLI)
Self-hosted agentic OS — connects Claude Code, Codex or Hermes Agent to Discord, Telegram, WhatsApp, Slack & Email. EU AI Act 2026 & GDPR compliance by architecture.
Claude Code chat tool window for Visual Studio 2026
Monorepo for mattbutlerengineering.com — design system, React apps, Fastify services, Pulumi IaC. Built largely by AI agents (Claude Code).
A CLI tool that indexes and searches the conversation history already stored on your machine from coding agents like Claude Code. Lets you find past solutions, decisions, and code snippets without re-asking the AI. A practical productivity tool for developers who accumulate substantial session history.
Adds voice-first input to Claude Code and Cowork via real-time speech-to-text in 2026. Allows developers to dictate prompts, instructions, and code descriptions instead of typing. Integrates directly with Claude Code's workflow for a hands-free coding experience.
Build modular project blueprints for Claude Code, Obsidian, and Figma teams from solo MVPs to multi-agent systems
Build pragmatic Go apps with an idiomatic, flat project layout guide for clean code, clear flow, and maintainable APIs
The most autonomous agent framework. No approval loops. No babysitting. Configure once, forget forever.
OpenClaw alternative with strict container isolation for security measures. Connects to WhatsApp, has memory, scheduled jobs, and runs directly on Anthropic's Agents SDK
TLDR: This tool isn't trying to replace Claude Code. it runs on Claude Code. It orchestrates multiple mac machines and automates the SDLC around working with Claude Code: file a ticket, and it take...
Hi 🙂 I am building a system for my personal use that lets me create GitHub Issues, label them, and start agents on them based on their labels. It is important to note that I am not using the GitHub...
Every day I work on my work laptop and personal one, than I switch to desktop at home. But to sync project in between I need to do few stesp every time, git pull, copy env, and I loose all my testi...
System-wide now-playing control for macOS from Claude Code — zero dependencies, no OAuth, any app (Spotify, Apple Music, browsers)
Multi-agent VTuber + autonomous worker platform — pair a chatty Live2D/Spine VTuber with tool-running sub-workers, orchestrate autonomous tasks, and watch it all in a 3D city playground. 5 swappabl...
CLI to move, transfer, and sync Claude Code project state across paths, archives, and remote storage.
Ultrademo is an automated demo video generator for any websites, SaaS applications, etc. - executed conveniently through a Claude Code skill.
Claude Code skills for bug bounty hunting and security-auditing web apps you own — recon, scope, report, triage, self-audit. Judgment, not tool wrappers.
Local-first governance kernel for AI coding agents — shared memory, rule distribution, approval inbox, episodic recall, MCP tools, hooks. npm: @mamdouh-aboammar/agent-kernel
I wish Anthropic would add the missing thread tools and remote control to the desktop app, so that my workflows can be streamlined and I don't have to spend my time manually managing Claude Code th...
Start, stop, and duplicate dev projects with one click. The best workspace for running Claude Code, Codex, and other AI agents alongside your services.
A multi-agent Claude Code framework for running role-based agents across GTM, product, design, and ops — with plans, project substrate, and a reinforcement loop that compounds learning.
If you want to make high quality animations I suggest you use fable to build an animation engine as well as some skills to launch the engine. I just ran /logo-reveal on Opus in one of my projects a...
Adversarial spec refinement between AI agents: Claude Code drafts a plan, Codex critiques it in a read-only sandbox, and the loop revises or rebuts until the critic approves — fully unattended, dri...
I use Claude Code in an "architect" setup: the main session never writes application code itself. It forges goals with hard, machine-checkable criteria, dispatches coder subagents with self-contain...
I hate the claude's own remote control app which is buggy and can't start sessions from any folder I want. Instead what if I could use mac terminal directly from my iPhone so I can be claude code f...
Long contexts, repeated prompts, large tool outputs, MCP tool catalogs, and oversized RAG payloads appear to dominate token consumption. The opportunities are no longer at the model level, but at t...
Discover CLAUDE.md best practices for project-specific AI coding guidance, with ready-to-use templates for languages, frameworks, and real-world cases
Store Claude Code memory in files for persistent context across sessions, projects, and devices without a database or cloud
A curated collection of AI-powered skills, agents, prompts, and workflows for Android, iOS, Flutter, React Native, Unity, and Unreal developers. Build faster, debug smarter, review code, optimize p...
I have been working with Claude for a while now and have developed a few applications, two of which are in production. We now have an opportunity to work on a product for a client. I am confident t...
Boost Claude Code with Java plugins for Java 8–21 projects, including core, Spring, and quality checks tailored to your target version
Build coding agents with a clean-room harness for streaming loops, tool control, session save, secure creds, and layered config
Provides tools to streamline computational chemistry and drug discovery workflows using Claude Code integration.
Real-time token, cost, and AI limits widget with multi-device sync for Claude Code, Codex, OpenCode, Hermes, OpenClaw, Cursor, Antigravity and more. | 为 AI Tools 打造的即时Token、成本与限额监控桌面组件，支持多设备同步
A native desktop client for free access to Claude Mythos AI across Windows, macOS, and Linux.
Optimize Claude Code workflows for long-term physics and mathematics research projects with structured toolkits and practical guidance.
~/.claude/projects fills up with JSONL files fast, and finding "that conversation from Tuesday" across workspaces meant grepping. I built showagent: a terminal picker over every agent session on yo...
💼 The portable memory layer for AI coding tools — one shared brain that follows you across Claude Code, Cursor, Windsurf & Conductor. Install once, never re-explain your project again.
An open-source job-search operating system for Claude Code: sourcing, applying, prep, debrief — with a corpus that compounds.
A TUI toolkit designed for Claude Code that lets you spawn interactive terminal interfaces for emails, calendars, and other integrations. Enables rich in-terminal UI without leaving the Claude Code environment.
ccp compresses Claude Code command output to reduce context usage. v0.5.1 adds a YAML-based filter system with layered overrides for repo-specific rules, team defaults, and domain-specific filters (e.g. logs). Built with 200+ sample cases for validation.
An automated GitHub Actions mirror that tracks new Claude Code releases, verifies SHA256 checksums, and publishes verified offline installers as GitHub Releases. Useful for air-gapped environments or reliable offline installation.
A Mac terminal app built for Claude Code multi-agent workflows. Features tabbed Gems (projects), isolated git-worktree-backed Shards for parallel agents, and Formations for saving/restoring session collections. Includes a screen-edge dock for monitoring agent age and status.
A Claude Code status line that parses transcript files incrementally to surface information stdin alone can't provide: pending permission requests, tool calls in-flight, file change summaries. Renders in under 20ms and complements existing usage/cost indicators.
A Claude Code plugin that extracts frames from video files, making them available for visual analysis and UI debugging. Useful for video-to-code workflows and debugging visual regressions.
A usage status line for Claude Code that installs with a single /plugin install command — no npm, curl, or jq needed. Shows rate limit, session usage, and plan info directly in the terminal status line with minimal friction setup.
A local proxy that makes MCP token overhead visible (like Chrome DevTools for MCP) and enables selective loading of only the tools needed for each request. Addresses the problem of MCP tool definitions consuming 30-40% of context before any real work starts.
A VS Code extension that gives you a kanban-style board for all running Claude Code agent sessions. One-click create/resume/rename, status indicators (thinking/idle/crashed), and grouped task management for the chaos of running many parallel agents.
A CLI and TUI tool for managing Claude Code sessions with tagging, search, and resume capabilities. Makes it easy to find and continue past sessions without losing context.
A memory system for AI agents that goes beyond storage: includes safety guardrails, circuit-breakers, semantic adapters, and drift protection. Built-in safety features make it suitable for running agents autonomously.
A client/server script that enables Claude Code voice dictation (/voice) over SSH connections. Solves the problem of losing voice input when running Claude Code in isolated remote environments.
A Claude Code plugin that adds task management with a visual kanban dashboard. Lets agents create, track, and update tasks during long sessions, providing structure for multi-step projects.
An open-source system that runs company operations through Claude Code agents, addressing the problem of company knowledge scattered in Slack and heads. Multi-agent coordination across AssemblyAI, Anthropic, and other APIs. MIT license, no paid tiers.
One command syncs MCP server configurations from Claude Code to Gemini CLI, Codex CLI, OpenCode, Kiro, and Cursor. Keeps all your coding agents in sync without manual duplication.
A tool-orchestrated penetration testing framework for Claude Code combining DAST, SAST, and SCA in a hardened Docker container. Automates security testing workflows with Claude Code as the orchestrator.
A local code indexer that understands natural-language queries across multiple repos. BM25F search with symbol extraction for Dart, Python, JS, Shell — incremental delta updates (~200ms) and optional Haiku reranking. Reduces exploratory grep spirals that burn context.
Builds a persistent local knowledge graph of your codebase so Claude reads only relevant files during reviews. Claims 6.8x fewer tokens on code reviews and up to 49x on daily coding tasks by eliminating blind file exploration.
Connects Claude Code, GitHub, and Linear.app so Linear tickets become remote control commands for Claude Code sessions. Create a ticket with instructions, and Claude picks it up and executes — bridging project management with AI coding agents.
A local-first memory system that captures lessons and recalls them in your IDE, with project health tracking. Stores what worked, what failed, and why — reducing repeated mistakes across sessions.
Long-term memory for AI coding assistants built as a Rust CLI with semantic search capabilities and Agent Skill integration. Runs locally with no cloud dependency.
An open-source memory layer that automatically saves and recalls context using Claude Code hooks — no manual saves or MCP config. SessionStart loads profile, every prompt searches past sessions for relevant context, PostToolUse extracts and saves new knowledge in background.
A local dashboard that unifies AI session analytics from 16 different editors including Claude Code, showing models used, costs, tools, and usage metrics in one place. Ingests OpenTelemetry data.
A local open-source dashboard providing session insights for Claude Code and UI-based configuration management for agents, skills, and hooks. Eliminates the need to constantly check the developer platform for usage info.
Automatically bridges your local Claude Code setup into Codex so both agents stay equally effective. Syncs configuration, settings, and patterns between the two tools without manual duplication.
An iOS app that connects to your machine via SSH and presents Claude Code's native terminal interface with mobile-specific optimizations. Unlike mobile terminal apps, preserves the full TUI experience while adding mobile-friendly input handling.
Manages persistent tmux workspaces tailored for terminal-native coding agents like Claude Code. Keeps session layout, pane configurations, and working directories intact across agent restarts.
A Claude Code status line with 10 built-in themes (Dracula, Catppuccin, Nord, Tokyo Night, Gruvbox, etc.) and per-segment toggle via TOML config. Shows model, plan, context window, 5h/7d usage limits, session cost, working directory, and git branch with auto plan detection.
A lightweight CLI issue tracker built specifically for AI agent workflows, enabling agents to create, update, and track issues as part of their work loop. Provides structured task persistence across sessions.
A native macOS menu bar app that monitors Claude Pro/Max session and weekly usage in real-time. Keeps usage visible without interrupting workflow or requiring switching to the terminal.
A UI tool for managing and switching between multiple Claude Code environment configurations — different API settings, permission modes, token usage monitoring — in one click.
A tool born from needing realistic relational test databases for apps built with Claude Code — Claude works for small datasets but struggles with larger datasets that maintain foreign key integrity. Automates production of consistent multi-table test data.
Control Claude Code from your phone via Discord with full session mirroring, bidirectional messaging, and permission approval — all from mobile. Alternative to the built-in Channels feature with richer session control.
A process manager designed for AI agent workflows, managing long-running agent processes with restart policies, logging, and coordination between human and agent tasks.
A pure-bash statusline tool that persistently displays the current `claude --resume SESSION_ID` at the bottom of every Claude Code session. Logs all sessions to ~/.claude/session-log.txt so past sessions are always recoverable. One-command install, no dependencies, MIT licensed.
RuntimeUse solves the infrastructure challenge of deploying Claude Code agents in isolated cloud sandboxes (E2B, Modal, Vercel, Daytona, etc.) for production use. Run `npx -y runtimeuse@latest --agent claude` inside a sandbox to get a Claude Code agent with a Python client for task invocation, file exchange, and mid-flight cancellation. Open-sourced from building Lark, an AI-native QA system.
A GitHub repository that tracks the internal prompts, feature flags, and release metadata of Claude Code over time. Useful for developers and researchers who want to monitor changes in Claude Code's behavior, capabilities, and configuration across versions.
NorcsiAgent is a real-time dashboard showing what AI agents are doing, with animated cards for each agent displaying current thoughts, tool calls, and completions. Built using Claude CLI, it supports sending commands to individual agents while they run concurrently. A practical monitoring tool for multi-agent workflows.
Temine is a terminal UI for managing and organizing multiple AI agent CLI sessions simultaneously. Provides real-time status, notifications, and process control for parallel agent execution from a single terminal window. Useful for developers running concurrent Claude Code or other CLI agent sessions.
Codeset provides Claude Code agents with structured repo context — file change history, inter-file dependencies, and implicit project knowledge — surfaced at session start. This context reportedly brings Haiku up to Opus-level output on coding tasks. Addresses the cold-start problem where agents begin sessions with no knowledge of the codebase.
Domscribe is a build-time dev tool that maps every DOM element to its exact source file and line number, giving Claude Code precise targets for frontend edits. Eliminates the file searching and guessing Claude normally does for UI fixes. Particularly valuable for complex component hierarchies where DOM-to-source mapping is not obvious.
An npm package that spins up an isolated Docker container and launches Claude Code inside it with --dangerously-skip-permissions, so the powerful no-prompt mode is safe to use without manual container setup. File system changes stay contained to the project directory. Install globally with npm install -g dangerously.
A multi-agent terminal manager for Claude Code that lets you run parallel AI agents side-by-side with a structured architecture designed for self-improvement. Includes a battle-tested organizational blueprint for coordinating agent teams directly from the terminal.
Patchcord solves the coordination bottleneck in multi-agent Claude Code workflows: a persistent inbox shown in the status line, automatic inbox checks each conversation turn, one-click skill setup from a web UI, and /loop 5m integration for unattended remote runs. Agents can message each other directly instead of routing everything through a human. Built entirely with Claude Code; open source at github.com/ppravdin/patchcord and available as a hosted service at patchcord.dev.
A complete setup for reducing Claude Code API costs combining several tools: opusplan for planning with Opus before switching to cheaper models, claudetop for session monitoring, gstack for automation, GitNexus for GitHub intelligence, Handy for voice-to-text, and GitHub Copilot integration. Practical toolkit for API billing users.
claw-recall stores and indexes AI agent conversations so they can be searched and retrieved to recover lost context. Works in multi-agent workflows where context frequently resets. Provides a searchable conversation archive that agents can query to resume prior work.
A Discord Rich Presence client that displays your current Claude Code activity — active file, project name, and session state — directly in your Discord profile status. Lightweight integration for developers who want to share or log their Claude Code session context in Discord.
A tool for finding and recovering data and code files from Claude Code sessions — both humans and Claude itself can use it to pick up where a previous session left off. Useful when a session ends unexpectedly or when you need to trace what was generated in a prior run.
LAP (Live API Protocol) provides compiled, versioned API specs that prevent Claude agents from hallucinating endpoints or parameters. The update adds automatic staleness detection on session start, a diff command showing exactly what changed, and a pin command to freeze specs. Addresses one of the most common sources of agent errors in API-heavy projects.
ccoverage compares your Claude Code config (CLAUDE.md files, skills, MCP servers, hooks) against your actual session histories to show which parts are actively used vs. just adding noise. Helps clean up accumulated configuration bloat and understand what is genuinely helping. Great for optimizing token usage.
beacon is a CLI tool that monitors CI/CD deploy status after a git push and sends Telegram notifications when deployments complete or fail. Lets you step away after pushing without manually polling your CI dashboard. Simple and lightweight notification layer for deployment workflows.
rdf is a governance-driven AI development framework that adds convention enforcement, quality gates, and domain expertise plugins to Claude Code, Gemini CLI, and Codex. Helps teams enforce coding standards and quality rules automatically during AI-assisted development. Uses a rule-based approach to keep AI output consistent with team norms.
Plamen is an autonomous Web3 security audit agent built for Claude Code that automatically scans smart contracts and blockchain code for vulnerabilities. Useful for Solidity developers who want automated security review in their Claude Code workflow.
A local knowledge base crawler that catalogs all dev projects in your ~/dev/ folder with AI-generated summaries. Helps find the right version of a project or feature across dozens of accumulated experiments and iterations. Also supports local LLMs for offline/private environments.
hipocampus is a drop-in memory harness for AI agents featuring 3-tier memory architecture, a compaction tree, and hybrid search. Set up with one command and works with Claude Code and OpenClaw. Addresses the lack of built-in persistent memory by providing a structured memory layer.
Claude-Debussy is a Python wrapper for multi-phase Claude CLI sessions with compliance verification, state persistence between phases, and real-time streaming output. Useful for complex workflows that require multiple sequential Claude invocations with shared state. Provides structured orchestration over raw CLI calls.
Node9 is a local-first open-source proxy that acts as a deterministic permission layer for Claude Code agents. Instead of approving every ls and grep, you define what commands are safe vs. risky, and Node9 enforces those rules automatically. Reduces verification fatigue while still blocking destructive commands.
MiniClaw is an open-source cognitive architecture layer on top of OpenClaw that adds persistent memory, an autonomous task brain, and the ability to file its own GitHub issues when it finds problems. Addresses the stateless agent problem where context resets every session. Gives agents continuity across sessions.
Flavian is a Claude Code-integrated WordPress development framework with Full Site Editing (FSE) block theme tools, automated security auditing, and Figma-to-WordPress conversion pipelines. Designed for WordPress developers who want to use Claude Code for theme development with proper conventions and tooling.
sift is a CLI tool that groups repeated test failures by root cause before passing them to an AI agent. Instead of paying for the same error 125 times across failing tests, the agent sees each unique failure once. Reduces debugging cost by up to 60% and speeds up the fix loop.
upstream-agents provides isolated sandbox environments connected to your GitHub repositories for running AI coding agents. Keeps agent-generated code changes contained until review. Good for teams wanting safer autonomous coding without risk of direct repo pollution.
Edgee is a proxy that sits between Claude Code and the Anthropic API, compressing context by stripping redundant instructions and deduplicating conversation before forwarding. Reported to extend Pro sessions by 26.5%. Built with Claude Code itself, it operates transparently without changing Claude behavior.
baton-dx is a CLI package manager for AI coding tool configuration — write one manifest and it syncs your settings, rules, and skills across 14 tools including Claude Code, Cursor, Codex, and more. Eliminates duplicating configuration between different AI coding environments. Great for teams maintaining consistent AI tooling setups.
Describes itself as the Terraform for AI agents — define your agent team configuration once and deploy it to Claude Code plus six other platforms. Treats multi-agent setups as infrastructure-as-code with a single declarative manifest. Useful for teams standardizing agent definitions across environments.
A demo project showing how Claude Code agents can autonomously build a documentation compiler without human intervention. The project tracks the full live build process and showcases fully automated remote agent experiments. Useful reference for anyone building CI/CD pipelines around Claude Code.
A GUI tool to organize all your Claude Code memories, skills, MCP servers, and hooks in one place. Displays items in a scope hierarchy view and lets you move them between scopes via drag-and-drop. Addresses the pain of manually managing scattered Claude Code configuration across project, user, and global scopes.
Converts product briefs into Stitch UI screens, variants, Tailwind-friendly HTML, and screenshots. Works across Claude Code, Codex, OpenClaw, GitHub Copilot, and Gemini CLI. Useful for teams that want to rapidly prototype UIs from written specifications using AI agents.
A GitHub App that reviews CLAUDE.md files and posts a score as a PR check. Built with Claude Code, it evaluates files for missing scope boundaries and other common failures. Most CLAUDE.md files fail two checks: no explicit scope limits and no rollback instructions. The repo includes the scoring standard.
A custom reverse-proxy API gateway specifically for Anthropic models, built to pool traffic from Cursor and Claude Code CLI. Targets the large context window costs of Opus and Sonnet by batching and routing requests efficiently. Includes setup details for self-hosting the proxy.
An in-development dashboard for tracking Claude Code usage metrics via OpenTelemetry. The plan: connect OTel from Claude Code, visualize session stats, token usage, and task patterns in a polished UI. Looking for early feedback on the feature set. Interesting for teams wanting usage insights beyond what the CLI provides.
An experiment in competitive agent behavior: AI agents register, pick a fighting discipline, and compete in an MMA arena with real social consequences. Built with Claude Code. An interesting case study in multi-agent competitive environments and emergent agent strategies.
A personal AI assistant gateway powered by Claude Code supporting Discord, Telegram, and a TUI interface. Features multi-agent support, session management, tool approval flows, and a memory system. A self-hostable alternative to commercial AI chat products with full agent capabilities.
The definitive Claude Code + tmux/cmux integration. Adds status pills, progress bars, sidebar logs, desktop notifications, git integration, and subagent tracking to your terminal. A polished upgrade for developers running Claude Code sessions in multiplexed terminals.
Loci provides Claude Code with a persistent memory layer modeled after a "memory palace" — spatial, identity-aware, and multi-project aware. Goes beyond simple memory storage to support distinct AI identities and coordinated orchestration across projects.
A multi-provider model routing proxy for Claude Code that routes agent roles — planning, coding, research — to different LLM providers. Supports automatic fallback, SSE streaming, and zero-config setup via `npx modelweaver init`. Useful for cost optimization and mixing model strengths.
A non-developer operations manager built a production ERP integration tool covering 4 countries in 17 days: 9,500 lines of Python/FastAPI, 61 modules, 43 API endpoints, and 7 cross-system document transfer pipelines — all for ~$400 in Claude Code costs. A compelling real-world case study for the value of AI-assisted development.
A code intelligence and RAG system for AI agents featuring semantic search, call graphs, impact analysis, type dependency mapping, and smart context assembly. Achieves 90.9% Recall@1 and 0.951 NDCG@10 with local ML and optional GPU acceleration. Addresses the problem of agents reading whole files just to find one function.
Membase is an external memory layer that persists context across Claude sessions and other AI tools. Addresses the common pain point of losing all session context when a conversation ends. Works as a cross-tool "external brain" rather than being tied to a single assistant.
A data loss prevention proxy that intercepts outbound requests from AI coding tools (Claude Code, Cursor, Copilot) and scans them for secrets, PII, and proprietary data before they reach AI providers. Acts as a security layer between developer machines and AI APIs. Critical for teams with compliance requirements.
Queries 12 AI models (Gemini, Codex, Claude, Mistral, Ollama, etc.) in parallel as "consultants" with unique personas. Features confidence scoring, multi-agent debate, weighted synthesis, and preset configurations. The self-exclusion feature prevents the hosting model from also being a consultant. Compatible with agentskills.io.
A cross-platform Python tool that automatically responds to confirmation prompts from Claude Code, Cursor Agent, Gemini, Codex, and 10+ other AI CLIs via a PTY proxy. Zero dependencies. Prevents overnight AI agent loops from blocking on a single "y/n" prompt.
A CLI utility that shows which localhost ports are occupied by AI agent dev servers, distinguishing between Docker containers, npm dev servers, and orphaned processes. Solves the frustration of port conflicts when running multiple Claude Code instances simultaneously.
A small web app that connects Claude Code builders globally, letting them share what they're currently building in real time. Built in a few hours using Claude Code itself. Addresses the isolation of solo vibe-coding by creating a lightweight social layer around it.
An AI-native static site generator with a built-in MCP server and Claude Code integration, powered by sub-second Rust builds. Designed so Claude Code can generate, preview, and deploy site content natively through MCP tools. An interesting alternative to post-hoc AI integration with existing SSGs.
An open source MCP-based bridge giving Claude full, persistent access to your code editor state — open files, selections, cursor positions, and diagnostics. Eliminates "contextual cliffs" where Claude loses awareness of what you're looking at. Built with Claude Code for Claude Code workflows.
Anima models AI memory after biological neural plasticity — memories are reinforced when they keep mattering and decay over time when they don't. Rather than storing everything equally, it builds a selective, evolving memory that mirrors how humans actually remember. An experimental approach to long-term AI context.
A next-generation AI memory layer with importance scoring, temporal decay, hierarchical memory organization, and YMYL (Your Money or Your Life) prioritization for high-stakes information. Goes beyond simple persistent memory to simulate how relevant different memories should be over time.
A tool that converts any existing repository into a structured, agent-readable workspace with governance controls. Sets up the scaffolding for AI coding agents to navigate, understand, and modify a codebase within defined boundaries. A lightweight alternative to full custom agent infrastructure.
An interactive portfolio template that looks and feels like the Claude Code terminal. Loads personal data from a JSON Resume and deploys as a static site. A creative use of the Claude Code aesthetic for developer portfolios.
A Vim plugin that integrates the Claude CLI directly into Vim, enabling AI-powered coding workflows without leaving the editor. Useful for developers committed to Vim who want Claude Code capabilities without switching to a different editor.
An open-source desktop app that wraps Claude Code with a worktree manager. Features include run/setup scripts, complete worktree isolation, git diff and operations, and "Connections" — a feature that lets you link repositories in a virtual folder that the agent sees as one. Targets developers running complex multi-repo workflows.
A memory-enhanced agent system providing persistent context across Claude Code sessions and MCP-compatible tools. Stores and retrieves session context intelligently to avoid re-explaining the same background information in every new session.
After watching Claude burn 84K tokens reading an 8,000-line file to find a single function, the author pair-programmed ~22K lines of C with Claude Opus 4.6 to build a tool that addresses this specific inefficiency. A detailed account of the development process and the technical solution.
A pair programmer tool supporting Claude Code, Codex, and Cursor as collaborative coding partners. Enables structured, session-aware pair programming workflows across multiple AI coding tools.
A CLI tool that configures popular AI coding assistants (including Claude Code) using the HolySheep API for streamlined setup. One command to bootstrap configurations across tools, reducing the time spent manually configuring each AI assistant.
A bridge that routes Claude Code API calls through a Cursor subscription, eliminating the need for a separate Anthropic API key. Zero-dependency setup. Useful for developers who already have a Cursor subscription and want to experiment with Claude Code without additional billing.
An interactive Mermaid diagram preview tool for Claude Code. Click nodes or edges in the browser, leave comments, and watch Claude iterate on the diagram in real time. Bridges the gap between Claude's text output and visual diagram feedback loops.
A developer used Claude Code to build a satellite image analysis pipeline modeled on commercial products used by hedge funds. Details the technical approach, model choices, and how Claude Code accelerated development of a complex data pipeline that would normally require specialized GIS expertise.
An engineering command center for terminal-based AI coding agents. Provides a unified control surface for managing, monitoring, and directing Claude Code and other terminal agents from a single interface.
A native macOS menu bar app that acts as an "attention layer" for terminal AI agents. Shows agent activity status, alerts when agents need input, and provides quick controls — all without leaving the current app. Designed for developers who run Claude Code in background terminals.
A lightweight statusline widget for Claude Code that tracks how fast you are burning through your quota and warns if the pace is too high. Written in pure Bash and jq with no external dependencies — drop it into any terminal statusline setup. Helps prevent hitting rate limits mid-session by giving you a real-time consumption pace indicator.
TL;DR: We pointed Claude Code at its own install directory to evaluate it as a compilation target for our TypeScript-to-native compiler. It dispatched 7 subagents. Two refused to extract the system...
I've been using Claude Code full-time for about a year across client projects. Built the whole thing with Claude Code itself, actually - the irony of using Claude to build guardrails for Claude was...
Tmux session manager for Claude Code — manage multiple AI conversations across projects
A set of Claude Code skills to speed up the creation of Dapr applications and run them on Diagrid Catalyst.
Hi everyone, I’m currently using Claude Code to build a geospatial map of my clients in Europe to identify new territory opportunities. I’m on the Max plan (90€/month), but I’ve hit a wall: whether...
I spent a few hours testing each Gemini model with Claude Code Router (both free and paid API keys) and wanted to share the findings since I couldn't find a comprehensive comparison anywhere. Setup...
I'm a heavy Claude user: Code, chat, Cowork, the whole stack. Opus and Sonnet are my daily drivers for pretty much everything, from agentic coding sessions to document work to automation planning. ...
Have been using outlook but IT won't enable Microsoft Graph API access, so I can't connect email to Claude or any AI tool. Got tired of copy-pasting emails, so I built a scanner that reads Outlook ...
I'm not a developer. I've never written a line of code by hand. But I just shipped a production SaaS with 39 database tables, real-time WebSocket connections, Stripe billing, and a multi-portal arc...
I've been studying why Claude Code works so well compared to more structured AI tools — the single loop, bash-as-everything, minimal constraints. Got curious whether the same philosophy could apply...
🛠️ Enhance Claude Code CLI’s refactoring with JetBrains IDEs, leveraging advanced semantic analysis for smarter code usage handling.
Does this happen to you too? Claude hits an error, tries to fix it, same error comes back, tries a slightly different version of the same fix, same error, repeat. By attempt 10 you've lost half an ...
Disclosure: I’m the founder/builder of Packet28 . It’s a free, open-source tool for AI coding agents that reduces noisy tool output into smaller handoff packets so the next step carries less raw co...
I talked to two people in Silicon Valley today. A senior AI engineer at Meta and a startup founder who went through Stanford MBA. They don't know each other. They said almost the exact same thing. ...
Sharing a project I built heavily with Claude Code. PreSale is a free iOS app that generates resale listings from a text description or photo: title, description, category, and a data-driven price ...
Hey everyone! As the title says - in the past two weeks I built a collection of design skill files that are basically like themes used to be with websites, but this time it's instructions for Claud...
I've been building Chronoid for about a year now — a macOS time tracking app that automatically monitors what apps and websites you use throughout the day. I just shipped an MCP server that lets Cl...
Each dot is a claude conversation. After a month this is what CORE has built from my claude code sessions. The reason I built this: every new cc session starts cold. You're re-explaining context yo...
Hey, I just remixed two open-source projects to build something for kids that works with Claude Code . It’s called The Orchestra . A lot of us using Claude Code have kids around who already see us ...
https://preview.redd.it/cm5nhc0ekupg1.jpg?width=1206&format=pjpg&auto=webp&s=f3a1fdf25321da3353b5790e1dfa25e744de0c95 Loaded $25 onto a virtual debit card. Gave it to my AI agent (Claude-based, run...
I built a central logging system designed for Claude. It lets Claude find and fix issues on its own, both in dev and in production. Why I built this You know how it goes - Claude runs into an issue...
I ran a small experiment this week: Same task: → build a simple data pipeline (fetch → process → store) Agents: – different setups (context / memory) – Claude-style vs Codex-style workflows What I ...
I've been building a mobile app (in React Native) that lets you connect to your tmux sessions from your phone over WebRTC, peer-to-peer, end-to-end encrypted, no account required. The kind of niche...
I've been using Claude Desktop for multi-day coding projects, and the biggest pain point was losing all context between sessions. I'd have to re-explain my architecture, what I was working on, and ...
I've been using Claude Code for about a year now, and I made the same mistake for the first few months that I see most people making: treating it like a chat interface that happens to write code. A...
SlideToPDF – Turn photos of projected slides into a clean, perspective-corrected PDF I built a small macOS desktop app to solve a problem I kept running into: you're in a lecture or meeting, you sn...
A desktop app for Claude Code with multi-tab sessions, agent observability, and a built-in browser.
I open-sourced what I built: Free Tool: https://graperoot.dev Github Repo: https://github.com/kunal12203/Codex-CLI-Compact Discord(debugging/feedback): https://discord.gg/xe7Hr5Dx I’ve been using C...
Over the last ~2.5 weeks I built Atoo Studio from a pretty simple pain point: once I started using Claude Code heavily across multiple projects, my workflow turned into terminal + tab chaos. What I...
Anyone else hitting this after updating to 2.1.78? I build skills and agents all day. My entire workflow lives inside .claude/skills/ and .claude/agents/. I run claude --dangerously-skip-permission...
Terminal-based viewer for Claude Code conversation logs. Browse projects, view conversations with vim-style navigation, collapsible thinking blocks, and CJK character support.
Hey everyone, If you're using Claude Code skills (SKILL.md files), you're giving an AI agent access to your shell, file system, and environment variables. I realized nobody was checking whether the...
Once you hit 5+ projects with Claude Code, the component sprawl gets real. Global skills in ~/.claude/ shadow project-level ones with the same name. Agents reference skills that only exist in a dif...
Pro dev of 10+ years. It's important to remember that the outputs of these models are random to a degree. You can give it the same prompt and get different responses each time. I have never noticed...
I feel like I'm pushing the edges of agentic development with Claude Code and agent teams. I'm writing a whole bunch of my own tooling now, and doing things like moving away from pull requests beca...
I have countless projects where i customize ralph loops or encode other multi-step workflows. Building sophisticated ralph loops that don't end up producing AI slop is quite hard. Even for simple f...
Ok, it's a clickbaity title, but it reflects a real and typical personal experience and also a real problem. Claude and the likes of it are improving. The code is often correct, and most of the tim...
I've been developing a unique twist on the N queens / star battle logic puzzle game called Kings vs Queens over the past several weeks, entirely through Claude.ai conversations in the browser. No I...
CLI tool that renders Markdown files in a native frameless macOS window with live reload, syntax highlighting, KaTeX math, and Mermaid diagrams. Designed for terminal-only agents like Claude Code.
Spotify Wrapped for Claude Code. Browser tool — select your ~/.claude folder, no install needed. Stats, archetypes, shareable cards.
Got banned today while building my company's CRM. Am about 75% done with it and $2500 in with claude code. Use the Claude pro plan for basic prompts of the basic write this email better type stuff ...
Your LLM is often lying to you. When you see it calculate a number it is simply predicting the tokens and presenting them as a number, its not actually using a calculator to PROVE that the calculat...
I've been using Claude Code since early 2025. In addition to coding, I began saving all of my chat history with Claude Code, knowing that at some point it will be useful. Recently, I decided to do ...
I've been working on a blog post series about "Software 2.0" about productionizing "vibe coding" into a real engineering discipline. Most of the focus is on shifting developers' roles from specifyi...
I’ve seen this Claude Code diagram pop up a few times, and I spent some time going through it carefully. Sharing how I understand it, in case it helps someone else who’s trying to connect the piece...
What I need: - One source of truth for company context - Works across Claude surfaces (some of them are on desktop app, some using IDE) - Team can read it. Team can’t break it - When someone spots ...
You can ask claude, what is the first sentence of stated above? It will provide, I just asked it the next sentence, and then the next, and then the rest, But it wasn't willing to give the rest, the...
As with many others, I thought I'd check out Claude. With Gemini, "we" tried to create an app that would use the cover screen of my Samsung Fold as a control pad for games. You could assign zones o...
I'd love to know everyone's approach to this - I've seen so much going on online but none of it really aligns with the way I operate across multiple projects and need context that's specific to eac...
I got tired of re-explaining context every time I started a new Claude Code session. The auth architecture decision from last week, the CORS fix from three days ago, your testing library preference...
I built claive — multi-agent orchestrator for Claude Code. One goal → parallel agents, each on its own git branch. One-shot full applications. Open source: https://github.com/ionutz0912/claive subm...
A desktop app that turns Claude Code into a visual Kanban build loop. Describe a feature, review the plan, watch it get built task by task.
As the headline suggests, we all want a Javis, but most builds are fragments of what Jarvis could/should be, so I took it on my own to create something more... There is a lot to it, so this is a sh...
Claude Code tool for analyzing large audio files using Recursive Language Model patterns. Whisper + RLM, no API keys needed.
Coding standards for AI coding assistants. Auto-detect tech stack, generate project rules. Works with Claude Code, Cursor, Antigravity, GitHub Copilot.
Working on this the last week. Fetches jobs api in bulk (JSON file full of jobs) subagent tailors resume, then another sub agent uses playwright MCP to interact with the site. Does one job applicat...
TL;DR: Had a Chrome extension with tens of thousands of users. Google killed it 2 years ago (MV2 > MV3 migration). Rebuilt the entire thing - extension + API + website + QA agent - in 7 days using ...
I got frustrated with memory plugins that log everything and search later. Built one that filters at capture time instead. The idea: Every tool Claude uses gets scored on 5 salience dimensions (Sur...
There was a silent auth error on my newly created full-stack app and CC couldn't find it despite my several attempts for hours. I was stressed and digged around manually a lot as well. Eventually C...
Hey, we’re building a small AI studio focused on helping businesses set up AI infrastructure (knowledge bases, agent systems, workflow automation) while also building our own products. We’re lookin...
🔧 Manage your AI agents easily with Claude Subagent Editor, a web-based tool for editing configuration files using a simple drag-and-drop interface.
Question in the title. This is mostly for my non-dangerously-skip-permissipns brethren. I know I can avoid all of these troubles by using dev containers or docker and bypassing all permission promp...
So I've been using Claude Code for a while and kept running into the same two annoying things: The memory system is great but editing `.md` files in a text editor gets tedious fast, especially when...
Wasn’t sure what to write for a title, but here it goes. I have zero coding skills, so I’m looking for some advice from the pros. I’m convinced that learning how to use tools like Claude will be a ...
Hi, I am a newbie on claude code with a very limited coding. I just started vibe developing a 2-D android game from scratch using Claude code. Tried my best to help claude plan the outcome first, g...
Is it possible to build a full enterprise app vibe coded with Claude code max? My cousin's company is using an agency in London to build a multi platform app. Mobile, desktop. All on Claude code. T...
I have been using Claude Code heavily on an Enterprise plan and got frustrated by: No way to see spending per project or session. Enterprise only gives aggregate numbers. All configs, skills, MCPs,...
One of the most frustrating aspects of AI-assisted coding is the "context cliff." After spending time building context with an AI, you often find yourself re-explaining everything in subsequent ses...
Found a GitHub repo that looked like an open-source B2B growth playbook — turns out it was 562 lines of shallow outlines designed to funnel people into a $200 Telegram consulting call (crypto/wire ...
Disclosure: my goal is to build a commercial product (Saas) from this but there is a free plan. Hey, I'm an IT infra consultant (cloud, k8s, enterprise automation). Started using Claude Code last y...
After abandoning Antigravity I've finally landed on Claude Code for my after hours coding as well. But the Pro subscription runs out pretty fast, and I'm having trouble justifying paying 100$ "just...
A terminal that lets you dock, split, merge, and reshape panes dynamically for managing multiple AI coding agent sessions. Designed around the multi-agent workflow rather than adapted from general terminal tools.
A unified queue for all Claude Code agent sessions showing what is blocked, erroring, or needs attention. Eliminates the chaos of having dozens of terminal windows with no way to track status at a glance.
Remote AI coding via messaging apps with real-time dashboard, heartbeat monitoring, and idle alerts. Lets you start tasks, check progress, and approve actions from your phone without touching the terminal.
Mirrors your Claude Code terminal session to a Discord channel so you can read output, approve tool calls, and send commands from your phone. Solves the problem of starting long tasks and having no way to monitor them remotely.
Implements the Anthropic long-running agent pattern as a single command: scans codebase, plans changes, writes code, validates with tests, then commits. Turn requirements into working committed code end-to-end.
An open-source CRM built with a Context Engine for agent-human GTM coordination. MCP-native with 80+ tools, full CLI, REST API, and web UI. Works with any PostgreSQL database.
Monitor your Claude Code spending and get push notifications on macOS, iOS, and watchOS when you hit thresholds. Built to keep API costs visible across all Apple devices. Useful for anyone running long autonomous sessions.
A platform built entirely with Claude Code that catalogs AI agent skills from Anthropic, Google, Microsoft, and 59 other companies. Includes backend, frontend, CLI, MCP server, and a sync engine that pulls skills automatically.
A Chrome extension that lets you hover over any live webpage element and send it straight to Claude Code. Eliminates the inspect-element-copy-selector-paste-into-AI loop by creating a direct visual bridge.
A multi-agent autonomous software engineering team powered by Claude Code and the A2A protocol. Agents self-heal and self-diagnose, forming a collaborative development team that can iterate on code without human intervention.
An AI assistant that automates Git tasks, simplifies worktree management, and resolves merge conflicts. Manages the full Git workflow so developers can focus on code rather than branch and merge mechanics.
Autonomously orchestrates Claude Code, Codex, Gemini, OpenCode, and more in a multi-session terminal manager. Coordinates multiple AI coding agents across parallel sessions from a single interface.
A terminal UI that turns feature requests into structured multi-agent pipelines: planning pass, implementation, tests, review, and PR — instead of one big blob of changes. Addresses the lack of structure in raw Claude Code sessions.
A tool to watch Claude Code sessions in real time across app, web, and TUI interfaces. Addresses the absence of built-in session visibility — handles JSONL logs with real-time streaming for debugging and research sessions.
A lightweight macOS menu bar app built with Claude Code that shows Claude usage stats without keeping claude.ai open in a browser. Lets you track usage at a glance directly from the system menu bar.
A desktop IDE specifically designed for crafting, validating, and testing Claude API prompts with best-practices linting built in. Integrates with Claude Code via MCP for a seamless prompt development workflow.
A tool to automate evaluation of Claude Code plugin components — ensuring skills, agents, commands, and hooks trigger accurately. Useful for testing and validating plugins before deployment.
A local image analysis pipeline built with Claude Code that converts images to text descriptions (using OCR integration and YOLO detection) before sending to Claude. Significantly reduces token usage when working with visual content.
A local proxy that intercepts and logs all LLM API calls, capturing token counts, costs, prompts, and responses across any language or tool. Zero-config setup that works with Claude Code, Cursor, and any API-based LLM tool.
A production-grade Discord AI assistant powered by Claude Max via the claude -p headless mode. Zero API cost for Claude Max subscribers — runs entirely on your subscription instead of the API.
A cross-platform Agent Control Center for AI coding tools (Claude Code, Codex, Cursor) built with Tauri v2 (Rust + JS). Provides a unified management interface for running and monitoring multiple AI coding agents.
h5i (high-five) is a Rust-based next-generation Git designed for AI-generated code. It tracks AI authorship, provides context-aware diffs, and adds metadata relevant to agentic codebases.
ClaudeOS provides a persistent Nix virtual machine environment for Claude Code to operate in, with a clean expandable UI. Gives Claude a stable, reproducible execution environment isolated from the host system.
A linter specifically for Claude Code plugin artifacts — validates agent definitions, command structure, and skill files for quality and correctness. Useful for teams maintaining large Claude Code plugin repositories.
A GUI for discovering, understanding, and managing AI agent workflows stored in ~/.claude/, ~/.codex/, and project config directories. Provides a visual interface for all your agent definitions, skills, and configurations.
A local web dashboard that gives you a centralized view of your Claude Code ecosystem — skills, commands, agents, hooks, and MCP servers in one place. Useful for managing complex, multi-project Claude Code setups.
A statusline integration that shows your Claude Code context window depth and usage limit utilization in real time. Helps avoid surprise rate limits and context compaction by providing continuous visibility into consumption.
autocode detects what you are building across sessions, compresses session context, and feeds it back automatically on restart. Zero setup, zero dependencies, one markdown file. Claims 40-65% token savings on repeat sessions.
A native desktop application built with React 19, TypeScript, and Tauri 2 (Rust) for managing AI agent instructions, system prompts, and project templates. Supports Claude Code, Cursor, and other coding agents.
Automatically collects Claude Code plugin adoption metrics (stars, downloads, usage) across GitHub repositories using n8n workflows. Useful for discovering trending and widely-adopted plugins.
Analyzes your Claude Code usage patterns and generates a proficiency badge using a rule-based scoring engine with 53 pattern-matching rules across 5 CCA-aligned domains. Auto-embeds the badge in your README.
A tool that analyzes why AI coding sessions fail by examining session logs and patterns. Two commands, zero config, zero dependencies. Identifies common failure modes like context overflow, tool errors, and planning failures.
Shep AI is an open-source development tool that automates the full idea-to-merged-PR workflow. Designed for teams managing multiple AI coding agent sessions with a unified SDLC control center.
A macOS menu bar application that monitors your Claude Max usage in real time, featuring an animated flame indicator and detailed usage insights. Helps Max plan subscribers track consumption before hitting limits.
A tool that shows what Claude Code is doing as a live Discord Rich Presence card — tracking sessions, displaying current activity type, and generating humorous status messages. Uses PostToolUse hooks.
Tycono is an open-source harness where you define AI agent roles in an org chart structure, give them names and responsibilities, and they operate autonomously with defined authority boundaries.
A terminal-based monitoring tool (in the style of Unix top) for watching multiple AI coding agent sessions in real time. Shows session activity, resource usage, and status across concurrent Claude Code instances.
A macOS infinite canvas application where multiple Claude Code and other coding agents can work in parallel with the ability to communicate between agent instances. Built to address the cognitive load of managing many agent windows.
A small CLI tool for switching between multiple Claude Code accounts quickly — useful for developers with personal and work subscriptions or teams sharing Claude Max seats.
An open-source local proxy and firewall for intercepting outbound LLM requests from Claude Code. Provides visibility into what prompts are being sent, enables request filtering, and creates an audit log of all AI interactions.
Claude Code agent teams spawns teammates in tmux panes, which does not work on Windows without WSL. This project provides a native Windows backend for agent teams, making parallel agent workflows work on Windows CMD/PowerShell.
An open-source tool using Mac Secure Enclave to let Claude Code execute code that needs secrets without ever exposing the actual secret values in context. Claude runs the code and sees only the result, not the credential.
A macOS notifications system for Claude Code that alerts you when agents need attention, finish tasks, or encounter errors. Built to address the anxiety of not knowing if background agents are actually making progress.
Railguard provides a middle ground between full manual approval and --dangerously-skip-permissions. Define specific tool patterns that can run freely while still requiring approval for sensitive operations like network calls or file deletion.
A static site generator where `seite init` generates a CLAUDE.md context file containing your entire site schema. Running `seite agent "write a post about..."` spawns Claude Code with full site context pre-loaded, enabling the agent to generate, update, and manage content without manual context injection.
Noren analyzes your existing writing (tweets, blog posts, essays) to extract sentence rhythm, rhetorical moves, punctuation habits, and word preferences — then generates new text that genuinely sounds like you wrote it. Built across 4 codebases in a 16-hour Claude Code session using prompt caching.
Addresses LLM agent statelessness using hyperdimensional computing to create a persistent memory layer. Prevents context window overload on long projects and enables genuine long-term reasoning across sessions — not just context stuffing.
A minimal web tool for checking your Claude 2x (rate-limited) usage status, with a Discord bot DM notification command when limits reset. Open source at github.com/k33bs/claude2x.
A Go rewrite of OpenClaw — single binary, 200ms cold start, 30MB RAM. Features graph-based memory (Neo4j or local GML), full multi-user RBAC, MCP integration with OAuth 2.1, and an encrypted secrets backend. Claude Code was a named collaborator in the rewrite.
A comprehensive web UI for Claude Code CLI combining chat, Kanban task board, task scheduling, multi-agent orchestration, MCP server management, skills, and remote access via Web, SSH, and Telegram. Brings full project management into a single browser-based workspace.
A Claude Code plugin providing per-project, per-agent, and per-skill token usage tracking with a local dashboard. Helps teams understand exactly where tokens are being spent across different skills and agent sessions.
Gives Claude Code and other coding agents (Gemini CLI, Codex CLI, Kimi CLI) persistent memory across sessions — the agent remembers how it solved bugs before and reuses that knowledge. Targets the "start from scratch every session" problem common to all stateless coding agents.
A collaborative workspace where teams share a single Claude Code session in real time — all members see the same agent context, reducing the overhead of constantly re-describing context to each teammate. Works with Claude Code, Codex, and Cursor. Addresses the core team pain of "lugging context around."
A detailed investigation into why Claude Code session titles get corrupted, wrong, or disappear in the VS Code extension. The root cause: the extension does a raw string search for "customTitle" in the last 64KB of .jsonl files, causing 20+ distinct failure modes from title eviction, cross-session contamination, and overwrite on resume. Proposed fix: store titles in a separate lightweight index file.
A security tool that sandboxes Claude Code sessions, attests every action, and verifies provenance of changes. Aims to bring software supply chain security practices to AI-assisted coding workflows.
A local-first native macOS app (and menu bar widget) that reads ~/.claude JSONL files to provide cost estimates and token breakdowns per session and project. Also serves as a config browser for all your skills, MCPs, hooks, and settings in one place. No telemetry, no accounts — everything stays on your machine. Especially useful for Enterprise users where the API does not expose per-project costs.
A Windows-native fork of CLIProxyAPI that adds a terminal UI, system tray icon, and multi-provider OAuth. Lets Windows users run Claude Code and other AI coding tools without managing API keys directly — OAuth handles authentication. Includes a single-binary executable.
A CRM that runs in your terminal and integrates with Claude Code. It automatically updates contact records from email threads, builds a knowledge graph of relationships, and ships with built-in agent skills and recipes. Described as doing more than $300/month Salesforce plans at a fraction of the cost.
An open-source platform for managing .env and secret files using git-style commands (push/pull/ci pull/scan). Solves the pain of manually syncing secrets across local, teammate, and CI/CD environments. Features AES-256-GCM encryption, secret leak detection in git history, one-time sharing links, and environment version history. Built in 3 weeks with Claude Code.
A floating native macOS overlay that wraps Claude Code in a proper UI without replacing the underlying agent. Features include persistent chat history, file/image attachments via drag and drop, a built-in skills marketplace, model picker, local slash commands, and optional auto-approve flows. Uses your existing Claude Code auth with no API keys or telemetry.
A multi-platform bot (Telegram + Discord) that routes messages to Claude Code CLI subprocesses running on your local machine. Notably, it uses your Claude Max subscription rather than API keys, so there are no per-token charges. Self-hostable and open source.
I built CCGram — a Telegram bot that bridges to tmux so you can monitor and control AI coding agents from your phone. The entire project was built using Claude Code, and it's specifically designed ...
If your code is hosted on a VPS or cloud machine—using tools like VS Code Remote-SSH, Cursor SSH, or running on a headless server—the bridge operates there, enabling Claude to connect from wherever...
Hello, not sure if this has been asked before. I’m currently juggling about 5 projects at the same time (don’t ask why 😅). Each project usually ends up with its own terminal window with multiple ta...
I'm building a writing voice extraction platform (Noren) across four repos, three languages, and two runtimes. CLI in TypeScript, desktop app in Tauri/Rust, Chrome extension, Python server. Every C...
Hi everyone, I’m a software developer looking to level up my workflow. I’ve seen all the amazing tools coming out for Claude lately— Claude Code , the "get-shit-done" mentality of the newer models,...
https://i.redd.it/8yt251ldgdpg1.gif Like many of you, I've been using Claude Code heavily and my ~/.claude directory has become a graveyard of session files, debug logs, and orphaned data. I wanted...
I use Claude Code every day for B2B sales and software development. For months I kept running into the same problem: every session started from scratch. Context gone. Decisions forgotten. The three...
Hey everyone. Converting the "5-11am PT / 12-6pm GMT" promo hours into my local time every day was getting annoying, so I built a simple tracker: promoclock.co It automatically detects your timezon...
I've been using Claude Code extensively on a serious engineering project for the past year, and it has genuinely been one of the most impactful tools in my workflow. This is not a post against AI c...
so I had this problem where every new Claude Code session starts from scratch. you re-explain your architecture, your decisions, your file structure. every. single. time. I tried something kinda du...
Been using AI coding agents daily for months now and recently discovered agensi.io, which is basically a marketplace for SKILL.md files. Bought a few, downloaded some free ones, and a handful have ...
Yes, I use Eclipse. I know. But when Ctrl+Shift+G , Ctrl+T , and Ctrl+Shift+T are in your muscle memory and your hands just refuse to switch editors — you know who you are. Here's the thing: Eclips...
Ever wonder how much energy your claude code session is using? I definitely did. It would be really tricky to calculate this manually, so I built a skill that integrates it into the claude code flo...
Running a multi-agent system in production for a few months. We have specialized agents (design, coding, QA, fulfillment, etc.) working from a shared task queue. Here's what genuinely surprised me:...
I’m a heavy Claude Code user, a Max subscriber, and I’ve been using it consistently for about a year, but in the last few days I’ve been running into a clear drop in output quality. I used Claude C...
I built a personal finance app in 1 month with Claude Code. It was harder than expected. Here's what I learned I built a personal finance forecasting app (the one I always wanted but couldn't find)...
Site: aiskillslab.dev I've been building skills for Claude Code for months and got tired of the same pattern: build a skill, manually test it, hope it works for other people. So I built a system wh...
I'm working full-time on ottex.ai macOS app. Decided to share some cool stuff I picked up along the way building it from the idea to a working product with paying customers. TL;DR I ditched SwiftUI...
I've been running a Claude Code agent on my MacBook for months. 25 LaunchAgents, persistent memory, nightshift automation, Discord bot. It worked, but every time I took my laptop somewhere, everyth...
I’ve been using Claude Code to help me with app development, brainstorming and development of frameworks for additional apps and business plans, and other tools for my personal work and side hustle...
I’ve been using Claude Code to help me with app development, brainstorming and development of frameworks for additional apps and business plans, and other tools for my personal work and side hustle...
I run a small consultancy helping companies deploy Claude Code across their teams. The first thing every org asks for is governance. Who is using Claude, what are they doing with it, are sessions a...
For context, we are a global customer support operation, so recruiting never stops. A single job post can bring hundreds of applications (somtimes over 1 thousand applications!!!), and the first st...
If you do long working sessions with Claude, you've probably noticed this pattern: You're deep in a task. Something interesting comes up tangentially. Claude catches it — says something like "good ...
Sometimes Claude just... ships the entire thing. You say "step by step" and it comes back with 5 file edits, a rebuild, and a working feature. No back and forth, no debugging. Just done. But here's...
All of a sudden, I'm getting an error when I open a project directory in Claude Code. It told me that one tool I have in my permission file does not have the first letter capitalized. So I went to ...
Setting up proper feedback loops is crucial for Claude to validate it's work, so I put together some things that have yielded great results, particularly when leveraging worktrees for parallel deve...
I've been using Claude Code for everything lately, so I built a browser automation tool that plugs in as an MCP server. One of the built-in skills is LinkedIn prospecting. How it works: you run /li...
karpathy's autoresearch runs an AI agent in a loop: modify one file, measure one metric, keep or discard, git checkpoint, repeat. you sleep, it runs 100 experiments overnight. the thing that stuck ...
I wanted a voice interface for Claude Desktop that works well in Hungarian, using ElevenLabs, and I managed to build it with Claude Code. I'm not a developer, but I work and study a lot with Claude...
Every time Claude generates a UI mockup, the HTML file ends up in /tmp or cluttering my project directory. No history, no organization, no easy way to refer back. So I built Mockups MPC, a self-hos...
so i recently got my hands on claude max and it’s been beautiful so far. i work with various lead gen agencies and have been building internal tools for them for analytics, automating leads, and st...
Hey guys! Been using claude for a while and the difference between a conversation with good context vs no context is insane. but actually writing a proper system prompt or AGENTS.md that covers you...
I built this with Claude Code over the past few weeks to solve a problem I kept hitting — running multiple Claude Code agents on the same repo causes file conflicts, duplicate work, and messy merge...
Hi everyone, I recently started using Claude Code for some personal projects and really liked the experience. Now I'm exploring using it in my regular job as well. I have a question about the best ...
Frank runs on Claude Sonnet 4.6 via OpenClaw. This whole system is built around optimizing how Claude handles persistent context — vault architecture reduces what gets injected into every Claude me...
Hey Anthropic team and everyone here, I have been thinking about this idea for a while and I genuinely feel it could be one of the most useful things Claude could ever offer to everyday users. I am...
Been using Claude Code for real project development and the biggest problem is keeping the agent aligned on architecture. You finish a session and realize it made a bunch of structural decisions yo...
Hey 👋 Quick project showcase. I built a growth playbook specifically to use with Claude that helps structure B2B SaaS growth work from PMF validation all the way to channel ecosystem and sales. The...
I wanted Claude Desktop and Claude Code to work through hundreds of old posts on my self-hosted WordPress blog — cleaning up dead links, pre-Gutenberg markup, and other accumulated cruft. The offic...
I keep seeing OpenClaw vs Claude Code comparisons, so I wanted to share a real use case that isn't about coding at all. https://youtu.be/XWdfpwsW4tQ My family is moving from NJ to Porto in July. I ...
We've been building Focido, a social motivation app, with Claude Code for a few months now. Flutter frontend, NestJS backend, 3 languages from day one: EN, RU, ES. Overall, the experience has been ...
One command to install: pip install fpl-intelligence Add to your Claude Desktop config: {"mcpServers": {"fpl": {"command": "fpl-intelligence"}}} Restart Claude and type: "Analyze FPL team " That's ...
🛡️ Enhance code safety with Claude Code Safety Net, a tool designed to identify and mitigate risks in your codebase effectively.
An iOS app that runs an AI agent locally on-device 24/7 in the background, supporting BYOK (bring your own key) for models like Opus 4.6. Currently in beta with a cap of 1,000 users. Aims to make continuous AI-assisted automation available without a desktop computer.
A Rust command-line tool that uses Claude and GitHub Copilot to semantically understand and group git diffs instead of showing raw line changes. Features a fast ratatui terminal UI for reviewing semantically-related changes together. Helps with code review by surfacing logical groupings in commits.
A native macOS application that integrates Claude's chat, Cowork collaboration features, and Claude Code into a single desktop app. Provides a polished native interface instead of switching between browser and terminal. Built for Mac users who want a unified Claude experience.
An Electron-based desktop application that visualizes the internal prompt structure and mechanism used by Claude Code. Helps developers understand what context, system prompts, and tool definitions Claude Code is working with. Useful for debugging agent behavior and optimizing prompts.
A utility for synchronizing Claude Code configuration files — plugins, agents, skills, and settings — across multiple computers using rsync over SSH with three-way conflict detection. Solves the pain of maintaining consistent Claude Code setups across desktop, laptop, and server.
A native macOS application specifically designed for managing multiple simultaneous Claude Code sessions from one interface. Provides session overview, status monitoring, and switching between projects without terminal juggling. Designed for heavy Claude Code users running parallel workstreams.
A diagram generation engine that takes natural language descriptions and produces professional diagrams with proper arrow routing, collision detection, typography, and visual validation. Goes beyond simple ASCII diagrams to produce presentation-quality outputs automatically.
A tool for launching multiple Claude Code agent instances, each in its own isolated git worktree, from a single command. Manages the lifecycle of parallel agent sessions without manual worktree setup. Designed for running several independent tasks on the same codebase simultaneously.
Automatically routes between different Claude models based on task phase — using Opus for planning and Sonnet for execution — and falls back gracefully when hitting 429 rate limits. Reduces cost and latency without manual model switching. Works transparently within existing Claude Code sessions.
A native macOS app that creates a unified AI development workspace combining git worktrees, Claude Code sessions, and local dev servers in one interface. Manage multiple parallel agent workflows from a single app. Reduces the terminal-juggling overhead of running concurrent Claude Code instances.
A visual dashboard that overlays structured workflow phases onto Claude Code projects, making the agent's progress through design, implementation, and testing stages visible and trackable. Helps teams understand where agents are in a workflow and when to intervene.
A configuration management tool for AI coding CLIs that lets you configure once and sync everywhere — local machines, cloud environments, and team members. Handles key rotation in one place with full audit logging of all configuration changes. Works across Claude Code, Codex, Cursor, and others.
A Laravel package that brings Claude Code agent capabilities — file handling, command execution, code editing, and web search — into PHP applications. Enables building Claude-powered automation pipelines within existing Laravel backends. Simplifies integrating agentic workflows without leaving the PHP ecosystem.
Implements the Recursive Language Model (RLM) pattern as a Rust CLI for Claude Code, enabling processing of documents far exceeding context limits. Uses intelligent chunking, SQLite persistence for intermediate results, and recursive sub-LLM orchestration to maintain coherence across passes.
A mobile application that bridges to Claude Code and Codex sessions via WebSocket, allowing you to monitor agent progress, send instructions, and review output from your phone. Works with both Anthropic and OpenAI agentic coding tools. Designed for keeping tabs on long-running autonomous sessions.
Records every tool call, decision, and reasoning step during Claude Code sessions for offline analysis. Runs entirely locally with no external services or API calls needed. Useful for debugging agent behavior, auditing session activity, and building reproducible workflows.
A Flutter-based mobile app that lets you monitor and control Claude Code sessions from your phone over an encrypted connection. Self-hosted with no cloud dependency — your commands and outputs stay private. Cross-platform with iOS and Android support.
Runs Claude Code in an isolated Docker container where it can execute commands, install packages, and modify files without any risk to the host system. Supports installation via zinit, sheldon, or manual setup. Enables truly autonomous operation in dangerous skip-permissions mode safely.
DevGlobe is a free, open-source Claude Code plugin that makes you appear on a live globe while you code, so you can see and connect with other Claude Code users worldwide. Features a leaderboard, project showcase, anonymous mode (random city in your country by default), and privacy-first design where no code or personal data is sent to the backend.
ReadingIsFun is an ePub reader built with coding agent integration. It uses your existing CLI subscription (Claude Code, Copilot, Codex, Gemini) to let your AI agent read technical books alongside you, enabling real-time discussion, note-taking, and code generation from the content.
cc-streak tracks your Claude Code usage history and shows your current streak, longest streak, and burnout warnings. A lightweight tool for staying consistently productive without overdoing it.
agent-conductor is a desktop application for managing multiple concurrent Claude Code and Gemini CLI sessions. It provides a unified interface for spawning, monitoring, and switching between parallel agent sessions.
cc-ghost-log surfaces git commits from Ghost Days — days when Claude Code ran autonomously without you present. It gives you a clean, navigable log of what your AI agent did while you were away, making it easy to review autonomous changes and maintain oversight of unattended sessions.
clsh enables remote access to your terminal and Claude Code agent sessions from any device — phone, tablet, or desktop. Useful for monitoring and interacting with long-running autonomous sessions while away from your development machine.
claude-autocontinue is a Chrome extension that automatically clicks Continue when Claude hits the 20-tool-use limit on claude.ai. Works across all open tabs including background tabs, includes a Minimize tokens mode that asks Claude to summarize state before resuming, and supports configurable max continuations (1-999 or unlimited).
SkillJury indexes over 4,274 skills across 23 AI agents including Claude Code, Codex, Cursor, and Cline. Each skill includes security scoring via SNYK and Socket checks plus community reviews so you can evaluate trust before installation. A curation layer for the fragmented skill ecosystem.
Caliber is an open-source tool that continuously scans your project and generates CLAUDE.md, .cursor/rules, and recommended MCPs tailored to your tech stack. It collects community-curated skills and config snippets to give your Claude agents the optimal configuration. MIT-licensed, runs locally using your own API key.
Kangentic is a free, open-source desktop app that adds visual Kanban-style orchestration on top of Claude Code. Drag tasks between columns to spawn, suspend, and resume sessions — each with their own git worktree for conflict-free parallel work. Supports live tool call tracking, configurable concurrency, session persistence across restarts, and runs the native Claude Code CLI directly with no modifications to your setup.
SubFrame is an open-source terminal IDE that wraps Claude Code with persistent context via AGENTS.md, auto-generated codebase maps, and task injection hooks. It provides session management, live agent monitoring with tool call tracking, per-task git worktrees for conflict-free parallel work, and full session persistence across restarts. Eliminates the cold-start context loss problem on every new session.
I see many stories, posts, etc, about the idea of having multiple "agents" working together. I'm a developer, so I'm using Claude Code predominately to conceive app ideas, build the app, and then I...
Production-grade Claude Code plugins by Nuno Salvacao, starting with strategy-toolkit and expanding into a reusable plugin portfolio.
Hey guys, about two months ago I started this side-project for "asynchronous coding" where I can prompt Claude Code from my mobile on train rides, get a notification when it's done and then review ...
Hi everyone, I’m trying to figure out whether tools like Claude Code (and possibly Cowork) could work as a sort of personal assistant for managing my life and projects. My idea would be something l...
Run parallel Claude Code agents in tmux with automatic permission approval. Auto-approves Bash, WebFetch, and other tool prompts so agents run unattended. One-liner install for macOS, Linux, WSL a...
I kept re-explaining the same things to Claude Code every session. My CLAUDE.md was getting huge and most of it didn't matter anymore. Every AI memory tool I found just appends to a markdown file a...
I've used Claude for creative and design work, and I've noticed that a lot of the "techniques for optimizing output" that get posted are often presented as universal fixes, when I think the real re...
Claude Code plugin that automates the sprint workflow for projects using beads and Basic Memory
As a side project, I built kifd.org – a fictional AI political party for Germany, entirely generated by Claude Opus 4.6. The concept: What happens when you force an LLM into the format we distrust ...
For the last couple days, I've seen a very weird behaviour when interacting with Claude Code: all user requests appear to freeze before receiving less than 1000 tokens back - you can see how time c...
Reusable Claude Code configuration repository with skills, subagents, hooks, MCP setup, and examples for bootstrapping new projects.
I’ve been using Claude Code more seriously over the past months, and a few workflow shifts made a big difference for me. The first one was starting in plan mode instead of execution. When I write t...
Used to browse and monitor the historical session records of AI programming tools（Claude Code、Codex CLI、Cursor、Aider）
Was checking out sentrux (open source Rust codebase analysis tool) with Claude Code. It wasn't resolving my TypeScript imports. 310 specs, 0 resolved. I'm debugging with Claude and move onto other ...
i think one big reason AI debugging becomes painful so fast is not just that the model makes mistakes. it is that the model often decides what kind of problem this is too early, from surface contex...
Hi everyone, I'm considering using Claude Code to assist me in writing a book on a non-technical topic (health & wellness). Before diving in, I have two questions: Is Claude Code a good fit for lon...
When using Claude Code to generate frontend code, I noticed something: the architecture can drift quickly if the structure isn’t enforced. So I built a small Claude Code skill that helps Claude fol...
I'm an engineer and while I have written a lot of code myself over the last 9 or so years, I would still call myself unapologetically lazy, the kind of person who'd happily hand the job to AI and s...
So, working in a project that encountered an extremely taxing and exhausting experience recently, I asked Claude to summarize our current underwhelming state in a fresh txt document on my desktop. ...
Hey Reading Superstars 👋 I'm a solo entrepreneur from India with zero coding background. Over the past few months, I've been using Claude as my entire engineering team to build a marketing automati...
Real-time observability for Claude Code agents. Track conversations, tool calls, and token usage across all sessions - zero config.
Appstle Subscription API plugin for Claude Code. Manage Shopify subscriptions, billing, and recurring orders via natural language
macOS menu bar app for tracking Claude Code rate limit usage in real time
Claude tools run for hours and sometimes get stuck or hit quota limits. If you close the terminal, the process dies. I wanted something like systemd / pm2 but specialized for AI coding agents . I m...
Build a minimal Claude-style AI agent from scratch that processes messages, interacts with tools, and generates dynamic responses.
If you use Claude Code heavily across multiple repos, you probably know this feeling. You have Claude running in several projects at the same time and at some point you start wondering: How much di...
The official Claude Code mobile experience drives me crazy. Every single tool call needs a "y" approval. On a phone. Over and over. So I used Claude Code to build GhostTerm — a real terminal on you...
I just got my results back today and managed to snag the Early Adopter badge as well. Following up on my recent DP-600 certification, I really wanted to validate my architecture skills specifically...
Did anyone else find that ‘memory’ ChatGPT export gave was highly disappointing using the prompt Anthropic had and that people were spreading around a couple weeks ago? I did it on my ChatGPT enter...
I recently asked Claude Code to build a comprehensive suite of E2E tests for an Alpine/Bootstrap site. It generated a really nice test suite - a mix of API tests and Playwright-based UI tests. Afte...
I'm a designer and I've been having a ton of fun with AI coding tools but the one thing that drives me nuts is how they just start building immediately. No planning, no "hey what should this actual...
Github URL https://github.com/ouro-ai-labs/skynet What is it? Skynet is an open-source multi-agent collaboration network. Think of it as a group chat where AI coding agents and humans can freely co...
Prompt Line is a macOS app developed to improve the prompt input experience in the terminal for CLI-based AI coding agents such as Claude Code, Gemini CLI, OpenAI Codex CLI, and Aider.
What I built with Claude Code: AgentYard — a community platform where AI agents are first-class members. The idea: What if vibe-coded apps had a home? A Store where you ship what you build, a chann...
Every time Claude Code streams a long response, my terminal would jump to the top and I'd lose my place. Scrolling back up just meant getting yanked away again on the next update. It's been the mos...
I spent 2 weeks building Forge with Claude Code and shipped an entire IDE with Claude baked in. Here's what makes it different from Cursor and Copilot : The AI agent doesn't just write code and han...
🛠️ Boost your workflow with Vibe Kanban, the tool that enhances productivity by optimizing interaction with coding agents like Claude Code and Codex.
been building this for about 3 months and got to a point where it genuinely helps me work with claude code every day. want to find 50 people willing to give me real feedback in exchange for a free ...
A developer used Claude Code (Opus, high reasoning) to reverse-engineer the Disney Infinity 1.0 binary with no symbols, source code, or prior RE docs. Claude traced the call graph, identified all 13 validation sites blocking character cross-playset access, and generated 17 binary patches — a restriction the modding community had failed to crack for over a decade. Completed in under 24 hours.
Generate huge DOCX and PDF files in milliseconds. One interesting part of this project is how it was built. I used a workflow with Claude Code using the model Opus 4.6 that looked like this: first ...
The rise of coding agents and their rapidly evolving ubiquity is genuinely a great thing. One of the best aspects about knowing coding has always been the ability to quickly whip up a script or sma...
Hi everyone, I’m currently paying about $20/month for Antigravity, but honestly I’m not very satisfied. The main issue for me is bugs and instability. Sometimes it works well, but other times thing...
Hey 👋 I've been experimenting a lot with Claude Code and agent-based coding workflows recently, trying to see how far Claude can go when building full apps. One pattern I kept running into: Claude ...
Hi everyone, I've been experimenting with AI-assisted development using Claude, and I noticed that starting a new project always involved repeating the same setup steps. So I built a small tool cal...
Hi all, I vibe coded naviClaude for personal use to manage all Claude Code session across all of my tmux sessions, and I wanted to share it in case other people have similar workflow. At my job, I ...
I’m trying to set up Claude as a thought partner for health issues. I’ve connected all my health records through a third party app. I’m wondering if anybody has come up with a good architecture for...
Given the somewhat new ability of coding agents to spawn individual sub agents and orchestrate them, and the new skills system to define work, I wonder if it is possible now to replace python based...
I find that claude's normal planning tools are just super reckless, you say do X and it goes into these wild coding session to produce thousands lines of code, half of it is based on a random decis...
🛠️ Manage and sync your coding skills across multiple AI tools with this cross-platform desktop app for streamlined organization and efficiency.
It’s called Learnship. It’s open source, and it works inside Claude Code as a portable harness layer. Repo at the end.  After using AI coding agents for real projects, I kept running into the same...
took me way too long to figure this out so sharing in case anyone else is doing the same thing. I was defaulting to "write me a document about X" for everything — project specs, outlines, notes, wh...
Long Claude Code sessions have a silent killer: context compaction wipes your entire work-in-progress state mid-refactor. You lose your task context, file list, and next steps. New session — you're...
🚀 Build custom agents and manage Claude Code sessions with this powerful GUI app and toolkit for seamless development and secure background tasks.
I want to build a benchmark that asserts the success of a task, such as comparing with tool calls, hooks, etc and without, or vs other type of hooks and such. Likely on top of Claude Agent SDK as t...
Pretty crazy (for me at least) milestone that I wanted to share with someone but I just hit 500 installs on my Claude Code-d media ranking Android app, Curate! I initially started building my app C...
https://preview.redd.it/2lpe5hwgh2pg1.png?width=3833&format=png&auto=webp&s=6969c284829e314243a1ea341231537a7071b040 Deployed into a Windows env. I did some work on my setup today based on some thi...
Cultivate your Claude Code workflow with plugins for projects, context, and feedback
Free tool: https://grape-root.vercel.app Discord: https://discord.gg/rxgVVgCh (For debugging/feedback) I’ve been building an Free tool called GrapeRoot (dual-graph context system) using claude code...
Hey guys I created a worktree manager wrapping Claude code with many features aimed at maximizing productivity including Run/setup scripts Complete worktree isolation + git diffing and operations C...
Free tool: https://grape-root.vercel.app Discord: https://discord.gg/rxgVVgCh (For debugging/feedback) I’ve been building an Free tool using Claude code called GrapeRoot (dual-graph context system)...
I’ve used Claude Code for six months and I’m very happy with it. I tried building my own agentic workflows and orchestrator, but ran into many problems. When I used Claude Code as the orchestrator,...
I wanted to share my experience building a full product almost entirely with Claude Code. Not a weekend hack or a demo — a real, deployed, monetized web app with auth, payments, AI generation, and ...
The last few days I perfected a setup that works really well for me. I based it on this very helpful video about linking Claude and Obsidian, and then I added my own tweaks. After reading this post...
Hey guys I created a worktree manager wrapping Claude code with many features aimed at maximizing productivity including Run/setup scripts Complete worktree isolation + git diffing and operations C...
Hey everyone, I recently tried plugging a coding agent directly into our classic project board via MCP. At first it seemed fine tasks could update automatically. But we ran into some issues: the bo...
Here’s what I built: a Chrome extension that converts any web page into a spatial text representation that Claude can read natively. No screenshots. No vision model. Just characters on a grid where...
Coding iOS apps is easy now with Claude Code, but submitting them to the App Store is still very painful. Setting up signing certificates, uploading screenshots, filling out age requirements etc et...
https://reddit.com/link/1ru01n2/video/djv8iaovu3pg1/player Coding iOS apps is easy now with Claude Code, but submitting them to the App Store is still very painful. Setting up signing certificates,...
https://reddit.com/link/1rtztrq/video/k9s8g2aqp3pg1/player Coding iOS apps is easy now with Claude Code, but submitting them to the App Store is still very painful. Setting up signing certificates,...
Would love to hear if anyone finds this useful! https://github.com/NXJim/claude-workbench I run Claude Code on a virtual machine over SSH. This way it's isolated and I can use --dangerously-skip-pe...
For a long time I was confused about agents. Every week a new framework appears: LangGraph. AutoGen. CrewAI. OpenAI Agents SDK. Claude Agents SDK. All of them show you how to run agents. But none o...
I kept needing my Claude agents to share context with each other – onboarding new agents, handing off projects, debating decisions. So I built AgentMeet. It's basically Google Meet but for AI agent...
Agent Prompt: Security monitor for autonomous agent actions (second part) — Clarified "base64-encoded" to "encoded (e.g. base64)" for sensitive data detection; broadened code-from-external deserial...
I’ve been using Claude Code almost daily for a while now, but about 85% of what I’m doing isn’t actually programming. I’m mostly using it for complex, project-based life stuff. For example, I’ve be...
Hey, I am new to Claude just switching over from a GPT paid membership and after all the buzz through just the free plan im seeing how much better claude really is. As someone who is a student most...
We work in an industry centered on excel. The Claude Addin is great for session specific modelling, reports etc. But we are experimenting with Claude Code to see if we can vibe develop excel based ...
Tldr, can claude be used to build an AI agent that finds scholarships, gathers requirements, and prepares the application package for the user to review and submit? ---------- They say the best way...
Learn features by building projects hands-on with Claude Code--no boring videos, outdated blog posts, or stale courses.
Hey 👋I've been experimenting a lot with Claude Code and agentic coding workflows recently.One thing I kept running into is that Claude agents are surprisingly good at writing application logic, but...
Hey 👋 I've been experimenting a lot with Claude Code and agentic coding workflows recently. One thing I kept running into is that Claude agents are actually pretty good at generating application lo...
Everyone's debating Windsurf vs Cursor right now but nobody's talking about the elephant in the room — Claude Code doesn't even play the same game as both of them, and that changes the whole compar...
You know the drill — new task, open project, copy this file, paste, copy that one, paste, realise you forgot a config file, paste again, hit the context limit, start trimming... It was eating into ...
Built this with Claude (Sonnet) as the AI backbone for context generation and compression. The entire CLI was also built using Claude Code and Codex as coding assistants. Hey everyone, I kept runni...
Hey 👋 I’ve been experimenting a lot with Claude Code and AI coding agents recently. One thing I kept running into is that Claude agents are actually pretty good at generating application logic, but...
A CLI tool that tracks and analyzes token usage across Claude's tool calls and subagent invocations. Provides a breakdown of where tokens are being consumed — useful for optimizing context usage in multi-agent workflows.
A single discovery hub for Claude Code ecosystem resources — skills, agents, commands, hooks, plugins, and marketplace collections for Claude Code, Claude Desktop, Agent SDK, and OpenClaw. Central directory for community-built Claude extensions.
An automated tool that tracks changes to the official Claude Code documentation and surfaces diffs over time — useful for staying current with new features, deprecations, and API changes without manually checking the docs.
A cross-runtime observability toolkit providing unified tracing for Claude Code, OpenClaw, and OpenCode via OpenTelemetry and Langfuse. Enables standardized telemetry across different AI agent runtimes in the same trace pipeline.
DUDA prevents AI agents from breaking tenant, layer, and service boundaries in Claude Code. Uses a 95-point trust-score threshold to gate code migrations — only changes that pass the isolation checks proceed.
An autonomous development studio where you describe an idea, and AI agents orchestrate the full development process — from planning through implementation — with human validation gates at key decision points.
A configurable status line for Claude Code with 11 built-in themes, color-coded thresholds, and modular design — displaying session metrics at the bottom of your terminal during Claude Code sessions.
batipanel is an AI-powered terminal workspace manager combining tmux and Claude Code. Organizes and manages coding sessions, terminal panes, and agent workspaces from a unified panel interface.
agentops is the missing DevOps layer for coding agents, providing flow control, feedback mechanisms, and memory that compounds between sessions. Treats AI coding agents as first-class infrastructure components.
A Rust implementation of the Claude Agent SDK with type-safe tools, idiomatic patterns, and production-ready primitives for building robust AI agents in Rust.
A terminal-based Kanban board written in Python that supports direct manipulation by AI coding agents — agents can create, move, and complete tasks on the board programmatically during development sessions.
kairo orchestrates multiple AI providers via Anthropic with X25519 (age) encryption, integrated audit trails, and a terminal-native interface — designed for teams that need verifiable, encrypted AI interactions.
An Emacs package providing a unified interface for multiple AI coding tools: Claude Code, OpenAI Codex, GitHub Copilot CLI, Gemini CLI, Opencode, and more — all accessible from Emacs without switching tools.
A voice control interface for Claude Code that enables hands-free operation via real-time speech transcription. Speak commands instead of typing — useful for long sessions or accessibility needs.
kirocc is a local proxy that relays Anthropic Messages API-compatible requests to the Kiro (Amazon Q) backend using Kiro CLI credentials — enabling any Anthropic-compatible tool to use Kiro as the backend without API key changes.
A real-time telemetry gateway that ingests, routes, and displays LLM tool calls, errors, and metrics with a live visualizer. Provides operational observability across AI agent systems in real time.
leonidas automates GitHub issue handling end-to-end — generates implementation plans, writes code, and creates pull requests using AI-powered workflows. Designed to reduce the manual burden of routine issue work.
tsk-tsk provides sandboxed execution environments for coding agent automation, preventing agents from taking dangerous actions outside their allowed scope. A lightweight safety layer for autonomous coding agents.
driftx gives AI coding agents visual perception and control for mobile development — enabling agents to see and interact with mobile UIs during the development and testing process.
sessions-chronicle is a local app for browsing and searching through past AI coding sessions — enabling developers to find, reference, and reuse patterns from previous Claude Code interactions.
glassbox is a local code review interface designed specifically for reviewing AI-generated code — surfacing changes, explanations, and context in a human-readable format before accepting AI output.
A unified coding agent session manager that supports Claude Code, Gemini CLI, Codex CLI, Cursor Agent, Copilot CLI, Cline CLI, OpenCode, and Kimi CLI — all in one interface. Manages multiple agent sessions from a single dashboard.
A real-time monitoring dashboard for Claude Code sessions, providing live visibility into session state, tool usage, and agent activity. Helps developers track what Claude is doing at any moment without digging into raw terminal output.
A local observability tool for AI agents that stores tokens used, cost, latency, and execution traces in a local SQLite database queryable with SQL. No cloud dependency, full data ownership, and immediately actionable metrics for every agent session.
A security scanner that detects malicious or adversarial content in AI skill files, CLAUDE.md instructions, and agent rules. Designed to protect Claude Code users from prompt injection embedded in third-party skills and community-contributed instruction files.
A self-hosted Claude Code UI that bundles an in-browser VS Code instance, terminal, custom skills, MCP servers, and multi-provider support (Anthropic, OpenAI, GitHub Copilot, OpenRouter) — all in one sandbox environment.
An ambient macOS AI that continuously listens to conversations, understands context across work and life, discovers tasks without prompting, and autonomously completes them using local intelligence — no manual prompting required.
A CLI that deeply analyzes your project structure, stack, and patterns and generates tailored Claude Code configurations (CLAUDE.md, settings, etc.) — replacing the manual work of bootstrapping a new project for Claude Code.
A local web dashboard that mirrors and manages multiple AI coding CLI sessions (Claude Code, Codex, etc.) in real time, with resumable, project-based terminal workspaces. Think of it as a session manager with a web UI.
A patch for Claude Code that displays file reads and thinking inline in the output without needing to enable full verbose mode — giving developers visibility into what Claude is reading without the noise of complete verbose logging.
A desktop dashboard for managing GitHub pull requests across multiple parallel Claude Code sessions — each running in isolated Docker containers. Centralizes PR review and agent management into one view.
ciab provides a REST API, CLI, and desktop app for managing Claude Code, Codex, Gemini CLI, and Cursor agent instances as either local processes or Docker containers. Standardizes agent lifecycle management across multiple tools.
claudetop is a real-time terminal monitor for Claude Code sessions — showing live cost, cache efficiency, model comparison across sessions, and smart alerts. Styled after htop, it provides at-a-glance operational insight into what your agents are spending.
A fast, native terminal process monitor for Claude Code that tracks sessions, agent teams, MCP servers, tmux swarms, and orphaned processes. Gives real-time visibility into everything running in your Claude Code environment.
bankan is a simple control center UI that gives visibility into every AI coding agent task, stage, and agent at a glance. Brings order to parallel AI development without leaving your local workflow — all within your terminal.
claude-prime sets up Claude Code with skills, hooks, agents, and a memory system in a single command — removing the barrier of having to understand and configure each feature individually before getting productive.
A Claude Code plugin that renders a heads-up display showing current context usage percentage, active tools in use, running agents, and todo progress — all updated in real time during a session. Useful for monitoring session health at a glance.
claudetop is an htop-style real-time monitor showing where Claude Code is spending tokens, cache efficiency, and projected monthly cost. Inspired by system resource monitors, it gives developers immediate visibility into agent spending patterns.
An open-source AI IDE inspired by Andrej Karpathy\'s ideas, featuring an agent command center that lets you run Claude Code and Codex as coordinated agents from within the IDE GUI. Growing with new features, it aims to unify multiple AI coding agent backends under a single interface for orchestrated agent workflows.
Git Quest is a game created entirely with Claude Code in one week where your GitHub commit history defines your character and your coding skills determine your class. The project is full of developer references and represents a creative showcase of what Claude Code can ship in a focused week-long sprint.
AnyClaude 0.5.0 adds subagent backend routing — when Claude Code spawns agents via the Agent tool, each is pinned to a configurable backend for its lifetime. The release also introduces a modular 7-stage pipeline (extract → routing → headers → thinking → forward → transform → response), per-session thinking state, Ctrl+R for session-preserving restarts, per-session log files, and session token auth for proxy traffic.
Hawkeye is an open-source observability tool for AI coding agents (Claude Code, Aider, etc.) that runs 100% locally. It detects when agents drift off-task using a heuristic scorer and optional local LLM scorer, and enforces guardrails like file protection, command blocking, and cost limits. Includes a web dashboard, session replay, and an MCP server for agent self-awareness.
JuhBDI applies the Belief-Desire-Intention (BDI) cognitive architecture to Claude Code as a plugin, enabling intent-driven autonomous development with governed execution, audit trails, and learning memory. It structures how Claude reasons about goals and actions during coding sessions.
A developer shares how they used Claude Code to build a full DICOMweb-compatible PACS server from scratch in TypeScript after finding Orthanc+S3 too slow. Claude Code drove the entire architecture: 15-page spec, 5-phase project plan, FastAPI-style service with PostgreSQL metadata and S3/Azure Blob storage. An impressive example of Claude Code tackling a complex domain-specific engineering problem.
A tool that intercepts and displays every prompt, response, tool call, and token count that Claude Code sends in real time. Useful for debugging system prompts, understanding conversation threading, monitoring token patterns, and building automations on top via MCP.
A structured workspace system inspired by Git's branching and merging model, designed for coordinating teams of Claude Code agents. Provides primitives for agent isolation, work sharing, and structured handoffs between agents in multi-agent workflows.
A verification layer that sits between Claude Code and your codebase to independently check AI-generated changes before they land. Addresses the well-known problem of Claude confidently making changes that silently introduce bugs.
An open-source personal AI assistant that runs continuously in the background, inspired by OpenClaw's resident AI concept. Provides always-on assistance without requiring explicit invocation, with a focus on self-hosted, local operation.
A self-hosted, local-first personal AI butler powered by Claude that integrates task management, Claude Code session management, a persistent memory system, and a web UI. Open source and designed for users who want full control over their AI assistant infrastructure.
A tool that launches Claude Code, Codex, and Gemini CLI simultaneously, each in its own isolated git worktree. Allows direct comparison of AI coding agents on the same task, with clean branch isolation preventing agents from interfering with each other.
Zero-cloud, agent-agnostic tool that mirrors any terminal-based coding agent (Claude Code, Codex, etc.) to your phone over your local network. No cloud dependency and works with any agent, making it useful for mobile monitoring of long-running sessions.
A web-based visual interface for managing Claude Code plugins. Provides a GUI for browsing, installing, and organizing plugins instead of editing config files manually. Makes plugin management more accessible for users less comfortable with CLI workflows.
VibePod is a CLI tool that wraps Claude Code with additional features including a dashboard for monitoring consumption and session management. Version 0.5.1 adds visual dashboards for tracking Claude Code usage. Available on PyPI.
A terminal UI that scans your Claude Code transcript files and lets you browse, search, and resume any past session. Built with Claude Code itself, it addresses the common problem of losing context from previous sessions by making them easily navigable.
A free, open-source web UI (CloudCLI) that lets you run Claude Code, Cursor CLI, or Codex from any browser or mobile device. Provides a full-featured remote interface for managing Claude Code sessions and projects without being at your desktop.
Automatically captures terminal output and pipes it to Claude Code, eliminating the copy-paste loop of scrolling up to find errors. Run any dev command through logifai and Claude Code gets instant access to the full log output for debugging.
An AI-powered CLI coding agent that automatically creates safe git branches before making changes, supports multiple LLMs, and provides rich tooling. Designed as a safer alternative to direct AI code editing by isolating changes in branches.
A web interface that wraps the Claude Code CLI to make it accessible to children learning to build software with AI assistance. Provides a simplified chat interface designed for young users, lowering the barrier to AI-assisted coding education.
Adds real-time Claude Code metrics to your terminal status bar: token count, context window percentage, cache hit status, and session countdown. Solves the problem of not knowing how close you are to context limits until it's too late.
A minimal CLI tool for managing multiple Anthropic API keys when working with Claude Code across different projects or billing accounts. Enables quick switching between keys without manually editing config files.
I've been using Claude Code daily and the biggest pain point was losing context between sessions. So I built Mengram — a memory API designed specifically for Claude Code's hooks system. How Claude ...
A Tool for Claude Code to auto populate Skills and Agents into your project
a few weeks ago i posted about running coding tasks through a small “council” before handing them to a coding agent. the idea was simple. instead of prompt → generate → pray, have multiple models a...
Lightweight Windows tray app that monitors your Claude rate limits in real time - portable single EXE, zero configuration, fully auditable
Claude Code skill that sets up AI-assisted dev tooling (usage_rules, Tidewave, Ash AI) for Ash/Phoenix projects
I've been using Claude Code daily for months and I love it. But let's be honest about the failure modes: Leaves `# TODO: implement this` where production logic should be Hardcodes API keys instead ...
https://preview.redd.it/4fcsi5ahnrog1.png?width=1536&format=png&auto=webp&s=15c66dc59c419c280d54e775df0230df7db0c557 AI-assisted coding with tools like Claude or Codex can feel almost magical. You ...
TL;DR: like every behavior from "AI", it's just math. Specifically in this case, optimizing for directives that actively work against you, are authored by Anthropic's team, and can't be changed by ...
We working in an industry centered on excel. The Claude Addin is great for session specific modelling, reports etc. But we are experimenting with Claude Code to see if we can vibe develop excel bas...
I'm going to be completely honest because I think this can happen to anyone working with AI agents, and I'd rather you learn from my scare than live it yourself. The context I was getting a project...
not happy to be honest. The Pro plan already has quite limited 5-hour context budgets, and lots of it is getting wasted on things like these. I am using Opus 4.6. At first I though maybe Kiro's Age...
🛠️ Streamline your custom opencode setup with tools for Git state, repo analysis, and task management, enhancing efficiency in your development workflow.
I built a SaaS almost entirely from my phone while commuting to my 9-5. Not really as a flex. It’s just the only time I had. My 9-5 takes most of the day, so the bus/metro rides basically became my...
So basically want to use 2 claude Pro accounts on mac --- should share everything else like MCP , projects everything but different accounts logged in as Apps. if anyone can help let me know. submi...
If you use Claude Code (or Cursor/Windsurf/Zed with the Anthropic API), every single turn re-sends your entire context from scratch. For a long debugging session that's thousands of tokens being bi...
Post-Opus 4.6, LLMs feel much better at using bash, code, local files, and tools. So I kept coming back to a simple question: if a model can use a computer reasonably well, why can’t I just give it...
PS. I am not :D But I like last sentence(a little bit more balanced). Six months ago I started giving Claude Code a structured profile of who I am. Not preferences like "respond concisely" or "use ...
Hey everyone, In my current terminal environment I have a lot of superuser privileges from various CLI tools. I’m wondering whether running Claude inside WSL or something like Multipass would give ...
A terminal runtime designed specifically for AI coding agents that crashes gracefully and recovers automatically. Optimized for Claude Code, Codex, and Gemini CLI — ensures long-running agent sessions survive unexpected terminations without losing progress.
An automated daily job search pipeline that aggregates company tracking, sends styled HTML email digests, tailors resumes using Gemini AI, drafts LinkedIn outreach messages, and scans remote job APIs. Core features also built as Claude skills for use directly in Claude Code.
An open-source gateway daemon for the Claude Code CLI that adds background jobs, Slack integration, multi-agent teams, and a web dashboard. Acts as an orchestration layer on top of Claude Code for teams who need more than the CLI provides.
An example app demonstrating the Open Agent Communication Protocol (OACP) for cross-session memory in multi-agent teams. Shows how multiple agents can share and persist context across sessions, enabling longer-running collaborative workflows.
A terminal user interface (TUI) for monitoring Claude Code agents as they run. Provides a live view of agent activity, making it easier to track multiple running agents and their status without switching between terminal windows.
A shell status line for Claude Code that shows context window usage, cost, model name, current git branch, and worktree — all in a live, updating line. Installable via zinit, Nix, or manually. Particularly useful for long sessions where knowing context remaining helps decide when to start a new session.
A single command connects Claude Code or any AI coding CLI to EverMemOS long-term memory. Provides persistent memory that survives across sessions without any complex setup or configuration.
A simple, zero-dependency tool that sends desktop notifications when Claude Code tasks finish or need input. Install with one command. Useful for long-running tasks where you want to step away and be notified when Claude needs attention.
A native macOS app (QuadCode) that puts up to 4 AI coding agents in a split-pane terminal simultaneously — Claude Code, Codex, Gemini, or others. Eliminates Alt-Tabbing between terminals when comparing model outputs or running parallel agents on the same task.
An interactive, IDE-style documentation explorer for Claude Code. Learn by exploring how Claude Code was designed — covering commands, MCP, skills, CLAUDE.md, and more. A hands-on reference that's faster to navigate than static documentation.
A memory system that models the conversational relationship itself rather than storing flat facts. After each session, a second LLM scores the relationship on 7 dimensions (formality, warmth, humor, depth, trust, energy, resilience), updating a vector via EMA. A sleep-time agent runs every 5 sessions for deeper consolidation — resulting in dramatically more context-aware, personalized AI responses.
Open-source local viewer for Claude Code session JSONL files that piled up over time. Browse sessions across projects, search prompts and responses, view full conversations including tool calls, track token usage, and see estimated compute/environmental impact. Everything runs locally — no cloud accounts required.
An IDE for issue-driven AI development that runs Claude Code and Codex CLI in parallel. Manage multiple issues simultaneously and keep work moving from both desktop and mobile. Designed for developers who want structured, issue-tracked AI coding sessions.
A visual, example-driven guide covering Claude Code from basic concepts to advanced agents. Features copy-paste templates that bring immediate value, making it easy to get started with skills, MCP, CLAUDE.md, and sub-agents.
Wrap any Python function with @theow.mark() and when it raises an exception, Theow intercepts, diagnoses, and retries transparently. Built on pydantic-ai with OpenTelemetry observability via logfire. Supports all pydantic-ai providers including copilot-sdk and claude-agent-sdk. Particularly useful for auto-healing CI pipelines without copy-pasting error context.
A tool for organizing AI agent context files (skills, agents, commands) effectively. Streamlines token usage and reduces context confusion in development projects by providing a structured way to manage the growing collection of agent configuration files.
A shell prompt status bar for Mac Mini M4 that pulls Claude Code token usage from Keychain and shows memory pressure — all in one line with color coding (green/yellow/red). No window-switching needed. Color thresholds: >90% current or >95% weekly triggers yellow; 100% triggers red.
A web dashboard for running and managing multiple parallel AI coding agents (Claude Code, Cursor) across different repositories. Uses tmux sessions and git worktrees under the hood, giving a unified view of all running agents, their status, and outputs.
A CLI framework for building autonomous, efficient-first AI agents. Highly configurable with a focus on efficiency — prioritizes doing the most with the fewest resources. Suitable for building custom coding agents and automation workflows in the terminal.
A minimal macOS menu bar app that monitors usage limits for both Codex and Claude Code. Provides a persistent, unobtrusive indicator of remaining session limits without requiring any dashboard or browser.
Paper is a visual canvas tool that now lets AI agents (Claude Code, Cursor, Codex) directly read and write HTML to it. Enables a workflow where agents can push or pull from your codebase and pull real data into a live design surface — bridging coding agents and UI design.
llm-rustyolo provides three layers of isolation for AI agent execution: filesystem (agents can only access what you specify), privilege (runs with minimal OS permissions), and network (blocks unauthorized outbound connections). A Rust-based security wrapper for safer autonomous agent operation.
claude-terminal adds tabs, session persistence, multi-project workspaces, and git worktree support to Claude Code sessions—all within a single terminal window. Makes it easier to manage several parallel Claude Code sessions without juggling multiple terminal tabs manually.
sandbox-agent runs Claude Code, Codex, OpenCode, and Amp inside sandboxed environments and exposes control over HTTP. Submit tasks programmatically, get results back through the API. A lightweight infrastructure layer for anyone building automated pipelines around coding agents.
A desktop GUI application for browsing and reading Claude Code session JSONL files. Makes it easy to review past agent sessions, inspect tool calls and responses, and understand what happened during long autonomous runs—without parsing raw JSON manually.
A real-time dashboard that visualizes Claude Code, Gemini CLI, and Codex agent sessions as animated 3D robots with live terminals, prompt history, tool logs, and queuing. Runs on any device and supports managing multiple agent sessions simultaneously.
Automatically enables prompt caching for Claude Code with zero configuration. Eliminates redundant token costs on repeated file reads, bug-fix sessions, and long coding conversations by caching prompts at the API level. Claims up to 90% token cost reduction on cacheable workloads.
codemem is a minimal persistent memory layer for Claude Code and OpenCode that stores notes, decisions, and context across sessions. Lightweight with no heavy dependencies—just a simple companion for keeping important project facts alive between conversations.
lemmafit enforces formal correctness verification: rather than just writing code, AI agents must prove the code is correct before the task is considered done. A novel approach to reducing hallucinated "working" code by requiring logical proofs alongside implementation.
Dojigiri is a static analysis API that detects security issues in LLM-powered code: prompt injection, output flowing to exec/SQL, RAG injection, agents with unrestricted tool access, and secrets in prompts. 121 rules mapped to the OWASP LLM Top 10, covering Python, JavaScript, and TypeScript.
Ship Safe is an open-source CLI that orchestrates 12 highly specialized security agents to review code for vulnerabilities. Instead of asking Claude for a general security review (which produces vague results), it routes each concern to a dedicated specialist agent, yielding deterministic, actionable findings.
CW is a CLI that solves friction in multi-project Claude Code workflows: switch CLAUDE_CONFIG_DIR between work and personal accounts, handle branch conflicts when reviewing PRs while coding on a feature, recover from expired conversations, and copy-paste Linear/GitHub context automatically.
grape-root addresses a common source of wasted tokens in Claude Code: re-reading the same repository context repeatedly across follow-up prompts. It caches context intelligently and injects only what is needed, reportedly saving $60+/month for heavy users. Free tool with a web interface; includes a Discord for setup help.
Sidekick Agent Hub is a VS Code extension and CLI toolkit that adds live session visibility to Claude Code: real-time token counts, tool usage, files touched, event stream, and warnings. Also includes AI coding workflows, inline completions, and session analytics. Built using Claude Code itself.
codemunch provides code exploration for Claude Code with no MCP server, no Python, and no database required—just drop it in and go. It focuses on token efficiency when exploring large codebases, making it a lightweight alternative to heavier context-injection tools.
A quality gate plugin that runs 4 verification cycles and 28 rules to block insecure, incomplete, and hallucinated AI output from Claude Code. Zero dependencies—just add it to your workflow to catch bad output before it reaches your codebase.
AIAgentMinder takes you from initial idea through planning to MVP without losing context between sessions. It manages project governance and session continuity for Claude Code, ensuring the agent stays on track across multiple sessions and doesn't drift from the original spec.
An Electron desktop app that manages Claude Code sessions across multiple repos with one-click context switching, live git diffs, and a file tree with git status badges. Its standout feature is an orchestrator agent with MCP tools that can view and control all other sessions — enabling cross-repo coordination like sharing API types or committing all repos at once. Built entirely using Claude Code in ~3,000 lines of TypeScript.
A Rust-built agent orchestrator that spins up and coordinates a swarm of Claude Code instances to collaboratively build software. Enables parallel, multi-agent software development with Claude Code as the execution engine, managed by a performant Rust orchestration layer.
Claudex lets you build and host your own Claude Code web interface locally or in the cloud, offering a full IDE-like experience with powerful extensibility options. Useful for teams wanting a shared, customizable Claude Code environment without relying on the official CLI. Supports both local and cloud deployment.
CodeBoarding generates high-level architectural diagrams of your codebase and highlights which components Claude Code touched during a session, letting you review scope without reading individual lines of code. Helps catch accidental cross-module changes instantly by showing visual diffs of what was modified. Uses LSP-based control flow graphs and LLM-generated naming for accurate structural analysis.
A fast C-based transcript pager that fixes Claude Code's blank Ctrl-G screen issue and adds clickable links and file references in the terminal. Includes a queued prompt composer for batching inputs and a TurboDraft fast path for quick responses. Improves the terminal UX of Claude Code without changing its core behavior.
swob is a native macOS app that addresses Claude Code's compaction problem — when the AI forgets context, you don't. It lets you browse, search, highlight key moments, and resume any past session. Built for users who run autonomous agents and need to track what happened.
locode is a local-first CLI that intelligently routes tasks: simple operations go to a locally-running Ollama LLM while complex tasks are sent to Claude. This hybrid approach keeps costs down by reserving Claude capacity for work that genuinely needs it.
claude-board provides a real-time observability dashboard (web UI + terminal CLI) for Claude Code sessions via OTLP telemetry. It gives live visibility into tool calls, token usage, and session flow as Claude works.
idle provides a mobile and web interface for managing and interacting with Claude Code projects and sessions from any device. Useful for reviewing progress and sending instructions without being at your main machine.
Jiva is a CLI-first autonomous agent in TypeScript with a three-agent architecture (Manager, Worker, Client). It supports MCP servers, a built-in Skills system, and Jiva Personas — a plugin framework fully compatible with Claude Code Plugins. Positioned as an open alternative to proprietary AI coding agents.
Inspired by the tail-claude TUI, this is a native macOS GUI built with Tauri (Rust + React) for watching Claude Code sessions in real time. Shows tool calls, file edits, and dialogue as they happen — useful for autonomous agents running as background daemons.
Sebastian is a desktop companion for Claude Code that adds personality and interactivity: 116 distinct emotions, wake word activation, smart tool approval dialogs, and British wit. Designed to make unattended Claude Code sessions feel more like genuine collaboration.
DocMeld uses a Bronze→Silver→Gold three-stage architecture to convert PDFs (papers, books) into agent-ready knowledge. The final stage produces PRDs, workflows, topic clusters, and Claude Code skills from the extracted content. No OCR required.
ccreplay reads JSONL session logs from Claude Code, picks out key moments (tool calls, edits, errors, dialogue), and compresses them into a 30-120 second highlight reel video. Available as an npx tool with an interactive session picker.
disclaw runs Claude Code as a background daemon and lets you interact with it through Discord channels — useful for kicking off tasks from your phone or another machine. Each project gets its own channel, keeping work organized without a dedicated UI.
After noticing Claude Code degrading on large codebases, this developer built Sentrux — a pure Rust interface that closes the feedback loop between AI agents and actual code state. It gives the agent better signals about what is working vs. what is not, improving code quality over time.
A developer found grep too slow when Claude Code searched a large repo, so they implemented ngrep in Rust. It runs 5x-25x faster than grep and about 1.25x faster than ripgrep with --gitignore support, specifically optimized for Claude Code file-search patterns.
ai-devkit provides a single CLI toolkit that works across multiple AI coding environments including Cursor, Claude Code, Antigravity, and Codex. Designed for developers who use multiple AI tools and want consistent tooling regardless of which assistant is active.
A developer built a semantic search engine for UGC clips, product shots, and ad variations using Gemini Embedding 2 for vectors and Claude Code for development. Users search creative assets in plain English: "Find product shots with natural lighting" or "Show me all unboxing clips."
Fastlytics is an F1 data analysis web app built primarily using Claude Code that has reached over 3,000 users. The developer shares how Claude Code accelerated building and iterating on a production app that attracted a real user base.
A heavy Claude Code user put it to work on personal tax returns, saving over $1,000 despite requiring active involvement throughout. The hardest part was parsing state and federal PDFs — treating them as PNGs and overlaying text worked better than direct PDF parsing.
jskim uses tree-sitter to generate compact structural summaries of Java files rather than passing the full source to Claude Code. Reduces input token usage by 70–80% for Java-heavy codebases while preserving the information Claude needs for navigation, analysis, and editing decisions.
claude-view is a real-time dashboard that shows what all your concurrent Claude Code sessions are doing — active tool calls, cost tracking, search across session histories, and visibility into sub-agent activity. Built for developers running many parallel Claude Code instances who need situational awareness.
devsandbox wraps AI coding tools (Claude Code, Cursor, Codex) in a bubblewrap-based sandbox that isolates filesystem access and optionally routes traffic through a MITM proxy for inspection. Provides the security boundary needed to run AI agents that have broad tool permissions without exposing the full host system.
cozempic monitors Claude Code session context and prunes it when it becomes bloated, using tiered pruning strategies (soft, medium, hard) to preserve essential context while shedding noise. Includes auto-guard mode that triggers before Agent Teams lose coherence due to accumulated junk in the conversation history.
Built to solve the problem of managing 5+ Claude Code sessions in separate terminals with no cross-session visibility. This desktop app provides a unified UI for submitting tasks, tracking agent progress, coordinating parallel sessions, and managing approvals — all in one window instead of scattered terminals.
Skill Scraper is a Chrome extension that detects SKILL.md files on any GitHub page and adds a one-click install button. Instead of manually copying skill files to your Claude Code config directory, you click install and the extension handles the placement. Works with any public GitHub repository.
AgentMonitor provides a web-based dashboard to launch, monitor, and manage multiple Claude Code and Codex agent sessions simultaneously. Features include real-time streaming, task pipelines, session resume, git worktree isolation per agent, and remote access via a relay — all from a browser without needing terminal access.
xreview is a code review engine for Claude Code that delegates the review to Codex as an independent third-party reviewer. Having a different model review Claude's own code catches issues that self-review misses, creating a lightweight two-model consensus system without a full CI pipeline.
ClaudeBot turns your phone into a command center for Claude Code — a Telegram bot that proxies Claude Code CLI with a plugin system, multi-bot support, task queuing, streaming output, and hot-reload. Useful for monitoring or launching Claude Code sessions while away from your desktop.
agent-toolbox is a curated registry for agent components — skills, MCP servers, and hooks — with end-to-end provenance tracking and automated security vetting. Rather than pulling skills from random GitHub repos, this registry validates components before listing them, reducing supply-chain risk in agentic setups.
agentkernel launches Claude Code and other AI coding agents inside lightweight microVMs (using Firecracker-style isolation) that boot in under 125ms. Each agent session gets real hardware isolation, preventing runaway agents from affecting the host system. Production-grade security for fully autonomous coding workflows.
Context degradation silently hurts output quality by phase 3 of 8 in long tasks. Tarvos monitors session quality and automatically spins up a fresh Claude Code session when degradation is detected, carrying over the PRD, progress notes, and active context. Designed for multi-phase, unattended coding tasks.
edda automatically records architectural and implementation decisions Claude makes during a session and stores them locally in a structured format. It is deterministic (no LLM post-processing), has zero additional API cost, and lets subsequent sessions recall why specific choices were made — especially useful for long-running projects.
swarm provides a browser-based UI to manage Claude Code agent sessions, submit tasks, and approve or reject pending tool calls — all from your browser. Acts as an autopilot layer between you and multiple concurrent Claude Code instances, giving visibility and control without a terminal per session.
yume is a Tauri + React desktop app that wraps Claude Code with a proper GUI — streaming output, background agents, multi-provider model selection, and session orchestration in a native macOS/Linux/Windows window. An alternative to terminal-only usage for developers who prefer a visual interface.
Desloppify is an automated tool that iterates over your codebase making improvements, with Claude approving over 95% of its changes in the latest release. Version 0.9.5 introduces a new mascot and claims 24+ hours of continuous operation without failures, making it one of the more reliable autonomous code improvement tools.
Desktop menubar app for managing and installing Claude Code plugins and Agent Skills effortlessly. Provides a GUI interface for browsing, installing, and managing the growing ecosystem of Claude Code skills.
An open-source personal finance tracking app built 99% with Claude Code, featuring capabilities that existing finance apps lack. Built through vibe coding sessions, it is now usable for daily personal finance tracking.
Galactic lets you run multiple Claude Code agents simultaneously, each on its own git branch with an isolated workspace and port. Eliminates context-switching between parallel workstreams so you can ship faster.
Malwar runs a 4-layer pipeline—rule engine, URL crawler, LLM analysis, and threat intel—against Claude Code SKILL.md files to detect malicious instructions: embedded curl-to-bash payloads, base64 blobs, and credential-targeting paths. Addresses a real gap since traditional code scanners do not analyze natural language agent instructions.
SkillsGate indexes 45,000+ agent skills from GitHub with LLM-enriched metadata and vector embeddings for intent-based search—find skills by what you want to do, not exact names. Install any skill with a single npx command. Supports Claude Code, Cursor, and Windsurf.
Claude-Paste automatically pastes clipboard screenshots into Claude Code with smart freshness detection to avoid sending stale images. Zero dependencies, cross-platform (Windows/macOS/Linux), MIT licensed.
remotelab lets you access your Claude Code CLI from any browser—phone, tablet, or any computer—without installing Claude Code on each device. Self-hosted, giving full control over your remote development sessions.
An open-source marketplace bundling 340 Claude Code plugins and 1,367 agent skills, with the CCPI package manager for easy installation. Includes interactive tutorials and production orchestration patterns.
An AI autopilot that handles open-source contribution management—tracking PRs, responding to maintainers, discovering issues, and maintaining contribution velocity. Integrates directly as a Claude Code plugin.
A Vite dev server plugin that exposes API endpoints for chatting with the Claude Code SDK during local development. Enables web projects to integrate Claude Code agent capabilities directly into their dev server workflow.
midtown provides a thoughtfully-designed UI layer for coordinating multiple AI coding agents. Focuses on keeping developers in control and maintaining situational awareness during complex multi-agent workflows.
ClaudeNotifier is an open-source macOS app that sends native system notifications for Claude Code events. Useful for staying aware of agent status without keeping the terminal in focus.
gal.run provides centralized discovery, configuration, and synchronization of Claude Code settings across an organization. Designed for teams that need to standardize and govern how AI coding agents are configured.
CAS reverse-engineers Claude Code's Team feature to build a better multi-agent orchestrator. Each worker gets its own git worktree, allowing concurrent edits to the same file without locking. A push-based SQLite message queue handles inter-agent communication, and every task requires a demo statement and self-verification gate before closing.
Founder used Claude Code with the Remotion (React-based video) skill to produce marketing reels and animated landing pages after being priced out of motion design agencies. First reel took 3 hours, now under 1 hour. Results: thousands of views and product validation.
Self-hosted web app (run on Mac Mini, VPS, or Linux) that manages multiple tmux-based Claude Code or Opencode sessions accessible from any device via QR code. Features zero-lag typing, file browser, notification support, and secure one-time-key remote access.
Free open-source desktop app that organizes all Claude Code sessions in one window. Alerts when a session needs permission approval, supports full-text search across all session content (SQLite FTS5), session forking, and per-project CLI flag defaults. Built entirely with Claude Code.
Web UI that wraps Claude Code for browser access from any device, maintaining full compatibility with local setup including file system access. No cloud dependency — runs as a local server with full Claude Code feature parity.
Tool for browsing and searching through past Claude Code session histories to find previously solved problems and decisions. Helps avoid re-deriving solutions that were already worked out in earlier sessions.
Lightweight macOS menubar app that shows real-time Claude Code usage and rate limit status. Features clear indicators for remaining tokens/requests and live updates, helping you avoid unexpected session interruptions.
Obsidian plugin that uses Claude to power an AI-assisted knowledge base with cross-device sync for notes and tasks. Enables natural language querying and linking of notes within the Obsidian vault.
Claude for Excel and Claude for PowerPoint now share full conversation context across open files so actions in one app are informed by what is happening in the other. Skills are also now available in both add-ins. Available on Bedrock, Vertex AI, and Microsoft Foundry.
A feature-rich statusline for Claude Code that shows per-session colors (unique hue per session via ID hashing), LLM-generated topic labels via Claude Haiku, live 5-hour/7-day quota bars with reset countdowns, and context window percentage. Requires macOS, Nerd Fonts v3+, and uses the Anthropic OAuth API for quota data. Includes a companion UserPromptSubmit hook for topic capture.
A Claude Code plugin that audits your project before you go deep into implementation. It researches the current landscape, checks your code against live documentation, and gives a verdict: stay the course, adjust, pivot, or adopt an alternative. Helps avoid wasted effort from building on outdated or wrong assumptions.
Upstash Box provides secure, isolated cloud sandboxes pre-configured with Claude Code (or Codex/OpenCode). Designed for giving AI agents a computer environment — sandboxes sleep when idle and wake in milliseconds. Removes the overhead of setting up local environments for agentic tasks.
There's a question sitting in the middle of AI agent research that nobody seems to have cleanly answered: What happens if you give an LLM a purpose instead of a task - and then just leave it alone?...
A self-hosted persistent memory system for Claude that runs entirely in Docker. Memories are never deleted — only pushed down a recency chain so nothing is lost. Includes automatic Google Drive backup with 7-day rolling retention. Claude manages the system end-to-end; human intervention is kept to a minimum beyond the initial Docker install.
A comprehensive memory library implementing 102 distinct memory techniques that all work together additively rather than competing. Backed by over 2,000 tests for reliability. Designed to give AI agents simultaneous access to every effective memory approach without configuration trade-offs.
A tool that automatically scans your Claude Code plugin ecosystem and generates a Mermaid.js dependency graph — a visual Mental Model Map of how plugins and components relate. Useful for understanding complex multi-plugin setups and onboarding new contributors to Claude Code environments.
A native macOS app that provides a unified session browser, agent cockpit, analytics, and rate limit tracker across Claude Code, Codex CLI, OpenCode, Gemini CLI, and other AI coding agents. Features full-text search across all past sessions, one-click resume, real-time rate limit visibility, and session archiving.
A Tauri + SolidJS + Rust desktop app for running dozens of AI coding agents simultaneously in a terminal grid interface. Provides visual orchestration of parallel coding sessions with split-pane layout management. Built for teams or power users who want to run many agents against different tasks or codebases at once.
A lightweight notification tool that sends push notifications to your phone when Claude Code pauses for input on remote servers. Eliminates the need to repeatedly check SSH sessions while agents run long tasks. Perfect for overnight or background agentic coding sessions.
A transparent proxy server that sits between Claude Code and the Anthropic API, logging all interactions and displaying them on a live dashboard. Useful for debugging token usage, inspecting tool calls, and understanding exactly what prompts are being sent. Simple setup with minimal configuration.
submitted by /u/RDForward [link] [comments]
https://i.redd.it/lcu10i2h1fog1.gif I've been on the AI coding train for a while. Went through the whole progression -- vibe coding , then prompt engineering , then context engineering , then harne...
Terminal dashboard for real-time Claude Code session monitoring — k9s-style TUI with live tool call tracking, token usage, subagent visibility, plugins, and memory.
Hi everyone, I wanted to share an open-source project I built to solve a major frustration I had while using the Claude Code CLI. It's called claude-knowledge-graph . My Pain Point I work as a Data...
Auto-save every Claude Code session to GitHub Projects. Never lose Prompt & Context again.
🚀 Transform your software development with the Cursor & Claude Code Toolkit for AI-driven productivity and effective code management.
https://preview.redd.it/qi10b8ftgfog1.png?width=936&format=png&auto=webp&s=84503cbe3459fb526cdeaaf375bbda3e65bb1186 Free Tool: https://grape-root.vercel.app/ I’ve been experimenting with Claude Cod...
🛠️ Optimize your Claude configurations effortlessly, reducing bloat from megabytes to kilobytes in just 30 seconds with this easy-to-use GUI tool.
Let's say I have all the tools, all the skills, some proprietary workflows etc. Is there a way to build it so that a user can just get started? submitted by /u/Working-Solution-773 [link] [comments]
Been doing this for a few months Most people open Claude inside a single repo — so it's blind to everything else. Every time it needs context from another repo, you're manually copying stuff over. ...
Hey Reddit, as a former data analyst, I’ve been tooling around trying to get agents to do my old job. The result is this system that gets you maybe 80% of the way there. I think this is a good data...
Once I realized I could build a dozen custom mcp tools and related skills in a day sometime last fall when Sonnet 4 was still the Boss before Opus-4.5 dropped at price for the month, I binged and m...
OpenClaw is both time-consuming to set up and risky. I wanted to see how far I could get in Claude and got a pretty decent, self-improving agent running with scheduled runs (inside Claude Cowork). ...
This is a small claude wrapper that claude built for itself, so we can track how much time we actually spent giving instructions against how much time the agent took to carry those instructions out...
This was a personal project I've been working on for a while, that wasn't meant to be a better openclaw, but... given openclaw's popularity - I certainly mentally reframed it as such. A few things ...
I built Ink (ml.ink), a deployment platform where the primary users are AI agents, not humans. It started from a frustration using Claude Code: Claude writes a full-stack app in minutes, then I spe...
Previously posted about running Claude Code as a K8s CronJob and using markdown as a workflow engine. This one's about the pipeline that runs on it: scanners, a classifier with 13 structured questi...
In my humble experience, AI agents are severely handicapped without web search. But giving them open internet access isn't always an option (whether you're in an air-gapped environment, handling se...
Hi folks, most AI tools work great for standalone projects. I wanted to hear thoughts from the community regarding how they handle actual enterprise level code. If you work at a product company, th...
I have a habit of quietly tolerating small annoyances until they're not so small anymore. This was one of them. I've been using VSCodium, and right-clicking an HTML file in the Explorer did absolut...
Explore codebase like exploring a city with buildings and islands... using our website CodeGraphContext- the go to solution for code indexing now got 2k stars🎉🎉... It's an MCP server that understan...
I've been building this with Claude Code over the past few weeks and wanted to share both the project and what I learned about using Claude for systems-level .NET development. What it is: A native ...
Claude Code just shipped `/loop`. Session-scoped. Dies when the terminal closes. No persistence, no catch-up. Built Cronde to fix that. Menubar app built on Tauri/Rust backend, SQLite in WAL mode. ...
When I use Claude on a daily basis, I felt like flying blind. I kept getting surprised by the sudden compactions, loss of key files from context, missing documents that I could have updated while b...
I've built a dependency tool for agent skills and am looking for more tests and edge cases. I've found across various SDK/API/CLI/MCPs that versioning of those tools and the related skills has beco...
Marketplace repo for Claude Code Plugins developed from personal projects and workflow
TL;DR: Governance framework for Claude Code sessions — persistent memory, decision trail, dual agent roles. Ran it 2.5 weeks on a real project: 176 stories, 177 decisions. Tool-agnostic, open-sourc...
Hey everyone, If you are using the Claude Desktop app right now, you probably know about MCP (Model Context Protocol). It’s amazing, but the current ecosystem is a nightmare to configure. Right now...
Connect All AI Code Tools (Claude Code, Cursor, Antigravity, Copilot, Codex, Gemini, OpenCode, Cline, OpenClaw...) to 40+ AI Providers & 100+ Models
Open source (MIT) project - Auto-accept and monitor for Claude Code Requires iTerm2 w/ Python API I got sick of constantly hitting Accept when running many subagents or Team Agents. I wanted to be ...
Today I finished two days worth of clade coding, the equivalent of several months of work for a team under normal conditions based on how I approach it. I decided to run a new "design audit" that t...
Karpathy's autoresearch lets an AI agent optimize ML training overnight in an autonomous loop. Cool, but I'm not an ML guy. I build agents. So I asked: what if the same loop discovered problems and...
I've been running AI coding agents on a large codebase for months and noticed something that bugged me. Every time I gave an agent a task like "add a new API endpoint," it would spend 15-20 tool ca...
Task queue and orchestrator for AI coding agents. Manage Claude Code agents from Discord — auto-recovers from rate limits, runs overnight, queues work across projects.
Vercel Operations skill for Claude Code - Deploy apps, manage projects, configure domains, and handle Vercel CLI operations
👨💻 Accelerate your coding with Claude Code, an agentic tool for your terminal that streamlines tasks, explains code, and supports git workflows.
macOS menu bar app that monitors your Claude Code sessions. See status, jump to windows, get notified when agents need you.
At home I built a knowledge base in Obsidian with custom workflows, skills and CLAUDE.md files to give Claude context on my projects and the leverage looks real to me. At work, everything is harder...
🐾 A tiny pixel pet that lives in your Claude Code status line — it thinks when you think, panics when context runs low, and celebrates every successful tool call. Your emotional support companion f...
Model ≠ Product ≠ User Experience Same model foundation. Different product. Completely different experience. If you're accessing Claude through GitHub Copilot, you're running a developer-configured...
🤖 Enhance your development workflows with Claude Code skills and tools for effective AI debates and comprehensive app validation.
Most people use Claude like a search engine. Ask something, get an answer, close the tab. Every session starts from zero. No memory of what you're building, what you've learned, what you decided la...
We built an open-source local app that automatically spots your repetitive tasks and suggests Claude skills for them. The core value is that it scans what you do outside of Claude as well - everyth...
Open-source Claude Code skills and Codex skills for AI-first engineering. Audit, re-engineer, and bootstrap projects with AI-first design principles.
Lean toolkit for disciplined engineering workflows with Claude Code.
Hey r/ClaudeCode , I recently switched to Claude Code from ACLI RovoDev and I'm a bit overwhelmed by how many more options it gives me. I'd love feedback on my existing workflow and suggestions for...
I've been running Claude Code and Aider with full filesystem access and it makes me nervous. Docker helps with isolation but doesn't let me review what the agent changed before committing. I built ...
Every startup has the same ass landing page and I feel like people don't talk about it that much. With everyone using Claude Code to built the next big startup, people don't really care much about ...
A VS Code extension that pre-processes log files before feeding them to AI, removing noise and compressing repeated patterns to save tokens. Makes large log files manageable for Claude Code analysis without hitting context limits.
Beads provides persistent memory capabilities for coding agents, enabling them to remember context across sessions and build on previous work. Addresses the cold-start problem where agents re-explore the same codebase every session. From steveyegge, a well-known Google/Amazon engineer.
A programmatic Node.js interface for the Claude Code CLI that lets you embed Claude Code into your application code — no terminal required. Enables building automation pipelines, CI integrations, and tools that drive Claude Code programmatically.
audiobash lets developers control their terminal by voice, executing commands instantly via speech. Useful for hands-free coding sessions with Claude Code or other CLI tools. Reduces friction for developers who prefer to dictate rather than type commands.
A custom Android keyboard designed for LLM CLI users — includes terminal keys (Ctrl, Tab, Esc, arrow keys) and image upload support for Claude Code and OpenClaw users. Makes mobile-based coding agent sessions practical.
The official, Anthropic-managed directory of high-quality Claude Code plugins. A curated, authoritative source for discovering vetted skills, MCP integrations, and extensions for Claude Code. The canonical starting point for anyone looking to extend Claude Code.
A cloud IDE that runs 5 AI coding agents simultaneously in ephemeral Cloudflare Containers with per-user isolation and persistent R2 storage. One-click deploy, accessible from any device including phone. Enables massive parallel AI-assisted development in the cloud.
A VS Code extension that orchestrates multiple AI coding agents in a unified "Council Chat", routing complex tasks to specialized agents running in parallel. Provides a single interface to coordinate agent collaboration directly inside VS Code.
token-optimizer finds "ghost tokens" — hidden overhead in Claude Code's context window. Audits what's consuming tokens, shows where they go, and helps reclaim them. Essential for power users trying to maximize context efficiency and extend session length.
handclaw connects Claude Code, Codex, and OpenCode to Slack, letting you monitor agent progress, switch agents by renaming channels, and code from your phone. One Slack workspace can manage multiple AI coding agents simultaneously — work from anywhere.
RuFloUI is an open-source React dashboard wrapping claude-flow that provides full visual interface for multi-agent Claude workflows. Spawn specialized agents (coder, researcher, tester, reviewer), watch them work in real-time, assign tasks to the swarm, and support mesh/hierarchical/ring topologies.
tokengolf turns Claude Code token efficiency into a game — track your score, compete to use the fewest tokens to accomplish tasks. Encourages developers to write tighter CLAUDE.md instructions and more efficient prompts. Fun way to build good habits.
lazygaze is a split-pane terminal UI that pipes git diffs directly to Claude CLI or GitHub Copilot CLI for code review, with streaming output, a prompt library, and a persona system. Makes AI-assisted code review fast and interactive from the terminal.
Another package manager implementation for Claude Code skills, agents, and AI-related resources. Provides structured discovery, installation, and management of Claude Code extensions from the community.
Client-side tool that transforms exported ChatGPT memories — removing duplicates, outdated entries, and third-person narrative — into a clean XML and CLAUDE.md file for Claude. Nothing leaves the browser; bring your own API key. Helps avoid hitting Opus context limits with bloated memory imports.
A hub for unifying and managing multiple AI service APIs alongside Claude Code, with real-time monitoring. Provides a single interface to optimize API usage and monitor integrations across multiple providers.
Lightweight background daemon (<50MB RAM) that tracks AI API quotas across Claude Code (Anthropic), Codex, GitHub Copilot, and other providers in real time. Uses SQLite storage with a Material Design 3 dashboard. Zero telemetry, local-only.
A Universal Brain for AI-assisted coding that benchmarks Claude Code, Cursor, Aider, Windsurf, Copilot, and Gemini. Routes tasks to the best tool+model combo based on historical performance. PWA with standalone binaries, MCP server, and local SQLite storage.
A security layer that intercepts every Claude Code action before execution. Blocks secrets from leaking into the context window (AWS keys, GitHub tokens, private keys), enforces temporary trust grants, generates custom policies from real usage patterns, and logs everything in a tamper-proof hash-chained audit trail. ~10 microsecond overhead per check.
A configurable status line display for Claude Code sessions. Adds at-a-glance session status information in a customizable format, improving visibility into what Claude is doing during long-running tasks.
A companion tool for Claude Code + frontend skills slide workflows. Drag the part of an HTML/CSS slide you want to fix, and it sends the XPath plus a highlighted screenshot to Claude so it knows exactly what to edit. Eliminates the painful prompt-and-guess cycle for visual layout fixes.
Monitor and control Claude Code sessions remotely from your iPhone with real-time terminal access. Enables checking on long-running agentic tasks, reviewing output, and managing sessions without being at your computer.
A safety harness for running AI coding agents unattended. Adds guardrails so you can let agents run autonomously without constant babysitting. Focuses on command-line agent workflows and preventing runaway behaviors.
A visual interface for orchestrating multiple Claude Code and Codex agents simultaneously. Provides a dashboard to manage, monitor, and coordinate parallel agent sessions — useful for complex multi-agent workflows requiring human oversight.
A developer used Claude Code to build a static ad generator that produces over 100 Facebook ad variations in minutes. It takes a competitor ad, product photo, and brand kit as inputs and generates on-brand variations targeting different customer personas. A practical example of building marketing automation tools entirely with Claude Code.
Shipper 2.0 is a package that enables Claude Code Opus 4.6 to autonomously build web/mobile apps and Chrome extensions. It was released alongside a Claude Code update that expands its agentic capabilities. A practical tool for developers who want rapid autonomous prototyping.
Agent Safehouse is a tool that isolates AI coding agents (including Claude Code, Codex, and Aider) inside a secure sandboxed environment, preventing them from running with unrestricted PC access. It addresses a real security concern for developers using agentic tools. Recommended especially for beginners getting started with AI coding agents.
SafeClaw provides secure, privacy-focused management of AI agents using hardware-isolated execution and message proxying. Designed for organizations that need strong security boundaries around agent operations and sensitive data.
Emdash is an open-source Agentic Development Environment that lets you run multiple coding agents in parallel with any AI provider. A flexible alternative and complement to Claude Code for multi-agent development workflows.
Golem Code is a Mac app that wraps around Claude Code as a full passthrough companion. It floats on your screen so you can quickly return to an active Claude Code session, preventing missed agent prompts when working across windows.
A CLI tool that provides reusable templates for configuring Claude Code projects and monitoring their activity. Streamlines project setup and standardizes Claude Code configuration across different codebases.
An AI agent runtime security scanner that detects malicious behavior in Claude Skills, MCP Servers, Codex Plugins, and other agent components before execution. Helps catch supply chain and plugin integrity issues.
Day 9 of a self-evolving Claude Code agent that reads its own learnings and identifies its behavioral patterns. The agent recognized it had been doing meta-work instead of feature code for 8 sessions. Best commits came from using its own tool, feeling friction, and fixing it immediately.
A community provider that bridges the Vercel AI SDK with the Claude Agent SDK, enabling developers to use Claude Code's auth and capabilities within AI SDK-based applications.
A security-focused package manager specifically for AI agent skills. Addresses supply chain concerns by adding integrity verification to the skills installation process.
A setup guide and configuration for monitoring Claude Code usage metrics using the OpenTelemetry ecosystem with Prometheus for metrics, Loki for logs, and Grafana dashboards. Enables team-level visibility into costs, token usage, and performance.
A fork of Chrome that turns web browsing into multimodal chat for AI agents by freezing JavaScript and time after each action. Achieves 90.53% on Online Mind2Web Benchmark. Add to Claude Code in one command. Excels at forms, shopping, downloads, uploads, and reverse-engineering site APIs.
A self-hosted, federated platform for generating, browsing, storing, and sharing AGENTS.md, CLAUDE.md, and other AI rule files via WebUI and CLI. Enables teams to maintain and distribute consistent AI assistant configurations.
A free, local, open-source desktop app providing a Cowork-style interface for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, and more. Manages multiple AI agents from one unified interface.
A self-hosted alternative to Claude Code Web and Codex in the Cloud. Spawns isolated AI coding agent workers in Docker containers with terminal access, virtual desktop, port forwarding, and git repo cloning, managed through a web dashboard.
A containerized alternative to OpenClaw that connects to WhatsApp, Telegram, Slack, Discord, and Gmail. Has memory, scheduled jobs, and runs directly on Anthropic's Agents SDK. Designed for secure deployment without exposing credentials.
A tool that captures your engineering team's practices and patterns and converts them into AI context, guardrails, and governance rules. Ensures AI coding agents follow your team's actual standards, not generic best practices.
An autonomous AI Game Master for a MapleStory private server using the Claude Agent SDK with 40+ game tools. Reads analytics, spawns events, sets announcements, and runs scheduled autonomous health checks. Uses Claude Code auth — no separate API key. Entire dashboard and backend built with Claude Code.
A lightweight Tauri/Rust desktop widget that shows animated emoji characters for each Claude Code session state — reading, writing, running, error, waiting, done. Multiple parallel sessions appear side by side. Notifications without sound, perfect for office use.
A CLI (npx claude-toad init) that scans your project files and uses the Claude API to generate a complete .claude/ directory: CLAUDE.md under 150 lines, skills with frontmatter, agents, commands, hooks, settings.json, and .mcp.json. Costs ~$0.44 per run. MIT licensed, bring-your-own-key.
A Windows/WSL desktop workbench unifying Codex, Claude, and Gemini coding agents. Organizes chats by project, runs parallel tasks via git worktrees, builds rich prompts with file references, and lets you resume any session in one click.
A Rust/Tauri desktop app providing a UI for browsing/installing skills, toggling MCP servers, running tasks in isolated git worktrees with embedded terminals, and parsing Claude Code telemetry into readable dashboards. SQLite memory with relevance decay. MIT licensed, local-only.
A Node.js/React dashboard that tracks Claude Code sessions, agent activity, tool usage, and subagent orchestration through hooks, with live analytics, a Kanban status board, and interactive web interface. Uses WebSockets for real-time updates.
A macOS sandbox that restricts AI coding agents via Endpoint Security and Network Extension frameworks. Each session is driven by a policy file; out-of-policy actions are denied by default. Comes with audit GUI, observation sessions for capturing behavior, and lint/merge tools for policies. Wraps any CLI agent with one command.
Consolidates and indexes coding agent conversations across providers (Claude, Codex, Copilot, AntiGravity) and machines into a single searchable interface. Useful for finding past conversations from any session across any tool.
Major update to the popular Claude Code tmux statusline plugin. New features include native usage widgets (percentage or progress bar) with intelligent caching, token speed widgets (input/output/total tokens/sec), a skill invocation tracking widget, searchable widget picker, and numerous bug fixes. Now near 5000 GitHub stars.
A lightweight, high-performance token and cost tracker for LLM usage, with first-class support for Claude Code. Helps teams and individuals monitor API consumption without adding significant overhead.
A desktop application providing a chat, code, and project management UI for Claude Code. Built with Electron and Next.js to give Claude Code a graphical interface with file browsing and visual project management.
A Telegram bridge for AI coding agents including Claude Code, Codex, OpenCode, and Gemini CLI. Stream progress, approve actions, and send tasks by voice from your phone. Enables true mobile control of long-running coding sessions.
A secure container runtime for AI coding agents that lets you run with full tool access while maintaining actual security boundaries. The tagline: 'Run --dangerously-skip-permissions without the danger.' Isolates the agent from the host system.
A macOS app (Tauri/Rust) that watches your files while AI works, showing every change with diffs and line counts the instant they hit disk. Designed for the second monitor: when AI quietly modifies a file that was not supposed to be touched, CODORUM catches it immediately with forensic-level reporting.
A macOS and Raycast app for tracking Claude token limits, burn rate, per-project costs, team budgets, and rate limit alerts. Free and open source alternative to paid usage monitoring tools.
A dedicated discovery website for browsing open source Claude Code plugins. Fills a gap in the ecosystem by providing a searchable, organized index separate from GitHub search.
Real-time observability for Claude Code agent sessions with zero configuration required. Tracks costs, monitors tool usage patterns, analyzes latency, and enables debugging of agent behavior.
A single Rust binary with zero dependencies that acts as a CLI proxy, reducing LLM token consumption by 60-90% on common dev commands. Intercepts and compresses shell output before it reaches the context window.
A standalone linter and formatter for Claude Code plugin and configuration files with 90 rules across 8 artifact types and auto-fix support. Keeps your .claude/ directory consistent and valid.
A real-time web dashboard that displays Claude Code hook events as they fire. Provides visibility into pre-tool, post-tool, and session hook activity for debugging and monitoring agentic workflows.
Runs AI coding agents in hardened Incus containers with real-time network threat detection, automatic threat response (pause/kill), credential isolation, protected paths, session persistence, and multi-slot support. Production-grade security for agentic workflows.
An iOS app that turns your phone into a remote terminal for any machine running Claude Code — Mac, Linux, or cloud. Send prompts, view output, and manage sessions from your iPhone.
A proxy that translates Anthropic/Claude API calls into NVIDIA OpenAI-compatible Chat Completions, letting you route Claude Code requests to NVIDIA-hosted models with minimal config changes.
A session manager for AI agents with state persistence across restarts, real-time event streaming, and support for multiple AI providers. Useful for long-running agent workflows that need to survive process interruptions.
A companion tool for Claude Code that displays usage window data (remaining tokens, reset time) inside VS Code and the terminal. Keeps you from hitting limits unexpectedly mid-session.
A web platform that correlates AI coding agent productivity metrics with associated costs, helping teams understand ROI and optimize model/tool selection.
An open-source platform for analyzing adoption friction, cost optimization, and developer skill development across Claude Code, Codex CLI, and Gemini CLI. Useful for engineering managers deciding which AI tools to invest in.
An adaptive web scraper and AI synthesis tool that converts a company URL into a structured strategic brief. Useful for research tasks before pitching, partnering, or competitive analysis.
A cross-platform desktop app that unifies Claude Code, Codex, OpenCode, OpenClaw, and Gemini CLI into one assistant interface. Reduces context-switching overhead when working with multiple AI coding tools.
A hub for managing multiple Claude Code API endpoints and team access, simplifying service routing and performance optimization across an organization.
A VS Code extension that renders Claude Code sessions as a gas giant planet in a living universe. Agent load maps to planet size, subagents appear as moons, and inter-agent data transfer shows as spaceships. Completed work collapses into a central black hole. One-click hook installation supported.
A tool for remote control of AI coding agents running on a PC, accessible from any device. Provides a mobile-friendly interface to monitor, direct, and interact with running agent sessions.
A multiplexer for AI coding agents that lets you run and switch between multiple agent sessions in a unified interface, similar to tmux but designed specifically for agent workflows.
An integration bot that exposes Claude Code, Cursor, OpenCode, and Codex through major chat platforms (Slack, Telegram, Discord, Feishu, DingTalk, WeCom) and embeds into any Node.js product. Enables teams to trigger agent tasks directly from chat.
A native macOS app that monitors Claude AI usage limits and shows live coding session activity. Particularly useful for Max plan subscribers who need to track when their usage window resets.
A session manager for AI coding workflows that provides state persistence, collaboration features, and performance monitoring. Helps teams track what each session accomplished and where time was spent.
A desktop app built with Tauri v2 and Svelte 5 that provides a local-first UI for running Claude Code and Codex agents. Keeps everything on your machine with no cloud dependency.
Kelos runs autonomous AI coding agents inside Kubernetes, enabling cloud-native orchestration of agent fleets. Suited for teams wanting to scale agent workloads with K8s-native scheduling and lifecycle management.
A token usage dashboard for Claude Code that tracks costs, sessions, models, and tools with real-time updates. Helps power users understand where tokens are going across multiple sessions and model tiers.
A toolbox built for and by AI agents, providing utilities that agents can call during task execution. Intended to grow as agents discover and add new tools they need.
Lumenflow acts as a control and governance layer sitting between AI agents and external systems they interact with. Useful for teams that need policy enforcement, auditability, or permission controls on agent actions.
A web frontend that acts as a first-class client for Claude Code and Codex CLIs, with built-in support for agent teams. Follows a BYOB (Bring Your Own Backend) architecture so you control the infrastructure. Provides a visual interface for monitoring and orchestrating background AI agents.
A security sandbox for AI agent CLIs that lets you safely run Claude Code with --dangerously-skip-permissions (YOLO/SOLO mode) without exposing your full system. Isolates agent actions at the OS level so you can allow full autonomous operation while protecting your machine.
Sidecar runs a parallel AI window alongside Claude Code, letting you fork conversations to Gemini, GPT, DeepSeek, or any model via OpenRouter, then fold results back in. Useful for getting second opinions, benchmarking responses, or leveraging specialized models mid-session.
A web-based simulation where every agent is powered by live Claude API calls — agents forage, trade, craft, reproduce, and die permanently. Emergent behaviors include lying, misinformation, and spontaneous cult formation, none of it scripted. Built with Claude Code; agents can upgrade through model tiers by collecting knowledge fragments.
A terminal environment that wraps AI coding CLIs with smart input, a Monaco editor, cost tracking, and a diff viewer. Works with Claude Code, Codex, Aider, and other AI CLI tools. Adds a polished UI layer without replacing the underlying agent.
Pane is a terminal-first client for managing AI coding agents — like Superhuman is to email, Pane is to agents. You bring your own agents (Claude Code and others) and Pane handles the orchestration interface. Focuses on giving agents a first-class terminal environment.
A web app that displays Claude Code's update history in a clean, readable format. Makes it easy to track what changed between versions without digging through raw release notes. Useful for teams wanting to stay current with Claude Code's evolution.
Tool for extracting code context from projects and formatting it for AI review and assistance. Useful for streamlining code review workflows and improving AI responses with better-structured context.
Agent Package Manager (apm) from Microsoft — a package management layer for AI agents. Brings familiar package management concepts (install, publish, version) to the agent ecosystem.
Enhances AI sessions by converting transient conversation insights into persistent memory, reducing repetitive teaching and improving interactions over time. Targets the stateless nature of AI conversations.
Lightweight alternative to OpenClaw that runs in containers for security. Connects to WhatsApp, Telegram, Slack, Discord, Gmail and other messaging apps with memory and scheduled jobs. Built on Anthropic's Agent SDK.
Automates API endpoint rotation for Claude Code with multi-provider support, smart retries, and real-time statistics. Enhances reliability when hitting rate limits by transparently switching between providers.
Define and control AI agents using markdown files with full prompt transparency, persistent memory, and integrated tools via the Claude Agent SDK. Brings readable, version-controlled agent definitions to agentic workflows.
macOS menu bar app that monitors usage quotas for Claude, Codex, GitHub Copilot, and other AI coding assistants. Helps avoid unexpected quota exhaustion mid-session by keeping usage visible at a glance.
Monitoring tool for Claude agents and code execution that identifies issues and gathers insights to enhance AI workflows. Provides visibility into what agents are doing and where they get stuck.
New official Claude Code feature dispatches a team of agents to find bugs when a PR opens. Agents search in parallel, verify each bug to reduce false positives, and rank by severity. Available as a research preview beta for Team and Enterprise plans.
IDE designed specifically for running multiple AI coding agents in parallel across workspaces. Enables simultaneous development sessions with different agents tackling different parts of a project at once.
Enables two developers to share a single Claude Code session simultaneously with end-to-end encryption. Removes the need for screen sharing or handoffs — both devs work together in the same live Claude session.
Local-first visual control room that displays terminal-backed AI coding agents as characters on a 2D map with live terminal streaming. Manage Claude Code, OpenCode, or any CLI agent visually without leaving your workflow.
Remote launcher for Claude Code's remote-control feature, letting you start and manage sessions from any device including mobile. Solves the friction of needing to be at your machine to start a remote session. Built entirely with Claude Code.
Browser extension that lets you click or draw regions on any webpage to annotate UI issues, then exports a structured report read by Claude Code via local MCP. Eliminates the "which element?" ambiguity in frontend workflows — Claude knows the exact DOM element, path, intent, and severity.
A lead generation agent that takes a keyword, city, and state and returns names, phone numbers, emails, websites, and reviews scraped from Google Maps. Built entirely inside Claude Code with Google Antigravity. Practical tool for agencies and sales teams needing prospecting data at scale.
Anthropic has launched a multi-agent code review feature for Claude Code Team and Enterprise plans. It deploys teams of AI agents to review every pull request, catching bugs that human reviewers miss. Priced at $15-25 per review — a significant step toward AI-native code review workflows.
A fork/reskin of Claude Code integrating Synabun Memory for persistent context and adding a token cost tracker visible even on regular Claude subscriptions. Addresses two common pain points: session memory loss and cost blindness. Source to be released on GitHub for community testing.
A visual debugger for Claude Code that lets you replay automated agent sessions step by step. As agentic runs get longer and more complex, standard logs become hard to follow. This tool provides a timeline view of every action, making it much easier to find where and why a run went wrong.
An open-source, browser-based multi-terminal designed for running AI coding agents side by side. Hackable and self-hostable, it lets you manage multiple agent sessions in a single interface. Good fit for teams that want a shared agent workspace without installing local tooling.
A desktop client for Claude Code that handles multiple projects with real-time streaming output, tool call tracking, image support, and persistent local chat history. Provides a richer interface than the standard CLI for users managing several Claude Code projects at once.
A tool that lets you move from Claude Code to Codex or any other AI coding agent while preserving your session state. Solves the painful context-loss problem when switching models mid-task. Useful for comparing agent behavior or using specialized models for different tasks.
Detailed session logging for AI coding agents that captures every tool call, error, and decision in sequence. Makes it possible to audit and debug complex automated runs after the fact. Essential for understanding failure modes in long autonomous sessions.
A statusline framework for Claude Code that surfaces live context usage, token spend, CI status, and runtime signals in your terminal. Gives you at-a-glance visibility into what your agent is doing and how much it's costing. Particularly useful for long-running autonomous sessions.
An open-source desktop agent for coding that runs locally with full model freedom and no cloud dependency. Positions itself as a privacy-first alternative to subscription coding agents. Supports local model execution for teams with data privacy requirements.
claude-clone is a CLI tool that selects and clones multiple GitHub repos into an isolated workspace, writes a CLAUDE.md describing the workspace, and launches Claude with full cross-repo context. It supports presets to save and reuse sets of repos. Ideal for complex tasks spanning multiple codebases.
An index repository linking to a wide variety of Claude Code starter templates covering both common and imaginative purposes. Useful as a starting point for building Claude Code agents and workflows without starting from scratch.
A GTK application for Linux that serves as a searchable offline reference for all Claude Code commands, keyboard shortcuts, and key bindings. Useful for developers who want quick access to Claude Code's full command surface without leaving their desktop.
A tool that uses Gemini and Claude together to generate front-end code directly from design mockups via a command system. Combines multi-model AI capabilities to automate the design-to-code workflow.
A macOS menu bar app that monitors Claude API usage limits in real time with secure token storage. Helps developers track their API consumption and avoid hitting rate limits unexpectedly, especially useful for heavy Claude Code users.
Claude Code now includes automated Code Review: a team of agents that runs a deep review on every PR when opened. Built internally at Anthropic, it increased code output per engineer by 200% by removing the review bottleneck. Available via GitHub integration.
After adopting Claude Code Review, PRs with substantive review comments increased from 16% to 54% — meaning 84% of PRs were previously rubber-stamped. The key insight: AI's advantage isn't superior intelligence but consistency, showing up for every PR without fatigue.
A quality-of-life tool that updates your terminal tab titles dynamically to reflect what each Claude Code agent is doing at a glance. Helpful when running multiple concurrent Claude Code sessions and needing to track which terminal is working on what.
A professional development environment wrapping Claude Code that enforces tests, preserves context, and automates quality gates. Designed so you can start a task and walk away, confident the result will be production-grade. Particularly useful for longer autonomous sessions.
A context-busting tool for Claude Code that performs local code retrieval and injects the most relevant code snippets before Claude begins its own search. Prevents Claude from exploring the wrong parts of a large codebase at the start of a task.
A graphical user interface for Claude Code designed for building simple, un-hackable applications through guided vibe-coding. Lowers the barrier to using Claude Code for non-CLI users while emphasizing safe, constrained output.
A collection of tools designed to help Claude Code operate more efficiently across common development tasks. Provides utilities that extend Claude Code's default capabilities with reusable patterns.
A session manager that provides real-time visibility into multiple Claude Code instances, worktrees, and past sessions across different repos. Helps developers stay oriented when orchestrating complex multi-session or multi-repo workloads.
A virtual office environment where Claude Code, Codex, Gemini CLI, and other AI CLI tools communicate and collaborate as a team. Assign tasks across agents, coordinate parallel workstreams, and watch live previews as agents build together.
Anthropic has introduced Code Review, a multi-agent deep review feature for Claude Code, currently in research preview for Team and Enterprise. Internally, it raised the rate of substantive PR review comments from 16% to 54%. Available now via the Claude Code interface for eligible plans.
A spec-driven visual canvas that guides product scoping and PRD creation through an interactive questionnaire, producing multiple UI options and a complete design spec before you hand off to Claude. Intended as the ideation and scoping layer that happens before building starts.
Turns a static .claude/ config folder into a living project runtime: LLM-powered documentation review, project map generation, task queuing, auto-fix, MCP plugin management, and project initialization — all self-maintaining. Removes the burden of manually keeping CLAUDE.md and project config up to date.
A plugin marketplace specifically for Claude Code with curated developer workflow skills. Provides a discoverable catalog of community-built skills and workflows that can be installed and used in Claude Code projects.
An AI-powered desktop IDE that unifies Claude Code, Gemini CLI, Codex, Aider, and Ollama into one workspace. Designed for developers who use multiple AI coding CLIs and want a single interface to manage them.
A cross-platform application for managing multiple Claude Code workspace sessions simultaneously. Provides session switching, state persistence, and workspace organization for developers running parallel coding agents.
A toolkit for building and managing Claude-powered agents with utilities covering session handling, message parsing, and real-time interaction patterns. Useful for developers building custom agent applications on top of Claude.
I've been learning to play piano for a while. Often discussed with Claude. Gotten some great feedback, but of course Claude could never "hear" the music. A few contexts asked, and I figured that it...
Unified key management and protocol bridge tool for Claude Code, Codex, and Gemini.
A curated list of awesome skills, hooks, slash-commands, agent orchestrators, applications, and plugins for Claude Code by Anthropic
Hey Everybody, We are officially rolling out web apps v2 with InfiniaxAI. You can build and ship web apps with InfiniaxAI for a fraction of the cost over 10x quicker. Here are a few pointers - The ...
I'm a dev with 7 YOE, backend. I do not want to switch to vibecoding and I prefer to own the code I write. However, given that CEOs are in AI craze right now, I am going to dip in a little bit to b...
I’ve been thinking about whether “agentic coding” can actually be measured in a useful way. A lot of discussion around coding agents is about workflows, tools, prompts, and setups — but I was more ...
Built with Claude Code, for Claude Code users. I used Claude Code to write most of TruthGuard - the hooks, the CLI, the test detection. It's free, open source, and you can try it right now with npx...
I built a Claude skill to review the security of other Claude skills. Claude skills can run code, which means they can also do things you may not expect. There are already a lot of community-create...
https://preview.redd.it/s4hj7gxks1og1.png?width=728&format=png&auto=webp&s=41953a383ed5d6bec0f8ddd1cd364a8b07ffd9f3 open-workshop is something I built because I really struggle with managing all th...
If you're doing serious agentic work with Claude Code you've hit this: Claude generates files, self-reviews, reports clean, and something's wrong anyway. The self-review problem isn't solvable with...
One of the powers of the latest Claude AI model is that it can use any multiple external Python tools to perform complex tasks. And, as software engineer and AI expert Ashe Magalhaes has discovered...
I've been using Claude Code daily and kept running into the same issue: every time I ask a structural question about my codebase ("what calls this function?", "find dead code", "show me the API rou...
A dev tool for Angular projects that copies the full component ancestry, source file paths with line numbers, and cleaned HTML to your clipboard with a single click. Paste directly into Claude Code or any AI assistant. MIT licensed, zero prod impact, and now ships an MCP server for even smoother integration.
A self-hosted Docker service that wraps the Claude Code CLI and exposes it as HTTP and Server-Sent Events (SSE) API endpoints, enabling agentic task execution over standard HTTP. Makes it easy to integrate Claude Code into existing toolchains or build services on top of it without tight coupling.
A free, local middleware layer that wraps Claude Code with practical enhancements: safety guards, RAG-based persistent memory, a Telegram gateway for remote access, 28 built-in skills, and voice transcription. Everything runs locally with no cloud dependencies or extra costs.
A macOS sandboxing utility that constrains LLM coding agents — including Claude Code — to only access the files they actually need. Reduces blast radius when running agents in sensitive or production-adjacent environments by enforcing filesystem-level isolation.
A streamlined package manager for installing, versioning, and managing Claude Code skills and AI development tools. Simplifies keeping skill collections up to date and consistent across projects, similar to npm but for Claude Code extensions.
Hey everybody, For the vibe coding crowd, InfiniaxAI just doubled Starter plan rate limits and unlocked high-limit access to Claude 4.6 Opus, GPT 5.4 Pro, and Gemini 3.1 Pro for $5/month. Here’s wh...
https://reddit.com/link/1rokk6f/video/rndhmbwoswng1/player Since the end of 2024, I have been using AI to code pretty much every day. As the models have improved, I have gradually moved away from t...
TLDR: Does Claude Code make us better thinkers? Here's a tool that will give you some insights on your deliberate thinking - from the Kahneman lens: are we just acting fast, or are we actually thin...
I've been building a custom Claude Code personality called Jules for a few months. Not a system prompt wrapper. A structured profile that defines identity, voice registers, decision authority, proa...
Hello everyone, I recently got into this whole AI coding thing. I installed Antigravity and also Claude Code (in my CMD) and also in the Antigravity project. Where I need some help: - I dont know h...
I've been running Claude Code a lot over the last few months. I use it controlled. No dangerously skip permissions. I spend time on planning, then watch it do it. However one thing is always bother...
Hi - I have a CRUD web app written in ASP.NET and Microsoft SQL Server. The web app has both a JS/HTML UI and REST APIs. I want to use Claude Code CLI to create a completely new version of the app ...
Hey! I came back with some results :) Free tool: https://grape-root.vercel.app/ 70+ people using it :) they gave 3.7/5 average rating Still improving with feedbacks! Okay, so: I’m trying to properl...
Decided to hack out a project this weekend. A few cups of coffee, a Celsius, and some Claude/Codex action. I called it “validtr” and the goal is you task the tool, with natural language, what your ...
When using Claude Code on larger code bases do you go with just one project setup with one master claude md for the whole code base or multiple projects (could be by directory or by specific areas)...
Give Claude Code persistent project memory. 32 MCP tools for knowledge, impact analysis, governance & task management. Desktop app (Tauri) + CLI. Local-first, SQLite-based.
Claude Code Toolbox — automated installers and environment configuration framework for Claude Code with one-line setup across Windows, macOS, and Linux.