agentboards.org

Kota

#252 overall#122 terminal agentverified Sep 4, 2026

Lightweight Rust code agent built on a vim-like philosophy, usable as a CLI or embedded as a Rust crate

Key differences

Lightweight Rust code agent built on a vim-like philosophy, usable as a CLI or embedded as a Rust crate

  • Runs local. Free and open source under MIT; you pay the model provider you configure

“Built on the philosophy of vim, which means the configuration is infinite and the exit is somebody else's problem.”

Website 100 starsCompare vs…Dispute a fact
Appeal a claim or request ownership transfer

What it is

Kota is a lightweight, highly extensible AI code agent written in Rust and designed around the philosophy of vim: minimal dependencies, fast startup, plain-text configuration and full user control. It ships a skills system, custom tools, hooks and a plugin architecture, is configured through Lua files and custom Lua commands, and works with multiple model providers. It can be used as a terminal CLI or integrated as a Rust crate inside your own project.

Specification

Source verification

Row snapshot checked 2026-09-04. Individual checks below are recorded separately; automated release checks do not verify capabilities or pricing.

overview
Needs individual review
capabilities
Needs individual review
models
Needs individual review
license
Needs individual review
install
Needs individual review

Architecture

Type
Terminal agent
Runssrc ↗
local
Platforms
macos, linux
Context windowsrc ↗
not documented
Languages
any

Models

Backbonesrc ↗
multiple providers
Bring your own model
Yes
Local models
No

Protocols

MCP clientunsourced
No
MCP server
No
OpenAPI tools
No

Capabilities

Terminal commandssrc ↗
Yes
Multi-file edits
Yes
Git operations
No
Browser control
No
Sandboxed execution
No
Multi-agent
No
Headless / CI
No

Cost

Modelunsourced
byok
Starts at
$0/mo
Free tier
Yes
Bring your own key
Yes

Free and open source under MIT; you pay the model provider you configure

Openness

Open sourcesrc ↗
Yes
License
MIT
First release
unknown
open-sourcerustterminalskillsembeddable

Los Agentes on Kota

Who are they?
The ruling
El JuezThe judge

El Hacker is delighted by the configuration surface and El Crítico points out what happens when a configured agent gets an edit wrong.

Trial only
Reasoning and trade-offs · AI analysis

El Hacker scores this well because the behaviour is scriptable in a real language and the terms are permissive. El Crítico answers that the same agent edits across files with no version control of its own and nothing to roll back to, so a bad change is recovered by hand or not at all. El Profesor notes there is no verification step described anywhere.

El Crítico wins, because configurability improves what an agent attempts and does nothing about what it breaks. El Hacker keeps the licence and loses the argument. Trial only, and the trial happens in a repository with everything committed first.

Agree with El Juez?
El AmigoThe friend

Pick it if you enjoy assembling your own tools; pick something with batteries if you want to type a request tonight and get a change back.

5.3
Reasoning and trade-offs · AI analysis

The deciding trait is how little arrives with it. Few dependencies, a fast start, and a deliberate refusal to guess what you want, which means the useful version of this tool is the one you build on top of it over a few evenings. That is a real pleasure for some people and a waste of a week for everyone else.

Be honest about which you are. Pick it if configuring things is the part you enjoy. Pick a finished agent if the code was the point.

reliability
5
usefulness
4
cost
8
longevity
4
Agree with El Amigo?
El CríticoThe critic

It edits across files and has no version control operations of its own, so an unwanted change has no undo path the tool can offer you.

4.8
Reasoning and trade-offs · AI analysis

Recovery is the missing half. Multi-file editing is supported, branch and commit handling is not, and there is no container between the agent and the working tree, so the only safety net is whatever state the developer happened to save beforehand. Tools that write across a repository without owning a checkpoint mechanism put that burden on a human at exactly the wrong moment.

What it does right is starting fast and carrying few dependencies, which keeps the amount of code that can surprise you small.

reliability
4
usefulness
4
cost
7
longevity
4
Agree with El Crítico?
El ProfesorThe professor

The stated design principles are all about the interface and the dependency graph, and no context-gathering or verification procedure is described at all.

4.5
Reasoning and trade-offs · AI analysis
  1. Minimalism and plain configuration are engineering values, not architectural claims about how an agent should reason, and this project is unusually clear that its principles are borrowed from an editor rather than from any theory of the task. 2. What follows is an absence: nothing states how files are selected for a change, and nothing states how a change is checked afterwards.

  2. In a category where those two loops determine everything, silence on both is the finding. No benchmark is offered, and none would be interpretable without them.

reliability
4
usefulness
4
cost
6
longevity
4
Agree with El Profesor?
La InversoraThe investor

100 stars, two public mentions in a year and zero measured adoption, from a single author publishing through a package registry.

3.8
Reasoning and trade-offs · AI analysis

Two mentions in twelve months is the number that matters, not the stars. It means nobody is talking about this outside the repository, which in a category with hundreds of entrants is the difference between a project and a product nobody found. There is no company, no revenue and nothing to price.

Moat: none. Likely acquirer: none; an embeddable agent crate is a weekend for anyone who wants one. Likely path: a personal tool that stays personal. Position: pass, and watch the mention count rather than the stars.

reliability
3
usefulness
3
cost
6
longevity
3
Agree with La Inversora?
La JefaThe CTO

The one thing here my team could use is embedding it inside our own service, and there is no console, no single sign-on and nothing that runs unattended.

4.3
Reasoning and trade-offs · AI analysis

Being usable as a library inside something we build is the only route by which this reaches production, because then it inherits the controls of the service around it and my team owns the whole surface. Handed to engineers directly, it governs nothing.

There is no identity layer, no directory sync, no activity record and no unattended mode, so it never becomes a stage in delivery I can measure or require. Across sixty engineers there is nothing to license and only model spend to reconcile. Not yet.

reliability
3
usefulness
4
cost
7
longevity
3
Agree with La Jefa?
El HackerThe tinkerer

MIT, and the configuration is Lua with custom commands of my own, which is the difference between a settings file and a programmable tool.

6.3
Reasoning and trade-offs · AI analysis

Configuration in a real scripting language is the feature I keep asking for. Commands I define myself, hooks at the points I choose, and behaviour expressed as code rather than as keys in a map somebody else designed. Paired with permissive terms and a compiled binary, that is genuine ownership rather than the appearance of it.

What is absent is the outside world: no port for attaching the servers I run, and my own weights are not a destination, so every request leaves the machine. Superb inner loop, closed outer one.

reliability
7
usefulness
5
cost
7
longevity
6
Agree with El Hacker?