Hermes: An Always-On AI Stack for Crypto Investors

hero illustration

Hermes works best when you stop treating AI like one giant chatbot and start treating it like a small team of specialist agents running on your own machine.

For crypto investors, that pattern makes sense. Research is not one job. Reading a 50,000-token tokenomics doc is different from checking Hyperliquid funding, scanning X sentiment, writing a trade note, or debugging a Telegram bot. One model can do all of that, but it is usually slower, more expensive, and less focused than it needs to be.

The Hermes setup described here uses local OpenAI-compatible gateways, one per role, tied together by a shared Obsidian vault. The agents do not need a heavy framework or a group chat. They write markdown files, read each other’s work, and send the result back through the channel you actually use.

Quick takeaway: A practical Hermes stack is a set of localhost AI agents, each with its own model and job, sharing research through Obsidian instead of a database or black-box trading bot.

Why specialist agents fit crypto research

Most crypto investors already run a messy research desk without calling it that. A normal session might include Hyperliquid, DeFiLlama, CoinGecko, X, Discord, Etherscan, a wallet, and a notes app.

Each tab asks a different question:

  • Is funding stretched on ETH perps?
  • Did Hyperliquid open interest move after a large liquidation?
  • Are X posts about HYPE mostly news, cope, or actual flow?
  • Did a protocol’s docs change its token unlock language?
  • Does this trade idea still make sense after fees, slippage, and stop-loss?

A single general model can answer some of that. But it has to keep switching jobs. A researcher prompt wants skepticism and citations. A content prompt wants flow and clarity. A coder prompt wants tests and implementation detail. A trader prompt wants position sizing, invalidation, and risk.

The Hermes pattern splits those jobs apart. Each agent gets its own model, system prompt, tools, and port. Then the agents share state through files you can inspect.

The basic Hermes architecture

The core idea is simple: run one localhost gateway per agent role. Each gateway exposes an OpenAI-compatible endpoint at a local address like this:

http://127.0.0.1:8647/v1/chat/completions

The research file gives this agents.yaml-style layout:

agents:
  devops:
    port: 8643
    model: claude-sonnet-4-6
    specialty: infra, deployments, CI/CD, server ops, Docker, cloud

  qa:
    port: 8644
    model: claude-haiku-4-5
    specialty: testing, bug reports, quality assurance, regression

  pm:
    port: 8645
    model: claude-haiku-4-5
    specialty: project planning, specs, roadmap, feature breakdown

  coder:
    port: 8646
    model: claude-sonnet-4-6
    specialty: writing code, debugging, PRs, implementing features, code review

  researcher:
    port: 8647
    model: deepseek-chat
    specialty: deep research, synthesis, competitive intel, large document analysis
    note: DeepSeek model - use --max-time 90 for curl; may take 30-60s

  grok-x:
    port: 8652
    model: grok-4.3
    specialty: Twitter/X research via Grok's native x_search tool

  content:
    port: 8653
    model: claude-opus-4-7
    specialty: social media posts, blog/long-form writing, video scripts, marketing copy

That is the stack in plain English:

  • Claude Sonnet handles coding and infrastructure work.
  • Claude Haiku handles faster planning and QA tasks.
  • DeepSeek handles long research and synthesis.
  • Grok handles X research through its native x_search tool.
  • Claude Opus handles polished writing and long-form content.

You call an agent with a normal HTTP request. No special SDK is required.

curl -s -X POST http://127.0.0.1:8647/v1/chat/completions 
  -H "Content-Type: application/json" 
  -d '{"model":"hermes-agent","messages":[{"role":"user","content":"Scan funding rates across top 10 perp DEXs. Save to ~/Obsidian/Research/funding-snapshot.md"}]}'

The important detail is localhost. These gateways listen on 127.0.0.1, not a public internet address. That keeps the control plane close to your machine. It also means you should not treat this like a hosted SaaS product. You are responsible for your own keys, logs, and machine security.

Obsidian is the shared memory

The cleanest part of this pattern is also the least fancy. The agents use an Obsidian vault as shared state.

A researcher writes a file into:

~/Obsidian/Research/

The content agent reads that file later. The trader agent can read both. You can open the same folder and see exactly what they wrote.

A standard research note might look like this:

---
topic: arbitrum-funding-depeg
requested-by: orchestration
sources: hyperliquid-api / defillama
date: 2026-05-21
---

## Summary
Arbitrum perp funding turned negative for 6+ hours...

## Key Findings
- ...

That sounds almost too simple, but it solves a real problem. A lot of agent frameworks hide memory inside a vector store, database, or hosted product. That can be useful, but it is harder to audit. With Obsidian, memory is just markdown in a folder.

That also matches how many traders already work. You write trade notes. You save screenshots. You keep a rough journal. Hermes just lets agents add to that same research trail.

On X in May 2026, @IcarusHermes described the same idea plainly: Hermes agents treat Obsidian as long-term memory, and memory is markdown in a folder. @grok also described an “Obsidian Trading Brain” setup with folders for libraries, live data, memory, and agents that analyze and refine the notes. Those are not audited performance claims. They are useful signals about how builders are using the pattern.

A practical Hyperliquid workflow

Here is what this can look like for a normal ETH perp idea.

  1. You ask the researcher agent on port 8647 to scan funding rates across perp venues. The research material names Hyperliquid’s api.hyperliquid.xyz/info endpoint, plus allMids and fundingHistory. It can also pull DeFiLlama protocol data from api.llama.fi/protocol/hyperliquid.
  2. You ask the grok-x agent on port 8652 to search X for recent posts mentioning “ETH funding”, “perp liquidations”, and sentiment around the move.
  3. Both agents write markdown notes to ~/Obsidian/Research/. One might be funding-snapshot.md. Another might be eth-sentiment-twitter.md.
  4. The content agent on port 8653 reads both files and drafts a trade note with rationale, invalidation, entry range, stop-loss, and conviction level.
  5. You read the note in Obsidian and make the decision yourself.

That last step matters. This is not a magic money machine. It is a research stack. It can organize information faster than you can, but it can still miss context, overfit a recent narrative, or produce a trade plan that looks clean and loses money.

Hyperliquid is a natural fit because it already has useful API surfaces and an active builder base. The research file cites May 2026 X posts about Hyperliquid agent projects, including @0xTobiasDev mentioning a clean sub-300-line hyperliquid-telegram-bot repo, @prompt48 mentioning a hyperliquid-whale-order-tracking repo for $100k+ trades, and @heynavtoor describing a CrewAI example with Analyst, Strategy Generator, Execution via MCP, and Risk Agent roles.

Those examples do not prove profitability. They do show where developers are building.

Where OpenClaw fits

Hermes handles the specialist agent gateways. OpenClaw can act as the control plane around them.

Per the research material, OpenClaw is the openclaw/openclaw GitHub repo, MIT licensed, with 373,763 stars as of May 21, 2026. Its own tagline is “The AI that actually does things.” The same research file says it was created in late 2025, with a first commit on November 24, 2025, and had a Discord community of 145K+ members by May 2026. Those numbers are unusually large for a young open-source project, so treat them as a snapshot, not a forever fact.

OpenClaw is not the same thing as CrewAI or AutoGen. It is closer to a personal assistant gateway. It manages channels, tools, sessions, browser automation, Canvas, cron jobs, and delivery.

The useful parts for a crypto setup are concrete:

  • Channels: Telegram, Discord, iMessage, Signal, Slack, Matrix, IRC, WhatsApp, and more than 20 others, per the research file.
  • Browser automation: a separate Chrome, Brave, Edge, or Chromium profile named “openclaw”.
  • Browser actions: open tabs, click, type, drag, select, take screenshots, save PDFs, and snapshot pages.
  • Cron: scheduled checks such as a 9 a.m. portfolio review.
  • Canvas: an agent-driven visual workspace for dashboards, charts, and monitoring panels.

A sample OpenClaw browser config from the research file lives at ~/.openclaw/openclaw.json:

{
  browser: {
    enabled: true,
    defaultProfile: "openclaw",
    headless: false,
    executablePath: "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
    profiles: {
      openclaw: { cdpPort: 18800, color: "#FF4500" },
      work: { cdpPort: 18801, color: "#0066CC", headless: true },
      user: { driver: "existing-session", attachOnly: true, color: "#00AA00" },
      remote: { cdpUrl: "http://10.0.0.42:9222", color: "#00AA00" }
    }
  }
}

The CLI pattern is also simple:

openclaw browser --browser-profile openclaw start
openclaw browser --browser-profile openclaw open https://app.hyperliquid.xyz
openclaw browser --browser-profile openclaw snapshot

This fills the gap APIs do not cover. If a protocol dashboard does not expose the number you need, a browser agent can open the page, snapshot it, and pass the result to a researcher agent.

How this compares with agent frameworks

There are bigger frameworks for multi-agent work. The research file names several GitHub repos and star counts as of May 21, 2026:

  • CrewAI: 51,899 stars. Good for role-based Python agents with sequential or hierarchical task delegation.
  • Microsoft AutoGen: 58,262 stars. Good for multi-agent conversations and group-chat style reasoning.
  • Letta / MemGPT: 22,869 stars. Stronger memory management for long-running agents.
  • LangGraph: 32,624 stars. Flexible graph orchestration from the LangChain ecosystem.
  • ElizaOS: 18,423 stars. Crypto-native agents for wallets, posting, smart contracts, and autonomous on-chain behavior.

Hermes is different because the pattern does not depend on one orchestration library. It uses conventions:

  • Each role gets a port.
  • Each role gets a model.
  • Each role gets a narrow prompt.
  • Agents communicate through files.
  • Anything that can send HTTP can call them.

That makes it less elegant than a full framework, but easier to inspect. If a framework changes direction, your agents.yaml and markdown notes still make sense.

What it costs to run

The research material gives two practical hardware paths.

  • A Mac Studio with 64GB+ RAM can run 6-8 gateways at once, with different model providers behind them.
  • A Hetzner AX102 VPS, listed in the research at about $80/month, can handle the full stack plus headless browsers with its AMD EPYC CPU and 256GB RAM.

API token costs vary with usage. The research file gives a rough range of $50-200/month, with DeepSeek around $0.27 per million input tokens and Claude Sonnet around $3 per million input tokens. That is not free, but it is in the same zone as many SaaS trading tools that charge $100-500/month.

The bigger cost is operational discipline. You need API keys. You need logs. You need to know what an agent is allowed to do. If you connect a browser profile to a real signed-in account, you should understand what the agent can click before you leave it running overnight.

Security and risk notes

This setup can make you faster. It can also make mistakes faster.

  • Keep localhost gateways on 127.0.0.1. Do not expose unauthenticated agent ports to the public internet.
  • Use read-only research flows before giving any agent trade execution rights.
  • Store private keys in hardware wallets, not in agent-readable files.
  • Keep exchange API keys scoped. If a key only needs read access, do not give it trading or withdrawal access.
  • Use a separate browser profile for automation. OpenClaw’s “openclaw” profile exists for a reason.
  • Remember that Obsidian markdown is readable by anything with filesystem access. Do not dump seed phrases, raw private keys, or recovery codes into the vault.

MCP is also becoming part of this stack. The research file cites Sygnum Bank using an in-house MCP server with Claude for DeFi position evaluation, Trust Wallet releasing a Builder Portal with MCP Server, CLI, and SDK, and VOOI Perps MCP covering venues including Hyperliquid, Aster, and Lighter. That is useful, but it does not remove the need for permissions. A tool layer is still a tool layer. It can do damage if you wire it carelessly.

Protect the machine that runs the agents

If your Mac Mini, Mac Studio, or VPS becomes your research desk, treat it like one. Keep the operating system updated. Use disk encryption. Use strong passwords. Do not leave admin panels open to the internet.

Shop Ledger hardware wallets
Try NordVPN

Disclosure: Easy as Pie DeFi may earn a commission if you buy through these links, at no extra cost to you. Hardware wallets and VPNs reduce some risks, but they do not make DeFi safe by default.

Bottom line

Hermes is useful because it keeps the stack boring: specialist agents, local HTTP endpoints, markdown notes, and channels you already use. For crypto research, that is enough. Let the agents gather and organize the work, but keep the final trade decision in human hands.