models: A TUI and CLI for Browsing AI Models, Benchmarks, and Provider Status
TUI and CLI for browsing AI models, benchmarks, coding agents, and statuses for AI providers.
At a glance
- What is it?
- reyamira/models is a Rust-based TUI and CLI that aggregates AI model catalogs, benchmark data, coding agent updates, and provider health into one terminal interface. It is a practical tool for developers who want to compare models and track agents without leaving the shell.
- Who is it for?
- Adopt models if you spend significant time in the terminal and need a single place to compare AI model pricing, capabilities, and benchmark results, or to track updates for coding agents. It is less useful if you prefer graphical dashboards or if your workflow relies on a single benchmark source, since multi-source switching and scatter plots are best enjoyed in the TUI.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 4 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 14, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
What problem does models solve?
Developers who work with AI models face a fragmented landscape. Model catalogs live on different websites, benchmark results are spread across multiple sources, coding agents update on their own schedules, and provider status pages are scattered across platforms. models addresses this by pulling these data streams into a single terminal application. It targets engineers who already live in a terminal and want to compare models by capability, price, context, or provider category without opening a browser. The README states it covers roughly 4,000 models across 85+ providers from models.dev, about 1,000 benchmark entries from four sources, 12+ coding agents, and 22 provider statuses. That scope makes it a potential daily driver for anyone who needs quick answers about which model to use or whether a provider is having an outage.
How the TUI and CLI are structured
The application is organized into four main tabs: Models, Agents, Benchmarks, and Status. The Models tab uses a three-column layout with providers, a model list, and a detail panel. The detail panel shows capabilities, structured output support, reasoning controls, and pricing details, including conditional rows for thinking tokens or audio input. The Agents tab tracks coding assistants, showing version detection, changelogs, and GitHub release information. The Benchmarks tab aggregates data from Artificial Analysis, Epoch AI, Arena, and LLM Stats, with the ability to switch sources and compare models side by side using scatter plots and radar charts. The Status tab provides live health monitoring for providers across seven status page platforms. The CLI mirrors these features with commands like `models list`, `models show`, `models search`, `models providers`, `agents status`, and `models benchmarks list`. This dual interface means you can use the TUI for interactive exploration and the CLI for scripting or quick queries.
Installation and first launch
Installation is straightforward across platforms. On macOS or Linux with Homebrew, you run `brew install models`. On any platform with Cargo, `cargo install modelsdev` builds from source. Windows users can use Scoop with `scoop install extras/models`, and Arch Linux users can install via AUR with `paru -S models-bin`. Nix users can run the flake directly with `nix run github:reyamira/models`, which downloads prebuilt binaries from a Cachix cache instead of compiling. Pre-built binaries, `.deb`, and `.rpm` packages are available on GitHub Releases. After installation, launching the TUI is as simple as running `models` with no arguments. Navigation uses arrow keys, tabs switch with `[` and `]`, search is triggered with `/`, and context-aware help appears with `?`. Mouse support was added in v0.12.1, allowing row clicks, panel focus, and scrolling, which makes the TUI usable in terminals that support mouse events.
Agent tracking and self-update mechanism
A notable feature is the ability to track coding agents and update them in-app. The Agents tab includes a curated catalog of 12+ agents, but you can add your own by pressing `A` and providing a name and `owner/repo` pair. The application detects the installed version and derives the update command based on how the agent was installed, whether that is bun, npm, brew, cargo, AUR, apt, dnf, or another method. Pressing `u` updates a single agent, `U` updates all agents with available updates, and `x` cancels an in-flight update. There is an interactive suspend-and-run mode (`i`) for updaters that require a prompt or sudo. This design is practical but carries a risk: if the detection logic misidentifies the install method, the update command could be wrong. The README does not specify how detection handles edge cases like multiple installs or custom paths. You should verify the update behavior on your own system before relying on it for critical tools.
Benchmark comparison and data sources
The Benchmarks tab aggregates roughly 1,000 entries from four sources: Artificial Analysis, Epoch AI, Arena, and LLM Stats. You can switch between these sources in-app, and the application preserves your state when switching. A column picker lets you choose which metric and effort columns are visible, and those preferences are stored per source in config.toml. The detail panel can cycle through a field average, peer average, or rank comparator for each score. There is also a compare mode with head-to-head tables, scatter plots, and radar charts. Filters cover creator, region, type, reasoning, and open or closed source. This multi-source approach is a strength, but it also means the data is only as current as the last refresh. The README mentions in-app refresh for benchmarks, but it does not state how often the underlying sources are polled. For time-sensitive comparisons, you may need to manually refresh to get recent results.
Limitations and when it is the wrong tool
models is a terminal application, so it is not suited for users who prefer graphical dashboards or who need to share visual comparisons with non-technical stakeholders. The scatter plots and radar charts are rendered in the TUI, which is fine for individual use but awkward for presentations. Another limitation is that the CLI output is JSON-oriented. The README shows that `models show` and `--json` include fields like description, structured-output, reasoning-controls, and pricing, but it does not mention a human-readable table format for the CLI. If you need quick terminal output without parsing JSON, you may find the CLI less convenient. The project also depends on external data sources; if models.dev or any benchmark source changes its API or rate limits, the application could break or show stale data. The README does not document offline capabilities or caching behavior, so assume network access is required for fresh data.
Alternatives and how they differ
The most direct alternative is to use the websites that models aggregates, such as models.dev for model catalogs or Artificial Analysis for benchmarks. These sites offer richer visualizations and are always up to date, but they require a browser and do not integrate with your local agent installations. Another terminal-based alternative is a custom script that queries each source's API and formats the output with jq or similar. That approach gives you full control but requires maintenance and does not provide the interactive TUI features like agent tracking or status monitoring. There are also GUI applications for AI model management, but they are generally platform-specific and do not cover the breadth of data sources that models does. The key difference is that models brings everything into one place and automates the update detection for agents, which a manual script would not do.
Maintenance and upgrade considerations
The project is actively maintained, with releases v0.14.1 in August 2026, v0.14.0 in July 2026, and v0.13.0 in July 2026. The repository is not archived and has a default branch of main. The license is MIT, which permits commercial use, modification, and redistribution with attribution. The README includes a link to a Buy Me a Coffee page, suggesting the project is community-supported rather than backed by a company. Upgrading is straightforward if you use a package manager: `brew upgrade models` or `cargo install modelsdev --force` will fetch the latest version. The Nix flake is available directly from GitHub tags and branches, but it is not published to FlakeHub or nixpkgs, so you must reference the GitHub URL. The in-app self-update feature for agents is separate from the application's own updates; you still need to update the models binary itself through your package manager. The documentation wiki covers installation and usage, but the README does not specify a formal changelog process beyond release notes, so review the release notes before upgrading to understand breaking changes.
Editorial conclusion
Adopt models if you spend significant time in the terminal and need a single place to compare AI model pricing, capabilities, and benchmark results, or to track updates for coding agents. It is less useful if you prefer graphical dashboards or if your workflow relies on a single benchmark source, since multi-source switching and scatter plots are best enjoyed in the TUI. Before adopting, verify that your preferred provider and benchmark sources are covered, test the agent update detection against your actual install method, and confirm the Nix flake or package manager build matches your platform. The project is actively maintained with recent releases, but the CLI output is JSON-oriented, so script integration requires parsing that format rather than a dedicated API.
Community notes