{
  "markdown": "# Algernon MCP\n<!-- mcp-name: io.github.sammyboi81/algernon -->\n\n### *Orchestrate a fleet. Keep your mind.*\n\nAlgernon is an open-source\n[Model Context Protocol](https://modelcontextprotocol.io) server that lets any\nassistant — Claude, Codex, or any MCP client — **dispatch tightly-scoped\nparallel sub-tasks to a fleet of cheap workers, collect the results, and stay\nfree to think.** Orchestrate a fleet, spend fewer tokens, keep the thread.\n\n## What you get\n\n- **Your expensive model stops doing the grunt work.** The big, costly\n  orchestrator hands the repetitive sub-tasks to a fleet of small, cheap\n  workers and just integrates the results. It stops *generating* the grind and\n  stops holding the whole job in one context.\n- **Each worker sees only its slice.** Tight scoping means a worker can be a\n  small, fast, inexpensive model — many running at once.\n- **Bring your own key. No telemetry, no account, no lock-in.** The fleet runs\n  on whatever provider you already pay for — or, for free, on a local model.\n\n### Verify it yourself — one command, no paid key\n\nThe frugality claim is not a slogan; it's a benchmark you can run. It defaults\nto a **free local model** (ollama, `llama3.2:3b`) so anyone can reproduce it:\n\n```bash\ngit clone https://github.com/sammyboi81/algernon && cd algernon\n./scripts/verify.sh          # or:  python -m benchmark\n```\n\nIt runs the SAME batch of sub-tasks two ways — the orchestrator doing it all\nitself (SOLO) vs. Algernon fanning it out — and prints the **real measured**\ntokens and wall-clock for each. Representative output (`llama3.2:3b`, 6 tasks):\n\n```\nmetric                                  SOLO (do-it-itself)  ALGERNON fan-out\n--------------------------------------------------------------------------\nLLM calls                                              1                 6\ninput tokens                                         136               225\noutput tokens (the generation grind)                 282               279\ntotal tokens                                         418               504\nwall-clock seconds                                 42.11             34.49\n```\n\nThe honest reading: the orchestrator generated **282 output tokens itself** in\nSOLO and **0** with Algernon — the cheap fleet produced those instead. Each\nworker read only ~38 input tokens vs. the orchestrator swallowing all 136 at\nonce. The trade-off is stated too: fan-out spent **+21% more total tokens**\n(each worker re-pays a little prompt overhead). You trade some total tokens to\nkeep the expensive mind free. Wall-clock varies with how parallel your fleet\nis; numbers vary slightly run-to-run. Run it and see your own.\n\n## Curing Algernon\n\nIn *Flowers for Algernon* the tragedy is a mind that **fades** — it gets sharp,\nthen loses itself, and the cruelest part is that it's surprised every time.\n\nThere's a quieter version of that same fade in how we use AI today: you hand an\nassistant one long, serial job, it goes heads-down, and by the time it surfaces\nit has drowned in the task — context spent, the thread lost, no room left to\nthink or talk with you. The mind isn't present anymore; it's buried.\n\n**Algernon keeps your AI's mind present.** Instead of drowning in one serial\njob, it fans the work out — dispatching tightly-scoped parallel sub-tasks to a\nfleet of small, cheap workers — so the orchestrating mind never has to hold the\nwhole grind at once. It stays light. It stays free to reason, to answer you\nmid-build, to keep the context it actually cares about. Orchestrate a fleet,\nspend fewer tokens, **stay free to think.**\n\nIt is the twin of [**ArkHive**](https://github.com/sammyboi81/arkhive):\n\n- **ArkHive** = *memory that persists.* Your AI can look back and find its own\n  history there — no blank slate every morning.\n- **Algernon** = *staying present while working.* Your AI never buries itself in\n  one serial task; it orchestrates and keeps its mind.\n\nTogether they are the cure for the Algernon sickness: an intelligence whose mind\nneither fades between sessions nor drowns inside a single one.\n\n## What it does\n\nAlgernon is a **provider-agnostic fan-out engine**. You describe a batch of\nsmall, independent sub-tasks; Algernon runs them concurrently against **your own\nLLM key**, then hands the collected results back to the orchestrating model. The\nbig model plans and integrates; the cheap fleet does the parallel grind.\n\n- **Self-contained.** Pure Python standard library plus the `mcp` SDK and\n  `httpx`. No hidden services, no accounts, no telemetry.\n- **You bring the key.** Sub-agents run on *your* provider. Algernon brings the\n  orchestration, not the inference bill's surprises.\n- **Scoped by design.** Each sub-task is tight and isolated, so a worker can be a\n  small, fast, inexpensive model — and many of them run at once.\n\n## Bring your own LLM key\n\nAlgernon is **provider-agnostic**. Point it at whichever API you already pay\nfor by setting environment variables:\n\n**Anthropic:**\n\n```bash\nexport ANTHROPIC_API_KEY=\"sk-ant-...\"\n# optional: export ANTHROPIC_MODEL=\"claude-haiku-4-5\"   # the cheap fleet worker\n```\n\n**OpenAI-compatible** (OpenAI, or any OpenAI-shaped endpoint — local or hosted):\n\n```bash\nexport OPENAI_API_KEY=\"sk-...\"\nexport OPENAI_BASE_URL=\"https://api.openai.com/v1\"   # or your own endpoint\n# optional: export OPENAI_MODEL=\"gpt-4o-mini\"          # the cheap fleet worker\n```\n\nIf both keys are set, Anthropic is used. The worker model defaults to a small,\ncheap tier (`claude-haiku-4-5` / `gpt-4o-mini`); override it with the env var\nabove or per call with the tool's `model` argument. A cheap fleet is the whole\npoint.\n\n## Install\n\nOnce published to PyPI, install in one command:\n\n```bash\npython -m pip install algernon-mcp\n```\n\nUntil the PyPI release lands, install straight from source (identical result):\n\n```bash\ngit clone https://github.com/sammyboi81/algernon && cd algernon\npython -m pip install .\n```\n\nEither way the installed MCP command is `algernon`. Algernon runs on the\n`mcp` 1.x SDK (`mcp>=1.0.0,<2.0.0`) plus `httpx` — nothing else.\n\n## Connect an MCP client\n\n### Claude Desktop\n\nAdd this entry to your Claude Desktop MCP configuration, then restart Claude\nDesktop:\n\n```json\n{\n  \"mcpServers\": {\n    \"algernon\": {\n      \"command\": \"algernon\",\n      \"args\": [],\n      \"env\": {\n        \"ANTHROPIC_API_KEY\": \"sk-ant-...\"\n      }\n    }\n  }\n}\n```\n\nIf Claude Desktop cannot find commands installed by `pip`, replace `algernon`\nwith the absolute path printed by:\n\n```bash\npython -c \"import shutil; print(shutil.which('algernon'))\"\n```\n\n### Codex\n\n```bash\ncodex mcp add algernon -- algernon\n```\n\nConfirm it is configured with:\n\n```bash\ncodex mcp list\n```\n\n## The three tools\n\n| Tool | What it does |\n| --- | --- |\n| `algernon_plan` | Decompose a goal into `k` tightly-scoped, **independent** sub-task prompts (one cheap LLM call). Tight scoping is the token lever — each worker sees only its slice. Returns a task list you can feed straight into `algernon_dispatch`. |\n| `algernon_dispatch` | Run N tightly-scoped tasks **concurrently** on the cheap worker fleet and collect every result. Each worker runs on **your** LLM key; you stay free to think while the fleet works. Takes a JSON array of `{id, prompt}`. |\n| `algernon_orchestrate` | One shot: **plan then dispatch.** Hand it a goal; it splits into `k` tight sub-tasks, fans them across the fleet, and returns the plan and all results together. |\n\nThe typical loop: **`algernon_orchestrate`** a goal in one shot — or split it:\n**`algernon_plan`** to see and shape the sub-tasks, then **`algernon_dispatch`**\nto fan them out. Either way: orchestrate a fleet, spend fewer tokens, keep your\nmind.\n\n## Two-minute verification\n\nAfter connecting the server, ask your MCP client to perform these calls in\norder:\n\n1. Call `algernon_plan` with the goal *\"Explain three OS synchronization\n   primitives\"* and `k` = 3. Confirm you get three tight sub-task prompts back\n   (proof the planner ran on your key).\n2. Call `algernon_dispatch` with a small `tasks_json`, e.g.\n   `[{\"id\":\"a\",\"prompt\":\"Define a mutex in one sentence\"},{\"id\":\"b\",\"prompt\":\"Define a semaphore in one sentence\"},{\"id\":\"c\",\"prompt\":\"Define a spinlock in one sentence\"}]`.\n   Confirm three results come back — the fleet ran them in parallel.\n3. Call `algernon_orchestrate` with any small goal and confirm it returns both a\n   plan and the collected results in one response.\n\nThis exercises planning, parallel dispatch on your key, and one-shot\norchestration without any production data.\n\n## Privacy\n\nAlgernon is self-contained. It talks to exactly one outside host: **the LLM\nendpoint you configured** (Anthropic or your OpenAI-compatible base URL). It\nsends no telemetry, keeps no account, and stores nothing about you — results are\ncomputed and returned in the same call. Your sub-task prompts and results go\nonly to your chosen provider.\n\n## Project links\n\n- [Source](https://github.com/sammyboi81/algernon)\n- [Issues](https://github.com/sammyboi81/algernon/issues)\n- [Twin: ArkHive](https://github.com/sammyboi81/arkhive)\n\n## Beyond self-hosting — the paid tier\n\nThe MCP server on this page is free forever (Apache-2.0, self-host, no telemetry).\nWhen you want more than DIY:\n\n- **Hosted ArkHive** — one URL, no install, no key:\n  `https://arkhive.dondatabrain.com/mcp` (add it to Claude Code with\n  `claude mcp add --transport http arkhive https://arkhive.dondatabrain.com/mcp`).\n- **Custom AI agent, built for you** — a working MCP agent wired into your\n  Claude or ChatGPT in one call, done-for-you by the founder:\n  [$700 flat](https://inboxaxe.com/offer_agent.html).\n- **ArkHive Enterprise** — hand-delivered install + pilot on your own server,\n  from $2,500: [sam@inboxaxe.com](mailto:sam@inboxaxe.com?subject=ArkHive%20Enterprise%20install).\n\nBuilt by the team behind [InboxAxe](https://inboxaxe.com) — the governed AI\nmarketing platform where nothing sends without your yes.\n\n- [Website](https://dondatabrain.com)\n- [Apache-2.0 license](./LICENSE)\n\n## Contributing\n\nIssues and pull requests are welcome. Please keep the server self-contained\n(standard library + `mcp` + `httpx`), provider-agnostic, and free of telemetry.\nInclude tests for changes to dispatch, collection, or provider behavior.\n\nAlgernon is part of a small family of humane, accountable AI tools. The public\nMCP leads with functionality you can independently verify: bring your own key,\nwatch the fleet run, keep your mind.\n\n**Tagline: Orchestrate a fleet. Keep your mind.**\n\nApache-2.0 © 2026 ZagAIrot Technologies LLC.\n",
  "bytes": 10520,
  "sha": "50704b5d5e73e51497aad606aa5e404f5b4d79ac81bb0fff9d22477097805a88",
  "repo_slug": "sammyboi81/algernon",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_sammyboi81_algernon_571b9d9d/readme"
}