Workflows
40 recipes, filter by use case, license, or difficulty.
QM: prove the destructive-action denials hold in every security posture, even the loosest
Run YC's company-wide QM agent with one org-wide security posture, and prove the predeclared hard denials (recursive delete, destructive SQL, mass delete) are refused in every posture including the loosest, so loosening the posture only relaxes approvals, never the destructive-action guardrails.
One shared memory for every coding agent: prove the configs actually point at the same server
Wire a Markdown memory MCP server (Basic Memory or an Obsidian MCP) into Claude Code, Cursor and Cline, and prove with CI that all three resolve to one server, that a write-the-memory house rule exists, and that the vault is under git before any agent gets write access.
Validate a WrenAI semantic model's references before an agent queries through it
Before letting an agent query through WrenAI's governed semantic layer (MDL), validate that every relationship and metric resolves to a model and column that actually exist, so a stale definition fails a check instead of quietly returning wrong-but-plausible numbers.
Verify an agent-skills plugin before you ship or install it
Check that a Claude Code / agentskills.io skills package is structurally valid, every SKILL.md has proper frontmatter and a name matching its folder, and the plugin marketplace manifest parses, so a broken skill never fails to load after you publish it.
WebMCP: declare a site's agent tools, and gate the ones that spend money
Publish a WebMCP tool manifest so an agent calls named site tools instead of guessing at buttons, and validate that every tool has a real schema and every sensitive tool (pay, checkout, delete) requires a human confirmation before it runs.
Voyager pattern: validate a procedural skill store before you trust a saved skill
Capture a working routine as a named, described skill entry and validate the skill-library structure, so saved skills are findable and reviewable before an agent reuses them.
Hermes MoA: stack frontier models into one virtual model for hard turns
Configure a Mixture-of-Agents preset in Hermes so several models answer in parallel and an aggregator writes the final response, and validate the preset before you spend double the tokens on it.
promptfoo: make agent evals fail the build, not the user
Write a declarative promptfoo config with real assertions and wire promptfoo eval into CI, so a regression in prompt or agent behavior fails a check instead of reaching production.
E2B: run model-written code in a sandbox, not on your box
Execute AI-generated code in an isolated E2B cloud sandbox with the API key read from the environment, so untrusted code never touches your laptop or prod.
DSPy: program the pipeline, compile the prompts (stop hand-tuning)
Define an agent step as a DSPy program with a signature, a module, and a metric, so an optimizer improves the prompts against your metric instead of you fiddling by hand.
Write an agent loop in code with smolagents (sandboxed)
Stand up a smolagents CodeAgent that writes Python to act instead of emitting JSON tool calls, and run that model-written code in a sandbox, not on your machine.
Hermes /learn: author a reusable skill from a source, not by hand
Use Hermes Agent's /learn to turn a doc, a repo, or a workflow you just performed into a standards-compliant SKILL.md (and an automatic slash command), instead of hand-writing a skill file that drifts from the real docs.
Text your own AI assistant on WhatsApp: Hermes wired to FreeLLMAPI
Point Hermes Agent at a FreeLLMAPI backend and connect it to WhatsApp, so a memory-keeping assistant runs 24/7 on a free always-on server and costs nothing per message, with the wiring validated before you link a number.
FreeLLMAPI: one socket, sixteen free model tiers with auto-fallback
Front the free tiers of many providers with a single OpenAI-compatible endpoint and a prioritized fallback chain, so your apps point at one key and the router switches providers automatically when one runs out for the day.
Flue: define a sandboxed headless agent and deploy it anywhere
Author a Flue agent manifest that runs each agent in a sandbox instead of a dedicated container, keeping infra costs flat as task volume grows, and validate the config before you deploy.
Build the Fugu pattern in the open: fan out, assign roles, verify
Run the idea under Fugu, a panel of models with roles and a verifier or a tests-passing arbiter, with your own keys and every hop visible, so the black box is a choice and not a lock-in.
Run GLM-5.2 fully local on a Mac Studio and drive it with Hermes
Serve GLM-5.2's 2-bit GGUF on a Mac Studio over an OpenAI-compatible endpoint, point Hermes at it as a custom provider, and hand it long hands-off agentic jobs.
Eve: make evals the deploy gate, not a vibe check
Write a file-based Eve eval that asserts a large refund routes through approval, and wire eve eval into CI so a prompt change can't ship a regression.
Eve: gate the dangerous tool behind a human, in one field
Make an Eve agent's irreversible tool stop and wait for a person above a threshold, using the needsApproval predicate, and verify the file is shaped right before you trust it.
Hermes + OKF: a knowledge folder your agent reads before it answers
Wire an OKF knowledge bundle into Hermes so the agent reads knowledge/index.md first, validated bundle conformance + a SOUL.md house rule that points at it.
OKF: consume a bundle without blowing your context window
Use index.md for progressive disclosure so an agent navigates the graph instead of swallowing the whole folder, with reserved files that follow the spec.
OKF: generate a bundle from your schema, then ground it with citations
Mirror Google's reference pattern: a model drafts one OKF concept per table or module, and a stricter project rule requires a # Citations section on anything with a resource, so the knowledge is checkable, not just plausible.
OKF: turn your repo's tribal knowledge into a bundle your agent reads first
Write one markdown concept per thing worth knowing, cross-linked, as a conformant OKF bundle in version control that any agent can read with no SDK.
Hermes + Mnemosyne: give the cheap agent a local memory
Wire Mnemosyne into Hermes as an MCP server so a budget model stops re-stuffing the same context every session, validated config + a real remember→recall round-trip.
Hermes: a scheduled agentic briefing on Hy3-preview
Schedule a hands-off tool-using job (search, summarize, deliver) on the cheap, agentic Hy3-preview model, validated cron + config.
Hermes: offload background jobs to MiMo-V2-Flash and cut your main bill
Route Hermes' cheap, high-volume auxiliary work (compression, vision, web-extract) to MiMo-V2-Flash so your expensive main model only handles real reasoning.
Hermes + DeepSeek V4 Flash: a one-line reasoning-effort throttle
Run one model from cheap-and-fast to deep-and-careful with a single reasoning_effort setting, so you don't pay for deep thinking on easy turns.
Hermes on MiMo-V2.5: a 1M-context agent for pennies
Set MiMo-V2.5 as your everyday Hermes model: 1M context at $0.14/$0.28 per 1M tokens, with tool-use enforcement on for a non-GPT model.
Letta + Fable 5: Persistent Memory for Multi-Week Projects
Give Fable 5 a memory that survives restarts via Letta's structured memory blocks, so a project runs for weeks, not one session.
Letta: An Agent That Manages Its Own Memory
Install the Letta CLI and SDK, the MemGPT lineage where the agent edits its own memory blocks like an OS pages memory.
Graphiti: A Temporal Graph for What Was True When
Stand up the bi-temporal context-graph engine behind Zep on a local FalkorDB, with indices built and ready for episodes.
Mem0: A Personalization Layer Your Assistant Remembers With
Add user, session, and agent-level memory to an assistant so it remembers preferences across conversations.
Mnemosyne: Fully Local Agent Memory, No Cloud at All
Give your agent persistent memory in a single SQLite file: store a fact, recall it by keyword, fully offline.
Obsidian × MCPVault: The Project Kickoff Generator
Hand Claude your goals and constraints and have it scaffold a whole project folder from what your vault already knows.
Hermes Kanban: The Swarm
Fan a goal out to N parallel workers, gate a verifier on all of them, then a synthesizer on the verifier.
Hermes Kanban: The Idempotent Nightly Review
A task that files itself onto the board every night and never double-books.
Hermes Kanban: The Research-to-Draft Relay
Two researchers work in parallel, then a writer's card unblocks once both finish.
Meeting Processor: Raw Dump to Structured Note
Paste a raw meeting dump into your vault and have Claude turn it into action items, decisions, and links.
Fine-Tune an Open LLM to Make It Yours
Adapt an open-weight model to your domain with a small dataset.
Self-Hosted Self-Improving Agent with Hermes
Stand up a Hermes agent that remembers and improves over time on your own VPS.