smelt

A fast terminal coding agent installed as one small binary and reshaped through live-reloading Lua files.

Stars
★ 73
Last updated
2d ago
License
MIT
Primary language
Rust

At a glance

How it runs
CLI
Works with
Universal · cross-platformChatGPT · Claude Code · OpenAI API · Claude API
Cost
Free software; you pay for model usage
Setup effort
Low · running in minutes
You'll need
Rust/cargo (only when installing from source)Shell / CLINetwork accessLocal filesystemMCP Server
Typical use
Backend or systems developers who live in a terminal and want a lightweight agent instead of a several-hundred-MiB install.
Not a fit if
  • Teams that need a stable 1.0 API and can't absorb interface changes between releases
  • Users who work only in a GUI and never in a terminal
  • Windows users on architectures other than x86_64
Website
smeltagent.dev ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-11-18latest release v0.8.1 (2026-11-18)

What does this agent do, and when should you use it?

smelt is a coding agent that lives in the terminal and ships as a single small binary, installed via a shell script, a prebuilt release archive, or cargo from source. Its defining trait is malleability: keymaps, commands, tools and the UI are plain Lua files that reload live, with no restart and no build step. It ships its own from-scratch terminal renderer, which the project says keeps typing and scrolling instant even in sessions with tens of thousands of messages, plus Vim motions shared between the prompt and the transcript for searching and yanking agent output. Providers span subscription logins through smelt auth (ChatGPT, GitHub Copilot, Kimi Code), any OpenAI-compatible endpoint including local Ollama, and your locally installed Claude Code, where Claude Code owns authentication, the agent loop, native tools and context management while smelt supplies the TUI, permissions and extra tools over MCP. The project is explicitly beta until 1.0, so interfaces may change between releases.

Running smelt opens an interactive terminal session: it takes your prompt, drives the configured model provider to work on coding tasks, and renders model output and tool activity through its own renderer. Configuration lives in ~/.config/smelt/init.lua, where you can enable bundled plugins such as which_key, the local request inspector, and LSP-backed semantic code tools, or override keymaps, commands, tools and the UI with changes applied live. Model access has several paths: smelt auth performs a one-time login for ChatGPT, GitHub Copilot or Kimi Code; --model with --api-base and --api-key-env targets any OpenAI-compatible endpoint such as a local Ollama server; or a logged-in Claude Code install acts as the provider, in which case smelt exposes extra tools and a permissions layer to it through MCP. The default mode cycle is Normal → Plan → Apply → Yolo, with Plan bundled and autoloaded.

  1. Backend or systems developers who live in a terminal and want a lightweight agent instead of a several-hundred-MiB install.
  2. Neovim users who want Vim motions to search and yank agent output directly in the transcript without touching the mouse.
  3. Teams that want to rewrite keymaps, commands and tool sets in Lua and see changes take effect immediately.
  4. Developers who already pay for GitHub Copilot or ChatGPT and prefer to reuse that subscription rather than buy separate API credits.
  5. Users who want to route coding tasks to a local Ollama model to limit what leaves the machine.
  6. Developers already authenticated with Claude Code who want a smoother terminal interface and extra tools on top of it.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Install / run
  • curl -fsSL https://smeltagent.dev/install.sh | sh
  • cargo install --locked --git https://github.com/leonardcser/smelt.git smelt-agent
Environment variables
OPENAI_API_KEY
Config files
~/.config/smelt/init.lua
Install notes cover
Windows · macOS · Linux

How do you install or deploy this agent?

Install with the official script:

curl -fsSL https://smeltagent.dev/install.sh | sh

Alternatively download a prebuilt archive from Releases — Linux and macOS on x86_64 and aarch64, Windows on x86_64 — extract it, and put smelt (smelt.exe on Windows) on your PATH. Installing from source requires a Rust toolchain:

cargo install --locked --git https://github.com/leonardcser/smelt.git smelt-agent

How do you use this agent?

For subscription providers, log in once and then just run it; the provider is auto-detected from credentials:

smelt auth
smelt

To use your installed Claude Code:

claude auth login
smelt

To use any OpenAI-compatible endpoint, here a local Ollama model:

smelt --model qwen3.6:27b --api-base http://localhost:11434/v1

To use a hosted endpoint with an API key:

smelt --model gpt-5.5 --api-base https://api.openai.com/v1 --api-key-env OPENAI_API_KEY

Running smelt with no arguments starts a setup wizard. Bundled plugins are enabled from ~/.config/smelt/init.lua.

What are this agent's strengths and limitations?

Pros
  • Single-binary distribution; project benchmarks report 47 MiB install size, 36 ms startup and 102 MiB memory after 64 turns, below most compared agents.
  • Lua plugins reload live, so keymaps, commands, tools and UI can be changed without restarting or rebuilding.
  • A purpose-built terminal renderer designed for very long sessions, rather than reusing ratatui.
  • Vim motions work in both the prompt and the transcript, letting you search and yank output without a mouse.
  • Broad provider coverage: ChatGPT, GitHub Copilot, Kimi Code subscriptions, any OpenAI-compatible endpoint, and local Claude Code.
  • MIT licensed, so the code can be audited, modified and redistributed.
Limitations
  • Explicitly beta until 1.0: interfaces may change between releases, putting custom Lua configs and plugins at breakage risk on upgrade.
  • Prebuilt binaries cover only Linux/macOS on x86_64 and aarch64 plus Windows x86_64; other targets require a Rust toolchain to build.
  • Terminal-centric and Vim-flavored, which raises the bar for people who rarely use a shell.
  • Benchmarks are the project's own three-run medians; no independent reproduction is provided.
  • The Claude Code provider depends on a locally installed and logged-in Claude Code, and the project states it is not affiliated with Anthropic, so upstream constraints apply.

How does this agent compare with similar options?

The README benchmarks smelt directly against pi, fx, codex, omp, claude code and opencode on install size, startup time, starting memory, CPU on a task and memory after 64 turns; smelt leads on post-64-turn memory, while pi edges it out on CPU for a task. It also states the project was inspired by Claude Code and Neovim.

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
smelt This agent 50 · Major gaps CLIFree + model costs ★ 73 2d ago Rust ChatGPT · Claude Code · OpenAI API · Claude API
Mini-Kode 43 · Major gaps CLIFree + model costs ★ 305 18d ago TypeScript OpenAI API
rpi: Rust Coding-Agent Runtime 71 · Some gaps CLIFree + model costs ★ 287 today Rust OpenAI API · Claude API
Aster 70 · Some gaps CLIFree + model costs ★ 139 20d ago Rust OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
50/ 100 5-point scale 2.5 / 5
This review covers the source as of Nov 17, 2026. The project has shipped 2 stable release(s) since, which have not been re-reviewed. The score and verdict describe the reviewed version only. Recent releases ↓
Trust 10/29
Reliability 8/14
Adaptability 12/18
Convention 10/18
Effectiveness 7/13
Verifiability 3/8
Why each dimension lost points
Trust10 / 29 · 1.7/5

SECURITY.md honestly states that Lua config, plugins, skills, MCP servers and trusted .smelt config run in-process with the same OS privileges and are not sandboxed, and that permission modes are not a security boundary. That is transparent but means least privilege is largely absent. README mentions a Normal→Plan→Apply→Yolo mode cycle and /trust gating, implying confirmation exists, but no concrete confirmation UI or default-deny policy appears in the sample, so 1. Data-flow transparency only notes that providers receive prompts and context; per-request audit detail (request inspector, export requests) is referenced but not shown. Sensitive-data handling, dependency security (pinned versions but no audit/vuln-scan evidence), external effects and rollback (session backup/doctor exist, but no tool-level undo) are only indirectly evidenced, so 1 each. Source attribution: README credits Claude Code and Neovim inspiration and LICENSE is MIT, but publisher identity is unverified, so 1.

Reliability8 / 14 · 2.9/5

Cargo.toml uses workspace-pinned dependencies and CI runs nextest, clippy, fmt, an 80% coverage gate and an MSRV matrix, supporting dependency availability and self-consistency, so 2. Failure messages: the sample only shows xtask eprintln usage and fuzz log conventions; no user-facing error taxonomy or recovery guidance, so 1.

Adaptability12 / 18 · 3.3/5

README clearly states target users (terminal coders), scenarios (subscription/API-key/Claude Code providers), install and run paths; skill files (brief/handoff/customize/fuzz-triage) show explicit triggers and boundaries (customize explicitly excludes ordinary coding), so 2. Capability boundaries are described in SECURITY.md and README but unsupported scenarios are not systematically enumerated, so not 3.

Convention10 / 18 · 2.8/5

README is well structured with complete install notes (curl script, prebuilt binaries, cargo install) and LICENSE is full MIT text, so 3. However README declares beta with changing interfaces, version is 0.0.0-dev, and changelog is only mentioned in AGENTS.md as release-time generated with no CHANGELOG file in the sample, so naming stability and versioning get 1 each. Examples/FAQ are limited to a demo GIF and external doc links with no in-sample FAQ, so 1. Known limitations appear in SECURITY.md and the README warning, so 2. Maintenance responsibility is 1 because the publisher is unverified and only a single maintainer is named.

Effectiveness7 / 13 · 2.7/5

The product positioning is clear (lightweight, Lua-scriptable, own terminal renderer) and skill outputs have concrete fixed structures (brief/handoff), giving real value to the target user, so 2. But benchmark numbers are self-reported with methods only linked externally and no independent reproduction, so cost_benefit is 1.

Verifiability3 / 8 · 1.9/5

The README benchmark table gives a date and medians but the method is an external link, untraceable within the sample; skills and code partially corroborate claims (e.g. customize's paths match the runtime/skills layout), but most claims are self-asserted and fact/inference separation is limited, so 1 for each of the three.

Risks and how to mitigate them
  • Lua plugins and trusted .smelt config run in-process with full OS privileges and are not sandboxed; review third-party config before loading.
  • Permission modes (including Yolo) are not a security boundary and must not be relied on against malicious plugins or config.
  • README benchmark figures are self-reported with methods only linked externally and cannot be independently verified from the sample; do not use them as the sole basis for adoption.
  • The project is beta with interfaces that may change and a 0.0.0-dev version; assess compatibility risk before upgrading.
  • Publisher identity is unverified by the FollowAgents registry; maintenance responsibility and update path should be independently confirmed.
Evidence confidence: Low Reviewed Nov 17, 2026 Reviewed revision 6c192d1c343c New commits since this review; the score may not cover them
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/smelt.svg)](https://followagents.com/en/agents/smelt)
<a href="https://followagents.com/en/agents/smelt"><img src="https://followagents.com/badge/smelt.svg" alt="FARS review"></a>

Recent releases

Latest entries from the project's GitHub Releases. Notes are quoted from upstream as written, not rewritten or tested by FollowAgents.

  1. v0.8.1
    Release notes excerpt
    Upgrade notes - smelt no longer uses the OS keyring for OAuth credentials, so startup no longer prompts for macOS Keychain access. If your credentials were stored only in the keyring, sign in again with smelt auth. Added - Preview image attachments and move them within the prompt before sending. - Stash a Vim visual selection without stashing the rest of the prompt. - Redeem available Claude Code quota reset credits from /usage. - See messages between Claude Code agents in the transcript. - The startup banner shows upgrade status next to the version. Changed …
    View on GitHub ↗
  2. smelt-term-v0.9.0
    Release notes excerpt
    Published [smelt-term v0.9.0](https://crates.io/crates/smelt-term/0.9.0) to crates.io. ```toml smelt-term = "0.9.0" ```
    View on GitHub ↗
  3. v0.8.0
    Release notes excerpt
    Breaking - Sessions live in one SQLite database. The first start imports smelt 0.7 data. - Goals and notebook editing are opt-in. Add require("smelt.plugins.goal") or require("smelt.plugins.notebook") to ~/.config/smelt/init.lua. - donut is opt-in. barrelroll loads by default. - The status file schema is 2. It drops expires_at_ms, boot_id and process_start_time_ticks. A held <pid>.lock proves a session is alive. Added - /files and /files git search workspace or Git-tracked files and preview the source. …
    View on GitHub ↗

FAQ

Does smelt itself cost anything?
No. It is MIT licensed and free to use. Model usage depends on your provider: ChatGPT, GitHub Copilot, Kimi Code or Claude Code reuse an existing subscription, while API-key providers bill per request on their side.
Does the Claude Code mode copy my subscription credentials?
No. The README states smelt does not copy subscription credentials or impersonate Claude Code's API requests. Claude Code owns authentication, the agent loop, native tools and context management; smelt provides the terminal UI, permissions and additional tools over MCP.
Do my Lua edits take effect immediately?
Yes — changes apply live with no restart or build. However, because smelt is beta until 1.0, upgrading versions may require adjusting those files as interfaces change.
Which operating systems are supported?
Prebuilt releases cover Linux and macOS on x86_64 and aarch64, and Windows on x86_64. Other environments must build from source with cargo.
Is there permission control over what the agent runs?
Yes. smelt uses a Normal → Plan → Apply → Yolo mode cycle, with Plan bundled and autoloaded, and exposes permissions handling as part of its terminal UI layer.
Is smelt open source?
Yes. The source code is on GitHub (leonardcser/smelt) under the MIT licence.
Is smelt still maintained?
Yes. The latest commit on GitHub is from 2026-11-18, within the last 30 days. The latest release is v0.8.1 (2026-11-18).
Who makes smelt?
smelt is published on GitHub by the account leonardcser. FollowAgents has not verified which person or company is behind that account.
What is smelt's official website?
The project's GitHub repository lists http://smeltagent.dev/ as its website. That link is set by the repository owner; the source code itself is on GitHub (leonardcser/smelt).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts