Buy a domain, point it at your Pocketcorp, and build your website by talking to your agent on Telegram — every change live in minutes.
Your Pocketcorp has a public IP, a terminal, and an agent that writes code. That is everything a website needs. This guide wires a domain to your server, puts nginx in front (with certbot doing the certificate work), and gives Hermes a site-builder skill with one golden rule: never claim “done” without a screenshot of the live URL.
Hermes is a terminal-native coding agent with a learning loop: after your first deploy it saves the whole build-verify-deploy workflow as a skill, so the tenth change ships faster than the first. Your Pocketcorp is the web server — the site never leaves your machine.
Copy this prompt and send it to the agent on your Pocketcorp. It sets up everything in this guide and reports back when it’s done. The steps below explain what your agent is doing — and how to check its work.
Turn this server into my website agency.
1. Connect Telegram: I’ll create a bot with @BotFather and give you
the token. Put it in ~/.hermes/.env with my numeric user id as
the only allowed user, then restart the gateway.
2. Ask me for my domain and a Cloudflare API token (Edit zone DNS,
scoped to that zone). Create the A record pointing at this
server, DNS-only (grey cloud), and verify with dig.
3. Install nginx and certbot (apt install nginx certbot
python3-certbot-nginx). One server block per domain, root
/var/www/<domain>, HTTPS via certbot --nginx. Iron rule: always
nginx -t before reloading.
4. Create a site-builder skill: one git repo per site at
~/sites/<domain>; static-first (plain HTML, Astro only if a
build step earns its keep); deploy = copy to /var/www, nginx -t,
reload; after EVERY deploy screenshot the live URL with
Playwright and send it to me with the link; max 3 fix loops,
then ask me.
5. Then ask me what the first site is about — and build it.Paste the prompt and the agent asks you for one thing: a Telegram bot token. Getting it takes half a minute and happens entirely inside Telegram — message @BotFather, send /newbot, pick a name, copy the token it answers with. Paste that token to your agent, and it stores it and locks the bot to you:
TELEGRAM_BOT_TOKEN=123456789:AAF...
TELEGRAM_ALLOWED_USERS=987654321 # your numeric ID — ask @userinfobotThe agent restarts its gateway and your bot comes alive. Say hi to it — anyone not on the allowed list is denied by default, so the bot answers you and nobody else.
Two things only you can do: pick a domain (buy it anywhere — Cloudflare Registrar sells at cost) and give the agent permission to manage that domain’s DNS. The permission is a Cloudflare API token, and the agent tells you exactly which buttons to click — the “Edit zone DNS” template, limited to just your domain, so the token can’t touch anything else. Paste it to your agent:
CF_API_TOKEN=v1.0-abc...
CF_ZONE_ID=023e105f4ecef8ad9ca31a8372d0c353From now on the agent manages DNS itself with one API call — this is what it runs when you say “point the domain at the server”:
curl -X POST "https://api.cloudflare.com/client/v4/zones/$CF_ZONE_ID/dns_records" \
-H "Authorization: Bearer $CF_API_TOKEN" \
-H "Content-Type: application/json" \
--data '{"type":"A","name":"mysite.com","content":"<your-pocketcorp-ip>","proxied":false}'The record stays DNS-only (grey cloud) at first — Cloudflare’s proxy would block the little handshake certbot uses to prove your domain and issue the free HTTPS certificate. The prompt bakes this rule in, so the agent gets it right; you can flip the orange cloud on once the certificate exists.
The agent installs nginx — the web server that answers your visitors — and certbot, which fetches the free HTTPS certificate and renews it forever. One tidy folder per site:
server {
server_name mysite.com;
root /var/www/mysite.com;
}
# enable it, then let certbot add HTTPS + the redirect:
# ln -s ../sites-available/mysite.com /etc/nginx/sites-enabled/
# certbot --nginx -d mysite.comThe guardrail that keeps one bad edit from downing every site: the agent must always run `nginx -t` before `systemctl reload nginx`. Test-then-reload is zero-downtime. The prompt writes this rule into the agent’s skill (next step), so it can’t forget it.
The prompt has the agent write its own operating manual — the difference between “an agent that can code” and “an agency that ships”. It encodes stack defaults, the deploy path, and the golden rule: never claim “done” without a screenshot of the live site:
---
name: site-builder
description: Build, deploy and iterate websites on this server
---
## Defaults
- One git repo per site at ~/sites/<domain>. Every change = commit.
- Static-first: plain HTML + Tailwind (CDN) or Astro if a build
step is justified. No framework unless asked.
- Deploy = copy build output to /var/www/<domain>, then
nginx -t && systemctl reload nginx. NEVER reload without the test.
## Verify loop (non-negotiable)
- After every deploy: screenshot https://<domain> with Playwright
and send it to me with the live URL.
- If the screenshot does not match what I asked, fix and repeat
before replying. Max 3 loops, then ask.
## DNS
- New domains: create the A record via the Cloudflare API
(CF_API_TOKEN in env), verify with dig before claiming success.Now the whole workflow is conversational:
Set up mysite.com — landing page for my bakery. Warm, minimal, one page: hero, menu, opening hours, map.
Live at https://mysite.com 🍞 [screenshot] — DNS propagated, HTTPS issued by certbot, repo initialized at ~/sites/mysite.com (commit 1a2f3c). Want changes?
Hero darker, and add a “pre-order for weekends” button.
Done — [new screenshot]. Darkened the hero overlay to 60% and added the pre-order CTA linking to your contact form. Commit 8e4d21; say “revert” to undo.
Because every iteration is a git commit, “undo yesterday’s changes” is a real command, not a hope. You can also watch edits live in the Pocketcorp VS Code tab while the agent works.
This is where Hermes differs from a one-shot site generator. After the first successful deploy, it saves what worked — your taste, the deploy quirks, the nginx layout — via its skill_manage tool, refining the site-builder skill from experience. The second site you ask for skips every mistake the first one taught it.
Prefer not to host on your own box? The same skill works with edge hosts — swap the deploy line for `wrangler pages deploy dist/` (Cloudflare Pages, free, doesn’t even consume build minutes via direct upload) or `netlify deploy --prod`. Your Pocketcorp stays the brain; the edge serves the bytes.
A live, HTTPS-secured website on your own domain and your own server, iterated by chat, verified by screenshot, versioned in git. Changes ship in the time it takes to type them.