Detailed guide • Hermes Agent • /goal workflows

Hermes /goal on a VPS: Setup, CEO/CTO Agents, and Practical Autonomous Workflows (2026-05-17)

Use this guide to turn the video’s demo into a safe, repeatable workflow: install Hermes Agent, configure model access, understand /goal, create skills, delegate to coding agents, and write goals that run for hours without wandering.

Updated 2026-05-17Difficulty: IntermediateTime: 45–90 minutesCategory: AI & Automation

What you will build

By the end, you will have a Hermes Agent environment that can run long, judge-guided tasks from a terminal or server, with enough configuration to delegate practical work such as building an app, drafting a campaign, testing software, generating a slide deck, or backfilling records.

Definition of done: Hermes launches, responds to a test message, has model access configured securely, can see useful skills, and you can start a /goal with measurable acceptance criteria instead of a vague instruction.

What /goal is — and why it matters

The video contrasts simple “agent loops” with a more useful goal loop. A basic loop keeps prompting an agent over and over; it may burn tokens, repeat itself, or continue after the work is done. Hermes /goal is more useful because the task is framed around an end state and progress can be judged against that end state.

Goal text

The desired outcome, not just an activity. Example: “A working reporting app with weekly submissions and a marketing blog integrated.”

Judge/check

A separate review step evaluates whether the agent is progressing and whether completion criteria are met.

Persistence

Long jobs can survive pauses, restarts, or steering. You can check status and resume instead of restarting from scratch.

Sub-goals

You can add refinements mid-run, such as a visual style, extra test, or changed deliverable, without throwing away prior progress.

Key lesson: /goal is only as good as the finish line you give it. “Build a great app” is not a goal. “Build a Next.js app where team members submit weekly wins, blockers, plans, and mood; include tests and a launch blog page” is a goal.

Prerequisites and safety

  • A local computer with a terminal, or a VPS you can SSH into.
  • Basic comfort copying commands and reading terminal output.
  • One model/provider path: OpenAI/Codex OAuth, OpenRouter API key, Anthropic API key, Nous Portal, Gemini, or another Hermes-supported provider.
  • Optional: GitHub account if you want agents to create branches, issues, pull requests, or repositories.
  • Optional: OpenRouter credits if using image generation or non-subscription API models.
Do not paste secrets into prompts. Store API keys with hermes config set, hermes auth add, provider login, or environment files. Never place API keys in a guide, public repo, screenshot, or chat message.

1. Prepare a VPS or local machine

The video uses a Hostinger VPS because it is a clean always-on environment. You can also run Hermes locally on macOS, Linux, Windows, or WSL2. The VPS route is helpful when you want long-running goals to continue while your laptop is closed.

  1. Create the server. Choose a Linux VPS close to your location. A small plan is enough for agent orchestration; larger plans are useful if you run local models, browsers, build tools, or many concurrent agents.
  2. Record access details securely. Save the SSH command, username, server IP, and password/key in a password manager.
  3. Connect by SSH.
    ssh root@YOUR_SERVER_IP

    If prompted about host authenticity, confirm only when the IP is the server you just created.

  4. Update the server.
    apt update && apt upgrade -y

If using macOS locally, skip the VPS section and install Hermes directly in your terminal.

2. Install and launch Hermes Agent

The official quick-start command is:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash
Security note: Piping a remote install script into a shell is convenient but powerful. For stricter environments, open the script URL first, review it, then run an audited install path from the official repository.
  1. Run setup.
    hermes setup

    Use the setup wizard to choose a provider, model, terminal backend, and optional gateway/messaging configuration.

  2. Check health.
    hermes doctor

    Fix missing dependencies before starting a long /goal.

  3. Start a test chat.
    hermes

    Send a simple message. If it responds, the model path is working.

  4. Learn the two key references.
    hermes --help
# then inside Hermes:
/help

3. Configure model/provider access safely

The video demonstrates using a ChatGPT/Codex-style login and also mentions OpenRouter for image generation. Hermes supports many providers, so pick the one that matches your accounts and budget.

NeedRecommended command/pathNotes
Interactive provider choicehermes model or hermes setup modelBest first step if unsure.
OAuth login, where supportedhermes login --provider openai-codexUse official Hermes provider names shown by your installed version.
Store an API keyhermes config set model.api_key YOUR_KEY or provider-specific configNever paste the key into normal chat.
View config pathhermes config pathUseful for backup and troubleshooting.
Secret storagehermes config env-pathSecrets belong in environment/config, not public docs.
OpenRouter for images: If you use an image-generation workflow, add only a small credit limit at first. Use a capped key, test one generation, and then increase limits only when the workflow is stable.

4. Add skills and reusable resources

The video shows Hermes creating a skill for image-generation slide decks. Skills are reusable playbooks that load when relevant, so the agent does not have to rediscover a process every time.

  1. List what you already have.
    hermes skills list
  2. Search or browse.
    hermes skills search powerpoint
hermes skills browse
  3. Install or create a skill.

    Install known skills from the hub, or ask Hermes to create one after it completes a repeatable workflow.

  4. Reload skills after adding them.

    Inside Hermes, use /reload-skills or start a new session so the new skill appears in the system context.

Good skill pattern: trigger conditions, exact commands, prerequisites, pitfalls, verification steps, and examples. A skill should save future time, not just store a vague note.

5. Run /goal with a measurable finish line

Start /goal from an interactive Hermes session. The exact syntax can change by version, so run /help if needed. The durable pattern is:

/goal Build [specific deliverable].
Definition of done:
1. [Measurable outcome]
2. [Files/tests/URLs/evidence]
3. [Quality criteria]
4. [Stop when these are satisfied and summarize what changed.]

Prompt template for a coding goal

/goal Create a modern Next.js weekly reporting app.

Outcome:
- Team members can submit weekly wins, blockers, next-week plans, and mood.
- Managers can view a dashboard of all reports.
- Include one sample marketing blog post at /blog.

Definition of done:
- App builds successfully.
- At least one test or scripted verification passes.
- README explains how to run it.
- Changes are committed to a local git repo.
- Final response lists paths, commands run, and verification results.

Prompt template for business/outreach work

/goal Identify 20 likely local buyers for excess farm produce and draft a contact plan.

Definition of done:
- Produce a CSV with business name, contact method, reason they fit, and first-message draft.
- Do not send messages without explicit approval.
- Include a short prioritization summary and next-step checklist.
Approval boundary: For outreach, purchases, deletions, remote writes, or public posts, have the agent draft and stage first. Require explicit human approval before sending or publishing.

6. The CEO/CTO pattern: Hermes orchestrates, coding agents execute

The video’s most useful pattern is to make Hermes the “CEO” that owns the outcome and delegates focused work to coding agents such as Codex CLI-style subagents. The CEO keeps the big picture; the CTO agent builds; a marketing agent can write launch copy; the judge checks whether the deliverables satisfy the goal.

  1. State the roles. Tell Hermes it is responsible for orchestration and quality, not just coding.
  2. Delegate bounded work. Give each subagent a clear deliverable and avoid overlapping edits.
  3. Require integration. The final goal should not be “two agents produced files.” It should be “the outputs are integrated and verified.”
  4. Ask for evidence. Require paths, test output, screenshots, URLs, commit hashes, or checklists.
/goal You are the project CEO. Use available autonomous-agent/coding skills when helpful.

Project:
- Build a Next.js weekly reporting app.
- Create a B2B launch campaign with one blog post and two email drafts.
- Integrate the blog post into the app.

Definition of done:
- App runs locally and includes reporting form, dashboard, and /blog route.
- Marketing deliverables are saved in docs/marketing/.
- README includes run instructions.
- Verification commands are run and summarized.
- Do not stop until all deliverables exist and are integrated.

While the goal is running, use status and steering commands available in your Hermes version, such as /goal status, /goal pause, /goal resume, or sub-goal/steering commands shown by /help.

High-value use cases from the video

Slide decks

Give a style reference, outline, number of slides, and require editable text, not just flat images. Verify file opens before calling it done.

App testing

Define every feature to test, the emulator/browser target, and expected pass/fail output. Great for overnight regression checks.

Data backfills

Define record count, source, destination, idempotency, and audit report. Require a dry run before touching production data.

Business growth

Ask for researched leads, drafts, calendars, or landing-page improvement plans. Require approval before external messages are sent.

Codebase refactors

Define language/framework target, tests that must pass, migration constraints, and rollback plan.

Research packages

Ask for source notes, ranked options, costs, risks, and recommendation. A goal works best when the final artifact is concrete.

Troubleshooting and guardrails

Hermes does not start

  • Run hermes doctor.
  • Check your Python/node/system dependencies from the official docs.
  • Restart your terminal after install so PATH changes apply.

Provider login fails

  • Run hermes model and select the provider again.
  • For OAuth flows, copy the device code exactly and complete browser login.
  • For API keys, store keys in config/env and verify no extra spaces were pasted.

/goal wanders or never finishes

  • Add measurable completion criteria.
  • Break the work into deliverables with file paths and tests.
  • Use sub-goals/steering to narrow scope.
  • Set budget or turn limits when appropriate.

Subagents edit over each other

  • Assign separate folders, branches, or worktrees.
  • Have Hermes integrate after subagents finish.
  • Require a final diff/review before committing.

Long VPS jobs disconnect

  • Use tmux or a durable background/service setup.
  • Keep credentials in environment/config, not in terminal scrollback.
  • Periodically check /goal status rather than restarting.

Sources and related links

Creator-provided video description links include Hostinger, David Ondrej’s Hermes CEO resource page, New Society, Scale Software, Instagram, and X/Twitter. Treat sponsored services as optional examples; choose infrastructure and providers based on your security, budget, and reliability needs.