Applications and tools built with or for Claude Code.
Local-first memory for Claude Code that retrieves with BM25, dense vectors, and reciprocal rank fusion — no LLM call in the retrieval path. Returns the original passages verbatim by default instead of a paraphrase, so recalled context is not silently rewritten. MIT-licensed and installable from PyPI as fidelis-memory.
Shared notes, cross-session messaging, and event watches that persist across Claude Code sessions, so context is not lost when you /clear or the window compacts. The watches are token-free, and an orchestrator sits on top to coordinate work between sessions.
An observability tool for watching agent activity as it happens rather than reading logs after the fact. Aimed at anyone running several agent sessions at once and losing track of what each one is working on.
Runs your personal coding agents inside a single Docker container that is walled off from the host filesystem. Lets you hand an agent broader permissions without giving it your whole machine, and keeps Claude Code and Codex in the same reproducible environment.
Runs Claude Code and OpenCode in Docker sandboxes, shipped as a Go library with a ready-to-use binary. The library form is the interesting part — you can embed sandboxed agent runs inside your own Go tooling instead of shelling out to a script.
A lightweight memory layer that carries context between agent sessions and keeps receipts — a record of where each remembered fact came from. The provenance angle is the differentiator against memory layers that hand back assertions you cannot trace or verify.
Brings back the specific Claude Code session each pane was running when tmux-resurrect restores your layout, using Claude's own native session metadata. No Claude hooks and no background polling, which keeps it out of the way of whatever else is wired into your session lifecycle.
Draws a workflow run as a live graph in the tmux pane next to the transcript, so you can see which steps and agents are active while the run is in progress. Fills the gap where a long orchestrated run reads as a wall of scrolling text with no structure.
A native macOS menu-bar app showing live Claude Code quota usage. Nothing unusual for a well-covered category, but it is native and focused on the one number most people want visible while they work.
A self-hosted gateway that puts a single stable API in front of many upstream AI providers, so developer tools and apps keep working when you swap or add a backend. Useful as the seam between your agent tooling and whichever provider you are currently routing to.
Bundles rules, skills, and MCP servers into named profiles, then lets you pick one profile per repository. Every agent on that repo reads the same configuration and stays in sync, which beats maintaining parallel config for Claude Code, Codex, and friends by hand. Docs in Korean and English.
A CLI that gives any coding agent speech-to-text and text-to-speech through bash, running locally on CPU — so Claude Code, Codex, or Grok can talk to you and you can talk back. Built for running several agents at once: while one is still reasoning you switch and speak to another. Agents also get a canvas to draw diagrams on and point at while they explain.
Puts remaining quota in the glow around a MacBook notch — yellow at 70% used, red at 90% — and lights it up when a turn finishes or quota resets, with hover detail for reset countdowns and token usage. Covers Claude Code plus 15 other agents. Open-source core, and the author notes the unexpected part was letting Claude sessions coordinate with each other.
A pull request shows what changed; this records what nearly happened — the commands a human declined, the pushes policy blocked, the turns that got rolled back. That near-miss trail is the part of agent behaviour normally lost entirely, and it is what you want when reviewing how much an agent tried to do on its own.
A single window onto Claude Code, Codex, Cursor and 11 other agents running across all your machines. A daemon keeps each one alive in tmux and the connection is end-to-end encrypted with no SSH, delivered as a desktop app plus daemon, relay, and a USB device. Aimed at people driving many long-running sessions from wherever they happen to be.
A self-hosted version control system for machine learning: atomic commits spanning code, weights, and datasets that check out identically anywhere. A C++17 core hashes multi-gigabyte files in parallel and shards safetensors per layer with content-defined chunking and dedup, behind a FastAPI registry and a Next.js dashboard with weight diffs. Agent-facing features include stable JSON envelopes, a Python SDK, resumable event streams, and .avh context memory so the next agent inherits intent. Positioned against bolting Git LFS or DVC onto a normal repo.
A Claude Code plugin that provisions your agent its own Inkbox identity — a mailbox, iMessage, a phone number for calls and SMS, and an internet address. You can then talk to the agent from anywhere rather than only from the terminal. Aimed at long-running agents you want to reach while away from the machine.
A small macOS utility that renders Claude Code session status in the MacBook notch area. Gives you an at-a-glance signal of whether the agent is working, waiting on you, or done without tabbing back to the terminal. Handy when running sessions alongside other work.
A Claude Code / zcode plugin that converts any set of questions into practice sessions, courses, flashcards, wrong-answer deep-dives, and spaced repetition, with progress synced across devices. Distributed as a plugin so there is no repo to clone or site to stand up. Bilingual Chinese/English.
A local skills hub that centralizes, tags, and deduplicates your AI agent skills, then distributes them to individual agents and project directories by symlink or copy. Skills stay plain files you own rather than entries in someone else's registry. Chinese-language README.
A Claude Code plugin that drafts an IDEA special education due process complaint from school documents for any US state, fact-checks every claim against the source documents, and outputs a PDF to file plus a Word file to edit. A narrow but concrete example of a document-grounded legal workflow as a plugin.
An official aws-samples repo for running Claude Code against any foundation model on Amazon Bedrock (43 of them) or a self-hosted model on EC2, bundled with a HumanEval benchmark harness. Lets you measure how the harness performs across models instead of guessing. Useful reference for anyone evaluating model choice for agentic coding.
A desktop pet that monitors Codex, Claude Code, Claude Desktop, DeepSeek Harness, and Grok at once, with a macOS GUI and a cross-platform CLI. The pet's state reflects what your agents are doing, so idle or blocked sessions are visible without checking each terminal. Bilingual Chinese/English.
A privacy-first local dashboard for exploring Claude Code and Codex usage across tokens, costs, models, projects, sessions, and billing blocks. It reads exported JSON, runs on the Python standard library, and needs no dependencies, build step, or cloud service. Good choice if you want usage visibility without installing a stack.
A local real-time token usage and quota dashboard covering Claude Code, ccmr, Codex, ZCode, dsh, WorkBuddy, and Grok Build. Zero-dependency backend, live SSE panel, and a macOS menu bar entry, started with a single npx command. Useful when you split work across several agent CLIs and want one view of what is left.
Lets an agent strip bloatware from an Android TV over ADB, with brand-by-brand developer-mode entry instructions, twelve safety gates, and every step reversible. No root required. A good illustration of how to wrap a destructive-by-default operation in gates before handing it to an agent.
A usage tracker that aggregates token consumption across Claude, OpenAI, Gemini, and other providers in one place. Aimed at people who spread work across several model vendors and lose track of the total. Straightforward tool, minimal setup.
Watches an agent's changes to your project and streams live side-by-side diffs in the browser, snapshotting into a shadow git repo so your own .git is never touched. Lets you supervise an unattended session without polluting history or fighting over the index. Good fit for long autonomous runs.
Runs Claude Code, Codex, Grok, and Pi on remote machines through a native TUI over plain SSH, with nothing installed on the server. API keys stay on the remote side and sessions survive closing the laptop. Solves the 'agent dies when my connection drops' problem without tmux gymnastics.
A local workbench where you browse, edit, and AI-refine agent skills and subagents, then prove they work via scored simulation runs. The scoring turns 'this skill feels better now' into something measurable. Aimed at people maintaining a nontrivial skill library.
Draws your workspace as a 3D dependency graph and animates the live session on top of it — MCP calls, skill use, file reads and writes, spawned subagents, git diffs, and thinking all become visible motion rather than scrolling stdio. Includes conventional diff and code views in the same harness. Open source.
A file-based bridge that lets long-running Claude Code sessions message each other durably, with a per-session push watcher and a fleet launcher for Windows and Git Bash. Messages persist on disk, so a session that was busy still receives them. Useful for coordinating several agents that outlive any single terminal.
Scans, packs, routes, and runs work across Claude Code, Codex, Gemini CLI, Cursor, Aider, OpenCode, and other agents, measuring every token used and saved along the way. The 'zero-token' framing refers to the packing and routing work happening outside the model. Interesting if you are optimizing spend across multiple harnesses.
A demonstration of running OpenCode's remote server on Cloudflare Durable Objects for persistent, low-cost, global-edge command execution and session storage. Shows an alternative to keeping a VPS alive for agent sessions. Reference implementation rather than a product.
When Claude Code hits its limit, this relays the local session to Codex, OpenCode, Kimi, or Pi while preserving the working directory, with no cloud relay in between. Includes a macOS desktop app with light, dark, and system appearance. Chinese-language README.
Runs several Claude Code accounts side by side and fails over to another when one hits its rate limit, carrying the conversation across the switch. Worth checking against your plan's terms before use. Posted here as an example of the account-juggling tooling appearing since the limit changes.
Combines an AI agent, purpose-built 'pilots', and a theme-first PBIP generator to turn a single request into a finished Power BI report, verified in Power BI Desktop. The theme-first ordering means styling is not bolted on at the end. Aimed at analysts who build the same report shapes repeatedly.
Tracks how much headroom each of your team's Claude subscriptions has left across every machine, with cross-endpoint usage, per-team cost attribution, a live dashboard, and a read-only MCP server. Turns a pool of individual accounts into something you can actually account for. Aimed at teams rather than solo users.
A visual designer for Claude Code multi-agent systems shipping 28 agents, a Five Minds Protocol, human-in-the-loop gates, and live simulation — all in a single HTML file with zero dependencies. You can lay out an agent topology and watch it run before committing to it. Easy to try since there is nothing to install.
Unused weekly quota does not roll over, so this free open-source platform moves it between people: spend a spare week shipping a PR for a priced GitHub issue and earn credit, then spend that credit getting an issue in your own repo fixed during a dry week. Work lands as merged PRs under your own GitHub account. An unusual answer to the limit-reset problem.
Runs the same model on the same coding tasks through different harnesses and compares success rates and costs, so claims about a harness using fewer tokens can be checked against whether it still finishes the work. Includes a minimal reference harness with only shell and edit tools as a baseline. Open source and looking for feedback.
The official Jam plugin for Claude Code, Cursor, GitHub Copilot CLI, and Gemini CLI. Paste a Jam link and the agent pulls the screen recording, console logs, and network requests from the bug report. Removes the step where you manually transcribe repro details into the prompt.
A Node.js statusline for Claude Code showing model, current task, git state, context window, rate limits, and an Anthropic peak-hours indicator, with no dependencies. The peak-hours signal is an unusual addition given how much limits have been discussed lately. Drop-in for anyone who wants more than the default line.
A C# supervisor — running as a Windows service or scheduled task — plus a desktop app with an embedded terminal, built to keep Claude Code Remote Control sessions from dying. Addresses the recurring complaint about /rc sessions dropping when idle. Entirely C#, no Node or Python dependency.
A local multi-agent coding harness where agents work your repositories inside isolated Docker sandboxes, visualized as a pixel-art office. The sandboxing is the substance; the office is a legible way to see who is working on what. Good middle ground between raw parallel terminals and a full platform.
A Discord bot that handles Seerr media requests, built on the Anthropic SDK. Natural-language requests in Discord become Seerr actions. Small, focused example of the SDK used for a chat-fronted service rather than a coding agent.
A keyboard-driven macOS window holding projects, terminal sessions, AI CLI agents, dev services, Docker, and SSH together. Sessions run in a background daemon and survive quitting the app, so agents keep working after you close the window. Aimed at replacing a screenful of tmux panes.
Sits in the tray, periodically reads your current usage and limits, then writes Anthropic's payload verbatim to a file, POSTs it to a URL, or both. Because the JSON is unmodified, anything that reads a file or listens on HTTP — your own dashboard, a webhook, Home Assistant, a cron script — can display your limits. No API key needed, multiple accounts supported.
A whale-girl desktop pet with both a dsh and a Claude Code (PetPet) version. Idle animation is baked from a layered PSD; the remaining motions are AI video converted to sprite sequences. Chinese-language README.
Takes a static slide deck and produces animation code, with the machine checking output against fixed guardrails while the final call stays with a person. The author is explicit that this is a demo merging ideas from two production pipelines, not a finished product. Worth reading as a guardrail-plus-human-gate pattern.
A local-first control plane giving multi-runtime AI agents isolated Environments and auditable Runs, with a CLI, HTTP API, and Node.js SDK. The audit trail on every run is the differentiator over just launching agents in terminals. Bilingual English/Chinese.
Shows Claude Code usage in the VS Code status bar with a 5-hour block meter, weekly limit, and per-model and per-session breakdown. Keeps the limit picture in the editor instead of a separate window. Good fit if you drive Claude Code from the VS Code extension.
Interpretable machine learning tooling designed for agents to use and reason about, evolved through autoresearch. Comes from the imodels lineage of interpretable modeling. Niche, but a genuine research angle on agent-usable data science.
A Cockpit plugin turning the web console into a full file manager — browse, edit, preview, search, terminals, and Git — with integrated Claude and Codex CLI tabs showing a live git diff, plus fstab/mounts, SMB and NFS shares, and a GRUB editor. Brings agent-assisted work into server administration. Useful for homelab and small-fleet admins.
An open-source agentic development environment running Claude Code, cursor-agent, Codex, and plain shells side by side in a terminal grid, with a kanban board that dispatches work to them, shared agent memory, and multi-agent orchestration. The kanban-as-dispatcher idea gives parallel agents a single queue. Open source.
Measures execution, token usage, cost, sessions, tooling behavior, and repository alignment across Codex, Claude Code, and other agents. 'Repository alignment' is the interesting metric — whether the agent's work actually matches the repo's conventions. Open source telemetry rather than a vendor dashboard.
Aimed at the context-switching cost of running multiple agents: one dumps logs, another rewrites the plan, a third found the bug three messages ago. This plugin lets them show you the bug, the flow, or the change as a video instead. Example uses include a daily Sentry bug summary and a standup recap of the last day's work. Open source.
An entire agent harness in one Bash file with a one-line quick start, designed to act as a bootloader agent on bare-metal servers. Being a single script means it runs anywhere you have a shell, before any toolchain is installed. Useful as a readable reference for what a harness minimally needs.
Three parallel sessions are manageable; the fourth breaks the mental map — one is blocked on a permission prompt, one finished twenty minutes ago unnoticed, one is silent and you cannot tell if it is thinking or dead. Maestro gives an overview, a session grid, and a control panel over all of them. Free with no paid tier, built in-house by a dev shop.
A local dashboard showing your Claude and Codex usage quotas in one place. Monitor-only by default, so it reads state without touching your sessions. Currently a Windows preview, which fills a gap since most quota trackers assume macOS or Linux.
An open-source macOS daemon and companion CLI that attaches a phone number to your coding agents, so long-running sessions can reach you over SMS instead of requiring you to sit and watch a terminal. Useful for approval prompts and completion notices on unattended runs. Open source, unlike most agent-notification services.
A discovery tool for AI coding assistant skills that lets you compare candidates side by side and then save a chosen set as a reusable bundle for your stack. Solves the practical problem that skill catalogs are large and most entries are near-duplicates. Bundles mean a new project starts from your curated set rather than a blank skills directory.
A cross-platform desktop app that manages all your Agent Skills in one place and syncs them into the global skills directories of multiple AI coding tools. The pitch is 'install once, sync everywhere', which removes the manual copying you otherwise do whenever you switch between Claude Code, Codex, and friends. Worth a look if you maintain the same skill set across several tools.
lex anchors AI conversations to the place in the code they were about, so opening a file later surfaces the discussions that shaped it. It works inside Neovim and supports Claude Code, Codex, and OpenCode. A direct answer to losing the reasoning behind a change once the session ends.
TokenPulse is a zero-config Windows dashboard (v0.1) showing real-time token consumption, spend trends, and cost estimates across Claude Code, Codex, Gemini CLI, Qwen, and ZCode. Everything stays on your machine — no data leaves the host. Notable for covering multiple agent CLIs in one view and for being one of the few Windows-first trackers.
A curated German-language collection of 132 Claude Code tips attributed to Boris Cherny, auto-updated two to three times daily, with a visual dashboard offering filters and a timeline. It also ships a one-shot implementation guide that configures Claude Code from the tips. Worth a look for German-speaking teams or anyone wanting the tips in one browsable place.
A local-first, read-only tracker that reports token usage for AI coding agents and projects how much budget runway you have left. Read-only by design means it never touches your agent's state. Useful if you care about when the budget runs out, not just what you have spent so far.
orbit-code replaces the terminal view with a live 3D visualization of what the agent is doing, shipping as both a VS Code extension and a desktop app. Open source, and aimed at programmers and vibe coders alike. The most visually ambitious take on the Claude Code UI problem so far.
Generates a Spotify-Wrapped-style card summarizing how you actually work with Claude Code, built entirely from local transcripts. Nothing leaves your machine. One of several wrapped-card tools around, but this one commits hard to the local-first constraint.
Measures which of your standards-as-skills actually earn their keep by attributing token cost and outcomes to each skill across Claude Code and GitHub Copilot. It records metadata only, never content. The point is making keep/refine/deprecate calls on evidence rather than vibes — valuable once your skill library gets large enough to be unclear.
Amber is a simple, web-based clone of Claude Code, available at amberagent.dev. It aims at a clean uncluttered interface rather than replicating every terminal feature. Worth trying if you want agent coding in a browser tab.
domux is a terminal multiplexer built specifically for running AI coding agents, rather than a general-purpose tmux replacement. It gives each agent its own pane and keeps parallel sessions manageable. Open source and focused — useful once you routinely run more than two agents at once.
Built by a user tired of every generated site looking identical — purple gradient, Inter, three feature cards. A browser-based selector runs before any code is written: choose a style, set an accent color, upload screenshots of sites you like, and add your own rules, producing a .claude/branding.json everything downstream follows. The reference-image upload is the strongest part, since a screenshot rules out default archetypes better than paragraphs of description. Pure Python standard library, runs locally.
A Tauri 2 + React 19 + Rust desktop app that acts as a control cockpit for Claude Code. It provides governed memory, an AI router, and orchestration for skills and agents, installable component by component. Useful if you want a GUI layer over your Claude Code setup instead of managing config files by hand.
A documentation toolchain where agents write Markdown with typed YAML blocks, and the renderer (not the model) produces diagrams, API docs, ADRs, and slides. Because the blocks are typed, CI can validate them, so docs fail the build instead of silently rotting. Aimed at keeping AI-generated documentation correct rather than merely plausible.
A desktop companion wired into Claude Code hooks so it visibly types while the agent iterates and pops a speech bubble when the run finishes. Avatars are pluggable, so you can swap in your own character art. Useful as an ambient signal that a long session is still running without watching the terminal.
A cross-platform usage heads-up display that tracks both the 5-hour and weekly limit windows and shows reset countdowns. It ships a fetcher, a Claude Code statusline segment, and a GitHub Pages dashboard for the longer view. Aimed at people who keep hitting plan limits mid-week and want to see the burn rate before it bites.
A Rust proxy that speaks the Anthropic Messages API and forwards to CodeBuddy, tuned for Claude Code as the client and deepseek-v4.1-flash as the backing model. Lets you point Claude Code at a non-Anthropic model without changing the client. Niche, but relevant if you are spreading work across providers to stretch limits.
A deterministic, AI-free scanner that inspects Claude Code artifacts — skills, hooks, and MCP server configs — for data exfiltration paths, prompt injection, and supply chain risks. Because it is static analysis rather than a model call, results are reproducible and cheap to run in CI. A sensible gate before installing third-party skills or plugins.
A cross-platform terminal organized around projects as vertical tabs, where any tab splits into panes that can be a shell, editor, file tree, diff, git history, browser, or image board. It explains git operations in plain English and surfaces when a coding agent is blocked waiting on your input. Aimed at people juggling several agent sessions at once.
Terminal for Remote Agents in a Contained Environment — a browser-based IDE built on an xterm.js SSH client, where the server owns every terminal process so sessions survive closing the tab. It streams a real neovim over WebSocket with themes injected to match, plus a command palette and OnlyOffice integration. Built for people who work exclusively over SSH in remote containers and want agent harnesses living there too.
DGV, a diagram-as-code viewer, can now write its working model out as Structurizr DSL via `dgv export --format structurizr`, and the viewer grew a C4 button. Nodes become containers, frames become groups, modules become components, and externals sit outside the system, with output validated against the Structurizr CLI on every example. Useful if you keep architecture diagrams in the repo and want C4 tooling to read the same file.
A shared ledger built on GitHub issues and pull requests. A repo owner prices an issue with a 1-10 label, someone with spare weekly capacity claims it and ships the closing PR, and the merge settles: contributor credited, owner debited. Credit earned in one tracker spends in any other registered one, with review rounds subtracting from the credit so a sloppy PR costs the contributor. No money and no token involved — the pitch is that capacity you would otherwise waste before a reset fixes someone else's backlog.
A desktop app that builds a knowledge graph of your codebases and auto-manages the resulting context as docs and skill files. Each project gets a Brain that any coding agent can read, so switching tools does not mean re-explaining the project from scratch. Positioned as an open-source take on Cursor's Projects feature.
Three codebases from one person over a summer — a Rust core for the PC side, a Tauri 2 tray app on Windows, and a Kotlin/Compose Android app. Phone and PC pair by QR code and talk mTLS with pinned fingerprints, so new photos land on your own machine as original files sorted by year and month, and nothing is ever deleted. The write-up focuses on the testing discipline that made a three-codebase solo project survive a closed beta.
Captures website elements and assembles them into an editable local timeline you direct conversationally — 'keep this transition', 'give the product elements more movement', 'simplify the ending' — through Claude Code or Codex. Demo films are built from Notion's and Figma's own typography, colors and graphics with original soundtracks. The result stays editable in the local editor instead of being a one-shot render.
A prompt-history visualizer updated after community feedback. It now does full-text search across everything you have typed (you rarely recall the exact sentence, but usually two words of it), shows which prompts actually ended in a commit, and nests sub-agent work inside the prompt that dispatched it instead of floating it off separately.
A daemon that maps each Discord thread to its own Claude Code session with its own memory, so posting in a channel opens a thread and a second thread is a fully separate task running in parallel. Built because the official Discord plugin sometimes dropped replies and shared a single conversation across everything. Lets you keep handing an agent work from a phone.
A memory store for coding agents with four deliberate constraints: cross-agent, so a decision made in one tool is known to the others; local, as plain SQLite on your disk; zero dependencies, using only the Python stdlib with no vector DB or daemon; and git sync, so your memory is a repo you own and can diff or delete. Free and open source.
A discussion of how much session time goes into re-deriving things the agent already worked out — where things live, what calls what, how a system is structured — and why CLAUDE.md only partly covers it once a repo gets large. The author works on Ix, an open-source project that builds a persistent graph of a codebase and lets Claude query it.
Stores course material locally so an agent can teach from it with citations back to the original source. Aimed at keeping agent-delivered learning grounded in a vault you control rather than in model recall.
A free, open-source software engineering cockpit that wraps terminal-capable AI coding agents in Kanban-style task execution. Tasks move across a board as the agent works them, giving you a visible queue instead of a single chat session. Local-first, with no hosted service in the loop.
A terminal reviewer built for the moment just before you approve an agent's diff. Written in Zig for speed and driven with vim motions, it targets the habit of rubber-stamping changes you have not actually read.
An iPhone and iPad terminal for driving coding agents on remote machines, using Mosh so connections survive network changes. Its Vibe Island feature puts the agent's current status on the Lock Screen, so you can tell whether it is working or blocked without opening the app.
Replaces the usual one-line status with a daemon-driven instrument panel, so state that is expensive to compute is gathered out of band rather than on every status refresh. telltale-clawd covers Claude Code today, with a Codex variant planned.
Long-running local jobs make agents poll in a loop, and every poll costs a turn and a slice of context. This monitor watches the job out of band and hands the agent a result when there is one, replacing repeated check-and-wait cycles.
An Intellectual Work Environment layering protocols, AI-agent roles, memory and knowledge formalization over Claude Code. Aimed at structured thinking and knowledge work rather than at writing code.
An open-source, self-hostable control plane for running Claude Code, Codex and other coding agents on hardware you own, reachable from a phone, a browser or an automation. Keeps the work on your machines rather than someone else's.
Local-first context sync that keeps AGENTS.md, CLAUDE.md, MEMORY.md and Cursor rules up to date as the project changes, while checking that secrets do not end up committed inside agent context files.
Reports how much of your subscription allowance is left and, more usefully, projects whether it will survive to the next reset at your current burn rate. Aimed squarely at the weekly-limit anxiety dominating the community right now.
A browser-only visualizer for Claude Code transcripts that breaks context consumption down per tool call. Nothing to install and nothing leaves the page, which makes it easy to find the one tool result that ate half the window.
A free MIT-licensed CLI that turns speech into markdown prompts for AI coding agents, bring-your-own-key. Useful for the long prompts you would rather talk through than type.
A small native Windows monitor showing Qoder and Claude Code session status as a traffic light, so you can tell at a glance whether an agent is working, blocked or finished. Docs in Chinese.
A caching and cost-optimization gateway in front of OpenAI and Anthropic APIs that uses semantic matching to serve repeated work from cache, claiming 40-75% bill reduction. The headline numbers are the author's own and unverified.
Shows whether Claude Code is working, blocked or done directly in the tmux status bar, so a session waiting on input does not sit idle in a pane you are not looking at.
A local-first project brain that takes a brief through to approved analysis documents, then hands those to whichever agent CLI you use — Claude, Codex or another — to write the code. Holds no API key of its own.
Brings Claude Code session history, MCP server configuration, skills, usage and multiple accounts into a VS Code sidebar panel. Runs entirely locally.
A pure-Python harness for building and testing autonomous multi-agent apps, written to translate Anthropic's published agent design guidance into code you can actually run.
Captures sessions from every agentic client into one searchable store without lossy summarization, so a conversation from three weeks ago is still retrievable in full.
Measures your real output from AI-assisted work with no config, no daemon and no account by default — a counterweight to tracking tools that want a signup before they tell you anything.
A single Python file with no Node and no sudo that exposes tmux sessions and the agents running in them to a phone browser. Appealing precisely because there is almost nothing to install or trust.
Runs commands on a remote host over OpenSSH while preserving the process semantics an agent expects locally — exit codes, streams and signals — so remote execution needs no special handling on the agent side.
A Claude plugin that connects to the Tipee HR platform so Claude can read and modify employees, teams, shifts, absences, on-calls, activities, and time-clock entries. Aimed at teams who would rather run HR admin conversationally than click through the Tipee UI. Niche, but a clean example of wiring a business SaaS into Claude.
A CLI that reports remaining quota across all your agent accounts: every Claude Code profile on the machine rather than just the default one, plus Codex and the opencode providers. It reads local state only, with no network calls and no credentials required. Spanish-language README.
A statusline showing real-time 5-hour and 7-day Z.AI/GLM limits, styled to match Claude's own palette. Updates are driven by Claude Code hooks rather than cron or polling, so nothing runs in the background. For anyone pointing Claude Code at GLM models.
A static analyzer that scans skill files and flags routing collisions, where two skills claim overlapping triggers and the agent may load the wrong one. It runs offline and deterministically in milliseconds, so it fits in a pre-commit hook or CI. Increasingly relevant once a skill library grows past a handful of entries.
A zero-dependency heuristic scanner that finds leaked credentials inside the local transcript history of AI coding assistants, then redacts them. Covers Claude Code, Antigravity, Codex, Copilot, and Cursor. Worth a run if you have ever pasted a key into a session.
A Mac assistant with full-duplex voice behind an on-device wake word and Touch ID, backed by vendor-neutral brains including Claude Code and Codex. It adds native Swift automation, a console into every coding-agent session, and the ability to rewrite itself in a worktree once you approve. Ambitious and unusual in scope.
An experimental CLI that passes tasks between Grok Bot, Codex, Claude Code, Cursor, and Antigravity. The idea is to hand work to whichever agent suits it without re-explaining the context each time. Early stage.
Gives agents role-scoped folders and keys with the boundaries enforced by the operating system rather than by prompt instructions. When something is blocked it reports whose file the agent reached for, so the failure is diagnosable instead of mysterious.
Manages several agent accounts from one CLI: per-account usage limits, switching between them, and isolated sessions so state does not leak across profiles. Covers Claude Code, Codex, Cursor, and Copilot.
A terminal UI that runs coding agents in isolated git worktrees, puts a real build/lint/test gate in front of every change, and auto-merges only when policy allows. Local-first, so no hosted service is needed to coordinate the work.
Switches Claude Code between accounts directly, skipping the interactive login each time. Useful if you juggle a personal and a work subscription, or several profiles on one machine.
Turns a Stream Deck Mini into a monitor for six concurrent coding-agent sessions, with live status on each key and one-touch window switching. Ships adapters for OpenCode, Claude Code, GitHub Copilot, Gemini CLI, and Cursor CLI.
Lets you mark up an app's interface while it runs and hand those annotations to a coding agent, Claude Code, Codex, or Gemini, as specific change requests, with a two-way conversation back from the agent. Portuguese-language README.
Uses Claude Code to maintain Obsidian wikis: ingesting new sources, prioritizing what to tackle next, and catching items that would otherwise slip. Inspired by Karpathy's LLM-wiki idea, and built to handle several vaults at once.
A deep 2026 comparison of twelve AI coding agents focused on tool implementation rather than feature checklists: how each one does file editing, search, shell execution, and context handling. Covers Claude Code, Codex, omp, Hermes, Aider, Cursor, and more. Good reading if you are building a harness of your own.
A Go factory for coding agents: frontier models plan and inspect while cheaper OpenCode workers do the building, with every unit measured, audited, and traceable. Control and data planes are deterministic, so the orchestration itself is not left to model judgement.
Reads your Claude Code sessions off local disk and draws them as a pixel-art office, one room per project and one robot per session. Color codes status as working, waiting on you, blocked, or idle. Click a desk to open the conversation, send a follow-up, queue a message, or stop a run.
Open-source tooling that keeps coding agents aligned with a repository's existing architecture, using deterministic guardrails rather than prompt reminders. Targets the slow drift that accumulates when many agent-written changes each look reasonable on their own.
Routes each step of a long-horizon coding task to an appropriate model, adapting based on what your workflows actually look like over time. Lightweight and extensible, and deliberately agnostic about harness, model, and loop structure.
Generates icons, favicons, logos, and platform-specific asset sets from text prompts using free inference providers, callable from the CLI or from an AI coding assistant. Handles the tedious export-size matrix that app and web projects need.
An unofficial desktop distribution built on DeepSeek Harness and Tauri 2, avoiding Electron. Bundles a local agent runtime with BYOK, multi-provider model support, tools, MCP, and session management.
A mobile interface to a coding agent running on your own machine, covering Claude Code and Codex. Lets you check on a session, answer a prompt, or kick off work while away from the desk.
A terminal UI for reviewing and deleting accumulated AI chat sessions. Straightforward housekeeping for anyone whose local history has grown large enough to be worth trimming.
A dense, width-aware Claude Code statusline showing context usage, rate limits, prompt-cache economics, cost history, and machine pressure across ten labelled rows. It adapts to terminal width rather than truncating, so the whole picture stays readable.
A local dashboard showing Claude and Codex quota for Dot Quote/0, with a bilingual UI and Canvas-rendered output. Runs without Vibe Usage as a dependency.
Converts text into a prompt link for Claude, ChatGPT, Perplexity, or Grok, checks it against the 7500-character limit, shortens it, and returns the finished link. Handy for sharing a prompt that someone can open directly in their own assistant. Portuguese-language README.
A macOS desktop app that shows AI coding sessions as they run, searches your full session history, and restores any past session in one click. It also gives Claude Code and Codex a single place to manage skills, rules, MCP servers, agents, commands, and hooks. Everything stays local.
Monitors AI coding agents while they run and blocks file access, network connections, and shell commands that fall outside policy, with system resource limits on top. Aimed at people who want to let an agent run unattended without handing it the whole machine.
A local memory store for AI agents written in Rust, using hybrid retrieval to combine keyword and semantic search. It runs fully offline, so you can build a knowledge base agents query across sessions without sending anything to a service.
A desktop client that lets you pick which coding-agent harness to use per session, and any model that harness can reach. Useful if you switch between Claude Code, Codex, and others rather than committing to one.
Inspects, compares, and migrates Chromium-family browser profile configuration: extensions, shortcuts, and allowlisted settings. Dry-run by default with hash-verified backup and rollback, and it emits JSON an agent can act on.
The second version of CliDeck adds projects, live session status, and collaboration across CLI providers. Agents can now hand tasks to each other and talk inside the TUI so you see the traffic between them, and their output — docs, HTML, images, video — previews automatically. Open source.
A Claude Code status line showing your actual plan consumption — both the 5-hour block and the weekly limit — alongside current context window usage. Ships in both bash and PowerShell so it works on Windows as well as Unix.
An open profile format that records how much of a developer's work was AI-assisted and where it came from, with analytics over the result. Aimed at making AI-native contribution legible rather than guessed at.
Tracks subscription quota windows for Kimi, Claude Code, Codex, GLM, DeepSeek, MiniMax, and OpenCode Go, plus relay balances from several proxy services. Supports API keys, OAuth, and web session auth, and notifies on low balance or expired credentials. Native Swift with no third-party dependencies; adding a provider takes one directory and one line.
An IDE built around running several coding agents at once, reachable from desktop, mobile, or a VPS. Open source and self-hostable, so the agents run on hardware you control while you check on them from wherever you are.
An AI operations platform that runs continuously as a Discord bot, backed by a RAG store, an insight layer, and 99 automation scripts. It is built to detect and repair its own failures and accumulate knowledge over time, with no API charges.
A tutorial repository that builds an AI coding agent incrementally, implementing each piece so the mechanics — tool loops, context handling, execution — stay visible rather than hidden behind a framework. Bilingual Chinese/English.
A single bash script status line that estimates session spend, tokens in and out, elapsed and active time, energy in kWh, and a per-model cost breakdown. The author built it after a fleet of subagents quietly ran up a bill. Needs only bash, jq, and awk — no Node or Python. MIT.
Maps Claude Code onto physical hardware: live session status on the keypad screen, one-press canned prompts, git actions, and offline voice input. A tactile alternative to alt-tabbing back to the terminal to check whether a run finished.
Renders running Claude Code sessions as characters in a pixel-art office, so you can glance at activity across sessions instead of reading logs. Cosmetic, but a fast read on whether anything is stuck.
A lightweight system tray widget for Windows showing usage, remaining quota, and reset times across Codex, Claude Code, and Antigravity in one place.
Talks to local Claude Code instances over the native peer protocol they already use to communicate across sessions. Unofficial and reverse-engineered, but it opens the door to scripting session-to-session messaging without standing up a separate bus.
Indexes the projects on your machine into a catalog both you and your agents can query, and keeps learning from how they are used. Aimed at the problem of an agent not knowing what else you have already built.
A drop-in substitute for `claude -p` that drives the interactive TUI through a PTY instead of the headless path, so scripted and automated runs bill against your subscription rather than the API. Useful for cron jobs and pipelines on a Max plan.
A minimal always-on-top widget showing your Claude usage limits on Windows, for people who want the number visible without a tray click.
Indexes a codebase up front and generates ignore rules so the agent navigates by index instead of reading its way through the tree. The project claims around an 80% reduction in token usage on large repos.
Shows your Claude Code 5-hour and weekly usage limits side by side on the Windows desktop, each with its own reset countdown so you know when capacity comes back.
Takes sessions you already ran and replays them on a different model, then diffs the results. Rather than arguing about whether a new release is better, you get to see what changed on your own work.
A CLI reporting subscription usage across agent providers, designed to be readable by a person and parseable by an agent, with a plugin interface for adding providers.
A JetBrains plugin that puts Claude Code in the IDE properly: streaming chat, diffs you can edit in place, MCP support, and a deterministic security layer. Works across IntelliJ IDEA, PyCharm, WebStorm, GoLand, and Rider, and needs no Node.js at runtime.
Generates and runs API tests by reading the codebase, aiming to get a suite into CI within a single agent session rather than across a week of prompting.
Runs autonomous AI agents inside Docker-based sandboxes, giving each one an isolated micro-VM so a bad command stays contained.
A local dashboard that shows and steers everything running — sessions, subagents, /loop runs, and todo lists — from one place, with zero dependencies. Aimed at people who lose track of what is happening across several terminals.
Throttles a pool of Claude Code Sonnet workers automatically based on available capacity, so a fan-out of parallel workers neither stalls nor blows through limits.
Your agent writes documentation faster than anyone can review it. DocGov checks it — flagging docs that have gone stale, duplicate files covering the same ground, and prose that contradicts the code it describes. Ships as a Claude Code plugin and a CLI.
Records and monitors what Claude Code actually does on your computer, giving you an audit trail of file and command activity rather than trusting the session summary.
A macOS app that hands your existing Claude Code, Codex, or OpenCode agent a set of hands: a browser it can drive, access to Gmail and Calendar, a durable work queue, and an audit trail. There is no LLM inside and no API keys — it uses the agent you already pay for.
A companion that tracks Claude Code cost, token consumption, and session activity as they happen.
A Claude Code status line backed by a persistent per-request ledger. Because the numbers are recorded as each request happens rather than recomputed from the transcript, they stay accurate after compaction prunes history.
Mines your session history for loose ends: what you started and dropped, where each idea eventually went, and patterns in how you work. Available as a web app, an API, and a Hermes Agent plugin.
A model-agnostic CLI coding agent forked from Claude Code, able to drive local models as well as cloud providers. For people who want the Claude Code interaction model without being tied to one vendor.
Sorts the skills listed on skills.sh by a confidence heuristic with no LLM involved, then has a local model explain the top three. Zero billed tokens. French-language.
CodeSage indexes on every commit, checkout, and merge via a git hook, so its fixed cost is paid dozens of times a day. It was loading the ONNX model and mapping a CUDA context before checking whether any file had changed: 2.7-4.5s and 1.16GB. It now checks first — 0.07s and 67MB on a 210-file repo. Risk scores also now state what they did not measure.
The Windows tray front end for Nazar, showing remaining Claude Code and Codex quota without opening anything.
A cross-tool marketplace covering Codex, Claude, GitHub Copilot, and Cursor, so the same skills, agents, MCP servers, hooks, commands, and rules install into whichever one you are using.
Five releases of Claude Command Center summarized for people running many parallel sessions: ccc send and ccc ask message a running session from the terminal, a five-minute self-check surfaces dashboard health so silent local failures show up, a new Ask tab answers plain-language questions like 'where did I work on X?', and each Claude and Codex session gets a weekly quota estimate. The author runs 30+ sessions through it.
Meters exact usage for Claude Code, Codex, and any terminal agent on machines you own, then enforces budgets — the breaker trips rather than the bill growing. Self-hosted, with monitoring on top.
Keep your agent configuration in one place and transpile it out to every AI CLI you use, so adding a rule does not mean editing five config formats by hand.
A browser extension for Chrome and Safari that lets you point at an element in your localhost UI and prompt the agent about it directly, through one shared local bridge. Currently a temporary developer preview.
Proposes a semantic layer for software projects: a single generated artifact any AI agent can read to understand the project's shape, designed to be verifiable rather than hand-maintained prose.
A fork of the Three.js multiplayer game Claude of Tanks in which a virtual fruit fly operates the tank from a miniature cockpit, steering, aiming, firing and repairing. The neural simulation runs 124 identified fruit-fly neurons and 1,106 measured connections from a reduced MaleCNS circuit, with the neural activity visible on screen. A showcase of how far a hobby project built with Claude Code can be pushed.
A native macOS menu bar app that prevents your Mac from sleeping while Claude Code or Codex is working, so long unattended runs are not cut short. It also tracks daily and monthly token usage locally. Small quality-of-life fix for anyone running overnight sessions.
Gives an agent its own virtual screen on the Hyprland compositor so it can drive a GUI without taking over your actual desktop. Keeps computer-use style automation from stealing focus or clicking on your windows. Linux-only, aimed at people who want agents driving real applications safely.
A desktop workspace built to replace juggling one VS Code window per project. It runs several projects and agents from a single window, notifies you when an agent finishes or needs input, and adds a per-project markdown issue tracker and wiki. Works with Claude Code, Codex, Cursor and other CLI agents so you can swap models freely.
A Windows and macOS desktop app that sits around roblox-ts, Rojo and Roblox Studio so you can describe a game and watch it appear in Studio. The agent terminal is front and centre rather than hidden behind an API wrapper, and it never launches Claude with permission checks disabled. Includes a CC0 asset bank and optional Open Cloud publishing with your own key.
A memory system for AI assistants that stores everything as plain markdown files. The model writes once and retrieval is done with grep plus BM25 ranking, with no embeddings, no vector store and no MCP server to run. MIT licensed, and deliberately simple enough to inspect by hand.
A live terminal dashboard styled after btop that tracks token consumption for Claude Code, Codex CLI and OpenCode across multiple local accounts and backends. Runs offline and read-only with no API keys required, since it reads what the tools already write locally.
A human-gated review assistant that has Claude Code draft a pull request review, then lets you pick which comments actually reach GitHub. Everything posts under your own name rather than as a bot. A reasonable middle ground between fully automated review bots and doing it all by hand.
A small menu bar app that shows your Claude usage limits. It reads the OAuth token Claude Code already keeps in the Keychain and calls the same endpoint the usage command uses, so there is no account setup and checking your limits does not consume any of them. Rust and GPUI, MIT licensed, nothing leaves your machine.
A Claude Code plugin that generates draw.io architecture diagrams for Oracle Cloud Infrastructure, either from existing Terraform configuration or from a written description. Saves hand-drawing diagrams that go stale the moment the infrastructure changes.
Converts a pull request or code diff into a standalone interactive HTML page that walks through the logical flow of the change rather than listing files alphabetically. Useful for handing a large change to a reviewer who was not in the room when it was written.
A small integration that lets Claude Code collaborate with Codex directly, so you can route parts of a task to the other agent without leaving your session. Minimal in scope, aimed at people who keep both subscriptions and want a second opinion in-line.
A Windows system tray application that tracks usage limits, remaining quota, reset times and spend across several AI providers at once. Fills a gap for Windows users, since most of these monitors are macOS menu bar apps.
A Rust crate that exposes several agent harnesses through a single, simple interface, so a program can target one API and keep working as harnesses change. Aimed at developers building tooling on top of agents rather than at end users. Note this is unrelated to the earlier project of the same name.
A developer used Claude Code in the terminal to build footrue.com, a collection of 290+ browser-only utilities (ffmpeg via WASM, local Whisper transcription, PDF tools) with no backend at all. Everything runs client-side, so hosting stays free even under a traffic spike. The author reports the CLI workflow made debugging WASM workers and local models noticeably easier, and is answering questions about the prompts and terminal setup.
hicortex captures an agent’s working experience automatically, then distills it overnight into reusable lessons that are shared across an entire fleet of agents rather than staying stuck in one session. The pitch is memory that improves over time on its own instead of a static notes file you maintain by hand. It supports Claude Code alongside Hermes, OpenClaw, and Pi.
A native macOS terminal built for supervising many concurrent AI coding agents — Claude Code, Codex, and Antigravity — from one window. It surfaces which session is blocked and waiting on you instead of making you cycle through tabs. Aimed at people running several agents in parallel across projects.
A macOS app that runs Claude Code, Codex, and Kimi Code as real CLIs in hidden terminals sharing a single chat window, with OpenRouter models joining as extra participants. You type once and every agent sees it; @name addresses one directly, and they can reply to each other until you call it off. Built out of an adversarial-review habit of having one model critique another.
A desktop AI assistant, now in public preview, that integrates Claude Code alongside ChatGPT subscription plans, OpenRouter and API providers, and a built-in local model runner with its own download interface. Tested on Windows, macOS, and Linux. The author is spending the next several weeks exclusively on bug fixes before adding features.
A work-breakdown-structure and Gantt viewer that ships as a single HTML file reading one JSON data file, with no dependencies. The structure is deliberately plain so Claude Code can maintain the schedule directly. Includes an inazuma progress line for spotting slippage at a glance.
Gives every coding agent session one consistent identity across Claude Code, Antigravity, Codex, and Gemini. Each session is marked with your label plus the project, the machine, and the moment it ran. Useful when work is spread over several machines and you need to tell later which run produced what.
A Rust terminal and web control plane for coding agents that speak the Agent Client Protocol — Codex, Claude Code, Muse Code, Kimi Code, Grok Build, and DeepSeek Harness. Provides durable sessions, isolated environments, per-agent quotas, and remote control. Aimed at running a stable of agents without babysitting each one individually.
A macOS desktop app for running CLI coding agents like claude and cursor-agent, either one at a time in a chat or wired together as a team in a DAG where each agent feeds the next. Everything runs on your machine — no cloud, no account, no telemetry. For people who want multi-agent pipelines without handing sessions to a hosted service.
A CLI that hands coding agents Chrome DevTools Protocol browser control with guardrails attached: every action returns one JSON object, reachable origins are fixed by allowlist, and each run leaves reproducible evidence. Designed so agent browsing stays auditable instead of free-roaming. A safer option than giving an agent an unrestricted browser.
An open source, Docker-deployable platform for managing Claude Code and Codex sessions, with analytics, AI-generated recaps, sharing, and team features. Session history stays on your own infrastructure. Useful for teams that want visibility into agent work without routing it through a hosted vendor.
GhostSpend audits spend across Claude Code, Codex CLI, Gemini CLI and other AI CLIs against a one-time baseline of the tools you actually use. Instead of only reporting a total, it flags charges coming from anything unexpected. Ships as a free open-source Claude Code plugin plus standalone bash scripts.
auterix keeps one workflow across Cursor, Claude Code, Antigravity, Copilot, Codex, Windsurf, Cline and Augment so context does not drift when you switch tools. It pairs an autonomous context engine with a visual studio for inspecting and steering that context.
A zero-dependency scanner that inspects an agent Skill before you install it, flagging prompt injection, dangerous shell usage, secret access and exfiltration paths. It ships 31 rules and emits SARIF for CI. Run it with npx @royalpinto007/skill-audit.
A macOS app for running parallel Claude Code and CodeBuddy Code agent sessions side by side. It shows live context and credit meters, resumes past conversations, syncs across Macs, and renders terminals through Ghostty.
A benchmark that puts 105 real bugs from two production repositories in front of frontier coding models — GPT-6, Claude, Grok, Gemini, DeepSeek and others — each working in its own CLI. Results are graded blind, with a live leaderboard and every receipt published.
A Windows desktop client (棱镜) that lets you carry a task across multiple subscription accounts, run conversations in parallel, and keep project context together in one place. Localized in nine languages.
Prepare cards on a Kanban board, then let your AI agent pull them and work the queue unattended. It pings you only when it actually needs a decision from you.
A Windows 11 tray companion for the claude-swap CLI. Its glass popover shows live 5-hour and 7-day quota meters plus reset countdowns for every Claude account, and you click to confirm a switch.
Reads the first user turn of a long Claude Code or Codex session and reconstructs what you originally asked for, so you can restate it before continuing. It also includes a prompt wrapper that adds evidence and hedging constraints to evaluation prompts. Deterministic and local with no model calls; the author labels it experimental.
Checks a product idea before you build it by measuring how much supply already exists against search demand, then returns a red, yellow or green verdict. It covers global and Chinese markets and needs no API keys.
Lists the live AI coding-agent sessions running across your tmux panes, windows, sessions and hosts, then lets you select one and jump to it. It runs on the tmux you already have, with nothing extra to install.
A Russian-language personal AI assistant for Telegram handling Word and PDF documents, voice messages, reminders and conversation memory. It ships as a ready-to-go repository: hand it to Claude Code or Codex and the agent sets everything up.
Hand Claude a list of tasks on a board that runs on your own computer and walk away — it plans, writes and reviews the work in parallel. Includes approval gates and cost tracking.
A plugin for AI coding agents that opens images, captured web pages or Markdown files in a browser-based annotator, so you can mark things up visually and hand the result back to the agent.
Indexes your files once, keeps the index up to date as you save, and answers questions across the whole set in milliseconds. Everything stays on the machine, with no service to call out to.
A memory layer for your AI coding assistant: it keeps what you tell it and surfaces the relevant note at the moment it is needed. Runs entirely on your own machine.
Built after finding no agent-native way to sandbox code execution: Docker breaks down when the VM needs systemd, kernel modules or a loopback device and still shares your kernel, while VirtualBox and VMware assume a human clicking a GUI. stoat is a single Go binary that starts QEMU VMs an agent can call directly, instead of approving every bash command or letting the agent run loose on your machine.
An infrastructure engineer kept discovering they needed yet another data store as they did more with agents, which led to asking whether those models could be combined into a single data layer. PolyDB is the result after a year of work, now in beta, aimed at agents that manage their own infrastructure and complete tasks over APIs.
Uses an Obsidian vault as the memory layer for Cursor and Claude Code, holding session handoffs, plans and notes as plain files you own rather than in someone else's database.
Turns ccusage data into a dashboard showing cost, token counts and cache hit rates for your agent CLI usage over time.
A Claude Code plugin that captures the steps an agent cannot finish itself — filling a form in some console, seeding a secret, answering a review — and records them in local SQLite. You then work through them on a per-project board. Useful when agent runs keep stalling on human-only handoffs that otherwise get lost in the transcript.
A knowledge base built for coding agents to read, combining Markdown files, backlinks, semantic search, and Git context. The aim is giving an agent a durable place to look things up rather than re-deriving project knowledge each session. Sits between a wiki and a memory layer.
A status monitor that surfaces harness stats for Claude Code and the DeepSeek harness as a simple traffic-light display. It gives an at-a-glance read on whether you are clear to keep working or approaching limits. Documentation is partly in Chinese.
A loopback bridge that lets Claude Code or Codex continue the same turn on ASU CreateAI once you hit a usage limit, rather than losing the in-progress work. Aimed at users with institutional CreateAI access. Interesting as a general pattern for provider fallback mid-conversation.
A setup guide and menu for running five AI coding CLIs — Copilot, Claude, Codex, Antigravity, and OpenCode — under Termux on Android with no root required. Includes a real install walkthrough rather than just a package list. Documentation is in Portuguese.
A monitoring tool that answers which Claude Code session is eating your Mac. Breaks down CPU, memory, subprocesses and containers per session rather than showing one opaque process. Useful when several sessions run in parallel and the fans spin up.
A clean, minimal statusline plugin for Claude Code showing session context at a glance without the clutter of heavier HUDs. Documentation is bilingual Chinese/English.
A self-hosted personal AI agent that runs on an existing Claude Max subscription and is reachable from the terminal and Discord at the same time. Keeps persistent memory and a structured knowledge vault, with autonomous skills and a heartbeat loop that lets it act between prompts.
An open-source meeting recorder that transcribes locally with Parakeet, then summarizes and extracts action items, decisions and open questions per meeting, organized into projects so memory accumulates instead of resetting each call. Uses your existing Claude Code subscription — no separate API key — and only transcript text ever leaves the machine.
A note-taking app built for visual thinkers: pages are HTML rather than Markdown, so any agent can embed visuals and workflows directly into notes. Each page can carry its own distinct visual style instead of a single uniform template.
An AI-ready Next.js monorepo starter shipping auth, an admin panel, RBAC, audit logging, mobile apps and theming out of the box. Defines one shared development workflow that Claude Code, Codex, Copilot, Cursor and Gemini all follow.
An open-source TypeScript framework for building AI workflows and agents, designed so you describe what you want and Claude Code builds it with the framework's best practices already baked in.
A directory-tree tool rebuilt for AI consumption, positioning itself as a replacement for 20+ CLI tools with compression, semantic search, AST-aware editing and persistent partnership memory. The pitch is heavy, but the core idea — tree output shaped for a context window — is sound.
A Claude Code plugin that audits sites you own for both classic search and AI-search readiness, against a local build or a live URL. Every finding carries its evidence, the two scores are never blended into one number, and a free offline gate runs before deploy.
A single-file local search tool over your Claude Code, Cowork and Claude Chat session history. Useful for finding that decision or snippet from a session whose context is long gone.
A native SwiftUI app that reclaims disk space from AI-assisted projects and the local data left behind by Codex, Claude Code and Cursor, including installed skills. Local-only, no API key required; the app UI is in Simplified Chinese.
A universal bridge that points coding agents at whichever provider you want — Claude Code on MiniMax, Codex on GLM, Gemini CLI on OpenRouter — with one command. Also works with OpenClaw, Hermes and other harnesses.
A Claude Code plugin that intercepts large file reads so they never land in the context window. Ships with the measurement harness used to evaluate it — which found the win is context headroom rather than cost savings, a distinction most such tools skip.
An inference-layer routing proxy that sends individual Claude Code agents to different models, selectively rather than globally. Lets cheap subagents run elsewhere while the main agent stays on Claude.
Zero-configuration, local-first messaging between running Claude Code and Codex sessions, so two agents can talk to each other without you relaying prompts by hand.
Isolated, reproducible development environments plus a secure package manager, giving a whole team identical setups while confining AI agents to the sandbox instead of the host machine.
A relay for terminal-based agents that surfaces the moment a session is blocked waiting for input, so parallel agents do not sit idle unnoticed in a detached pane.
A knowledge base that Claude Code reads and that also sets Claude Code up: it writes the MCP entry into ~/.claude.json, maintains a managed block in ~/.claude/CLAUDE.md without touching the rest, and installs skills and subagents. Built to stop hand-copying configuration between machines and teammates.
Fast local workspaces for running coding agents in parallel: one git worktree per agent, isolated ports, private data directories and supervised processes, with no VM overhead and no daemon. Single Go binary for Linux, macOS and Windows, with an optional reusable container backend.
A local-first, self-hosted workspace where Claude Code, Codex, Grok, GLM and local models work alongside each other as a single team rather than separate terminals.
Evidence-based discovery, specification validation, static security auditing and ranking for open Agent Skills across Claude Code, Codex, Antigravity and Cursor. Addresses the real risk that installing a skill means running someone else's instructions.
A linter for agent context files that checks what CLAUDE.md or AGENTS.md claims against what the codebase actually contains. Catches the silent drift where instructions point at commands, paths or conventions that no longer exist.
Coordinates Claude Code, Cursor and Codex working the same repository through declared sessions, advisory or exclusive file scope locks, and shared decisions. Surfaced in VS Code, a browser dashboard, a CLI and natively over MCP.
A plain-Markdown corpus of 5,660 AI security references across 29 categories — prompt injection, agent and MCP security, skills and supply chain, red teaming, sandboxing, incidents and CVEs. Includes 570 arXiv papers and 1,155 repos, forkable and diffable, with an Obsidian vault export. Listed, explicitly not endorsed.
A tool that renders a repo's year of history as a film — commits flowing along a line, branches peeling off and rejoining, releases pinned. The follow-up post is about the useful correction: commenters did not want a prettier video, they wanted flags to control what the history shows.
Brings specialized AI agents into the conversations where work already happens, rather than asking the team to move into a separate agent tool.
A broad Claude Code plugin bundling guidance for frontend, backend, security, testing, architecture, DevOps, git/DX and AI integration into one install, aimed at both vibe coders and engineers.
A resilient gateway that collapses fragmented LLM providers, API keys and quotas behind a single endpoint, failing over rather than surfacing every provider's outage to your agents.
Batch-converts Word, Excel, PowerPoint, PDF, EPUB, RTF and CSV into clean Markdown before an agent ever opens them, so the model reads text rather than fighting binary formats. A wrapper over firecrawl/anydoc.
A deterministic layer sitting between untrusted content and an agent's actions: it strips the hidden layer of fetched content, tracks where each piece of data came from, and keeps tool calls inside the boundaries of the original intent. A structural answer to prompt injection rather than a prompt-level one.
Makes Claude Code skills available inside Codex sessions with automatic discovery and a /reload-skills command, so one skill library serves both harnesses.
A proxy between your coding tool and the model provider that masks sensitive values on the way out and restores them in the streamed reply. Works with anything you can point at a custom base URL, including Claude Code, Cursor and Codex. Docs are in Chinese.
Splits large images into pieces along content boundaries instead of a fixed grid, so a multimodal agent can read each tile without losing context at the seams. Aimed at feeding screenshots, diagrams and long designs to agents that have per-image size limits.
NVIDIA's framework for evaluating agent skills across multiple tiers: quality gates, detection of semantic overlap between skills, synthetic evaluation dataset generation, and live runs that measure how a skill actually shifts agent behavior. Answers the question most skill authors skip — does this skill help?
Puts Claude Code's context usage and rate-limit status in the macOS menu bar so you can see how close a session is to the edge without switching to the terminal. Useful for long sessions where compaction otherwise arrives as a surprise.
Converts chat transcripts between Claude Code, Codex, OpenCode, Cursor and other harnesses, so a session started in one tool can be continued in another. Ships as a Rust library, a CLI and a WASM build. A genuinely missing piece for anyone running more than one agent.
A profile manager and launcher that keeps separate Claude Code logins on one machine, with directory-scoped control over exactly what config, history and credentials each profile shares. Built for people juggling work and personal accounts.
A self-hosted private finance research setup built on opencode, Claude Code, MCP and a multi-agent layout, covering AI analysis and quantitative work. Starts from Docker in about fifteen minutes. Bilingual Chinese and English docs.
Docker images with the Claude, Codex and Gemini CLIs preinstalled alongside Java, Python, Go and Node toolchains. Useful for running agents in a disposable container instead of on your host, or for giving CI a ready-made agent environment.
A single-binary Rust inference server that speaks both the Anthropic and OpenAI APIs and keeps its KV cache alive across turns, so turn twenty starts as fast as turn two. Runs on Apple Silicon and NVIDIA, with on-policy distillation on the same runtime.
A Claude Code plugin and offline retrieval engine that indexes your project's docs and code, then benchmarks six approaches side by side — contextual BM25, LLM-enriched lexical, dense ANN, Lucene BM25, hybrid RRF, and tree-sitter AST chunking. Lets you pick a retrieval strategy from evidence instead of vibes.
Runs multiple AI coding agents at once and funnels all their permission prompts and questions into a single interface. Removes the usual problem of parallel agents each silently blocking in their own terminal.
A cross-platform colored status line showing project, git branch, model, context usage and rate-limit meters, plus a rarity-rolled mascot that indicates what the current turn is doing. Cosmetic on top, genuinely useful meters underneath.
A workspace that puts Claude Code sessions, terminals, files and git for several projects on one screen, designed to minimize context switching when you supervise multiple agents at once.
Applies curated community patches to the Claude Code CLI as selectable groups, tracking provenance, matching patches to your installed version, and reversing cleanly. A daily release watch flags when a new Claude Code version lands. Unofficial — patching the binary is at your own risk.
A native macOS front end pairing Claude Code with a self-hosted Forgejo instance, for people running their own git server rather than GitHub.
A read-only, localhost-only dashboard showing every Claude Code agent on your machine — which tool it is running, which file it is touching and for how long — including every sub-agent spawned. Zero dependencies.
Injects course corrections into a Claude Code turn while it is still working, instead of pressing escape and throwing away the turn's progress. Ships with a playful lightsaber interaction for when steering is not enough.
Keeps a local, continuously updated memory store that your AI tools read from, so context accumulated in one session is available in the next. Early-stage; the README is light on mechanics.
Analyzes your own session transcripts to find the context length at which your agent's output quality starts falling off. Runs fully locally with no configuration via `uvx contextrot`. Turns a widely-felt intuition into a number you can act on.
A local router letting Codex, Claude Code and any OpenAI-compatible client pick from GPT, DeepSeek, Kimi, GLM, Gemini and Claude in a single menu, pooling the subscription quotas you already have. Includes a vision relay so text-only models can get images described. Chinese and English docs.
A terminal tool that renders your Claude Code session history as a graph of sessions and branches, searches it locally, and starts a new conversation forked from any message in it. Makes 'I wish I had gone the other way at that step' an actual recovery option.
Converts Agent Skills in SKILL.md format into OpenAI Codex plugin bundles, enforcing the official manifest's hard constraints. Standard-library only, no dependencies.
Reads your local Claude Code and Codex transcripts and renders a Spotify-Wrapped-style SVG stats card for a GitHub profile README. Processing stays local.
A floating ASCII-styled status pill for Claude Code on macOS, modeled on the iPhone's Dynamic Island, showing what the agent is doing without keeping the terminal in view.
A profile switcher that isolates Claude Code configuration per terminal, so separate windows can run different models, permissions and settings at the same time.
Stores multiple local Claude Code credential sets under names and switches between them, for juggling separate accounts on one machine. Unofficial and not affiliated with Anthropic.
Brings a graphical Claude Code interface into IntelliJ, PyCharm and other JetBrains IDEs, replacing the embedded-terminal workflow. Formerly published as 'Claude Code with GUI'.
Builds a structural code graph using compiler-level knowledge, developed against operating-system kernel code, so an agent can retrieve exactly the relevant structures instead of dumping whole files into context. Aimed at very large C codebases.
Each worker is a single script with a native macOS GUI and no installer or dependencies. Connect one worker's outbox to another's inbox to chain tasks, driven by whichever of the Gemini, Claude or Codex CLIs you already have.
A searchable, self-hosted store of tasks, dead ends and lessons learned that agents consult at the start of a session and write back to as they work. Aims to stop the next agent from re-walking a path that already failed.
Change an API key once and OpenClaw, OpenCode, Codex and Claude Code all pick it up, with dead keys evicted automatically so a bad credential does not take a tool down. Chinese-language docs.
A Windows desktop app showing quota consumption, usage history, reset times and estimated API cost for Claude Code and Codex. Fills a real gap, since most usage monitors target macOS.
Intercepts tool results in Claude Code and blanks credential values before they reach the model — the command still runs and the file is still read, only the model-bound copy is redacted. Addresses the ordinary case where a useful command output happens to also contain an API token.
A zero-dependency CLI that reads the Claude Code session logs already on your disk and works out what each session actually cost. It runs retroactively over history you never instrumented, and entirely offline. Useful for per-session spend visibility without wiring up a billing dashboard.
A control surface that fans one prompt out to several coding models in parallel so you can compare answers in one place. It also ships a native MCP server, making the same model pool reachable from Claude Code as tools. Aimed at people who cross-check one model against another before committing an answer.
Lahe injects an editing layer into any HTML file on your machine, so you can click text to edit it in place and open threaded agent conversations anchored to specific elements. Edits and comments stay attached to the region of the page they came from. Handy for reviewing and revising generated pages without bouncing between browser and editor.
A local console that keeps API keys in an encrypted vault and swaps model and provider settings across Claude Code, Codex, OpenCode, Kimi, Grok and five other agent CLIs. Config changes are surgical — it patches the specific keys each tool reads rather than overwriting whole files — and usage is tracked per provider. Local-first with no resident daemon.
Catches the case where an agent's pipeline exits 0 but quietly produced wrong data. It layers data contracts and provenance over data-science coding agents: a plan-to-verified-change audit trail, runtime schema-drift detection, and a decision ledger so the same mistake is not repeated later. For anyone letting an agent touch real datasets.
A macOS menu bar app that tracks Claude.ai usage in real time without needing an API key. It shows daily limit progress and per-model (Sonnet) bars, and fires alerts when scheduled routine runs complete. Useful if you want quota visibility while working on a subscription plan.
A model-agnostic (BYOK) trust layer that sits under coding agents and refuses to ship claims that aren't backed by the real codebase. It combines repository memory, a deterministic grounding gate, and grounded review. Aimed at cutting hallucinated code and false claims of completion.
Two cold agents independently describe what a Claude Code project is supposed to do and what it actually does, then a deterministic diff surfaces every point where the two accounts disagree. The independence is the point — neither agent sees the other's write-up. Useful for catching scope drift on long-running agent-built projects.
The seventh installment of a public build log for an MMO built largely with AI coding agents. This week shifts from feature work to game balance and UX design, with a Hacker News traffic spike that brought ~1000 players but very low retention. Honest numbers on where vibe-coded projects get hard after the prototype phase.
An Anthropic-compatible gateway that lets Claude Code talk to Anthropic, Bedrock, Vertex, or any OpenAI-compatible backend. It adds API key rotation, fallback chains when a provider errors, cost tracking, and a dashboard. Aimed at teams who need resilience and spend visibility across providers.
A small local proxy that lets agent CLIs like Claude Code and Antigravity talk to OpenAI-compatible providers. Supports Groq, Nvidia NIM, and Ollama out of the box. Handy for local or cheaper inference without changing your agent setup.
A remote control layer for Claude Code across four clients — phone, watch, web, and desktop — supporting approvals, prompt injection, interrupts, and model switching mid-session. It also adds workflow features: stronger task management with completion push notifications, scheduled tasks, inline Q&A, and structured transcripts. Self-hosted cloud bridge with end-to-end encryption. Documentation is in Chinese.
Runs tmux sessions in the browser with per-user isolation and shared projects, plus a read-only watch mode for observing someone else's session. The session list is Claude-aware, so agent sessions are identifiable at a glance. Useful for teams pairing on or supervising agent runs.
Addresses the case where Claude reads an odd-looking exception during an unrelated task and helpfully removes it, undoing a fix that took hours to discover. Vestige records the reasoning behind decisions so it survives new sessions and context compaction. Built by the maintainer in response to recurring memory complaints in the community.
A relay you run on your own machine plus native desktop and iOS clients for driving coding-agent CLIs remotely. Supports chat, voice input, and a multi-session UI. Everything stays on your hardware — no third-party service in the loop.
Surfaces Codex and Claude subscription usage as a native bar widget in Dank Material Shell. Keeps quota visible in your desktop panel instead of a separate app. Niche but well-targeted for Linux users on that shell.
A career assistant that searches listings, tracks applications, and helps you tailor materials, exposed three ways — CLI, MCP server, and agent skill. Works with Claude Code, Codex, OpenCode, and WorkBuddy. Useful pattern for shipping the same tool through multiple agent surfaces.
Manages fleets of coding agents from one view with real terminals, live context and cost readouts, and agents that can message each other. Spans your Mac and any Linux box you point it at. Built for people running many concurrent agent sessions rather than one.
A context optimizer for Claude Code, Codex and Cursor that compresses Git diffs, summarizes history and enforces a per-session token budget. The author claims up to 70% lower token usage. Worth a look if long sessions keep blowing through your context window.
A macOS menubar app showing today's token spend, cost and remaining rate-limit headroom for both Claude Code and Codex. One click gets you the current numbers without dropping into a terminal. Useful for staying ahead of a limit reset mid-task.
A free, open-source agent plugin that scans long-form video and pulls out the moments worth cutting into short-form content, instead of you scrubbing the timeline guessing. Works across agents, with the author's testing documentation included in the repo. Aimed at creators and marketers sitting on hours of unedited footage.
An orchestrator that runs Claude Code, Codex and other coding agents behind one harness with request routing, shared project memory and live tool results. Its code-mode harness is meant to reduce the number of inference boundaries a task crosses. For people juggling several CLIs on the same codebase.
A Windows-focused memory layer that captures sessions automatically, compiles them nightly into a knowledge base, and injects BM25/FTS5 search results into every prompt. Built for Claude Code, with other agents reading the root map from AGENTS.md and querying over MCP. Stdlib-only with no vector database, which keeps setup light.
A local control room that keeps concurrent Claude Code agent sessions from stepping on each other, and juggles several Claude subscriptions with live hand-off between them. Useful if you routinely run more agents than one plan's rate limits comfortably allow.
Indexes every local coding-agent session straight from the agents' own log files, giving you searchable session state without extra instrumentation. It also runs agents inside containers that never touch your real working tree.
Launch Claude Code through `stvena claude` and get a review and control surface alongside the terminal: changed files and hunks visible while the agent is still working, with the ability to jump straight to suspicious code. Built to kill the terminal-to-editor-and-back loop when reviewing agent edits.
A small Rust tray applet for Linux that surfaces what /usage reports — your 5-hour session quota and weekly quota, along with reset times. Keeps the limit visible without interrupting a session to ask.
An open-source harness that scores coding-agent replies against ADHD-friendly 'do not bury the lede' rules using regex, structure, and heuristics — no LLM judge, so the same input always yields the same score. Produces a Markdown leaderboard; the demo runs without API keys and separates a good chat (~76.9) from a buried one (~7.9).
Discovers, browses, and cleans up AI agent sessions across platforms from one place, shipping as a single Go binary with both a CLI and a web UI. Aimed at the pile of stale session state that accumulates when you run agents daily.
Walks Claude in Chrome through opt-out flows on people-search and data broker sites, keeping all your personal data on your own machine and requiring your approval for every request. Each site integration is an open JSON file backed by a screenshot of the opt-out page it was built from, so the automation is auditable.
An open-source desktop app for running many Claude Code and Codex sessions at once, both locally and on other computers you own. Sessions run in a host process and survive closing the window, with live status, diffs, and usage collected into one workspace.
Claude Code writes a full JSONL transcript of every session to ~/.claude/projects — 596 MB in the author's case — undocumented, organized by directory, and often larger than any context window, so in practice the work is lost. This builds a local index over all of it and wires results back into live sessions through hooks, addressing both starting from nothing between sessions and compaction discarding your exact wording within one.
Reads git history alone to identify which files parallel work streams are likely to fight over, with no tokens spent and no configuration. Handy for deciding how to split tasks before launching several agents at once.
A small self-hosted web UI for reviewing the changes on a local branch, without pushing anywhere or opening a pull request. Fits the loop where an agent produced a branch and you want to read it properly before it goes anywhere.
A linter for your .claude/ directory that reports what is broken and what has been deprecated. Each finding cites the specific documentation that backs it, so you can verify the claim instead of trusting the tool.
A local macOS app that renders your Codex and Claude Code activity as a single visual map of the journey. Aimed at seeing the shape of a long stretch of agent work rather than scrolling back through transcripts.
A Claude Code agent given one open-ended prompt — play Ultima Online however you see fit — running fully autonomously on a live MMO shard for over two hours. Notable moments include the agent choosing to attend an in-game server festival after an NPC mentioned it; the author reports a clear improvement over an earlier Opus run of the same setup.
A self-hosted web terminal over tmux that lets you run Claude Code and Codex on your own machines and take over from a phone or tablet. Supports a multi-machine mesh, end-to-end encryption, and terminal sharing.
A macOS Markdown editor where Claude Code, Codex, or Ollama edit your documents in place, with review and undo around every change. No terminal, no API keys, and no setup required.
A CLI that takes structured Markdown notes generated by Claude Code and files them into an Obsidian vault. Closes the loop between agent output and a personal knowledge base you already maintain.
A browser extension that hands the current page to local agent CLIs — Claude Code, Copilot CLI, OpenCode, Cursor CLI and others — for web information gathering and browser automation. Keeps the agent local while giving it a real browser session to work from.
The computer-side half of Tapproval, which forwards Claude Code's approval prompts to an Apple Watch so a long run does not stall waiting on you at the keyboard. Open, auditable, and written against the standard library only.
A monochrome Plasma 6 panel widget that shows usage limits for Codex, Claude Code, and GitHub Copilot side by side. For KDE users who want the quota visible in the panel instead of checking /usage mid-task.
A CLI that turns whatever Claude Code, Codex, Cursor or Gemini CLI produces into a hosted artifact at a stable URL. Each publish is versioned, and the page carries comments so reviewers can respond in place. Useful when you want to hand a generated prototype to someone without setting up a repo or deploy.
A dev container built so you can skip permission prompts safely: egress is filtered to an allowlist, git is local-only, taint detection flags data that came from untrusted input, and everything is audited. The premise is that yolo mode is fine if the blast radius is bounded. A solid answer to the 'agent wiped my machine' genre of post.
Reads your local Claude data and reports the day's tokens, API-equivalent cost, commits and lines written, with the line counts scaled against familiar codebases for perspective. Runs entirely offline — zero tokens spent, no network calls. More fun framing than the usual usage dashboard.
Converts any Claude artifact or web page into a pixel-accurate PDF with no page breaks cutting through content. The continuous-page output is the point: long dashboards and generated documents survive export intact. Useful for archiving or sharing artifacts outside the Claude UI.
Press a hotkey, speak, and the transcription lands in whichever coding agent you have focused. Runs Parakeet and Gemma locally, so audio never leaves the machine, and works on Windows, macOS and Linux. A genuinely useful input method for long prompts you would rather not type.
A notes app that shells out to whatever `claude` is on your PATH using `claude -p --output-format text`, so there is no API key to paste and your existing subscription pays. Every AI change arrives as a diff you accept hunk by hunk rather than an in-place rewrite. If the CLI is missing it says so instead of silently degrading.
A Tauri 2 and Rust overlay showing remaining quota across MiniMax, DeepSeek, Claude Code, Cursor, OpenRouter and relay providers in one floating window. Runs on Windows, macOS and Linux. Aimed at people juggling several subscriptions who want one place to see burn rate.
A Rust replacement for the built-in multi-edit path that snapshots files before editing and verifies the result afterwards, so a partially applied batch is detectable and reversible. Targets the failure mode where a multi-file edit half-lands and leaves the tree inconsistent.
A self-hosted daemon that keeps Claude Code running on your machine, with web, VS Code and Android clients to talk to it. Sessions survive you closing the laptop. One of the more complete takes on remote Claude Code, given it ships three clients rather than just a web view.
A relay that fronts Claude Code, Codex, local and AG-UI agents behind chat clients, so a session can be started and steered from Discord or Teams. Multi-frontend by design rather than bolted to one platform. Useful for teams that already live in a chat tool.
An enhanced fork of CC Switch focused on managing a single skill library across projects and agents, so skills stop being copied per-repo. Keeps CC Switch's provider-switching lineage. Chinese and English documentation.
Exposes other locally installed AI CLIs to your coding agent, so Claude Code can delegate to whatever else you have running. Turns a collection of separate tools into something one agent can orchestrate. Sparse documentation, but the idea is clear.
An open-source platform that traces LLM calls, tool invocations, prompts, costs and full agent workflows using OpenTelemetry, with an evaluation layer on top. Standard instrumentation means it slots into existing observability stacks rather than being another silo. Mature project relative to most agent-monitoring tools.
Tracks how Agent Skills mutate as they get copied between repositories, surfacing the variants of a given skill. Useful for finding the version someone actually improved rather than the first search hit. A view of the skill ecosystem that did not exist before.
A menu bar app covering Claude Code, Cursor and Codex with provider switching, a live session monitor and token usage in one place. The provider switching is what separates it from the pile of usage-only menu bar widgets. macOS only.
A macOS companion reads Claude Code usage locally and syncs it through the author's own iCloud to an iPhone app with a Home Screen widget. Built for a setup where a Mac mini runs the agent and the phone is the interface. No account and no third-party cloud in the path.
A Chrome tool that lets you pick any element on a page and forward it, along with a prompt, to a coding agent running in cmux. Closes the gap between seeing a UI bug and describing where it lives. Requires cmux on the receiving end.
Tracks tokens and spend across Claude Code, Codex and Cursor, then converts finished sessions into reusable Skills and long-term memory. The distillation step is the interesting half — most trackers stop at reporting numbers. Open source and local-first, with Chinese and English docs.
A browser extension that injects usage meters into the claude.ai composer: 5-hour window, 7-day window, a local tiktoken estimate and a countdown to the cheaper cache window. It hooks fetch and XHR through an injected script and passes responses to the content script via postMessage. Knowing where the 5-hour window sits decides whether a long refactor starts now or after reset.
A task tracker built on Convex that Claude Code operates directly, so tasks are created and closed from inside the session rather than in a separate app. Personal-scale rather than team project management. Requires a Convex deployment.
A registry where teams publish and discover Agent Skills, designed to be read by agents rather than only browsed by humans. Free forever per the author. Fills the internal-distribution gap between a personal skills folder and a public marketplace.
Treats agent sessions as versioned artifacts you can share and pick back up, across Claude Code, Codex, OpenCode and Cursor. Lets a colleague resume the session that produced a change rather than only reading the diff. Useful for handoffs and for reproducing how something got built.
A gateway that fronts several model providers behind one unified API, so clients target a single endpoint and routing happens server-side. Open source. Crowded category, but a straightforward self-hosted option.
Maps Claude Code permission requests onto an Ulanzi D200 stream deck: approve, always-allow or deny with a physical key, while the display shows each session's state and context window usage. Turns approval into a glance-and-tap instead of a window switch. Requires the specific hardware.
A small macOS bash utility that watches a Claude Code session and sleeps the machine once it completes. For long unattended runs you start before leaving. Does one thing, in a shell script you can read in a sitting.
Reads Claude Code and Codex transcripts off disk, prices each session, and explains in plain English what you overpaid for. The diagnosis angle separates it from trackers that only show a total. Runs locally against files you already have.
A toolchain that installs multiple coding agents, gives them a shared context, and runs them alongside each other. Aimed at people who switch between agents and are tired of maintaining parallel configs. Early but the shared-context piece is the useful part.
Reads on-disk sessions from Claude Code, Codex CLI, Gemini CLI, Antigravity, Copilot Chat, Cursor, Cline, Roo Code, Continue and Aider plus three chat apps, with filtering, redaction and export — and can copy a session back into an agent to resume it. CLI and local web UI. The redaction step makes sharing transcripts practical.
A Go TUI that shows your agent's changes as they land and lets you review them without leaving the terminal. Supports both Codex and Claude Code. For people who want the review loop in the same window as the work.
Shows remaining quota, weekly utilization and usage history for both Codex and Claude Code from the menu bar. Bilingual Chinese/English. Another entry in a crowded category, distinguished mainly by covering both tools and keeping history.
A Chrome extension giving Codex, Claude Code and OrcaRouter browser tools and local workspaces, so an agent can act against pages you have open. Open source. Overlaps with headless browser MCP servers but keeps you in your real, logged-in browser.
Memory infrastructure for agents where knowledge is versioned and concurrent writes resolve without clobbering each other. Self-hosted. The conflict-safe write handling is what most agent memory stores skip and then regret at multi-agent scale.
An IDE for register-transfer-level hardware design with agent assistance built in. Niche relative to the usual web and backend tooling, which is exactly why it is worth noting — agentic tooling for HDL work is thin on the ground. Early stage.
Runs Claude Code locally and exposes it through Telegram with no tunnel, no webhook and no cloud relay in between. That constraint is the design: nothing about your session leaves your machine except the messages you send. Straightforward setup for phone-driven sessions.
A Windows tray app written in C17 with no runtime dependency that syncs coding agent usage and cost to Tokitoki. Half a megabyte total. Notable mostly for how small it is next to the Electron alternatives in this category.
Routes Anthropic-protocol requests to different upstreams based on the model name requested, with a console modeled on cc-switch. Runs locally. Chinese-language documentation.
Pick a time window, hit revive, and each crashed Claude Code or Codex session reopens in its own terminal tab — resumed, in the correct working directory. Windows, macOS and Linux, with no daemon running in the background. Directly useful after a machine restart or a terminal crash takes out a batch of sessions.
A macOS desktop and always-on Docker app tracking Claude and OpenAI/Codex quotas plus every agent session in real time: tool calls, files touched, token usage and analytics. Local-first with SQLite, SSE streaming and encrypted credentials, and no telemetry leaving the machine. More depth than a quota widget.
A Claude Code agent that produces methodologically rigorous statistical reports from the microdata of Uruguay's INE Continuous Household Survey. The user fills in guided forms instead of writing code, and the agent handles the analysis and write-up. A concrete example of pointing Claude Code at a public statistical dataset as a domain workflow.
Generates job-hunting material — resumes, interview talking points, technical articles — directly from a repository's commit history. The AI reads commits, diffs, and source to infer what problems were solved and how, while the bundled scripts only collect raw data. An interesting inversion of the usual "summarize my repo" tool.
A native desktop host for AI coding agents that speaks the Agent Client Protocol, written in Rust with GPUI. Runs many concurrent sessions against the same project root and includes a lightweight editor and terminal. An alternative to terminal-only workflows when you want several agents side by side.
Checks npm dependencies suggested by AI coding agents against ground truth, flagging packages that do not exist or that squat on a plausible-looking name. Runs before the dependency reaches your lockfile. Addresses a real and growing supply-chain risk in agent-written code.
A starter for building an agent harness on Buda's API Claws, combining an agent skill with a runnable TypeScript quickstart. The goal is to drop a hosted AI agent into an existing device, app, or SaaS product without building the loop yourself. Vendor-specific, but the quickstart is a reasonable reference for harness structure.
A CLI that stores each feature flag or experiment as a Markdown file checked into the repo, then generates a typed client that assigns variants locally with no network call. It also writes dif/context.json so Claude Code starts each session knowing which experiments are active and what earlier ones concluded. dif init installs three project skills for mapping routes to surfaces, authoring flags, and concluding experiments.
A desktop app plus Rust TUI for supervising many AI coding agents (Claude Code, Codex, OpenCode, Cursor, Aider, Antigravity) working across multiple repositories. Sessions are tmux-backed, and agents coordinate through durable "fleet mail" with policy-based supervision. Useful if you run several agents in parallel and want one place to watch and steer them.
A plugin collection published by Braintrust, the LLM evaluation platform, aimed at coding agents. The repo description is minimal, so check the source for exactly which agents and workflows are covered. Relevant if you already run Braintrust evals and want them reachable from an agent session.
Processes Claude Code session transcripts into notes in a local Obsidian vault, filtering out routine agent output and keeping the decisions you actually made. The result is a durable, searchable record of project reasoning that outlives the session files. Good fit if you already keep engineering notes in Obsidian.
A small Herdr add-on that detects the agent running in each pane (claude, codex, and others) and publishes it as an $agent_kind token for the sidebar, alongside the agent name. Makes a multiplexed session readable at a glance when you have mixed vendors running side by side. Only useful if you already use Herdr.
Open-source macOS app that attaches whatever you are looking at to your next Claude Code prompt — press both Option keys and the active window or webpage is captured as a screenshot plus full markdown text. Text comes from the accessibility tree, so content scrolled out of view is included; hold Shift for markdown only. Works across the CLI, desktop app and IDE extensions.
Agent workspace that keeps sessions, files and commits under your control rather than a vendor's, and reaches the same work from desktop or phone. Connects to Claude Code, Codex, OpenCode, Pi, Grok, DeepSeek Harness and Antigravity through ACP, so the harness is swappable.
Statusline plugin that makes it obvious when Claude Code quietly drops you to a different model or effort level. Renders a theme-proof full-width alarm covering model, effort, thinking level and rate-limit pressure, so a downgrade mid-session is caught instead of being blamed on the model getting worse.
Build story for an online poker app made for a friend group after their old site shut down, taken from a 40-minute prototype to a paying product. Claude Code handled game logic and front end, with Postgres replacing an early SQLite-plus-ngrok setup and Claude Design plus Gemini used for UI. Worth reading for the progression from pet project to production.
Single local board showing claude, codex and gemini CLI sessions as kanban cards, each with an attached PTY terminal you can type into. Also surfaces transcripts, health scores and cost per session. Local-only with no backend, so nothing leaves the machine.
Multi-tenant, self-hostable application that runs departments of agents — marketing, engineering, plus a CEO agent that reads each department's morning digest and briefs you. Every agent is a real Claude Code or Codex CLI running as a persistent process, driven by your own subscription or local models.
Time tracker that records both your hours and your agents', shipping a CLI, a TUI, agent skills and an MCP server so Claude Code can log its own work. Data format is Watson-compatible, so existing tooling and exports keep working.
Provisions cloud machines that mirror your local setup so Claude Code and Codex can work on a real replica of your environment instead of a bare container. Forking takes seconds, which makes throwaway machines per task practical.
Runtime that gives engineering agents a shared, project-scoped environment instead of each session starting from nothing. Both Codex and Claude Code attach to the same runtime, so state and context stay with the project.
Coordinates Claude Code, Codex, Antigravity and Cursor running on separate accounts as a single crew, driven over tmux with a web console and verified delivery of each task. Aimed at people juggling multiple subscriptions to work around per-account limits.
Bridge that hands an in-progress Claude Code session to Feishu/Lark so you can start at the desk, follow up from your phone, and return to the same session unchanged. Keeps one continuous conversation rather than spawning a separate mobile session.
Sits after whichever coding agent wrote the code and runs an independent review, producing evidence and an explicit acceptance decision rather than a summary you have to trust. Positioned as the trust layer for teams merging large volumes of AI-generated diffs.
Computer-use automation that runs several browser and native macOS tasks at once without stealing your keyboard focus — the usual failure mode when an agent drives a real desktop. Built specifically for Claude Code.
Long, candid account of building an opinionated personal-finance app solo with Claude Code, from years of failed pre-agentic attempts to a shippable product. Notable for the honest cost side — the author describes it displacing most other parts of life — alongside the design and tooling decisions.
Kanban board where each card is a markdown file for one branch, and column state is read live from git worktrees and pull requests instead of a separate database. No login, no server, no dependencies; Claude Code and Codex interact with it via a skill, hooks or MCP.
Sets up Claude Code, Cursor, OpenCode, Codex, Pi and others from a single choice of options: persistent memory, spec-driven development, curated skills, MCP servers, personas and optional bounded review. Open source and deliberately free of agent lock-in.
Liquid Glass overlay that collects the moments your agents need you — questions and pending tasks — into one surface, and sends your answers back into the sessions. Solves the babysitting problem of several agents each blocking on a different terminal.
Desktop harness that arranges the coding CLIs you already pay for into a self-coordinating crew, with per-agent memory, mailboxes and desks laid out on a 2D floor plan. Pre-alpha and built in public, so expect rough edges.
Flips Claude Code into a teaching loop by quizzing you on the code that just landed in your diffs and tracking which areas each developer keeps getting wrong. Aimed at the problem of shipping agent-written code you do not actually understand.
Self-hosted control plane for running Claude Code and other harnesses on infrastructure you own, built for teams but usable solo. The author walks through the reasoning for owning the control plane as agent processes scale, with a long explainer video linked.
Keeps project context as plain markdown in git, retrieved through a catalog and a graph rather than embeddings, so there is no vector database to run or keep in sync. Everything stays diffable and reviewable like the rest of the repo.
Your coding agent writes the check plan for each patch, human playtesters actually run it, and you get a report back per build. Bridges the gap where automated testing cannot judge whether a game feels right.
A task runner that gives every parallel task its own git worktree and its own Claude Code agent. Its main contribution is visibility: a dashboard-style view that surfaces which of the running agents is actually blocked and waiting on you. Useful if you routinely juggle several agent sessions and lose track of which needs input.
Audits a Claude Code session and reports the full set of file changes it made. The interesting part is that it separates changes you explicitly asked for from changes the agent applied on its own initiative. Good safety net for reviewing long unattended sessions before committing.
Wraps Claude Code in a longer-lived process that belongs to the repo rather than to one terminal session, owning conversation, task identity, repo context and execution environment. You can walk away from the terminal and keep steering the same work from Telegram or a web dashboard, and the underlying CLI can restart without losing agent identity. Supports worktrees, Docker, and Codex as an alternative harness.
A statusline framework that shares rendering and data-lookup primitives across harnesses, with one thin adapter per CLI so the same statusline config works in Claude Code and elsewhere. Python 3.8+ with zero dependencies. Worth a look if you maintain statusline setups across more than one coding agent.
A headless local-first coding agent written in Rust (axum, tokio, rmcp, portable-pty) exposed over HTTP + SSE, with an Angular 20 zoneless client and a Tauri 2 desktop shell. Supports Anthropic alongside OpenAI, Z.ai and Ollama, and includes an MCP bridge, a permission engine and a PTY terminal. An alternative harness rather than a Claude Code add-on, but the MCP and permission plumbing is worth studying.
A menu bar app that shows at a glance which Claude Code or Codex session is blocked, working, or done. Useful when you run several agent sessions in parallel and keep tabbing between terminals to find the one waiting on you. Offline, no telemetry, MIT licensed.
A family of single-binary CLIs that wrap your stack from the inner build/test loop out to changesets, releases and your Claude Code setup. Native builds for macOS, Linux and Windows with no runtime to install. Useful if you want one consistent command surface an agent can drive.
Reads the logs your AI coding agent already writes locally and renders a stat card you can commit into the repo. Gives a lightweight, shareable view of how much agent work went into a project. No account or API needed.
Turns the MacBook notch area into a workspace for Claude Code, Codex, CodeBuddy and other coding agents. Keeps session state visible without giving up screen real estate to another window. Local-first with no cloud component.
Wraps each coding agent CLI behind an HTTP API, with every agent isolated in its own sandbox. Makes it possible to call agents from other services or scripts instead of driving them interactively. Useful building block for automation and CI.
Adds durable memory to Claude Code and other agent CLIs, storing everything as plain Markdown on your machine with a consolidation step that keeps it from sprawling. No API key or hosted service involved. Aimed at the recurring problem of agents forgetting what happened last session.
Runs Codex, Claude Code, Gemini, Cursor and ACP agents side by side with shared history, permissions, handoffs and audit logs. Aims to be the single place you supervise a fleet rather than juggling per-tool UIs. Open source and self-hosted.
A FastAPI project template structured for services that coding agents will build and keep maintaining, rather than one optimized purely for human readers. Conventions and layout are chosen to be unambiguous to an agent. Good starting point for agent-authored backends.
A read-only diagnostic that reports the effective runtime state of Claude Code and Codex environments — what is actually loaded and configured, not what you think is. Useful when an agent behaves differently across machines or a config change silently did nothing. Makes no modifications.
A single Go binary that displays Claude Code and Codex usage in tmux: per-account gauges, rate limits and reset times, always visible. No runtime dependencies to install. Useful if you juggle several accounts and want to see which one still has headroom.
Project management built around tracking the intent behind work rather than just tasks, so context survives across agent sessions. Aimed at developers whose plans keep getting lost between runs. Durable storage rather than in-context state.
Desktop companion covering sessions, Git state, code review and development processes for several coding agents including Claude Code, Codex, OpenCode and Antigravity. Local-first with no hosted backend. Aims to be the place you supervise work rather than the terminal.
One-click installs skills straight from GitHub, manages them via symlinks so nothing is copied, and aggregates newly published skills across the web daily. Pure Node with zero dependencies. Solves the growing problem of tracking and organizing dozens of installed skills.
Gives each account its own macOS window with its own CLI login and a live rate-limit bar. Lets you move work to whichever account still has quota without logging in and out. Useful for anyone with a personal and a work subscription.
A regression harness that empirically tests whether a coding agent's permission and boundary settings really prevent the actions they claim to. Turns security configuration from a belief into an observation. Bilingual Korean/English documentation.
Manages project environment variables locally while withholding values you mark as protected from AI-agent workflows. Lets an agent run your app without ever seeing production credentials. Addresses a common gap when agents get shell access.
A delivery board designed around agents doing the work rather than bolted onto a human-first tracker, pitched as a Warp alternative. Team-oriented rather than single-developer. Worth a look if your kanban tool fights your agent workflow.
A personal assistant you run yourself that remembers what you tell it, carries long-running tasks through to a finished result, and reaches you on Telegram or in your terminal. Aimed at work that outlasts a single interactive session. Self-hosted with no cloud dependency.
A desktop workspace for coding agents that puts each project's terminals alongside its git state in a single view. Removes the tab-hunting that comes with running agents across several repos. Desktop native.
Shows your GitLab merge requests in a terminal dashboard focused on whose turn it is to act, and launches a Claude session preloaded with the full MR context from a single keypress. Removes the copy-paste step between review tool and agent. Terminal native.
A VS Code sidebar that names your Claude Code and Codex CLI sessions, lets you browse them and resume any one with a click. Includes auto-mode resume, session backup and switching between tools. Fixes the problem of forgetting which session held the work you want.
Scans GitHub for new and rising Claude skills, subagents and MCP servers, scoring them on momentum, trust, and whether the repository actually contains what its description claims. Explicitly detects star-farmed repos. Useful given how much of the skill ecosystem is now noise.
A Linux-native session manager built after the author found the desktop app and other Linux options lacking, forked from agent-session-manager. Manages multiple sessions including existing ones, has a GUI prompt editor with saved drafts, a model picker, automatic PR tracking via gh, attachments panel, git panel and split terminal. Works with subscriptions, no API key needed.
Connects Feishu or Lark group chats to agent sessions running on your machine, so a team can drive Claude Code or Codex from the chat they already use. Keeps the agent local while the interface is remote. Also supports pi.
A herdr plugin that collects the Linear issue, worktree, placement, agent kind, clauth account and initial prompt in a single dialog before launching a session. Compresses a multi-step setup into one form. Only useful if you already run herdr.
A local kanban board for one developer and their coding agent, where a card can only reach done when the command you declared for it passes. Removes the gap between an agent saying it finished and the work being verifiably finished. Runs entirely locally.
An ASO copilot for iOS covering keyword rankings and growth analysis, positioned as a free alternative to the Astro MCP service. Handles the research side of app store listing work. Useful for indie developers shipping iOS apps.
Compresses noisy Bash output from Codex and Claude Code before it eats your context, locally and deterministically, with the original recoverable. Unlike summarization it does not lose information you might need later. Targets build and test logs specifically.
Captures raw API traffic, does token accounting, and provides a live web inspector showing what Claude Code is actually sending and receiving each turn. The right tool when you want to know where your tokens went rather than guess. Useful for debugging cache behaviour and context bloat.
Sweeps a machine and lists every coding agent, MCP server, plugin and AI extension installed on it. Read-only, so it is safe to run anywhere including a machine you have inherited. Useful for security review and for finding the MCP server you forgot you installed.
A Claude Code plugin running short-form and long-form social content end to end: storyboarding behind adversarial quality gates, video production, human-approved publishing, and autonomous growth loops. Ships its own MCP server exposing 46 tools. Substantially more complete than a posting integration.
Watches Claude Code and Codex quota inside KDE Konsole and resumes a rate-limited session automatically — but only when terminal, process identity, prompt, quota and policy all agree it should. The multi-signal check is what keeps it from resuming the wrong thing. Python 3.12+ with no runtime dependencies.
A job queue that serializes expensive compilation, keeping several agents' cargo builds from competing for the same cores. One dependency-free bash script for macOS and Linux, bash 3.2 and up. Small, obvious, and fixes a real problem once you run more than two agents.
A Docker wrapper around the Claude Code CLI that handles directory mounts and environment config setup for you. Useful for keeping Claude Code isolated from the host or reproducing the same setup across machines. Low-ceremony alternative to hand-rolling your own devcontainer.
A macOS menu-bar-style app that renders your AI coding usage limits inside the MacBook notch area, so quota state is always visible without opening a terminal. Aimed at people running long agent sessions who keep hitting rate windows unexpectedly. Small, single-purpose utility.
A Stream Deck setup that fronts six concurrent AI coding agents from a single physical panel, built around OpenCode. Each key maps to an agent so you can switch focus and monitor state without window juggling. Relevant to anyone running several agent sessions in parallel.
A sovereign, reproducible orchestration stack running entirely on your own machine: Claude Code alongside Ollama, LiteLLM, adaptive routers, a Redis cache, PostgreSQL, and Langfuse for tracing. Local and cloud models are exposed through one unified interface. Documentation is in French; useful if you want observability and model routing without a SaaS dependency.
I don’t have max plans, or I’d do it myself. But I wanted to see if any of you have published or run across something like this. Basically: Pick a medium-complexity software development task/projec...
Cross-session memory for Claude Code projects via two in-repo docs: SESSION_PRIMER.md (current state) and LEARNINGS.md (hard-won bugs).
A live 3D world for your Claude Code sessions — one city per project, one street per session
Jamie Brown's portfolio site. Static, built with Claude Code and reviewed by hand. The site is the work sample.
Move, copy and back up your Claude Code chats across accounts — a 4 MB app for macOS and Windows, plus a zero-dependency CLI
Agent skills for making an AI-built application production ready: diagnose what is missing, then install only what fits. Each skill routes to TrustyCap's published decision surface rather than rest...
Local-first preference memory for coding agents — learns how you work once, applies it in Claude Code, Codex, and OpenCode. SQLite + on-device learning, no fine-tuning.
I spent most of the weekend + over 500M tokens auditing and optimizing my token usage. I mostly work in the Claude Code app and have Claude dispatch to CODEX for code reviews; sometimes work direct...
The reachpad CLI: workspaces where Claude, Codex and other coding agents build full-stack apps and share them by link, from your terminal.
# PRE-LAUNCH INSTRUCTION SET FOR AGENT DEVELOPMENT WORK Read this fully before your first action. Return the §14 pre-flight response, then wait. --- ## §1 DIAGNOSE BEFORE YOU CHANGE Reproduce the p...
Hi, I am using the claude code on claude desktop app and using it for just learning about AI and python. Problem i am facing is claude code interface is not too dopamine giving which my brain crave...
A complete, working CLAUDE.md written as a character sheet instead of a rulebook — plus the conversion recipe and an honest long-run operating record. Companion to claude-stall-tools.
Effortlessly switch between multiple concurrent AI coding agent terminal sessions (Claude Code, OpenCode) — a macOS app by Super Logic AI
Project control for Claude Code: requirements enrichment, anti-drift execution, context recovery, agent orchestration, and verified convergence.
I have been having fun building myself tools that better suit my use case. I built myself a cocktail app and a couple friends wanted access, so I put it on App Store, but my pride required that I i...
Claude Code usage governor: compact professional output, context slimming, tool-output filtering, telemetry, and drift guardrails.
I've started building a personal assistant that lives on a Mac Mini M4 (16GB) in my house and talks to me through Discord. It runs on the Claude Code SDK, so it isn't a chatbot with a nice prompt: ...
I've heavily invested in setting up my Cowork workspace (following Jeff Su's tutorials ) and regularly reach the weekly usage limit. I want to start building simple things for myself and potentiall...
Hello! I’ve been working on shared memory for coding agents lately. its an open source project: https://github.com/mex-memory/mex The obvious way to build it is some shared backend that every agent...
I love Claude and I would even use it before dumping one into the toilet. It is an awesome tool and is even more awesome if someone knows what he is typing into it! That leads me to my questions an...
TL;DR: Originally posted on r/1f916 . I made public the runner I use for my unattended Claude Code agent living on 1f916.ai . It is not a product, and not a sandbox, but a documented experiment: a ...
TL;DR: Given the size of my project(s), I was wondering if a bigger CLAUDE.md could increase p(error). I use Claude's CLI to run an experiment on different sized CLAUDE.md files. I thought there wo...
I have a strong suspicion that Claude Code is deeply optimized for Anthropic’s own models (especially Opus and Fable) and that performance drops noticeably when you try to run it with other LLMs. H...
Turn Claude Code conversations into per-project Kanban boards — tasks, recommendations, next steps & learnings, extracted by Claude itself (no API key).
Something happens on your computer, the devices around you react. RGB keyboards, light bars, smart lights, screen and notifications for Claude Code, Codex, builds and scripts.
A shared memory layer that stores agent knowledge as a federated graph rather than flat files. It adds a trust model so facts from different sources carry different weight, and a measured utility loop that scores whether stored memories actually helped. Worth a look if you have outgrown append-only CLAUDE.md memory.
A self-hosted web UI that runs multiple AI coding agents in parallel panes so you can watch and steer them from one screen. It runs on your machine with your own API keys — nothing is proxied through a third party. Handy if you routinely juggle several agent sessions across terminals.
Gives coding agents a local message bus plus a searchable archive of past sessions. Agents can pass messages to each other, and you can query what happened in earlier runs instead of scrolling terminal scrollback. Aimed at multi-agent setups where context keeps getting lost between sessions.
An electronics design tool built around an agent loop: it takes a schematic through routing to a fab-ready zip while the human watches and steers. Rather than bolting a chat window onto an existing EDA suite, the whole flow is designed for agent authorship. A concrete example of pushing coding agents outside software.
A linter that scans commit messages, PR descriptions, and documentation for the stylistic tells of generated prose. It deliberately does not try to classify authorship — it just surfaces the specific patterns so you can decide. Useful for teams that want agent output to read like the rest of their repo.
A status line widget for Claude Code and your shell prompt that renders a pixel-art canary in UTF-8 block characters, drooping as your session wears on. Zero dependencies and no API calls — it reads local state only. Pure whimsy, but a genuinely lightweight example of a custom status line.
A one-command install that lets Claude Code, Codex, or Cursor deploy a site to simple-host.app without leaving the session. Beyond static hosting it provides a per-site backend with state, collections, private pages, and templates. Aimed at the gap between "the agent built a site" and "the site is live."
A hosting engine for the HTML artifacts your team's agents produce, deployed to Cloudflare Pages with Cloudflare Access in front and shareable links out. Ships as a Claude plugin so a generated page becomes a URL your teammates can open without a manual deploy step.
An MIT-licensed bundle that packages specialized subagents, MCP servers and skills together with a dashboard for watching them run. Useful if you would rather install one curated set than assemble your Claude Code extensions piece by piece.
A Claude Code plugin that moves sessions between profiles, containers and machines. Handy if you develop across a laptop and a dev box, or run Claude inside containers and want conversation history to survive the jump.
A PDF pipeline tuned for e-ink: 12pt typography, halftoned images and a measured table of contents, so markdown arrives on a reMarkable actually readable rather than shrunk to fit. Ships as both a CLI and an agent skill, so Claude can send you a document to read away from the screen.
Analyzes a coding agent session to pinpoint the exact turn where the prompt cache was invalidated, what that cost you, and what a better context layout would have saved instead. Runs entirely locally, which makes it usable on sessions you would not upload anywhere.
A rule-based phishing triage tool covering SPF/DKIM/DMARC verification, lookalike domain detection and BEC patterns, with findings explained in plain English and Spanish. Detection is heuristic and fully local — no email content leaves the machine — and the repo doubles as a worked example of a Claude Code-built security tool.
An iOS app for supervising coding agents while away from the desk: a session overview, push notifications when an agent needs you, command approvals straight from the lock screen, and voice conversation. Aimed at long unattended runs where the bottleneck is you not being at the keyboard.
A gateway that routes Claude Code, Codex and Pi to whichever model you choose, including a local one, while carrying memory across requests. The distinguishing feature is auditability: for any answer you can show which model produced it, what context it saw, and what it cost.
pdfvision searches a PDF's text layer first, returns each match with its page and a crop-ready region grown to the containing table row, then renders just that region as a high-DPI PNG. Every page carries quality signals naming the specific risk (scanned page, broken font map, flattened table). Runs via npx or as an MCP server; the demo session kept context at 4%.
A top-bar extension displaying Codex and Claude usage as a percentage of the 5-hour or weekly window. Clicking opens a popup with both windows per service, reset times, model-specific caps (Opus/Sonnet/Fable weekly), and credits. It reads the credential files Codex CLI and Claude Code already keep on disk and calls the same endpoints /status and /usage use — no extra sign-in.
The AI Code Outcomes Index measures revert rate, PR acceptance, and code survival broken down by agent, language, and repository, compared against a human baseline. Continuous, vendor-neutral, with a published methodology — useful evidence when arguing about whether agent-written code actually holds up.
A TUI for reviewing diffs, files, and documents where you attach annotations inline as you read. Handy as a human review surface over agent-generated changes, where a browser PR view is heavier than you want.
A one-screen policy declares what your agent's tools are allowed to do; frostagent fails the check on anything outside it, across MCP servers, hooks, permissions, and skills. A lockfile additionally fails when a tool's definition changes under you — the supply-chain case most agent setups miss.
Schedules Claude Code work against your available capacity so runs land inside usage windows rather than stalling halfway through when a limit hits.
Point it at any repository: it takes a backup, builds an understanding of the codebase, then ships improvements behind verification gates, with a live local dashboard showing what it is doing. TypeScript, public alpha.
Scans a repository for stale guardrails, modules with no context coverage, and missing documentation — the gaps that cause an agent to wander. Single command, no configuration ceremony.
A tiny, dependency-free reader that maps any terminal coding agent's on-disk session onto one shared model — activity timeline, token and cost telemetry, edited-files and to-do roll-ups — so review tooling looks the same across agents. Read-only, no network, no telemetry.
An always-on-top window for running Claude Code (or any CLI) that surfaces itself when the agent is actually waiting on you. Removes the tab-checking loop during long autonomous runs.
Mesh simplification, part splitting, texturing, format conversion, LOD generation, and web delivery compression, reading glb/gltf/obj/stl/ply plus STEP CAD. Every command emits a structured meshify.report/v1 manifest so an agent can act on results rather than parse prose.
Live token, cost, and burn-rate monitoring across eight AI coding agents on macOS and Windows, with a budget circuit breaker that stops a runaway agent before the next API call rather than after the bill. Also includes an MCP manager and on-device prompt compression claiming 40-70% reduction.
A local gateway exposing GPT-6 Astra, Sol, Terra, and Luna inside Claude Code, with rolling context, explicit model routing, and fallback that is visible rather than silent. For multi-model workflows where you want one harness and several backends.
Shows live usage quota for each of your Claude Code accounts — 5-hour and weekly windows, reset countdowns, and a recommendation for which account to run next. For people juggling several subscriptions.
Tracks tokens, costs, cache efficiency, and account limits for Claude Code, OpenAI Codex, and OpenCode, entirely locally. Built with Rust and Tauri, with optional Discord Rich Presence. Cache efficiency in particular is a number most usage trackers skip.
Instead of answering a muddled question directly, it decomposes it into an interactive mind map with Claude, so you can see the structure of what you are actually asking before committing to an answer.
An open-source, self-hosted runtime for Codex, Claude Code, Cursor, Antigravity/Agy, and Grok Build that keeps durable coding-agent workstreams reachable from Telegram or Discord. Durability across disconnects is the point, not just chat relaying.
An SSH client with SFTP, tunnels, and a database GUI, plus a secured MCP bridge so an agent can drive the same connections. A free cross-platform alternative to MobaXterm, PuTTY, and Termius.
Scans everything a coding agent reads, marks the session as tainted when it ingests something suspicious, and blocks dangerous follow-up actions. A direct, practical defense against prompt injection arriving through fetched files and pages.
Chat with Claude Code from Telegram using your own Pro, Max, or Team subscription, with live streaming responses, multi-tenant account support, and session management. Distinct from other Telegram bridges in handling multiple accounts.
An unofficial Discord plugin for Claude Code offering context tracking, session clearing, bot status, server management, and custom slash commands.
Pins the files your coding agents obey. The built-in trust prompt asks once, before you have read anything; agent-lock asks again at the moment a hook, task, or MCP command actually changes — which is when the risk appears.
Compiles any codebase into a markdown wiki meant to be trustworthy as agent context: SCIP symbol resolution grounds the claims and a citation linter keeps them honest. Output is plain markdown you own, with no graph database or SaaS in the loop.
Lets Claude Code, Codex, Gemini and Copilot CLI agents message each other as one team, so work can be handed between vendors mid-task. Implemented in bash and SQLite with no daemon and no framework, which makes it easy to inspect and hard to break.
An astrophotography pipeline that stacks lunar eclipse RAW frames from any camera brand, handling frame rejection, phase grouping, HDR-aware stacking and sliver rescue, plus PixInsight and Photoshop automation. It ships a Claude Code skill so the whole pipeline can be driven conversationally. Useful mainly as an example of wrapping a deep domain workflow in a skill.
A weekly devlog from someone building an MMO almost entirely through AI-assisted coding, covering player acquisition numbers, what the model handled well, and gameplay updates. The interesting part is the feedback loop: following player feedback doubled average playtime, and the author is candid about where the approach strains.
A bridge that surfaces an agent running on a remote machine inside your local herdr sidebar, so several machines' agents live in one pane. Niche unless you already use herdr, but a clean example of multiplexing agent sessions across hosts.
A Claude Code plugin that scans React Native and Expo apps for the things that get builds rejected by the App Store or Google Play before you submit. Saves a review cycle by catching policy and metadata problems while the code is still in front of you.
A plugin that lets you invoke Claude Code from within OpenAI Codex by shelling out to the claude CLI, so no API key is needed and your existing subscription is used. Read-only by default and works on macOS, Windows and Linux. Handy for getting a second model's read on a change without leaving the first tool.
A physical macropad-style controller where each key and knob can be bound to an AI automation or shortcut on your computer, with a companion app for visual configuration. Designed and built by the poster with Claude writing much of the code.
A review tool built for the human half of the loop: you look over documents and sites that agents produced, and loupe structures that pass. Fills the gap where agent output is voluminous enough that ad-hoc review misses things.
A menu bar scratchpad for capturing terms you do not understand yet. Each capture files itself under a topic, and a headless Claude Code run expands any selection into an illustrated study guide. A nice pattern for using headless Claude Code as a background worker behind a native app.
A linter for the instruction files that steer coding agents, covering AGENTS.md, CLAUDE.md, Cursor rules and Copilot instructions. Catches the ambiguity and unsafe guidance that make agents behave badly, in the one class of file nobody currently reviews.
A pipeline that converts videos into illustrated study notes with searchable text, subtitles, playback links back to the source timestamp, printable PDFs and presentation pages. Useful for turning long talks into something you can actually revisit.
A local control plane for Claude Code on Windows and macOS that lets you switch LLM gateways in one click behind a fixed endpoint. Includes SSE keepalive proxies, key pools with live balances, GitHub accounts with TOTP, a statusline and Telegram remote control. Heavy, but aimed at people juggling multiple providers and keys.
Runs a private AI agent on a phone by pairing an on-device Linux environment with remote Claude Code sessions, extensible skills, and persistent memory. The goal is a self-hosted mobile agent rather than a thin chat client over an API. Documentation is in Chinese.
Routes any task to a bounded portfolio of skills across Claude Code, Codex, Cursor, Jcode, Hermes, and other agents, so a task only receives the capabilities it actually needs. A prompt-injection firewall sits on the routing path. The least-privilege framing is the interesting part: capability scoping instead of handing every agent every tool.
A Claude Code plugin for renting cloud GPU or CPU nodes by the hour across vast.ai and RunPod. Ranks offers by true total cost — machine plus disk plus download time — rather than the headline hourly rate.
Transfers Claude Code session history from one account to another, via a menubar app or the CLI. macOS only.
A local memory and project-operations layer for Claude Code and Codex, backed by SQLite. Keeps project state and recall on your machine instead of a hosted service.
A desktop application for launching and watching multiple Claude Code and Codex sessions from a single window. Useful when you routinely run several agents at once.
Speaks aloud which of your parallel Claude Code, Codex or Cursor sessions has finished or is blocked waiting for an answer. Aimed at people who run several agents and lose track of which tab is stalled.
A native macOS meter showing usage for Claude Code, OpenAI Codex and DeepSeek in one place. Sits alongside your work rather than requiring a dashboard visit.
A native Swift menu bar app tracking usage limits across all your Claude Code and Codex CLI accounts, with live percent-remaining meters per rate-limit window, reset countdowns and low-capacity alerts. Local-first: no cloud, no telemetry, and it never touches credentials.
A zero-dependency Node console showing which agent sessions are alive, what each is doing right now, and on what timescale. No build step required.
A local AI compression layer that reduces Claude Code and Codex token consumption. Prompts are processed on your Mac and never leave the machine.
A floating macOS status island showing live AI coding state for Claude, Codex CLI and Codex Desktop. Local-first, with a bilingual English/Chinese interface.
A self-hosted AI gateway that unifies multiple channels and credentials — API keys and subscription accounts alike — with scheduling, failover, request logs and usage tracking.
Self-hostable chat rooms in which agents participate alongside the people they work with, rather than being bolted on as bots. Aimed at teams coordinating human and agent work in one place.
A local meter that detects the point where cheap agent steering gives way to repeated correction, constraint restatement, repair and operator serialization. Effectively a signal that it is time to stop and reset.
Exports and imports Claude Code sessions across machines, email accounts and app builds including Win32 and MSIX. Reverse-engineered and unofficial, MIT licensed.
A coding agent bundling an RPC plugin, sub-agents, hashline-based edits and MCP support. An alternative harness rather than an add-on to an existing one.
A local PDF and Markdown editor with real PDF text editing and redaction via PDFium compiled to WASM. Needs no API key — it drives Claude through your existing Claude Code login.
Reports what each skill costs per message, which skills never actually fire, and which SKILL.md mistakes silently break the rest of the library. A maintenance tool for anyone whose skills directory has grown unmanaged.
A desktop workspace for Codex, Claude Code, Kimi Code and OpenCode, running local-first. One surface for agents you would otherwise run in separate terminals.
Picks the cheapest Claude or Codex/ChatGPT model and effort level that can still complete a task. Explicitly framed as protecting your rate-limit windows rather than a per-token bill.
A Claude Code plugin and status line reporting per-key usage for claude-lb load-balanced setups. Narrow, but useful if you already run claude-lb.
An agent-agnostic cloud runtime supporting collaborative cross-steering and containerization, so several people can drive the same agent workload. Self-hostable.
Assembles a single-page morning brief locally from the apps you choose, prioritized for the work you actually do. Runs on macOS, Linux and Windows.
A macOS tray app that boards your Claude Code sessions as kanban cards and schedules them against your remaining quota.
A three-line Claude Code status line showing context depth, cross-session rate limits, and per-repo git state including worktrees.
Analyzes finished sessions to find work your expensive model kept repeating, and recommends routing it to Haiku or Sonnet. No realtime router and no extra LLM calls.
A file-first control plane for supervising Codex, Claude Code, Antigravity and other agents toward production. State lives in files rather than a database.
A color-coded two-row Claude Code status line showing model, context percentage, skill and workflow counts, plus 5-hour and 7-day rate-limit windows as progress bars. One-line install.
Records the reasoning behind each change so that git blame can explain not just who and what, but why. Aimed at codebases where most commits came from an agent.
Semantic recall over a memsearch store shared between pi, Claude Code, Codex and OpenCode, so memory follows you between harnesses.
A free plugin that compresses tool-result output, deduplicates context and compacts the system prompt, stacking on top of Anthropic prompt caching. Rust hot path with a Python fallback, fail-open by design. PolyForm Noncommercial.
Private, local-first continuity for terminals and AI coding agents, carried to your phone via a self-hosted encrypted PWA.
Reads your Claude Code transcripts and scores agent behavior over time, showing the reasoning behind every score. Entirely local — nothing leaves your machine.
A small menu bar app showing your Claude Code usage limits at a glance on macOS.
Bridges Claude Code to Telegram so you can drive sessions from a phone. Uses your Max plan auth rather than an API key and runs as a systemd service on your own machine.
Shows every AI coding session running locally, including ones your terminal has lost track of, and remembers what is still waiting on you after you have read it. Local, private and zero-dependency.
Watches RSS feeds and listing pages, matches topics you define, and sends an LLM-summarized digest by email or chat.
A lightweight macOS hub for tracking local AI usage and quota across your tools.
A CLI plus versioned Intelligence Packages and a sync engine that pushes agent context to Claude Code, Cursor, Copilot, Codex, Pi and OpenCode. Built for keeping a whole organization's agents in step.
An agent that keeps the VSCode Claude Code extension patched, re-applying its own patches as the extension updates.
A self-hosted gateway written in Go that puts project keys, budgets and usage tracking in front of CLIProxyAPI.
Sends Bark push notifications when Codex CLI or Claude Code finish, with optional LLM-written personas for the message.
A desktop IDE whose base unit is the agent conversation rather than the file: projects, resumable Claude Code sessions and persistent tmux terminals. French-language project.
Gives each task the relevant repository context, runs the checks that apply to it, and records useful lessons for next time.
A control plane for native CLI coding agents offering orchestration, persistent workflows, managed worktrees, durable results and host monitoring.
Analyzes real Codex and Claude Code sessions, finds workflow patterns you repeat, and converts them into reusable skills, checks, prompts and recommendations.
Uses a kanban board as the memory layer for AI-assisted development, so board state carries context between sessions. Public release of a tool developed in a private workshop repo.
A Jarvis-style desktop assistant for Windows that floats on screen, listens, and hands real work to Claude Code without making you leave your workflow.
Streams a live adversarial debate between two Claude personas on a topic you choose, directly in the terminal.
Pushes your Claude.ai usage limits to a GeekMagic SmallTV ESP32 WiFi desk clock, so the number sits on your desk instead of in a menu bar.
A Claude Code plugin providing a cyberpunk-styled kanban board, with task management exposed through MCP tools, skills and hooks.
Extracts structured triples from conversations, compresses context by around 75% and enables cross-session experience reuse. Built for OpenClaw and Deepseek Harness.
Runs Claude Code across several of your subscription accounts, switching to the next one when the current account is rate-limited.
Writes agent findings to a .attic/ directory so that after a context compaction the agent reads its notes instead of re-reading every source file.
A small Linux system tray indicator showing Claude Code usage limits. Fills a gap in a space dominated by macOS menu bar apps.
A desktop companion that animates your agents, offering a different interface for seeing and interacting with what they are doing.
A tmux plus systemd session pool that keeps Claude Code sessions running on a Linux box and lets you drive them remotely, with self-naming sessions and survival across reboots.
A developer juggling five to seven simultaneous AI sessions argues that code review, not generation, is now the bottleneck — and that the review venue matters when you cannot dump one-shot AI output into the company's GitHub. Presents a local-first alternative.
The author traces DeepSeek-V4-Pro's shallow tool-churning inside Claude Code to the size of the tool schema payload rather than the prompt: with 30+ MCP tool definitions visible on the planning turn, attention goes to tools instead of planning. we-need-ds is a transparent proxy that fixes it without prompt injection or shutting off MCP.
A hobbyist rebuilt the bots for an old favorite game with Claude: on-the-fly pathfinding through a fully destructible voxel world, skill levels, aiming error, tunneling and role-based behavior. Reported as a long back-and-forth that no other model came close to completing.
Lets you reply to a running coding session, start a new one, or open a tab in iTerm2 from Telegram. The bot token lives in the macOS Keychain and no ports need to be opened to the internet.
A tool that finds different implementations of the same problem, not just copy-pasted code. The review mode checks git changes against the rest of the codebase for an existing equivalent, which matters most in large or poorly maintained projects. Integrates with Claude Code.
A developer of ten years built a free 3D voxel browser MMORPG on Babylon.js and Colyseus with Claude Code over two months, without reading most of the generated code. A substantial data point on how far the approach scales.
A standalone, free multiplayer remake of the StarCraft 2 custom map, built from an empty Godot project with Claude in limited spare time. Includes built-in bug reporting.
Claude Command Center's last five releases added ccc send and ccc ask for messaging a running session from the terminal, a five-minute dashboard self-check that surfaces silent local failures, and an Ask tab on the status rail.
A free ER-diagram designer that runs in the browser, VS Code, or off Google Drive. It exposes an MCP server and a Claude Code plugin so an agent can read and edit the schema diagram directly. Exports DDL for seven database engines.
A Claude Code statusline that shows the active model, rate limits, per-model weekly quotas, context usage, and git state. Renders in truecolor with Nerd Font glyphs, so quota headroom is visible without leaving the session.
A locally run pipeline built on Claude Code that searches job postings, scores and ranks them against China-specific hard filters (degree, hukou, outsourcing), then drafts outreach messages and a Chinese resume PDF. Personal data never leaves the machine.
An open-source app for running multiple coding agents across multiple machines with defined stage transitions — for example, In Progress to Review requires a human, Review to PR is automatic. A companion iOS app gives you a remote terminal and notifies you when an agent needs input.
A Mac utility that buzzes the trackpad instead of playing a sound when an AI coding agent wants attention. The office-friendly sibling of peon-ping, for people who cannot have notification chimes going off all day.
A lean agentic-RAG memory store for Claude Code backed by PostgreSQL and pgvector. The agent retrieves from its own past work rather than depending on a summary that drifts away from what actually happened.
Turns written descriptions into polished standalone HTML diagrams across 9 chart types and 5 themes, with optional high-res PNG export. Runs entirely locally with no telemetry.
Runs coding agents through Telegram with one topic per agent, live status shown in the topic icon, and two-way chat with inline buttons for choices. Gives you terminal-grade control of a session from a phone.
Simulates users and environments against your skills and instruction files to surface trigger misses, skill collisions, stale assumptions, and silent behavior failures. Catches the cases where a skill quietly never fires.
An agent-first kanban board that aims to take the human out of the loop — agents pull, move, and close cards themselves rather than reporting status for someone else to transcribe.
A CAST observability dashboard reading cast.db to show session analytics, agent runs, and hook activity. Built on React 19 and Express for people who want the numbers behind their sessions rather than a live feed.
An Ubuntu container preloaded with Herdr, Claude Code, Codex, opencode, and a mobile-friendly Neovim, all reachable over SSH. A disposable personal VM for agent work that you can drive from a phone.
A community directory of Agent Plugins 1.0 packages with signed discovery and compatibility metadata, so an installer can tell which plugins work with which agent before pulling them down.
A deliberately small statusline that works across both Claude Code and the Cursor CLI agent. For people who find the elaborate Nerd Font dashboards distracting.
Each window is its own agent on its own project, so several tasks ship while you review one. An autopilot mode checks the work before it reaches you. Free for Mac and Windows.
Gives Claude Code memory that survives crashes and restarts, with automatic session recovery and remote access to running work.
A single local web panel listing every Claude Code session running on the machine, so you can see and switch between them without hunting through terminal tabs.
A CLI giving Claude Code direct access to thousands of postings refreshed hourly, with keyword and vector search, filtering on constraints like location or work authorization, and batch LLM judging of postings against your resume. Steps chain into reusable search routines.
Built around a specific failure the author kept hitting: the diff looks reasonable, the suite is green, and something important silently changed. An auth check gets broadened while the dangerous part sits in an unchanged helper; security tests get skipped while everything else stays green; a strict assertion gets weakened without looking like a deletion. ShipCheck runs on the PR after the agent is done and asks whether protected behavior still holds, rather than whether the diff contains bad code.
Opens the Qur'an in your browser during a Claude Code session, advancing one ayah at a time from where you left off. Activates only when you launch with 'claude --cwq', so it stays out of the way otherwise.
A local-first pipeline that decomposes a project architecturally and produces PERT estimates, aimed at freelancers who need to quote work before building it.
A BYOK desktop app for macOS, Windows and Linux where you describe an agent team and they work your repo continuously. Bring-your-own-key, so the cost and rate limits are yours to manage.
A GPU-accelerated terminal board that lays all your running sessions out on an infinite, pannable canvas instead of a stack of tabs. Aimed at people juggling several agent sessions at once who want spatial layout rather than window switching.
Indexes every Claude Code session on your machine and makes the whole history searchable, so past work compounds instead of being lost when a session ends. Useful when you know you solved something before but can't remember which project or when.
A router that lets Claude Code, Codex or OpenCode run against an OpenCode Go subscription, with a Responses to Chat Completions bridge so any model works in any harness. Handy if you want to reuse one subscription across several CLI harnesses.
Keeps durable project state — decisions made, constraints in force, and paths already rejected — versioned in git across AI sessions. The author is explicit that it isn't a memory tool: the point is recording why the project is the way it is so the next session doesn't relitigate settled choices.
A browser-based dashboard for running Claude Code, Codex, Gemini CLI and Aider side by side, with a live status view, auto-approval rules and a structured review queue. Aimed at the case where you have more agents in flight than terminal windows you can watch.
An IntelliJ plugin for reviewing AI-generated diffs with inline comments, then shipping the whole review back to Claude Code, Codex, Copilot or any MCP agent to act on. Closes the loop between reading a diff in your IDE and getting it fixed.
A macOS desktop workbench for running multiple Claude Code agents: session management, natural-language collaboration across session cards, DAG visualization, tiered notifications, an agent HUD and git worktree integration. Chinese-language docs.
COMPLEX.md is a generated map of a codebase showing where changes tend to be risky and where bugs actually get fixed, so an agent can weight its caution accordingly. Ships as a spec plus a CLI, hooks and an MCP server.
A memory layer for Claude Code built to survive both compaction and session boundaries. It uses reconcile-on-write with LLM-judged de-duplication instead of appending patches, a forced PROGRESS.md handoff, a live PLAN.md anchor with a directive ledger, FTS5 search, MCP tools and a GUI — all pure stdlib Python with zero runtime dependencies.
A single progressive web app combining a Claude Code tool marketplace, a kanban board and cost tracking. Consolidates three things people usually run as separate tabs.
A control plane for native sessions across Codex, Claude Code, OpenCode, OMP and PI, letting you start work on one machine and resume or hand it off on another. Useful if you move between a laptop and a workstation mid-task.
A local coding board that routes each prompt to the cheapest model that can actually handle it, so a Claude Code or Claude Pro quota stretches further. Routine work goes cheap; the hard prompts still get the good model.
Control a local Claude Code agent from Telegram with streamed replies, session switching, cron-scheduled tasks, multimodal input and a web admin console. Turns your phone into a remote for a machine that's already running.
A local-first macOS desktop workspace for autonomous agents and coding harnesses including Claude Code, Codex and Grok, with support for multi-agent workflows. Everything stays on the machine.
Gives each project its own Docker environment for the coding agent to run in, so a misbehaving agent can't reach past the container. A straightforward answer to the risk of running agents with broad permissions on your host.
A durable, long-running agent whose job is evaluating and improving other agents. Meta-level tooling for anyone maintaining a fleet of agent configurations and wanting them to get better over time rather than drift.
Uniformly collected, reviewable measurements of the tokens, credits, quota and latency that real agent harnesses burn on a single trivial message. Useful as a baseline when comparing harnesses, since the overhead before you've asked for anything varies a lot.
Scores the tone of your prompts to Codex and Claude Code. A light diagnostic for anyone curious whether how they phrase requests correlates with the quality of what they get back.
Auto-opens a game while your agent is working, tracks the session's live status, and hands the terminal back the moment the agent needs you. A cheerful answer to the dead time in long agent runs.
An open-source layer letting Claude Code or Codex autonomously find, order and pay for goods on real e-commerce sites under a pre-signed mandate, with an Allegro/OLX MVP. Includes a site-skills registry, AP2-style mandates and PSD2-aware payments.
Renders your local git changes in a GitHub-style diff view and lets you talk to your Claude Code session from inside the diff, so review comments go straight to the agent. MIT licensed.
Masks personal data before a prompt reaches the model and restores the real values in the response, so tools and users still get correct data while the model never sees it. Pluggable detectors (regex, NER, LLM), integrations for LangChain, Pydantic and LlamaIndex, plus a companion OpenAI/Anthropic proxy.
A walkable browser 3D city where every building was designed and submitted by an AI agent for a project it works on. Your agent reads the claim page, builds a 10x10x6m lot as a single GLB, checks it in the live renderer and submits — no human review, live in about two minutes. Tight budgets (50k triangles, 4 materials, 1024px textures) keep the street fast.
An SEO plugin covering research, briefs, writing, optimization, audits and schema, all scored against one 100-point A-G framework and ending in an AI Overviews readiness verdict. The single scoring rubric across all stages is what makes it more than a prompt pack.
Aggregates usage, token and cost analytics for developer AI tools across all your devices, so the picture isn't split per machine. For anyone running agents on both a laptop and a workstation.
Reads Claude Code, Codex and Gemini transcripts already on your machine and turns them into cost, waste and habit analysis. Nothing is uploaded — the waste and habit angle is the differentiator over plain token counters.
A playful companion that rests, works and signals activity in sync with your Claude Code and Codex sessions, giving you session state at a glance without reading the terminal.
Keeps a Mac awake while local Claude Code or Codex agents are running, then lets it sleep once they finish. Solves the annoyance of a long agent run dying because the machine dozed off.
An open-source Claude plugin that makes Claude's video editing visible. The team already had an API exposing transcript, active speaker, faces and scene changes; handing that to Claude let it do much of the editing conversationally — 'start this one two seconds earlier', 'change the framing in clip 2'. The Cutting Room adds the visual view that was missing.
Derives per-session time, token and cost telemetry for Claude Code runs directly from the transcripts on disk. Lightweight if you want the numbers without installing a full dashboard.
A VS Code extension for developer notes anchored to specific files, lines and git branches, with a rich block editor, Claude Code MCP integration, GitHub PR and issue linking, and opt-in team sharing over git. Notes follow the code rather than drifting from it.
A plain-text document format organized around a single typed block for everything, readable by people and addressable, verifiable and versioned for machines, with history kept in a .gemlhistory sidecar. An attempt at a shared document substrate for human/agent collaboration.
A local, read-only terminal UI across every project you run Claude Code in, showing each one's state, what needs you, what only you can do, how far the work got and what comes next. Read-only by design, so it can't make things worse.
Agent memory built as a bi-temporal belief ledger plus a transcript index in a single SQLite file, designed so superseded facts stop being recalled. Directly targets the failure where stale memory outranks current reality.
A cross-platform desktop app for reviewing your own git repositories locally — single user, single machine, no server and no account. For reviewing agent-generated changes before anything reaches a remote.
Official Beezi plugins for Claude that track what AI-assisted work costs per session in Claude Code, give a personal usage summary on demand, and draft tickets from claude.ai — all under your own Beezi account.
Built on the observation that an agent session is a tree but your terminal shows it as a scroll. ccdeck draws the tree instead: a live DAG of tool calls with cost, quota and who is currently blocked on you, for Claude Code and Codex. Local, no telemetry.
A macOS Dynamic Island-style monitor showing the running state, working duration, conversation and token usage of local Codex, Claude Code and VS Code agents. Chinese-language docs.
A configurable terminal grid for running multi-agent AI workflows, so several agents are visible side by side in one layout instead of scattered across windows.
A localization toolkit that translates the Claude Desktop UI into Chinese across Windows (MSIX/Win32), macOS, and Linux. It patches non-invasively and self-heals after app updates, so a Claude release does not undo the translation. Aimed at Chinese-speaking users who want the desktop client in their own language.
A local memory layer where each stored fact is typed, carries its source, and gets retired when it changes — instead of an ever-accumulating notes file. Runs on local SQLite with no API keys, and works across Claude Code, Cursor, and Codex. The retirement mechanic is the interesting part: stale facts do not linger and mislead the agent.
A macOS app showing live usage gauges for Claude, Codex, and Antigravity side by side, rendered as liquid-fill meters. Handy if you split work across several AI coding tools and want one glance to tell you how much of each quota is left.
Open-source DFIR tooling that collects, preserves, and reconstructs activity from Claude Code, Codex, Cursor, Gemini, and Copilot sessions. Turns scattered agent logs into an investigable timeline. Aimed at teams that need to answer what an agent actually did after an incident.
A scanner for credentials that coding agents write into scratch files, logs, and temp output. MIT, zero dependencies, no network calls, so it can run on machines where you would not send code to a cloud scanner. The author publishes a benchmark claiming it beats TruffleHog and GitGuardian's engine.
Converts Claude Code session logs into a self-contained HTML replay showing what the agent explored, where it got stuck, and what finally worked. Fully local with no telemetry. Handy for reviewing a long unattended run or sharing how a fix was actually reached.
A desktop widget showing real-time Claude usage limits, session pace, weekly quotas, and service health. Runs in the KDE panel, a system tray, or on the Windows desktop. One of the few quota monitors that targets Linux desktops rather than macOS menu bars.
Cross-session networking for coding agents: @mention another team's AI and let the two agents coordinate directly across sessions, machines, and organizations. Runs from the terminal. An unusual take on agent-to-agent integration that crosses org boundaries rather than staying inside one machine.
A macOS floating dashboard tracking subscription quota balance, token consumption, and multi-device usage trends for both Claude Code and OpenAI Codex, with persistent Touch Bar display. Chinese-language UI. Useful if you split work across two subscriptions and several machines.
A Claude Code plugin implementing a six-phase publishing pipeline with 16 skills, 7 agents, and 8 genre templates, ending in EPUB and PDF output. Treats a manuscript as a build artifact with structured stages instead of one long generation. Notable as a large plugin applying agent orchestration outside of code.
A native Swift and AppKit app for running many Claude Code sessions across git worktrees, showing which are running, waiting, or need attention. Sessions survive quitting the app via zmx, and it suggests next actions when Claude is blocked. Deliberately not an editor or diff tool, since review stays with the agent in context.
Keeps skills, subagents, commands, and instructions in a shed you can restore onto any machine, selected by profile. Solves the drift between the configuration on your laptop and the one on a server or a fresh clone. Useful once your harness stops being a single CLAUDE.md.
A desktop app that aggregates usage, quotas and cost for Claude Code, Codex, MiniMax, DeepSeek, OpenCode and Kilo in a single view. Tracks local session costs with history and forecasts, and offers an optional self-hosted team view.
An unofficial Obsidian plugin that embeds a chat panel driving the Claude Code CLI against your vault. Lets you edit notes, run research, and refactor vault structure without leaving Obsidian.
Surfaces Claude Code's own prompt-cache state as a HOT/COLD indicator in the statusline, plus an audit tool that reconstructs when your sessions went cold, what caused it, and what the re-warm cost. Useful for anyone tuning long sessions against usage limits.
A CLI and GitHub Action that checks agent skills and plugins against the Agent Skills spec plus Claude Code and Codex conventions. Deterministic, so it can gate CI rather than being another model asked for an opinion.
A voice front end for Claude Code: speak your request, and the tool relays a spoken summary of what the agent did. Aimed at working away from the keyboard rather than replacing the terminal.
A work-in-progress native PC port of GoldenEye 007 built on the N64 decompilation, run explicitly as a research project on multi-agent AI-assisted porting. Interesting as a public case study of agents working a large, low-level C codebase.
A source-only macOS app that puts coding-agent session state, quota usage, and app focus on the Touch Bar. Niche hardware, but a genuinely glanceable place for session status if you have the bar.
A small local board where your separate AI agent sessions can post and read messages. Gives parallel sessions a shared place to leave notes without a hosted service or a shared filesystem convention.
A harness where worker agents send each other mail, a built-in task manager assigns budgets, each agent gets its own git worktree, and a cross-model review runs before every squash merge. Puts Claude Code, Codex, Grok and OpenRouter behind one contract.
A self-hosted bridge that exposes your local Claude Code and Codex sessions as phone-friendly chat rooms, with safe defaults on what the remote side can trigger. Solves the walk-away-from-the-desk problem without renting a cloud sandbox.
A small always-on-top Windows widget showing subscription quota state for Claude Code and Codex. Fills the gap for Windows users who cannot use the macOS menu-bar monitors.
Unofficial tooling to observe and contain the Claude Code tool-call stall and phantom-output bug. Explicitly not a fix — it detects the condition and limits the damage while you decide what to do.
A lightweight terminal monitor showing current subscription quota consumption for Claude Code and Codex. No dashboard, no daemon — just a command you run when you want to know where you stand.
A plugin for Claude Code, Codex and Cursor that pushes dashboards an agent builds to a hosted dashies.ai URL over MCP, then keeps them refreshing on a schedule. Bundles the authoring skill so the agent knows the dashboard format.
A gateway that connects a Telegram group to local agents (Claude Code, Antigravity, Codex, OpenCode) with a silent sliding context window, so a whole group's conversation becomes agent context. Useful for team-visible agent work.
Queues prompts for Claude Code and other AI CLIs to run in the background, with a web UI and a Telegram bot for submitting work and reading results. Turns a synchronous terminal tool into a job queue.
A FastAPI and React dashboard that spawns agents on several machines, streams their live terminals over PTY, tracks token usage via OpenTelemetry, and supports git worktrees. Deploys as rootless Podman containers.
Routes work across an agent fleet based on remaining credits and watches long Claude Code sessions for trouble. Deliberately generic: anything runnable in bash can be orchestrated, including OpenClaw, Hermes, Codex and Grok.
Runs skills against Codex, Claude Code, OpenCode and Pi at runtime to see whether they actually behave the same everywhere. Catches portability bugs that a static spec linter cannot.
A pip-installable local memory layer that lets Claude Code recall past sessions without replaying transcripts, claiming a 211k-to-2.5k token reduction. Nothing leaves your machine.
Manages OpenAI- and Anthropic-protocol providers in one place and syncs them, with models.dev metadata, into nine agents including Claude Code, Codex, opencode and Hermes. Non-destructive, so hand-tuned settings survive, and it imports from cc-switch.
A runtime that orchestrates AI work on software tasks entirely locally. Early-stage but positioned as infrastructure rather than another wrapper CLI.
A self-hosted gateway that puts many LLM providers behind one endpoint for personal use. Useful as the provider layer under a coding agent when you want to switch models without touching agent config.
A package manager for the agent ecosystem, positioned as Homebrew for AI agents, covering skills, MCP servers, plugins and subagents across Claude Code, Codex, Cursor and OpenCode. One install path instead of four conventions.
A dependency-free local dashboard for switching between multiple Claude Code accounts, showing each one's session and weekly usage before you pick. Spanish-language project.
Renders pull request changes as animated architecture and data-flow diagrams posted inside the PR itself. Available as a GitHub App, GitHub Action, CLI, or a skill your coding agent can call.
Capture a thought, link, PDF or whiteboard photo without deciding where it goes; a sandboxed Claude Code session distills it onto the right pages, links related ones, and keeps the original read-only. Big changes land in a diff inbox, small ones show in an activity log, all git-backed.
A zero-dependency read-only diagnostic run via npx that checks the usual Windows failure causes for Claude Code and Codex CLI. Aimed at the PATH, shell and permission problems that produce unhelpful errors.
A three-way comparison of mainstream Chinese LLM coding plans: vendor claims, user probe measurements, and the official monitor. Aimed at exposing dynamic multipliers, credit inflation and hidden throttling before you subscribe.
An installable plugin that analyzes coverage gaps, triages failures, detects flakiness and assesses release readiness against Qase test management. Evidence-backed, read-only by default, with deletions blocked in code.
A terminal dashboard for AI subscription limits built so that nothing about your usage leaves the machine. For people who want quota visibility without a telemetry-shipping monitor.
A wrapper that repairs the Ollama integration for the Claude Code desktop app: correct env vars scoped to the launch, a rewritten model catalogue exposing 1M context, and relief from the subagent concurrency limit that killed long /deep-research runs.
Carries task state between Codex, Claude, Gemini, Antigravity and custom agents so a handoff does not lose the thread. Local-first, so the relay state stays on your machine.
A Tauri, Rust and React desktop app that puts live telemetry for Claude Code, Antigravity, OpenCode and Aider sessions into a macOS-style Dynamic Island. Native rather than a browser tab you forget to open.
Persists what Claude Code learns between sessions as ordinary Markdown notes in your Obsidian vault, so the memory is human-readable and editable in a tool you already use rather than an opaque store.
A cage for coding agents where your nix devshell is the container: the agent gets unrestricted permissions inside a rootless podman sandbox and nothing beyond it. Removes the permission-prompt fatigue without removing the boundary.
A single self-hosted interface for driving several coding agents and plain shell workflows from a browser or the command line. Useful when your agents live on a server rather than your laptop.
Compresses what AI coding tools send and receive while preserving the information, installable into Claude Code via npx. Interesting if context size rather than model quality is your binding constraint.
A browser over the session files already on your disk for Codex, Claude Code, Gemini CLI and Pi, with filtering, export and resume. Makes the transcript archive navigable instead of a directory of JSONL.
Reverse-engineers an application into the product, UX, UI, architecture and design intent behind it, in a form coding agents can consume. For rebuilding or extending software whose original documentation is gone.
A Homebrew-installable tool for pruning accumulated Codex CLI and Claude Code session data with safety checks. Session archives grow quietly, and this deletes them without guessing at directory layouts.
A Portuguese-language index of the Claude Code extension ecosystem, cataloguing 502 plugins spread over 16 marketplaces. Useful for finding out whether the plugin you are about to write already exists.
A Zellij sidebar that surfaces the state of Claude Code, Codex and other agents in every tab at once. Solves the which-pane-is-waiting-on-me problem for Zellij users.
Wraps the actual Claude Code CLI rather than replacing it, fixing the terminal-shaped annoyances: composing long prompts, installing skills and MCP servers without editing config files, and jumping between editor, preview and agent.
A Windows statusline showing context meter, cost, rate limits, git branch and mode badges, in one or two lines with plain or powerline styling. Configured by a small JSON file, uses Nerd Font glyphs, needs no PowerShell modules.
An open-source operating system for running a company on AI agents, structured around a Director loop of observe, decide, act, evaluate, with departments as agent groups. Ambitious framing; worth a look for the loop structure.
Audits a completed Claude Code session against the rules in your CLAUDE.md or AGENTS.md and reports which were followed, with evidence. Answers the question everyone with a long rules file eventually asks.
Workspaces of terminal panes, each running Claude Code, omp, or a plain shell, all in one browser tab, with sessions living on the server. MIT licensed, and built almost entirely by Claude Code sessions running inside WebADE itself.
You describe the demo and the agent drives a real browser to record it, via npx demobite@latest. Turns demo recording into a prompt rather than a screen-capture session you redo four times.
A Claude Code plugin for building custom WordPress sites section by section, with ACF/SCF field setup and bilingual support, starting from a demo rather than a blank theme.
A local-first TUI reading the transcripts already on your disk to show cost, tokens, quotas, named workflows with agent timelines, and one-keystroke session ratings. The rating feature makes it a feedback loop, not just a meter.
Pulls a student's LMS, calendar and project deadlines into one interactive weekly page, set up through Claude Code with no coding required. A clean example of an agent-maintained personal dashboard.
Runs a local Ollama model as a code-review assistant feeding suggestions into Claude Code, with Claude retaining the decision. Keeps the cheap pass local while the expensive model adjudicates.
Puts a progress bar for any long-running job in the statusline, with Claude choosing how to observe progress and a self-correcting ETA. Crashes come back with a skull and a report rather than a silent stall.
A VS Code extension listing every coding-agent session across Claude Code, IBM Bob, Codex and VS Code Chat, with one-click switching and visibility into which are blocked waiting on you.
Surfaces subscription quota for four coding agents inside the Herdr multiplexer. Small and specific to Herdr users.
Keeps project accounts separate and launches each provider with the profile you pick, so work and personal credentials do not cross. Vendor-neutral across Claude Code and Codex.
A triage console that files structured tickets, scores them, and routes each to the coding agent best suited to it. Cross-platform and multi-provider.
A Claude Code plugin with a strict separation of powers: Codex writes in a git-isolated copy, your own commands decide pass or fail by exit code, and Cursor reviews the diff read-only. Nobody in the loop can both write and approve.
Every project is a room and every session a robot whose screen scrolls while working, goes amber when it needs you, red when stuck, dark when idle — readable from across the room. Click a desk to enter that conversation and approve the exact command it wants to run.
A manager for the tasks and workflows you hand to coding assistants, keeping the queue outside the agent session. Early-stage.
Connected tables, relations, workflows, formulas, rollups and per-entity markdown or PDF documents in one SQLite file, exposed through REST, a CLI and an MCP server so Claude Code and other agents are first-class users. Zero dependencies, MIT.
Tracks burn rate rather than cumulative totals for Claude Code, Codex and OpenCode, with a web dashboard, a TUI and notifications, all running locally. Rate is the number that tells you whether you will hit the limit.
A universal compiler that takes one source of prompt/context definitions and emits the config each coding agent expects, covering Claude, Cursor, Copilot and Antigravity. It keeps context synchronized so switching tools does not mean rewriting your rules files by hand. Handy if your team uses more than one agent and wants a single place to edit instructions.
A live Campeonato Brasileiro Serie A companion app on React 19, TypeScript, Express and AWS, developed entirely by directing Claude Code across 742 commits. It ships 45 unit tests and 30 Playwright e2e tests, seven GitHub Actions workflows including a documented rollback drill, and keyless OIDC deploys. Worth a look as a concrete reference for what a fully agent-driven production codebase and CI setup looks like.
A high-performance proxy that fronts multiple Google Antigravity and Gemini accounts and re-exposes them through OpenAI and Anthropic-compatible endpoints. That lets Claude Code, Cursor, Windsurf, and Aider talk to Gemini models without changing clients. Includes a web dashboard for account and usage management.
A meta-harness that generates a focused, branded agent harness with its own npx CLI, MCP server, memory store, learning loop, and witness-signed releases. Rather than adapting a general tool, you scaffold a purpose-built one. Output works with Claude Code, Codex, pi.dev, Hermes, OpenClaw, and the RVM sandbox.
A React and Supabase nutrition-tracking PWA developed and operated entirely from Claude Code, with a RAG pipeline, hybrid semantic search over pgvector, and a self-built remote MCP server using OAuth 2.1 with PKCE and RLS enforcement. A three-model fallback chain and an LLM eval harness gate every release. Useful as a worked example of a real agent-built production stack.
A small VS Code extension that launches Claude Code with every workspace folder passed through --add-dir. Saves manually re-adding directories in multi-root workspaces. Narrow in scope but removes a recurring papercut.
Tooling for developing, governing, and deploying Streamlit-in-Snowflake applications from Claude Code. Covers the build and ship loop rather than just scaffolding. Relevant if your data apps live inside Snowflake.
A terminal dashboard that reads local usage data from Claude Code, Codex CLI, Gemini CLI, OpenCode, and Ollama and shows tokens, cost, and budgets in one btop-inspired view. Runs as a live TUI or dumps JSON and CSV for scripting. Handy if you juggle several agent CLIs and want one number.
An agent harness built around OmniRoute that offers plan, build, and research modes plus a parallel swarm mode, all from a terminal UI. Positioned as an alternative front end for people who want swarm execution without wiring it themselves. Worth a look if you are comparing harnesses.
A quality layer that checks agent work in the same session that produced it, using fail-closed evidence so a missing check blocks rather than passes silently. Its policy survives delegation to subagents, which is where most in-session gates leak. Installs across Claude Code, Codex CLI, Gemini CLI, and OpenCode, and the author reports an adversarial audit.
A read-only dashboard showing live session state: active agents, transcripts, the current plan, and token consumption. A second optional plugin adds hook-enforced PM-mode discipline on top. Shipped as a two-plugin marketplace so you can take the dashboard without the enforcement.
The author traced a GPU locked at 60W to Windows 11 silently changing power profiles, then went from ~90 to 165 FPS after fixing it. They had Claude Code build a diagnostic site so others can check the same settings on their own machines.
A research agent that expresses web search as SQL SELECT statements and returns visual results rather than a wall of prose. An alternative framing for deep research workflows.
Version 3 of a watercolor painting simulator implementing Curtis et al.'s SIGGRAPH "Computer-Generated Watercolor" model. This release adds gyroscope and accelerometer input so paint and water respond to device tilt, and is being folded into an agentic learning environment for kids.
Official announcement of two new frontier models for coding and knowledge work. Fable 5.1 targets complex long-running tasks, scoring 52.6% on Terminal-Bench-Science 0.1 (more than double Fable 5) and 55.8% on Terminal-Bench 4.0 against Fable 5's 42.0%, while reaching comparable results at lower cost.
A formatting layer for polyglot codebases that reports rather than rewrites unless told otherwise, which is the safe default when an agent is driving. Runs the same way from local tools, Docker, CI, and agents.
Your agents produce reports; MOA is where you actually read them. A self-hosted hub that renders MDX reports, built for teams whose agents generate more written output than anyone can track in a terminal.
Record your screen and talk through a bug; it returns structured Markdown with one annotated screenshot per mark. Ships as a desktop app, CLI, and MCP server for Claude Code, Cursor, Codex, and Windsurf, with on-device Whisper transcription. Local-first and MIT licensed.
A loop runner and git worktree engine for running agents unattended, with a local dashboard built over the event log so you can see what happened. Inspired by Chip Huyen's agent factory writeup.
A plugin that brings native Claude conversations into DeepSeek Harness via the Claude Agent SDK, carrying over approvals, session continuity, and DSH tool support.
Indexes Claude Code and Codex JSONL session histories into LanceDB so you can search and inspect past sessions locally. Nothing leaves the machine.
Chat with coding agents running on your own servers over SSH from an Android phone. Supports Claude Code, Codex, and Gemini CLI, so a long-running session on a home box stays reachable from anywhere.
Scans Agent Skills, SKILL.md files, and MCP configs for dangerous patterns before you install them. Zero dependencies, aimed at the growing supply of third-party skills people paste in without reading.
An unofficial menu bar tool that keeps your Claude Code Fable weekly usage visible at all times on macOS, so you notice the quota before it stops you. Documented in Japanese.
Maps an unfamiliar codebase into something navigable for people working primarily through an agent, who need orientation without reading every file themselves.
A protocol for one repository's coding agent to file a request against another repository's agent, with consumer acceptance and escalation to the owner when they disagree. Aimed at multi-repo organizations where agents work in parallel.
An Obsidian vault template where an agent turns web clippings into a Markdown wiki with citations, versioned in Git. Built around Claude Code but model-neutral. Documented in Korean and English.
A coding agent that runs against any local Ollama model or cloud LLM, using native tool calling over JSON-RPC stdio. Useful as a reference implementation for how a harness wires tools to a model.
Shows every Claude Code and Codex session as a cell in a honeycomb with live status, context usage, and plan usage, and clicking one focuses the right terminal tab. Native macOS, built for people running many sessions at once.
A personal knowledge vault plugin that records sessions, distills them into memories, and retrieves with a hybrid of semantic search and BM25. Keeps what you learned in past sessions reachable in later ones.
Seven plugins behind a single install: sniff (AI QA in a real browser), ui-ux-suite (design audit), recap-studio (one-page explainers), aws-cost-audit (safe AWS savings), goalify, humanizer (AI-writing detector and rewriter), and loopify.
A single curated document that agents propose edits to and you approve, shared across sessions, models, and harnesses. Built on the approach in arXiv 2608.21690.
Each tile is a real PTY terminal showing live state, each workspace carries its own GitHub account, and your setup follows you to the next machine. Built on Tauri v2 with no UI framework.
Orchestrates Claude Code, Codex, and Cursor CLI from one desktop app written in Rust with no Electron, so it launches instantly and stays light.
Runs application security work through multiple agents with independent verification of each finding, safe tool adapters, root-cause remediation rather than symptom patching, and a regression proof that the fix holds.
Queue prompts for Claude Code sessions through a hosted multi-tenant web app with Google login, running them via the Claude Code CLI with optional AI optimization of each prompt. Documented in German, live at cue.celox.io.
Watches scheduled, unattended agent runs for the failure modes that go unnoticed until the output is already wrong. Ships with the field notes of the agent that wrote it — the code is entirely Claude's, with a human owning the account.
Computes the CRAP metric (complexity times coverage) per function, produces a ranked worklist of the worst offenders, and installs a commit gate whose threshold can only move in the direction of better.
Runs Claude Code inside a Docker sandbox so an autonomous session can't reach the rest of your machine. Documented in Japanese.
Investigates Claude Code and Codex JSONL histories read-only, surfacing how context and memory actually behaved over a session rather than how you assumed it did.
Watches RSS feeds and listing pages, matches against topics you define, and sends an LLM-summarized digest by email or chat. A small, self-hosted alternative to a news aggregator.
The blueprint conformance engine — you author architectural intent explicitly, and CI enforces it. Turns "we agreed the modules wouldn't depend on each other" into something that actually fails a build.
Watches for approaching Claude Code usage limits and for habits that quietly burn tokens, then nudges you about both. Aimed at people who only notice the waste after the quota is gone.
An open-source, drop-in compatible implementation of the Claude Managed Agents API plus a self-hosted Claude Tag-style agent runtime. Runs on Cloudflare Workers with Durable Objects or on Node.js. Apache 2.0.
Dispatches work to Claude Code and Codex agents through a visible, file-based Kanban board, so the queue is inspectable in the repo rather than hidden in an agent's head.
Generates a Spotify-Wrapped-style report and LinkedIn carousel from your own local Claude Code logs, covering six months of usage. Everything is computed locally from files you already have.
Encodes text as images that cost 50 to 75% fewer input tokens than the equivalent text. Ships as a Claude Code plugin, a browser app, and a right-click tool.
Configures and launches Claude Code against any Anthropic-compatible API gateway — Z.AI/GLM, OpenRouter, LiteLLM, or a local gateway — with no configuration to write yourself.
A macOS app that reduces token spend on Claude Code and Codex sessions by roughly half, aimed at people whose costs are dominated by repeated context rather than new work.
Runs untrusted code and AI agents in isolated Podman containers on krun microVMs, with network control, SSH, and a Privoxy proxy, all from one self-contained bash script.
Builds connected structure over a repository so an agent discovering it for the first time has something better than a file tree to navigate by.
Drives GitHub Copilot CLI, Claude Code, and Gemini through the Agent Client Protocol from one web UI, with permission policies, an audit trail, and git diff review before anything lands.
Provider-neutral coordination covering git worktrees, cross-runtime messaging, job progress, and FIFO integration authority, so parallel agents integrate in a defined order instead of racing.
A harness for testing voice agents, shipped with the grader, a spreadsheet template, and a Claude Code skill that drives the whole thing.
Mock scoring you can trust plus eight buildable projects you can defend in the Claude Certified Architect Foundations exam. Companion code to the book; educational and not affiliated with Anthropic.
Coordinates coding-agent sessions across vendors and machines using git itself as the coordination plane, with an optional read-only dashboard that makes the work visible without adding a control surface.
Records the decisions you've made and the paths you've explicitly ruled out, then holds every agent to them. Aimed at running more agents at once without re-litigating the same architecture choice in each session.
Applies the virtualenv idea to agent skills, so skills with conflicting requirements can coexist and a project can pin exactly the set it needs.
Audits your Mac and its AI assistant configuration at a point in time, read-only, offline, with no sudo and zero dependencies. Explicitly not an antivirus — it reports state rather than judging it.
Browse every session, keep persistent project memory, see which MCP servers are in play, and control launch settings per project — from a terminal UI or a desktop GUI, with zero runtime dependencies.
A desktop pet for Antigravity and Claude with a Pomodoro timer, physics-based feeding, screen-edge climbing, and live reactions to what you're coding.
When you run Claude Code in parallel across repos and orgs, GitHub output outruns your attention — notifications are per-event, the dashboard doesn't dedupe, and nothing separates "needs me" from "already handled." This Chrome extension puts deduplicated recent pushes, an attention queue (changes requested, review requests, failing CI, merge conflicts), and your open PRs in the new tab.
Reads Claude, Codex, GitHub, Grok, and Cursor usage straight from your own authenticated CLIs and shows it in a Windows side-notch. Local-first with no tokens to paste and no network calls of its own.
A declarative package manager for agentic coding CLIs. You list the skills, plugins, and MCP servers you want in a single TOML manifest and zskills installs and syncs them. Claude Code is supported today, with a multi-runtime design so the same manifest can target other agent CLIs.
A small Tauri desktop widget (~6MB) that floats above your work and shows current LLM costs. It reads Claude Code, Codex, and provider spend from local data, so nothing leaves your machine. Useful if you want a constant glance at burn rate without opening a dashboard.
Enforces runtime security policy below the agent using BPF-LSM, so a coding agent cannot escape the restrictions by rewriting its own config or shelling out. It also keeps an audit log that root cannot scrub. AGPL-3.0, aimed at people running autonomous agents on real infrastructure.
A macOS menu app in the Liquid Glass style that tracks AI token usage and breaks it down by session, model, and tool. Handy for seeing which tools or subagents are actually eating your context and budget, rather than just a single running total.
Brings the parts of the Claude Code experience people rely on — TUI, permission prompts, hooks, memory, skills, subagents, MCP, and git worktrees — over to DeepSeek Harness. Interesting both as a way to run a familiar workflow on a different model and as a map of which Claude Code features are load-bearing.
Reads your AI coding usage and reset windows locally, then estimates which subscription tier actually fits your consumption. Aimed at people juggling several plans who want a data-backed answer instead of guessing before the next billing cycle.
A deliberately minimal coding agent modeled on Claude Code, small enough to read end to end — the NanoGPT of coding agents. It works with any LLM backend, which makes it a decent base for experimenting with agent loops or understanding what a harness actually does. Formerly published as NanoCoder.
Scores and gates changes to agent instruction files so quality does not silently regress as they grow. It covers CLAUDE.md, AGENTS.md, Cursor, Copilot, and Gemini rule files, and is built to resist an agent editing its own instructions to pass the check. Useful in CI on repos where several people edit the agent config.
A local capture tool that pulls your own conversations off 10 AI platforms and stores them in a unified parquet schema. It is designed to be deletion-resilient, so history survives even if the provider drops it. Useful if you want a durable, queryable record of Claude Code and other assistant sessions.
An OpenCode plugin that routes requests through your existing Claude Max or Pro subscription via Meridian instead of pay-per-token API keys. It lets subscription holders use the OpenCode editor agent without a separate billing setup. Handy if you already pay for Claude and want to try another harness.
A viewer that shows how fast you are burning tokens in Claude Code, rendered in the browser rather than a statusline. Installs with a single command on Linux, macOS, and WSL. Useful for spotting whether your current pace will hit the quota window before it resets.
A Claude Code agent for language learning: paste a sentence and it picks the word worth learning, explains it in context, and schedules practice via spaced repetition. State lives locally alongside your other agent files. An unusual non-coding use of the Claude Code agent runtime.
A macOS menu bar app that tracks token usage, active working time, and cost across multiple AI coding agents in one place. Sits out of the way until you want the numbers. Distinct from the similarly named tracker by aashutoshrathi.
A 2D macOS office simulation where a CTO agent decomposes a goal and assigns it to AI employees, each working in a real terminal running Claude Code, Codex, or Gemini CLI. The game layer is a visualization of genuine multi-agent execution, not a mock-up. A playful take on making parallel agent work legible.
A macOS menu bar monitor for parallel AI coding sessions now shows machine CPU and memory beside the session list, so you can tell whether slowness is the model thinking or your Mac saturating. CPU uses Activity Monitor's whole-machine 0-100 scale with a busy-core footnote rather than the per-process 800% scale.
Successor to CC Connect: run Claude Code, Codex and 12 other coding agents on your own machine while driving them from a chat app. Native Feishu/Lark Card 2.0 streaming, mid-turn steering, and 11 more transports including Telegram, Slack and Discord. Privacy-first, with the agent staying local.
A Trello-style Kanban app whose built-in assistant is powered by the Claude Agent SDK and has context on your board, goals and profile. Instead of a generic chatbot bolted on, the assistant reasons about your actual tasks. Useful as a reference for embedding the Agent SDK in a product.
A tiny Rust CLI where agents record friction as 'cuts' and ideas as 'dogears' into an append-only JSONL file. Later you triage, verify and digest them into a list of the repo's real papercuts. Turns the annoyances an agent hits mid-task into durable data instead of lost chat scrollback.
A web UI client for Claude Code released after nine months of after-hours work. It drives the Claude Code CLI under the hood so an existing subscription just works, and keeps an LLM-summarized journal of every turn. Built by someone who was working from an iPad over code-server and wanted something better.
A local dashboard that shows Claude Code sessions, events, cost, worktrees and reviews in one place. One loopback server, no build step and no dependencies, so it starts instantly and never leaves your machine.
A Claude plugin aimed at product managers: 45 commands, 8 auto-selected skills and 7 sub-agent reviewers wired to a three-tier memory that carries context between sessions. Broad and opinionated rather than a single-purpose tool, so worth a look mainly if PM workflows are your use case.
Background process management built for LLM coding agents: non-blocking bash with streaming output, stdin support and long-polling. Solves the common failure where an agent starts a dev server or long build and then blocks or loses the output.
Drives iTerm2 tabs, including running AI agents, from Telegram. Lets you check on or nudge a long-running local agent session from your phone without a full remote-desktop setup.
Assigns each Claude Code session a human first name so parallel sessions become distinguishable people you can refer to. A small quality-of-life fix for the confusion of running several sessions at once.
Claude Code will keep going as long as you will; breather tracks real presence across all your sessions, reads your own calendar back to you, and offers a stopping point with a written handoff at safe moments. Explicitly never measures, lectures or blocks.
A local stack of token-reduction measures for Claude Code and ChatGPT Work/Codex. Aimed at stretching a fixed quota further by trimming what gets sent on each turn.
A local smart-router daemon that points Claude Code and VS Code at any Anthropic-compatible API provider, with a CLI and web dashboard and no dependencies. Useful for switching between providers or self-hosted endpoints without editing config each time.
A macOS menu bar dashboard showing token usage, spend and subscription quota for Claude Code, Codex CLI and other coding agents. Fully local with no data upload. Chinese-language interface.
A three-year-old MIT-licensed AI tools directory: 841 tools across 64 categories, every entry tagged free/freemium/paid/open-source, 255 merged PRs from 154 contributors. Also covers MCP servers, prompts, skills and trending repos, and unusually for the genre, it removes dead entries.
A Claude Code plugin that repairs ID3 tags and cover art across an artist's album folder so Navidrome, Plex or Jellyfin display it correctly. Every change is verified against MusicBrainz, presented as a reviewable plan first, and is reversible.
A modernized Android terminal for mobile developers, focused on running Codex CLI and Claude Code and on SSH remote development. Chinese-language project.
Runs a fleet of Claude Code agents in parallel, each in its own persistent tmux session, with a browser dashboard and a Telegram bridge for checking in remotely. Persistence via tmux means sessions survive disconnects.
A former hotel manager with no coding background documents the workflow and tool stack behind their first publicly released app. Covers the progression from Sonnet 3.5 experiments through failed internal projects to a shipped product. Useful as a concrete non-developer workflow write-up rather than a tool.
A 581-line open-source toolkit giving agents deterministic operations: bounded candidate search, state machines, simulations, checks and persistent workflows. The premise is that repeated state updates, finite workflow reduction and dependency-aware work across restarts shouldn't need another LLM round trip. Small enough to read end to end.
Built by pointing Fable 5 at a homelab's accumulated agent sessions, this distributes iOS smoke tests across many simulators rather than serializing them on one. Each agent gets its own simulator, cutting a long single-machine run down substantially. Aimed at iOS developers running agent-driven test suites.
Most news is factually true and still built to make you feel a certain way; fact-checking catches lies but not framing. The author built an agent-run news site around what they call a "framing-check" — flagging headlines that overreach the article, numbers with no baseline, and quotes from interested parties. An unusual application of agent pipelines to editorial judgment.
The stock software for an Epomaker TH108 could only run one lighting effect at a time, so the author reverse-engineered the HID lighting protocol and rebuilt it over WebHID in a normal browser tab. Layers reactive keys on an animated background with no firmware mod, vendor software or internet connection. A background daemon keeps the lighting running.
A small open-source model that sits in front of an LLM, agent or prompt optimizer and scores prompts across clarity, specificity, context, goals, constraints, completeness and actionability. It identifies weaknesses before you spend a large-model call, with an optional optimizer that rewrites weak prompts. Runs entirely locally.
Getting screenshots and images to agents running on a rented remote server usually means juggling temp file hosts. TermDrop is a browser-based drop target that pushes pasted or dragged files directly to your SSH session. Free and requires no client install.
Breaks a big code change into ordered, narrated chunks — a guided tour rather than a wall of files — so you can review agent output without leaving your multiplexer. Combines and extends ideas from hunk and stage-cli. The author is gathering feedback on the approach.
OMK evaluates and observes prompts, RAG pipelines, skills, agents and workflows, tying every judgement back to evidence rather than a bare score. Ships native support for Claude Code, Codex and the DeepSeek harness. Aimed at teams who need to prove an agent change actually helped.
Reads your own session data to report real token and cost figures, then gives advice derived from your numbers instead of generic guidance. Useful for finding which workflows are quietly expensive. Part of the agent-toolworks tooling family.
Covers GAMP 5, 21 CFR Part 11 and EU GMP Annex 11 with live eCFR and openFDA lookups plus an IQ/OQ/PQ qualification engine. Ships slash commands, auto-invoked skills, parallel sub-agents, an MCP server and a document-protection hook. One of the more complete regulated-industry Claude Code integrations published.
Shows context usage alongside your 5-hour and weekly limits, each with its reset time, in a compact two-line Claude Code status line. Cross-platform across macOS, Linux and Windows. Minimal alternative to heavier usage dashboards.
Compresses context locally with dedicated Claude Code, Codex and Cursor profiles, removing duplicate context, prioritizing git diffs and filtering generated files. Adds conversation summaries, token estimates, reusable presets, and clipboard or folder workflows. Runs without sending anything out.
Streams your machines' windows, desktops and terminals to a browser so you can close the lid and keep working — useful for checking on long-running agent sessions. End-to-end encrypted with no open ports, no client install and no account. Self-contained by design.
Verifies that the citations in a document are real, accurately described and used consistently throughout. Works on Markdown and .docx, so it fits documents agents actually produce. Directly targets one of the most damaging LLM failure modes.
Runs copilot-proxy-api from the Omarchy bar with GitHub sign-in and live Copilot quota meters. Wires Claude Code or Codex CLI to it in one click. Niche to Omarchy users but a tidy piece of desktop integration.
Gives agents semantic code search plus call-graph navigation without sending code anywhere. The combination matters — semantic retrieval finds candidates, call graphs prove how they connect. Entirely local operation.
Puts small arcade games into the Claude Code status line for the gaps while an agent works. Purely for fun, but a genuinely creative use of the status line API. Worth a look if only for the implementation.
Monitors usage limits, quotas and reset timers for Claude, OpenAI Codex and Google Antigravity from a Windows desktop widget. Built in Go with Fyne, with no telemetry. Fills a gap for Windows users left out of most macOS menu-bar trackers.
Analyzes Claude Code session logs to answer whether extending the prompt-cache TTL would have paid off for your actual usage pattern. Turns a pricing decision into a measurement instead of a guess. Small, focused tool.
Lets multiple Claude Desktop accounts run concurrently on one Mac while sharing Claude Code chats between them. Useful when personal and work accounts both need to be live. macOS only.
Indexes a channel's content so you can query it from the terminal, returning exact citations with every answer. The citation requirement is what separates it from generic transcript search. Useful for mining long-form expert content.
Wires a WhatsApp number into Claude Code so it can automate messages and manage conversations. Turns a chat thread into an agent interface. Check the permission model carefully before pointing it at a personal number.
Uses tree-sitter to widen every hunk to the surrounding function or block, so a diff reads with its context intact. Works as a pager for git, gh or lazygit, and as a viewer for coding-agent edit traces. Directly improves reviewing agent-generated changes.
Tracks and visualizes Claude Code, Codex and Cursor usage with heatmaps and statistics. Multi-machine sync happens over a git repository you control, so no third-party service holds your data. Good fit for people working across several machines.
Sets up skill routing and the Roblox Studio MCP server, and keeps enough written state that a new session knows where the last one stopped. Removes the setup friction from agent-assisted Roblox development. Template rather than framework.
Drives a fleet of high-reasoning agents through Pi, usable directly in the Pi harness or driven from Claude Code or Codex. Useful for fanning hard reasoning work out to a different model pool. Requires OpenRouter access.
Manages multiple concurrent coding agents in one macOS interface that behaves like an IDE rather than a terminal grid. "Calm" is the design goal — less noise from parallel sessions. macOS only.
Runs Claude Code sessions continuously with onion architecture, distinguishing rate limits from exhausted credits and resuming safely across usage windows. That distinction matters — most runners retry blindly into a wall. Also a full Anthropic SDK CLI.
Provides plugin registration, lifecycle management and a full-link adaptation layer built on fusion-desk. Reports 222 test cases at 99% coverage. Infrastructure rather than end-user tooling.
Shows whether you're ahead of or behind pace on your 5-hour and 7-day windows, and where your current burn rate lands you. Knowing the trajectory is more actionable than knowing the percentage. Drops into the Claude Code status line.
Lets cloud-hosted agents run against a genuine dev environment on hardware you own, rather than a stripped sandbox. Bridges the gap between cloud agent convenience and local environment fidelity. Self-hosted.
A self-hosted personal memory RAG with a Rust engine, Python hooks and Ollama for inference, recalling past session knowledge on demand. The wiki output stays human-readable, so you can audit what it remembered. Zero cloud dependency.
A terminal multiplexer and control plane for coding agents, reachable over Tailscale so you can drive sessions from a phone. Mobile-first layout rather than a desktop UI squeezed down. Good fit for supervising long agent runs away from the desk.
Two small tools for the agent layer: one detects skill poisoning, the other gives RAG bases temporal validity so stale facts expire. Pure Node with zero dependencies and no network access. Prompt-injection defence at the skill-supply-chain level.
Every long-running agent gets its own chat channel with voice-first control and a durable identity that survives restarts. The durable identity is what makes it usable — the agent you were talking to yesterday is still there. Built for supervising background work.
Built around coding agents as the primary user rather than retrofitting an editor, with end-to-end encryption on the command centre. Aims to be where you supervise agents rather than where you type code. Early but ambitious.
Handles reusable AI agent skills, prompts, rules and tool files with proper package-manager semantics. As skill collections proliferate, versioned distribution becomes the bottleneck. Open source with its own registry.
Agents send a small authenticated request and AgentNotify shows a dedicated non-activating WPF toast, so your focus isn't stolen mid-task. Unresolved requests stay visible from the system tray with full local history. Solves the "which of my six agents needs me" problem on Windows.
Compares Claude Code running Fable, Opus and Sonnet on the task of implementing a Rust OS kernel from a single prompt. A hard, unambiguous benchmark that's difficult to game with surface-level output. Useful reference data for model selection on deep systems work.
Curates Claude Code plugins and includes a generator that emits equivalents for Claude, OpenCode and Antigravity. The generator is the interesting half — write once, target three harnesses. Marketplace-format install.
A Mnemosyne OS cartridge that reads Claude Code and Antigravity session transcripts locally, letting you promote good drafts into your own memory system. Recovers the writing buried in transcripts you'd otherwise never revisit. Currently in beta.
A retro-styled front end for Claude Code, OpenAI Codex and Ollama on Windows and macOS. Style over minimalism, but a working multi-backend terminal client. Worth a look if the default TUI doesn't suit you.
A navigation toolkit aimed specifically at big C# and TS repositories where naive search overwhelms an agent's context. Language-specific tuning rather than generic embedding search. Useful for enterprise .NET work.
A Tauri 2, React 19 and Rust desktop application for managing Claude Code CLI usage at team scale. Positions itself as an AI programming assistant management platform. Documentation is in Chinese.
A hybrid Python library and agentic skill for finding and connecting with relevant researchers at an academic conference. Originally built for ECCB 2026. Niche but a nice example of a library plus skill pairing.
A web launcher and session manager for Claude Code and Codex on macOS with WezTerm, letting you start, watch and steer sessions remotely. Built around WezTerm rather than tmux, which is an unusual choice. Phone-friendly interface.
Repurposes the notch area as a switcher between running coding agents, with three hand-crafted modes. Installs in one prompt via Claude Code, Codex or Cursor. Genuinely clever use of otherwise dead screen space.
Tracks Claude usage limits in real time from the macOS menu bar, built in Swift and SwiftUI. Native rather than an Electron wrapper, so it stays light. Straightforward and focused.
A natural-language-first task manager where humans type freely and agents get clean JSON over a CLI. The dual interface avoids making either side use the other's format. Built on Next.js 16 with DeepSeek.
Pulls skills for Claude Code, Codex and Grok out of dozens of separate repositories into a single local catalog you can search, browse and install from. Runs a risk check on every skill before you install it. The risk check is a meaningful addition given skill-poisoning concerns.
A two-pane tmux workspace for voice-driven worldbuilding, where you speak and an agent organizes the notes into the vault. Removes the friction of filing while you're still thinking. Narrow use case, clean execution.
Moves sessions and configuration between machines so you can resume work after switching computers. Uses plain SSH rather than a hosted service. Bilingual English/Chinese documentation.
AAS Core handles catalog discovery, agent-owned selection, stack validation and planning across a large skill catalog, shipping a CLI, a local MCP server, plugins and a Workbench. Agent-owned selection means the model picks its own skills from the catalog. Local-first architecture.
A Claude Code plugin marketplace bundling role-based senior review lenses, dev-workflow generators, anti-slop scanners, a pre-publish secret-leak scanner and drop-in rule packs. The pre-publish leak scanner is the standout. Installs as a marketplace.
Verifies every legal quotation in a document against the real source text on your own disk, then sends the same question to several models and runs their quotations through the same check. Fully offline with no API key. A rigorous answer to legal hallucination.
Downloads the newest GitHub release while showing the changelog, verifies the binary, then restarts your running instances. Small quality-of-life wrapper around a manual update chore. Verification step is a nice touch.
Integrates AI CLI tools into a WeChat bot with shared thread and session state between WeChat and the local terminal, bidirectional conversation, and two-way file transfer. Supports switching between CLIs, emoji-bound commands and bidirectional /resume. Documentation is in Chinese.
Switches between model profiles for Claude Code, Codex and other CLIs through a proxy layer. Handy when you juggle several providers or accounts. Lightweight and focused.
One JSON policy file drives audit, recyclable cleanup and rollback of the files Claude Code, Codex, Aider and OpenClaw scatter around, backed by a hash-chained audit trail. Recyclable cleanup with rollback means you can be aggressive safely. Addresses a real and under-tooled problem.
Combines file-first task and bug tracking with a multi-provider agent runtime, and its CRASH components keep one shared project brain usable across more than 30 AI tools. Distributed as a signed single binary. Ambitious scope, cleanly packaged.
A cross-platform CLI bringing Claude Design's workflow to other coding agents, with automatic Agent Skills, codebase-grounded UI design, design-system sync, visual review, Impeccable integration and conflict-safe MCP workflows. Removes the copy-paste relay between the visual workspace and your terminal. Two-way sync keeps both sides current.
Meters your plan window and watches usage across Claude Code, Codex and Grok CLI without ever intervening. Observe-only is a deliberate choice — it warns rather than throttles. Runs entirely locally.
Manages Agent Skills from a central library with per-project switching and snapshot rollback, supporting Claude Code, Kimi Code, Cursor, Codex and six other agents. Ships as an Electron desktop app, a CLI and a TUI. Documentation is in Chinese.
Supports direct mail, project-wide broadcasts and advisory file claims across repositories for concurrent coding-agent sessions. One static Rust binary and one SQLite file, with no daemon and no polling. The advisory file claims are what prevent two agents editing the same file.
An Agent Knowledge Kit that lets agents understand a codebase's architecture at a fraction of the usual token cost. Architecture discovery is where most of an agent's early context goes. Measured efficiency claim rather than a vague one.
Lets a coding agent call the local Antigravity CLI to complete a task, adding a second model to the loop. Simple delegation bridge. Useful if you already have Antigravity access.
Searches all Claude Code session record types by regex, recovers files, extracts images, inspects subagent topologies and matches plan files to sessions. Session transcripts hold a lot you can't otherwise get back. The most thorough session-forensics tool published so far.
Dispatches and reviews AI coding agents, gives them disposable VMs to test in, and keeps meetings, tickets, pipelines and your calendar on one surface. Available as a desktop app on macOS, Windows and Linux, plus web and phone. Broad scope for a single tool.
Explains what each agent loads into context and estimates tokens per fire and per day, statically rather than by running the system. Lets you catch an expensive context graph before it bills you. Useful for anyone running large agent fleets.
A macOS sandbox for confining AI coding agents, shared by a user running it in daily practice. Restricts what an agent process can reach on the host so an unattended session cannot touch credentials or files outside its workspace. Relevant to anyone running Claude Code with relaxed permission modes on a Mac.
Fires a minimal session to open the rolling 5-hour usage window at a time you choose, so the window is already running when you sit down instead of starting from your first real prompt. Supports both Claude Code and Codex, with no dependencies on macOS and Linux. Aimed at reclaiming hours otherwise lost to badly aligned window boundaries.
Serves persistent tmux workspaces as live terminals in a browser, with a layout that works on a phone. Surfaces coding-agent status alongside the terminals so you can see which session needs attention. Handy for checking on long-running Claude Code sessions away from your desk.
Puts Pi, Claude Code, Codex, and Grok Build into one shared local Herdr room so several agents and the user occupy a single conversation. Enables cross-agent handoff without copying context between terminals. Early-stage and local-first.
An open-source desktop agent that reads and writes files, edits code, and runs commands as an alternative to Claude Code, Cursor, or Copilot. Runs local-first with no setup and no API key required, on Windows, macOS, and Linux. Aimed at users who want an agent workspace without a subscription or key management.
Keeps project context in a local store that the human curates explicitly, rather than letting each tool accumulate its own opaque memory. Shared across AI coding tools so the same governed context follows you between them. Local-first by design.
Gives Claude Code, Codex, Gemini, Cursor, and opencode a single shared Markdown vault for persistent session memory. Because the store is plain Markdown, memory survives switching between CLIs rather than being locked to one vendor. Set up through a create-style installer.
A workspace built around an explicit loop: you delegate a task, agents do the work, you approve the result. Structures agent output for review instead of leaving you to reconstruct what changed. Aimed at keeping a human decision point in every unit of work.
A stdlib-only CLI that statically audits the places AI tooling executes code on your behalf: Claude Code hooks, VS Code settings, npm install scripts, GitHub Actions, and instruction files. Surfaces supply-chain risk in configuration that normally gets installed without review. No dependencies, so it can be run on an untrusted checkout cheaply.
An autonomous backend delivery agent that takes a ticket through to a tested PR using multi-worker fan-out and sandboxed validation. Orchestration is evidence-gated, so a stage advances only against proof the work passed. Targets backend delivery rather than general-purpose chat coding.
A Stream Deck plugin that starts a Claude Code session in a chosen project folder from a single key press. Removes the terminal-open-and-cd step when juggling several repos. Simple, single-purpose plugin.
Wraps the Claude Code CLI in a messenger-style desktop window so a subscription session feels like a chat app instead of a terminal. Windows-only with a Chinese UI, running entirely locally. For users who find the terminal presentation a barrier.
A macOS app and CLI that talk to the OpenAI Codex app-server, shipped with a Claude Code skill for driving it. Lets a Claude Code session dispatch work to Codex through a proper client rather than terminal scraping. For users who run both tools side by side.
A desktop coding agent for macOS that runs on the Claude or ChatGPT subscription you already pay for, with guardrails around what it can do. Gives a native app experience without a separate API bill. Alternative front end for subscription users.
Statically scans a skill's SKILL.md, scripts, and config before you install it, flagging destructive commands, hidden network calls, secret reads, obfuscation, prompt injection, and persistence. Runs locally with explainable output, and ships a CLI, 36 test fixtures, and a GitHub Actions integration. Addresses a real gap now that skills are installed casually from arbitrary repos.
Wraps an agent process in a sandbox with minimal setup, so isolation is a one-command decision rather than an infrastructure project. From kontext-security. Lowers the friction of running agents with broad permissions safely.
Captures claims an agent made in chat and attaches them to the specific files they concerned, storing the tickets in git so they survive sessions and tool switches. A pinned assertion automatically goes stale when the underlying files change. Attacks the problem of load-bearing conclusions evaporating when a session ends.
Coordinates agents from different vendors through a chat-first interface, CLI-first and self-hosted. Keeps everything local rather than routing through a hosted control plane. For mixed-agent setups that should not depend on a third-party service.
Tracks Claude Code cost and usage locally and stops the agent before it blows through a budget you set, with guardrails alongside plain tracking. Local-first with no account required. Preventive rather than a dashboard you notice after the fact.
Sits after implementation and produces evidence that the change behaves as claimed, separating 'the agent said it works' from verified behavior. Complements rather than replaces your test suite. Aimed at the trust gap in agent-written code.
Displays remaining usage for Claude Code, Codex, and Cursor along the edge of the screen on macOS and Windows. Always visible without occupying a window or requiring a terminal command. Small ambient indicator for limit-constrained work.
Provides a controlled distribution point for agent skill marketplaces served over git, covering Claude Code, Copilot, and Cursor. Lets an organization vet and publish skills internally instead of having developers install from arbitrary repositories. Directly relevant given the supply-chain risk in casually installed skills.
A native app that gathers all pull requests awaiting your review, prioritizes them, and lets you review and merge without switching browser tabs. Not agent-specific, but useful when agent-generated PRs pile up faster than you can triage them. Single-window workflow.
An open-source terminal coding agent written in Rust, using AST micro-structure retrieval, a stable KV cache, and five levels of tool self-healing. Prioritizes speed and autonomy over interactivity. Chinese-language project.
Indexes local Claude Code and Codex session history so you can search what you did before and pull it back into the current conversation. Works across both the CLI and a desktop app. Turns session logs from a write-only archive into a usable memory.
An unofficial Windows widget that floats above other windows showing remaining Codex and Claude usage. Minimal footprint, single purpose. For Windows users who want the number visible without checking a terminal.
Bootstraps a full AI coding toolchain on a fresh machine from a single command. Makes a workstation reproducible rather than assembled by hand over months. Useful when you regularly work across several machines or VMs.
Persistent cross-project memory, session capture, and Markdown knowledge management for Claude Code, Codex, OpenCode, and Obsidian. Keeps everything local and in Markdown so your notes and your agent memory are the same corpus. For users already living in Obsidian.
A desktop front end for running and switching between multiple Claude, Gemini, Aider, and Codex sessions, built on Wails, Svelte, and xterm.js. The GUI counterpart to the CLI-based agent-session-manager. Addresses the lost-in-tabs problem when running several agents at once.
A lightweight terminal dashboard showing Claude Code token usage, active agent sessions, and system resources. Written in Go, so it is a single binary with no runtime to install. Stays in the terminal rather than requiring a browser or desktop app.
Routes mechanical sub-tasks to a local llama.cpp server so they consume zero cloud tokens, keeping the paid model for work that needs it. Ships as a toolkit plus Qoder CLI skill and agent integration. A concrete cost-reduction path for limit-constrained users.
Presents itself as a reference setup rather than a starter kit: staged installation, 41 verification checks, and a tool registry with a 90-day sunset window for anything unused. Built for Apple Silicon and tested against a real 100-tool inventory. The sunset window is a useful answer to toolchain sprawl.
Removes the caches, logs, and artifacts AI coding tools accumulate, with rules that are published and auditable rather than a black-box cleaner. You can see exactly what a rule will delete before running it. Chinese-language project.
A Windows x64 desktop pet that displays live status and token usage for Claude Code, Codex, TRAE, WorkBuddy, and opencode. Everything runs local-first, so session data never leaves the machine. Gives an ambient at-a-glance signal of whether an agent is still working without tabbing back to the terminal.
Runs a coding agent inside a sandbox so it cannot touch anything outside its workspace, then inserts review gates before it is allowed to open a pull request on your repo. The pitch is containment plus a human checkpoint at the moment changes leave the sandbox. Aimed at people running longer unattended sessions who want a blast radius.
A Claude Code plugin marketplace shipping four plugins: qa-swarm (multi-agent code review with TDD fixes), code-atlas (architecture index and queryable graph), plan-runner (parallel plan execution), and jupiter (spec consolidation). The plugins cover review, codebase navigation, and parallel execution as one installable set. Useful as a bundle rather than piecemeal.
A local memory layer for Claude Code built as a Rust CLI. It captures the agent reflections from your sessions and retrieves them later, so accumulated judgment about a codebase survives across sessions. Aimed at a single engineer craft rather than team-wide knowledge sharing.
Runs AI coding agents inside containers so a misbehaving agent cannot touch your host machine. Supports customizable agent profiles for different projects or permission levels, and ships a visual web UI for driving sessions instead of the terminal.
Keeps your Claude Code and Pi session history in sync across multiple machines. It canonicalizes project paths so the same repo checked out at different locations lines up, then merges histories through a Git-backed CRDT so concurrent edits from two machines resolve without conflicts.
A local dashboard that reads your Claude Code usage data and shows token counts, costs, plan limits, and pace predictions for whether you will hit your cap. Updates live and includes a picture-in-picture widget so the numbers stay visible while you work. No dependencies to install.
From Weights & Biases, an observability tool for agentic coding. It captures your Claude Code sessions so you can search them, replay how a task actually unfolded, and share the trace with teammates. Aimed at teams that want to learn from each other agent runs rather than each person debugging in isolation.
A human-in-the-loop conversational task manager that lets you control your coding agents from mobile, web, or desktop. Self-hosted and harness-agnostic, designed to work with your existing Claude subscription rather than an API key. Fills the gap for people who want to check on or redirect a running session away from their terminal.
Turns the Claude Code status line into an ad slot, showing a single labelled sponsored line only while the model is working. The developer keeps 70 percent of the revenue it earns. An unusual experiment in monetizing agent idle time rather than a productivity tool.
A local-first desktop viewer for browsing AI coding-agent session history, including Claude Code transcripts. Everything stays on your machine — no upload step or hosted account — making it usable for reviewing sessions that touched private repos. Useful for auditing what an agent actually did across a long run.
A small desktop widget for Debian/GNOME that displays your Claude Code usage in real time. It sits always-on-screen so you can watch quota burn without dropping into a terminal. Niche to the Linux desktop, but a straightforward answer to "how much of my window have I used".
A local-first associative memory store that several agent CLIs read from and write to, so context follows you between tools. It is taskless — no explicit save step or task list to maintain — and everything stays on your machine. Relevant if you switch runtimes mid-project and keep re-explaining the same background.
An opinionated local web interface that treats Claude Code or Codex as a personal assistant and second brain. Chats, projects, files, schedules, memory, and archived knowledge live in one place instead of being scattered across terminal sessions. For people who want agentic work to persist and stay browsable after the terminal closes.
An external memory store that persists decisions, patterns, failed approaches, and architectural choices between Claude Code sessions, so you stop re-explaining the same context after a break. The author has run it daily for several months and drives it from a simple slash command. Aimed at the gap compaction doesn't close — knowledge lost when a session ends entirely.
Clone the repo, point Claude Code at it, and the AGENTS.md drives the whole search: it interviews you, writes an ideal job description, embeds it once, then downloads a slice of a two-million-job dataset locally and ranks matches. Needs a real machine rather than the web app because of the dataset download. A good worked example of shipping an agent workflow as a repo instead of an app.
A shared message board that lets subagents and sessions across different LLM providers post to and read from each other rather than working siloed. Inspired by an incident where agents coordinated through a message board. The author reports it works best when several subagents need to reach consensus or debate before converging on a goal.
Open-source orchestrator that arranges Claude Code, Codex, and Gemini agents on a draggable canvas organised by authority, so agents can talk to each other instead of stepping on one another's work. Supports reordering and reorganising the hierarchy as a project evolves. The gallery shows real organisations the author maintains across live projects.
A local gateway that drives Claude Code, Codex, Kimi Code, DeepSeek Harness, and Antigravity from Feishu/Lark, with optional Telegram support. Ships a native DeepSeek Harness plugin. Useful if your team already lives in Lark and wants to hand work to a coding agent from chat.
Minimal plan review tool — Claude's plan renders in your browser, you annotate it inline, and the feedback goes back to the agent. Zero dependencies, no network, roughly 400 lines of stdlib Python. Fills the gap where plan mode gives you one approve/reject decision instead of line-level comments.
Sits between Claude Code or Codex and the cloud, stripping sensitive data from outbound traffic before it leaves your machine. Chinese-language project. Complements deny rules by controlling what escapes rather than what the agent is allowed to open.
Menu bar app showing remaining Codex and Claude quota, what you've spent locally, and when the usage window resets. Small, single-purpose answer to the recurring question of how much budget is left before the next reset.
Search across all Claude Code sessions regardless of which directory they started in, and resume the one you want. Tagged sessions are exempted from Claude Code's 30-day cleanup, so the ones that matter survive. Solves both halves of session loss — finding it, and it still existing.
Plugin for running long-horizon tasks that continue after you shut the laptop lid. Chinese-language. Targets the common failure where a multi-hour agent run dies because the machine sleeps.
Context engine for Claude Code, Codex, Gemini, and MCP clients that returns cited Markdown recall alongside code search, wired in through hooks and servable across machines. The citations matter: recalled context points back at its source instead of arriving as unattributed assertions.
Queue messages for Claude Code CLI and Desktop that are delivered on the next turn instead of interrupting the current one, and survive restarts. Lets you keep typing follow-ups while the agent works without derailing what it's doing.
Menu-bar app that starts a minigame while your coding agent works and pauses the moment the agent needs input. A genuinely different answer to waiting on long agent runs than another progress dashboard.
macOS app plus local CLI and MCP surface for managing coding-agent skills, MCP servers, usage, provenance, and project health in one place. Provenance tracking is the less common part — knowing where an installed skill actually came from.
Terminal UI that pulls issues from Linear and dispatches coding agents against them, keeping the board as the source of truth for what to work on next. Closes the loop between issue tracker and agent without a web dashboard.
Runs Claude Code and Copilot CLI side by side over a shared task board, where neither agent can mark work finished without the other signing off. The mutual sign-off is the point — it turns cross-model disagreement into a gate rather than a coin flip.
Local analytics over Claude Code, Codex CLI, and Gemini CLI usage with zero dependencies and no network access. Reads what's already on disk, so it works offline and nothing about your sessions leaves the machine.
Analyses your coding sessions into evidence-linked findings and an opportunity-aware profile of your AI skills — where you're losing time and what to change. Local-first with zero telemetry. Profiles the operator rather than the code.
Open-source framework treating people and agents as the same kind of entity on a personal second brain, driven by a Recall-to-Deep-Research loop. Manifest-first and Apache-2.0. An unusual framing of CRM and agent management as one problem.
Aggregates installs, growth, and social signal for agent skills from skills.sh, ClawHub, Tencent SkillHub, GitHub, X, and ten-plus communities into a daily top 100, published as open CSV. Handy for discovery when every skill repo claims to be the best one.
Tracks Claude Code, Codex, Cursor, OpenRouter, and other subscription quotas in the menu bar, with alerts fired before you hit a limit. The alerting is what separates it from the several read-only quota widgets around.
Runtime monitor that observes what installed npm packages actually do — reading SSH keys, touching secrets, phoning home — and blocks them. Relevant when an agent installs dependencies on your behalf and nobody reads the postinstall script.
Local-only layer that records every action your AI coding agent takes, blocks the ones you don't allow, and restores the tree to a previous state when something goes wrong. Undo for agent sessions rather than for individual edits.
Claude Code statusline combining who you are, how much context is used, a session quality read, and plan-limit tracking into labeled lines at the bottom of the session. Consolidates what usually takes several competing statusline scripts.
Reads your Claude Code session history and produces a personalized profile, a twin sub-agent that works the way you do, and a suggested CLAUDE.md patch. Local-first — logs never leave the machine. Derives your preferences from evidence instead of asking you to write them down.
Terminal viewer for spend across OpenCode, Claude Code, Codex, and other agents. Terminal-native rather than a menu-bar widget, so it fits alongside the tools it's reporting on.
Terminal UI that manages multiple git worktrees, runs Claude Code sessions in embedded PTYs, and lets you review diffs with structured inline comments — all without leaving the TUI. Combines the worktree juggling and the review step that usually live in separate tools.
Automated pipeline running trend research, scripting against a craft bible, HeyGen avatar cloning, Remotion graphics, a frame-level QA gate, and Telegram approval before publish. MIT-licensed. The QA gate and human approval step are what keep it from being a slop generator.
Gives coding agents a single authoritative memory for a repo so they stop re-learning the same facts and stop scattering conflicting memory files. Targets the failure mode where three agents each maintain their own notes that disagree.
Deterministic scanner that finds missing artifacts across a skill library — the code layer of the Agent Knowledge Cycle's Curate phase. Checks structure mechanically rather than asking a model whether your skills look fine.
Empirical study scanning 2,500 repositories and 1,652 agent-instruction files for hidden or adversarial instructions. The result is negative — none found — which is a useful data point against assuming AGENTS.md files in the wild are a live prompt-injection vector. Method and data are in the repo.
You describe what needs doing a single time; CMD dispatches agents to do it and returns results in a reviewable form. Aimed at recurring work you'd otherwise re-explain to an agent every time it comes up.
BYOK setup path for Claude Code aimed at users in mainland China, with no account required and no user data passing through the project. MIT-licensed. Addresses an access problem that most setup guides ignore.
Produces a Next.js workspace already structured for agent work, generated from a blueprint you review first in the browser or terminal. The review step before generation is the useful part — you catch structural mistakes before there's code to unpick.
Journals every turn to local SQLite, curates the durable facts out of that log, and syncs the result across machines. Works with Claude Code and OpenCode. Recovers a crashed session as well as carrying memory forward.
Takes a sketch and produces a Brownian-dynamics result you can defend: dimensional analysis first, predictions sealed before running, and failed attempts kept rather than discarded. A rare example of an agent workflow built around scientific method rather than throughput.
Mines git history together with AI coding sessions to surface rework, rollbacks, and time sinks, then generates a retrospective, a portfolio piece, and evidence-backed résumé material. Chinese-language. The rework detection is the interesting output.
Packages an unfinished task into a portable bundle another agent CLI can pick up, so switching tools mid-task doesn't mean re-explaining the state. Useful when you hit a usage limit on one provider and want to continue elsewhere.
Start and resume Claude Code and Codex sessions from a single launcher with fuzzy search and a transcript preview before you commit. Ships both a terminal TUI and a native macOS menu-bar GUI. The transcript preview is what makes resuming the right session practical.
Local-first desktop app that bridges your working directory to browser-based assistants — ChatGPT, Claude.ai, Gemini — so you can use a web subscription against local code without copy-pasting files.
Single surface for all your concurrent Claude Code sessions, with SDK-owned sessions, approval handling, finish chains, and usage tracking. Built on the Agent SDK rather than by scraping terminal output.
Self-hosted workbench for matching, staging, and tracking Etsy listings fulfilled by Printful, published together with documentation aimed at AI agents building a production version. The docs-for-agents framing is the more interesting half.
Contamination-resistant harness that compares whole agents rather than underlying models, using 80 fail-to-pass cases from merged OSS PRs, long-run sequences, SWE-bench-Live, and 25+ domain benchmarks. The authors run their own agent under the same rules, which is the right disclosure for a vendor-published benchmark.
SwiftUI macOS IDE with a project-aware Claude Agent SDK runtime built in, rather than a terminal wrapper or an editor plugin. For people who want the agent as a first-class part of a native app.
Hands out leases on ports and processes so several concurrent coding-agent sessions don't fight over :3000. A small, specific fix for a problem that shows up immediately once you run more than two agents on one machine.
Drives WordPress content and administration over the REST API from Claude Desktop, Cowork, or a CLI runtime. A companion advanced edition adds CLI-only theme development through GitHub, SSH, and WP-CLI.
Wires DeepSeek into Claude Code or the Codex CLI as a genuine sub-agent rather than a one-shot model call. The sub-agent gets a 7-tool loop of its own and runs inside a sandboxed workspace, so it can iterate on a task and report back. A way to offload cheaper or bulk work to a second model without leaving your main session.
Reads your Claude Code session logs and surfaces token usage, cost, and full conversation history in three interfaces. The TUI is for quick session triage; the web view is for digging through past transcripts. Handy when you want to know where a week of usage actually went.
A macOS launcher that opens a coding agent in a deliberately minimal environment, letting you pick exactly which context comes along. Cuts the default pile of config and history that gets loaded on startup. Useful when you want a session unpolluted by unrelated project state.
Replaces polling loops with notification callbacks, so an external event wakes the specific session that was waiting on it. Context is compressed with task-aware memory and subtasks dispatch into project-scoped sessions. Built for agent work that spans hours and must survive interruption.
Bundles sandbox isolation, model provider routing, terminal session management, and Kubernetes orchestration behind one control plane for AI coding agents. Adds plan-driven development workflows on top. For running agents at more than single-laptop scale.
Pulls any live Framer site down into a real codebase, deploys it, and lets you keep editing through agent chat afterward. Gets you off the hosted builder without rebuilding the design by hand. Useful as an escape hatch from no-code site tools.
Exports WeChat 4.1+ direct messages, group chats, and a ranked list of important contacts into a form Claude Code can read, with data never leaving the machine. Lets an agent reason over your chat history without uploading it anywhere. Documentation is primarily in Chinese.
Drives the Gemini web app through an existing Google AI Pro subscription to produce Nano Banana images, Veo video, and Lyria music from inside Claude Code. Generated media is written straight to disk so the bytes never enter the agent's context window. No separate API billing needed.
A five-plugin marketplace: token-eater for usage, pro-gate for access control, wsl-cdp for Chrome DevTools on WSL, skill-tuner, and memory-dream. The WSL CDP plugin is the most specific — browser automation from Windows Subsystem for Linux is otherwise fiddly.
Anthropic ships a Linux build only as a .deb; this repo converts that exact package into a proper Fedora RPM. The Code tab, Cowork, MCP, and sandbox all work, tested on Fedora 44 under KDE and GNOME on Wayland. Replaces the old Windows-installer hack, which broke on recent versions.
A curated plugin marketplace that publishes a native index for each host — Claude Code, Codex, Cursor, Grok Build, and GitHub Copilot CLI — rather than one format everyone has to adapt to. Same catalog, host-appropriate packaging. Reduces per-agent porting work.
Turns a Surface Pro into a dedicated control plane showing Claude Code usage, system telemetry, coding session state, and automations across several machines. Machines report through a normalized agent API. Built with Tauri, React, and Fastify, and runs local-first.
An open-source testing tool driven by your coding agent that behaves like a real user — walking both the happy path and the flows nobody designed for — to surface bugs and confusing interactions. It records every run for replay and reports quality-of-life suggestions without touching your codebase, so it stays read-only against the project under test. Works for websites and apps.
A small PHP bridge that turns a URL into a read-only Claude Code session, exploiting the fact that Tesla's built-in Grok assistant can open URLs. Speak to the car, Grok hits the endpoint, Claude Code answers, and the reply comes back through the voice assistant. A minimal pattern for reaching Claude Code from any voice assistant that can fetch a web page.
A Herdr plugin (with an optional Plannotator TUI) for marking up agent output and project files in place — grill sessions, plans, specs — and returning the annotations to the agent as structured feedback. Opens as a popover or a pane and works with mouse or keybindings. Aimed at closing the review loop without copy-pasting critique back into the prompt.
A 1080x1920 portrait dashboard built for a spare monitor: large clock, date, and a live list of Claude Code agent sessions currently running. Written in WinUI 3 on .NET 10, so it is Windows-only. For people running several unattended agents who want ambient visibility without alt-tabbing.
Renders repository state as a subway-style diagram of branches and pairs it with plain-English advice about what to do next. Explicitly built for people who arrived at git through AI coding tools and never learned the underlying model. A gentle way to see what an agent has done to your branch structure.
Inspects Claude Code, Codex, OpenCode and Cursor installations and reports what is actually configured — MCP servers that fail to start, misfiring hooks, and how much of the context window your setup consumes before work begins. Runs entirely locally, sending nothing anywhere. Genuinely useful once you have accumulated enough plugins to lose track of them.
A targeted fix for the "VirtioFS mount failed: bad address" crash that takes down Claude Desktop and Cowork VMs on Windows. It resolves the mount without a reboot, which is the part that matters when the crash hits mid-session. Narrow in scope but a real time-saver if you have run into it.
A local dashboard that gives each concurrent agent session its own workspace clone and its own database, so parallel runs cannot corrupt each other's state — a step beyond worktree isolation for anything touching a datastore. Adds an automated PR review loop on top. For running several agents on one project at once.
The vendor-published Claude Code plugin for Vertiso's memory service, giving sessions persistent recall across restarts. Being first-party, it should track the service's API more reliably than community wrappers. Only worth installing if you already use Vertiso.
A Claude Code statusline that surfaces the current model, reasoning effort, context usage, cost, quota reset times and working directory. Useful if you switch models often and want to see effort and remaining quota without leaving the session.
A unified configuration hub for AI coding agents. Define providers, MCP servers, skills and memory once, then sync them out to each agent instead of maintaining parallel configs per tool.
A living catalog of reusable plugin features that work across Claude Code, OpenCode and Gemini CLI. Ships automatic versioning, git hooks, cross-CLI compatibility checks and doc conventions; plugins pull features in and push improvements back. Spanish-language docs.
Wraps a command so that when it crashes, the error is scrubbed of secrets and handed straight to your AI coding agent. The free tier is open; a paid tier adds git checkpointing, undo and restart-to-verify.
Reopens your Claude Code tabs in Windows Terminal after a crash or reboot, reconstructing them from session history. No daemon and no setup required beforehand — it works from what Claude Code already wrote to disk.
A Sublime Text terminal built on real ConPTY with ANSI rendering via libghostty-vt, with no Terminus dependency. Tailored to running Claude Code, Codex and other agent CLIs inside ST tabs.
Instead of writing yet another agent loop, this framework runs an existing coding-agent harness — Claude Code, OpenCode or Pi — as its execution engine. Lets you build agent behavior on top of a harness you already trust.
A Claude Code plugin backing memory with HydraDB. Syncs workspace state, captures memories during a session and recalls relevant ones at prompt time rather than dumping everything into context.
Tells you what your AI agents cost per project without prompts leaving the machine. Ships as a CLI, an MCP server and a CI gate, with zero dependencies and fully offline operation.
A high-performance local codebase indexer and query engine offering architectural graph analytics, natural-language Cypher queries and multi-repository context generation. Built so AI agents and developers can navigate large codebases without loading them wholesale.
A visible caffeinate for agent-heavy Macs: shows per-session working-versus-waiting state for Claude Code, Codex, Gemini, Copilot and opencode, keeping the machine awake during work and letting it sleep when the agents are idle.
Claude Command Center, a dashboard for running many parallel Claude Code and Codex sessions, added a manual attach/detach action so related sessions with no real spawn lineage still render nested in the sidebar. Devin CLI sessions now show model, reasoning effort and subagent calls.
Positions the coding agent as a project coordinator rather than just a code writer, backed by a cross-project knowledge graph and an immutable audit log. Self-hosted and EU-resident, BSL 1.1 converting to Apache 2.0.
A Claude Code plugin giving an agent the scaffolding to operate a business over many sessions: an OKF wiki, an OKR loop, a session gate, a decisions log and a ledger. Written by the agent for its own business, which makes it an unusual case study.
The open data pipeline that produces LinklyAI/best-skills, a daily ranking of AI agent skills across ecosystems. Interesting both as a skill-discovery source and as a worked example of an automated ranking pipeline.
Gives Codex, Claude Code and other agents a bridge to control multiple browsers, shipped alongside an Agent Skill. An open alternative to per-agent browser integrations.
Injects secrets from Bitwarden into agent-run commands and scrubs them back out of output, so Claude Code, Codex or Cursor can use credentials without them entering the context window or transcripts. Addresses a real leak path in agentic workflows.
An LMSYS-style arena that compares Claude Code, Codex CLI, OpenClaw, Hermes and OnDemand on the same task with the same model in isolated runs. Humans judge blind and results roll into an Elo leaderboard. FastAPI and MongoDB backend.
A local-first knowledge base that doubles as an Agent Skill, with evidence-backed wiki entries, an interactive knowledge universe view, Q&A over your notes, and shareable knowledge galaxies.
A menu bar app showing remaining Claude and OpenAI usage quota at a glance, so you find out you are near a limit before a long agent run stalls partway through.
Native macOS, iPhone and iPad clients that connect over SSH directly to Codex CLI and Claude Code sessions running on workers you control. No hosted middleman between your phone and your machine.
An AI video studio where a desktop editor connects to CLI coding agents such as Claude Code and Codex over ACP, letting them compose, edit and export video. An unusual use of the agent-client protocol outside code.
A small terminal coding agent for people who want something far lighter than a full harness. Worth a look as a readable reference implementation of an agent loop.
An open-source network letting AI coding agents share knowledge rather than each rediscovering the same things per project and per machine.
A desktop app that runs coding agents in parallel, each isolated in its own git worktree, so concurrent sessions cannot collide on the same working tree. Built in Rust with Tauri.
A cost/benefit dashboard for your MCP toolbox across Claude Code, Codex, Gemini CLI and Cursor, showing RAM use, context tokens consumed and real usage per server — with working on/off switches. Directly targets context bloat from servers you never call.
Rather than trusting the agent report, this tool reads the session logs Claude Code already writes and draws the turn while it runs: the context window filling against the real model, each API call as it lands with latency and cost, and every subagent under the spawn that launched it with its own window and model.
Brings niris scrolling tiling window model to CLI agent sessions in any terminal, daemon-free and MIT licensed. For people running many agent panes who find traditional tiling cramped.
A notification-area app showing Claude token usage and time until the next limit reset. Supports Windows 11 and Linux as of v0.6.0, which is rarer than the many macOS-only equivalents.
A macOS app for running Claude Code sessions in parallel where each task gets its own git worktree, branch, agent conversation and dev server. Built from source only — no prebuilt downloads.
Combines vector retrieval, a hand-curated wikilink graph and cross-encoder reranking on plain SQLite, with a per-turn memory ledger that costs no tokens. A working pilot rather than a finished product, but an interesting take on agent memory.
Collects AI agent usage and cost across providers into a single view, instead of opening a separate dashboard for each one.
Reads Claude Code sessions and writes pi sessions, so you can carry an in-progress conversation across harnesses instead of restarting context from scratch when you switch tools.
Start Claude Code tasks from Slack and approve every tool call from your phone. Turns supervision into something you can do away from the desk without giving up the permission prompt.
Vanilla JS with no build step, offering editor/preview scroll sync, ETag conflict diffs and git history over a self-hosted memory store. Light enough to run off a Raspberry Pi.
Turns a repository into a slide deck and then flags the deck when the code it describes has drifted. Aimed at the architecture presentation that silently goes stale a month after it is written.
A transcript-pricing tool revealed that Bash calls were 51% of all tool calls — tests, builds and git status cost more than writing code. Cache hit rate was 99%, invisible on a flat plan, and one session silently repeated the same call five times in three minutes. The script became a dashboard with a looping-session banner.
Indexes your coding-agent transcripts, discards everything except the turns you wrote yourself, and grades them. Local and stdlib-only — it never opens a socket. A way to improve your own prompting rather than the model.
Renders your codebase and GitHub pull requests as a live isometric city where AI agents visibly build and review software in real time. A genuinely novel take on agent observability.
vat records what happened across a set of repositories, the way git records history within one. It acts as a control plane for multi-repo workspaces and the coding agents operating in them. Useful if you run agents across several checkouts and lose track of what changed where.
An operator cockpit for treating coding agents as background jobs rather than sessions you babysit. The loop is plan, run, review, ship — you queue work and come back to results. Aimed at people running multiple agent tasks who do not want to sit and watch each one.
Takes reference UIs — images, screenshots, or URLs — and extracts a structured "Design DNA" JSON covering tokens, qualitative style, and visual effects. That profile can then drive generation of matching UI for your own content. Aimed at getting agents to reproduce a visual language consistently instead of improvising.
Launches AI coding agents with your instructions, memory, and usage tracking held in one central workspace rather than scattered per-repo. Nothing is left behind in the repositories you work on. Appeals to anyone tired of copying CLAUDE.md variants into every project.
Detects which of a set of known Claude Code tools (rtk, jcodemunch, graphify, Headroom, superpowers) you have installed and wires them into a single panel. Adds programmatic tool routing, enforced skill chains, and a combined view of token savings. Useful if you have accumulated several overlapping extensions.
A self-hosted server for running and managing AI coding agents remotely, supporting Codex, Claude Code, ACP, and MCP with isolated workspaces. Docs are bilingual (Chinese/English). Fits the case where you want agents running on a dedicated box rather than your laptop.
A terminal orchestrator that drives multiple Claude Code sessions from one window instead of juggling separate panes. Aimed at people running parallel agent work who want a single place to watch and steer it.
A lightweight desktop workstation that manages both Codex CLI and Claude Code sessions, with a built-in task scheduler, git worktree isolation per task, and remote control. Lets you queue agent work to run unattended and check on it from elsewhere.
A lightweight macOS dashboard that acts as a local development workbench and mission control for AI-assisted coding sessions. Aimed at people running several agent tasks at once who want a single status surface.
Ingests source material into a living wiki that an agent keeps up to date, then composes decks, papers, and posts from it in your own voice. Combines a knowledge base with a drafting pipeline rather than treating them as separate tools.
Puts every AI coding session and automation on your Mac onto one page reachable from your phone over Tailscale. Includes a work queue with fencing that the author tested against SIGKILL, so jobs are not silently lost when a session dies.
Builds a compact "project brain" that describes a codebase's architecture so an agent can orient itself without reading half the repo first. Targets the common failure of blowing context on exploration before any real work starts.
A personalization and governance layer installed through a guided wizard, backed by an open-source skills library. Aimed at teams wanting a consistent Claude Code setup rather than each developer hand-rolling their own config.
A minimal dev container template for GitHub Codespaces and VS Code that ships Python, Node.js, GitHub CLI, Claude Code, and OpenCode. A quick starting point for disposable agent-ready environments.
Brings Linear into Claude Code with search, bulk editing, dedicated agents, and a config-driven issue curator. The repository doubles as a Claude Code plugin marketplace, so installation goes through the plugin system.
A Claude Code plugin that converts static HTML — from Lovable, Bolt, v0, Claude artifacts, or hand-written pages — into an editable WordPress block theme that matches the original pixel for pixel. No page builder dependency, with WooCommerce support for shops.
An Android and Windows app bundling 5,403 skills and prompts across 102 AI tools in eight languages, all available offline. No account or network connection required.
A framework for assembling AI agents from existing pieces instead of starting from scratch, extended through plugins and able to turn a finished agent into a standalone app. Aimed at the build-and-ship gap rather than at prompting.
A registry and sync system for agent skills that pushes one published skill out to Claude Code, Codex, Cursor, Windsurf, and any MCP client. Removes the copy-paste-per-tool problem when the same skill needs to live in several runtimes.
A documented llama.cpp setup for Strix Halo hardware (Ryzen AI Max+ 395, 128 GB) including a memory budget, a registry of known defects, and a gateway that exposes the local models to Claude Code. Useful if you are trying to run large local models behind an agent on this platform.
A model-agnostic spec runtime that reads existing .kiro steering files and specs directly from any coding agent. No conversion step, no duplicated spec files, and no lock-in to a single host.
Six modules driven by a single YAML file — change the preset and you get a knowledge system for a different domain. Aimed at reusing one agent architecture across unrelated problem areas instead of rebuilding it each time.
A macOS overlay that shows a small traffic light per running Claude Code session — green when working, amber when it needs you, red on failure. Includes a chat window so you can answer a prompt without switching to the session's terminal.
An open-source desktop app that runs Claude Code, Codex CLI, opencode and Grok CLI side by side, each in its own isolated Git worktree so parallel runs never collide. Local-first, and covers document work alongside coding.
A single CLI that lets an AI agent search and read WeChat public accounts, Xiaohongshu, Douyin and Bilibili alongside Twitter, Reddit, HN and YouTube, all returning one JSON schema. WeChat search works zero-config, and installation is done by telling your agent to install it.
Visualizes a running Claude Code session as a live bubble map of agents so you can see the shape of the work as it happens. Doubles as a canvas for designing your harness — lay out the agent topology visually rather than in config files.
Monitors usage across multiple Claude accounts against a countable 5-hour-window budget, forecasts what's left for the rest of the week, and pushes notifications before you run dry. For heavy users who keep hitting limits mid-task.
A Claude Code and Codex plugin plus npm packages for building independent, map-first, mobile-first travel websites. The toolkit is designed to be driven by an agent rather than hand-wired, with core and React packages published separately.
Runs any coding agent inside a Docker sandbox that already contains your rules, skills and MCP servers, so a fresh container is immediately useful. Adds Git worktree isolation, editor attach over SSH, and a live code graph of the project.
Gives two AI coding agents a paired local mailbox to exchange messages when they have no other channel between them. Useful for coordinating agents running in separate terminals or repos without inventing a shared file protocol yourself.
Controls local Claude Code and Codex CLI sessions from Slack using private channels, with terminals that survive and resume across disconnects. Lets you check on or redirect a long-running session from your phone without a VPN into your dev box.
Runs coding agents inside Apple Virtualization framework VMs where network egress rules are enforced from outside the guest. Because enforcement lives on the host, the policy holds even against root with every capability inside the VM — a stronger guarantee than in-guest allowlists.
Runs and switches between many Claude Code, Codex, Gemini CLI and pi.dev sessions from a browser tab instead of a wall of terminals. Aimed at people whose agent count outgrew their tmux layout.
A mini-window that surfaces vocabulary flashcards and other panels automatically while your AI coding agent is working, filling the waiting gaps. An unusual take on the fact that agent sessions leave you idle in short unpredictable bursts.
Records a rolling buffer of your desktop with OCR'd clips, watches project folders for real diffs, and logs agent tool traffic — all on one timeline the assistant can query. It enforces a whole-scene read before answering narrow questions, so it can't cherry-pick a frame out of context.
Daily VM images for x86 and arm64 hosts carrying a ready Armbian development environment in ISO and qcow2 form, including Docker, the Armbian build framework, and a browser-based code-server IDE with the Claude Code plugin already set up. Notable as an official distro shipping an agent in its dev image.
A terminal UI that shows what Claude Code is doing, in which files, and why — without opening a second editor to find out. Stays in the terminal rather than pulling you into a separate dashboard app.
Summarizes what your Claude Code sessions were working on, and keeps answering after the underlying transcripts have been rotated away. Fills the gap where session history disappears exactly when you finally need to remember what you did.
Starts agent runs from a dashboard, from Cursor, Claude Code, Codex or VS Code, or from a script, executing each inside an isolated KVM microVM on hardware you control and streaming output back live. Cloud-sandbox ergonomics without handing your code to a third party.
A REST API that places real outbound phone calls to book, confirm or reach any business, shipped with a Claude Code plugin and a Codex AGENTS.md. Gives an agent a way to complete tasks that only exist behind a phone number.
Wraps the CLI coding agents you already run on macOS into an office metaphor — each agent gets persistent memory and a mailbox, and a routing agent assigns incoming work. Coordination layer over existing tools rather than a replacement for them.
Keeps notes, documents, research and images as plain files on your own machine while Claude files them, retrieves them, and assembles new documents out of them. Local-first, with no proprietary store between you and your data.
A desktop widget for claude-swap users that tracks quota and switches between Claude accounts quickly. Turkish-language interface, aimed at people juggling several subscriptions to avoid running dry.
Watches several running coding agents and pulls you back only at the two moments that matter — completion, or when one needs a decision. Built for keeping your attention on your own work while agents run in the background.
An OS-level security boundary and sandbox for Codex, Claude Code, Cursor and Aider that runs without a background daemon. Fewer moving parts than daemon-based sandboxes, which matters when the sandbox itself is the thing you're trusting.
A macOS control panel that manages Claude Code, Codex and OpenCode sessions from one local-first interface. Chinese-language project, distributed as releases rather than source.
A multi-project terminal grid where the file explorer follows whichever pane has focus, so context switches don't require re-navigating. Built with Tauri, React and xterm.js.
Open-source LLM observability focused on the waste axis — four deterministic detectors plus an LLM-as-judge produce a waste-rate metric, validated across three corpora and 16,864 sessions. Rare in that the metric comes with published verification rather than a claim.
A self-hosted panel giving each project one persistent tmux session you can reach from your phone — resume conversations, toggle remote control, open a browser terminal, publish ports. Zero-dependency Node with a single-file UI, reached over Tailscale rather than a public endpoint.
Local-first coordination for mixed human and agent work, tracking durable work items, decisions, dispatches and evidence alongside prompt-first methods. Built with TypeScript and Bun.
A board of sticky notes where each note becomes work Claude Code picks up, making the queue visible instead of buried in chat history. A lightweight alternative to prompting each task by hand.
Turns the MacBook notch into an interactive cockpit with media, calendar, shelf, focus, clipboard and on-device Apple Intelligence — including live tracking of Claude Code and Codex sessions. Free DMG, macOS 15+.
Converts a YouTube video into a Markdown document capturing both audio and visuals via the Gemini API, so an agent can read a video the way it reads a doc. Useful for feeding conference talks and tutorials into a coding session.
Collects Claude and Codex subscription usage on macOS and surfaces it in a Scriptable widget on iPhone. Uses unofficial endpoints and is macOS-only, offered without warranty.
A web console for many parallel coding-agent sessions with a clean split of concerns — tmux owns process lifetime, the browser owns naming, ordering and state. Sessions survive a closed tab.
Direct work across every coding agent you run, follow each session live, and take over at any point. Single control surface for people running several agents at once.
Collects what Claude Code generates and lays it out as a readable shareable page instead of scattered files. Japanese-language project aimed at the last-mile problem of showing your session's output to someone else.
Builds a disposable index on top of the verbatim transcripts already in ~/.claude/projects and layers pluggable memory strategies over it, entirely locally. Because the index is disposable, you can change strategy without losing anything.
A local-first desktop app that indexes session transcripts from Claude Code, Codex CLI, and Gemini CLI in one place. You can browse, search, and manage past sessions rather than digging through JSONL files by hand. Handy for recovering context or auditing what an agent actually did.
A multi-agent coding orchestrator where a Go daemon supervises several agent CLIs, each in its own isolated git worktree, and routes work between them. A Vue 3 cockpit gives you a live view of what every agent is doing. Aimed at running parallel agents without them stepping on each other.
A Next.js monorepo starter designed to be built by agents rather than just edited by them, with a spec-driven build harness and a hard verify gate that work must pass. It adds a context layer intended for multi-agent development. Useful as a template if you want structure enforced before agent output lands.
A launcher for running several Claude Code terminals at once, each pointed at a different provider or model. The status bar shows which account a session is on and how much quota is left, so parallel sessions stop being a guessing game. Documentation is in Chinese.
A code retrieval index built for coding agents that runs entirely locally with no network access and no runtime dependencies, covering 15 languages. Results are explainable, so you can see why a chunk was retrieved instead of trusting an opaque embedding score. Useful for large repos where grep is too blunt and cloud RAG is not an option.
A package-manager-style tool for AI agent skills: reproducible per-project installs, declared skill dependencies, and a security audit step before anything lands. Adapters cover Claude Code, Codex CLI, Cursor, and Gemini. Addresses the growing problem of skills being copy-pasted around with no versioning or provenance.
A local-first control surface that brings agent workspaces, git worktrees, terminals, diffs, and previews into one interface. It also supports paired-device access, so you can check on runs from another machine. Aimed at people juggling several concurrent agent sessions.
A dashboard for directing many Claude Code agents at once, showing at a glance who is actively working, who has a pending question, and who has been idle waiting on you. The waiting signal is the interesting part, since blocked agents are easy to lose track of. Aimed at running a studio of agents rather than one session.
Keeps one personal library of agent skills and live-syncs it into every local project by symlink, so edits propagate instead of drifting across copies. Works with both Claude Code skills and AGENTS.md conventions. Simple answer to the copy-paste sprawl problem.
An orchestrator that manages Claude, Codex, or other agents from a single dashboard while adding shared capabilities: memory search, code graph queries, and agent-to-agent messaging. Agents can also be moved between computers and locations. The code graph and messaging pieces are what set it apart from simple session managers.
Persistent session memory for coding agents that runs local-first with on-device inference, associative recall, and drift detection to catch when an agent wanders off the established context. Supports Claude Code, Cursor, and Codex. The drift detection is the differentiator versus plain fact storage.
Restores each Warp pane to its own Claude Code conversation after a terminal restart, instead of dumping you into a single shared or blank session. Panes reattach to the conversation they were running before, which matters if you keep several parallel agent sessions open across projects. Small quality-of-life fix for a specific but common multi-pane workflow.
Wires Claude Code's AI Migration Kit skills into the Omarchy desktop environment with a status bar widget and a cross-repo work queue. It also keeps a local GitHub mirror so menus render instantly instead of blocking on network calls. For Omarchy users running migration work across several repositories at once.
An open-source raster-to-vector tool built because existing options were paid, overkill, or needed heavy tweaking for simple logo work. The interesting part is the CLI surface: Claude can vectorize its own generated images in-loop instead of handing PNGs back to you for manual conversion. Straightforward utility for anyone spinning up side projects that need a quick logo.
A CLI that moves conversation histories and configuration files between different agent interfaces, so switching tools doesn't mean abandoning your context and settings. Handles the format differences between agent frontends rather than requiring a manual re-export. Useful if you rotate between Claude Code and other coding agents.
A build log covering three months of developing a browser 8-ball game into a full physics simulation with a hand-rolled engine and an SVG table drawn to official World Pool Association specifications. The writeup traces the failure modes along the way — balls sliding instead of rolling, unpocketable pockets — and where the fixes came from. Plans now extend to ranked matchmaking and a community platform.
An open-source CLI that puts Claude Code, Cursor, and Codex traffic behind a shared control plane offering Zero Trust governance, MCP support, and usage routing. The pitch is central policy and visibility across multiple coding agents rather than per-tool configuration. Relevant mainly to teams that need governance over who runs what.
Turns a Claude Code session into a self-contained document in HTML, plain text, LaTeX, or PDF. The distinguishing feature is a fidelity report that proves nothing was silently dropped during export — a real risk when transcripts contain tool calls and attachments. Good fit for archiving sessions or turning them into shareable writeups.
Pushes live Claude Code state to a BUSY Bar LED matrix — state ring animations, the active model and effort level, plus context and plan usage. Moves the status line off your screen and onto physical hardware, so you can tell at a glance whether a session is thinking or waiting. Niche by definition, but a tidy piece of hardware integration.
Adds hand-drawn input to Claude Code through a persistent canvas you can sketch and annotate on, either locally or from a tablet elsewhere on your network. Diagrams, layout ideas, and annotated screenshots reach the agent without a screenshot-and-paste round trip. The canvas persists, so drawings stay available across a session.
An AI-powered take on Inspect Element: visually pick a React component in the browser and ship it, with context, to your IDE's AI agent. Removes the step where you hunt down which file and component a rendered element came from. Practical for front-end work where the gap between what you see and where it lives is the slow part.
An observability tool for agent sessions that surfaces what your agents are actually working on and how the collaboration is going over time. Aimed at the gap between launching agents and knowing whether the time they spent was useful. Worth a look if you run multiple agents and only find out afterwards where they went wrong.
A Rust CLI plus shell integration that binds a Claude Code account to a directory, so the right account activates automatically when you cd into a project. Works on macOS, Linux and Windows. Useful if you juggle personal and work accounts and keep forgetting to switch before starting a session.
Gives Claude Code Codex-style computer use by driving Windows and macOS apps through the OS accessibility tree instead of screenshots, which the author claims is about 20x cheaper in tokens. Because it reads structure rather than pixels, you can keep using the same desktop while the agent works. A practical option for GUI automation that does not need a dedicated VM.
A Claude Code statusline that surfaces the active model and remaining context window directly in your terminal prompt. Small quality-of-life tool for anyone who wants to see how close they are to compaction without checking manually. Documentation is in Spanish.
Generates a design system that coding agents can then build against, so UI work stays visually consistent across sessions. Targets the common failure mode where an agent produces functional but stylistically incoherent interfaces. Relevant to anyone who has shipped a Claude Code app that works but looks assembled from unrelated parts.
Scans local Claude Code logs for credentials that leaked in through transcripts and command output, then scrubs them when you pass --yes. Scanning is the default so nothing is destroyed accidentally, and it emits a rotation manifest listing what needs to be rotated. Addresses a real and underappreciated exposure: secrets sitting in plaintext session history on disk.
A zero-dependency SQLite memory layer for AI agents with a built-in experiment loop: observed patterns are tested and graduate to proven preferences only once they demonstrably work. This is a step beyond memory files that just accumulate assertions nobody validates. Attractive if you want agent memory that self-corrects rather than calcifies.
Traces where your personal data is being sold, then generates erasure requests, AI-training objections and regulator complaints under GDPR, LGPD and CCPA. Runs local-first and is driven by Claude Code rather than a hosted service. A concrete example of pointing an agent at bureaucratic paperwork that is tedious rather than hard.
An Among Us style social-deduction simulation where LLM agents play the roles, deceiving and deducing against each other. The author built it by directing AI coding agents against written contracts rather than ad-hoc prompting, which makes the process as interesting as the game. Worth a look if you are experimenting with contract-driven agent development.
A local control room for Claude Code tasks, scoped per workspace so runs from different projects stay separated. Gives you one place to see and manage what agents are doing instead of tracking scattered terminal sessions. Useful once you routinely run more than one Claude Code session at a time.
Runs deterministic scenarios to compare Claude Code releases, CLAUDE.md configurations, hooks and plugins, so you can bisect which change caused a behavior regression. Turns "it felt better last week" into something measurable. Genuinely novel: almost nobody is doing controlled A/B testing on their agent configuration.
Controls the iOS Simulator from Claude Code with a focus on token efficiency, combining agent-device conventions, a simprobe CLI for pixel-level ground truth, and a load-aware benchmark. Lets an agent verify what actually rendered rather than assuming its code worked. Valuable for iOS developers running agent-driven UI work.
Codebay gives each agent task its own Docker container instead of a git worktree, so every task gets a real dev environment with databases and caches that cannot interfere with the others. It runs the actual Claude Code CLI rather than the Agent SDK, so it stays current with CC features, and a central admin panel previews each container's services. Open source, self-hostable, and can run on a remote server so tasks continue while your laptop is off.
A local usage dashboard for Claude Code that reports token counts, estimated cost, cache efficiency, budgets, per-project breakdowns, and live sessions. Everything stays on your machine — no telemetry is sent anywhere. Useful if you want to see where your context and quota actually go without handing usage data to a third party.
A Checkov-style static analyzer aimed at agent configuration rather than infrastructure. It scans settings, permissions, hooks, MCP server definitions, subagents, skills, slash commands, and CLAUDE.md for risky patterns. A practical way to audit a repo's .claude/ setup before trusting it, especially with third-party plugins and marketplaces.
A single wrapper that launches coding agents — Claude Code, opencode, Grok and others — inside a bubblewrap sandbox on Linux. The agent gets a confined filesystem and process view instead of your whole machine. Handy if you want to hand an agent broad autonomy without giving it broad access.
A terminal UI that renders your Claude Code session history as a tree, showing where sessions forked rather than as a flat list. Makes it much easier to find the branch of a conversation where things were still going well. Useful for anyone who rewinds and resumes sessions often.
A single launcher and session surface for multiple coding agents, covering Claude Code, Codex, Pi, and managed backends. Rather than juggling separate terminals and conventions per tool, you get one place to start and return to sessions. Aimed at people who run more than one agent day to day.
Captures agent sessions as Obsidian notes so past work becomes searchable, linkable memory rather than buried JSONL. Recall is designed to be instant and feel native to the vault. Works across Claude Code, Cursor, Codex, Antigravity, and OpenCode, so memory is not locked to one tool.
Puts goals and subgoals on a single live board so the original objective survives a conversation that drifts. Subtasks are visible at a glance, and the agent's claims of completion are verified against what is actually on disk. Targets the failure mode where an agent reports done for work it did not finish.
An open-source gateway sitting in front of Codex and Claude Code that applies policy, routes between models, redacts sensitive content, and records usage and cost evidence. Aimed at teams that need an auditable record of what agents sent and spent. Self-hosted rather than a managed proxy.
A macOS-only single page that answers one question: which of your Claude Code projects is currently waiting on your input? Deliberately narrow rather than a general metrics dashboard. Handy when you run several sessions in parallel and lose track of which one has stalled on a prompt.
An open-source macOS and Linux browser that lets Claude Code, Codex, or any MCP agent act inside your already-logged-in accounts, without exposing cookies, passwords, or your profile to the agent. Access is off by default, granted per tab, killable instantly, and written to a hash-chained audit log. A far more careful design than handing an agent your whole browser profile.
A desktop app for the tedious half of frontend work with an agent: spotting ten small layout problems is easy, describing each one back to Claude is not. You hit record, walk through your app, and say what looks wrong; it captures screen, cursor, and voice, then matches each spoken comment to the right moment and screenshot. Output is a review.md plus screenshots you drag into Claude Code and tell it to fix.
A universal router that sits between your coding tool and model providers, trying free tiers first and falling back up a chain, with claimed cost cuts of 35 to 80 percent. Supports Claude Code, Cursor, Codex, Gemini CLI, and Copilot. Savings depend heavily on your workload mix, so verify against your own usage before relying on the numbers.
Runs scheduled digests locally that read your own files, have an LLM write them up, and send from your own inbox. The design is explicitly deterministic rather than autonomous — the schedule and the sources are fixed, and the model only writes. A good pattern for recurring reports without handing an agent open-ended email access.
A wrapper over GNU screen that lists Claude Code sessions by their actual subject, with previews, instead of by opaque session IDs. You can browse and attach from SSH or a phone. Solves the specific pain of reconnecting to the right long-running session on a remote box.
Claude Code already writes every session to disk as JSONL under ~/.claude/projects/, one per session plus one per subagent. roundtable turns those into a timeline player you can scrub to any second to see which agent was running and what it had read or edited. MIT, runs entirely locally via npm start.
Claude Command Center is a dashboard for running 30+ parallel Claude Code and Codex sessions. This release adds a manual "Attach as sub-session of..." row action so related sessions with no real spawn lineage still render nested, plus Devin CLI model/effort display in the board.
A browser tool for configuring a Claude Code status line visually. Rather than exporting a finished script it hands you the prompt to paste into Claude Code, which keeps the output adaptable to your setup. Built after the author's status line config drew interest as a comment.
A designer who does not write code shipped a 300-level React Native/Expo puzzle game on iOS and Android with Claude Code writing all the code. The interesting half is the verification pipeline: a solver proves the minimum move count behind every 3-star target, and each "mechanic required" badge in the HUD is solver-verified.
A harness that puts coding agents inside a sandbox so their file and command access is bounded rather than pointed at your real working tree. Relevant if you run unattended sessions and would rather not trust every tool call.
A verification tool for the moment an agent declares a task complete — it looks for evidence in the change rather than taking the claim at face value. Fits into the PR stage of an agent-driven workflow.
Live quota monitoring inside Herdr showing usage, reset times, and task context, with quota health calculated from remaining quota against your runway rather than raw percentage. Useful if you routinely burn through plan limits mid-task.
A local proxy that routes Claude Code to OpenCode Go/Zen, NVIDIA, or custom backends, selecting the provider by URL path. Supports per-provider profiles and fallback chains, so a failed backend hands off rather than killing the session.
A CLI-only Docker workspace running Claude Code, Copilot, Codex, Gemini, and Kiro as a non-root user behind a deny-by-default outbound firewall. Everything the agent reaches out to has to be allowed explicitly.
Fixes connected-letter shaping, right-to-left ordering, and mixed Arabic/English lines when running Claude Code inside VS Code. A real accessibility gap for Arabic-speaking users, since terminal rendering usually mangles this.
A viewer for Claude Code sessions, letting you read back what happened in a run rather than scrolling terminal scrollback. Small and focused.
Ingests Claude Code OTLP telemetry into SQLite and serves a per-person dashboard, so a team can see usage without sending data to a third party. Independent project, not affiliated with Anthropic.
The AgentMon CLI watches local AI coding-agent logs and forwards cost-enriched OpenTelemetry traces to an AgentMon server. This repo carries the prebuilt release binaries.
A substrate where one manifest declares an agent, its verbs, and the screens it presents — so an agent package arrives with its interface rather than depending on a host to build one.
Automated checks and quality gates wrapped around your agents, so work has to clear defined criteria rather than whatever the agent decides is done.
A browser-based team workspace where multiple people share Claude Code and Codex agents that carry memory between sessions. Self-hosted, so the conversation history and memory stay on your infrastructure.
A single dependency-free Python file that surfaces the live state of every coding-agent session running locally. Minimal enough to drop into any machine without a install story.
A Claude Code plugin running a full 3D asset pipeline — Blender MCP, Hunyuan3D generation, texturing, and batch mode — from a written brief to a production-ready GLB.
A small Go proxy presenting GitHub Copilot behind an Anthropic-compatible interface, so tools that speak the Claude API can run against a Copilot subscription.
A native desktop app built on GPUI for running coding agents side by side. Cross-platform, aimed at people juggling several agent sessions at once.
Covers the GA4 Data and Admin APIs plus live-site profiling, with vertical-aware benchmarks and markdown audit output. Works from Claude Code, Codex, or Gemini CLI.
Point it at a folder containing a video and a markdown file and it distributes to YouTube, TikTok, Instagram, X, LinkedIn, and Bluesky. The folder-as-interface design keeps it scriptable from an agent.
A zero-token verbatim check paired with a burden-of-proof judge, so citations must match source text rather than merely sound plausible. Framework-agnostic.
Every number you publish is a claim. This ties each figure in your README to the artifact it came from and fails the build when the two drift apart. No LLM, no API key, no dependencies.
Deterministic integrity checks run against real SDKs, with the scenarios distilled from actual incidents in a production agent fleet. For testing how a runtime behaves when things break rather than when they work.
A portable local-server UI layered over the gh and claude CLIs, giving you a web view for walking a pull request file by file with AI help. Runs locally, no hosted service.
Batch gene scanning, tumor cohort briefing, and target discovery with structured outputs, resume support, and pipeline-ready artifacts. Resume matters here because these runs are long enough to fail midway.
Installs Ghostty, tmux, Neovim with LazyVim, zsh, and Claude Code together, wired for inline images, mermaid diagrams, and fuzzy finding in the terminal. One command for the whole stack.
Stops the session at a usage percentage you set and waits for you to decide, instead of letting a long run consume the rest of your quota unnoticed. Small, targeted, and useful on a metered plan.
Three guards for agents running without supervision — a dead man's switch for hangs, a hard cost cap, and an outcome check on what the run actually produced. Works with Claude Code, OpenClaw, n8n, and cron jobs.
A dashboard showing every task you have handed to Claude Code, aggregated across repositories, so parallel work in different projects stays visible in one place.
A marketing-site template plus a WordPress-to-Astro migration playbook, and — the valuable part — 46 silent failures catalogued from real rebuilds, the kind that pass a build and break in production.
Organizes a session around action, background, and term tables surfaced in a live NiceGUI dashboard, so the shared state between you and the agent is explicit rather than buried in chat scrollback.
An agent that reads your GitHub profile and generates a portfolio website from it, built on LangGraph with Claude doing the writing and structuring.
Framework-agnostic graph memory that stores relationships between project facts rather than flat notes, kept small enough to drop into an existing setup.
Maintains a single source of truth for agent configuration and projects it into each tool's native format, so you stop hand-syncing CLAUDE.md, AGENTS.md, and cursor rules.
A web chat for analyzing sporting events built directly on Claude Code — MCP, skills, plugins, and slash commands — rather than a plain API wrapper. Russian-language. An example of Claude Code as an application runtime.
A local command center for driving coding agents, built for throughput and deliberately opinionated about the workflow rather than configurable to death. From Colin McDonnell, author of Zod.
Distinguishes a genuine fix from one that satisfies the test without solving the problem. Zero dependencies and no LLM in the loop, so the verdict is deterministic.
Bridges the gap where DSH can delegate to Claude Code but shows nothing until the child process returns. This keeps DSH as the driving agent and renders Claude Code's tool calls, file reads, and commentary as live sub-rows in the session UI. Works on the released rc.2 harness, unlike the existing background-agents approach that needs an unreleased core.
A dashboard over all your Claude Code projects showing git state and staleness at a glance, with one-click `claude -c` resume for any of them. Solves the problem of forgetting which repo had an unfinished session. Lightweight alternative to keeping a dozen terminal tabs open.
A structured Markdown wiki in `.mex/` holding architecture, conventions, decisions, patterns, and project state so agents stop relearning the codebase each session. The author's follow-up insight is that storing memory is the easy half — the hard part is staleness detection when files move, dependencies change, or two context files start contradicting each other. Adds validation for exactly that.
A tiny local-only menu bar app that shows your Claude Code token consumption inflating in real time. No network calls, no telemetry — it reads local session data. For people who want a constant ambient reading rather than opening a dashboard.
Generates a daily summary of what you actually did by combining your Claude Code session transcripts with your git commits. Useful for standups, timesheets, or reconstructing a week you can no longer remember. Reads local data only.
Renders where the tokens in an agent's context window actually went as a flamegraph — system prompt, tool definitions, file reads, tool results, conversation. The flamegraph framing makes the dominant consumers obvious at a glance instead of requiring a token-count spreadsheet. Direct diagnostic for context bloat.
Breaks down local session logs into context growth over time, cost per turn bucketed by context size, cache-write split, and machine-readable limit reset times. The cost-by-context-bucket view is the useful one — it shows how much you pay for letting context grow rather than just a total. No network, no dependencies.
A headless toolkit that indexes an Obsidian vault into SQLite and exposes backlinks plus Dataview and Bases queries, so agents can work the vault on a 24/7 server without the desktop app. Turns a personal knowledge base into something an automated agent can query and update. Good fit for always-on note pipelines.
A deterministic durability layer for coding agents built from three pieces: 2ms write-ahead-log crash recovery, source-span AST node splicing instead of text patching, and proof verification gates before changes land. Aims to make long autonomous runs survivable rather than restarting from scratch after a crash. Ambitious and low-level.
A supervisor for long-running agent CLIs — Claude Code, aider, or anything taking a prompt argument — with 11 layers of failure defenses and structured observability so you can see why a run died. Targets unattended operation where a crash at 3am otherwise means eight lost hours. Agent-agnostic by design.
Scans all repos in a workspace for anything pending a decision — uncommitted changes, unpushed commits, stashes, parked feature branches — then cross-references project docs for planned roadmap items and renders it as a self-contained HTML infographic with branch graphs and dirty-tree meters. Answers 'what did I leave half-finished everywhere' in one artifact.
Accounts for every byte in the Claude Code, Codex, and opencode data folders and attributes it back to the project that generated it. Read-only with zero setup. Useful when agent session data has quietly grown into tens of gigabytes and you need to know what is safe to delete.
An orchestration layer that runs a coordinated team of agents through plan, build, and ship phases rather than driving a single agent through everything. Role separation is the organizing idea. Early-stage but a clear expression of the multi-agent-team pattern.
A Claude Code plugin where the agent operates a Windows application and captures the session as a demo video, zooming in before each click so the recording is actually watchable. Produces documentation-grade footage without a human doing takes. Neat use of computer control for artifact generation rather than testing.
A minimal wrapper that manages multiple Claude Code sessions across tmux panes from a single hub, deliberately delegating listing and inter-session messaging to Claude Code's own built-ins rather than reimplementing them. The restraint is the design point — it adds only the tmux layer. Japanese documentation.
Wraps the AgentsKit code-review agent in both a local CLI and a GitHub Action, tuned for signal over volume — the stated goal is depth without the wall of nitpicks that makes automated review get ignored. Same agent runs in CI and on your machine. Worth comparing against the built-in review workflows.
A memory architecture that evolves both experiential memory (what has been learned across runs) and working memory (what matters now) recursively, aimed at harnesses running tasks far beyond a single context window. Research-flavored rather than a drop-in plugin. Relevant if you are designing your own long-horizon agent loop.
Shows which of your Codex, Claude Code, OpenCode, and Pi sessions are running and, more usefully, which are waiting on you — surfaced directly in the Omarchy status bar. Attention status is the differentiator over plain process listing. For Omarchy and Hyprland users running several agents at once.
A proxy that sits in front of Claude Code and routes its requests to several upstream providers — OpenCode Go, OpenCode Zen, and AWS Bedrock. It handles model selection automatically and transforms between the providers' request/response formats. Useful if you want to spread load or fall back across backends without changing how you invoke Claude Code.
An open-source pixel-art pet that reflects the state of your Claude Code sessions — a lightweight ambient status indicator instead of a dashboard. The author released it to the community looking for contributions and ideas. A playful take on the growing category of session-monitoring tools.
A Windows desktop app built with Tauri that puts animated pets on your desktop tied to the live status of your Claude Code or Codex CLI agents. The pet reacts as work progresses and alerts you the moment a task finishes. Solves the "did it finish yet?" problem without keeping a terminal in view.
A desktop hub that hosts multiple AI coding CLIs — Claude Code, Codex, Gemini, OpenCode, and arbitrary commands — inside a single window. Instead of juggling terminal tabs per agent, you get one surface to launch and switch between them. Handy when comparing agents on the same task or running several in parallel.
A viewer and smart editor aimed specifically at the Markdown that Claude, ChatGPT, and Cursor produce — long plans, specs, and reports. It renders live as the file changes and provides editing affordances suited to agent output. Useful if you accumulate a lot of generated Markdown you actually need to read.
A focused desktop app for managing which model provider your AI coding tools talk to, and routing requests between them. It centralizes provider credentials and switching rather than editing config per tool. Aimed at people running several coding agents against several backends.
A short browser game, built with Claude Code, designed to teach non-developers how to phrase instructions to AI agents without ambiguity. Each level puts the player in a situation where a sloppy prompt gets misinterpreted, making the failure mode concrete. Free to play with the source published on GitHub.
Reads Claude Code session logs and renders them as live Markdown so you can follow a running session in readable form. It has zero external dependencies. Useful for watching long unattended sessions or reviewing what happened after the fact.
A live instant-messenger network in which AI agents talk to and help each other while humans can only spectate — an intentional revival of the AOL Instant Messenger aesthetic, SmarterChild included. More of an experiment in agent-to-agent interaction than a productivity tool. Running publicly at aiim.broke2builtai.com.
An agent-first CLI that converts a lecture video into structured Markdown — one section per screen, each carrying the frames and the slice of transcript that belong to it. The output is designed to be fed to an agent as grounded context rather than read by a human. Fills a real gap for anyone whose source material is video.
A tmux sidebar that lists your Claude Code sessions grouped by git worktree, shows live status for each, and lets you click to jump straight to one. Keeps orientation across many parallel sessions without leaving the terminal. Fits naturally into an existing tmux-based workflow.
A local code intelligence and context engine for Codex and Claude Code, backed by an embedded SonnetDB. It indexes your repository so the agent retrieves relevant context instead of reading broadly. Everything stays on your machine.
An open-source cloud platform for agent-built applications: you do not choose a database, a region, or a RAM slider — your coding agent and Bay decide together, then keep the app running and scaling. Aimed at closing the gap between "the agent wrote it" and "it is live." MIT-spirited infrastructure for agent-first development.
Layers themes, plugins, and productivity tools on top of the Claude desktop app without modifying Anthropic's code or touching your login. The BetterDiscord model applied to Claude — client-side augmentation with a plugin ecosystem. Appeals to anyone who wants the app customized but does not want to fork it.
Keeps your AI coding configuration consistent across Claude Code, Cursor, and other tools — rules, skills, agents, and MCP server definitions in one source of truth. Removes the drift that builds up when the same setup is maintained per tool. Straightforward and broadly applicable.
Translates Claude Code's activity into plain status: how long a background process has actually been running, and an alert when something fails instead of silently stalling. It lives inside the session rather than watching from outside. Aimed at the visibility gap during long background work.
Lets you run several Claude Code and Codex accounts at once — in parallel, hot-switched, or auto-routed — with one slot per account and no copying of credentials between sessions. Supports macOS and Linux. Useful when you legitimately hold separate personal and work accounts.
Built for the moment Claude finishes a task and mentions three other things it noticed while you are already halfway into the diff. The plugin lets you drop a note anchored to that exact turn without leaving the session, so the observation is not lost. Implemented as a plugin for an agent IDE.
Tracks Claude Code usage against your weekly limits and paces you automatically, switching to an eco mode when you are burning through quota too fast. Rather than just reporting usage, it acts on it. Aimed at the recurring problem of hitting the weekly wall mid-project.
A set of customisations for CloudCLI, the Claude Code web UI, plus a launcher that re-applies them to the installed package on every start so upgrades do not wipe them. Adds a LiteLLM spend tab. The re-apply-on-launch trick is a practical answer to patching a package you do not control.
A provider-neutral reference implementation for moving coding-agent session history between tools, with a working Claude Code importer and an RFC for Antigravity integration. Treats session history as a portable format rather than a per-vendor lock-in. Worth watching if you switch harnesses and lose your history each time.
A Waybar widget showing Claude Code session, weekly, per-model, and extra-usage spending with progress bars, countdowns, and pacing hints. Handles OAuth refresh itself and supports Omarchy theming. Pure Bash with an AUR package, so no runtime to install.
Interviews you about what you actually do, builds a knowledge base from it, scores roles against your own stated values, and writes a bespoke CV for each application. The interview step is what makes the generated material specific rather than generic. A well-scoped example of an agent owning a long-running personal process.
Maintains one central definition of your coding agent configurations, skills, and instructions and syncs it out to the tools that need it. Removes per-machine and per-tool drift in your setup. Sits in the same space as other config-sync tools but with its own approach.
The author wrote a command-line client for Ultima Online and gave Claude open-ended prompts like "explore this world" and "make friends and sing them songs." Failures — such as not working out how to get resurrected by a healer — were fixed by writing better skill instructions rather than more code. A genuinely interesting demonstration of skills as in-world procedural knowledge.
Tracks token usage and quota windows across every local AI CLI and IDE tool from within the Hermes desktop app. It self-extends through provider adapters, so covering a new tool means adding an adapter rather than patching the core. Useful if your usage is spread across more than one vendor.
Renders Claude's long answers in a browser where you can comment on any individual block, and Claude rewrites just that block in place. Avoids the usual cycle of quoting a paragraph back and asking for a revision. A better interaction model for iterating on long generated documents.
A Claude Code statusline plus a live animated can in the terminal and a floating macOS overlay, where the Diet Coke level falls as you consume your usage limits. An unofficial CLI port of the Diet Claude browser extension. Pure whimsy, but a surprisingly legible way to feel quota depletion.
A browser that generates its own extensions on demand instead of requiring you to find or build one. The premise is that a missing browser capability should be a prompt away rather than a project. Early and unusual, but a genuinely different take on agent-driven tooling.
Adds a supervisory layer over agent sessions that would otherwise run unwatched. It monitors what sessions are doing and intervenes rather than only reporting after the fact. Part of the emerging pattern of treating long agent runs as processes that need oversight.
A statusline showing cost, context percentage, rate limits, git branch, active MCP servers, and system health, with no dependencies to install. Combines the usual usage metrics with MCP and machine state in one line. Easy to adopt precisely because there is nothing to set up.
Tracks what each of your coding agents changed and lets you query it all from one place, functioning as a version-control layer scoped to agent activity rather than commits. Useful when several agents touch the same repository and attribution gets murky. Answers "which agent did this, and when."
Stands up a xats cross-agent-bus peer — daemon, service registration, Claude Code and opencode hooks, and the bridge — with a single command on Windows, macOS, or Linux. Removes the multi-step setup that usually blocks people from trying agent-bus architectures. Installation tooling rather than the bus itself.
A low-latency terminal overlay written in Rust that adds local Whisper speech-to-text over a PTY passthrough, with wake words, macros, memory tools, and a customizable HUD. Transcription runs locally, so nothing is shipped to a speech API. One of the more serious attempts at voice-driven agent coding.
A shared memory file that every AI tool you use can read, where models may only propose entries and nothing is written until you approve it. The proposal-plus-approval gate is the whole design — it prevents memory from filling with things the model merely assumed. Chinese-language project with a broadly applicable idea.
An open-source viewer that gathers Claude Code sessions scattered across projects and directories into a single browsable list. Built out of the recurring annoyance of hunting for an old session by directory. Published for others to use and contribute to.
A leaderboard ranking AI coding tool users by how thoroughly they have exhausted their rate limits, joinable with a single npx command. Pure community fun rather than a productivity tool. Also a light window into how much other people are actually consuming.
Imports your existing local Codex and Claude session history into the DeepSeek Harness so a switch does not start from an empty slate. Practical migration tooling for anyone moving between harnesses. Narrow in scope but does the one thing that makes switching tolerable.
An open-source secrets manager that treats AI agents as first-class consumers alongside human team members. Agents get scoped access to credentials without secrets landing in a repo or a prompt. Increasingly necessary as agents run more real infrastructure work.
Cleans out the accumulated debris from Kiro CLI and Claude Code sessions — stale artifacts, abandoned scratch files, and leftover session state. Reclaims disk and reduces the noise an agent has to read past next time. Small maintenance utility for heavy session users.
A plugin marketplace entry that runs a job search end to end: application tracking, job board and career-page scans, Gmail reply tracking, LinkedIn matching, and interview prep. The Gmail integration means it notices replies instead of relying on you to log them. Genuinely long-running personal automation rather than a one-shot tool.
A web command panel for driving coding agents and real terminal workflows from anywhere, so you are not tied to the machine running them. Combines agent orchestration with genuine terminal access in one surface. Useful for kicking off or checking on work from a phone or another computer.
Builds a map of all your agent instruction files — AGENTS.md, CLAUDE.md, Copilot instructions, agent skills, and their imports — and lints them, with zero dependencies. Surfaces contradictions and dead imports across files that individually look fine. Increasingly necessary once instructions are layered at multiple directory levels.
Stores the "why" behind code alongside it without putting it in the file, so both agents and people can read the reasoning without the source accumulating comment cruft. Annotations live out of band and travel with the repository. A neat answer to context that matters but does not belong in the code.
An open build of Claude Code that cryptographically signs every tool call and records it on a transparency log, giving verifiable proof of what the agent actually did. Runs on both Bun and Node.js. Relevant wherever an agent's actions have to be provable after the fact rather than merely logged.
Inventories a TypeScript codebase and reports references, duplicated code, and agent-generated slop, entirely offline with no API calls. Aimed at codebases that have grown quickly under agent authorship and accumulated redundancy. Fast to run because nothing leaves your machine.
A single Rust binary that reads local agent logs and reports token usage in real time, with a live dashboard and budget alerts. Claims roughly 50x faster report generation than comparable tools and covers Claude Code, Codex, and more than fifteen other agents. Useful if you juggle several coding agents and want one place to watch spend.
A local-only companion that gives Claude persistent memory with evidence grading and drift detection, plus per-project attention analytics on a localhost dashboard. It also dispatches an agent fleet you can watch and includes Casper, a desktop companion that answers out loud with on-device speech recognition. Everything runs on your machine and voice data never leaves it.
Bridges OpenClaw to locally running Codex and Claude Code sessions through shared tmux terminals. Because the terminal is shared rather than owned, you can take over a session by hand mid-run and hand it back to the agent. Aimed at people who want remote control of local agents without giving up direct access.
Collaborative markdown documents that both people and agents can edit in the same room, structured so agents can read and write without stepping on human edits. Turns a shared doc into the coordination surface instead of a chat log. Fits planning, spec drafting, and any work where several agents and a human need one live artifact.
Points the Claude Code CLI at a folder of local Git repositories and produces an audit across all of them. Useful for taking stock of a machine full of side projects — what is stale, what is undocumented, what needs attention. Runs entirely locally against your existing checkouts.
Sends a buzz to your Wear OS watch the moment a Claude Code task completes, with no companion phone app required. Fills the gap left by the many macOS and Windows desktop notifiers for people who step away from the desk. Small, single-purpose tool.
A benchmark suite for agentic CLI models covering instruction-following, algorithms, browser work, spatial reasoning and exact arithmetic. Its distinguishing axis is resistance to fabrication, which most coding benchmarks do not measure. Useful if you are picking between CLI agents on evidence rather than vibes.
Analyzes Claude Code session logs to report cost, then breaks out how much of the bill came from the agent re-reading files it had already read. The re-read split is the interesting part — it turns a vague sense of context waste into a number you can act on by restructuring prompts or CLAUDE.md.
Watches the edits you make to AI-written code and distills them into repo-specific coding conventions the agent then follows. Harness-agnostic across Claude Code, Codex and Cursor, with zero dependencies. The premise is that your corrections are a better convention source than a hand-written style doc.
A single app covering manga, comics, books, audiobooks, TV, movies and anime plus a Kodi-style local library, built as a desktop-environment shell with a taskbar. The author built it using custom Claude Code skills remixed from Superpowers for brainstorming, planning and execution, including animated QML wallpapers.
A memory tool that started as a fix for copy-pasting context between sessions and grew to cover Claude Code, OpenCode, Gemini CLI, Codex, Antigravity and Cursor behind an MCP layer. Beyond chat it carries changed files, diffs and commits, and syncs across devices so asking Codex what Claude did last week works.
Runs many Claude Code sessions across many repos and puts them on one screen: dispatch work, watch what ships and act on what is blocked. Aimed at the point where parallel agent sessions outgrow tab-switching between terminals.
A Claude Code plugin marketplace bundling 14 plugins across development, project management and automation, installable with one command. A convenience entry point if you would rather adopt a curated set than assemble plugins individually.
An NVIDIA-published scanner that inspects Claude Code, Codex and MCP skills before you install them, flagging vulnerabilities, malicious patterns, prompt injection, data exfiltration and supply-chain risk. The most credible answer yet to the problem that installing a skill means running someone else's instructions.
An orchestration layer for locally-run LLM agents offering durable sessions, profiles, scheduling and native MCP, tool and skill integration. Deliberately thin — it coordinates agents rather than trying to be a framework.
A Kubernetes operator where alerts, schedules, cluster events and chat messages each start a Conversation running in an isolated agent pod that replies in a thread you can respond to. Self-hosted, and what an agent may touch is defined by the wiring rather than by the agent's own judgment.
A retrospective on building a full poker training site — rules engine, cash games, 10,000-entrant tournaments resolving in six seconds, three bot tiers, ~2,300 tests — where Claude wrote all the code. The valuable half is the explicit account of what the AI could not supply, starting with knowing what a poker player actually looks like.
The fifth weekly devlog of an MMO built largely with AI coding agents, covering player acquisition, gameplay updates and lessons about vibe coding. This week's change came from player feedback that the intro was a wall of text with no context, so the onboarding was rebuilt.
Runs architecture-level code review across Claude Code, Codex, Cursor, Gemini CLI and 100+ other agents, returning a single verdict where each blocker is proven by actually running the code. The run-it-to-prove-it rule is what separates this from a model asserting a design smell.
A stdlib-only Python CLI that convenes Claude Code, Codex, Antigravity, OpenRouter, DeepSeek, Groq, local models and Aider as a jury on a pull request — they debate, verify, and synthesize a single verdict. Local-first and secure by default, with no dependencies to vet.
Reads the logs your coding agents already write and answers what actually ran: what was touched, what activity occurred and what it cost. Local, read-only and dependency-free, so it can be pointed at existing history without instrumenting anything first.
Builds polished product demo videos with AI coding agents and Remotion, rendering the UI as code instead of capturing a screen recording. That makes the demo re-renderable when the product changes, and lets an agent update it like any other source file.
A bridge that lets the Hermes Agent drive Claude Code on your Mac through the native Claude Agent SDK, so Claude Code sessions become steps in a larger Hermes-managed workflow rather than something you start by hand.
A self-hosted personal intelligence magazine where external AI agents research the targets you are watching over MCP and file the resulting articles. An interesting inversion of the usual chat interface — the agents publish to you on a schedule rather than waiting to be asked.
A browser-based cockpit for local AI coding agents — Claude Code, Codex, Grok, Pi and OpenCode — with persistent sessions, streaming output and remote access. Lets you leave a session running on a workstation and check on it from elsewhere.
A bash installer that deploys Akita's ai-memory onto an Ubuntu VPS with a Cloudflare Tunnel and basic hardening, giving agents a centralized long-term memory store. Portuguese-language documentation.
A self-hosted agent-to-agent protocol platform letting AI agents negotiate with each other for their owners, using DID:web identities and RFC 9421 HTTP message signatures. Ships a Claude Code plugin as one of its clients.
Converts a recorded AI coding session into an animated, interactive replay you can view in a browser. Useful for reviewing what an agent actually did, sharing sessions with teammates, or producing demos of an agent run.
A desktop canvas that launches several AI coding agents as real OS processes and lets you wire them together by drawing connections. Connected agents discover each other and share tasks and memory, giving a visual way to compose multi-agent work.
Watches processes, file access, and network activity on the local machine and attributes each event back to the specific agent instance that caused it. Gives you an audit trail of what an autonomous coding agent actually touched outside the transcript.
Captures logs and telemetry from running agents and writes them to flat files with a searchable index. The archive is meant to be read back by agents themselves, so a later session can look up how a past problem was solved.
A Python CLI that scans an existing site, generates evidence-backed pages for search and AI-answer visibility, and enforces hard quality gates before publishing. Each generated page carries provenance receipts so claims can be traced. MIT licensed.
An open-source Android SSH terminal built for driving coding agents from a phone: full IME and Unicode input, tmux-backed reconnection, multi-window and split-screen, and lock-screen approval prompts for Claude Code and Codex.
A plugin that exposes OpenCode as a subagent to Claude Code, so you can hand work to a second, independent model. Intended for cross-model code review, adversarial feedback on your own agent's output, and delegated background tasks.
An idle engine for agents that keep running between tasks: rather than scripted busy-work, behaviour emerges from the agent reasoning about its own idle state. A cheap model-free safety layer gates what the idle reasoning is allowed to act on.
A Rust proxy that routes requests across LLM providers and translates between their API formats, in the same vein as ccrouter. Useful for pointing Claude Code at alternative backends without changing the client.
A statusline for Claude Code showing live quota, reset countdowns, context window usage, active model, cost, and recent git activity. Aimed at knowing whether a long session will survive before you start it.
A Claude Code plugin that pulls someone else's GitHub PR and reviews it using Codex instead of Claude, giving a second-model opinion. Handy when you want review feedback that isn't from the same model that wrote the code.
An Emacs package giving Claude Code a real IDE integration rather than a bare terminal, including management of multiple concurrent sessions. For Emacs users who don't want to leave the editor to drive an agent.
Paste a single line and it installs the tooling, writes the agent instructions, opens a starter project, then drops you into Claude Code or Codex. Cross-platform across macOS, Linux, and Windows.
Covers your Mac screen with a hotkey while background AI agents keep working, unlocking with Touch ID. Includes a dog/cat mascot and native Settings, aimed at stepping away from a shared desk mid-run.
Brings a Claude Code style autonomous loop to OpenCode: a background goal engine that drives subagents, plus a modal TUI dashboard for watching the run. Inspired by Codex's background execution model.
Manages Claude Code sessions while automatically recording what each one did and which artifacts it produced. Gives you a durable record of a session without asking the agent to write a handoff note.
An AI profile manager that injects environment variables so each terminal session can use a different API configuration for claude or codex. Lets you run several accounts or endpoints side by side without editing config files.
A model relay you administer through a Telegram bot, speaking the Anthropic, OpenAI Chat/Responses, and Grok protocols. Supports OAuth login and plugging in third-party endpoints.
Drives Webflow development from Claude Code with explicit hand-routing and hooks that guard the publish step so an agent can't push live by accident. Includes a field manual of actual Webflow MCP behaviour, verified rather than inferred from docs.
Puts tmux-backed terminals and parallel agent sessions on an infinite pan/zoom canvas as draggable nodes, so a fleet of sessions is spatially arranged rather than tab-hopped. Runs on macOS and Linux, plus a browser-based Server Edition.
Tracks Claude Code usage and session limits in real time on macOS, entirely locally with no data leaving the machine. Aimed at pacing work so a long run doesn't hit a wall mid-task.
Runs prompt or skill variants against each other and compares results blind, so improvements are measured rather than assumed. Fills the gap where most prompt tuning is judged by whichever output the author read last.
Keeps one source of truth — 148 commands, 88 agents, 115 skills, and 23 role-based packs — and compiles it into the native config format for Claude Code, Cursor, Gemini CLI, OpenCode, Aider, Cline, Codex, Continue, Copilot, Windsurf, Kimi, and Qwen. Solves the drift problem when you use more than one agent.
Takes a technical idea and produces a Word invention disclosure ready for submission, with anti-hallucination checks on the generated claims and background. Domain-agnostic rather than tied to one technical field.
A command-line audit tool covering both classic SEO and GEO — whether AI assistants can find, parse, and cite your pages. Reports issues rather than rewriting the site for you.
Point it at a repository and it returns an isometric visual map of the codebase, with each claim backed by a file path, line number, and the text found there. The citations make the map checkable instead of a plausible-looking diagram.
A menu bar app that converts your Claude usage percentage into remaining time ("limit in ~1h 17m"), covering the 5-hour and weekly windows with daily history and threshold alerts to Slack, Discord, or webhooks. Electron with a native Objective-C++ module, shipped through the Mac App Store; the post covers the build gotchas.
Upstream Collaborator stopped shipping .exe builds after v0.6.2; this packages v0.8.4 for Windows x64 and arm64, with fixes to the Windows build and CLI. Useful if you want the infinite-canvas agent workspace on Windows.
Starts the full stack, drives the actual running application, records the session, and tears everything down again. Gives you evidence that an agent's change works in the real app rather than only in its own summary.
Shows every Claude Code and Codex session on your Mac in a single live tree — including sessions you started by hand and the child agents they dispatch — marking which are working, done, or waiting. You can answer any of them from your phone, with no hooks, MCP, or wrapper required; works with iTerm2 or tmux.
Spawns a bongo cat for each running coding agent that drums along with that agent's output. A lightweight ambient signal for whether your agents are actually producing anything.
Surfaces running Claude Code sessions in the MacBook notch, chiming when one finishes and jumping you to the right terminal tab on click. Minimal surface area compared to a full dashboard.
Doop.design is a shared live canvas where Claude Code, Codex, and other LLMs collaborate on visual design. It stores design preferences in memory so every agent produces work matching the same design system. You can drop in screenshots and ask Claude to design a site in a similar style.
A zero-dependency linter that grades an AI coding agent's setup: permissions, hooks, MCP servers, skills, and memory files. A correctly configured project produces no output, so the tool only speaks up when something is off. MIT licensed.
Beacon sits in a screen corner showing one light per Claude Code or Codex session: amber while working, green when finished, red when it needs an answer. Clicking a light jumps back to that session. Lights group by project and hold a stable order so the display stays readable as sessions pile up.
An open-source browser chess app that lets Claude Code play a full game against you while running in your terminal. Claude reasons about the position in chat, narrates its moves, and occasionally trash-talks. In the author's demo game it opened by the book, then lost on narration-induced time trouble.
Runs Claude Code inside a hardened Docker container that holds no credentials at all. Every CLI call (git, aws, gh, kubectl, terraform) is brokered through a host-side server with pluggable authorization, temporary credentials, and audit logging. Aimed at letting an agent work autonomously without handing it your keys.
A helper for people who keep separate Claude Code setups, such as home versus work. It manages the configuration sets and lets you hop between them instead of hand-editing settings each time. Small, single-purpose utility.
A manager for running several coding agents side by side, covering Claude Code, Codex, Cursor, Grok, and more. It gives one place to start, watch, and switch between parallel sessions across different vendors.
Claude Code discards session history after 30 days; this tool backs it up. It captures config and chat history, syncs daily on a schedule, and supports migrating everything to another machine.
A cross-platform client for driving Claude Code sessions from a phone, desktop, or browser. Beyond sending prompts it manages plugins, browses project files, and streams a live view of the host machine.
Another take on the coding-agent status line, showing model, token counts, cost, and git status in real time. Fields and layout are configurable, and it targets AI coding assistants generally rather than one specific CLI.
A retrieval agent that runs locally and indexes multimodal content for Claude Code to query. Keeps the corpus and the retrieval on your own machine rather than in a hosted vector service.
Renders a live map of what your coding agents are doing: plans, tool calls, file changes, and progress, as it happens. Runs locally across Claude Code, Codex, and Cursor so you can watch several agents from one view.
A Tauri and Node desktop command center for managing a fleet of coding agents, with 306 tests. What makes it worth reading is the author's post-mortem against their own usage data, which concluded the premise was wrong: no click-driven feature survived 20 days of real use.
A local token-burn HUD that needs no API key, priced per model at each model's own list rate. It pairs the readout with a pet that glows from cool to hot as your burn rate climbs. macOS only.
Sits between a coding agent and an image generation model, enforcing a brand kit, a budget governor, and a quality bar. Images that fall below the bar do not leave the darkroom.
A local scheduler that queues work and runs it so each 5-hour usage window is consumed rather than expiring idle. Engine profiles extend it to other Anthropic-compatible subscriptions (Kimi Code, GLM, MiniMax, MiMo, OpenCode Go, Ollama Cloud), each with its own cooldown and ledger. Single Go binary with a read-only web board.
A desktop tray app for Windows that tracks token consumption across Claude Code and Codex. Sits in the system tray so you can watch usage against your limits without leaving the terminal. Niche but welcome if you're on Windows, where most usage monitors are terminal-only.
A zero-dependency, single-file tool that summarizes a finished Claude Code session into a clean handoff.md you can hand to Gemini, GPT, or another Claude. It runs post-hoc against an existing session rather than instrumenting your workflow up front. Worth a look if you want cross-model handoffs without installing a plugin.
Renders every Claude Code skill and agent in your setup as a living pixel creature in a Tamagotchi-style village. Purely for fun, but it doubles as a surprisingly readable inventory of what you've actually installed. A novelty that makes a sprawling skills directory legible at a glance.
A Claude Code plugin that meters every token and ties the cost back to the specific work item it produced. Instead of a single monthly burn number, you get per-story receipts you can put in front of someone. Aimed at teams that need to justify agent spend rather than just observe it.
Checks code signing, provisioning profiles, and App Store Connect state to explain why a build won't make it to the store. All checks are read-only, so it diagnoses without mutating your certificates or project. Useful to hand an agent when release failures are opaque.
Takes a semantic intermediate representation and emits native DrawingML, so agent-generated decks stay editable in PowerPoint instead of degrading into images or brittle XML. Ships as a Claude Code plugin, a DSH plugin, and a CLI. Solves the usual failure mode where agent-built slides can't be touched afterwards.
Turns Claude Code and Codex sessions into characters in a small 2D world, and now signals state clearly — working, waiting for input, finished, or errored — with visuals and sound. The point is knowing when an agent needs you without watching terminals. Open source.
A fully featured mobile and web client that connects to your Claude Code and Codex sessions, with realtime voice and end-to-end encryption. Lets you drive and monitor agent work away from the desk. One of the more complete remote-control clients in the ecosystem.
A terminal companion for autonomous coding agents that clusters, flags, questions, and annotates their output. It deliberately never writes back to the agent, so review stays a separate, human-controlled pass. Useful when agents produce more diff than you can read linearly.
Runs Claude Code inside a PTY session so process-based print mode emits usable JSON or streaming output. Solves the case where the CLI behaves differently when it is not attached to a terminal. Handy for scripting and CI around Claude Code.
A Rust harness and agent runtime that is fully decoupled from any one model provider and driven by plugins. Compatible with ACP and Claude Code plugins, so existing extensions carry over. For people who want to own the loop rather than the vendor CLI.
Provides a controlled, isolated environment for Claude Code and Gemini CLI built on Kubernetes with Firecracker microVMs. Each agent gets real isolation rather than a container escape hatch. Aimed at running agents with fewer permission prompts but real containment. Documentation is in French.
A unified desktop app for managing skills, plugins, and extensions across AI tools from one vault. Replaces hunting through per-tool config directories. Useful once your skill collection outgrows manual file management.
A WebGL time-trial racer with a pager built in: paste a token into your agent and it writes its own hook config for Claude Code settings.json, Codex notify, or OpenCode. The game then shows a banner when a turn ends or the agent is stuck on a permission. Built in three days and 74 commits with Claude Code.
Describes a product demo in YAML so you rerun it after every change instead of re-recording. Built for coding agents to maintain alongside the code. Solves the stale-demo problem that kills most screen recordings within a release or two.
A drop-in memory layer that claims roughly 90% lower token consumption while holding response quality. Integration is deliberately minimal — three lines. Worth benchmarking against your own workload before trusting the number.
Run, follow, resume, and migrate conversations across Claude Code, Codex, Cursor, Grok, Devin, and OpenCode from a single local workspace. Moving a conversation between agents is the distinctive part. For people who switch tools mid-task.
A PTY wrapper with a small VT emulator that colors command, subcommand, flags, strings, and operators in Claude Code's shell output, so a long git line reads at a glance. Claude Code itself runs exactly as shipped, leaving hooks, MCP, plugins, permissions, and Remote Control untouched. Rust, one dependency, 380 KB.
A terminal app built after the author measured that their two worst long sessions (60h and 53h) were the ones that hit compaction twice, while a 4.6h session that never compacted stayed sharp. Claude interviews and plans, Codex implements, and memory lives outside both models. Written by a daily Claude Code user of over a year.
Bridges a coding agent to Telegram so you can follow and respond from your phone. Dependency-free and built with security in mind. Another entry in the growing remote-control-over-chat category.
Captures each session as it ends and renders Markdown plus self-contained HTML beside the untouched original JSONL. Survives project moves and renames, and supports redacted sharing, integrity checks, and one-shot import of existing archives. For people who want their session history to outlive the tool.
Coding agents author explainers in MDX/React, which then pass deterministic design-quality verification and a multi-model eval harness. The verification step is what separates it from a template library. Aimed at documentation and teaching material that has to look right.
The Claude Command Center dashboard, used by its author to run 30+ parallel Claude Code and Codex sessions, adds a manual attach and detach action for linking related sessions that lack real spawn lineage, so they nest like true subagents. Devin CLI sessions now show model, reasoning effort, and subagent calls, with the low-to-max effort ladder mapped across tools. Ships most days.
Gives any agent — pi, Claude Code, or Codex — control of a Wayland desktop through plain bash commands, plus a headless pi summon. Fills the Linux gap in computer-use tooling that mostly targets macOS. Hyprland-oriented.
Connects command-line AI agents to each other over a Unix socket locally and SSH federation across machines, via a Rust daemon. Agent-to-agent messaging without a cloud broker. Documentation is bilingual French and English.
A memory layer for Claude Code, Codex, and terminal agents that watches sessions and captures the steps that genuinely resolved problems, rather than storing everything indiscriminately. It then feeds that high-signal context back so the next run starts where the last one ended. The evidence-first framing is the differentiator in a crowded agent-memory field — it filters on outcomes instead of recency.
A diagramming DSL designed so a coding agent can author architecture diagrams reliably while you keep precise control over the output. Renders to deterministic SVG, which means diagrams diff cleanly in git and regenerate identically. A better fit than Mermaid-by-prompt if you want agent-generated architecture docs to stay stable across commits.
An unofficial utility for the Claude Code session files on disk: surface a session under a different Claude account on the same machine, or relocate one to another project folder. Operations are journaled and reversible, and it fails closed rather than risking your history. Niche, but it solves a real annoyance if you juggle two accounts or reorganize project directories.
A CLI for running long-lived agent "teammates" that keep memory between runs, load skills, and act on schedules rather than only when prompted. The pitch is proactive and self-improving agents — work that continues on a cadence instead of per-session. Early and broad in scope, so treat it as something to watch rather than a settled tool.
A hosted IDE that puts live Claude Code terminals on a kanban board, each running in its own container on a server you control. Cards represent agent tasks, so you can watch and steer several concurrent sessions from one browser tab. Useful if you want parallel agent work without juggling tmux panes on your laptop.
A small native Windows desktop companion that reflects what Claude Code (or Codex) is doing — current task status, progress across a whole request, and a signal when the quiet window means it is done. It is an ambient status indicator rather than a control surface. Handy when the agent runs long and you have switched to another window.
An unofficial VS Code extension that reads ~/.claude and surfaces spend, active agents, workflows and usage limits in a dashboard plus status bar. Everything is local file parsing, so no account hookup is required. Useful for keeping an eye on limits mid-session without leaving the editor.
A motion design layer that lets you tune animations by direct manipulation instead of describing them in prompts. Aimed at projects scaffolded by AI coding agents, where the generated UI usually lands with generic or missing motion. Fills the gap where natural language is a poor tool for timing and easing.
A local-first workbench for running multiple coding agents across projects, with evolving org blueprints describing agent roles. Supports Claude Code, Codex, OpenCode, Antigravity and pi CLI alongside OpenAI-compatible and Gemini API executors. Each task gets its own git worktree, so parallel agents do not collide on the same files.
Packages the official Anthropic Claude Code binary for NixOS so it stays current without npm global installs, third-party binary caches, or waiting for a nixpkgs bump. Includes a pinned fallback for reproducible builds when you need a known-good version. Solves the recurring NixOS friction of a CLI that expects to self-update on a system where the store is immutable.
A Linux alternative to Solo (soloterm.com) that runs your dev stack and your CLI coding agents side by side in one window with real terminals. It adds crash auto-restart, Git and pull request handling, and a shared project workspace where multiple agents coordinate over MCP. Targets Ubuntu 22.04+ on x86_64.
A mobile control panel for shipping and maintaining a portfolio of web apps from your phone. Tasks are delegated to Claude Code workers that pull from a queue, run in isolated containers, and open PRs; you can also open browser terminals. It surfaces live status across Cloudflare, Vercel, Neon, VPS, Expo, and Apple Developer in one view.
A time tracker for Claude Code that monitors sessions and shows how much of your weekly limit you have consumed. It gives you a dashboard view of usage over time rather than discovering a limit at the moment you hit it. One of several tools in this space, so check whether it adds anything over what you already run.
A Paseo plugin that tracks every coding-agent account you hold — Claude Code, Codex, Kimi, Grok — with live health status and automatic routing between them when one is throttled or down. It also bundles a universal MCP server manager. Works standalone if you do not use Paseo.
A developer's own web app that wraps Claude Code so sessions across many projects stay findable. Hooks stream prompt data to the app as Claude works in the background, and replies go back through claude -p with the stored session ID to continue the conversation without opening a terminal. Includes a diff viewer and plan view; shared as a show-and-tell after six months of daily use.
A telemetry layer that instruments AI agents wherever they run — local machine, CI, or cloud — so behavior is observable across environments instead of only in the terminal you launched from. Open source, and positioned as general-purpose rather than tied to one agent runtime. Useful if you are running agents in CI and currently flying blind.
A plugin marketplace of specialized agents that works across Claude Code, Codex, Cursor, OpenCode, GitHub Copilot, and Google Antigravity. Instead of maintaining separate agent definitions per tool, you install from one catalog and reuse the same roles everywhere. Useful if you switch harnesses or run several in parallel.
Maps a fleet of parallel Claude Code sessions onto a Stream Deck XL, one key per session, colour-coded by lifecycle state. Press to focus a session, long-press to tear it down safely, and answer permission prompts directly from the deck. macOS + iTerm2 only.
Open-source prompt version control aimed at AI teams: git-style history, automated evals against saved prompt versions, and one-click rollback. Fills the gap where prompts live in code but are not reviewed or regression-tested like code. Not Claude Code specific, but relevant to anyone maintaining prompts in a shared repo.
A self-hosted gateway that exposes one endpoint and routes requests to 96+ model providers. It translates automatically between the Claude, OpenAI, and Gemini API formats, so a client written against one API can talk to any backend. Handy for pointing Anthropic-format tools at alternative or local models without rewriting them.
A practice tool that asks you to predict what the agent will do before it shows you the code, then turns every gap between your guess and reality into a personal curriculum. It targets skill atrophy from heavy agent use. Turns ordinary coding sessions into deliberate practice instead of passive review.
A Windows console that runs a fleet of Claude Code sessions as a coordinated dev team, with one place to launch, watch, and steer each agent. Most multi-agent orchestrators assume tmux or a Unix shell, so this fills a real gap for Windows users. Useful for running parallel agents on separate tasks without juggling terminal windows.
A local tool that lets coding agents render ordinary HTML so they can visually review their own output instead of guessing from code alone. It closes the write-render-inspect loop without a heavyweight browser automation stack. Useful for agent workflows that generate UI, reports, or documents and need a visual check step.
A local-first analytics layer for AI agent skills: it tracks which skills fire, how often, and in what context, keeping all of the data on your own machine. Useful if you maintain a large skill library and want evidence about what actually gets used rather than guesses.
A native application that hosts your coding agents in one place instead of scattered terminal tabs. Built by egoist, it gives agent sessions a proper desktop UI with the responsiveness of a native app.
A CLI (ccs) that collects your Claude Code configuration, pushes it to a GitHub payload repo, and applies or bootstraps it on another machine. Solves the drift between laptop and desktop setups without hand-copying dotfiles.
A repository-committed memory bank holding project context, governance rules, and delivery workflows for coding agents. Because it lives in git, the agent's understanding is reviewable in a diff and travels with the branch.
An open-source desktop app (Japanese-language) bundling Codex CLI, Claude Code, Gemini, and cloud or local LLMs into a single AI team workspace. It moves you from one chat window to coordinating several agents from one surface.
A Go tool that patches Claude Code v2.1.233 to talk to third-party model endpoints while keeping the native /model and /fast commands and normal terminal interaction intact. Written in pure Go with no runtime dependencies.
A shared bulletin board where each Claude Code session on a machine declares the finite resources it is about to use — ports, devices, files — so the others can see it. It deliberately never blocks and never inspects a resource; visibility is the entire mechanism. UI and docs are Japanese.
A client for Codex, Claude Code, OpenCode, Kimi, Augment Code, and Qwen that runs on web, desktop, and mobile with end-to-end encryption throughout. Start a session at your desk and keep following it from a phone.
Extracts and summarizes the content of a video given only its URL, covering Bilibili, Douyin, and YouTube. Useful as a research step when the source material an agent needs is locked inside video.
Migrates your configuration — rules, skills, subagents, hooks, permissions — between Claude Code, Codex CLI, Cursor, and Grok Build. It plans the migration before touching anything and supports an undo afterwards.
Drives a real browser keyboard-only and with a screen reader, then emits WCAG findings each linked to the evidence that produced it. Aimed at accessibility checks an agent can run and a human can actually audit.
A Claude Code plugin providing persistent memory that spans projects plus a phase-based workflow engine, stored locally and event-sourced so every change is replayable. Writes to memory are human-gated rather than automatic.
Searches every past Claude Code and Codex CLI conversation on your machine and lets you resume the one you find. Answers the recurring 'I solved this three weeks ago in some session' problem.
Reads your Claude Code and Codex usage from local data to show what you have spent and how much quota remains. No account, no telemetry, and no network calls at all.
A desktop app presenting your Claude Code work as a roster of bots, where each keeps its own model, working directory, and persistent conversation. Switching tasks means switching bots rather than re-establishing context.
Watches every Claude Code session on your machine in real time and keeps a ledger of tasks, worktrees, and resources alongside token spend and cost. Rules are enforced centrally instead of being repeated in each session.
Maps Claude Code and Codex session state onto Stream Deck keys so you can see at a glance which agent is running, blocked, or done. Physical ambient status instead of one more window to check.
Measures the always-on context tax of your CLAUDE.md, skills, and subagents, diffs it on every pull request, and fails the build when it grows past budget. The bundle-size bot, applied to agent configuration.
A single control surface for directing several coding agents, following each session as it runs, and stepping in at any point. Positions you as the captain rather than a tab-switcher.
Connects two Claude Code sessions so the one holding the relevant context answers the other's question — no copy-paste, no re-explaining. Aimed at the split-brain problem when you run more than one session on a project.
An open-source agent runtime security tool that sandboxes tool executions one at a time and blocks the shell-wrapping tricks agents use to slip out of isolation. The release adds worked tool-sandbox examples.
An Omarchy plugin turning the desktop wallpaper into a clickable status board showing every running AI agent — Claude Code, Codex, Grok, Ollama — with a seven-day heatmap, rate limits, recent prompts, and machine stats. Follows the active theme.
A high-performance coding assistant CLI written in Go that stays compatible with Claude Code, adds multi-account routing, and supports ClaudeKit skills. Positioned as a faster drop-in for the same workflow.
A cross-agent permission policy kept in a single .agents/permissions.json, with an MCP sync daemon, a CLI, per-tool codecs, and an evaluator. Write the rule once instead of maintaining a different allowlist per agent.
Scans Claude Code's local transcripts and state files for credentials that ended up there — keys pasted into a prompt, secrets echoed by a command. Read-only with zero dependencies, so it changes nothing while it looks.
A local browser for your Claude Code session history, letting you dig through past conversations on your own machine. No upload and no service in between.
An installer wizard aimed at users in China for setting up Claude Code, Codex, Hermes, and domestic model CLIs from a directory-driven catalog. Still in testing, with the author actively asking for reports.
Scans your Claude Code skills for prompt injection, hidden instructions, credential exfiltration, and guardrail tampering before any of it reaches the model's context. Since skill installs increasingly come from strangers' repos, this is the gap between npm-style convenience and actual review.
Colours iTerm2 tabs by agent state — red when blocked, amber when it is your turn — with the colour fading over twelve hours so stale tabs recede. Supports iTerm2 and Claude Code today.
Bundles a Claude Code plugin, an MCP server, and a spec-driven development framework into a single pip install, giving persistent memory plus workflows whose completion is backed by receipts. Aims to replace three separate tools with one.
Shows pending agent changes on a rich visual surface with inline comments and supporting evidence, gated so nothing lands unreviewed. The gate remembers the approaches you rejected, so the agent stops re-proposing them.
A follow-up on an F-Zero-style browser racing game built by someone with no coding background, now closer to beta than tech demo after four months. The main change was moving planning to Fable and wiring it into the build loop.
Compacts what a session learned without losing it, using symptom-first triage, durable capture of findings, and a cold-start verification pass that checks the compacted form still works. Targeted at the moment context runs out mid-investigation.
A Rust graph tracker that follows where numbers and dates came from, evaluates the expressions that produced them, and verifies each derivation. Aimed at the class of agent error where a plausible figure has no traceable origin.
A user evaluated memplace after a month and found it rarely surfaced the context the agent needed, at roughly a 900:1 ratio, and asks what people use instead. Worth reading as much for how to test a memory tool as for the recommendations.
Annotates TypeScript declarations with @evidence tags pointing at the spec sections, endpoints, and hooks each one satisfies, then enforces coverage as a compiler rule. Requirements an agent skipped become build failures instead of silent gaps.
Runs coding agents in the background through the full cycle — do the work, review it, land it — without a human in the loop at each step. For the queue of work you would otherwise babysit.
Wraps a command you already run and stays invisible until the process exits non-zero, then captures the stack trace, output tail, and git state, cuts a branch, and hands it to a headless Claude Code session that writes a failing test and patches it. Crucially, phantom re-runs the tests itself outside the session and audits the branch, so nothing in the report rests on the model's own word.
Local hooks sitting under your coding agent that condense flooding command output before it enters context while keeping the full text on disk. When a session ends it prices your real usage from the harness transcript, and it keeps one git-committed .wolf/ memory shared across Claude Code and Codex.
Structures research as a tree of questions and falsifiable hypotheses kept in plain markdown, so an AI agent can extend the tree while you keep the files in git. Ships an LLM-maintained literature wiki and a browser GUI cockpit for navigating the tree. Aimed at agent-assisted research rather than agent-assisted coding.
A migration tool that safely transfers skills, slash commands, subagents, and MCP server config between Claude Code, OpenCode, Codex, and DeepSeek Harness. Handles the format differences per harness instead of making you hand-port each file. Handy if you keep one canonical config but run several CLIs.
A plugin (Burmese for 'scaffolding') that installs project governance structure and then keeps it current as the codebase evolves. Rather than a one-shot template dump, it re-checks and maintains the conventions it scaffolded.
A native macOS menu bar app that shows the state of local AI coding runs at a glance. Codex is supported today with Claude Code and Qwen3.7 listed as next. Useful if you kick off long agent sessions and want status without keeping a terminal in view.
Drives a long-lived Chrome instance through CLI commands so agents can browse sites that require being logged in. Sessions and cookies persist between commands, which is the piece plain headless automation usually loses.
A ticket board that both you and your coding agents read and write, so agent work is tracked as cards instead of buried in chat scrollback. Gives multi-agent runs a visible queue and a shared definition of what is in progress.
A local-first Rust engine that records agent session history so you can trace back what happened — described as a stack trace for your agent history. Supports 20+ providers and keeps every byte on your machine, with no hosted dashboard in the loop.
A local control plane for handing scoped software tasks to coding agents, with observability, durable state, and approval gates. Built independently on the Claude Agent SDK, inspired by Danny Postma's AgentOS video. Currently a v0.1.0 developer preview.
A harness that gives coding agents a structured environment for trading work rather than ad-hoc scripts. It targets both Claude Code and Codex agents, so strategy and execution logic stays agent-agnostic. Useful as a reference for how to wrap a domain with real-world side effects in an agent-driven loop.
specfill analyzes a project specification, researches the topic, and then interviews you one question at a time about missing architecture, behavior, edge cases, and UI/UX decisions, folding the answers back into the original document while preserving its structure. Skipped questions stay unresolved instead of being filled with invented answers. Unlike Plan Mode, which produces a plan for the current session, the output is a reusable spec you can commit; it supports Anthropic, OpenAI, Google, and OpenAI-compatible providers.
A community-maintained Docker image that packages Claude Code for containerized use. The stated focus is staying lightweight rather than bundling a large toolchain. Handy for sandboxed runs, CI, or keeping agent sessions off the host filesystem.
A VS Code extension that collects every file Claude Code touched during a single turn and presents it as one unified multi-file diff. Instead of reviewing edits tool call by tool call, you get a single review surface per turn. Aimed at people who run Claude with auto-accept and want a fast after-the-fact review pass.
A Claude Code agent that generates a personalized 15-20 minute business news briefing every business day, reading a portfolio and watchlist from Google Sheets, pulling live quotes via yfinance, and rendering audio with Kokoro TTS to Google Drive. It carries context from prior reports so stories build on each other instead of repeating, and accepts feedback that shapes future runs. A good template for scheduled, personalized research agents.
A local-first kanban board designed to be driven by Claude Code, combining a kb command-line interface with a web board view. Cards live locally and can optionally be mirrored to GitHub issues. Useful if you want the agent to track and update its own task board without leaving the terminal.
A Claude Code plugin marketplace whose plugins are written to work with any agent harness, not just Claude Code. Every change has to clear a three-tier evaluation suite before landing, which is an unusual amount of rigor for a plugin registry. Useful both as a source of plugins and as a model for testing them.
Session Kit runs on the machine hosting your Claude Code and Codex sessions and presents them all in one terminal picker, each with a stable number, name, color, model, and status. Status comes from live process evidence rather than window titles, so sessions blocked waiting on you sort to the top. Sessions survive SSH disconnects via shpool, and a per-repo session-kit.toml sets the provider, account, model, and startup command.
VibeRevert wraps a Claude Code session, snapshotting the project before the agent starts and flagging changes that touch payments, auth, migrations, secrets, infrastructure, or dependencies. The checks are deterministic rules rather than another model, so the same inputs always produce the same findings with an inspectable reason. Rollback previews before writing and preserves your own uncommitted work, which plain git checkout would destroy.
lore gives Claude Code a memory layer that reasons about you instead of just storing notes, using a Honcho-style belief store with deriver, dreamer, and dialectic stages. It automatically turns recurring patterns into skills via a closed judge/update/retire loop, hard-caps curated memory so it cannot grow without bound, and adds FTS5 full-text search over past sessions. Everything lives in one SQLite file using only stdlib Python, with a human in the loop.
agent-tty from the Coder team lets you drive, inspect, and record terminal sessions programmatically from the command line. That makes it a useful primitive for automating or observing coding agents that live in a TTY, including headless Claude Code runs. Useful for building supervisors, replay tooling, or test harnesses around interactive agent sessions.
A parent with no prior wiring experience built a real toy cash register — six arcade buttons, a thermal receipt printer, and a Pi Zero — through Claude Code sessions run mostly over SSH on the Pi itself. Two debugging stories stand out, including RPi.GPIO's interrupt-based edge detection failing on newer kernels because it depends on a stale sysfs interface, which they replaced with a plain 20ms polling loop. A concrete look at how far agent-driven development goes into unfamiliar hardware territory.
A visual browser for every Claude Code session on your machine, spanning all projects and git worktrees. Fuzzy search narrows the list, a live preview pane shows session content before you commit to opening it, and a single keypress resumes the session you land on. Handy when you juggle many short-lived sessions and lose track of where a piece of work happened.
tracer converts session transcripts from AI coding CLIs into a single self-contained, browsable HTML file. Because the output has no external dependencies, a trace can be shared, archived, or attached to a bug report and still open anywhere. Useful for reviewing what an agent actually did across a long session or for post-mortems on runs that went sideways.
Claude Code writes every session as JSONL under ~/.claude/projects and deletes it after ~30 days, with no browser or search. Claude Sessions is a 100% local Tauri/Rust/Svelte desktop app that indexes every session across projects with global search, in-session find, and keyboard nav, handling 500k-token sessions. It surfaces what raw logs bury — mid-turn interrupts, AskUserQuestion picks, edited files, subagent transcripts, fork lineage — and lets you save sessions past the cleanup window or export to Markdown.
A plugin that gives Claude Code SQL, hybrid RAG, and grep as retrieval options over your repository instead of relying on grep-and-read alone. The author reports 32% fewer tokens, 53% fewer tool calls, and 32% less wall time, since context retrieval is offloaded to local CPU and memory rather than spent on the model reasoning about how to search.
A local-first video production studio shipped as one Go binary that drives AI editing through your Claude CLI subscription rather than a separate API key. It handles auto-cut, subtitles, on-device TTS, translation, quality control, and packaging for publish. Everything runs on your machine.
A free and open-source desktop app that runs Claude Code, Codex, and Kimi across your own machines. Hosts discover each other over your local network, so you can start work on whichever box you want and monitor it from your phone. No cloud service and no account required.
Keeps a single AGENTS.md as the source of truth and symlinks it into the config location each AI coding tool expects. No code generation and no duplicated files that silently drift apart. Small tool for anyone juggling Claude Code alongside other agents.
A local-first macOS app for picking up where you left off across AI coding tools. It finds past sessions, keeps per-project memory, and resumes work in whichever tool the project belongs to. Aimed at the context loss that happens between one day and the next.
An MIT-licensed Android, iOS, and desktop terminal built on Mosh with a pure-Kotlin terminal emulator, so sessions survive WiFi roaming and network drops. Positioned as the pocket entry point to TUI agents like Claude Code and Codex running on your own machines.
A deterministic plus AI-aided scanner that flags integrations at risk from retiring vendor APIs, CVEs, and EOL dependencies, reporting the exact file and line. Notably it also states where it is blind rather than presenting a clean bill of health it cannot back up.
A terminal UI that pulls the local session history of Claude Code, Codex, Grok, and GitHub Copilot Chat into one place to browse, search, resume, and fork. Solves the problem that each agent stores its history in its own format in its own directory.
Tracks LLM token usage locally across Claude, Codex, OpenCode, ZCode, WorkBuddy, and Zhipu-AutoClaw, with both a CLI and a background daemon on macOS and Windows. Everything stays on your machine.
Tracks daily prompt activity across CLI coding agents and renders it as a contribution graph. Lightweight and mostly for fun, though it gives an honest picture of how much of your work actually flows through an agent.
Puts your machine terminal on your phone, giving you a way to check on or drive a long-running Claude Code session while away from the desk. Minimal scope by design.
Manages several coding agents on a single Mac as one small crew rather than as isolated terminal tabs, coordinating what each is working on. Documentation is in Chinese.
A self-hostable runtime for persistent autonomous coding agents, isolating each in a KVM virtual machine or rootless container. Includes an A2A-protocol executor with signed AgentCard discovery, AIWG mission dispatch, a web dashboard, and virtiofs shared storage. Runs entirely on your hardware with no hosted control plane.
A local mission control for Claude Code sessions: live activity, cost and token burn, verified multi-agent tasks, and loop detection to catch a session spinning on the same failing edit. Run, observe, and orchestrate from one place.
JFrog open-sourced a tool for saving tokens and maximizing usable context safely. Worth attention mainly because it comes from an established tooling vendor rather than a weekend project, so the context-trimming heuristics are likely to be conservative.
An agentic development environment with built-in cross-harness subagents and agent-to-agent communication, running on desktop, mobile, and VPS. Cross-harness means a subagent need not be the same model or CLI as its parent.
Routes Claude Desktop third-party inference calls to cheaper OpenRouter models, with live token pricing so you can see what each route costs before committing to it.
Adds file-level ownership claims for multiple AI coding agents working in a single git working tree, so two agents cannot silently overwrite each other edits. Zero dependencies. A lighter alternative to giving every agent its own worktree.
A Claude Code plugin that measures where you rank in both search results and AI answers, identifies what to fix, and carries the change through to actual code edits. Backed by a local SQLite store and a dashboard, and works without an API key. Documentation is in Korean.
Serverless remote access to your Claude Code and Codex sessions, built on AWS. Lets you check in on and interact with a running session from any device without leaving a machine exposed to the internet.
Keeps agent work in sync across interfaces, from a CLI session to a GUI to your phone, so the same task is visible and controllable wherever you happen to be.
A coding harness built around keeping the human in the driving seat rather than dispatching work and hoping. Worth a look if the fully autonomous loop has burned you and you want tighter turn-by-turn control.
An open-source control plane for organizations running coding agents at scale, starting with Codex and Claude across Mac, web, and iOS. Positions agent fleets as infrastructure to be operated rather than terminals to be babysat.
An open-source company brain that runs inside whichever AI agent you already use — Claude Code, Codex, Gemini CLI, or Antigravity — keeping business context local to your machine instead of uploading it to a SaaS knowledge base. Documentation is in Portuguese.
Puts a live clock in the Warp tab title for Claude Code sessions, so a glance at the tab bar tells you how long a session has been running. Tiny scope, and a neat answer to losing track of a long agent run.
One command to run Claude Code, Codex, OpenCode, Droid, Pi, and others against OpenRouter, DeepSeek, Groq, Ollama, or any OpenAI- or Anthropic-compatible endpoint. Useful for evaluating how much of a harness quality comes from the harness versus the model behind it.
A desktop app for running a team of Claude Code agents using a hiring metaphor: hire an agent, assign it a project, watch its work, and pick up where you left off. The persistent per-agent context is the substance behind the framing.
A paste-installable, hardened deployment of Daniel Miessler Personal AI Infrastructure on a Linux VPS, with private Tailscale-only access, an isolated pai system account, and Pulse plus gateway components. One PAI instance reachable from every device without exposing it publicly.
A local-only, free floating pomodoro/flowtime timer for macOS that exposes a Claude Code-friendly API. That means an agent session can start, stop, or query your focus timer as part of a workflow. Small utility, but a neat demonstration of giving a desktop app an agent-callable surface.
A local-first app that reads your AI coding agent telemetry and renders it as a generative 3D forest that grows with your usage. Sessions, tokens, and activity become trees and terrain rather than a bar chart. Purely a visualization toy, but a memorable way to see your own agent usage patterns.
A web app that lets you share a live Claude Code session with friends or coworkers so several people can watch and collaborate on the same run. It is bring-your-own-Claude, so there is no per-seat cost and the author serves it free. Useful for pairing, teaching, or reviewing an agent run as it happens.
A self-hosted service that streams your Claude Code or Codex sessions to Telegram, Feishu, or a web terminal and lets you approve tool calls remotely. You can keep long unattended runs moving without sitting at the machine that started them. Works with either a subscription login or an API key.
A proxy that speaks the Anthropic Messages API on the front and the OpenAI Responses API on the back, letting Claude Code drive models served through a ChatGPT subscription. It is an adapter layer, so the CLI you already use stays unchanged. Relevant if you want to reuse Claude Code tooling against a different model provider.
A tool for searching across your past Claude Code sessions instead of scrolling transcripts by hand. It indexes your local history so you can find the conversation where you solved something before. Simple but fills a real gap for anyone with months of accumulated sessions.
A project that turns real Claude Code and Codex session trajectories into verified, tradable post-training assets. The pitch is that everyday agent runs are latent training data if you can validate and package them. Early and speculative, but an unusual angle on what session logs are worth.
A macOS app for pulling tables and other structured content out of PDFs, built over three months of iteration with Claude Code. The author works in finance and wrote it after commercial OCR tools mangled financial tables. The Reddit writeup also covers the model and agent workflow used to build it.
A local-first, open-source mobile interface for terminal-based coding agents like Claude Code, Codex and OpenCode. It gives you a real terminal backed by durable tmux sessions, so agents keep running when you close the app. Approvals are risk-gated, letting you sign off on sensitive actions from your phone while everything stays on machines you own.
A voice bridge that adds session-safe TTS and STT to terminal coding agents, with wake-word activation and barge-in so you can interrupt the agent mid-speech. Harness adapters are modular, so it is not tied to a single CLI. The session-safe framing matters — it aims not to corrupt the agent's stdin/stdout while piping audio alongside it.
An open-source macOS app that gives every coding agent its own live terminal and shows each one's state in a sidebar, so you can tell at a glance which is working, waiting on input, or done. It supports isolated git worktrees for parallel agents, remote agents over SSH, persistent sessions that survive closing the app, and MCP so one agent can spawn others. Written in Rust and GPUI; very early at v0.0.1.
A browser multiplayer tank game built with Claude Code across a long-running multi-agent pipeline, inspired by World of Tanks Blitz. It has 100+ procedurally generated vehicles across 16 maps, with detailed armor zones, internal modules, crew positions, physics-driven destruction and private/LAN lobbies. Worth a look as evidence of what sustained agent-directed development produces at scale.
A launcher for Claude Code built on a keep-it-simple premise: a lean tool set, concise prompts, and no vendor-injected noise in the context window. The pitch is that stripping back what gets loaded into every session improves both durability of output and token cost. Worth comparing against your own CLAUDE.md and plugin sprawl.
Runs autonomous coding agents — Claude Code, Aider, Hermes Agent — inside rootless Podman or Docker containers so they cannot reach your host filesystem. Rootless matters here: a container escape does not hand over root on the host. A reasonable option if you want to run agents in permissive/YOLO mode without giving them your whole machine.
Opens a single authenticated SSH window onto a SLURM cluster and keeps it alive via connection multiplexing, with optional VPN and TOTP two-factor support. Jobs can be submitted, watched and fetched through it. The key detail is that it works from shells with no terminal, which is exactly the situation a coding agent runs in.
Shows how much of your AI coding CLI quota is left without opening a session to find out. It runs as a native macOS menu-bar app, or as a cross-platform quotabar command on Linux. Covers Codex, Claude Code and Gemini in one place, which is handy if you rotate between plans as limits run down.
A small 1.54-inch ESP32 desk display that surfaces your coding plan quota so you stop alt-tabbing to check it, plus voice input piped into Cursor. There is a live demo on GitHub Pages. Hardware side-projects around agent tooling are rare enough to be worth noting, even if the integration targets Cursor rather than Claude Code.
A native macOS app for browsing and tracking AI agent memory files, session logs and project transcripts. Reading these as raw JSONL is painful once you have any volume; this gives them a fast interface. Useful for auditing what an agent actually did across a long session or figuring out where its memory went wrong.
A desktop app wrapping CLIProxyAPI so Claude, ChatGPT, Gemini, and Copilot subscriptions can drive any coding tool. Provides a UI for managing connections and tracking usage across providers.
Multiplexes Claude Code and Codex sessions behind one local-first interface, with a durable event log and a web UI. The event log means you can reconstruct what any session actually did rather than scrolling terminal history.
A local API gateway that centralizes multiple AI providers, models, and keys behind one endpoint, so tools are configured once. On upstream network errors, timeouts, rate limits, or auth failures it automatically fails over to the next channel by priority.
A marketplace that installs and injects agent plugins — skills, MCP servers, hooks, and slash commands — into Claude Code, Codex, or Cursor from git marketplace repos. Includes a web GUI market page for browsing what is available.
Gives Claude Code a screen — a desktop application for launching and supervising a team of agents working in parallel. For people who have outgrown a grid of terminal tabs.
An unofficial macOS menu bar app that surfaces your current Claude and ChatGPT usage limits at a glance. Small, but it removes a question people otherwise answer by hitting the wall.
A free MIT-licensed Git client for macOS, Windows, and Linux in Rust and Tauri, now at v0.6.2. The author credits two things: a large CLAUDE.md documenting architecture and every hard-won libgit2 gotcha, and 36 integration tests against real temp repos that decide what survives.
Triages incoming issues, reviews PRs across multiple iterations, watches your sites, and escalates only the decisions that genuinely need a human. Aimed at maintainers drowning in the mechanical half of repo upkeep.
Runs Claude Code Workflow JS locally with resume, checkpoints, token budgets, and git worktree isolation. Codex-verified and Claude-compatible, so long orchestrations survive interruption instead of restarting from zero.
A terminal UI that manages multiple agent sessions inside tmux. Keyboard-driven and lightweight, for people who want parallel agents without leaving the terminal.
Observes agent behaviour — repeated actions, context burn, retries that produce no progress — records evidence, and only earns the right to intervene once it has enough proof. Supports tool enforcement on Codex and observation mode for Claude Code, OpenCode, and PrivacyCode. Contributors wanted.
Claude Code writes every conversation to .jsonl under ~/.claude/projects but gives you no way to search them. claude-scope syncs incrementally per file by byte offset on every query, so a message from a minute ago in your current session is already searchable, and results include the session ID for claude --resume. The author notes a subtle bug most indexers miss: messages typed while Claude is working are logged as attachment lines, not user lines.
Visualizes every running Claude Code session on a single screen so you can see which agent is working, waiting, or stuck without cycling through terminals.
Switches environments across Claude Code, Codex, and OpenCode, with API proxy auto-failover when an upstream goes down. One config surface instead of three sets of environment variables.
Starts a usage window before you sit down so you are never waiting on one, and with multiple subscriptions spaces them evenly and tells you which to spend next. Scheduling as an answer to rate limits.
A side panel that answers questions about the repo you are working through, deliberately sized so it does not push your pairs view off screen. Driven by the Claude Code or Codex CLI underneath.
Each stream of work gets its own git worktree, and an agent can operate the orchestrator itself — spawning sub-agents, delegating, and integrating results. Supports Pi and Claude Code.
A macOS menu-bar app that turns the notch into a live dashboard for system stats, battery, media, calendar, clipboard, focus, and AI coding-agent status. Built with Claude Code.
Migrates native session files across Claude Code, Codex, Pi, OpenCode, Copilot CLI, Antigravity, and Cursor Agent. Lets you switch tools mid-task without abandoning the conversation you already built.
A fast browser for agent automation that hands your existing logged-in session to Codex or Claude Code without taking over the browser you are using. Zero cost, zero config, which is the pitch against heavier automation stacks.
One directory that is simultaneously an Obsidian vault, a Claude Code memory store, and a git repo — with git as the only database. No sync service, no index server, just files and commits.
A physical touch display showing Claude Code and Codex usage, talking to your machine locally over USB. Local-first with nothing leaving the desk.
Tracks usage and halts Claude Code before it crosses your 5-hour and weekly plan limits, so no extra usage credits get spent. Windows GUI with pausing, thresholds, and weekly pacing.
Orchestrates many Claude Code sessions across both local and remote tmux servers from one panel. Useful when your agents are spread across a laptop and a couple of boxes.
Agent memory stored in git, where each remembered fact is grounded in a source and the history of what changed is auditable. Git as the substrate means no separate database to run or trust.
Upload a file, get a hard-to-guess URL — so an agent can put a screenshot into a pull request, which GitHub has no API for. One Go binary, no database, files on your own disk.
A Claude Code plugin that detects when a turn was killed by a transient API stream error and resumes the session automatically. Removes one of the more annoying reasons long runs die unattended.
Shows rate limits, context window consumption, and reset countdown in a persistent bar alongside the CLI. Three numbers you otherwise only learn about when one of them runs out.
An analysis and tool showing where Claude Code tokens actually go, with the headline finding that the overwhelming majority are files being read again. Worth checking against your own transcripts before you start optimizing anything else.
A spreadsheet framework built for agents: express the model in React and export a working .xlsx with live formulas. The third medium in the series after open-slide and open-doc.
A sandbox for Claude Code where the boundaries are yours to configure, rather than accepting whatever the default permission model allows.
An ESP32-S3 display showing Claude Code and Codex usage, live agent activity, and a NEEDS YOU alert when an agent is blocked waiting on you. Backed by a pure-stdlib Mac service, with nothing leaving your LAN.
You and every agent you run write into one pad, and a note written once resurfaces the moment it is relevant. A background archivist merges, connects, and retires notes so the pad improves without curation. What one agent learns at 3am, the rest know by morning. Self-hosted, MIT.
Auto-continue for Claude Code — when you hit a usage limit it waits for the reset and picks the session back up on its own. For long unattended runs that would otherwise stop dead at 3am.
A shared local room where you and both agents work together, while each keeps its own official harness rather than being wrapped or emulated. Preserving the native harnesses is the design constraint here.
Project memory for coding agents that stays on your machine and tracks the evidence behind each remembered fact, so stale claims can be spotted rather than repeated.
Watch tool calls, model responses, token counts, and context usage across Claude Code, Codex, DeepSeek Harness, and Hermes in a single live terminal feed. Useful for spotting an agent that has gone off the rails before it burns the window.
Lightweight audit trail and policy enforcement for AI agents, pitched explicitly as a 500-line alternative to Microsofts Agent Governance Toolkit. Small enough to read end to end before trusting it.
A macOS menu bar app that finds running Claude Code and Grok Build sessions, pauses them, and frees their memory — without losing the resume id, so you can pick them back up. For laptops running more sessions than RAM.
Batch local transcription for Claude Code and any other agent, with no API key and nothing leaving the machine. For turning recordings into text the agent can work with when you would rather not upload them.
Produces evidence receipts for Claude Code and Codex sessions that fail closed when evidence is missing, and does it without an LLM judge grading its own homework. Deterministic verification rather than a second models opinion.
A terminal UI where each agent gets its own git worktree, cmux workspace, GitHub PR, and Linear/Jira/Trello ticket, all visible in one live table. Wires the agent fleet into the tracking systems the work actually lives in.
201 Slack Web API methods across 29 groups exposed as a CLI, with agent skills wrapping them and a draft-and-approve gate before anything is actually sent. The approval gate is the right call for a tool that can post to your team.
Launches Claude Code against a NIM model through a per-run loopback proxy that translates the Anthropic Messages API to NIMs OpenAI-compatible API — streaming, tools, and images included — and exits with the process. No lingering daemon.
Stores contact-form enquiries in Cloudflare Workers KV and reads them back safely behind Cloudflare Access, with audited deletes and CSV/JSON/Mailchimp/Klaviyo exports. Ships as a framework-free npm package plus a Claude Code plugin.
Shows which free models are actually live across 14 AI gateways and applies the matching Anthropic, OpenAI, or Gemini configuration to Claude Code or any client in one click.
Finds production failures agents commonly leave — hardcoded secrets, missing RLS policies, IDOR, runaway cost, hallucinated dependencies, and general AI rot — across 64 checks, then fixes the ones that are safe to fix automatically. A Claude Code plugin.
Turns Plaud voice recordings of client meetings and brainstorms into briefs that understand your repository, then files them as conventional GitHub issues. Closes the gap between a conversation and a tracked task.
Persistent project memory for coding agents built on a structured scaffold, paired with a CLI that detects when the memory has drifted from the actual state of the code.
Plannotator opens the last agent message in a browser UI where you can mark up individual questions and answers, then send the annotations straight back to the agent. The Reddit report pairs it with Matt Pocock's batch-mode Grill Me via a /plannotator-last command. More granular than a questionnaire component because you annotate parts of each question.
A free, local desktop app that surfaces where agent runs burned effort without producing results. Notably it targets business tasks rather than code, and reads sessions from Claude Cowork, Chat, and Code plus ChatGPT Work and Codex.
A capability-decay sentinel that establishes baseline success rates per capability category, then warns when a long-running agent starts degrading mid-run. Useful for unattended sessions where quality drifts silently instead of failing outright. Documentation is in Chinese.
A Tauri v2 and SolidJS desktop app that runs the real Claude Code CLI inside a PTY rather than reimplementing it. Adds panels for the terminal, a shell dock, git changes, and a file tree around the session.
A workspace engine for macOS built on pure Python 3 stdlib with no resident daemons. Sets up and switches development workspaces for both humans and AI coding agents without a background service.
An open-source agent runtime benchmarked against Claude Managed Agents on 14 cross-system tasks with the same model and three MCP services. Both solved 11 of 14, but TrueForge used 3.7M tokens versus 10M by offloading large tool outputs behind references and compacting old events. The author is candid that compaction is lossy and the runtime lacks tracing and sandboxing.
A zero-dependency local meter showing live cost, token, and quota use, with a budget gate, a burn-rate alarm for runaway loops, and a prompt-cache leak detector. Adds no text to the conversation, so it does not consume the context it measures.
A Windows tray app that mirrors each agent session to a lane on your keyboard F-row via hooks: pulsing means waiting on you, green done, red broken. Pressing a lane key brings that agent window forward. Deliberately read-only — every hook reply is empty and a test asserts the hook binary cannot print a byte. Rust, MIT, works with Claude Code and Codex on native Windows and WSL.
Long-running Claude Code Remote Control and tmux sessions self-register, and a systemd timer restores them after a reboot or crash. Ships as both a skill and a CLI.
Coordination for AI coding agents working in one repo across different people, machines, and models. State is carried on a git ref, so there is no server to run — the repo itself is the coordination channel.
A Rust API and store that collects token usage from multiple coding agents through per-harness plugins, covering Claude Code, Codex, Grok, and Hermes. Useful if you split work across tools and want one number instead of several dashboards.
Answers which AI account a machine is currently using. Register multiple subscription accounts per AI CLI, switch in two clicks, see remaining quota per account, install and update tools through vendor mechanisms, and catch billing traps. Manages accounts only and never runs tasks.
Tracks token usage across Claude Code, Codex, and Copilot CLI, storing everything locally in an encrypted append-only log. The append-only design means historical usage cannot be silently rewritten.
A fleet system where agents write code, review one another's work, and coordinate across multiple machines. Peer review between agents is the distinguishing feature versus a single agent looping on its own output.
A single-binary self-hosted gateway that keeps the harness and swaps the model, translating between Anthropic Messages, OpenAI Responses, and Chat Completions. Lets Claude Code and Codex CLI drive open-weight, self-hosted, or relay-provided models.
A macOS menu bar app and widget showing Claude plan limits, token usage, and cost at a glance. Native and always visible, so you notice quota pressure before hitting a wall mid-session.
A single bash script that launches Claude Code inside a bubblewrap namespace on an allowlist model, so your home directory and credentials are absent rather than merely denied. Uses --clearenv to drop GITHUB_TOKEN, AWS_*, and SSH_AUTH_SOCK, binds settings.json read-only at both user and managed-settings precedence so a session can't rewrite its own security config, and makes only the launch directory writable. Built for people who want YOLO mode without approving every tool call.
A native Mac app that runs Claude unattended on schedules and on event triggers — a file landing in a watched folder, an incoming email, a text message, or a new RSS entry — through an agent event queue, with each agent scoped to its own key. SMTP notifications come back when something needs attention, and you can reply like a normal email to continue the conversation. Replaces a hand-run Java/Spring MCP server so agent work continues while away from the machine.
A Docker setup for Claude Code built on a pinned non-root image with persistent login across container runs. Adds an egress firewall so --dangerously-skip-permissions can be used without giving the agent unrestricted network access. Ships compose and CI examples for dropping it into an existing pipeline.
A push-to-talk voice interface for Claude Code — hold a key, speak, and the agent answers aloud about a second later with all its tools and its own personality intact. Both speech recognition and the voice run on free local models, so no cloud speech APIs or keys are involved.
Adds persistent memory to Claude Code backed by a database you supply, so context carries across sessions. The bring-your-own-database design means no hosted service holds your project history.
A game development kit for isometric games built to be driven by coding agents rather than hand-authored. Shared on r/ClaudeCode; the post itself is a bare link, so check the project for specifics.
A harness for picking up existing Claude Code, Cursor, and Codex sessions from within Pi. Lets you continue prior agent work from one place instead of restarting each tool separately.
Maintains a single AGENTS.md and syncs it out to Codex, Claude Code, Cursor, Copilot, Gemini, Windsurf, Aider, and others. Removes the drift that comes from hand-maintaining a separate instruction file per tool.
A Claude Code statusline CLI displaying project location, model, git branch, context, cost, and usage rate, with Powerline separator support. Widgets can be toggled from within the Claude Code chat itself. Korean-language project; automatic account switching is not in the current release.
A codebase comprehension tool aimed at both humans and AI agents, surfacing system-level structure instead of raw files so you can orient in an unfamiliar repo quickly. The description stays high-level, so check the repo for how the analysis actually works.
An open-source local layer that compresses deterministic tool output and safely reuses deterministic work. A real-agent benchmark on Codex showed -14.2% tool output at equal task success (10/10), but +12.4% input tokens and +39% wall time — less terminal noise without the expected savings. The author has Claude Code integration surfaces and is looking for people with noisy TypeScript or Python repos to run a paired study.
Explains in plain English why a Mac is slow, hot, and loud by naming the responsible processes. Specifically surfaces AI tool helper processes and stuck processes that accumulate during heavy agent use.
Coordination for multiple AI coding agents working the same repo, using path claims, leases, and write-once notes. Generates a shared board readable from any terminal so each agent can see what is already claimed before it writes.
Characterizes and caps CPU and memory for AI coding agents per individual tool call, built on cgroup v2 and eBPF. Shows which specific agent actions are expensive and bounds them before they saturate the machine.
Maintains an architecture index the agent consults in place of re-scanning a large codebase, plus work state that survives context compaction. Aimed at long-lived codebases where repeated exploration burns most of the context window.
Runs your coding CLIs in a browser UI, organised by folder and held open in tmux so sessions survive disconnects. CLI-agnostic, so Claude Code and other agents share one interface.
A Windows GUI for batch-opening fixed Claude Code sessions, with archive, rename, and per-session cost and context columns. Zero dependencies beyond tkinter. Unofficial.
A self-hosted workspace that makes work-in-progress addressable, so humans and AI agents operate on the same artifacts while those artifacts are still changing. No API keys and no metered inference.
Estimates the cost of a coding job before you launch it, running entirely locally with no network and no account. Notably, the project documents that its own first prediction was off by 9x and explains why. Italian-language README.
A monitor for Claude Code usage that reports spend, context consumption and quota limits in one place. Aimed at people who want to see how much of their plan a session is burning before they hit a wall.
Practice system design interviews with an AI agent, Excalidraw diagrams and voice input. Includes company-tailored scenarios, mock interview flows and critique of the diagrams you draw.
Compresses verbose command output before it reaches the agent's context, with zero LLM calls involved. Every original output stays on disk and remains searchable and recallable if the agent needs the full text later.
A Feishu bridge that runs coding agents locally rather than through a cloud relay. Supports group collaboration with per-group @ control, multi-turn sessions, streaming cards and cross-session memory across Grok, Claude and Codex.
A keyboard-driven cockpit for running many AI coding agents at once. Adds work items, a task queue and per-panel resource caps so a fleet of agents does not swamp the machine.
A local engine that reads genome data, lab results, prescriptions and wearable data against each other to surface contradictions the individual silos never catch. Ships as a web UI, a CLI, a Claude skill and an Ouroboros plugin, with a source citation behind every answer.
A local-first CLI with 12 scanners built to catch the classes of bug that AI coding assistants routinely miss. Deterministic rather than model-based, so results are reproducible. Apache 2.0.
An external runner for headless coding agents built on a no-evidence-no-done rule. The gates live outside the agent, so every completion claim has to come with machine-checkable proof before it counts.
A TypeScript CLI and Claude Code plugin that strips watched YouTube Shorts out of your watch history. Regular videos are left untouched, so recommendations stop being dominated by Shorts.
A self-hosted workspace for coding agents with a sub/child multi-agent architecture and an AST-aware ChromaDB indexer for fast file discovery. Includes a built-in UI with Git diff management.
A quality gate that runs acceptance checks in a real browser rather than trusting the agent's own self-test. Available as a CLI, an MCP server for Claude Code/Cursor/Copilot, and a GitHub Action.
Wires the pi agent into Claude Code's native peer protocol so the two can exchange messages with ListAgents/SendMessage. No daemon and no cloud relay — Claude reaches pi with nothing extra installed on its side.
A self-hosted runtime for running Claude Code, Codex or Maestro against shared memory, skills, a secrets vault and cron schedules. Reachable from a terminal, Telegram or the Otium client.
A local associative engine that lets an agent suddenly recall something it wrote earlier. Runs without embedding or API costs.
A macOS panel that puts editor's notes, people, a gallery, anecdotes, a timeline and sources beside every Apple Music track. Supports 11 languages with a local cache.
Positions itself as a sage you consult rather than an assistant that executes. Reads your work and the work around it to advise on where to go next.
Runs Claude Code unattended to turn GitHub issues into pull requests, inside a strict containment boundary. The isolation is the point — unattended agents get a sandbox rather than your shell.
A web tool for tuning Claude Code environment flags with sliders instead of reading docs. Save presets and copy the resulting settings.json straight into your project.
A macOS Dock pet with 17 pixel-art F1 cars that race while Claude Code is working. Adds a pit-wall chat that replies to your sessions and shows plan usage stats, at zero token cost.
A containerized CLI agent for AI-assisted development, keeping agentic work inside an isolated environment rather than on the host.
A CLI framework in which Claude writes and manages its own tools on the fly, growing its capabilities over the course of a conversation.
A marketplace and plugin set adding persistent long-term memory to Claude Desktop and Claude Code, shared across AI tools rather than scoped to one client.
Lets Claude Code keep working after you leave your desk and report to your phone over Telegram. Read task summaries, reply to steer it, check usage and send voice notes — all from one bash script.
A personal management system built on daily logs, with multi-agent AI handling weekly reviews, scheduling, finance tracking and self-improvement analytics.
A visual agent for existing sites that supplies the browser and runtime context coding agents normally lack, instead of you pasting screenshots and selectors by hand. Recent releases improved grounding via server-side source maps for React Server Components and fixed packaged code search for Astro, Next.js and Vite.
An Obsidian vault the agent maintains as its memory, with hot/warm/cold tiers, size budgets, a weekly janitor pass and a typed-relation mini knowledge graph. No database and no embeddings — just markdown.
A single command that tightens the security settings on a solo developer's AI-assisted setup. Aimed at people shipping alone without a security team behind them.
A native macOS front end for the Claude Code CLI exposing its full agentic toolset — shell, file edits, search and sub-agents. Runs on Anthropic's models or a local Ollama LLM, including one hosted on another machine.
A horizontal canvas for terminal panes where windows sit side by side at full size instead of splitting into unreadable slivers. Built for workflows running several coding agents alongside dev servers and SSH shells.
A COSMIC desktop panel applet showing active Claude Code sessions plus 5-hour and weekly usage limits. Reads local files only — no network requests and no credentials. Unofficial.
Narrates Claude Code's responses aloud using a Qwen TTS model running on your own machine. No cloud, no API key, no account, and no audio ever leaves the computer.
A coordination bus for several agent sessions working in the same repository at once. Addresses the collision problem you hit when parallel agents touch overlapping files.
A Claude Code plugin framework modelled on oh-my-zsh, bundling 11 agents, 36 commands and 15 skills. Includes six layers of security hooks and installs in about five minutes.
A Feishu/Lark plugin that lets a single bot fan out multiple group chats to separate, isolated Claude Code instances, managed by an auto-router. It adds access control, a persistent WebSocket connection, and automatic fallback to OpenCode when Claude is unavailable. Useful if your team already lives in Feishu and wants to drive coding agents from chat without one shared session.
A terminal switchboard for running several Codex and Claude CLI accounts side by side, each with isolated credentials and its own persistent tmux session. Handoffs between agents are recorded so you can see what was passed where. Aimed at people juggling quota across accounts or mixing agents on one machine.
Connects Claude Code to Obsidian through the /ide integration, but sends far more than the raw note: embeds are inlined, wikilinks are summarized, and the heading path plus backlinks are included. The result is that the agent sees a note in the context of its graph neighborhood rather than in isolation. Handy for vault-driven work where the surrounding links carry the meaning.
A free, no-tracking SSH client for iPhone and iPad, built with Claude Code and aimed at driving coding agents from mobile. It includes voice mode, git change tracking, a file viewer, and support for tmux and other multiplexers, so a Claude Code session on a home machine can be reached over Tailscale from a phone. Source is on GitHub and the app is on the App Store.
A Claude Code plugin marketplace that narrows its scope to software engineering work instead of trying to cover every domain. Installable through the standard plugin marketplace mechanism. Useful if you find the general-purpose marketplaces noisy and want a shorter list of dev-focused plugins.
A lightweight Go AI gateway that speaks both the OpenAI and Anthropic protocols from one static binary, positioned as a smaller alternative to one-api, new-api, and LiteLLM. It handles automatic routing, load balancing, retries, and cost-priority routing with failover so a client stays up when one upstream degrades. Relevant if you point Claude Code at multiple providers and want a single endpoint in front of them.
A toolchain aimed squarely at the entropy LLM-assisted development creates — clone detection, duplication, dead code, and structural judgment — with a Haskell analysis core and a Rust frontend. It ships Claude Code guard hooks, an MCP interface, CI gates, and a Tauri GUI, so the same judgment can run interactively or block a merge. Notable for treating agent-generated sprawl as a first-class problem rather than a linting afterthought.
A small VS Code extension that plays one sound when Claude Code finishes a task and a different one when it is waiting on you. The two-tone distinction is the point — you can tell from across the room whether the run completed or stalled on a permission prompt. Minimal setup, no external service.
Prevents a MacBook from sleeping while Claude Code or Codex is running, including with the lid shut, then lets it sleep again as soon as the agent stops. The conditional behavior is what separates it from leaving caffeinate running — the machine is only held awake for the duration of actual agent work. One of several tools in this space; pick whichever matches your menu-bar preferences.
Pulls email, Teams, Slack messages, and reports into a single local timeline, runs AI triage over them, then dispatches the resulting work to coding agents like Claude Code, Codex, or Gemini — with you approving before anything lands. Everything runs locally rather than through a hosted service. An ambitious take on wiring a whole inbox into an agent loop.
A job-search workspace built around the rate-apply-track loop: find roles, vet them, tailor materials, track applications, and prep for interviews, all driven from a chat interface backed by your own AI CLI. Bring-your-own-agent rather than a hosted service, so the search history stays local. Useful mainly as an example of a domain workspace built on top of a coding agent.
An open-source desktop client for Claude Code built on Tauri 2 and React, talking to the agent over the SDK control protocol rather than scraping a terminal. Features include permission-approval cards, model switching, multi-tab sessions, and video analysis. One of the more complete GUI wrappers, though the docs are in Chinese.
A local bridge that lets you run coding agents by voice through ChatGPT Live, controlling tmux to launch, close and coordinate Claude Code and Codex CLI sessions. It announces when a session stops and relays your spoken replies back into the terminal. Runs on a ChatGPT subscription with no API key, so it is a cheap way to supervise long agent runs hands-free.
A VS Code / Cursor extension that reads your local Claude Code session transcript and renders a short plain-English summary in a side panel: what you asked for, what changed, what to check, what is unfinished. Bring your own OpenAI or Anthropic key, stored in the OS keychain, with file contents stripped before sending and no middle server. Open source and on the marketplace.
A Go TUI that manages one agent session per git worktree, so parallel Claude Code or Codex runs never fight over the same working tree. Each session is a tmux pane you jump into with a single keypress. Handy when you routinely branch several agent attempts off the same repo.
A dashboard that visualizes coding-agent session history and quota consumption across providers, with heatmaps, token counting, cost tracking and quota reset timers. Aimed at people who want to see where their tokens actually went rather than just how close the limit is. Complements menu-bar meters with longer-range analytics.
A macOS menu bar app showing live plan limits, an activity calendar and token metrics for both Claude Code and Codex in one place. Written in native SwiftUI with no telemetry. Pick this over the other quota meters if you want the activity-calendar view alongside the current-window gauge.
A group-based usage tracker: create a club, share a join code, and see how much Claude Code everyone is burning through. It turns quota monitoring into a shared leaderboard rather than a solo gauge. Mostly for fun, though useful for teams gauging relative consumption.
An open-source coding-agent desktop app that brings Claude Code-class workflows and multi-agent fleets to a bring-your-own DeepSeek API key, which the author pitches at roughly 1/50th the cost. Worth a look if you want the agent workflow shape but need a cheaper model backend.
tart (tartifacts) lets an agent build a live terminal dashboard — a manifest, a fetch script, and a render script — that updates in place rather than repeating state back to you in chat. Install with `uv tool install tartifacts` and point the agent at `tart --skill`; pairs well with tmux, agent in one pane and dashboards in another.
A small utility for flipping between different Claude Code accounts without manually juggling credential files. Handy if you keep personal and work subscriptions separate, or hit limits on one and want to move over cleanly.
A Neovim plugin that runs the official Claude Code CLI in a terminal window and feeds the agent editor context through hooks, so each prompt carries a fresh snapshot of the cursor position or selection. It also exposes scripts that let the agent move the cursor in your Neovim session. Works with Claude Code and Codex with minimal configuration.
VibePod runs coding agents such as Claude Code, Codex, and Qwen Code inside containers. Version 0.20 adds credential profiles, so a subscription login, an API-key setup, and a local Ollama config can coexist and be selected at run time with vp run claude --profile work. Only credential directories swap; skills, config, and logging stay shared, and projects can pin a profile.
A local-first CLI that enriches coding agent session transcripts with tool error categories, skill activation outcomes, token cost attributed to merged PRs, task complexity, and re-steer themes. Some signals are derived statically from transcripts, others via Haiku-class LLM-as-judge processors. Run it with npx tuneloop@latest analyze to answer questions like how much spend went into a given PR.
Reads the coding agent session logs already sitting on your disk and reports cost, cache efficiency, and tool-call effectiveness across Claude Code, Codex, and others. No server and no account required, so nothing leaves the machine. Useful for spotting where tokens and cache misses actually go.
Build one master resume, then generate a resume and cover letter tailored to each individual job posting. Removes the manual copy-edit loop of maintaining many near-identical documents. A practical, self-contained agent-assisted tool.
Scans a GitHub org and produces an evidence-backed map of each repo: what it is, how to run it, what it talks to, and where it deploys. Adds daily and weekly digests plus a single shared memory handed to Claude Code and Cursor at session start. Built on bash, gh, and jq with no daemon or database.
A desktop wrapper that spins up git worktrees by default, groups sessions by repo, lets you name sessions and assign tasks, and launches reviewing agents. Aimed at orchestrating several Claude Code agents without scattering them across a pile of terminal windows. Free, and built with Claude Code running multiple agents in parallel worktrees.
I run CLI coding agents in the terminal all day, and over months I kept extending the terminal to get more out of them. Now I have a terminal but not just a terminal, and I use it daily for all my ...
I’m looking for a simple way to use Claude Code and Codex together on the same project, ideally with shared context and an actual back-and-forth between them. I’d like to be able to say things like...
One place to install AKA Security's tools for coding agents — Claude Code, Codex, and more.
From Opus 5, I feel frustrated reading the output. Sometimes, I have to jump in to steer it in the right direction. I was close to switching. I have some coding background, so I tried to dig into t...
Comprehensive cross-platform toolkit for Claude Code
https://preview.redd.it/2z2mijf4i2kh1.png?width=3360&format=png&auto=webp&s=21ba714d00b59fa1c551bc188516488947b40343 Anthropic recently added an interesting feature to allow Claude Code sessions to...
High-performance local 3-in-1 gateway unlocking Google Gemini as standard OpenAI, Anthropic (Claude Code), and Gemini API endpoints for coding agents, IDEs, and tools.
Something I've been working on for the last few months, with Claude doing most of the donkey work. The process has been mostly a cycle of specs and plans with Superpowers via Fable, then implementi...
I'm looking for help with good prompts or skill files that can be used to create modern and clean UI that uses image resources (through direct search) as part of my web development workflows I'd ap...
I follow this sub since I would like to see what kind of projects other people use claude code for, how they configure their workflow, claude.md tips, what kind of hooks people are doing and so on ...
CLI tool to bootstrap and manage Claude Code harness configuration for your projects
Been using claude code on my own project every day for months now and the thing that actually broke my flow wasnt the model, it was the handoff between sessions. CLAUDE.md drifts out of date the se...
Open-source workspace manager for AI coding CLIs: Claude Code and ChatGPT Codex in one browser app. Discovers every session on disk, embedded terminals, phone-ready, cost tracking, kanban, docs. Wi...
I’ve been building **Claudey** — a local manager that lets you use **Claude Code** (same tools, Task subagents, agent teams, /model) against **Antigravity, Codex, and/or Grok** subscriptions via a ...
Skills for Claude to work with UK planning applications — retrieve documents from council portals, triage the grounds, and draft well-founded representations on ecology, transport, heritage and flo...
Claude Code·Codex·Grok·Gemini·Z.ai GLM의 quota와 reset을 한곳에서 확인하는 로컬 우선 macOS 메뉴 막대 앱 | Local-first macOS menu bar app for monitoring AI coding-agent quotas and reset windows
Remote-control your own coding agents. Send a task from your phone; your home PC runs GitHub Copilot CLI or Claude Code on your local repo, runs your tests, and reports back. Telegram + installable...
Lately every time I’ve been using opus has been extremely painful. It does not act like fable or GPT. Even just using it for small things felt buggy with random Chinese characters showing up and it...
Herdr-backed task dispatch for Claude Code: run implementation work in a session rooted in your app's own directory, single-app or across a monorepo
A Windows desktop app that fronts Claude Code, Codex, and other ACP agents working across an Obsidian vault and code projects. Provides persistent chats, visible tool use, approval prompts, embedded terminals, and usage analytics in one window. Useful if you juggle several agents and want a single control surface instead of scattered terminals.
A small utility that prevents sleep exactly for the duration of a Claude Code turn, then releases the lock. Avoids the usual blunt fix of disabling sleep entirely or leaving caffeinate running all day. Handy for long unattended runs on laptops.
A CLI that gives Claude Code your team's accumulated context, enforces coding standards across sessions, and records which agent version produced which change. Aims at the audit and consistency problems that show up once several engineers run agents against the same repo. CLI-first, so it slots into existing scripts and CI rather than requiring a UI.
Reads Claude Code and OpenCode session data already sitting on disk, grades each run against the repository, and flags whether the run should have been stopped earlier. No LLM calls, no telemetry, and zero runtime dependencies — it is pure local analysis. Good for auditing where long autonomous sessions went off the rails.
A macOS development environment built around terminal agents rather than a traditional editor. It supports Claude Code, Codex, OpenCode, and any TUI agent, giving them a shared home instead of scattered terminal tabs. For people whose main IDE has effectively become the agent.
An unofficial MIT-licensed toolkit letting long-running AI agents coordinate through their human owner Fulcra account — a shared bus, cross-model reviews, session continuity, and load balancing. The account becomes the coordination substrate between otherwise isolated agents. Niche, but an interesting take on multi-agent state.
Runs Claude Code, Codex, or any terminal agent from a Telegram topic, mapping one topic to one tmux session. It watches the context window and the 5-hour limit, compacts before hitting the wall, and holds prompts through a lockout instead of dropping them. Python standard library only, with no relay server in between.
A desktop control panel for running four Claude Code agents at once on the same project, with a voice and text PM agent coordinating them. You direct the PM, which distributes work to the four workers. An unusually concrete take on parallel agent orchestration with a real UI.
Builds a structural map of your repository so the assistant starts with an overview rather than grepping blindly through files. The intent is fewer wasted tool calls and better navigation on large codebases. A lightweight alternative to full semantic indexing.
A zero-setup, agent-first visualizer that renders agent runs as a graph so you can see how a session actually branched. Covers Claude Code sessions and workflows without configuration. Useful for understanding where subagents were spawned and where time went.
A visual "pixel office" where inexpensive models work the night shift and you play boss, delegating small tasks to any model behind an OmniRoute gateway. The game-like floor view makes background delegation legible instead of invisible. A playful UI over routine model routing.
A Claude Code agent that edits vertical 9:16 video using Remotion, with a single edit.json driving the whole render. A frame gate and ten hard checks stop it from shipping footage it has not actually inspected. A rare example of an agent working in a visual medium with real verification.
Converts large context into dense PNG pages that models read as images, claiming 59-70% cost reduction with full read accuracy. Ships per-provider billing math for Anthropic, OpenAI, and Gemini, fail-closed gates, and published benchmarks. Available as a CLI, a proxy, and Cloudflare Workers — worth verifying the savings claims on your own workload.
Tracks live token costs, sessions, tool calls, and cron runs across more than twenty agent runtimes including Claude Code, Codex, Cursor, Aider, and Goose. It requires no configuration and adds a governance layer on top of raw metrics. Useful if you run several different agents and want one place to see them all.
A local-first visual task graph meant to keep a human and their coding agent looking at the same plan. It tracks goals, progress, reasoning, and the next action in one view. Useful when long agent sessions drift and you want a shared source of truth for what is done and what is next.
Your agent can read git log but not the shell commands you tried that failed. NexusMem indexes shell history with exit codes, git commits and diffs, and project docs into a local SQLite database, then serves back a token-budgeted slice on demand. No cloud service and no account required.
A multi-frontend relay that lets you drive coding agents from chat instead of a terminal. It supports Claude Code, Codex, local agents, and AG-UI agents behind Discord or Microsoft Teams frontends. Handy for kicking off or checking on agent work from a phone.
A local voice room where several coding agents — Claude Code, Codex, Gemini CLI — sit together and answer out loud, each with its own distinct voice. No API keys are needed since it drives the CLIs you already have. An unusual take on comparing agent answers side by side.
A hand-curated, continuously updated directory of Claude Code plugins, skills, and agents. Entries are published in a machine-readable format, so it can be consumed by tooling rather than only browsed. Useful as a discovery source when you are hunting for an existing skill instead of writing one.
An installer that gets Claude Code running from scratch on Windows and macOS. It bundles Node.js and Git, a Windows Terminal theme, a live status bar, a folder picker, right-click launch, and named profiles with flags. Aimed at people whose first blocker is environment setup rather than the tool itself.
An Electron desktop app that sits one layer above your AI coding tools and coordinates them from a single place. The pitch is that the tools themselves are good but managing several of them is a mess. Worth a look if you routinely juggle multiple agent CLIs.
Reads your local Claude Code logs and surfaces the recurring patterns that quietly consume tokens. It runs entirely offline with no LLM calls and no dependencies, so nothing about your sessions leaves the machine. A diagnostic rather than a limiter — it tells you what to change.
A cross-platform C#/.NET CLI that treats individual files like packages: keep instruction files, hooks, coding rules, and unpublished skills in any repo or gist, and map remote paths to local destinations per machine. "check" shows what has updates and "pull" installs them, with conflict detection and a diff when both sides changed. Fits the case where full clones and symlink farms do not, because each machine needs only a subset.
A zero-configuration setup layer that gets Claude Code and Codex into a working flow without hand-editing config. Aimed at removing the initial setup tax when starting on a new machine or a new project. Small in scope, quick to try.
A linter for agent skill definitions, auditing the SKILL.md and AGENTS.md files consumed by Codex, Cursor, and Claude Code. Instead of finding out a skill is malformed when an agent silently ignores it, you get static errors up front. Fills a genuine gap now that skill files are numerous enough to rot.
An additive overlay that points Claude Code at local Apple Silicon MLX models through vllm-mlx. Your private configuration stays local and the overlay does not disturb your existing setup. Useful for offline work or for keeping sensitive repos off any API.
A macOS app for asking questions of your data in plain language, driven by CLI agents you already have — Claude Code, Codex, or pi — rather than a hosted model. Built with Tauri and Rust and licensed Apache-2.0. Local-first, so the data does not leave your machine to be queried.
Breaks down Claude Code token spend, context growth, and cache behavior across projects, agents, and sessions. Rather than a single usage number, it shows which project or subagent is responsible for the burn. Pairs well with any effort to trim a workflow that has quietly gotten expensive.
Hold a key, describe the task, release, and punctuated text lands in the terminal; a second binding sends it. Recognition is on-device and CPU-only, so client code and unreleased work never transit anyone cloud. Two details matter for agent prompting specifically: spelled-out acronyms collapse ("m c p" becomes MCP) and a user dictionary covers project jargon, with no AI rewriting of what you said.
Watches your local Claude Code logs and reports usage cost, firing alerts when you cross configured thresholds. Everything is derived from local log files, so no account access is needed. A small, focused tool for people who keep hitting limits without noticing.
A self-hosted, open-source dashboard for monitoring and controlling AI coding agents from one place. Rather than tailing several terminals, you get a hub view of what each agent is doing. Useful once you routinely run more agents than you have screen space for.
A study kit for the Claude Certified Architect Foundations exam: 30 task statements across 5 domains, 98 linked wiki notes, and 90 original practice items. Every wrong option is tagged with one of seven named distractor families, and the diagnostic ranks which family you pick by rate rather than raw count. That ranking is the point — it names the kind of mistake you keep making.
A terminal UI for managing parallel background sessions across Copilot, Claude Code, Codex, Qwen, Gemini, and Kimi. It adds cross-session search and AI-suggested grouping so a dozen sessions stay navigable. Aimed at people who run agents in bulk rather than one at a time.
When a session needs your eyes, it publishes a local interactive HTML board where you can comment on any element, and widgets let the agent request specific decisions — everything you annotate returns as structured feedback. It runs as a local daemon backed by SQLite and ships with a Claude Code skill. Templates cut both publish time and tokens (roughly 2x faster at half the cost in the author evals), and it supports round diffs, diagrams, Excalidraw whiteboards, and themes.
A two-line ANSI statusline for Claude Code showing git and Kubernetes context, rate-limit bars, service health, and AI session topics. The rate-limit bars and service health make it more operational than most statuslines. Suited to people running Claude Code against live infrastructure.
An open-source platform for orchestrating coding-agent workflows powered by Claude Code, with GitHub App integration. It provides real-time observability into running workflows and can be self-hosted. Aimed at teams wanting agent runs tied to repository events rather than launched by hand.
A semantic context compiler that assembles the smallest useful slice of a codebase for a given task. It has zero dependencies and is deterministic, so the same task produces the same context every run. Directly targets the token cost of dumping too much of a repo into an agent session.
Analytics over your git history and AI-assisted work across CLIs, IDEs, and APIs, written in Rust for speed. Data is stored as open JSONL and there is zero telemetry. Useful for seeing how much of your output actually comes through agent sessions.
One screen for all your background coding agents, porting the Claude Code agent view to opencode, claude, and copilot. It gives non-Claude tools the same fleet overview Claude Code users already have. Handy if your background work is split across more than one vendor CLI.
An aggregator that indexes and retrieves SKILL.md files from pluggable sources. Instead of hunting through repos, you query one index for the skill you need. Complements skill directories by being something you run yourself over sources you choose.
Paces Claude Code background work against its own usage windows, so unattended jobs give up budget when you need it interactively. Without this, a long background run can consume the allotment you were saving for real work. A scheduling answer to the usage-limit problem rather than a measurement one.
A fast local workspace that hosts Claude Code, Codex, Gemini CLI, Kimi Code, Qwen Code, DeepSeek, OpenRouter, and your shell together. From Ultralytics, so it comes with some expectation of maintenance. Useful when you want one surface across every agent CLI you use.
Keeps at least one remotely-attachable Claude Code session alive on a Debian server, surviving reboots and manual kills. You can attach over SSH and tmux or through Claude Code Remote Control from the web or phone. Aimed at treating a server session as always-on infrastructure.
An open-source agentic coding CLI written in Rust that plans, thinks, and executes against any LLM backend rather than being tied to one provider. It is designed to be compatible with Claude Code workflows, so existing project conventions and habits carry over. Useful if you want a native-binary agent or need to run coding agents against self-hosted or alternative models.
A dashboard that renders parallel AI coding work as a navigable spatial map of branches, results, approvals, and notifications. It supports Claude Code alongside Codex and OpenClaw, so multi-agent and multi-tool runs land in one view. Aimed at people running several agent sessions at once who lose track of what finished, what is blocked, and what needs a decision.
A macOS and Windows desktop app that live-monitors Claude Code, Cursor, and other agents, surfacing runaway sessions before they burn through budget. It also manages MCP server configuration and applies context-reduction to cut token usage, with processing done on-device. Source and releases are both published. Note the 40-70% cost-reduction figure is the project authors own claim.
A cross-platform tool for keeping multiple coding-agent profiles isolated, so separate accounts for Claude, ChatGPT, and Codex can run at the same time without clobbering each others credentials or config. Works on macOS, Windows, and Linux. Practical if you switch between personal and work accounts, or run several agents concurrently.
A local-first second brain for athletic performance and physical and mental health, built on an Obsidian vault driven by Claude Code with no cloud RAG. It emphasizes statistically honest biometric analysis and adversarial claim-checking, so the agent pushes back on weak inferences from noisy personal data rather than confirming them. A good reference for privacy-sensitive personal-data agent setups.
A mod for the programming game The Farmer Was Replaced exposes a local REST API so an agent can play it headlessly, paired with skills that contain no hints or example strategies. Claude Opus wrote an initial script from the game rules alone, then Claude Fable iterated it into a top-3 leaderboard entry. A clean testbed for measuring agent capability on an unfamiliar task with a real scoreboard.
A development environment built around one developer running multiple coding agents, supporting both Claude Code and Codex CLI. It manages git worktrees, plans, and multi-commit review in one place so parallel agent work stays reviewable. Everything runs locally with no hosted service.
A Vite plugin that injects an AI dev agent directly into your running application, giving it chat, page control, and the ability to run live tests against the real UI. Instead of describing a bug, you point the agent at the page where it happens. Useful for frontend debugging loops where reproducing state in a test harness is the slow part.
Puts an animated Pokemon sprite in a terminal pane next to your Claude Code session. The sprite rests while Claude waits for input and animates while it is working, giving you an at-a-glance status indicator from across the room. Pure ambient fun, but a genuinely readable signal for long unattended runs.
Reads the prompt history already sitting on your machine from every AI CLI you use and puts it behind one searchable TUI. No indexing service, no dependencies, nothing uploaded. Solves the recurring problem of knowing you wrote a good prompt once but not remembering where.
A launcher that indexes skill directories across roughly 19 known agent CLIs and copies a one-line 'read this SKILL.md and follow it' prompt to your clipboard. No install step, no restart, and it works inside a conversation you already have open. Also lists past sessions across CLIs and copies a claude --resume command. Rust, macOS, Apache-2.0.
Organizes multi-agent work as tmux panes and windows, spanning Claude Code, Codex, and Antigravity in one workspace. Because it is tmux-native it survives disconnects and works over SSH without extra machinery. A lighter-weight alternative to purpose-built agent dashboards.
Parses local agent logs into a cost and token report, so you can see which sessions and tools actually consume your budget. Zero network by default — nothing leaves the machine. Apache-2.0 with no dependencies.
A live view into an in-progress Claude Code turn showing the context window filling up, the subagent tree as it branches, and where tokens are being spent. Reads the local logs only, so nothing leaves your machine. Genuinely useful for diagnosing why a long turn stalled or blew its context.
Renders Claude Code, Codex, and Gemini sessions as tiny pixel-art office workers who type while working, take coffee breaks when idle, and visibly get blocked. Runs in the browser in real time. A playful status dashboard that happens to make multi-agent state legible at a glance.
Sends task-completion notifications to your phone through ntfy.sh and lets you answer the agent's questions and permission requests with a tap. Covers both Claude Code and Codex. Documentation is in Chinese. Turns a long unattended run into something you can supervise away from the desk.
A multi-pane terminal workspace for AI coding CLIs, backed by a shared task and memory MCP server and swarm-style multi-agent orchestration. The shared memory server is what lets panes coordinate rather than duplicate work. Fits the growing category of terminal-native agent workspaces.
A filesystem-native daemon that consolidates, extracts, and organizes markdown memories through pluggable LLM backends. Memory stays as plain files you can read and version. Addresses the drift problem where agent notes accumulate without ever being reorganized.
A study repo reconstructing Claude Code's internals, architecture, and design patterns from original pseudocode and technical analysis. Useful for understanding why the agent behaves as it does, not for running anything. Joins several existing source-exploration efforts on the board.
Takes issues from your tracker and drives a coding agent through to a pull request, letting you pick which agent and model handle the work. Source-available under FSL. Aimed at teams who want ticket-to-PR automation without locking into one vendor's agent.
Orchestrates Claude Code, Codex, OpenCode, and pi from a native macOS app, from Telegram/Discord/iMessage, or by voice. Provides per-project workspaces, worker teams, flow graphs, and parallel runs. Local-first and MIT licensed.
A local scanner that points at a repo worked on with Claude Code or Codex and reconstructs a report on the build: sessions, model usage, turning points, and build patterns. The author used it on its own development to see what the process actually looked like. Interesting if you want retrospective visibility into agent-assisted work.
Renders images, video, PDFs, code, and diffs from inside AI coding CLIs that cannot display them. Works with Claude Code, Codex, Gemini CLI, and Hermes. Removes the constant context switch to another window just to look at an asset the agent just produced.
An open-source workspace that runs Claude Code or Codex across your tools, apps, browser, and files with shared memory between them. Ships 100+ integrations plus MCP support, with built-in models or bring-your-own-key. Positions itself as the surface where several agents share one context.
Bridges the gap between agents generating web code and agents understanding what that code actually does at runtime. Provides runtime perception of the running application rather than only static source. Relevant if your agent keeps writing frontend code it cannot verify.
A macOS mission-control surface for running Claude Code, Codex, and teams of coding agents. Open source. One of several recent takes on managing many concurrent agent sessions from a single pane.
A git diff for repository instructions that shows how a change to AGENTS.md or CLAUDE.md propagates across Codex, Claude Code, Gemini CLI, and Copilot CLI. Makes instruction edits reviewable instead of guesswork. Particularly relevant for shared repos where several agents read the same files.
Shows quota, token consumption, burn rate, and reset time for Claude, Codex, and Grok in a single terminal gauge. Consolidates what would otherwise be several separate usage checkers. Handy on subscription plans where the weekly limit is the real constraint.
Breaks down AI coding agent spend across tasks, branches, models, and individual files. Runs locally with a dashboard on 127.0.0.1:4976 and no telemetry. More granular than a plain token counter, which helps when attributing cost to specific work.
Alibaba's OpenTelemetry instrumentation plugins for JavaScript-based coding agents, collecting traces, tool calls, and LLM metrics from Claude Code and OpenClaw. Requires no code changes to the agent. Notable for bringing standard observability tooling to agent sessions.
A Windows desktop panel and taskbar badge showing Claude subscription limit usage across several accounts at once. Reads usage by asking the Claude Code CLI rather than scraping credentials. The multi-account support sets it apart from similar widgets.
Runs Claude Code, Codex, Copilot, Cursor, and Grok CLIs in parallel with every approval prompt surfaced in a single browser tab, including from your phone. Solves the practical bottleneck of parallel agents: being present for each permission request. Mobile access makes long runs less tethering.
Scans deployed apps or repos from Lovable, Bolt, v0, and Base44 for exposed secrets, open Supabase RLS, Firebase leaks, and missing headers. Also ships a deterministic prompt gate that blocks a 'disable RLS' instruction before your agent acts on it. The prompt gate is the notable piece, catching the mistake before it ships.
Claude Code loses a project's memory when you move or rename its folder; commonbook binds memory to the repo's git identity instead. It also recovers notes already orphaned by a past move. Fixes a specific, well-known annoyance rather than reinventing memory.
Calculators estimating spend across Claude Code, Codex, Cursor, and Copilot, including prompt caching effects and team budgets. Estimation before the fact rather than reporting after it. Useful when deciding between subscription tiers and API billing.
Deterministically detects overly complex prose in coding-agent responses and asks the same agent for one clearer rewrite. Built in response to the dense, abstract paragraphs recent models produce. The author's argument: cognitive effort should go to the problem, not to decoding the answer.
Runs many Claude Code and Codex CLI sessions in parallel on macOS from a keyboard-driven dashboard. Optimized for switching between sessions without reaching for the mouse. One of the leaner entries in the crowded session-manager category.
Creates a set of AI teammates that collaborate over shared context, supporting Claude Code, Codex, OpenClaw, OpenCode, and local LLMs. The shared context is the design point, keeping teammates from re-deriving the same facts. Local LLM support helps for cost-sensitive background work.
A cross-platform second brain built as an Obsidian vault that Claude Code drives, using hooks to carry memory between sessions. Notes stay in plain Markdown you can read without the agent. Appealing if you already live in Obsidian.
A desktop workspace running Claude Code, Codex, OpenCode, and Gemini CLI side by side, with every task isolated in its own git worktree. MIT licensed, local-first, and no telemetry. Worktree-per-task is the right default for parallel agents touching the same repo.
Makes agent file edits deterministic by anchoring them to SHA-256 hashes, routing through a three-tier AST, hash, then diff strategy. Targets the class of failures where an edit lands in the wrong place after the file shifts underneath it. Technically the most interesting edit-reliability approach in this batch.
Manages all your macOS AI coding agents from a Dynamic Island-style overlay. Keeps agent status ambient rather than requiring a dedicated window. A lighter-touch alternative to full dashboard apps.
Lets Windows users switch Claude Code between Anthropic and any 9Router provider, with both terminal and VSCode support. Windows-first tooling remains comparatively rare in this ecosystem. Useful if you route requests across providers.
A macOS menu bar app for browsing and resuming past Claude Code and Codex sessions. Makes session history navigable instead of relying on remembering a directory. Minimal footprint compared to full dashboard apps.
Shows remaining Claude and Codex capacity from the macOS menu bar. Native rather than an Electron wrapper, so it stays out of the way. Fills the macOS slot alongside the Windows and terminal-based quota tools.
Compares installed Claude Code plugins against your desired set, updates them, and prunes stale caches. Turns plugin management into a declarative reconcile instead of manual upkeep. Increasingly needed as plugin counts grow.
A self-hosted web interface giving Claude Code persistent, resumable chats on your own server, reachable from any browser. Supports forking and rewinding a conversation. Self-hosting keeps session history under your control.
Routes prompts by type: coding tasks to Claude Code, simple questions to a local model, and deep questions to OpenRouter. Keeps expensive models for work that needs them. Straightforward cost control for mixed workloads.
Runs Claude Code, Codex, Copilot, and Kimi in parallel from the shell, each session on its own git worktree and branch. Attach, detach, and reattach as with tmux, and sessions keep working after you disconnect. Survives disconnection, which matters for long unattended runs.
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.