33 lesser-known coding agent CLIs, and the bets they are making

Why the small projects are worth reading

A curated directory tracked more than 110 terminal-native coding agents and harnesses as of 13 August 2026.^[1] Most readers will never adopt more than two. The reason to read the rest is that a small project cannot afford to be good at everything, so it has to pick one thesis and build the whole product around it. That makes the architecture legible in a way that a mature vendor product, which has quietly absorbed every feature its competitors shipped, no longer is.

The scores below use the same ten-dimension rubric as our full harness comparison, and they carry an explicit caveat: they are derived from published documentation and repository evidence rather than sustained hands-on operation, so treat them as an ordering to investigate rather than a verdict.^[2]

Bet one: the harness should be a single small binary

The most visible independent trend is a rejection of the Node and Electron stack that the mainstream tools are built on. agentty is the extreme case — a native C++ terminal agent shipping as a single static binary of roughly 14 megabytes with sub-millisecond cold start and no runtime dependencies at all, sandboxed by default via bubblewrap or the macOS sandbox, able to act as an ACP client inside Zed and to drive air-gapped hosts over SSH. Waveloom makes the same bet in Go at around 19 megabytes; Zap, QQCode, and picocode make it in Rust.

The thesis is not vanity. Startup cost and memory footprint stop being cosmetic the moment you run twenty agents in parallel, and jcode makes that dependency explicit: it is a Rust terminal agent tuned specifically for RAM and startup latency, at roughly 28 megabytes of resident memory per session with local embeddings disabled, built so that many concurrent sessions are affordable. Once parallel agent fleets became a normal workflow, per-session cost became an architectural constraint rather than a benchmark boast.

Bet two: governance is the product

A smaller group has concluded that the interesting problem is not capability but accountability, and these are the projects worth watching if your constraint is regulatory. DvalinCode is the clearest statement of the thesis: an organisation policy engine, network egress enforced both by per-request checks and by operating-system-sandboxed subprocesses, a tamper-evident hash-chained audit trail, inline diff approval, and a durable session journal — shipped as a provider-neutral local-first binary with a built-in web interface.

OpenSquilla approaches the same territory from a runtime-design angle, with a self-hostable microkernel architecture, bubblewrap and Seatbelt sandboxing, machine-learning-based tier routing, and a gateway mode. Grinta targets long-horizon autonomous execution with durable state and recovery, structured tool orchestration, LSP and DAP integration, and validation-gated completion — a rare instance of an independent project treating debugger-protocol access as a first-class capability.

Read together, these three are converging on the same conclusion that the durability layer is where the field is thinnest, which matches what a broad rubric scoring shows: durability was the weakest dimension across the whole full-harness tier.

Bet three: the scarce resource is context, not capability

Keen Code’s thesis fits in one sentence: replace raw tool traces in the conversation with lean structured turn summaries, so the context window carries conclusions rather than transcripts. It backs that with full transparency — every prompt, design document, and implementation plan is written to disk as markdown — which also makes it one of the most readable projects in the field for anyone studying prompt design.

Waveloom attacks the same problem from the other end with four-tier context compaction and three distinct subagent modes it calls Fork, Cold, and Explore, plus provider prompt-cache awareness for long-context efficiency. Zap takes a third route, injecting only skill-relevant context rather than a large fixed system prompt, and maintaining a SQLite code index for fast symbol lookup — notable because a real symbol index is something several much larger harnesses still lack.

These are the projects most likely to influence the mainstream, because context cost is the one constraint that gets worse as models get better: a larger window invites a larger prompt, and the bill follows.

Bet four: the agent should improve itself

Hermes Agent is the largest independent project on this list and the most ambitious: a self-improving loop with persistent memory, automated skill creation, sandboxed code execution over socket-based RPC, support for hundreds of models, and reach into Telegram, Slack, Discord, and WhatsApp. It scores highest in the independent tier at 72, mostly on context, model breadth, extensibility, and surface reach.

The pattern is spreading. jcode ships agent memory alongside swarm mode and browser automation; several projects now derive reusable skills from session evidence rather than requiring you to author them. The open question — and it is a real one — is verification. An agent that writes its own memory will eventually write a wrong conclusion about your codebase and then act on it repeatedly. Inspectable, editable, per-fact memory files are the mitigation worth insisting on, and the projects that store memory as opaque blobs should be treated with more caution than their feature lists suggest.

Bet five: rebuild the leader, openly

A large sub-population exists to reproduce Claude Code’s surface under a permissive licence. openHarness is the most complete: 78 slash commands, 42 tools, MCP over stdio, HTTP and SSE with OAuth, hooks, subagents, and plan mode, working against Anthropic, OpenAI, Ollama, llama.cpp, and LM Studio, and shipping both npm and Python SDKs. Coro Code and Kode CLI occupy similar ground with narrower scope.

A parallel group forks Codex instead. Every Code adds validation, browser integration, theming, and multi-provider orchestration; Codex Infinity adds auto-continuation, parallel multi-agent runs, and CI repair loops; open-codex and nori-cli widen provider support. These forks are the most practical way to get a specific missing feature today, and the least likely to still be maintained in a year — a trade worth making consciously.

Two entries belong to a different category entirely. Mini-Kode is an educational reference implementation whose purpose is to be read, and Smol Developer was an important early demonstration that a model could generate a whole codebase from a prompt. Both score low on an architecture rubric and neither should be judged by it.

The independent tier, scored

Scores are out of 100 on the same ten-dimension rubric: loop, edit engine, context, isolation, permissions, durability, model layer, extensibility, surfaces, and cloud. They are indicative rather than measured.

How to adopt from this tier without regret

Independent harnesses fail in predictable ways: the maintainer stops, a provider changes an API, or a fork drifts from the upstream it depends on. Three habits make that survivable. Keep your instruction files in the standard formats so they transfer. Keep your extensions as MCP servers rather than harness-specific plugins, since MCP is now the portable layer. And avoid depending on a harness-specific state format for anything you would mind losing.

The strongest reason to run one of these alongside a mainstream tool is that they surface the questions the mainstream tools have stopped answering. A harness that ships an explicit audit trail forces you to notice that your primary tool does not have one. A harness that reports per-session memory makes you notice what twenty parallel sessions actually cost. That diagnostic value is real even when the adoption decision is no.

Sources and evidence

Primary and authoritative sources used for factual claims. Company research and executive forecasts are labeled as such in the article.

1. 1
   Awesome CLI Coding Agents: 110+ terminal-native agents and harnessesbradAGI · 2026-08-13
2. 2
   Kendr Research coding agent harness scorecardKendr Research · 2026-08-14
3. 3
   Agentless: Demystifying LLM-based Software Engineering AgentsarXiv
4. 4
   Agent Client ProtocolAgent Client Protocol