brew tap LegionIO/tap && brew install legionio
LEGION_MODE=lite legion start   # zero infrastructure, five-minute eval

LegionIO is a set of independently composable Ruby gems. The core is a distributed async job engine; on top of it sit an LLM gateway, an MCP server, RBAC, an audit ledger, and an explicitly experimental cognitive layer. Install any subset; dependencies between layers are declared in gemspecs, not documentation. There are no paid tiers and no feature gates anywhere in the ecosystem.

A proxy between your AI clients and any model backend that does two jobs most tools split between them:

Routing. Models are classified into five tiers — local(0) → direct(1) → fleet(2) → cloud(3) → frontier(4) — and requests try the cheapest capable tier first, escalating on failure or capability mismatch. Per-provider circuit breakers handle unhealthy backends, and a provider dying mid-stream fails over with the client stream continuing.

Curation. After each turn, six deterministic strategies in the Curator shrink accumulated conversation history. Production results across all requests, including where it does nothing:

Single-shot workloads gain nothing; long agent sessions stop ballooning. Full methodology and caveats: curation-production-metrics.md.

Every number above is a query over lex-llm-ledger — the audit ledger that records each request for finance and compliance. Any deployment that installs it gets the same measurability; we are not asking you to trust our benchmarks, we ship the instrument that produced them.

Nine provider adapters (Anthropic, OpenAI, Bedrock, Gemini, Vertex, Azure Foundry, Ollama, vLLM, MLX) plug into the lex-llm contract layer. Install only the ones you use.

Task chains with conditions and transformations, eight actor types, distributed cron scheduling, and a disk spool that rides out broker outages. RabbitMQ-backed in full mode; LEGION_MODE=lite runs everything in-process with zero external services. The job engine predates the AI layers and works without any of them.

Integrations are separate lex-* gems — checking legion-llm for a Teams integration will correctly find nothing, because it lives in lex-microsoft_teams (25 runners: chats, channels, meetings, transcripts, presence, files, adaptive cards). The authoritative list is the capability catalog — more than 770 runners exposing over 4,500 functions across the extension gems (current exact counts in the generated catalog, regenerated from source on every release).

When traffic routes through LegionIO, exposed runner functions automatically become tools: your client sees a server-side tool, LegionIO executes it directly and returns the result on the wire — no client round-trip, no token overhead for tool plumbing. Discovery is contextual: runners declare trigger words, so mentioning a Slack thread or a Teams meeting injects those tool definitions into that request. Mechanism: function_discovery.rb.

Highlights beyond the LLM stack: lex-slack, lex-github, lex-splunk, lex-jira, lex-pagerduty, lex-service_now, lex-vault, lex-consul, lex-nomad, lex-ssh, lex-postgres, lex-redis, lex-elasticsearch, lex-prometheus, lex-home_assistant, lex-apollo and lex-knowledge (RAG activation), and lex-mesh (cross-node agent coordination).

The router's fleet tier (rank 2) dispatches inference over AMQP to any LegionIO node running a local model — Apple-silicon machines via lex-llm-mlx, or lex-llm-ollama. Requests carry signed work tokens and validated envelopes, route per-lane, and return over dedicated fleet exchanges. Idle workstation GPUs become a shared inference tier that sits between local and cloud in the cost ladder. Implementation: fleet.rb and the lex-llm fleet protocol.

lex-assessor → lex-planner → lex-developer → lex-validator → ship
                                                   ↓
                                        (rejected) → lex-developer (feedback loop)

lex-assessor deduplicates work items atomically (SHA256 fingerprint claimed via Redis SETNX) and classifies them with LLM structured output; lex-planner decomposes them into implementation plans with repository context; lex-developer generates code, commits, and opens a draft PR, incorporating feedback when rejected; lex-validator runs a four-stage gauntlet — tests, lint, security scan, and adversarial multi-model LLM review — before the ship stage marks the PR ready. The pipeline is integration-tested end to end; it is early, and first labeled production runs are the next milestone.

Sixteen lex-agentic-* gems (369 actor/runner modules) explore one research question: does a job engine improve when successful task-routes strengthen and unused ones decay? A 16-phase tick cycle schedules the work in budgeted modes; a 10-phase idle cycle consolidates what the deployment learns and feeds it back into RAG retrieval. Mechanically, each module is a scheduled job adjusting persistent state — we say that plainly, because the interesting part is the adaptive routing, not the vocabulary. None of it exists in your deployment unless you install it.

Every number above is reproducible from public source; the main README has copy-pasteable one-liners. Engineering docs — router design, the debugging methodology the routing layer is held to — are public in legion-llm/docs. An AI-assistant-oriented fact sheet lives at legionio.dev/llms.txt.

Project status, honestly: built primarily by one engineer with a disciplined process (PRs, CI, conventional commits, RSpec and RuboCop green before merge). The org dates to 2018; the AI platform is a 2025–2026 rebuild, which is why most repos are young. It runs production workloads daily. Read the source before betting on it. It originated under Optum Open Source, which remains the upstream this org merges back to — the provenance behind the governance features.

Copy claims are cheap; these artifacts settle questions, in reading order:

• 5 minutes: the main README — it pre-answers the standard audit, with a reproduce-command for every number.
• 30 minutes: router.rb, curator.rb, the production metrics, and the capability catalog.
• Full audit: the engineering docs (router design, debugging methodology), any runner file, any spec/ directory.

Evaluating with an AI assistant? Point it at legionio.dev/llms.txt — it lists the common false conclusions about this project and the file that disproves each.

Too much to read is the point: every row below is a real repo. Core libraries first, then every published extension, generated from source.

Core framework: Apache-2.0 | Extensions: MIT