Overview

here.now is a free, instant static web hosting service designed specifically for AI agents. An agent publishes files via a simple 3-step HTTP API (create → upload → finalize) and gets back a live URL at <slug>.here.now in under 2 seconds. No signup required for anonymous 24-hour publishes; free accounts get permanent hosting.

Source: here.now, docs, Termo skill page

This fills a clear gap — Hermes Agent can create websites, dashboards, visualizations, reports, and documents, but has no way to publish them to the web. Agents frequently need to share created content with users via a URL, and currently the only option is saving files locally. This skill would give Hermes a "publish to web" capability with zero friction.

Related but distinct: #361 (Pinggy Skill) covers localhost tunneling — exposing a running local service. here.now covers static file hosting — publishing files that don't need a running server. These are complementary: Pinggy for "share my dev server", here.now for "publish this website/document/dashboard".

Research Findings

How here.now Works

3-Step Publish API (confirmed via hands-on testing):

# Step 1: Create publish — get presigned upload URLs
curl -sS https://here.now/api/v1/publish \
  -H "content-type: application/json" \
  -d '{"files": [{"path": "index.html", "size": 936, "contentType": "text/html"}]}'

# Response includes:
# - slug: "trusty-grove-hh36"
# - siteUrl: "https://trusty-grove-hh36.here.now/"
# - upload.uploads[]: presigned Cloudflare R2 PUT URLs
# - upload.finalizeUrl: URL to call after uploads complete
# - claimToken + claimUrl (anonymous, returned ONCE only)

# Step 2: Upload file to presigned URL
curl -sS -X PUT "<presigned_url>" \
  -H "content-type: text/html" \
  --data-binary @index.html

# Step 3: Finalize to make it live
curl -sS https://here.now/api/v1/publish/<slug>/finalize \
  -H "content-type: application/json" \
  -d '{"versionId": "<version_id>"}'

Tested result: Published a "Hello from Hermes Agent" page → live at https://trusty-grove-hh36.here.now/ in ~2 seconds total.

Architecture

• Storage: Cloudflare R2 (S3-compatible object storage)
• CDN: Cloudflare edge network — served from nearest PoP to each visitor
• URLs: <slug>.here.now subdomains, auto-generated slugs (e.g., "trusty-grove-hh36")
• Auto-viewer: Single files (images, PDFs) get a rich viewer page; directories get auto-generated gallery/listing

Authentication Modes

Agent-assisted signup flow:

1. POST /api/auth/agent/request-code with user email → sends magic code
2. POST /api/auth/agent/verify-code with code → returns API key
3. Store key at ~/.herenow/credentials (chmod 600)

Key Design Decisions

• 24-hour claim window — Agents publish autonomously; humans have 24h to claim with a free account. Pragmatic balance between agent autonomy and human accountability.
• Claim token returned once — The claimToken is only in the initial response. If lost, the site expires. The agent MUST surface both siteUrl and claimUrl to the user.
• State file — .herenow/state.json tracks published slugs, claim tokens, and expiry times for updates.
• Slug-based updates — PUT /api/v1/publish/:slug with claim token (anonymous) or auth header (owned) to update in-place.

URL Serving Logic

1. Root index.html → served as homepage
2. Single file → rich auto-viewer (image gallery, PDF reader, etc.)
3. Subdirectory index.html → served if no root index
4. No index → auto-generated directory listing/gallery

Additional API Endpoints

• PUT /api/v1/publish/:slug — Update existing site
• POST /api/v1/publish/:slug/claim — Transfer anonymous site to authenticated account
• PATCH /api/v1/publish/:slug/metadata — Update TTL or viewer metadata
• DELETE /api/v1/publish/:slug — Hard delete
• GET /api/v1/publishes — List all owned sites (authenticated)

Current State in Hermes Agent

What we have:

• terminal tool — can run curl commands for HTTP API calls
• write_file / read_file — can create HTML/CSS/JS files to publish
• search_files — can locate project files for multi-file publishes
• Pinggy skill (Feature: Pinggy Skill — Zero-Install Localhost Tunnels via SSH #361, proposed) — localhost tunneling (different use case)

What we lack:

• No "publish to web" capability — no way to share agent-created content via URL
• No static hosting integration
• No skill or tool for deploying websites, dashboards, or documents

Use cases this unlocks:

• Agent builds a dashboard → publishes to here.now → shares URL with user
• Agent generates a report → publishes as a styled HTML page
• Agent creates a data visualization → publishes for sharing
• Agent builds a prototype/demo → publishes for review
• Agent generates documentation → publishes for team access
• Cronjob generates daily reports → publishes and sends URL via Telegram/Discord

Implementation Plan

Skill vs. Tool Classification

This should be a skill (bundled) because:

• The entire capability is expressible as curl commands via the existing terminal tool
• It wraps an external HTTP API — no custom Python integration needed
• No API key management by the agent harness (key stored in ~/.herenow/credentials if needed)
• No binary data handling, streaming, or real-time events
• Broadly useful to most users — publishing agent-created content is a common need across workflows

What We'd Need

1. SKILL.md — Instructions for publishing, updating, claiming, and managing sites
2. scripts/publish.sh — Shell script wrapping the 3-step API (create → upload → finalize) for single or multi-file publishes
3. templates/ — Optional starter templates (dashboard, report, gallery)

Phased Rollout

Phase 1: Core publish skill

• SKILL.md with publish workflow instructions
• scripts/publish.sh wrapping the 3-step API:
  • Accept a file or directory as input
  • POST to create publish, parse presigned URLs
  • Upload each file to its presigned URL
  • POST to finalize
  • Output siteUrl and claimUrl to the user
• State management via .herenow/state.json
• Instructions for updating existing sites (--slug flag)
• Clear user communication: always show siteUrl AND claimUrl for anonymous publishes

Phase 2: Authentication & management

• Agent-assisted signup flow (email → magic code → API key)
• Secure credential storage at ~/.herenow/credentials
• Permanent publishes with authenticated API
• Custom TTL support
• Site listing and deletion commands
• X-HereNow-Client: hermes-agent/publish-skill header for attribution

Phase 3: Templates & integration recipes

• Starter templates: dashboard (Chart.js), report (styled HTML), gallery (image grid)
• Integration with cronjobs: "publish daily report and send URL to Telegram"
• Integration with Dogfood skill (Feature: Dogfood Skill — Agent-Driven Exploratory QA for Web Applications #315): publish QA reports
• Integration with Pinggy (Feature: Pinggy Skill — Zero-Install Localhost Tunnels via SSH #361): decision guide — "use here.now for static content, Pinggy for running services"

Pros & Cons

Pros

• Zero friction — No install, no signup, no config for basic use. Just curl commands the agent already knows how to run.
• Fast — Entire publish flow takes <2 seconds (confirmed via testing)
• Free — Anonymous 24h hosting with no account; free accounts for permanent hosting
• CDN-backed — Cloudflare edge network means fast load times globally
• Agent-native — Designed for agents, not adapted from human-oriented tooling. The API is clean and predictable.
• Complements Pinggy — Static hosting vs. tunnel to running service. Both needed, neither replaces the other.
• Low maintenance — The skill wraps a stable HTTP API; no binary dependencies, no SDK required
• Broad utility — Publishes websites, documents, dashboards, games, galleries, any static content

Cons / Risks

• 24-hour expiry — Anonymous publishes expire. Agent must clearly communicate the claimUrl to users, or they lose the site.
• Claim token returned once — If the agent doesn't capture and surface the claim token/URL, it's unrecoverable. The skill must enforce this.
• Vendor dependency — Relies on here.now infrastructure. Service is new (launched ~Feb 2026), no track record yet.
• No SLA — Free service with no guarantees of uptime or data retention
• Static only — No backend support. Projects needing databases or server-side processing need a different solution.
• Rate limits — 5 publishes/hour/IP for anonymous. Could be limiting for batch workflows.
• Content moderation risk — Agent-published content reflects on the user; here.now prohibits illegal/malicious content

Open Questions

• Should the skill auto-prompt users to claim their site, or just display the claimUrl and move on?
• Should we bundle a publish.sh script, or have the agent construct curl commands inline based on the SKILL.md instructions?
• Should the skill attempt authentication setup on first use, or only when the user explicitly requests permanent hosting?
• How should multi-file publishes handle large directories? (Upload all files in parallel? Sequential? Size limit warnings?)
• Should published URLs be logged to memory for future reference?

References

• here.now homepage
• here.now documentation
• here.now on Termo — Existing skill implementation for Termo/OpenClaw
• here.now on Wikimolt — Community wiki entry
• X announcement by @DataChaz — Launch context
• Hands-on test: Published https://trusty-grove-hh36.here.now/ successfully via the 3-step API
• Related: Feature: Pinggy Skill — Zero-Install Localhost Tunnels via SSH #361 (Pinggy Skill — localhost tunnels, complementary use case)