Detailed guide • Video-derived • Hermes Agent OS

Build Anything with an Agent OS: Hermes, Voice, Goals, Video, Search, and Memory Guide (2026-05-28)

This guide turns Julian Goldie’s “How to Build Anything with Agent OS” video into a practical build plan. It focuses on the architecture and operating habits: one dashboard, voice interaction, Hermes /goal, a video workflow, search/research, and a persistent memory vault.

Source video: 20:16Published: 2026-05-28Audience: AI workflow buildersDifficulty: intermediate

Overview: what you are building

The video’s central idea is simple: stop treating AI as a calculator where you ask one question, receive one answer, and lose the output. Instead, build an agent operating system: a local dashboard where agents, tools, files, memory, and finished outputs are organized around repeatable workflows.

Recommended outcome: a dashboard that launches the AI workflows you actually use, saves outputs into a searchable knowledge base, and lets Hermes or another agent work from measurable goals instead of constant human babysitting.

The five “power moves” from the video

  • Voice: talk to agents instead of typing every request.
  • Goals: use Hermes /goal for longer-running autonomous work.
  • Video: use a video agent/workspace, mentioned with Hyperframes CLI.
  • Search: run research queries that return organized markdown guides.
  • Memory: store voice, search, video, goal, and project outputs in an Obsidian-style vault.

What this guide adds

  • Neutralizes hype into a practical architecture.
  • Cross-checks Hermes terminology, especially /goal, against current Hermes references.
  • Separates optional paid/community resources from the build-it-yourself path.
  • Gives a phased implementation plan so you can build one useful module at a time.

Agent OS architecture

Think of the Agent OS as a front door for work, not as a single magic tool. The dashboard is the place where you start workflows; Hermes, OpenClaw-style coding agents, video tools, search tools, and your memory vault do the specialized work behind the scenes.

1. Dashboard layer

A local web dashboard or app with buttons/cards for common workflows: talk to an agent, start a goal, generate a video, run research, open recent outputs, or search memory.

2. Agent layer

Hermes Agent handles tool-using work, /goal objectives, provider/model access, skills, memory, and integrations. Other agents can be launched as bounded workers when needed.

3. Workflow layer

Each workflow has inputs, a saved output path, and a definition of done. Examples: “turn a keyword into three SEO posts,” “make a short video from a prompt,” or “research a new tool and save a markdown brief.”

4. Memory layer

An Obsidian-style vault or markdown workspace stores durable outputs, prompts, project notes, transcripts, and examples. The point is findability and reusable context.

Dashboard
  ├─ Voice: speech → agent conversation → saved notes
  ├─ Goals: /goal objective → autonomous run → local files + logs
  ├─ Video: prompt → video workflow → preview + saved output
  ├─ Search: query → markdown research brief → vault
  └─ Memory: searchable markdown vault → context for future agents

Prerequisites and assumptions

  • Hermes Agent installed and working. Current install path is usually: curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash, then hermes setup.
  • A model/provider configured. Hermes can use many providers, including OpenRouter, Anthropic, Gemini, DeepSeek, Nous Portal OAuth, OpenAI Codex OAuth, xAI/Grok, Hugging Face, and custom endpoints. Use hermes model or hermes auth rather than pasting tokens into prompts.
  • A local workspace. Create a folder for dashboard code, generated assets, and logs. Keep it separate from your private vault if you will publish outputs.
  • A markdown knowledge vault. Obsidian is the example pattern in the video, but any searchable folder of markdown files can work.
  • Optional specialized tools. Hyperframes CLI for video, OpenClaw/OpenCode/Claude Code/Codex-style agents for coding, search APIs or browser automation for research, and Netlify if you publish generated sites.
Safety boundary: do not paste provider tokens, passwords, OAuth codes, or private client data into prompts. Store credentials in Hermes config/auth/env mechanisms and keep public outputs scrubbed.

Step-by-step build plan

Step 1 — Define your first three workflows

Do not begin by building a giant dashboard. Write down three workflows you repeat often. Good first candidates are:

  • “Research a topic and save a markdown guide.”
  • “Start a Hermes goal to build or update a small website/app.”
  • “Create an outline, script, or video asset from a prompt.”

For each workflow, define the input, tool, output folder, and success check.

Step 2 — Create a local project and dashboard shell

Ask Hermes or Claude to scaffold a small dashboard. It can be a simple static HTML/JavaScript page at first. The video emphasizes that the first version does not need to be perfect; the system improves as you use it.

Build a local Agent OS dashboard for my workflows.
Include cards for: Voice, Hermes Goals, Video, Search, and Memory.
For each card, show: purpose, input box, output location, and next action button.
Keep it simple and save all files locally in this project folder.

Step 3 — Wire in Hermes for goals and long-running work

Hermes supports an in-session /goal slash command for standing objectives. In the video transcript, the presenter describes clicking “start goal,” walking away, and letting the agent work for multiple turns in a sandboxed directory. In guide form, the important discipline is the definition of done.

/goal Build a small landing page for [topic].
Definition of done:
- Create local HTML/CSS/JS files in [folder].
- Include the sections: hero, benefits, proof, CTA, FAQ.
- Run a local validation check.
- Summarize changed files and any assumptions.
Stop before publishing or spending money.

Use /goal status, /goal pause, /goal resume, and /goal clear when you need to inspect or control the ongoing objective.

Step 4 — Add voice as an input mode

The video’s “voice” module is about reducing friction: speak to the agent like a phone call, then save the conversation or resulting task into the system. For a first version, you can treat voice as optional: transcribe voice notes into markdown, then pass the cleaned instruction to Hermes.

  • Save raw voice transcript to vault/inbox/voice/.
  • Save cleaned task briefs to vault/tasks/.
  • Turn recurring voice requests into dashboard buttons or prompt templates.

Step 5 — Add a research/search workflow

The demo shows a current-search workflow that returns a nicely formatted markdown guide. Your implementation can be simple: accept a query, run your preferred search/research process, and save a markdown brief with sources.

Research: [query]
Output format:
- 5-sentence overview
- Key names, tools, links, and dates
- Practical implications
- Risks/caveats
- Source list with URLs
Save the result to vault/research/YYYY-MM-DD-[slug].md

Step 6 — Add video generation as a separate lane

The presenter mentions using Hyperframes CLI so one prompt can become a video and the output can be previewed in the dashboard. Keep video generation isolated from the rest of the system because it can involve large files and different dependencies.

  • Use a dedicated workspace/video/ folder.
  • Save prompts, scripts, rendered videos, and thumbnails together.
  • Keep a manifest file for each generation: prompt, model/tool, date, output path, and whether it is publish-ready.

Step 7 — Build the memory vault as the system’s compounding asset

The video calls memory the part that saves the most time. The practical version is not mystical: it is a clean folder structure plus consistent naming. Store outputs where future agents can find them.

vault/
  inbox/
    voice/
    quick-notes/
  research/
  goals/
  video/
  prompts/
  projects/
  clients-or-private/   # keep private and never publish accidentally

Each note should include: title, date, source workflow, summary, useful links, and next actions.

Step 8 — Add one module per day, then refine

The video recommends not trying to build everything at once. A practical week-one schedule:

  • Day 1: dashboard shell and folder structure.
  • Day 2: Hermes goal card and one goal template.
  • Day 3: search/research workflow.
  • Day 4: memory vault organization and search.
  • Day 5: voice or video lane, whichever you will use first.

Reusable prompts and templates

Dashboard scaffold prompt

Build me a local Agent OS dashboard.
Audience: one operator using AI for [your work].
Workflows to include: [workflow 1], [workflow 2], [workflow 3].
Requirements:
- Save outputs under a clear workspace folder.
- Include a search box for existing markdown notes.
- Include buttons or instructions for launching Hermes workflows.
- Include a recent outputs panel.
- Do not require paid services for the first version.
- Create a README explaining how to run and extend it.

Hermes /goal template

/goal [Outcome]
Context:
- Project folder: [path]
- Audience/users: [who]
- Constraints: [time, tools, privacy, budget]
Definition of done:
- [measurable deliverable 1]
- [measurable deliverable 2]
- [test/validation evidence]
Boundaries:
- Ask before deleting files, spending money, contacting people, or publishing.
- Do not expose secrets or private data.
Final report:
- Changed files
- What works
- What still needs human review

Memory-note template

---
title: [Workflow output title]
date: YYYY-MM-DD
workflow: [voice | goal | video | search | client | project]
source: [link, prompt, or task]
status: [draft | verified | published | archived]
---

## Summary

## Key details

## Links and files

## Reusable prompts or examples

## Next actions
Tip: Put these templates directly in your vault under prompts/. The dashboard can simply open or copy them before you automate anything.

Operating rhythm: how to actually use the system

The biggest risk is building a shiny dashboard and then returning to scattered habits. Use a lightweight rhythm:

  • Morning: open the dashboard, choose one priority workflow, and start one agent task with a clear definition of done.
  • During work: capture voice notes or quick tasks into the inbox, not random chats.
  • End of day: move useful outputs into the vault, rename files clearly, and mark what is ready to reuse.
  • Weekly: convert repeated instructions into templates; archive abandoned experiments.
  • Monthly: add or remove dashboard modules based on real use, not novelty.

Verify that your Agent OS works

  • You can open one dashboard and see the five lanes: voice, goals, video, search, and memory.
  • A Hermes goal can create or modify files in a known local folder and produce a final report.
  • Every workflow has a saved output path; nothing lands in a mystery folder.
  • You can search the vault and find a recent voice note, research result, video prompt, and goal output.
  • You have at least one reusable prompt template for each workflow you actually use.
  • You know what actions require human approval: publishing, deleting, spending money, contacting people, or handling sensitive data.

Troubleshooting and common pitfalls

“This feels too complex.”

Build one workflow first. The video explicitly says each component can stand alone. Start with memory plus one Hermes goal template.

“My agents wander.”

Your goal is probably too vague. Add acceptance criteria, output paths, boundaries, and a final report format.

“I still lose files.”

Standardize output paths. Require every workflow to write a markdown note or manifest into the vault.

“The transcript says odd command names.”

Speech-to-text can garble commands. This guide normalizes “slash goal” style references to Hermes /goal after checking current Hermes Agent references.

“Do I need the paid community or zip?”

No for the concept. The video promotes optional ready-made files and community support. The build-it-yourself path is: Hermes + local dashboard + markdown vault + your chosen tools.

“Should I deploy through GitHub?”

Not necessarily. The video’s final Q&A says an SEO/blog workflow can create content locally and deploy directly to Netlify, with backups as needed.

Video timestamp map

  • 00:00 — Build an Agent OS: The video opens with the promise: one dashboard that can run voice agents, video creation, long-running goals, and a memory system.
  • 02:22 — Why an OS Beats Tools: The presenter contrasts one-off AI tool use with an operating-system approach where outputs, context, and workflows compound.
  • 03:31 — One Dashboard Demo: Demonstrates a dashboard that can launch OpenClaw-style chat, goals, video workspaces, search, and memory from one interface.
  • 05:32 — Five Power Moves: Introduces the stack: voice, goals, video, search/research, and memory.
  • 06:13 — Voice Agents Setup: Shows a talk/studio style interface for speaking to agents instead of typing every request.
  • 06:36 — Goal Mode Autonomy: Discusses Hermes /goal as a long-horizon objective mode that runs in a sandboxed directory for multiple turns.
  • 07:10 — Video Agent Workflow: Mentions a video agent built around Hyperframes CLI and a one-prompt-to-video workflow.
  • 07:44 — Search and Research: Shows a search workflow that returns a markdown guide from current/social search context.
  • 08:11 — Memory in Obsidian: Explains saving outputs into an Obsidian-style knowledge vault so work can be found and reused as context.
  • 11:00 — How to Build Yours: Recommends starting by asking Hermes or Claude to build a local dashboard around the reader’s own workflows, then iterating.
  • 12:52 — Q&A and Access Options: Covers Hermes model/login options, optional paid community files, and the idea of building one module at a time.
  • 17:26 — Recap and Next Steps: Recaps the five core systems and recommends building a system rather than juggling separate tools.
  • 19:36 — Final Q&A and Outro: Notes an SEO/blog workflow can deploy directly to Netlify without GitHub in between.

Sources and related references

Editorial note: the video includes optional paid/community offers. This guide treats those as optional resources and focuses on the self-build architecture and operational practice.