Hermes via Tokonomix

//What is Hermes?

Hermes is an open-source, self-hosted AI agent from Nous Research, released February 2026 under an MIT licence. It bills itself as the only agent with a built-in learning loop: it creates skills from experience, improves them during use, searches its own past conversations, and builds a deepening model of who you are across sessions. You run it on your own infrastructure — a $5 VPS, a GPU cluster, or serverless backends that cost almost nothing while idle — and reach it from a real terminal UI or from Telegram, Discord, Slack, WhatsApp and Signal.

Out of the box Hermes ships with 40+ tools and skills, a built-in cron scheduler, parallel sub-agent spawning, and six terminal backends (local, Docker, SSH, Singularity, Modal, Daytona). Because everything runs on your own machine, your data stays local — no telemetry, no mandatory cloud. That privacy-first design makes the choice of which model brain powers Hermes entirely yours.

And that is exactly where Tokonomix fits. Hermes can point at any OpenAI-compatible endpoint, which means a single Tokonomix API key unlocks 132 frontier models — Anthropic, OpenAI, Google, Mistral, Meta and others — without you signing up for, billing, or rotating keys with each provider separately. Switch the brain with one command: hermes model.

//Why route Hermes through Tokonomix?

Hermes runs long, autonomous sessions: it plans, spawns sub-agents, calls tools, and commits work without a human reviewing every step. The single biggest risk in that loop is a confident-but-wrong decision early on that the agent then builds on for fifty more steps. Tokonomix addresses this directly.

• Cross-family consensus. Point Hermes at the tokonomix-consensus model and every call is answered by 2–6 frontier models in parallel, then reconciled by a judge model into one verified answer. Hallucinated API calls and architectural dead-ends get caught before the agent acts on them.
• One key, 132 models. Swap the brain — Claude, GPT, Gemini, Mistral — by changing a single model slug, no new provider account.
• Sovereignty routing — your choice, not EU-only. Pin models by where they run (hosting_region) or where they're made (origin_country) — EU-only, US-only, a single country, or a custom set. Enforce it per call, or set a predefined rule (e.g. auto-select EU models) in your dashboard; your data already stays local on the Hermes side.
• Transparent per-call cost. Every autonomous run is metered to the cent in your Tokonomix dashboard — essential when an agent can fire thousands of calls unattended.

//Install Hermes — Windows, macOS, Linux (also WSL2 & Termux)

Hermes installs with a single command and provisions its own dependencies (uv, Python 3.11, Node.js, ripgrep, ffmpeg, plus a portable MinGit on native Windows). Native Windows is fully supported — no WSL required.

iex (irm https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.ps1)

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Then reload your shell and launch:

# reload (macOS/Linux) — Windows opens a fresh shell automatically
source ~/.bashrc      # or: source ~/.zshrc
hermes                # start the terminal UI

//Enter your Tokonomix key

Already have a key? Hermes treats Tokonomix as a custom OpenAI-compatible provider. Generate a key (tok_live_…) in your Tokonomix dashboard, then wire it in any of three ways — all equivalent.

① Config file — ~/.hermes/config.yaml

model:
  provider:  custom
  model:     "tokonomix-consensus"
  base_url:  "https://tokonomix.ai/api/v1"
  api_key:   "tok_live_your-key"

② CLI — hermes config set

hermes config set model.provider custom
hermes config set model.model    "tokonomix-consensus"
hermes config set model.base_url "https://tokonomix.ai/api/v1"
hermes config set model.api_key  "tok_live_your-key"

③ Environment — ~/.hermes/.env

OPENAI_BASE_URL=https://tokonomix.ai/api/v1
OPENAI_API_KEY=tok_live_your-key

//Pull in skills & MCP tools

There are two complementary ways to get Tokonomix consensus into Hermes — and Hermes' own skill system layers neatly on top.

# turn consensus on
hermes config set model.model "tokonomix-consensus"
# or any Tokonomix slug — e.g. a fast direct model
hermes config set model.model "anthropic/claude-sonnet-4-6"
# one-off override for a single run
hermes --model "tokonomix-consensus"
# or switch mid-chat
/model custom:tokonomix-consensus

# ~/.hermes/config.yaml
mcp_servers:
  tokonomix:
    command: "npx"
    args: ["-y", "tokonomix-mcp"]
    env:
      TOKONOMIX_API_KEY: "tok_live_your-key"

After editing MCP config, reload it without restarting:

# inside a Hermes chat
/reload-mcp
# browse what's now available (Hermes skills + MCP tools)
/skills

The Tokonomix MCP server exposes tools such as tokonomix_consensus_ask (multi-model verified answer), tokonomix_single_ask, tokonomix_list_models and tokonomix_get_skill. Hermes can then invoke consensus only on high-stakes steps — a refactor, a security decision, a "is this really right?" moment — while keeping latency low everywhere else. Browse Hermes’ own built-in skills the same way with /skills; they’re compatible with the agentskills.io open standard.

//Using Hermes inside an IDE

To be precise: Hermes is not an IDE extension. It does not install into VS Code, Antigravity or JetBrains as a plugin the way Cline, Continue or Cursor’s agent do. Hermes is a full terminal-UI agent (and messaging gateway) that runs natively on Windows, macOS and Linux. It integrates with your editor in two practical ways:

• From the integrated terminal. Open the built-in terminal in VS Code, Antigravity, Zed or JetBrains and run hermes there. It operates on the same working directory your editor has open, so its file edits and git commits show up immediately in your source-control panel.
• As a remote agent on your repo. Hermes can run on an SSH host or serverless backend and commit through its GitHub skill. You keep coding in your IDE while Hermes works the same branch from its own environment — you review its commits as they land.

So: want an in-editor inline-edit assistant? Pair a dedicated IDE agent (see related below) with Tokonomix. Want an autonomous teammate that runs tasks end-to-end and reports back? Hermes is the right tool — and your IDE’s terminal is the front door.

//Verify it works

After wiring the provider, ask Hermes to make a small, reversible change — say, add a docstring — and watch your Tokonomix dashboard. You should see a metered call against tokonomix-consensus in your Tokonomix dashboard, with the multi-model verdict in the x_council response. From there, hand Hermes a real task and let consensus catch the dead-ends before they cost you a fifty-step detour.