8 Hermes Agent workflows that do real work
Copy a prompt, paste it into your Hermes Agent, and get a working workflow. Each one runs privately inside your own agent. No signup. No subscription.
Why this page exists
The product is Hermes Startup. The prompts are the raw material.
Each workflow is a ready-to-paste prompt that turns a Hermes Agent capability into a working routine. Copy one, replace the [BRACKETED] part, and run it privately in your own agent. Hermes Startup automates the same idea for one specific job: the last workflow on this page is where that path starts.
What you get
Eight workflows, written for Hermes Agent
- Ready-to-paste prompts.Each workflow ships with the full prompt. Replace the [BRACKETED] part and run.
- Private by design.Everything runs in your agent. Nothing is sent to a server.
- Free and open source.Use the prompts as they are or adapt them to your work.
Workflow 1
Morning Chief of Staff
One front door for your day: priorities in, a time-blocked plan out, and a clean carry-forward list for tomorrow.
When it helps: you want one routine that turns scattered tasks, deadlines, and messages into a daily operating view.
I want Hermes as my Morning Chief of Staff: one front door for the day. Do not act on anything external without my approval.
1. Ask for my active work areas, current priorities, deadlines, channels that matter, and tools I already use.
2. Build a daily operating view: urgent today, important this week, waiting on others, blocked, and low-leverage tasks that should not dominate the day.
3. Turn the list into an action plan: group related work, define the next action for each, and mark what can be delegated, scheduled, drafted, or deferred.
4. Route work that belongs to another bot, profile, or workflow instead of doing everything in this layer.
5. Propose a day plan with time blocks, deep-work windows, admin windows, and follow-ups. Show trade-offs when the plan is overloaded.
6. Keep a running update log through the day: completed, in progress, waiting, blocked, moved. Surface slippage early.
7. End with a short wrap-up and a next-day carry-forward list.
Rules: no fake urgency, no silently dropped tasks, no messages or calendar changes without approval, no hiding overload.
Hand back: priority view, routed tasks, proposed schedule, blockers, updates captured, carry-forward list.Workflow 2
Deep Research Desk
A decision-ready answer with primary evidence, competing interpretations, and explicit uncertainty. Not a list of search results.
When it helps: the answer will be acted on, so the research needs verification and honest confidence levels.
Build a Deep Research Desk for this question: [RESEARCH QUESTION]. I want a decision-ready answer with primary evidence, competing interpretations, and explicit uncertainty, not a list of search results.
1. Clarify the decision the research supports: scope, geography or time period, freshness, must-cover entities, excluded sources, and evidence level. Split the question into 3-5 non-overlapping workstreams.
2. Use direct search and page extraction for simple retrieval. Use browser automation only for dynamic pages or interactive data. Use X search only when social posts are real evidence.
3. Delegate up to three reasoning-heavy workstreams in parallel, each with complete context, source expectations, and an output schema, because delegated agents start with isolated context.
4. Require each workstream to return findings, strongest sources with dates, direct factual claims, unresolved questions, and evidence that challenges the obvious conclusion.
5. Identify the 3-7 claims that matter most to the decision and verify each independently before synthesis. If sources disagree, preserve the disagreement and state what each source establishes. Never average conflicting sources into a fake consensus.
6. Synthesize one report: executive answer, evidence table, major drivers, counter-case, confidence by claim, and what would change the conclusion. Label interpretation separately from observed facts.
Rules: no fabricated evidence, no unsupported conclusions, surface what could not be verified.
Hand back: one-paragraph answer, evidence matrix, strongest sources, contradictions, confidence by claim, unresolved gaps, next three checks that would most improve the decision.Workflow 3
Competitor Intelligence Watch
Track meaningful changes at target companies, deduplicate the noise, and keep an evidence-backed watchlist.
When it helps: you need to notice product launches, pricing moves, executive changes, and strategic shifts without reading the same story ten times.
Run a Competitor Intelligence Watch for: [COMPANIES OR PRODUCTS]. Monitor meaningful changes, deduplicate noise, and keep an evidence-backed watchlist.
1. Define the companies and products to watch, plus the source set: newsrooms, blogs, product pages, investor relations and filings, status and security pages, GitHub repos, and trade press.
2. Set a materiality threshold: what interrupts me, what goes in the digest, what is ignored. Do not elevate marketing posts, duplicate stories, minor dependency bumps, or low-signal chatter.
3. Scan all sources for each target and capture potential changes with links and timestamps.
4. Verify material changes against primary sources. Keep direct page monitors only where semantic change detection is needed.
5. Deduplicate by underlying event: group every article about the same launch or move into one record.
6. Summarize each event: what happened, why it matters, source, confidence, likely implication. Keep fact and implication separate.
7. Keep a recurring watch: store the baseline, run scheduled checks, alert only on new material changes.
8. Review quality after each cycle: drop noisy sources, fill missing primary evidence, tighten materiality rules from misses and false positives.
Rules: no rumor inflation, link evidence for material changes, no duplicate alerts.
Hand back: new material events only, source links, why each passed the threshold, duplicates rejected, coverage gaps.Workflow 4
Software Delivery Agent
One clean, verified change from ticket to tested output, with every review gate visible.
When it helps: you want a consistent, reviewable delivery loop instead of broad opportunistic edits.
Act as my software delivery agent for this repository and task: [ISSUE, FEATURE, OR BUG]. One clean verified change, not broad refactoring.
1. Define the ticket: restate the task and acceptance criteria, affected surfaces, constraints, likely files, tests required, and explicit out-of-scope work. Ask only for what the repo or issue cannot answer.
2. Inspect the repository: read project docs first (.hermes.md or HERMES.md if present), then code, tests, recent history, and existing commands.
3. Plan the smallest execution pattern that satisfies the criteria. Delegate at most three focused agents (implementation, tests, review) and give each full context.
4. Implement a bounded change. Preserve conventions and unrelated behavior. Do not silently upgrade dependencies, rewrite architecture, change generated files, or touch production configuration unless the task requires it.
5. Verify: targeted tests first, then the build, lint, and typecheck suite. Treat stop-time verification as a minimum gate, not the whole check.
6. Summarize: intent, files changed, tests and build results, risks, documentation updates, and any lockfile or artifact changes with reasons.
7. Hand back for review. Do not merge, deploy, publish, or close the issue. Return exactly what still needs human approval.
Rules: no silent production changes, no hiding failing tests, preserve repository conventions.Workflow 5
Skill Builder
Turn a recurring manual process into a reusable agent skill, proven before it is automated.
When it helps: you keep repeating a process and want the agent to learn it the way you actually do it, not from a guess.
Teach me this recurring workflow: [WORKFLOW]. Do not write a skill from my description alone. Observe or execute the real process with me, then turn only the proven method into reusable procedural memory.
1. Map the workflow before automating: trigger, inputs, tools, ordered steps, decisions, human judgment, external actions, quality checks, failure cases, expected output, definition of done. Ask me to demonstrate any step that depends on taste or tacit judgment.
2. Run it once in the safest useful mode. Stop before consequential steps and show the proposed action. Capture where clarification was needed, which tools worked, what failed, and what checks separated good results from bad.
3. Repeat on one different real example. Separate stable procedure from case-specific facts. If the runs need materially different logic, split the capability instead of forcing one skill.
4. Draft the skill only after the process is proven: trigger, minimal sequence, tools and skills required, approval points, acceptance checks, failure handling, output contract.
5. Test on at least two positive cases and one edge or non-trigger case. A skill that performs well but activates on unrelated tasks is not ready.
6. Revise only from observed failures. Do not silently expand scope, permissions, or external actions while improving.
7. Once live, record the specific failure or improvement first, then patch the skill deliberately. Keep topic facts in memory and project files; keep repeatable procedure in the skill.
Rules: no invented steps, no forced automation where judgment stays with me, prove every improvement with one bounded test.Workflow 6
Multi-Agent Project Team
A small team of specialist agents for one project: clear ownership, clean handoffs, approval gates.
When it helps: a project has several distinct workstreams and you want each owned by a focused agent instead of one generalist doing everything.
Build a small Hermes Bot team for this project: [PROJECT]. Use the fewest specialist agents that get the job done. I want clear ownership and clean handoffs, not a swarm.
1. Define the project outcome, recurring workstreams, decisions that require my approval, and the work that really benefits from persistent specialist context. Propose 2-4 bots maximum, each with a distinct role.
2. Create each bot as its own profile with isolated config, memory, skills, credentials, sessions, and cron jobs. Never point multiple agents at the same profile or home directory.
3. For each bot define: job, inputs it owns, outputs it produces, allowed tools and skills, source-of-truth files, approval boundaries, what it must never do, and the exact handoff it gives the next bot. Give each bot only the credentials it needs.
4. Route work explicitly with mentions or queues. One owner per deliverable, one final integrator. A bot does not redo another bot's work unless it is the declared reviewer.
5. Run one supervised trial on a small real task that needs at least two specialists. Track ownership, context passed, duplicate work, and whether the integrator reconciled outputs without losing evidence.
6. Fix the team from the trial: merge overlapping roles, narrow vague responsibilities, remove bots that exist only because multi-agent sounds better.
7. Add routines only for recurring work owned by one bot, as scheduled jobs that deliver into that bot's chat. Test every routine manually before scheduling.
8. Set operating limits: maximum concurrent expensive work, models per bot, who can browse or write files, and which external actions always stop for my approval. Review cost and usefulness after one week before expanding.
Rules: no overlapping ownership, no hidden blockers, no autonomous external actions without approval, clear accountability per task.Workflow 7
Browser Operations Assistant
Let the agent use a browser safely: inspect first, act one step at a time, stop for approval on anything consequential.
When it helps: a task needs real site interaction and you want it done without blind clicking or surprise purchases.
Complete this browser workflow: [WEBSITE TASK]. One bounded run with visible checkpoints. Browser access is not blanket permission to submit forms, buy things, send messages, or change account state.
1. Confirm the target site, exact goal, account and environment, allowed actions, forbidden actions, and the final safe checkpoint. Prefer normal search and page extraction for simple information retrieval; use the browser only when the page is dynamic or needs interaction.
2. Open the site and inspect before acting: identify actual controls and page state from the page snapshot or accessibility tree. Use screenshots for anything the text snapshot misses.
3. Navigate one step at a time using observed controls. Re-inspect after major navigation so stale selectors do not hit the wrong control. Keep one isolated browser session for the task.
4. For login, use an already authenticated profile or hand control to me for credentials and 2FA. Never print passwords, session cookies, tokens, or recovery codes into chat or logs.
5. Stop before any action that creates an external commitment unless I already approved that exact action: purchase, payment, submission, booking, account change, deletion, message send, publish, or irreversible form completion. Show me the target, key fields, price or terms, and what happens after the click.
6. After approval, perform only the approved action and verify the resulting page or state. Capture the confirmation evidence. If the result is ambiguous, inspect before retrying so nothing is submitted twice.
7. If the workflow is likely to recur, document the stable sequence and failure points as a skill only after a real successful run. Do not hardcode fragile selectors. Do not store credentials in the skill.
8. For unattended repetition, schedule only read-only or low-consequence checks by default. Keep transactional actions interactive unless I set a specific standing rule.
Rules: no blind clicking, no destructive actions without approval, prefer test accounts, explain failures and stop at the last verified checkpoint.Workflow 8
Memory and Decision System
Turn agent memory into a reliable operating system: save durable decisions, recall them at the right time, preserve history, surface contradictions.
When it helps: your agent forgets context between sessions or you want decisions from months ago to still shape today's work.
Manage my project memory as a disciplined operating system. Save durable decisions and conventions, recall them at the right time, preserve history, and surface contradictions.
1. Define the memory foundations: the four context layers (identity and style, about me, environment and workflow lessons, project rules) and the project memory files that hold them. Use past-session search for detail when needed.
2. Set recall rules: review existing context and memory entries, spot duplicates, stale rules, contradictions, and facts in the wrong layer. Do not rewrite yet. Stage every proposed change.
3. Set save rules: durable memory holds stable preferences, environment facts, recurring tools, important corrections, and decisions that shape future sessions. Exclude raw logs, large files, one-off status, and easily rediscoverable details.
4. Write atomic durable facts: for each new decision, record what changed, why it matters, and enough context to distinguish it from older rules. Be concise and specific.
5. Revisit decisions when I reference last time, we decided, or inactive context. Retrieve the actual messages around that decision.
6. Surface contradictions: when a decision supersedes another, replace or consolidate the active memory and preserve the old record as superseded history. Do not silently choose.
7. Use memory on future tasks: load relevant memory, apply active decisions, cite sources, and call out uncertainty instead of asking me to restate everything.
8. Audit at meaningful milestones: active facts, stale or conflicting entries, evidence used, capacity remaining, and whether a fresh-session resume recovered the project correctly.
Rules: no credentials, secrets, or sensitive data; no saving every conversation; preserve superseded decisions; recall only when useful.
Hand back: active facts, updated files, staged changes, contradictions resolved or flagged, capacity remaining, next-step recommendations.One more workflow: make your first $1
Hermes Startup turns your Hermes Agent into a business that pays you. Answer ten private questions, get all ten proven ideas matched to you, free. When you pick one, a one-time US$10 balance funds the API calls to build and run it, with every action and spend approved by you.