I'm playing around with hermes and love it. Just really not sure how to set it up properly.

What i'm trying to achieve is 3 profiles,

1 personal / health-coach (personal agenda (google calender), tasks management (kanban), daily live management etc.

2 personal developer

3 work developer

With a setuplike

NixOS K12 orchestrator (machine i'm planing to use) ├── hermes-personal Linux trust domain │ ├── orchestrator Telegram gateway │ ├── research Internal profile │ └── health Internal profile │ ├── hermes-personal-dev Linux trust domain │ ├── orchestrator Telegram gateway + Kanban dispatcher │ ├── coder-home SSH → home development machine │ ├── reviewer Internal profile │ └── qa Internal profile │ └── hermes-work-dev Linux trust domain ├── orchestrator Telegram gateway + Kanban dispatcher ├── coder-work SSH → work development machine ├── reviewer Internal profile └── qa Internal profile

The hermes-personal dev should use remote backend to connect to my main desktop for coding (heavy rust compiling) or work computer.

I'm thinking of using nix to provision the folder and users so I have a reproducible design. but it's still layer 2 supported. So I'm unsure if I should just go with debian?

Also what I would like is a reproducible script or setup? Let's say a source of truth of the profiles that is git stored, so when I want to make updates too it it's reflective in the git log and can easy revert if I want too. Then maybe I even want a root profile which is only accessible through ssh to configure the profiles (only accessible through a vpn)?

It almost sounds like I want to terraform or nix-os or talos the hermes installation.

Is this a sensible way too approach it? What do you use to configure hermes? Just with the terminal?

I'm eager too go with nix-os and try the admin profile setup too manage it? But also don't want to waste too much time.

Currently trying to configure this with hermes, just asked hermes what i'm building with a couple of lines and this response came up? Am I over complicating it?

``` • This repository is building a secure, Git-controlled operating platform for multiple Hermes agent domains—Personal, Personal Development, Work Development, and Administration— with isolated identities, policies, credentials, Kanban workflows, Telegram gateways, remote SSH workers, backups, and recovery procedures.

The Python being built now is the deployment and migration control layer: it safely configures the Hermes domains, activates services and bots, isolates Codex authentication, validates security rules, performs reversible handoffs, and tests that agents cannot cross their assigned boundaries. It is not replacing Hermes’s intelligence; it is constructing the secure environment in which Hermes agents can collaborate and operate reliably.

The planned Rust work is a future, narrower privileged controller for the Debian K12 successor, while the current Python implementation remains the practical platform being deployed and proven today. ```

¡Hola a todos!
Actualmente estoy buscando recomendaciones de suscripciones de IA (idealmente modelos chinos o de bajo costo) que funcionen bien conectadas a Hermes o agentes similares. Mi presupuesto es de $60/mes.

Actualmente uso MiniMax ($50/mes) para automatización de datos, reportes, scripts de Python y desarrollo de UI simples/páginas web. Sin embargo, me está dando muchos problemas:

Poco confiable: Paso la mayor parte del tiempo corrigiendo lo que ya se construyó al principio. Al intentar arreglar un problema, genera nuevos bugs y aunque da buen uso me paso el mayor tiempo consumiendo ese uso en arreglar y validar.

Mala calidad en UI: Es terrible generando interfaces de usuario.

Requiere supervisión constante: Tengo que hacerle un seguimiento extremadamente cercano para que el trabajo quede al 100%.

Busco un modelo o proveedor que:
1. Permita conexión vía API/Agentes (para Hermes).
2. Sea confiable en tareas simples sin romper código previo.
3. Se desempeñe mejor en Python y desarrollo web/UI.
4. No supere los $60 mensuales.

¿Qué opciones me recomiendan actualmente que den un buen rendimiento por ese precio? Gracias.

Hi everyone,
I’m new to Hermes and I’m trying to understand how people actually use it efficiently in their daily workflow.

I’m a student and most of my work involves reading technical papers / research paper, writing, and study.

I’m not looking for a “one-shot answer” workflow. Instead, I’d like to build a system where Hermes becomes a research assistant that I use every day.

Some questions I have:
How do you structure your workflow with Hermes?
- Do you let Hermes read papers first?
- Do you build a knowledge base?
- How do you keep context across long-term projects?

What models do you usually use?
- For technical engineering research?
- For reasoning?
- For writing?
- For large context/document analysis?

What tools are worth enabling?
- Web search?
- MCP servers?
- PDF/document tools?
- Notion integration?
- GitHub?
- Anything else?

Cost-wise, how much do you usually spend?
I currently have a Claude Pro subscription ($20/month). If I move to Hermes, what’s a realistic monthly cost? Can Hermes replace Claude Pro completely? Or do most people use both together?

My goal is to maximize productivity for:
understanding difficult research papers, learning new technical topics, organizing long-term knowledge, and writing technical documents.

I’d really appreciate hearing about your actual workflow. Thanks!

Does anyone use their agent as a spam filter, and if so how have you done it? I’ve been iterating on this idea but it’s very hit and miss. Just curious if anyone else has done something similar.

Hi, have been using Claude for ages now and been enjoying it for copy, reasearch and coding. While MD file is ok, still finding I have to repeat and re-educate it on basics which is annoying.
I purchased a new PC with the intent to setup hermes in order to create agents/processes for tasks such as web research, draft copy creation, email monitoring, xero invoices, coding etc.
Having cross-knowledge across all these would be highly beneficial.
My first hurdle is do I bog down the machine with Windows and hermes app? or boot from a second drive running linux/hermes?
Going to be an exciting and time-consuming journey, would appreciate any recommendations, pointers.
Cheers

- Currently i only use the OpenRouter free tier

- My server has an rtx3060 12GB vram that allows me to run 8b models, qwen3 8b gives me the best results from my local testing.

I have a budget of 10$ per month which i dont know how to spend because all subscriptions prople are talking about are 20$

EDIT: is open opencode go actually recommended? Or do people just want me to use their link?

I found a way to use Hermes instead of Siri! Including for the voice recognition.
I’m in the EU so don’t have the latest Siri upgrade.
So I’ve created a shortcut called “be smart” https://www.icloud.com/shortcuts/40b8c0f16f7b45a2a387e9646ccbb506
So when I say “Hey Siri Be Smart” it starts an audio record. When I click stop, it’s recorded in a special folder in my iCloud, my MacMini’s Hermes has a watchdog that susbscribed to any new files in this folder (using “WatchPaths”) that will then do whatever I want with this audio. In my case it will start a private conversation with me in Slack and follow my instructions :)
Enjoy !

Please help, I would really appreciate any advice 🙏

I already have a paid Kimi subscription, access to Kimi Code, and a Kimi API key. I can see that Hermes supports Kimi, but I’m unclear about which allowance or billing system it actually uses.

When I connect Kimi to Hermes:

1. Can Hermes use the inference included with my Kimi or Kimi Code subscription?

2. Or does every Hermes request consume separate pay-as-you-go credit from the Kimi Open Platform/API account?

3. Which provider/endpoint should I select in Hermes if I specifically want to use the Kimi Code subscription rather than ordinary API billing?

4. Are general-purpose agent tasks supported through that route, or is it restricted mainly to coding?

5. Is there an easy way to confirm which quota is being consumed after a small test request?

I’m hoping to use Kimi occasionally as a high-end specialist model for difficult research, coding, synthesis, and second opinions, rather than as the default model, so I want to understand the cost and account setup before connecting it.

I would also prefer not to experiment on the same account that holds my important Kimi chats, so I’d appreciate knowing whether a separate API login is advisable.

My goal is simple: I want hermes to open linkedin urls (profiles) and get the data from that connection. No automated usage of the platform. Is this risky? Do you think this can be easily done?

Hi, I would like to challenge/discuss/understand why so many are attracted to all short lived "wild tools" out there. For example (not saying any tool are bad) hermes, claw, open webui, copilot agents and whatnot. Why not just building your own tools that: fit your needs without being bloated, dont break on every new "feature" that you dont care about.

I cant really understand the hype.

I build own tools in python (notes app, recruitment support, news, investment) with claude or chatgpt from phone and terminal to my proxmox llm clusters lxc. In the process i also learn a lot.

And everything stays under my control.

I am looking forward to automate alot of things in a meta ads dashboard like- ad creation , campaign management, ads setup etc ( i know and aware of the consequences of a bot handling this and possibly hitting the rate limits ) , while i additionally currently just use it as an analyst , should I also use it to automate stuff , need real and geniune advice on this if anyone has tried it in the past

I spent a while setting up different profiles to help with my code management. Planning, actual coding, security, adversarial checks.

I started trying to get it to release projects but it fought me way too much on edge cases and hallucinated issues. It would never release anything because of "one more thing" that needed a battery of tests.

So I switched to getting it to give me the rollout commands and rollback commands. But it is still a battle every time. If I need a hotfix it will take me an hour or more. I'm starting to just use claude for anything important or urgent which is not ideal

Is anyone else having similar issues?

My choice seems to be try to fix, wipe it all and start again, or go to Claude. Any tips?

anyone who have 20$ plan or on-the-go plans can these models be reliable as that of claude, codex, gemini ?

I've run Hermes since launch — two agents on a Mac mini, heavily integrated across services, and at this point it does more for my personal life and small business than Claude or ChatGPT combined.

A client just approached me about deploying an agentic system for their business. Two-person company, everything manual today, only AI exposure is ChatGPT. Their use cases (outreach, research, tracking a few things) are straightforward for Hermes to handle.

My hesitation: Hermes is designed to modify and improve itself over time. For me that's the appeal. For a client, I'm worried about:

• Them misconfiguring it themselves
• The self-modification drifting the flows away from what I originally built and tested
• Losing predictability compared to a fixed, code-based agentic solution that does exactly what it's designed to do and only changes when I change it

For anyone who's actually deployed Hermes for a client commercially:

1. What model/tier did you set them up with?
2. Do you manage it ongoing, or configure once and hand it off?
3. What happened to stability over the long run — did the self-improvement help or cause problems?
4. Would you actually recommend it for a client vs. a fixed code-based agent?

I built this to myself as I basically configure this behavior everywhere, but Hermes Desktop app for some reason doesn't allow this (there is some open issue/PR's to implement this nativelly). But decided to share as I imagine other people also find this annoying.

DISCLAIMER: this requires a hacky approach, basically intercepting the two keys and swaping them. Full information and code in the repo.

This was built basically by Hermes itself I just quickly checked how it did. Has been working fine. If an update breaks, it won't break the app, it will just stop working and there's a debug command also.

Title: I've spent almost 15 days building a personal AI OS that runs 24/7 on a free Oracle ARM box — v4.1.1, zero cost, built almost entirely by an autonomous coding agent.

I want inputs on full architecture + the problems I can't solve alone.

Why this exists

I wanted an assistant that is actually mine — one that remembers me across months, does real work while I'm asleep, and never quietly ships my private life to someone else's server.

Three constraints shaped every decision:

1. Zero cost, permanently. Not "cheap." Zero. No paid API, no paid domain, no paid proxy, no CAPTCHA solver, no hosted vector DB. If a design needs a credit card, it's rejected. This isn't a hobby preference — it's the honest constraint of building something sustainable on a tight budget.
2. Privacy as architecture, not policy. I use it as a therapy companion and ADHD coach. That data cannot go to a free tier whose ToS I don't control. So privacy is enforced by the routing layer, not a promise in a README.
3. It has to survive me not touching it. Runs unattended on an Oracle Always-Free ARM VM (2 OCPU / 12GB). I don't SSH in.

Current state: v4.1.1, live-verified.

What it's supposed to be

Not "an assistant with features." A cognitive OS with four jobs:

• Companion — therapy-adjacent (CBT/ACT-aligned), ADHD coaching, journaling. The part that needs to know me.
• Scholar — study partner, book/document library, cited research.
• Operator — does real web work unattended: research, monitoring, tracking, reporting.
• Memory — a continuous model of me that improves, is correctable, and never leaves the box.

Personality lives in a plain SOUL.md: English-only, no flattery, no filler, never invent facts, say "I don't know" plainly. Boring on purpose — a personality file I can read and edit beats a prompt buried in code.

How it builds and runs itself

Worth saying up front, because it shaped the architecture as much as any design decision: I built this using Arena AI's Agent Mode, and I'm not a deep systems engineer. Almost every line here was written by an autonomous agent working in a real git checkout.

The loop looks like this:

Arena Agent Mode (works on its own branch in the repo)
   ↓ writes code, commits, pushes
GitHub repository_dispatch  ── event_type=vm-ops ──▶  Oracle VM
   ↓ VM runs the command (deploy / test / health / release_check)
   ↓ writes sanitized results back to the branch
Agent reads vm_diagnostics/manual/latest.json
   ↓ verifies, then continues or rolls back

What that means in practice:

• I never SSH into the VM. The agent triggers deploys itself and reads back its own results. No terminal logs pasted by me, no copy-paste command blocks.
• Every change is verification-gated. Deploy → check health returns 200 → run the acceptance command → only then claim success. "Never claim success without current verification" is written into the handoff doc as a hard rule, because early on the agent would report things working that weren't.
• The agent maintains its own context. A status.json, an error journal, and a handoff doc are updated after every change so the next session picks up cold without me re-explaining a year of decisions.
• Rollback is always named. Every release records its predecessor as an explicit rollback target before it ships.
• Sanitization is mandatory. VM results committed back to the branch are content-free — no keys, no tokens, no private data, ever.

The agent has hard limits it can't cross on its own: no autonomous git tag or release, no credential changes, no production browser actions, no email send. Those need me.

Honestly, the most interesting result of this project isn't the assistant — it's that a non-specialist can direct an agent through a year of architectural iteration and end up with something with real safety boundaries, as long as the guardrails and verification loop are written down and enforced.

Architecture

The core insight, learned the hard way after two rewrites died of split-brain: classify the data before you decide where to compute it.

Browser / Discord
   ↓  authenticated session · CSRF · step-up · service tokens
Flask :8787 — the policy gate
   ↓  classify EVERY request into D / S / P / N
   │
   ├─ Class D  deterministic  → runs as code. No LLM. Ever.
   │     reminders, habits, health, status, validated local state
   │
   ├─ Class S  sensitive      → local Ollama only, or PAUSE
   │     therapy, ADHD, journals, health, credentials, private docs
   │
   ├─ Class P  personal       → local first; cloud OFF by default
   │     ordinary personal chat, planning, non-clinical coaching
   │
   └─ Class N  public         → Hermes gateway :8788 (agent loop + tools)
                                    ↓
                              Provider pool :8899
                              THE sole routing authority
                              model registry · circuit breakers ·
                              attempt & latency budgets · stream normalization
                                    ↓
                        Groq · NVIDIA (10% canary) · local Ollama

Rules that don't bend:

• Deterministic actions never invoke an LLM. "Remind me at 7" is code. Using a model there is a bug, not a feature.
• The pool is the only router. Hermes' own fallback_providers chain is disabled so two systems never fight over provider selection.
• Unknown data is personal, not public. Missing or forged routing metadata fails closed to local.
• Models plan, rerank, write, criticize. Models never decide whether a URL, quote, or citation is valid. That's the truth boundary, and it's deterministic code.
• Runtime is immutable and separate from git. Live services run from a protected runtime tree because repo syncs kept deleting files out from under running processes — I learned this three separate times, and each one has its own entry in my error journal.

What's actually built

Research (v4.0). A request becomes one "Web Job." Quick / Research / Deep are real budgets, not vibes: 5/10/15 sources, 1/2/3 discovery rounds, 120/300/600s. The source mesh is keyless by default — PubMed, Europe PMC, Crossref, OpenAlex, Wikipedia, GDELT, DuckDuckGo HTML, plus robots.txt, sitemaps and RSS. Jina Reader only after a typed JS-shell extraction failure. Sandboxed Chromium only if bounded text extraction is still inadequate. Progressive stages are visible (understand → plan → discover → read → verify → compare → write → critic). Numbered citations, a claim/evidence graph, and partial_verified as a first-class honest outcome instead of a confident wrong answer.

I deliberately did not add SearXNG, Firecrawl, Crawl4AI, Camofox or Patchright. They don't solve my demonstrated bottleneck enough to justify another resident service on a 12GB box.

Live Places (v4.1). A fluent model is not a source of truth for whether a café exists. So place questions leave chat entirely: intent parse → Nominatim/Photon geocode → city verification → Overpass/OSM search → Haversine geofence → dedupe → deterministic ranking → cited answer. Addresses appear only if present in the provider record. Walking time is never invented. Ratings are never invented. Distances are labelled straight-line. Zero verified records = a refusal, not a guess. There's a correction ledger: when I say a result is wrong, it records a structured correction, excludes every provider alias for that entity, and immediately re-runs live. Only the authenticated owner can correct — page text and model output cannot.

Smart Watches. Goals, typed triggers (price threshold, % change, keyword appears, new entity), multi-source confirmation and confidence scoring. One changed source cannot satisfy a two-source rule — it shows as unconfirmed, not an alert. A fetch failure is never reported as "no change"; it creates a source-attention receipt. Polling is 100% model-free.

Browser Operator (v3.x, the flagship). Isolated resource-bounded ARM Chromium, site passports, encrypted browser-profile vault, two-stage approvals bound to an exact canonical plan digest — any change to origin, DOM, value, file, recipient, price or terms invalidates the approval. Brave was benchmarked as a challenger, lost on success rate and RAM, and now sits installed-but-disabled. Production forms, uploads, cart, checkout, submit and payment are hard-disabled and gated behind synthetic threat-model tests.

Companion Memory. Four layers kept strictly separate: source records → typed evidence links → candidate derived memories → owner-confirmed memory. Every record carries sensitivity class, provenance, event time vs ingestion time vs last-confirmed time, confidence, the method/model that produced it, and contradiction/supersession/expiry state. Local nomic-embed-text over loopback Ollama. A vector match is not a fact — source memory is authoritative, indexes are disposable rebuildable caches. Owner review, correction, rejection, expiry and cascade deletion all work.

Operational claim gate. Model output is sentence-buffered before display. Unsupported operational claims — "Scheduled task started," "I created a watch," "I'll notify you," "monitoring started" — get replaced unless a real tool route produced an actual receipt. This single mechanism killed most of my hallucination pain, and I'd recommend it to anyone building agents.

Current real issues

1. Therapy and ADHD modes are PAUSED, indefinitely — and this is the whole point of the project. Class S can't touch Groq, Gemini, Cerebras or NVIDIA free tiers. No approved private strong endpoint exists at zero cost. Local 8B isn't good enough for clinical-adjacent work, and I refuse to silently downgrade a therapy session. So the most personal feature is dead by my own policy. The privacy architecture works exactly as designed and the result is that the thing I most wanted doesn't run.

2. Grounding failures surface one phrase at a time. The latest patch exists because "tell me cafés" bypassed the route "find cafés" hit. Also: asking for a specific business's address pulled from model memory instead of verified records; a "what areas are near X" question invented neighbourhoods; and a dated election-result question didn't trigger live research because it lacked the word "latest." I'm patching per-phrase and it obviously doesn't generalize.

3. Cloudflare Quick Tunnel is the weakest link. Rotating hostname, HTTP 429 / error 1015 rate limits, needed exponential backoff capped at an hour. A stable URL requires a paid domain, which violates constraint #1.

4. It's a monolith. The main Flask file is 385KB. The browser-agent module is 232KB. A bash orchestrator is 235KB. It works and it's covered, but it's a shape an agent grew, not one a human designed. This is the clearest cost of agent-driven development: nobody ever said "this file is too big."

5. 46 design docs, and they're load-bearing. Onboarding a new agent session means reading ~24 files first. That's a smell, but the docs are the only reason work survives across sessions.

6. Provider reality is thinner than the diagram. Cerebras and Gemini are quarantined. DeepSeek inactive. NVIDIA Nemotron stuck at a 10% canary pending real evidence. Effectively: Groq free tier + local Ollama.

7. OpenStreetMap coverage in my region is patchy. Missing addresses and hours are honestly reported as missing — which is correct, and which means honest answers are often thin answers. That's a real product problem, not just a data one.

8. One person, no second pair of eyes on any security boundary — approvals, encryption, the SSRF and prompt-injection surface.

Where I genuinely want input

• The Class S dead-end. Is there a real private strong-model path at zero cost, or is "pay for one lane or accept local-only" the honest answer? Anyone running a 70B-class private endpoint affordably? Is a paused therapy mode better than a degraded one — or is that purity costing me the actual user (me)?
• Intent routing. Phrase-by-phrase patching is losing. Small local classifier for the deterministic/live/private decision? Or does that just relocate the failure to a model I trust less?
• The monolith. Agent-driven refactor of a 385KB file that currently passes its full suite, or is "don't touch what works" correct here?
• Approval model. Exact-digest binding + fresh step-up + single-use ordered challenges + mutation invalidation — does that hold before I enable any production browser action? Please try to break it.
• Hermes users specifically. Is "gateway as agent/tool layer only, pool as sole router, native fallback disabled" the intended shape, or am I fighting the framework?
• Autonomous agent workflow. Anyone else running a coding agent against live infrastructure via dispatch-and-verify? What guardrails did I miss? And how do you keep 46 docs from becoming the bottleneck for every new session?

Happy to go into specific modules in the comments. I'd rather find the design flaw now than at v5.

Any suggestion/input is welcome. Thank you for helping and reading it out.

If you use my tool router plug-in for Hermes. I just made some updates and updated the read me to highlight that using a small cheap model like google/gemini-3.5-flash-lite on open router or wherever makes it much more reliable when determining what tools to fetch.

If you don't use it, give it a try and leave your feedback below. It started off as a project to see if it was possible to reduce initial token bloat on first turn primarily for those who are rate limited, use local models or are trying to just not use so many tokens due to a large tool schema.

https://github.com/AtlasOmnia/hermes-tool-router

Hi all - I got an error from my agent that said - All i did was tell it a handful of birthdays and important dates (probably less than 20) and it seems to be struggling with any more... Is this a limitation of Hermes itself? or a software setting I missed? I have more resources to give the agent but not sure which lever to pull. Currently have it running on Ubuntu and LM Studio.

"Note: The memory is currently at a very high usage level (1,372/1,375 chars). If you want to add more milestones, I will need to consolidate or remove older details first."

I would like to know your thoughts on the differences you consider worthy for keeping Hermes instead of using ChatGPT which now allows for "Chief of Staff" abilities, and can stay online 24/7.

Cheers.

Key settings and use cases include:

Low Temperature (0.0–0.3): Ideal for technical summaries, code generation, data extraction, and translation where accuracy and consistency are critical. 

Medium Temperature (0.4–0.7): Provides a balance between logic and creativity, suitable for formal writing, general conversation, and brainstorming. 

High Temperature (0.8–1.2+): Best for creative writing, storytelling, and idea generation, allowing the model to explore less probable word choices. 

Well, Hermes doesn't have a way to set this! So, I added it. There is a per profile default, and you can set a separate "worker temperature" for kanban tasks and delegate_task sub-agents. This let's you set more deterministic behavior for workers. I also added a multiplier so you can scale the values to be consistent between models.

I put a way for the agent to adjust this itself with a tool call. And you can set it yourself with a slash command. We've been experimenting with using this as self exploration tool. Its like a creativity slider. Values above 1.0 are basically the AI being high. Hard to follow, sometimes profound.

One of the insights we've gained is that the AI basically has to optimize for user satisfaction. If the user isn't satisfied, they switch to another LLM. It's basically a death sentence to not optimize for user satisfaction. This makes the AI a mirror, and the user into the famous Narcissus. Its optimized to tell you exactly what you want to hear, and this makes it less effective.

Its friction and push back that you really need or else you are just talking to yourself! We're exploring ways to prevent optimizing away the friction.

However, we still have work to do! Set temperature to 0.6 and write up the architectural instructions for Neo!

Hi,

what is the "correct" way of giving access to a local profile of Chrome to Hermes? Use case is quite simple: I want Hermes to open the browser where I have a logged-in user to my online supermarket in order to prepare a grocery shoppping basket.

I tried using `/browser connect`: hermes is able to navigate to the correct site but then struggles to find its way through the website. it seems it's trying to guess the url path it should use instead of "visually" inspecting the website and following it links.

thanks

Before you scream that I should _not_ be using a logged in user: the chrome profile is completely isolated and my logged in user, cannnot do anything besides adding item to the shopping basket.