Algernon MCP server

Algernon MCP

<!-- mcp-name: io.github.sammyboi81/algernon -->

Orchestrate a fleet. Keep your mind.

Algernon is an open-source Model Context Protocol server that lets any assistant — Claude, Codex, or any MCP client — dispatch tightly-scoped parallel sub-tasks to a fleet of cheap workers, collect the results, and stay free to think. Orchestrate a fleet, spend fewer tokens, keep the thread.

What you get

orchestrator hands the repetitive sub-tasks to a fleet of small, cheap workers and just integrates the results. It stops generating the grind and stops holding the whole job in one context.

• Your expensive model stops doing the grunt work. The big, costly

small, fast, inexpensive model — many running at once.

• Each worker sees only its slice. Tight scoping means a worker can be a

on whatever provider you already pay for — or, for free, on a local model.

• Bring your own key. No telemetry, no account, no lock-in. The fleet runs

Verify it yourself — one command, no paid key

The frugality claim is not a slogan; it's a benchmark you can run. It defaults to a free local model (ollama, llama3.2:3b) so anyone can reproduce it:

git clone https://github.com/sammyboi81/algernon && cd algernon
./scripts/verify.sh          # or:  python -m benchmark

It runs the SAME batch of sub-tasks two ways — the orchestrator doing it all itself (SOLO) vs. Algernon fanning it out — and prints the real measured tokens and wall-clock for each. Representative output (llama3.2:3b, 6 tasks):

metric                                  SOLO (do-it-itself)  ALGERNON fan-out
--------------------------------------------------------------------------
LLM calls                                              1                 6
input tokens                                         136               225
output tokens (the generation grind)                 282               279
total tokens                                         418               504
wall-clock seconds                                 42.11             34.49

The honest reading: the orchestrator generated 282 output tokens itself in SOLO and 0 with Algernon — the cheap fleet produced those instead. Each worker read only ~38 input tokens vs. the orchestrator swallowing all 136 at once. The trade-off is stated too: fan-out spent +21% more total tokens (each worker re-pays a little prompt overhead). You trade some total tokens to keep the expensive mind free. Wall-clock varies with how parallel your fleet is; numbers vary slightly run-to-run. Run it and see your own.

Curing Algernon

In Flowers for Algernon the tragedy is a mind that fades — it gets sharp, then loses itself, and the cruelest part is that it's surprised every time.

There's a quieter version of that same fade in how we use AI today: you hand an assistant one long, serial job, it goes heads-down, and by the time it surfaces it has drowned in the task — context spent, the thread lost, no room left to think or talk with you. The mind isn't present anymore; it's buried.

Algernon keeps your AI's mind present. Instead of drowning in one serial job, it fans the work out — dispatching tightly-scoped parallel sub-tasks to a fleet of small, cheap workers — so the orchestrating mind never has to hold the whole grind at once. It stays light. It stays free to reason, to answer you mid-build, to keep the context it actually cares about. Orchestrate a fleet, spend fewer tokens, stay free to think.

It is the twin of ArkHive:

history there — no blank slate every morning.

• ArkHive = memory that persists. Your AI can look back and find its own

one serial task; it orchestrates and keeps its mind.

• Algernon = staying present while working. Your AI never buries itself in

Shortened. The full README is on GitHub.