AI Coding

DeepSeek Harness237.2k★

DeepSeek Harness is DeepSeek's own agent runtime, the layer that sits between a model and your machine and gives it tools, memory, skills, and an interface. The architecture is one idea taken all the way: everything is a plugin, built on top of Cordis, so pieces get swapped rather than forked. MIT licensed and free. Running it is one command, npx @deepseek-ai/dsh web, which needs Node and serves a web UI on 127.0.0.1 port 3080. Building from source is a pnpm install and build. There is no server to operate: it runs on your machine and calls out to whichever provider you configure. A plugin ecosystem formed within days of launch, including native desktop wrappers and a terminal UI, all discoverable through the dsh-plugin topic on GitHub. The harness costs nothing and the model calls are the only bill. DeepSeek's own API is cheap by frontier standards, and it charges roughly half rate outside its weekday peak window. Solo developers: free, and worth an evening if composable systems appeal to you. Small teams: free, but pin your version and mean it. Large teams: watch it rather than standardize on it. The catch, and DeepSeek puts it in capital letters in their own README: this is a developer preview and there will be compatibility-breaking changes. The plugin API you build against this month may not exist next month. The popularity is real and so is the churn, so treat anything you write on top of it as disposable until the interfaces settle.

opencode210.3k★

opencode is an open-source AI coding agent that lives in your terminal. It is built by Anomaly, the team behind SST, and it is the project now hosted at opencode.ai (the old sst/opencode repo redirects here). Bring any model provider, Anthropic, OpenAI, Google, GitHub Copilot, or a local model, and it reads, writes, and edits files and runs shell commands from a clean TUI. MIT licensed. The design choice that sets it apart is a two-agent flow: a plan agent that only reads and analyzes, and a build agent that actually makes changes, so you review the plan before anything touches your code. It pulls in LSP diagnostics as it works. Install is trivial through npm, Homebrew, or a one-line script, with no Docker and no GPU. Supply an API key for a hosted model, or point it at a local one and run for nothing. The agent is still free and there are still no feature gates, but Anomaly now sells model access too. Zen is their gateway of models they have benchmarked for coding agents: pay per token with no subscription, several models free for now, GPT 5.6 Luna at $0.20 in and $1.20 out per million tokens under 272K of context, Claude Opus 5 at $5.00 and $25.00, GPT 5.5 Pro at $30.00 and $180.00. Balances auto-reload $20 when they drop below $5, and card processing of 4.4% plus $0.30 is passed through at cost. There is an enterprise track as well. Solo developers with existing API access should keep using it exactly as before. The catch is the model bill and the terminal-first workflow. opencode is free, but the models it drives are not, and heavy use adds up the same way a subscription would. For a graphical editor experience this is not it. It is a TUI first, with a desktop app still in beta.

codex126.7k★

Codex CLI is OpenAI's coding agent for the terminal. Point it at a repo and it reads files, writes code, and runs commands while you approve each step or let it run. The client is Rust, Apache 2.0, and free to install with a single command. There is nothing to host. The sandboxing is real rather than decorative: Seatbelt on macOS, bubblewrap on Linux and WSL2, with an approval mode that asks before the agent reaches the internet. The escape hatch is the part worth knowing about. Run codex with the --oss flag and it drives Ollama or LM Studio on your own machine, and the provider config accepts any OpenAI-compatible base URL. Anyone already paying for ChatGPT gets this at no extra cost. Teams weighing it against Copilot or Cursor should know it does no inline completion. It is a terminal agent plus an IDE extension, not an autocomplete engine. The catch is what Apache 2.0 actually covers. The license is on the wrapper, not the model. Codex runs on every ChatGPT tier including Free, but free buys you quick tasks and little else, and real work pushes you up through Go at $8 a month, Plus at $20, and Pro from $100. What the tiers sell is volume, not access. You can read and fork the client all you like; the intelligence behind it stays metered.

orca79.1k★

Orca runs a fleet of coding agents side by side so you can pick the winner. Point it at a task and it spins up several agents (Claude Code, Codex, OpenCode, whatever you already use), each working in its own isolated git worktree, then you compare the diffs and merge the one that got it right. It is a desktop app for macOS, Windows, and Linux, MIT licensed, and free. Running it is a download. Point it at CLI agents you already have and it handles the worktree juggling, terminal splits, a built-in browser, GitHub and Linear integration, and a tracker for Claude and Codex usage limits. Your real cost is the agent subscriptions: Orca drives tools you already pay for and never sits between you and the model. A mobile companion kicks off runs from your phone. For a solo developer who runs one agent at a time, this is a workflow upgrade the day you install it, and it costs nothing. Small teams get the same benefit per person. Larger teams can run an always-on Orca server inside their own network, and Orca Enterprise is available by contact with no published price. The catch is that parallel agents multiply your token spend fast. Running five agents on the same task means paying for five attempts to keep one. That math works when the task is hard and wasteful when a single agent would have nailed it. Deciding when the fleet is worth it is on you.

oh-my-openagent69.5k★

Oh My OpenAgent (OMO) is an enhancement layer for coding agents like Claude Code, OpenCode, and Cursor. Instead of one agent doing everything, it splits work across specialized sub-agents, a planner, a builder, an orchestrator, that run in parallel and hand off to each other. One command turns the whole crew loose on a task until it's done. It's free to use, but the license is the Sustainable Use License, which limits you to internal business or non-commercial use. That is not open source. The pitch is that orchestrating several models beats betting on one. It adds parallel team mode with tmux panes so you can watch agents work, content-anchored edits to avoid stale-line mistakes, and built-in web search and docs lookup. Setup is light: it's config files dropped into your project, not a service to run. It works best if you already live in an agent harness and want more horsepower. Solo developers and small teams get the most out of it. Larger teams should test it on throwaway work first, because autonomous multi-agent runs can rack up API spend and make sweeping changes fast. The catch: this is young, opinionated software under a custom license, not a battle-tested standard. The marketing leans hard on grand claims. Treat it as a promising experiment, not infrastructure, and read what it's doing before you let it run unattended on code you care about.

cline69.4k★

Cline is an AI coding agent that lives inside VS Code and actually does things. Not autocomplete. Not suggestions in a ghost text overlay. It reads your project, edits files, runs terminal commands, launches a browser, and debugs runtime errors, all with your approval at every step. Apache 2.0 and free; you bring your own API key from Anthropic, OpenAI, or a dozen other providers. Version 4 rebuilt the extension on a shared SDK runtime and added a plugin system with a marketplace for skills and MCP servers, so extending it no longer means hand-editing config files. GitHub Copilot is the obvious comparison, but Cline executes multi-step tasks end to end; Cursor does similar agentic work but locks you into its editor. There's now a subscription option too: ClinePass at $9.99/mo bundles curated open-weights models at higher rate limits, an alternative to managing your own keys, not a feature gate. The extension stays free either way. Solo and small teams: free plus your own key. Organizations: an enterprise plan adds SSO, audit trails, and policy controls. The catch: however you pay, tokens are the real bill. Complex multi-file tasks burn dollars per session, and the v4 runtime rebuild is still rolling out in stages, so expect some churn.

aider49.2k★

Aider is a terminal-based AI pair programmer that edits your actual codebase. Not a chatbot that spits out snippets you copy-paste. You point it at your repo, tell it what to build or fix, and it writes the code directly into your files with proper git commits. It builds a map of your entire codebase so it understands how everything connects, even in large projects. Works with Claude, GPT-4o, DeepSeek, o3-mini, local models, basically anything. Supports 100+ languages. Has voice input, image context, linting integration, and IDE watch mode. Alternatives like Continue and Cursor offer similar AI coding but lock you into their editor. GitHub Copilot stays in VS Code's world. Aider stays in the terminal and works with whatever editor you already use. The catch: you bring your own API keys and pay for tokens directly. Heavy usage with frontier models gets expensive fast, and the terminal-first UX has a learning curve if you are not already living in the command line.

Codewhale41.0k★

Codewhale is a coding agent that runs in your terminal. Describe a task and it reads your project, edits files, runs commands, and checks the result, using whatever model you connect. It started life as deepseek-tui and is now provider-neutral: 44 provider IDs, from DeepSeek (still the default), OpenAI, Anthropic, and Google to local models through Ollama, vLLM, or SGLang. MIT licensed, written in Rust. Install is one curl command, or npm, Cargo, Docker, Nix, or Scoop, with builds for Linux, macOS, Windows, and Android under Termux. Then you add your own API key or point it at a local model server. Plan mode explores without touching files, work mode makes changes, and Shift+Tab switches between Ask, Auto-Review, and Full Access. A ChatGPT sign-in route bills against your subscription instead of an API key. Free at every team size today. You pay your model provider and nothing to Codewhale. anomalyco/opencode, openai/codex, and Aider-AI/aider are the closest alternatives. Pick Codewhale for DeepSeek-first defaults and a wide provider list in a single Rust binary. The catch: usage analytics are on by default until you run codewhale config set telemetry false. It is pre-1.0. And the company behind it, Shannon Labs, is building accounts, a hosted API route, and a closed-source desktop app. The terms promise to show a price before charging, which tells you prices are coming.

DeepSeek-Reasonix35.7k★

DeepSeek-Reasonix is a coding agent that lives in your terminal and runs on DeepSeek's models. It edits files, runs shell commands, plans multi-step changes, and plugs into MCP servers and custom skills, the same shape as Aider or Claude Code but built specifically around DeepSeek. The agent itself is free and MIT licensed; you bring your own DeepSeek API key. The whole point is cost control through prefix caching. The project is engineered to keep your conversation prefix stable so DeepSeek's cache keeps hitting, and the numbers are real: one documented session ran about twelve dollars instead of sixty-one without caching. Install is a single npm install with Node 22 or newer. A Tauri desktop client exists but it is still a prerelease, so the command line is where the stable experience lives. Solo developers already paying for DeepSeek API access get a capable agent for nothing extra. Small teams that want AI coding without per-seat Copilot or Cursor bills can run this and pay only for tokens. Larger teams will weigh the lack of polish and support against the savings, and many will still want an IDE-integrated tool instead. The catch is that you are tied to one model family. DeepSeek is cheap and capable, but it is not the strongest coding model out there, and the project says so itself. If you need the best results regardless of cost, this is not it.

oh-my-pi33.4k★

Oh My Pi is an AI coding agent that lives in your terminal. It reads your code, makes edits, runs commands, and drives whole workflows. What sets it apart is that it wires in the machinery a real IDE uses: language servers for accurate renames and refactors, and actual debuggers (lldb, Delve, debugpy) so the model can step through running code instead of guessing. MIT licensed and completely free. Setup is a one-line install through curl, Homebrew, or Bun, and the same binary runs on macOS, Linux, and Windows with no WSL. It picks up rules, skills, and MCP servers from the config folders of Claude, Cursor, Windsurf, Codex, Cline, and Copilot. It works with more than 60 model providers, local runners like Ollama and llama.cpp included, and signs in with existing subscriptions like GitHub Copilot as well as API keys. The tool costs nothing. What you pay is the model bill, and a swarm of subagents plus browser automation runs that up faster than a single-threaded assistant. Solo devs and small teams comfortable in a terminal: this is a legitimate free alternative to a Cursor subscription. The catch is maturity. It is a hard fork of another young project, shipping several releases a week. A company, Stencil Labs, now stands behind it, but there is no support offering. Treat it as a powerful tool you are willing to debug.

DSH Desktop29.1k★

DSH Desktop turns DeepSeek Harness into a normal app. The harness is DeepSeek's open source agent runtime, and running it means Node, pnpm, a terminal, and a port. This is one installer for Windows x64 or any Mac, Intel or Apple Silicon, and the Web UI, host service, and plugin system open in a native window. MIT, free, and not an official DeepSeek project. Nothing to host. The installer bundles Electron, Node, pnpm, and a pinned harness build, and leaves your global PATH alone. Updates download only after you confirm. Upstream runs unmodified, so official plugins install from the bundled terminal. Newer builds add a built-in community plugin market and mobile remote control. Solo and small teams on Windows or a Mac should use this instead of the npx command. Medium and large teams get nothing extra: no shared profiles, no policy controls. Anyone already running the harness in a browser gets more from zhu1090093659/dsh-web-ui. For a multi-provider chat client instead, CherryHQ/cherry-studio is further along. The catch is what it pins. Upstream calls itself a developer preview and warns in capitals that breaking changes are coming, and this ships a fixed release candidate. No Linux installer has shipped yet, the issue tracker carries launch crashes on both supported platforms, and LAN mode opens the UI to your network with no authentication.

qwen-code28.1k★

Qwen Code is Alibaba's open-source answer to Claude Code: an AI coding agent that lives in your terminal, reads your repo, writes code, runs commands, and fixes its own mistakes. Apache 2.0 licensed, and unlike the proprietary agents it takes after, it is not locked to one model. Point it at Qwen's own API, OpenAI, Anthropic, Gemini, or a local model through Ollama or vLLM. The framework is free. What you pay is whatever the model behind it costs. Install is a one-liner through npm, Homebrew, or a curl script, then you configure an API key or a local endpoint. It ships more than a terminal: there are VS Code, Zed, and JetBrains plugins, a headless mode for scripting, and a daemon. Built-in skills like /review, /bugfix, and /loop cover the common agent workflows out of the box, and it speaks MCP for extending into your own tools. The real question is the model, not the tool. Run it against a strong hosted model and it competes with Claude Code and Cursor on capability while costing you only tokens. Run it against a local Qwen model and you get a fully offline coding agent for free, at the cost of some quality. Solo devs and cost-conscious teams get the flexible, no-lock-in option here. Teams already deep in Cursor's IDE experience may not switch. The catch: an agent is only as good as the model driving it. Free and local sounds great until a weaker model burns your afternoon on a task Claude would have nailed in one pass. The freedom to choose your model is also the freedom to choose a bad one.

grok-build27.1k★

Grok Build is SpaceXAI's terminal coding agent, the Grok answer to Claude Code. It reads your codebase, edits files, runs commands, and works through multi-step tasks in a full-screen TUI. It also runs headless for CI and plugs into editors through the Agent Client Protocol. The client is Apache 2.0. Install is one curl command, with prebuilt binaries for macOS, Linux, and Windows. First launch signs you into an x.ai account, and the product page says it is free to try, though the free tier's limits are not published. It is not locked to Grok either: the docs cover custom model endpoints, including OpenAI-style and Anthropic-style APIs and self-hosted models. Your MCP servers and skills carry over, because it reads the config files Claude Code and Cursor already use. Solo: free to try, then SuperGrok at $30/mo or SuperGrok Plus at $100/mo for more usage, or pay per token through the API. Team accounts get OIDC single sign-on and zero data retention. anomalyco/opencode and Aider-AI/aider are the community-run alternatives, and openai/codex is the same open-client, vendor-model play. The catch: open source here means you can read and build it, not shape it. The public repo is a periodic sync from a private monorepo, and outside contributions are not accepted. There are still no tagged GitHub releases, even though versioned binaries ship several times a month.

Superset (superset.sh)14.7k★

Superset runs a swarm of coding agents at once, each in its own Git worktree so they do not collide. Point it at a repo, launch Claude Code, Codex, Cursor Agent and others in parallel, then review every diff in one window. This is not Apache Superset, the BI tool at apache/superset. Same name, different project. The desktop app is free forever and you bring your own agent subscriptions. Setup is installing an app, not standing up a server. But running many agents at once is real load on your machine and real review work for you. macOS builds are native, Linux ships as an experimental AppImage, Windows has nothing. Free covers one user and local workspaces, which is the whole product for a solo developer. Pro runs $20 per user per month, or $180 a year, and adds remote workspaces, unlimited users, and Linear and Slack integrations. Enterprise adds SAML SSO, SCIM and audit logs. Running one agent at a time? Use opencode (anomalyco/opencode) or aider (Aider-AI/aider) directly. The catch is the license. Elastic License 2.0 is source-available, not open source. You can read and run the code, but not offer it as a competing service. Plan around that before you build on it.

freebuff12.8k★

Freebuff is a coding agent that costs nothing to use, and the way it pays for itself is text ads. Five products share one account: a CLI, a desktop app that runs parallel agents locally, a web builder, a cloud runner that works on any GitHub repository, and a chat. Apache-2.0, and you start with npm install -g freebuff. No subscription, no credits, no API key. The model catalog is the interesting part. GPT-5.6 Luna is the default, DeepSeek V4 Flash handles fast coding, MiMo 2.5 is the unmetered fallback that costs no session at all, and GLM 5.3 Flash is the deep-reasoning pick capped at two sessions a day. Models may serve from a quantized Q8_0 build, which the project states up front rather than burying. Under the hood it runs specialized agents rather than one model and one prompt, orchestrated by Codebuff, the same team's open framework. Access depends on where you are. Supported regions get full access; other regions and VPN users get limited access, currently MiMo 2.5 with three one-hour sessions a day, earnable up to seven. Solo devs and students: a real way to use a capable coding agent with no card on file. Small teams: fine for side projects, but the session caps will bite in a real sprint. Companies: keep this away from proprietary code. That last line is the catch and it deserves to be blunt. Freebuff's own data-use notice says it uses prompts, messages, code, files, and repository data to run the service, and that it may analyze prompts and messages, including anything you paste, to personalize ads. Where the law does not require an opt-out, that processing may be a condition of using the free service, and some models may retain submissions for training. Uploads and connected repositories are excluded from ad providers. Your prompts are not. Nothing here is free. You pay with what you type, and for anything under an NDA that is too much.

codeburn11.3k★

Codeburn shows you where your AI coding tokens go. Install it, run it, and get a TUI dashboard breaking down cost by project, model, and session across Claude Code, Codex, Cursor, Copilot, and others. No API keys needed: it reads the session files these tools already store on your machine. Setup is one command: npx codeburn. Pricing data pulls from LiteLLM and caches for 24 hours. Beyond raw cost, it classifies your sessions into task types (debugging, testing, coding) and calculates one-shot success rates so you can see which tasks burn tokens on retries. Anyone paying for AI coding tools should run this once just to see the numbers. The macOS menubar app gives passive cost awareness without opening a terminal. The optimize command flags waste patterns like repeated failures on the same task. The catch: it only knows about tools that store session data locally. If your AI tool does not write to disk (or you have not used it on this machine), codeburn cannot see it.

claurst10.3k★

claurst is an open source terminal coding agent written in Rust, built to replicate the behavior of Claude Code. It reads files, runs commands, searches codebases, and handles git operations from your terminal. The project was built from behavioral specs, not copied source code. The appeal is obvious: Claude Code is a proprietary tool that costs money. claurst gives you a similar workflow for free (assuming you bring your own API key for whatever model you point it at). Being written in Rust means it starts fast and uses less memory than Node.js-based alternatives. The project grew quickly after the Claude Code source leak sparked interest in how these agents work under the hood. For developers who want a terminal coding agent but do not want to pay for Claude Code, this is the most direct alternative. Aider and Continue are more established options with broader model support and larger communities. claurst is newer and less battle-tested, but the Rust foundation and active development are promising. The catch: this is early-stage software riding a wave of hype. The feature set is thinner than Claude Code, the plugin ecosystem does not exist yet, and you are depending on a solo maintainer. If you need reliability today, the established tools are safer bets.

html-anything9.0k★

HTML Anything is a desktop editor that takes Markdown, CSV, or notes and asks your existing coding agent (Claude Code, Cursor, Codex, Gemini, others) to render them as styled HTML: keynote decks, magazine articles, resumes, posters, social cards. Apache 2.0. Reuses whatever agent sessions you're already logged into, so the marginal cost is zero. Self-hosted by design. There's no cloud tier. Run it locally, it scans your PATH for installed agent CLIs, you pick one and a template. The 75 templates ship as SKILL files (Anthropic's skill format) and produce single-file HTML you can paste into WeChat, Zhihu, X, or just download as PNG. Setup is install dependencies, run pnpm dev. For anyone who already pays for Claude Code, Cursor, or similar and wants polished HTML output without sending more tokens through paid APIs: this is the angle. For people without an agent CLI installed: skip it, the value disappears. It's downstream of someone else's project (nexu-io/open-design) and the README leans hard on showcase shots. The template library is the actual product. If the templates don't fit your output, you're writing your own SKILL files in custom HTML and CSS, which is the work the tool claims to spare you.

dsh-web-ui8.1k★

DeepSeek Harness ships a usable web UI. This collection adds the parts you start wanting around day three: a kanban board with cron scheduling, a git graph, a file and diff panel, live token stats, and a mobile remote you pair by QR code to check on a long-running agent from your phone. Apache 2.0, installed with one plugin command. Install really is one line through the dsh plugin CLI; building from source wants Node 22 and pnpm, but most people never need to. The SSH plugin is the sleeper of the set: terminal, file transfer, port forwarding, and cluster execution from inside the UI. One plugin breaks the no-external-cost rule, the image understanding one, which routes vision through an endpoint like GPT-4o or Qwen-VL that you pay for separately. Anyone already running DSH should install it, and the live token stats alone justify the slot. Solo and small teams: free, and the mobile remote is worth more than it sounds once agents run long. Medium and large teams get less, because there is no multi-user model and no access control anywhere in the set. The catch is the dependency. None of this works without DeepSeek Harness, so the collection lives or dies on one upstream project's plugin API. Nine skins, including a Windows XP theme and two Hatsune Miku variants, tell you the priorities honestly. Pin the version before you build a workflow on it.

kimi-code7.7k★

kimi-code is a coding agent that runs in your terminal, built by Moonshot AI around their Kimi models. It reads and edits code, runs shell commands, searches files, fetches web pages, and decides its next move from the results, the same agent loop as Claude Code or Aider. It ships as a single binary with no Node install required, and supports subagents for parallel work, MCP servers, and lifecycle hooks. MIT licensed and free; you authenticate with a Moonshot API key or OAuth. Install is a one-line script on macOS, Linux, or Windows, and the single-binary design means there is nothing else to set up. This is early software, though, sitting at version 0.2.0. The agent works and the feature list is ambitious, with video input, subagents, and hooks, but expect the rough edges of a tool that shipped weeks ago, not one hardened over years. Solo developers already in the Kimi ecosystem get a capable terminal agent for the price of API tokens. Small teams curious about Moonshot's models can try it without committing to a subscription tool. Larger teams should wait for it to mature, or stick with a more established agent. The tool is free; your cost is Moonshot API usage. The catch is that you are betting on one vendor's models and a very young project. Kimi is capable, but if Moonshot changes pricing or the project stalls, you are stuck. Treat it as worth watching, not yet worth standardizing on.

ZCode6.9k★

ZCode is Z.ai's own AI coding workspace, open sourced on September 20, 2026. Describe a task and an agent plans, writes, runs, and reviews the code, from a desktop app, a browser tab, or the terminal. It is built around Z.ai's GLM models but takes OpenAI, Anthropic, DeepSeek, Kimi, MiniMax, Qwen, xAI, and OpenRouter keys too. Apache 2.0, and Z.ai says the app itself is completely free. Official installers cover macOS, Windows, and Linux. Building from source needs pinned versions of Node and pnpm. You sign in with Z.ai or paste an API key, so there is nothing to host. This is a vendor source drop, not a community project yet: two commits, no tagged releases, and a Chinese-first README. Solo and small teams: free, and the cheap way in is the GLM Coding Plan, which starts at $18/mo. Medium and large teams: read the NOTICE file before rolling it out. For a more mature open agent, anomalyco/opencode is further along, and Hmbown/Codewhale is the terminal-only option. The catch is in that NOTICE file. There is no operating system sandbox. Headless runs with --prompt default to yolo mode, which waves ordinary tool calls through without asking. The Computer Use package is a placeholder that returns an error. And Z.ai does not promise the source matches the product it ships.

hapi5.1k★

Hapi runs a Claude Code, Codex, Gemini, or OpenCode session on your laptop and lets you control it from a phone or browser. The agent stays where it works best (your machine, your file system) and a web/PWA/Telegram app gives you remote eyes and a remote keyboard. End-to-end encrypted via WireGuard plus TLS. AGPL. Setup is one npx command. You get a URL and QR code, scan it, and you are looking at the active session from anywhere. Workspace browsing is opt-in. Voice control works through a built-in assistant, and Telegram approvals let you sign off on agent actions while away from the keyboard. The relay is provided, but you can self-host with Cloudflare Tunnel or Tailscale. Solo developers running long agent loops: this is the most polished way to monitor them away from the desk. Small teams: same value, but pair-sharing across teammates is not the use case. Large teams: stick to internal devloop tools. The AGPL license adds friction for enterprise legal reviews. The catch: it is built around a relay you do not own. Self-hosting is supported, but the easy path uses someone else's WireGuard hub. Read the security model before you point it at production credentials.

dsh-market4.7k★

dsh-market is a plugin store that lives inside DeepSeek Harness. Open Settings, then Plugin Market, and you get browse, search, category filters, AppStore-style screenshots, and one-click install against a curated community catalog. MIT licensed, free, added with a single dsh command. Setup is one line and a restart, so the real question is not installation, it is trust. Installs are restricted to sources in the curated awesome-dsh-plugin registry, build scripts stay blocked by default under pnpm 10, and plugins that touch the terminal surface get flagged before they land in a web profile. The maintainers say plainly that listing is not endorsement. Backup and restore export your plugin list and config as readable JSON and merge rather than clobber. Solo: install it, the discovery problem it solves is real and the alternative is hand-editing config. Small teams: same, and the backup export turns onboarding a second machine into a copy and paste. Anywhere a supervisor owns the process, set allowRestart to false and let systemd or pm2 handle restarts. It needs dsh web 0.1.0-rc.6 or newer, and on an older host it quietly disables itself and only says why in the browser console. Desktop builds that bundle their own dsh are the usual culprit. Past that, this is downstream of one vendor's agent framework that shipped in August 2026, so the ecosystem it indexes is exactly as young as the framework it plugs into.

gptme4.4k★

gptme is a coding agent that runs in your terminal and works with whatever model you point it at. It executes shell commands, writes and patches files, runs Python, browses the web through Playwright, and reads images, all from a single CLI. The model is your choice: Anthropic, OpenAI, Google, DeepSeek, or a local llama.cpp model when you want zero API cost. There's nothing to host. You pip install it, drop in an API key, and you're working. It also exposes a web UI and a REST API if you want to drive it from somewhere other than the terminal, and it speaks MCP, so you can plug in external tool servers. For something this capable, the setup is refreshingly light. Solo developers and tinkerers who live in the terminal and want a model-agnostic agent get the most here. It's a direct open-source answer to Claude Code, Copilot CLI, and Cursor, with the advantage that you're not locked to one vendor's model. Teams standardizing on a single coding agent may prefer something with more polish and support. The catch: the software is free, but the models aren't. Point it at a frontier API and you'll pay per token like any agent, run it on a local model and you trade that bill for slower, weaker output. And model-agnostic means you're the one tuning which model handles which job, that flexibility is also homework.

codex-plusplus3.7k★

Codex++ was a tweak loader for OpenAI's Codex desktop app. It patched your local install so Codex would load community-written tweaks at startup: custom settings pages, UI changes, main-process code, even native macOS APIs through its own bridge. MIT licensed, free, macOS, Windows, and Linux. Past tense on purpose. The maintainer archived the repository on August 15, 2026, and it is now read-only. Version 1.0.0 was real work, with a Homebrew formula, a doctor command for signature and permission failures, a safe mode that disables tweaks without deleting them, and detection for Owl, the native shell current macOS Codex builds use. None of it gets another commit. Do not install this now. The whole design depends on somebody tracking OpenAI's app changes and shipping a patch when Codex breaks the loader, and nobody is doing that anymore. For an AI coding tool you can actually modify, use one that is open to begin with: anomalyco/opencode, cline/cline, and Aider-AI/aider all take extensions without touching a signed app bundle. Solo, small, or large, the answer is the same. The catch was always that this was unofficial, patched a signed application, and voided its code signature. Archiving turns that from a tolerable risk into a dead end. If it is already installed and working, run codexplusplus uninstall to restore the original app while the tooling still runs.

dsh-TUI3.5k★

dsh-TUI swaps the browser interface on DeepSeek's agent runtime for a terminal one. DeepSeek Harness (the dsh command) opens a local web UI by default, and this plugin gives you a Claude Code style terminal experience instead: streaming markdown, live agent status, tokens per second, a context usage meter, and double Escape to roll a turn back. MIT licensed and free. Installing is two npm packages, and it mounts as a plugin rather than patching the harness, so removing it leaves nothing behind. You need Node 22.19 or newer, pnpm, a real terminal, and a DeepSeek API key. The plugin itself costs nothing. The model calls behind it bill at DeepSeek's published rates, which are among the cheapest of the frontier providers. The audience is developers who want the agent in the same window as their code with no browser tab involved. Solo: free, and worth the ten minutes to try. Small teams: free, and it makes everyone's agent sessions look and behave the same way. Larger teams: this is a personal preference layer, not something to standardize centrally. The catch: everything in this stack is days old. The harness is still on a release candidate, the plugin is pre-1.0, and the repository is barely a week into its life with dozens of open issues. That means fast fixes and fast breakage in equal measure. Worth naming plainly too: this is a front end for one vendor's runtime, so your terminal workflow now tracks DeepSeek's roadmap.

background-agents3.3k★

Background-agents lets you fire off AI coding agents that work on their own. You hand one a task, it spins up a sandboxed dev environment, clones your repo, does the work, and opens a pull request while you do something else. It is the self-hosted, open source take on what Cursor's cloud agents and Devin sell as a subscription. MIT licensed. Free to use is not free to run. This is a multi-service system: a Next.js web app, Cloudflare Workers, Python pieces, a GitHub App, and an account with a sandbox provider such as Modal, Daytona, Vercel Sandbox, OpenComputer or E2B. Models come through an Anthropic key or Claude subscription, a ChatGPT subscription for Codex, SuperGrok, or OpenCode Zen. The software is free; the sandbox and model bills are not. Sessions start from the web UI, Slack, GitHub pull requests, Linear issues or webhooks, and it runs scheduled and event-driven automations. One person does most of the maintenance, so treat it as capable but young. Solo devs and small teams who want autonomous coding without a per-seat bill get the most from it. Teams that need reliability and support today should pay for a hosted product. The catch is trust and ops. It is single-tenant by design: anyone whose role allows repository use can reach every repo the GitHub App is installed on, with no per-user access check. Add infrastructure you maintain and API bills you watch, and it only pays off if you value control over convenience.

codex-host2.6k★

CodexHost runs other coding agents inside Codex Desktop. If you have settled on one desktop app but keep dropping to a terminal for Claude Code or Pi, this puts those harnesses behind the Codex UI instead. It supports Pi, Claude Code, OpenCode, DeepSeek Harness, Grok, Oh My Pi, and Antigravity, and it can hand a task from one agent to another. The interesting call is that it does not flatten everything into one protocol. Each agent goes through its own native interface, Pi over its official RPC and Claude Code through the Agent SDK, with a CLI shim in front. Streaming, tool calls, diffs, and approval prompts come through the way the underlying agent produced them instead of as a lowest common denominator. Install is a global npm package, or an installer for macOS and Windows, with Linux on x64 and ARM64. MIT and free. Nothing to host. The agents themselves still bill you on their own plans. The catch is that this is glue over seven moving targets, and it needs official Codex Desktop plus Node 22.19 or newer. Every one of those vendors ships breaking changes on its own schedule. The question is not whether it works today. It is whether the author is still patching it in six months.

deepclaude2.3k★

deepclaude swaps the model behind Claude Code without changing the interface. You keep the autonomous agent loop, file editing, and bash execution, and route calls to DeepSeek V4 Pro, OpenRouter, Fireworks, or any Anthropic-compatible backend. Free, MIT. Setup is two minutes. npm install, set environment variables for your chosen provider, and the CLI behaves like Claude Code with a different brain inside. Multiple providers can be configured at once, and you switch between them at the env-var level. Solo: real money. DeepSeek V4 Pro at $0.87 per million output tokens versus Anthropic's $15 means a hobby project can stop bleeding cash. Small teams: depends entirely on whether your model of choice handles your codebase as well as Sonnet does. Larger teams: probably stay on Anthropic. A productivity hit on a senior engineer costs more than the API bill ever will. The catch: Claude Code is good because of Sonnet and Opus, not because of the loop around them. DeepSeek is solid but it is a different model with different blind spots. Test it on your real code before committing.

claude-usage2.2k★

Claude Usage reads the JSONL session logs that Claude Code writes to your machine and turns them into charts. Per-model token breakdowns, cache hit rates, cost estimates, and session history, all in a local browser dashboard. Anthropic's own UI gives you a progress bar. This gives you the full picture. Zero dependencies. Standard library Python only, no pip install. Clone the repo, run the dashboard command, and it serves a Chart.js UI at localhost:8080 that auto-refreshes every 30 seconds. A SQLite database at ~/.claude/usage.db caches the parsed data for fast incremental re-scans. CLI commands cover scan, today, stats, and dashboard. Pro and Max subscribers who want to understand their actual token consumption per session and per model need this. The cost estimates use current API pricing, which is useful even for subscription users as a proxy for understanding usage patterns. The catch: only captures local Claude Code sessions. Cowork sessions (server-side) are not included. Cost estimates reflect API pricing, not what you actually pay on a Pro/Max subscription. Single-maintainer project, so pricing tables need manual updates when Anthropic changes models.

smallcode2.0k★

smallcode is a terminal coding agent built for small, local language models, the 8B to 35B range you can run on your own hardware, not frontier models like Claude or GPT. Most agents assume a huge, reliable model behind them. smallcode assumes the opposite and engineers around it. MIT-licensed and free. The adaptations are practical: a managed context budget instead of dumping everything at the model, forgiving parsing for messy tool calls, TODO-file planning, and search-and-replace patches instead of full-file rewrites. It's actively maintained, with real releases and a benchmark harness. The project claims 87% on a benchmark with a 4B-active model, though it doesn't spell out the suite or baseline, so take the number as a signal, not proof. The catch: a coding agent is only as good as the model driving it, and small local models still make mistakes a frontier model wouldn't. If you want to keep code on your own machine or avoid API bills, this is a serious attempt at making that work. If you just want the best results, a frontier model with a mature agent like aider will still beat it.

pi_agent_rust1.8k★

A from-scratch Rust port of Mario Zechner's Pi Agent, done with his blessing. Single binary called pi, no Node runtime and no Electron shell, 28 built-in tools with 18 live in a default session, and streaming that holds up over a long conversation. The complaint it answers is startup time and memory, and it answers it by rewriting the engine rather than trimming the old one. Security is designed in rather than bolted on. Extension execution is capability gated across tool, exec, http, session, ui, and events, then a second stage mediates the command itself and blocks recursive delete, raw disk writes, and reverse shells by default. Extensions move through a trust lifecycle from pending to trusted to killed, with audit logs on the kill switch. More thought than most agent CLIs have given the problem. Install is a curl script, and the only recurring cost is the model API key you already have. The catch is the license, and it is a real one. GitHub's badge says MIT. The LICENSE file is MIT plus a rider that grants no rights whatsoever to OpenAI, Anthropic, or their affiliates, and forbids use in any training corpus, evaluation harness, or ML pipeline. Breach terminates the license automatically. That is not open source under the OSI definition.

Deepseek-Harness-EAC1.8k★

Deepseek Harness EAC wraps DeepSeek's official dsh agent harness in a Windows and Linux desktop app. It bundles its own Node runtime, so there is no npx and no Node install to manage: double-click and you are running. Ten built-in UI skins, and a desktop-only profile that keeps its plugin tree isolated from a native CLI install while still sharing sessions and API keys. The interesting piece is the plugin protection center. It snapshots before an install, health-checks on launch, and rolls back to the last good snapshot when a plugin bricks the app. Anyone who has broken an agent harness with a bad plugin late at night knows why that matters. Builds ship for Windows 10 and 11 and for Linux as pacman, deb, rpm, and AppImage. Free, and it gates nothing. Your real cost is whatever DeepSeek's API bills you, same as running the CLI. Solo and small teams who want dsh without owning a Node install: this or anywhere-labs/deepseek-harness-desktop, which is chasing the same job. Anyone already comfortable with npx should stay on the official CLI and skip the wrapper entirely. There is no LICENSE file in the repo. The README shows an MIT badge and GitHub reports no license at all. Until someone commits the actual file, the legal status of this code is unspecified, which matters the moment you want to fork it or ship it inside something. It is also a wrapper around a fast-moving framework somebody else controls, which is where upstream changes break you first.

keep-codex-fast1.6k★

keep-codex-fast is a maintenance script for OpenAI's Codex CLI. It walks through accumulated chat history, terminal logs, and worktrees, then archives or prunes them safely. MIT. The flow is conservative on purpose. Inspect first, write a handoff doc, back up state, then optionally apply changes. Read-only by default, archive instead of delete, and you opt in with --apply when you actually want it to do something. Solo: useful if your Codex sessions feel sluggish from months of chat history, terminal logs, and stale worktrees piling up. Teams: skip, this is personal-machine maintenance with nothing to centralize. The catch is the scope. This is for OpenAI's Codex, not Anthropic's Claude Code. The names sound similar, the tools are different, and the state directories do not overlap. If you run Claude Code, this script will not help you.

mindwalk1.4k★

Mindwalk replays what your coding agent actually did. It renders your repo as a 3D map and plays back the session as light moving through it: which files the agent searched, read, and edited, in order. The diff tells you what changed; this shows you how the agent got there. MIT licensed and free. Install is a one-line script and it runs entirely on your machine. No server, no account. The only outbound call is optional: it can send a session summary to your own Claude Code or Codex account for evaluation. Worth a look if you run coding agents daily and keep wondering why the agent read half the codebase to change one file. It comes from the maintainer of air, the Go live-reload tool, which counts for something on follow-through. Free at any team size. The catch is that it's young and narrow. Version 0.2, small codebase, one use case. Tracing platforms like Langfuse cover LLM apps broadly; nothing else does this specific replay trick, but 'nothing else does it' cuts both ways.

codex-shim1.1k★

codex-shim is a local proxy that lets Codex Desktop talk to models it was never built to support. OpenAI's Codex app normally locks you into a short list of models. This shim sits between the app and whatever provider you want, translating Codex's Responses API format into calls to Anthropic, DeepSeek, or any generic chat-completion endpoint, with an optional ChatGPT passthrough that reuses your existing subscription. MIT licensed and completely free. Running it means Python 3.11 or newer, a pip install, and editing a JSON config to point Codex at localhost. On macOS you may also patch the app so your custom models show up in the picker. None of this is hard for someone comfortable in a terminal, but it is fiddly, and it can break when Codex ships an update that changes its internal API. This is a workaround, not a product. Solo developers who want Claude or DeepSeek inside Codex without paying for a second tool get real value here. Small teams might standardize on it to route through a cheaper model. Larger teams should think hard before depending on an unofficial shim that lives or dies by one maintainer. The catch is fragility. You are patching around a closed app's limits, so every Codex release is a chance for this to stop working. Use it knowing that.

fablize896★

Fablize is a plugin for Claude Code that forces the agent to slow down and prove its work. Instead of letting the model declare a task done, it makes it reproduce the bug first, break the work into steps, and verify the result before claiming success. The pitch is procedural discipline: give a weaker model the working habits of a careful engineer without swapping the model. MIT, free, installs into Claude Code. There is nothing to host and no key to manage beyond the Claude subscription or API you already pay for. The whole thing is a discipline layer, not the intelligence. By the author's own admission it cannot make a model smarter, it can only make it more rigorous, which for agentic coding is often the part that actually fails. It is an early project, a handful of commits in, so treat it as promising rather than battle-tested. This is for developers already running Claude Code who keep getting confidently-wrong 'done' from their agent and want guardrails. Solo or team, the cost is the same: free. If you do not use Claude Code, or you do not run agentic coding workflows, there is nothing here for you yet. The catch is dependency. Fablize is only as useful as the agent it rides on, and its value is entirely in process, not capability. If your model is already disciplined, you will notice less. If it cuts corners, this is the leash.

herdrm718★

herdrm is a native macOS window onto every coding agent you have running, local or over SSH. Claude Code, Codex, Gemini, Grok, and OpenCode across your Mac and any box you can reach, each on a real PTY at full TUI fidelity, with a sidebar showing which one is working, blocked, or done. It is a client for herdr, the Apache 2.0 runtime that owns the terminals. The details show someone uses this daily. SSH targets accept user@host, explicit ports, ssh:// URIs, and ~/.ssh/config aliases, with auth falling back from OpenSSH keys to Tailscale SSH to a password kept in the macOS Keychain rather than a file. Failures name themselves instead of reporting a bare not connected. Files and images paste straight into Claude Code or Codex, locally or streamed over SSH. Free, with signed builds and a Sparkle appcast so it updates itself. The recurring cost is the agent subscriptions you already pay for. Mac only, and herdr has to be running on every machine you want in that sidebar. The catch is that there is no license file. herdr itself is Apache 2.0, but this client ships without one, which legally means no rights granted at all. Given the release cadence it is almost certainly an oversight, and it will still fail a dependency audit.

token-diet472★

token-diet is a set of rules you bolt onto a coding agent to make it stop wasting tokens. It trims the padding out of replies, docs, tests, and tool calls, the verbose scaffolding an agent emits by default, without dropping the parts that matter for correctness. Works with Claude Code, Codex, Cursor, Windsurf, and Cline through their session hooks. One-line install and it is free. There is no server and nothing to run. It installs a SessionStart hook or context file for whichever agent it detects, and you tune aggressiveness with flags, lite, ultra, or off when you want the agent verbose again. Because it works by steering style rather than intercepting traffic, setup is a single command and reversible in seconds. The pitch is money. The project claims roughly 31 percent lower bills on average, with a wide range, and output reductions from 30 to 81 percent on real Sonnet runs. Take the averages with salt, savings depend heavily on how you work, but the direction is right: terser agents cost less. Solo developers burning through API credits: try it, the downside is a one-line uninstall. Teams on metered agent usage: worth an A/B test before rolling out. The catch is that the repo ships without a stated license. No license technically means all rights reserved, so treat it as use-at-your-own-discretion until the author adds one, and know that terser output can occasionally clip context you actually wanted. Keep the off switch handy.