I run SEO campaigns across multiple sites, monitor rankings daily, and manage automation scripts on a homeserver. For a long time the AI layer was completely disconnected from all of it — I'd open a browser, paste in context, get a response, close the tab. Every session started from zero. No memory of what I was working on, no access to my data, no continuity between conversations.
The problem isn't the models. The problem is the interface. A browser tab is a one-shot tool. You get a response and you leave. Nothing persists, nothing connects, and every time you come back you're rebuilding context from scratch.
The fix was OpenClaw — a free, open source AI orchestrator that runs as a background daemon on your server and connects your agent to Telegram. I already used Telegram for monitoring alerts — ranking drops, RAM spikes, cron failures. Having the AI in the same app meant going from an alert to asking the agent to investigate it without switching tools. One app, one workflow — and the agent is always on.
What OpenClaw Is
OpenClaw's official description is "multi-channel AI gateway with extensible messaging integrations." The mechanics are what matter.
The gateway runs on local loopback at port 18789 on your machine. Every message you send through Telegram routes through it to the agent. The agent has a persistent workspace — files that carry context between sessions: who you are, what your projects are, what it's learned about how you work. That workspace loads into every conversation automatically.
Most web AI interfaces are stateless — each session starts fresh. OpenClaw's agent accumulates context over time. The longer it runs, the more useful it gets.
It supports multiple LLM providers out of the box: Anthropic, Google, OpenRouter, Ollama, and OpenAI. You're not locked into one model or one bill. I run a free OpenRouter model as my primary and route heavier tasks to Claude or Gemini when needed.
Installation
I didn't run through this manually. I gave Claude Code the task over SSH — it handled the full install, configured the files, and flagged the two things that needed my input. Here's what the process looks like:
1. Install OpenClaw globally via npm
npm install -g openclaw@latest
Requires Node.js 22.16 or higher. Node 24 is recommended. I was on Node 22 and it worked fine.
2. Run onboarding with the daemon flag
openclaw onboard --install-daemon
The --install-daemon flag registers a systemd user service on Linux (launchd on macOS). After this, OpenClaw starts automatically on boot and stays running in the background.
3. Configure the main settings file
The config lives at ~/.openclaw/openclaw.json. This is where Claude did the most work — channel settings, model providers, plugin allowlist. The key sections:
{
"channels": {
"telegram": {
"botToken": "YOUR_BOT_TOKEN_HERE",
"enabled": true,
"dmPolicy": "pairing",
"allowFrom": ["YOUR_TELEGRAM_USER_ID"]
}
},
"agents": {
"defaults": {
"model": {
"primary": "openrouter/minimax/minimax-m2.5:free"
}
}
},
"models": {
"providers": {
"ollama": { "baseUrl": "http://127.0.0.1:11434" },
"anthropic": { "baseUrl": "https://api.anthropic.com" },
"openrouter": { "baseUrl": "https://openrouter.ai/api/v1" }
}
},
"plugins": {
"allow": ["ollama", "anthropic", "google", "openrouter", "browser", "telegram"]
}
}
4. Create a Telegram bot via BotFather
This is the one step you do manually. Open Telegram, search @BotFather, send /newbot, follow the prompts. You get a bot token — paste it into openclaw.json under channels.telegram.botToken. Your Telegram user ID goes in allowFrom — message @userinfobot to find it.
5. Restart the daemon
openclaw daemon restart
6. Pair your Telegram account
Send your bot a message. OpenClaw's default security model (dmPolicy: "pairing") means unknown senders get a pairing code before the agent responds. Approve it with:
openclaw pairing approve telegram <code>
After that, the bot responds. Setup done.
Watch out: The
plugins.allowlist must explicitly include"telegram"or the channel silently fails to start — the daemon reports running but your bot won't respond. This catches people off guard because there's no error. The Ollama TUI inside OpenClaw also rewritesopenclaw.jsonwhen you change models, and it dropstelegramfrom the allowlist. If your bot goes quiet after a model change, that's why. Add"telegram"back toplugins.allowand restart the daemon.
Choosing a Model
My primary is openrouter/minimax/minimax-m2.5:free — handles general queries, completely free, good enough for most daily tasks. For anything that needs more reasoning I fall back to Claude Haiku 4.5 via the Anthropic API. For recurring automation like trend alerts I use kimi-k2.5:cloud via Ollama running locally — no API cost at all.
The free OpenRouter tier covers the majority of day-to-day use. You only route to paid models when the task demands it, which keeps the running cost close to zero most months.
One thing to avoid: Gemini via the OpenAI-compatible endpoint returns 400 errors on this setup. Route it through the native Google provider in openclaw.json instead.
How I Use It Day to Day
Setting up OpenClaw is what prompted me to build out my SEO monitoring scripts properly. Once I had Telegram as a reliable delivery layer, it made sense to build scripts that push data directly there.
The key design decision: scripts deliver raw GSC data straight to Telegram via the bot API — not through the OpenClaw agent. That's intentional. When I want accurate ranking numbers and click metrics, I don't want an AI in the middle summarizing or rounding figures. The script pulls from the API, formats it, and sends it. Exact data, no interpretation.
The agent comes in on top of that. Once raw data lands in Telegram, I ask the agent to interpret it, spot patterns, or flag what to act on. That's where AI adds value — commentary and analysis, not data retrieval. It also keeps cost down since the agent only runs when I actually need it.
What's Next
In Part 2: How I Wired Google Search Console to Telegram on Day One I show the full SEO monitoring workflow built on top of this — the scripts, the cron jobs, the Telegram alerts, and how the agent turns raw GSC data into actual decisions. That's the real case study.
The foundation is what this post covers: a self-hosted agent, always on, connected to your data, living in the app you already use. Everything else builds on top of that — including posting to X directly from Telegram without touching a browser.
