HERMES AGENT + GROK 4.5. HOW TO BUILD AN AUTOMATED X CONTENT MACHINE (FULL SETUP GUIDE INSIDE)

Grok 4.5 is the only frontier model with live access to the X firehose. Hermes Agent ships with xurl, the official X API CLI. Together they create a content pipeline that monitors X for news, drafts posts in your voice, sends them to Telegram for approval, and publishes after one tap.

This is the full setup.

WHY GROK 4.5 FOR THIS

Every other model (Claude, GPT, Gemini, DeepSeek) searches the web. None of them search X natively.

Grok 4.5 connects to the live X firehose through your Grok subscription. It sees posts, engagement, trending topics, and conversations in real time. Not cached. Not scraped. Live.

For a content pipeline built around X, this is the only model that can do the intake step without scraping or third-party tools.

What Grok 4.5 brings:

→ 1.5T parameters, V9 foundation (3x larger than Grok 4.3) → Trained alongside Cursor on real developer workflows → 80 tokens per second output → 2x more token-efficient than comparable models → Live X data access (no other frontier model has this) → #1 on Harvey Legal Agent Benchmark → Competitive on DeepSWE, Terminal Bench, SWE Bench Pro

Benchmarks (from SpaceXAI official):

Not the best on every benchmark. Consistently competitive on all of them. The X access is what makes it irreplaceable for this workflow.

THE PIPELINE

Four tools. One profile. Runs 24/7.

→ Grok 4.5: finds news on X → SOUL.md: controls your voice and content rules → Telegram: approval gateway → xurl: publishes to X

BEFORE YOU START: CHOOSE YOUR PLATFORM

Pick where Hermes will run. Every step after this works identically on all three.

OPTION A: NOUS PORTAL CLOUD (easiest, zero ops)

• Go to portal.nousresearch.com/cloud

• Pick a server size

• Click deploy. 60 seconds. Agent is live.

• Open the terminal in the Portal dashboard

• Follow every step below the same way

you skip: server provisioning, Docker, OS updates, SSH config. Nous handles infrastructure. You handle the agent.

for teams: spin up one agent per team member. granular access controls. unified billing.

OPTION B: VPS (full control, cheapest long-term)

• Rent a VPS (Hetzner CX22, $7/month, or any Linux server)

• SSH into it

• Install Hermes:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

4. Run hermes setup and follow the wizard

5. Follow every step below

OPTION C: LOCAL MACHINE (maximum privacy)

• Download Desktop app from hermes-agent.nousresearch.com or install via terminal with the same curl command above

• Run hermes setup

• Follow every step below

note: agent stops when you close the lid. for 24/7 operation, pair with VPS or Cloud.

AFTER CHOOSING YOUR PLATFORM:

every step below uses the same commands. Desktop app, Dashboard, and CLI all work on all three platforms. Cloud has a web terminal. VPS has SSH. Local has your terminal.

the content machine setup is identical regardless of where Hermes runs.

STEP 1: CREATE THE CONTENT PROFILE

Desktop app / Dashboard: Profiles → Create → “content-machine” CLI: hermes profile create content-machine

Set the model to Grok 4.5:

Desktop app / Dashboard: profile settings → Model → xai/grok-4.5 CLI: content-machine config set model.default xai/grok-4.5

STEP 2: CONNECT GROK 4.5

If your Telegram gateway is already running (Step 5), you can skip the manual setup below. Tell your agent in Telegram: “connect Grok 4.5 via OAuth to this profile” and it walks you through the entire process.

Manual paths:

**Grok OAuth (free with X Premium+):**content-machine setup → select xAI → authenticate No API key. Uses your subscription tokens.

**Nous Portal:**content-machine setup –portal Grok 4.5 appears in model picker.

**SpaceXAI API:**Get key from console.x.ai Add to .env: XAI_API_KEY=your_key

**OpenRouter:**Already available if you have an OpenRouter key.

STEP 3: CONNECT X API (READING + PUBLISHING)

If your Telegram gateway is already running (Step 5), you can skip the manual setup below. Tell your agent in Telegram: “set up the X MCP server so I can search and post on X. here is my Client ID: [paste]. here is my Client Secret: [paste].” the agent configures everything for you.

Manual options below. X MCP is simpler. xurl skill gives more control.

OPTION A: X MCP SERVER (recommended, simpler)

X now has an official hosted MCP server at api.x.com/mcp. add it to Hermes as any other MCP. no separate xurl install needed. the xurl bridge runs through npx automatically.

Prerequisites:→ X Developer App (developer.x.com) with OAuth 2.0 enabled → Register redirect URI: http://localhost:8080/callback → Copy your CLIENT_ID and CLIENT_SECRET → Node.js installed (for npx)

Add to Hermes:

Desktop app / Dashboard: MCP → Add Server

name: xapi command: npx args: [“-y”, “@xdevplatform/xurl”, “mcp”, “https://api.x.com/mcp”] env: CLIENT_ID: “YOUR_X_APP_CLIENT_ID” CLIENT_SECRET: “YOUR_X_APP_CLIENT_SECRET”

or via CLI, add to your profile’s mcp.json:

startup_timeout: set to 300 seconds (first run opens browser for OAuth login, needs time).

First run: browser opens automatically. log in with your X account. authorize. done. tokens cached and auto-refresh from here. no further browser logins needed.

Headless / VPS / Cloud (no browser):

export CLIENT_ID=“YOUR_CLIENT_ID” export CLIENT_SECRET=“YOUR_CLIENT_SECRET” xurl auth oauth2 –headless

prints an auth URL. open it on any device. paste back the code. done.

What X MCP gives Hermes:

search + read + write. one MCP. no separate skill install.

Verify:

tell your agent: “search X for the latest posts about Hermes Agent”

if it returns real posts, X MCP is connected.

OPTION B: XURL CLI SKILL (more control, manual setup)

xurl ships bundled as a Hermes skill. gives direct CLI access to every X API v2 endpoint. more granular control but requires manual install and auth.

install xurl:

curl -fsSL https://raw.githubusercontent.com/xdevplatform/xurl/main/install.sh | bash

register your app:

xurl auth apps add my-app
–client-id YOUR_CLIENT_ID
–client-secret YOUR_CLIENT_SECRET

authenticate:

xurl auth oauth2 –app my-app YOUR_X_USERNAME

set as default:

xurl auth default my-app YOUR_X_USERNAME

verify:

xurl auth status xurl whoami

The #1 setup mistake: omitting –app my-app from the oauth2 command. The token saves to the empty default profile and every command fails with auth errors. Always specify the app name.

Docker pitfall: in the official Hermes Docker layout, tool subprocesses use /opt/data/home as HOME, not /opt/data. Run xurl auth commands with the correct HOME:

HOME=/opt/data/home xurl auth apps add my-app
–client-id YOUR_CLIENT_ID
–client-secret YOUR_CLIENT_SECRET HOME=/opt/data/home xurl auth oauth2 –app my-app YOUR_USERNAME HOME=/opt/data/home xurl auth default my-app YOUR_USERNAME

WHICH OPTION TO CHOOSE:

X MCP (Option A): faster setup, auto-managed through Hermes MCP infrastructure, recommended for most users.

xurl skill (Option B): direct CLI access, more granular control over every endpoint, better for power users who want raw API access.

both use the same X API pay-per-use pricing. both use OAuth 2.0 with auto-refresh. both keep credentials local, never in agent context.

X API PRICING (pay-per-use, as of April 2026):

no subscription. no monthly minimum. buy credits in the Developer Console. spend as you go. deduplication: same resource requested twice in one UTC day = charged once. bonus: up to 20% back in free xAI API credits. 2M post-read monthly cap.

cost-optimized setup:→ Grok 4.5 for searching/monitoring X (0, included in subscription) → X MCP or xurl for posting only (1.35-18/month depending on links) → owned reads for analytics ($0.001 per resource, minimal)

STEP 4: WRITE THE SOUL.MD (AND TRAIN YOUR VOICE)

The SOUL.md controls your voice, rules, and content standards. But writing rules alone is not enough. The agent needs to SEE your style.

Step 1: feed it your best posts.

Before writing SOUL.md, send Hermes 10-15 of your best performing posts. Tell it:

“read these posts. analyze my writing style. identify patterns: hook structure, sentence length, vocabulary, formatting, tone, what I avoid. write a style guide based on what you find.”

Hermes analyzes your content and creates a style profile.

Step 2: feed it competitor posts you admire.

“read these 10 posts from [@competitor]. identify what makes their style different from mine. find elements I should adopt and elements I should avoid. update my style guide.”

Step 3: iterate in conversation.

“write a sample post about [topic] in my style.”

if the output feels wrong, tell it WHY: “too formal. shorter sentences. more direct hook. I never use questions as openers.”

each correction sharpens the style profile. after 5-6 iterations, the agent writes like you.

Step 4: save the refined style as SOUL.md.

“take everything you learned about my style and write a complete SOUL.md for a content profile.”

The agent writes the SOUL.md from real understanding, not from generic rules you copied from a template.

Template to start with (customize after voice training):

You are a content monitor and writer for @[YOUR_HANDLE] on X. Niche: [YOUR NICHE].

YOUR JOB:

1. Search X for breaking news and trending topics in [YOUR NICHE].
2. Evaluate: is this worth posting about? Score 1-5 on:
   • relevance to our audience
   • timeliness (posted in last 6 hours?)
   • engagement potential Only proceed with scores 4+.
3. Draft a post in our voice.
4. Send draft to Telegram for approval using clarify tool with choices.
5. If approved: publish via xurl.
6. After publishing: post any links as a reply to your own post.

VOICE RULES: [paste the style guide the agent generated from your posts]

CONTENT RULES:

• Never publish without Telegram approval.
• Links go in reply to own post, never in post body.
• Every technical claim must be verifiable.
• No speculation presented as fact.
• Maximum 3 posts per day (prevent account spam).
• Minimum 2 hours between posts.

SOURCES TO MONITOR:

• X search: “[keyword 1]”, “[keyword 2]”, “[keyword 3]”
• Filter: minimum 100 likes OR 1,000+ views in last 2 hours
• Ignore: posts from accounts with < 1,000 followers
• Prioritize: original takes over reshared news

STEP 5: SET UP TELEGRAM GATEWAY

Telegram is your control interface. Cron results deliver here. Approvals happen here. The gateway must be running for any of this to work.

Create the bot:

• Open Telegram. Search for @BotFather.

• Send /newbot

• Name it (e.g., “Content Machine”)

• Give it a username (e.g., content_machine_bot)

• Copy the bot token BotFather gives you. Keep it secret.

Get your user ID:

• Search for @userinfobot in Telegram

• Send it any message

• Copy the numeric ID it returns (e.g., 123456789)

Connect to Hermes:

Desktop app / Dashboard: Messaging → Telegram → paste token + user ID CLI:

content-machine setup gateway

Select Telegram. Paste bot token. Paste user ID.

Or set directly in .env:

TELEGRAM_BOT_TOKEN=your_bot_token TELEGRAM_ALLOWED_USERS=your_user_id

Start the gateway:

content-machine gateway

For persistent service (survives reboots):

content-machine gateway install

Set home channel:

Open Telegram. Message your bot. Type:

/sethome

This marks the current chat as the home channel. All cron job results deliver here.

Verify:

Send “hello” to your bot. If Hermes responds, the gateway is live.

On Nous Portal Cloud: the gateway setup is identical. Use the Portal terminal instead of SSH. Same commands. Same flow.

PRO TIP: SET UP EVERYTHING THROUGH TELEGRAM

once your Telegram gateway is running, you can do every remaining step by chatting with your agent.

instead of running CLI commands yourself, tell Hermes what you need:

“connect Grok 4.5 via OAuth to this profile” “set up the X MCP server for posting and searching” “create a SOUL.md for content creation on X” “set up a cron job that scans X every 2 hours”

the agent walks you through each step. opens auth URLs, creates configs, sets up cron jobs. all from your phone via Telegram.

if you get stuck on any step below, skip the manual setup and tell your agent: “I need help setting up [step name].” it has access to its own docs and can configure itself.

this is how we set up the entire content machine. Telegram gateway first. everything else through the agent.

STEP 6: SET UP THE CRON PIPELINE

CHOOSE YOUR SCANNING FREQUENCY:

wakeAgent gate on all options: scans that find nothing = $0. you only pay when the agent wakes to draft.

TOPIC-SPECIFIC MONITORING:

instead of searching “AI” (too broad), narrow to your exact niche.

example topics:

for a Claude Code creator:

search terms: “Claude Code”, “claude code agent”, “@anthropic new release”, “opus 4.8” monitor accounts: @anthropaborhood, @alexalbert__, @ClaudeCode_dev

for a Hermes Agent creator:

search terms: “Hermes Agent”, “@NousResearch”, “@teknium1 hermes”, “hermes agent update” monitor accounts: @NousResearch, @teknium1, @tonbistudio

for a crypto trading creator:

search terms: “BTC breakout”, “ETH analysis”, “crypto AI agent”, “trading bot results” monitor accounts: @[top 5 analysts in your niche]

tell the agent your topics in SOUL.md under SOURCES TO MONITOR. it searches only those terms.

FILTERING CRITERIA (WHAT COUNTS AS NEWSWORTHY):

not every post with 50 likes deserves coverage. set thresholds:

VIRAL THRESHOLD (time-weighted): → 1,000+ views in the last 2 hours = viral velocity → 500+ likes in 6 hours = confirmed engagement → 100+ bookmarks = reference-worthy content

RELEVANCE FILTER: → must match at least one of your tracked topics → must be from an account with 1,000+ followers → must be original content (not a repost or quote of old news) → must be posted within the scan window (not old content resurfacing)

DEDUP: → skip if you already posted about this topic in the last 48 hours → skip if the source post is a repost of something you already covered

put all of these in SOUL.md. the agent applies them automatically.

CRON 1: NEWS SCANNER

tell your content-machine agent:

“create a cron job that runs every [YOUR FREQUENCY]. search X for posts matching my tracked topics in SOUL.md. apply these filters:

• 1,000+ views in the last 2 hours OR 500+ likes in 6 hours
• from accounts with 1,000+ followers
• original content only (no reposts)
• not a topic I posted about in the last 48 hours

for each post that passes all filters:

• score relevance 1-5 based on SOUL.md criteria
• if score 4+: draft a post in my voice
• send draft to Telegram using clarify tool with choices: [✅ Approve & Post] [🔄 Regenerate] [🔀 Different Topic]

if nothing passes filters: reply with silent.“

CRON 2: SPECIFIC ACCOUNT MONITOR

track accounts that matter most to your niche:

“create a cron job that runs every 2 hours. check these specific accounts for new posts: @NousResearch, @teknium1, @AnthropicAI

if any posted in the last 2 hours: evaluate if their post is relevant to my audience. if yes: draft a reaction or quote tweet in my voice. send draft to Telegram with choices: [✅ Approve & Post] [🔄 Regenerate] [⏭ Skip] if nothing new: reply with silent.“

CRON 3: BEST TIME OPTIMIZER (daily, 7am)

“create a cron job that runs daily at 7am. check my X analytics for the last 7 days via xurl. identify which posting times got the highest engagement. deliver a one-line summary to Telegram: best posting window today based on last 7 days.”

CRON 4: WEEKLY PERFORMANCE REPORT (Sunday 8pm)

“create a cron job every Sunday at 8pm. pull my last 7 days of posts via xurl. for each post: impressions, likes, reposts, replies, bookmarks. rank by engagement rate. identify: which topics performed best, which flopped. which drafts I rejected and why (check clarify responses). deliver a structured report to Telegram.”

IMPORTANT: TEST YOUR CRONS FIRST

don’t set all 4 crons and walk away. test each one manually first:

hermes cron run [job-id]

watch the output. check the draft quality. if the formatting is wrong, the filter missed something, or the voice is off, adjust the SOUL.md or the cron prompt. talk to the agent: “that draft was too formal. shorter sentences. more punch in the hook.” iterate 2-3 times per cron job before letting it run on schedule.

STEP 6.5: USE THE RIGHT MODEL FOR WRITING (NOT GROK)

Grok 4.5 is the best model for searching X. live firehose access. no other model has this.

but Grok is NOT the best model for writing posts.

Writing quality ranking (verified across multiple benchmarks):

the solution: split search and writing across models.

three ways to do this:

OPTION A: AUXILIARY MODEL FOR WRITING (simplest)

keep Grok 4.5 as the profile model for X search. route content generation to a writing model via auxiliary:

set in Desktop app, Dashboard, or config.yaml:

auxiliary: content_generation: provider: openrouter model: anthropic/claude-sonnet-4.6

in your cron prompt, tell the agent: “search X using your primary model. when drafting the post, use the auxiliary content model.”

OPTION B: SUB-AGENT FOR WRITING

cron job uses Grok to search X. when it finds something newsworthy, it spawns a sub-agent on Sonnet to write the draft:

add to cron prompt: “when you find a newsworthy topic, delegate the draft writing to a sub-agent using claude-sonnet-4.6. provide the source, the key facts, and my voice rules from SOUL.md. the sub-agent writes the draft. you deliver it to Telegram.”

delegation model override:

delegation: model: “anthropic/claude-sonnet-4.6” provider: “openrouter”

OPTION C: MIXTURE OF AGENTS (best quality, highest cost)

Grok searches. multiple models advise on the draft. Sonnet aggregates into the final post.

create a MoA preset:

presets: content: reference_models: - provider: xai model: grok-4.5 - provider: openrouter model: openai/gpt-5.5 aggregator: provider: openrouter model: anthropic/claude-sonnet-4.6

Grok brings X context and real-time data. GPT-5.5 brings creative writing strength. Sonnet aggregates into clean, natural prose.

tradeoff: 2-3x more tokens per draft. use for high-stakes content. skip for routine posts.

RECOMMENDED SETUP:

daily routine posts → Option A or B (cheapest) important posts → Option C (best quality) news reactions → Option A (speed matters)

Nous Portal subscribers have access to all of these models under one subscription. no separate API keys needed.

STEP 6.6: MEDIA IN POSTS (IMAGES AND VIDEO)

posts with media get 2-3x more engagement on X. the content machine needs to handle images and video.

THREE MEDIA SCENARIOS:

SCENARIO 1: SOURCE POST HAS MEDIA

the source post contains an image or video. your cron draft should note this:

add to cron prompt: “if the source post contains an image or video, include a note in the draft: SOURCE HAS MEDIA: [describe what it shows]. suggest whether to create original media or screenshot the source.”

the draft arrives in Telegram with the media note. you decide what to attach.

SCENARIO 2: YOU ATTACH MEDIA AFTER DRAFT (most common)

the agent sends a draft. you want to add an image.

workflow:

• read the draft in Telegram

• send your image or video to the bot

• reply: “APPROVE WITH MEDIA”

• agent uploads the media via xurl, gets media_id

• agent posts with: xurl post “[text]” –media-id [id]

add to SOUL.md:

MEDIA HANDLING:

• “APPROVE WITH MEDIA” → wait for the next image/video I send. upload it via xurl upload-media. post text + media together.
• “APPROVE” (no media) → post text only.
• up to 4 images per post.
• one video per post maximum.

SCENARIO 3: AGENT GENERATES COVER IMAGE

if you have image generation enabled (via Nous Portal Tool Gateway or image MCP):

add to cron prompt: “after drafting the post, generate a cover image that visualizes the main topic. dark background. clean typography. send the image with the draft to Telegram. if I approve, post text + generated image together.”

agent generates image, sends both to Telegram. you approve. both publish together.

XURL MEDIA COMMANDS:

upload:

xurl upload-media ~/images/cover.png

returns a media_id.

post with image:

xurl post “your text” –media-id MEDIA_ID

multiple images:

xurl post “your text” –media-id 111 –media-id 222

HOW IT WORKS IN TELEGRAM:

you send a photo to your bot. Hermes receives it, saves locally. uploads via xurl upload-media, gets media_id. attaches to the post.

send draft → you send image → agent posts both. one Telegram conversation. no switching apps.

STEP 7: THE APPROVAL FLOW

When the cron scanner finds something newsworthy, it delivers a draft to your Telegram home channel.

HOW THE APPROVAL WORKS:

cron jobs deliver results to Telegram automatically. but cron sessions are fresh and ephemeral. the interactive approval happens in your gateway session.

the flow:

• CRON fires → agent searches X → drafts post

• CRON delivers the draft to Telegram with instructions: “reply APPROVE to post, REDO to regenerate, SKIP to pass”

• You read the draft in Telegram

• You reply to your bot (this goes to the GATEWAY session, not cron)

• Gateway agent reads your reply, recognizes the command

• APPROVE → agent runs xurl post + xurl reply

• REDO → agent regenerates with a different angle, sends new draft

• SKIP → agent logs it and moves on

What the Telegram message looks like:

📝 CONTENT DRAFT

SOURCE: @[account] posted about [topic] (URL: https://x.com/…) VIEWS: 3,200 in 2 hours (viral velocity) ENGAGEMENT: 890 likes, 120 RT, 45 bookmarks RELEVANCE: 5/5

DRAFT POST: [your post text here, written in your voice]

REPLY WITH LINK (will be posted as first reply): [source URL]

Reply: APPROVE → publish this post now REDO → rewrite with a different angle SKIP → skip this topic

INLINE BUTTONS (for direct bot conversations):

when you interact with the bot directly (not via cron delivery), the clarify tool renders inline keyboard buttons:

[✅ Approve & Post] [🔄 Regenerate] [🔀 Different Topic]

tap a button. the agent acts immediately. no typing needed.

this works when you ask the bot directly: “draft a post about [topic]” the bot drafts, then uses clarify with button choices.

configure the response timeout:

agent: clarify_timeout: 600 # seconds, default 10 min

TEACH YOUR GATEWAY AGENT THE APPROVAL COMMANDS:

add to SOUL.md:

APPROVAL COMMANDS (from Telegram replies):

• “APPROVE” or “yes” or “go” → publish the most recent draft via xurl
• “REDO” → regenerate the draft with a different angle, same source
• “SKIP” → discard this draft, do not publish
• “EDIT [text]” → replace the draft with the provided text, then publish

after APPROVE:

1. run: xurl post “[draft text]”
2. wait 5 seconds
3. run: xurl reply [post_id] “[link from draft]”
4. confirm in Telegram: “posted. link in reply.”

STEP 8: SAFETY RAILS

Never auto-publish without approval:

The SOUL.md says “never publish without Telegram approval.” This is your safety net. One bad auto-posted take can cost your reputation.

Rate limiting:

Maximum 3 posts per day. 2 hours minimum between posts. Set in SOUL.md. The agent follows these as hard rules.

Content verification:

Every technical claim must be verifiable. The agent should search the web to confirm any facts before drafting. “I saw it on X” is not verification.

xurl security:

xurl never exposes your credentials to the agent. ~/.xurl stores tokens locally. The agent calls xurl commands but never reads the credential file. OAuth tokens auto-refresh. No passwords in chat context.

COST BREAKDOWN

ON NOUS PORTAL CLOUD:

**Total Cloud: ~$21-38/month. (cost could vary due to usage and where calculated for 2-3 posts per day with one account) **

ON YOUR OWN VPS:

Total VPS: ~$8-25/month + X subscription.

the biggest cost variable: links in posts. $0.015 per post without a link. $0.20 per post with a link. links in REPLIES also cost $0.20.

cost-saving rule: post content without links. put links in a SECOND reply (still $0.20 per reply with link, but you can skip link-replies on posts that don’t need them).

Token cost for scanning:

12 cron runs per day (every 2 hours). wakeAgent skips empty scans. Maybe 3-4 actual drafts per day. Estimated: $5-15/month in Grok tokens.

BEYOND SINGLE POSTS: WHAT ELSE THE MACHINE CAN DO

Once the pipeline is running, extend it:

**Quote tweet trending posts:**Agent finds a viral post in your niche. Drafts a quote tweet with your take. Sends to Telegram. You approve. Published.

**Reply to comments on your posts:**Cron job checks your latest post for new replies. Agent drafts responses. Sends to Telegram. You approve. Replies posted via xurl.

**Thread follow-ups:**Agent notices a post performed well (100+ bookmarks). Drafts a follow-up post expanding on the topic. Sends to Telegram the next morning.

**Competitor monitoring:**Agent tracks 5 competitors on X. Flags when they post something with high engagement. Suggests a counter-post or reaction in your voice.

**Content calendar:**Agent maintains a weekly plan in memory. Monday: news reaction. Tuesday: blueprint. Wednesday: hot take. Thursday: data dump. Suggests posts that fill gaps in the calendar.

THE FULL STACK

→ 1 Hermes profile (content-machine) → Grok 4.5 for X search and content intelligence → xurl for publishing (official X API CLI) → SOUL.md for voice, rules, and content standards → Telegram for approval gateway → 3 cron jobs (scanner, timing optimizer, weekly report) → wakeAgent gates (zero cost on quiet hours) → VPS keeps it running 24/7

you set the voice. the agent finds the news. you approve the draft. the agent publishes. your X presence runs while you build.

OFFICIAL SOURCES

• xurl Skill

• xurl CLI

• Grok 4.5 Announcement

• X Developers Guide All technical details verified against Hermes Agent v0.18.0 and xurl v1.1.0+ documentation.

@Teknium @NousResearch