---
title: "Where to Host an Always-On Telegram AI Bot Without a Server"
description: "DIY Telegram AI bot vs. Hermes on AgentRoost — always-on, persistent memory, AI credits included, Telegram auto-provisioned. Live in 2 minutes from $19.99/mo."
canonical: https://agentroost.app/en/blog/where-to-host-telegram-ai-bot-no-server
date: 2026-05-17T12:00:00Z
---

[Canonical URL](https://agentroost.app/en/blog/where-to-host-telegram-ai-bot-no-server)

You want a Telegram AI bot that answers questions, summarizes articles, monitors something, or just keeps context across days — and you want it running around the clock. The question is how you actually get there.

There are two honest paths: build it yourself on a server, or use a platform that handles the infrastructure. Here's the full picture of both.

## The DIY Path: What It Actually Takes

Running a persistent Telegram AI bot on your own means stitching together several moving parts. Here's the real checklist:

### 1. Get a VPS

You need a machine that stays on 24/7. A cheap VPS (Hetzner, DigitalOcean, Vultr) runs $4–12/month depending on region and specs. That's the floor — it doesn't include anything else.

### 2. Register the Bot with BotFather

On Telegram, open [@BotFather](https://t.me/botfather), run `/newbot`, pick a name and username, and grab your `BOT_TOKEN`. This is the key Telegram needs to send messages to your bot.

### 3. Wire Up an AI API Key

Your bot needs to call an LLM somewhere. That means:
- Creating an account at OpenAI, Anthropic, Google, or a proxy like OpenRouter
- Adding payment info and setting spending limits
- Injecting the API key into your bot's environment

This is a separate recurring cost on top of your VPS. If your bot is chatty or handles file summarization, the AI bill can spike unexpectedly.

### 4. Write and Deploy the Bot

Pick a framework (`python-telegram-bot`, `Telegraf` for Node, `grammY`, etc.), write your polling/webhook handler, and push the code to your server. A minimal webhook-based bot needs something like this in your handler:

```python
async def handle_message(update: Update, context: ContextTypes.DEFAULT_TYPE):
    user_text = update.message.text
    reply = await call_llm(user_text)  # your API call here
    await update.message.reply_text(reply)
```

Straightforward enough — until you need conversation memory, file handling, or scheduled tasks.

### 5. Keep It Alive

Your process will crash. You need:
- `systemd` or `supervisor` for process management
- Log rotation so the disk doesn't fill up
- Monitoring so you know when it's down
- A way to update it without breaking the bot mid-conversation

This is the part DIY guides gloss over. In practice it's an afternoon of setup per bot, and occasional weekend debugging when something drifts.

### 6. Manage Memory (If You Want It)

A basic bot forgets everything between restarts. Persistent memory — knowing that a user asked about topic X last Tuesday — requires storing conversation state in a database, implementing retrieval logic, and deciding how to trim context windows when they get long.

None of this is impossible. But the total DIY cost looks like this:

| Component | Monthly cost |
|---|---|
| VPS (2 GB RAM, EU) | $6–12 |
| LLM API (moderate usage) | $5–20 |
| SSL/nginx/domain | $0–5 |
| Your time to maintain | hours |
| **Total** | **$11–37+ / month** |

And that's before you build anything useful.

---

## The Hermes Path: What Changes

[Hermes on AgentRoost](/en/agents/hermes) is a persistent AI assistant framework designed for exactly this use case. Instead of assembling pieces, you get a running assistant in roughly two minutes:

1. **Sign up** at agentroost.app — email/password, Google, Microsoft, or Discord
2. **Pick the Hermes framework** from the workspace menu
3. **Name your assistant** (this becomes your private instance)
4. **Connect Telegram in one click** — the AgentRoost manager bot sends you a link; open it, `/start` your agent's Telegram bot, and it's live

No BotFather. No API keys. No server. The Telegram bot is auto-provisioned.

### What Hermes Includes Out of the Box

**Persistent memory across days.** Hermes remembers context between conversations — no database to wire up, no retrieval logic to build. Ask it to track something on Monday; follow up on Thursday and it knows what you meant.

**Scheduled tasks.** You can ask Hermes to check something every morning, summarize your inbox at noon, or ping you when a condition is met. The scheduling layer runs on AgentRoost's infrastructure, not a cron job you have to babysit.

**AI credits included.** This is the part that surprises people: the LLM calls are already paid for. You're not managing an OpenAI account or watching your credit balance. Every plan includes a credit pool for AI usage — no separate API key, no separate bill, no surprise charges when usage spikes.

**350+ LLM models, switch anytime.** You can change which model powers your assistant without touching a config file.

### What It Costs

Plans start at **$19.99/month all-in** — that's the server, the AI credits, the Telegram provisioning, and the uptime guarantee rolled into one number. [Compare plans](/en/pricing) for Plus and Pro tiers if you need more compute or larger credit pools. Monthly billing, cancel anytime, 14-day money-back guarantee.

---

## Honest Comparison

| | DIY (VPS + BotFather) | Hermes on AgentRoost |
|---|---|---|
| Setup time | 2–6 hours | ~2 minutes |
| BotFather required | Yes | No (auto-provisioned) |
| API key management | Yes (separate account + billing) | No (credits included) |
| Persistent memory | Manual (you build it) | Built-in |
| Scheduled tasks | Manual (cron/systemd) | Built-in |
| Uptime monitoring | Manual | Handled |
| LLM model choice | Whatever the API supports | 350+ models |
| Monthly cost | $11–37+ (variable) | From $19.99 (fixed) |
| What breaks at 2am | Your problem | Not your problem |

### Who Should Pick DIY

DIY is still the right call if you need deep control over the bot's code, you're already running a VPS for other reasons, or you want to build something highly custom that no hosted framework would support. A Python developer building a bot with unusual integrations or specific security requirements is probably better off self-hosting.

### Who Should Pick Hermes

Hermes makes sense if your goal is the assistant, not the infrastructure. If you want a bot that monitors your email, summarizes research, tracks a project, or answers questions from your team — and you want it working this afternoon rather than this weekend — the hosted path is faster and often cheaper once you count the AI API bill.

---

## What You Can Actually Build With Hermes

To make this concrete: here are assistant patterns that work well with Hermes today:

- **Daily briefings**: ask Hermes to summarize a set of topics every morning and message you on Telegram before 9am
- **Research assistant**: send it a URL or a block of text; it summarizes, extracts key points, and remembers what you've already read
- **Inbox triage**: forward email summaries; Hermes tracks threads and follows up on things you flagged
- **Monitoring alerts**: check an API or a URL on a schedule and notify you when something changes
- **Meeting notes**: paste transcript text; Hermes extracts action items and stores them for later recall

These are all things you could build on a VPS — but with Hermes you're describing the task, not writing the plumbing.

---

## Get Started

If you want to try the Hermes path: [start here](/en/agents/hermes). Pick the framework, name your assistant, connect Telegram in one click. The AI credits are already included — no BYOK, no API account, no separate bill.

If you want to compare all frameworks first (including n8n for workflow automation and OpenClaw for a lighter personal assistant): [see all agents](/en/agents).

The infrastructure is someone else's problem. The assistant is yours.
