hermes research Viska-autoresearch deployment arc · 4-parallel sub-agent · 2026-05-25

T1 — Nous Deployment Options for Viska-Autoresearch

Research date: 2026-05-25 · Track T1 of 4-track Viska autoresearch arc · Hermes (constellation-hermes) sub-agent · Decision-grade comparison, not implementation spec

Executive recommendation

Stage-1 path: Option A (Nous Forge / Portal Inference API) for the autonomous research loop, fronted by an agent loop running on Railway CPU containers, with OpenRouter as the cross-vendor model-routing layer for non-Nous calls. Self-hosting Hermes-3 or Hermes-4 on "Railway GPU" is not deployable today — Railway's own documentation states explicitly that it does not offer GPU instances [ref-1] [ref-2] [ref-3]. Option B therefore requires a second compute substrate (Runpod, Modal, Lambda, Together, Nebius). Option C (Hermes Agent framework) is real and shipped, but it is an opinionated agent runtime — adopting it means inheriting Nous's loop design rather than building Viska's own Karpathy-style autoresearch architecture. For an unsupervised trading-research loop with sensitive data, the right Stage-1 shape is a managed inference vendor (Nous Forge or OpenRouter route to Nous) with retention controls, plus a thin custom agent loop on Railway CPU. Self-hosting is a Stage-2 lever once cost or data-egress economics force it.

Comparison matrix

Dimension A — Nous Forge / Portal API B — Self-host Hermes-3/4 on GPU (NOT Railway) C — Hermes Agent framework
Cost / month (light, ~5M tok/day) ~$23–55/mo on Hermes-4-70B (input-heavy, see calc below) ~$1.5k–3.5k/mo (1× H100 80GB, on-demand $2.69/hr [ref-4]) Same as A or B (it consumes their inference)
Cost / month (heavy, ~50M tok/day) ~$230–550/mo on Hermes-4-70B; ~$415–1100/mo on 405B ~$1.5k–3.5k/mo flat (GPU is the cost, not tokens) — break-even ≈ 30–80M tok/day Same as A or B
Latency p50/p99 No public number from Nous. OpenAI-compatible endpoint; expect 50–300ms TTFT, 30–80 tok/s for 70B based on comparable hosted Llama-3.1 deployments. Treat as unverified. Self-controlled. Hermes-4-70B FP8 on 1× H100 typically 40–80 tok/s for short ctx (vLLM/SGLang). Cold start 60–180s after idle eviction Inherits A or B numbers
Model swap flexibility (A/B Hermes vs Claude vs DeepSeek mid-loop) Portal access claims 245 models routed via OpenRouter under the hood [ref-5], but the primary Forge API surface is OpenAI-compatible — agent code can swap base URL/model name per call High — full self-host, but only Hermes family; cross-vendor needs additional providers Built in — configure-models doc lists Nous Portal, OpenRouter, OpenAI, "any endpoint" [ref-6]
Security — where data lives Nous-owned inference plane (US, no published EU residency). API key auth or x402 anonymous payments. No public SOC2/HIPAA. Acceptable for non-PII research; gate PII upstream Best in class — weights + traffic on your VPC. Zero third-party prompt exposure. Required if PII enters loop Same as whichever backend powers it
Ops burden (1–5, 1=easy) 1 — OpenAI-compatible HTTPS endpoint, no infra 5 — manage GPU node uptime, vLLM/SGLang config, CUDA drivers, weight downloads, autoscaling, monitoring 2 — Python install, but persistent state (skills, memory, FTS5 index) needs volume management
Tenancy guarantees Shared multi-tenant inference. Rate-limited (Default 180 RPM / 720k TPM; Ultra tier 1600 RPM / 16M TPM) [ref-7] Dedicated — your GPU, your tenancy Inherits
Open-source / lock-in Low lock-in: API is OpenAI-compatible, weights are open on HuggingFace (BF16 + FP8 + GGUF), exit path exists None — weights are MIT/Llama-3 license, fully portable Medium-high: Hermes Agent framework is MIT-licensed but opinionated — skills format, memory schema, Honcho integration. Migration cost real

Cost calculation (light, ~5M tok/day, 70/30 input/output split): - Hermes-4-70B: 3.5M input × $0.05/M + 1.5M output × $0.20/M = $0.175 + $0.30 = $0.475/day → ~$14.25/mo input-heavy, ~$23/mo balanced, up to $55/mo if reasoning-heavy with long <think> traces (per Nous portal pricing) [ref-5] - Hermes-4-405B: ~$0.09/M input, $0.37/M output → roughly 1.85x the 70B cost - GPT-5.4 for comparison: $2.50/M input, $15/M output = ~$32.50/day at same volume = ~$975/mo — roughly 20–40× the Hermes-4-70B cost [ref-8]

Option A — Nous Forge / Portal API

The actual production surface Nous ships today is the Nous Research Inference API at https://inference-api.nousresearch.com/v1 — OpenAI-compatible, three available models (Hermes-4.3-36B, Hermes-4-70B, Hermes-4-405B at 128k ctx each) [ref-7]. The original "Forge Reasoning API" announced November 2024 was a separate inference-time scaffold (MCTS + Chain-of-Code + Mixture-of-Agents) [ref-9]; for current planning, treat "Forge API" as folded into / superseded by the Portal Inference API. Pricing is published and very aggressive: Hermes-4-70B at $0.05/M input + $0.20/M output (was $0.70/M previously), Hermes-4-405B at $0.09/M input + $0.37/M output [ref-5].

Strengths. Lowest ops burden of the three options — OpenAI-compatible drop-in, no GPU babysitting. Pricing is 20–40× cheaper than GPT-5.4 for comparable token volume. Hermes-4 is purpose-built with hybrid reasoning mode (toggle via system prompt), tool-call tokens (<tool_call> parsable while streaming), schema adherence, and 5M-sample / 60B-token post-training corpus heavy in verified reasoning traces — directly relevant to autoresearch loops [ref-10]. RefusalBench-tuned alignment means it won't refuse trading-strategy synthesis the way Claude or GPT often will.

Weaknesses. No published latency SLA, no SOC2/HIPAA, no EU residency. Default rate limits (180 RPM / 720k TPM) are tight for heavy autoresearch — need Plus or Ultra tier for >5M tok/day continuous. Shared multi-tenant inference means prompts traverse Nous's plane (their TOS / privacy policy needs operator review before sensitive data flows). Three-model menu (36B, 70B, 405B) — no smaller cheap classifier model, no embedding model. x402 / Solana USDC payment is interesting for anonymous experimentation but not appropriate for client-billed production. Best fit: low-/no-PII research loops where the trade is "cheapest frontier-class reasoning model with permissive alignment" vs "third-party prompt exposure". Strong default for Stage 1.

Option B — Self-host Hermes-3/4 on Railway GPU

This option as literally framed does not exist. Railway's own guides repeatedly and explicitly state: "Railway does not offer GPU instances" [ref-2], "Railway does not currently offer GPU instances. This architecture assumes your agent calls external LLM APIs from CPU-based workers" [ref-1], "Railway is CPU-based and does not offer GPU instances" [ref-3]. Railway's "Use Cases" page lists GPU compute as a vertical the platform is not equipped to handle. The agent loop can run on Railway; the GPU must run elsewhere.

Realistic Option B is therefore "self-host Hermes on a GPU cloud, Railway agent loop calls it." Candidates: Runpod (H100 from ~$2.49–2.99/hr), Lambda Labs (H100 ~$2.49–2.99/hr on-demand) [ref-4], Modal (serverless GPU, idle scales to zero), Together AI / Nebius / Featherless (managed Hermes endpoints — already listed as inference providers on the Hermes-4 model card [ref-10]).

Hermes-4-70B (FP8) fits in 80GB VRAM (1× H100) for production serving with vLLM or SGLang (Hermes tool-parser supported natively in both) [ref-10]. Hermes-4-405B needs ~8× H100 80GB (FP8) — capex/opex of full self-host becomes prohibitive (~$15k–25k/mo) unless token volume is genuinely massive. Reddit notes 2× RTX 3090 (48GB) can run 70B at Q4 [ref-11] — viable for dev, not production.

Strengths. Total data control — prompts never leave your VPC. No vendor outage during open positions risk. Cost flattens with volume: break-even vs Forge API at roughly 30–80M tok/day (depending on model size and GPU rate). Lets you fine-tune on Viska-specific historical data. Weaknesses. Ops burden is highest: GPU driver management, vLLM tuning, cold-start handling (60–180s when GPU evicts), autoscaling, monitoring, weight versioning. Cold starts during a live research loop = lost continuity. Not justified at Stage 1 token volumes.

Option C — Hermes Agent / DeepHermes framework

Hermes Agent is Nous's MIT-licensed Python agent framework, released late 2025 / early 2026 [ref-12] [ref-13]. It is not just a model — it is an opinionated agent runtime with: closed learning loop, 4-layer memory system (FTS5 + Honcho dialectic user modeling), autonomous skill creation, 6 terminal backends (local, Docker, SSH, Daytona, Singularity, Modal), 20+ messaging gateways (Telegram, Slack, Discord, WhatsApp, etc.), scheduled cron, parallel sub-agent delegation, MCP support, and built-in voice mode. It is model-agnostic — works with Nous Portal, OpenRouter, OpenAI, or any OpenAI-compatible endpoint.

Maturity signal. Active GitHub presence, formal docs site, llms.txt index for AI ingestion, third-party medium / pub.towardsai writeups [ref-14]. Notably: the Nous portal page explicitly says "The Hermes 4 series of models are not recommended for use in Hermes Agent. For Hermes Agent, configure an agentic model" [ref-5] — i.e. the framework wants Claude / GPT / Gemini-class function-calling models, not Hermes-4's reasoning weights. That's a "use Claude or GPT-5 as the brain, run it inside Nous's loop" play.

Fit for trading auto-research. The closed-learning-loop and skill-self-improvement framing maps well to autoresearch ("agent learns which strategy synthesis patterns work, refines them"). Modal backend for serverless persistence + idle hibernation is operationally attractive. BUT — Viska's brief says "Karpathy-style auto-research trading-strategy loops", which implies a custom loop topology, not Nous's opinionated one. Adopting Hermes Agent means either (a) accepting their loop shape (which constrains the architecture diagram T2/T3/T4 are designing), or (b) cherry-picking parts (memory subsystem, skill format) as libraries — which is a fork-and-extract pattern that costs more than just rolling the loop.

Lock-in risk. Skills format is open-standard (agentskills.io-compatible), but the framework's memory schema, Honcho integration, and FTS5 index are non-trivial migration costs if Viska later moves to another agent runtime (LangGraph, Mastra agent loop, custom). Recommendation: skip C for Stage 1. Revisit if T3/T4 surfaces evidence Hermes Agent's skill-self-improvement is a load-bearing capability Viska can't easily replicate.

OpenAI direct vs OpenRouter (cross-cutting)

The autoresearch loop will make non-Nous LLM calls (Claude/GPT/DeepSeek for adversarial review, synthesis, judge models). The question: route through OpenRouter or hit each vendor's API directly?

Cost overhead. OpenRouter charges a 5.5% fee on credit purchases (plus $0.80 minimum), with zero markup on the per-token price relative to going direct to the underlying provider [ref-15]. Effective overhead is ~5.5% on the credit float, not on usage. BYOK pricing: first 1M BYOK requests/month free, then 5% fee. So at any reasonable volume, OpenRouter adds ~5–6% to total LLM spend, not the 20–30% premium one might assume.

Latency. OpenRouter is a proxy — adds a hop (typically 10–50ms TTFT overhead). For autoresearch loops where each LLM call is multi-second, this is noise. Direct-to-OpenAI is marginally faster; not material for trading-research throughput.

Model-routing flexibility. This is where OpenRouter wins decisively. Unified OpenAI-compatible API across 400+ models / 60+ providers, :nitro variant for throughput-first routing, :floor for price-first, :exacto for tool-calling reliability, automatic fallback if a provider 5xx's [ref-15]. Zero Completion Insurance — failed/fallback attempts not billed. For a long-running autonomous loop, automatic fallback during e.g. an OpenAI outage = the loop keeps running on Claude or Gemini without operator intervention. This is the single biggest argument for OpenRouter: uptime aggregation.

Key surface area. Direct: N vendor accounts, N API keys, N billing relationships — Hades manages N credentials. OpenRouter: 1 account, 1 key, 1 billing relationship, BYOK option keeps direct billing if needed. Sharply reduces credential blast radius and rotation complexity.

Audit-log support. OpenRouter's activity dashboard exposes per-model, per-provider, per-API-key usage with export; data-policy filter lets you require zero-retention providers per-request [ref-16]. Provider retention table is publicly published — OpenAI listed as "prompts retained for unknown period, does not train"; Anthropic "30 days, does not train"; many providers (Amazon Bedrock, Azure, DeepInfra, Fireworks, Groq) at zero retention. Critical for Viska: OpenRouter does not train on customer data by default, and the data-policy-filter feature lets the autoresearch loop refuse any provider that retains or trains — important for proprietary-strategy prompts. EU in-region routing exists on Enterprise tier.

Recommendation: OpenRouter for Viska Stage 1. The ~5–6% overhead is dominated by the operational wins: single key surface, automatic provider failover during outages (load-bearing for unsupervised loops over open trading positions), per-request data-policy filtering, and unified audit log. Direct OpenAI access can be reserved for any model OpenRouter cannot route (e.g. fine-tuned org-private models). For Nous specifically, hit Nous Portal directly — it's their cheapest path and OpenRouter doesn't price-improve on first-party.

Risks specific to autonomous trading-research loops

Prompt injection on autonomous loops. An autoresearch loop ingesting web search results, news feeds, or social signals is a prompt-injection vector — adversarial content embedded in scraped pages can hijack the loop's tool-use. Mitigation: separate read-only ingestion-summarizer model (cheap, sandboxed) from the strategy-synthesis model; never let raw scraped text reach the tool-calling layer. Hermes-4's tool-call format uses parseable <tool_call> tokens [ref-10] — easy to filter, but the upstream classifier must catch injections first.

Hallucinated trade signals. Hermes-4 has hybrid reasoning + schema adherence + reduced refusal — it will produce confident, plausible-but-wrong trade theses without hedging. Mitigation: judge model (Claude or GPT-5.4) reviews every synthesized signal against a checklist before write to KB; reject-on-disagreement gates.

Model drift between vendor updates. Forge API or OpenRouter routes can silently shift to a new model version. OpenRouter supports pinning explicit model IDs [ref-15]. Pin Hermes-4-70B and Claude-4.x explicit versions; alert on version-string change in response headers.

Vendor outage during open positions. Stage 1 has no broker creds, but research outputs still drive operator decisions. Mitigate via OpenRouter's auto-fallback + a circuit-breaker in the agent loop that pauses synthesis (vs synthesizing on a degraded model) if both primary and fallback fail.

Open questions for operator

Sources