Run Your Own Cloud AI Agent with Hermes - No Terminal Required

Update, August 2026 — the setup I'd build today

When I first wrote this, standing up Hermes meant renting a box on Railway, wiring in OpenRouter for inference, and gluing the pieces together yourself. That path still works, and it's still below—but two months later there's a shorter one. Nous Research now hosts Hermes for you, and the agent has grown a real tool layer and a real memory layer worth turning on from day one.

Here's the stack in one line: Nous Portal Plus ($20/month) for hosting and inference → a cheap or free model → Composio as an MCP server for tools → Honcho for memory.

1. Host it on Nous Portal instead of Railway

Nous Portal is Nous Research's own platform, and Hermes Cloud is its one-click hosted agent. No Railway template, no volume to configure, no redeploys.

The Plus tier runs $20/month and includes:

• $22 in monthly credits (a 10% bonus on what you pay), with up to $10 rolling over month to month
• 400 requests/min and 4M tokens/min rate limits
• Access to the full catalog—248 models plus 29 embedding models, spanning Anthropic, OpenAI, Google, Meta, Mistral, DeepSeek, and Nous's own Hermes series
• The Tool Gateway: web search and scraping (Firecrawl), image generation (FAL, Krea), video (FAL), speech (OpenAI audio), browser automation (Browser Use), and code execution (Modal sandboxes)—all routed through the one subscription, no separate API keys to collect

There's a free tier ($0, free models only, 50 RPM), and Super at $100/month and Ultra at $200/month if you outgrow Plus. For most personal agents, Plus is the sweet spot.

To deploy:

1. Sign in at portal.nousresearch.com and subscribe to Plus (or top up credits—Cloud wants $10 minimum on the balance, or an active subscription).
2. Go to Cloud and start a new instance: give it a name, pick a starting model, choose a size.
3. That's it—your agent is online.

Instance sizes bill hourly for compute only, and scale to zero when idle:

Inference and tool usage bill separately against your credits. Hermes Cloud is still marked preview, so treat it accordingly.

Already self-hosting? You don't have to move. Point your existing Hermes at Portal for inference with hermes setup --portal—it opens a browser for OAuth login and configures both the provider and the Tool Gateway. Confirm with hermes portal info.

2. Pick the model: cheap, or free

Two picks, depending on whether you want to spend anything on tokens.

Cheap and fast:  deepseek/deepseek-v4-flash
Free:            nvidia/nemotron-3-ultra-550b-a55b:free

deepseek/deepseek-v4-flash is the same model the original walkthrough used—quick, inexpensive, and more than good enough for a personal assistant handling everyday tasks.

nvidia/nemotron-3-ultra-550b-a55b:free is NVIDIA's Nemotron 3 Ultra—an open frontier reasoning and orchestration model, 550B total parameters with 55B active (mixture-of-experts)—offered at no cost. If you want a heavier reasoner without touching your credit balance, this is the one to try. Free tiers come with tighter rate limits, so expect it to be slower under load.

Set it in the Cloud instance's model picker, or swap mid-session with /model. To make it permanent: hermes config set model.default.

One caution from the Nous docs: the Hermes-4 models are tuned for chat and reasoning, not agentic tool-calling. For an agent that actually uses tools, stick with the frontier agentic models or the two above.

3. Connect Composio as an MCP server

The Tool Gateway covers search, images, and browsing. Composio covers everything else—GitHub, Gmail, Slack, Notion, HubSpot, Linear, and hundreds more real SaaS integrations—exposed to Hermes over MCP.

The setup is deliberately boring. Add an MCP server named composio, transport HTTP, pointed at:

https://connect.composio.dev/mcp

Do not add authentication headers. Composio handles auth over OAuth automatically once the server is connected—that's the whole point of the Connect endpoint.

If you're editing ~/.hermes/config.yaml directly rather than using the UI:

mcp_servers:
  composio:
    url: 'https://connect.composio.dev/mcp'
    connect_timeout: 60
    timeout: 180

After the config changes, run /reload-mcp to refresh the tool registry. Then ask your agent to search the available toolkits and connect the ones you actually use—Composio's Tool Router handles discovering and serving the right tools per request, so you're not dumping 500 tool definitions into every prompt.

You control the blast radius: when you connect an account, you choose which Composio scopes and actions are allowed, and you can bring your own OAuth credentials or API configuration if you'd rather not hand over broad access. Grab an API key or manage connections at dashboard.composio.dev.

4. Give it memory with Honcho

This is the upgrade that changes how the agent feels. Hermes ships with basic built-in memory. Honcho is an AI-native memory backend that adds dialectic reasoning and deep user modeling on top of it—instead of key-value scratch notes, it maintains a running model of who you are: your preferences, your communication style, your goals, the patterns in how you work. It reasons about conversations after they happen and folds the conclusions back in.

Setup, on a fresh install:

hermes memory setup honcho     # or: hermes memory setup, then pick honcho

The wizard writes the config for you. If you'd rather do it by hand, set the provider in ~/.hermes/config.yaml:

memory:
  provider: honcho

…and put your key in ~/.hermes/.env:

HONCHO_API_KEY=***

Get the key at app.honcho.dev—the free tier includes $100 in credits, which goes a long way for a single-user agent.

Two gotchas worth knowing before you hit them:

• The package is honcho-ai, not honcho. pip install honcho installs an unrelated Procfile runner.
• Hermes uses a uv-managed venv, and there's no pip binary inside it. Use uv pip install.

Tuning lives in ~/.honcho/config.json (global) or $HERMES_HOME/honcho.json (per-profile). The knobs that matter:

Verify it took:

hermes honcho status     # expect Enabled=True, API key present, status OK

Once it's live, Hermes gains four memory tools: honcho_profile (quick peer retrieval), honcho_search (semantic search), honcho_context (synthesized Q&A), and honcho_conclude (store an observation). The real test is simple—mention a preference in one session, start a fresh one, and ask what it knows about you. If it answers correctly, you're done.

What this costs, all in

$20/month for Portal Plus covers hosting, inference credits, and the Tool Gateway. Compute for a Small Cloud instance is roughly $9/month if you leave it running continuously, less if it idles. Composio and Honcho both have free tiers that comfortably cover a personal agent. Call it $20–30/month for an always-on agent with real tools and real memory—versus a Railway bill plus separate OpenRouter credit under the old approach.

Fair warning: unlike the original walkthrough below, the Composio and Honcho steps do touch a config file and a terminal. Hosting and model selection stay fully browser-based on Portal, but the memory and MCP layers currently expect you to edit YAML at least once.

The original walkthrough follows. Everything in it still works—if you'd rather own the whole stack on Railway, or you want to understand the pieces before handing them to a managed platform, start here.

The original walkthrough (Railway + OpenRouter + Telegram)

Most of the AI we use only exists when an app is open. Close the tab and it goes quiet. Hermes flips that around: it's an open-source AI agent that stays online continuously, remembers context, picks up skills, and automates tasks over time. You reach it the same way you'd message a friend—through Telegram, Discord, Slack, or email—from your phone or your desktop.

The best part: you can stand the whole thing up from your browser. No servers to rent, no terminal, no config files to edit by hand. If you're curious what people are actually doing with it, the Hermes user stories are a good place to get inspired before you build.

Below is the path I took, start to finish. Prefer to follow along in slides? You can download the full setup guide as a PDF.

The three building blocks

Each piece does exactly one job, and together they give you a personal AI agent that's online around the clock.

• OpenRouter — the brain. One account, one API key, many AI models (including free and very cheap ones). Hermes calls these models to think and reply.
• Railway — the home. A cloud platform that runs Hermes for you. A ready-made template gives you the dashboard, admin panel, and gateway in a single deploy.
• Telegram — the interface. You create a bot, connect it to Hermes, and chatting becomes as easy as messaging that bot.

The whole thing is five real steps: create an OpenRouter key, make a Telegram bot, deploy the Railway template, configure Hermes, then approve yourself and chat.

Step 1 — Create an OpenRouter API key

Head to openrouter.ai and sign up. From the homepage, click Get API Key.

1. Give the key a name.
2. Leave the credit and reset limits blank.
3. Click Create.

OpenRouter shows the key only once, so copy it the moment it appears and paste it somewhere safe. If you lose it, just delete it and create a new one—it takes a few seconds.

Key format:   sk-or-v1-...
Model format: provider/model-name   (e.g. deepseek/deepseek-v4-flash)

You won't enter the model name here—you'll type it later, inside Hermes. Just decide which model you want it to use and keep the name handy alongside the key.

Add a little credit. OpenRouter is pay-as-you-go. Drop a bit of credit on the account so the key can make calls—$10 is plenty to start.

Step 2 — Create a Telegram bot

Open Telegram, search for @BotFather, and open the chat. Several lookalikes show up—the real one has the orange verified checkmark, so ignore copycats like BotFather123_robot.

In the chat with BotFather:

1. Type /newbot.
2. Follow the prompts to choose a name and a username.
3. Copy the Bot Token it sends back—a long string of letters and numbers. Keep it safe.

Optional but recommended: message @userinfobot (or @getmyid_bot) and tap Start to get your numeric Telegram user ID. You can use it later to control exactly who's allowed to talk to Hermes.

Step 3 — Deploy the Railway template

Go to Railway and sign in with GitHub. You can jump straight to the template here: Deploy Hermes Agent.

The template deploys a single service—Hermes Agent. Click Configure and set three things:

• Volume — keep it set to /data so your config survives redeploys.
• ADMIN_USERNAME — your admin login name (e.g. Admin).
• ADMIN_PASSWORD — a strong password; you'll use it to log in to Hermes.

When it reads Ready to be deployed, click Save Config, then Deploy.

The first build takes a few minutes. Wait until the deployment reads successful, then click the app link above the service card (something like hermes-production-450f.up.railway.app) to open Hermes.

Step 4 — Sign in to the Hermes admin

The hermes /admin sign-in screen loads. Enter the ADMIN_USERNAME and ADMIN_PASSWORD you just set on Railway and click Sign in. No terminal required.

A quick tour of the Setup screen so you know where things live:

• LLM Provider — the provider dropdown, API key, and model name.
• Configured providers — saved providers, each showing an "API key set" badge.
• Messaging channels — tick at least one to receive messages.
• Save & Start — the bottom-right button that launches the gateway.

Step 5 — Configure the provider and channel

In the Setup tab, open the Provider dropdown and choose OpenRouter (it sits right at the top). Hermes works with DeepSeek, Anthropic, Google, xAI and more, but we're using OpenRouter here.

Then:

1. Paste your API key (starts with sk-).
2. Enter the model name, e.g. deepseek/deepseek-v4-flash.
3. Click Save & Start. Your provider now appears below with a Remove button and an "API key set" badge confirming it's connected.

Scroll down to Messaging Channels and:

1. Tick Telegram.
2. Paste the Bot Token from BotFather.
3. Save the configuration.

Step 6 — Go live and approve yourself

Click Save & Start to launch the gateway and watch for the green running status.

Now the part that makes Hermes feel like yours:

1. Send any message to your Telegram bot.
2. Back in the dashboard, open the Users section.
3. Find your new pairing request and approve it.

When you first message the bot, Hermes registers a pairing request. Approving it tells Hermes that user is allowed to chat—that's your built-in access control. From here on, just open Telegram and message your bot. Ask it questions or hand it tasks, and it replies—running on Railway 24/7. Because your config lives on the /data volume, the agent stays available across redeploys.

When the bot goes quiet

If messages don't come back, work through these in order:

• Read the Railway logs. Open your Hermes service logs and scan for obvious errors during startup or message handling.
• Verify OpenRouter. Confirm the API key is valid and the model name is spelled exactly as the provider lists it.
• Re-check the bot token. Make sure the token in the admin dashboard matches the one from BotFather.
• Confirm the gateway is running. Look for the green running status—if it's stopped, hit Save & Start again.

Wrapping up

Create the key, make the bot, deploy the template, fill in the settings—and you have a personal cloud AI agent you can message from anywhere, with no terminal in sight. OpenRouter gives it a brain, Railway keeps it alive around the clock, and Telegram is your front door.

If you start in on this and hit a snag or have a question, reach out to me—I'm more than happy to help you get it running.

Links you'll need

For the 2026 setup:

• Nous Portal — plans, credits, and model catalog
• Hermes Cloud — one-click hosted agent
• Nemotron 3 Ultra (free) — the free model option
• Composio dashboard — MCP connections & toolkits
• Honcho — memory backend & API key
• Honcho memory docs — full configuration reference

For the original walkthrough:

• OpenRouter — sign up & manage models
• Railway — deploy & host Hermes
• Deploy the Hermes template — one-click deploy
• Hermes user stories — what people build with it
• Hermes setup guide (PDF) — the full slide-by-slide walkthrough