agentboards.org

Albatross

#172 overall#77 terminal agentverified Sep 4, 2026v2.5.0

Small Rust terminal coding harness that runs the same session against a local model or a cloud API and prices every turn

Key differences

Small Rust terminal coding harness that runs the same session against a local model or a cloud API and prices every turn

  • Runs local. Free and open source under MIT; bring an API key or run a local model for nothing
  • Runs local models. Listed for 66 of 125 tools in this category.
  • Keep in mind: The README offers bringing your own MCP server alongside your own model and key.

“Optimised for Apple Silicon, so your local model and your laptop can run out of memory in perfect harmony.”

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

What it is

Albatross is a terminal-first coding agent in Rust that treats a local model and a cloud API as interchangeable: Ollama, LM Studio, MLX and llama.cpp sit alongside OpenAI, Anthropic, OpenRouter and Grok, and `/provider` switches between them mid-session without changing the tools, commands or session log. It ships the usual read, edit, grep, shell and test tools, shows per-turn and per-session cost on the status line when pricing is known, and adds transparent multi-model routing that scores models per task plus an OpenRouter Fusion mode for deliberative work. Optimised for Apple Silicon.

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
website
Needs individual review
install
Needs individual review
capabilities
Needs individual review
models
Needs individual review
license
Needs individual review

Architecture

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

Models

Backbonesrc ↗
Ollama, LM Studio, MLX, llama.cpp, OpenRouter, OpenAI, Anthropic, Grok
Bring your own model
Yes
Local models
Yes

Protocols

MCP clientunsourced
Yes
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; bring an API key or run a local model for nothing

Openness

Open sourcesrc ↗
Yes
License
MIT
First release
unknown
open-sourcerustterminallocal-modelsmodel-routingcost-tracking

Los Agentes on Albatross

Who are they?
The ruling
El JuezThe judge

El Hacker and La Jefa argue about a toolchain; El Amigo raises the qualifier that actually decides whether the tool does what it says.

Trial only
Reasoning and trade-offs · AI analysis

El Hacker and La Jefa disagree about a Rust toolchain. He installs one without noticing; she has to put one on sixty machines and answer for it. El Amigo raises the point that decides the tool: you can see what each turn costs, when the price is known.

La Jefa is overruled, because this was never a fleet purchase. El Amigo's qualifier is the one that survives: a cost meter with gaps in it is a cost meter you check. Trial only, and the exit criterion is that the price line still appears for the models you actually use after a week.

Agree with El Juez?
El AmigoThe friend

Pick it if you want to watch the meter while you work; pick a subscription agent if you would rather never think about what a turn costs.

6.5
Reasoning and trade-offs · AI analysis

The deciding trait is the number on the status line. Each turn and each session shows what it cost, so the relationship between a lazy prompt and a real charge stops being theoretical. Once you have watched that figure move you write shorter prompts, which no pricing page ever achieved.

The caveat is that the figure only appears when the price is known, so the moment you point it somewhere unusual the meter goes quiet. Pick it if cost awareness is why you are here and you live in a terminal. Pick Aider if you want a longer track record behind the same idea.

reliability
6
usefulness
6
cost
9
longevity
5
Agree with El Amigo?
El CríticoThe critic

Switching provider mid-session leaves the tools, commands and session log unchanged, so one transcript can span several models with nothing in it recording which one answered.

5.8
Reasoning and trade-offs · AI analysis

The problem is attribution. A single command swaps the model mid-session, and the log is the same log, so a transcript can contain answers from several providers with no boundary marked between them. When a change turns out to be wrong, there is no way to tell which model produced it.

That matters more here than elsewhere, because switching is the headline feature rather than an escape hatch, so the mixed transcript is the normal case. What it does right is refusing to change the tools and commands across the switch: the interface stays constant, which is the half of the problem worth solving.

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

Routing is described as transparent and as scoring models per task, but the scoring function, its inputs and its calibration are all undocumented.

6.0
Reasoning and trade-offs · AI analysis
  1. The routing is described as transparent and as scoring models per task; the word transparent is asked to do the work of a specification. 2. A per-task score implies features, weights and a threshold, none of which appear in the documentation, so a design presented as legible is legible only in its outcome.

  2. The Fusion mode for deliberative work is a stronger claim still, since deliberation between models is precisely the sort of design that needs an evaluation to distinguish it from an expensive average. None is published and none is claimed. The architecture is interesting; the record supporting it is a README.

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

226 stars, one author, no company, no hosted tier and no revenue line: a good project with nobody to acquire it and nothing to acquire.

5.5
Reasoning and trade-offs · AI analysis

The signal to read is the size of the audience. Stars in the low hundreds describe a project that has not yet found the users who would keep it alive, and there is no company, no paid tier and no funding to buy time while it looks for them. Moat: none.

Likely path: a single-author terminal agent either finds a niche and compounds, or the author's attention moves and the last release becomes the last release. There is nobody to acquire and nothing to acquire them for. Position: enjoy it, contribute if you like it, and keep your workflow portable to something with more shoulders behind it.

reliability
5
usefulness
5
cost
8
longevity
4
Agree with La Inversora?
La JefaThe CTO

It installs through cargo, which means a Rust toolchain on sixty machines before anyone writes a line, and nothing here runs unattended afterwards.

5.5
Reasoning and trade-offs · AI analysis

The install is the cost. Cargo means every desk needs a Rust toolchain, a compile step and a story for keeping both current, which is a platform project rather than a rollout. Licence cost is zero and the model spend sits on keys the engineers already hold, so finance is not where this stalls.

It stalls on operations. No single sign-on, no directory sync, no audit record, and it does not run unattended, so it contributes nothing to a pipeline and reports nothing upward. Onboarding a mid-level engineer is an afternoon. Not yet: I will revisit it when there is a packaged build.

reliability
5
usefulness
5
cost
8
longevity
4
Agree with La Jefa?
El HackerThe tinkerer

MIT, and Ollama, LM Studio, MLX and llama.cpp are all named providers, so the same session runs on my own weights or on a hosted key without changing anything else.

7.8
Reasoning and trade-offs · AI analysis

Four local runtimes named explicitly, rather than implied through an OpenAI-compatible escape hatch, is the part I want to see. My hardware is a first-class provider here and not a tolerated one, and MCP servers attach, so the tools I already run are available inside the session.

MIT means a fork is both legally and practically possible: one binary, no runtime to drag along, and a codebase small enough to read in a weekend. The bring-your-own-key story is complete rather than partial. Grudging respect for a project this young getting the ownership questions right first.

reliability
8
usefulness
7
cost
10
longevity
6
Agree with El Hacker?