Legion

The deciding trait is where it lives. This is not a separate service you call, it is a dependency your application carries, so the agent reaches your business logic as functions rather than through an API you had to invent for it. For a team that already models its domain in modules, that removes an entire translation layer nobody enjoyed building.

The narrowness is the whole risk: outside this language there is nothing for you here. Pick it if Elixir is your production language. Pick something mainstream if it is your side project.

The gap is between two meanings of the same word. An interpreter that restricts a language is not the same as a boundary that restricts a process, and the published material describes the former while a reader will assume the latter. If the application holds database credentials and network access, so does anything the agent decides to evaluate inside it.

What it does right is read before it writes. The agent examines the source of the modules you exposed, so the code it produces is written against real signatures rather than guessed ones.

1. This is the strongest efficiency argument on the board, and it does not depend on a benchmark, because the saving follows from the shape of the protocol rather than from a measurement somebody chose. Ten conditional steps expressed as one program is ten fewer inferences, whatever the model.

2. The trade is legibility: a tool call is inspectable before it executes, and a program is not, so what is bought in latency is paid in reviewability. 3. The project states the mechanism and leaves the reader to price that exchange, which is honest.

Agency-published open source is a marketing budget with a version number, and it is a more reliable funding source than most single-maintainer projects because somebody is paid to be seen. It is also conditional in a way donations are not: the day the firm's positioning moves, the library stops being a priority and nobody announces it.

Moat: none, and the addressable base is one language community. Likely path: steady maintenance while it wins conversations, then quiet. Position: fine as a dependency, and read the commit history before a major version.

There is no seat, no console and no vendor, which settles finance and opens the operations question in the same breath. Whatever gets built on this becomes an internal system with my team's name on the pager, including the model spend, the logging and the incident review when it does something surprising in production.

Nothing here runs unattended by itself, so it never appears as a step in my pipeline; it appears as code inside a service. Approved with conditions: it ships behind a process boundary my platform team defines, with credentials scoped to that process alone.

Exposing my own modules as the tool surface is a better story than a plugin registry. I decide what the agent can touch by deciding what I make visible, which is a permission model I already understand, and the permissive licence means the runtime itself is mine to modify when the prompt strategy annoys me.

What is absent is the protocol layer everything else here speaks, so the servers I already run have nowhere to plug in, and there is no documented path to weights on my own hardware. Elegant library, closed neighbourhood.