Workflows

Self-hosting the open-source stack? Prove your backup actually restores before you need it

Make the one self-hosting discipline that matters a machine check: back up your database, destroy the live copy, restore from the backup, and assert the restored data matches the original exactly, so you find a broken backup in CI instead of at 2am.

Prove your meeting-notes pipeline never phones home (and gates on consent)

Run capture -> whisper.cpp transcription -> Ollama summary fully on your machine, with a CI check that every endpoint is loopback, no cloud host or API key appears anywhere in the config, and recording is gated on a consent acknowledgment.

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.

Chat with a CSV, but pin a known-answer guardrail so a wrong query cannot pass

Ask a CSV or dataframe questions in plain English with PandasAI, but wrap it in a deterministic known-answer check so a confident-but-wrong generated query is caught instead of trusted.

Self-host CodeWiki on private code: validate the config before you spend tokens

Configure the open-source FSoft CodeWiki to generate architecture-aware docs on your own machine (so private code never leaves it), and validate the provider and model config before a full, token-spending run.

Wire the DeepWiki MCP into your agent so it looks up repos instead of hallucinating

Give your coding agent the DeepWiki MCP server so it can pull real context about an unfamiliar dependency mid-task, and validate the client config declares the three documented tools before you trust it.

Advisor pattern: cap how often the expensive model gets called, and catch drift

Run a cheap executor with a rarely-consulted expensive advisor, but enforce a hard cap on advisor calls per task and a drift-check before the executor can keep going, so the benchmark's 63% discount doesn't quietly erode into nothing.

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.

Shepherd: prove an agent task is retained and least-privilege before it runs

Declare an agent task's per-repo read/write grants and hold its output to one side (retained, not applied), then validate that nothing auto-applies and every write grant is explicit, before you run it.

zvec: run vector search inside your app, no server, offline

Embed a vector database directly into your process with zvec, insert vectors, and query for nearest neighbors, with no separate server to run, config, or babysit.

Vet the fine print a star count hides: real license and a gate on dual-use tools

Before you build on a starred repo, record its actual license (not an assumed permissive one) and whether it is dual-use, so a custom license or an impersonation risk never surprises you after you have shipped.

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.

Read your token receipts right: volume and cost are different leaderboards

Attribute your model usage by both tokens and dollars, so you can see the flip the OpenRouter rankings show: cheap open models dominate volume while premium models dominate spend, and never mistake a high token ranking for value.

Wire GLM-5.2 into Hermes: valid route, 64k-context check, no key in config

Validate a Hermes Agent config that runs GLM-5.2 through a real provider route (direct Z.AI or OpenRouter), clears Hermes's 64k minimum context, and keeps the API key out of config.yaml, before you start a session.

Route through a gateway with a tested open-weights fallback

Keep model access from being a single point of failure: route through an OpenAI-compatible gateway and pin a fallback that is open-weights and has actually been tested, so a pulled or deprecated model is a two-minute config change, not a lost week.

ReMe pattern: define prospective memory as a schedule your agent can tick off

Write a reminder schedule config that an agent can load to surface its own future obligations — follow-ups, timed checks, recurring digests — and validate the structure before wiring it up.

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.

Unsloth: write parametric memory in with a fine-tune config

Write a valid Unsloth fine-tune config that bakes stable, always-needed domain knowledge into a small model so the knowledge is native rather than carried in a prompt on every call.

LlamaIndex: index your documents and query them at runtime

Point LlamaIndex at a document corpus and build a VectorStoreIndex so an agent can retrieve the relevant chunks at query time instead of stuffing everything into context.

Swap to a cheap image model, but guard the cases it loses

Default image generation to a cheap model for general scenes, while proving the cases the premium model dominates (text in the frame, charts, precise layout) are still routed to it, so the swap saves money without quietly degrading the work that has words in it.

Grind a huge one-time job overnight on a free tier's tiny rate limit

Pace a big one-time batch (label a dataset, summarize an archive, draft alt text) through a free tier with a very low rate ceiling, proven to finish within the rate limit and the monthly token budget before you start it.

Pick a model with evidence: a GitHub Models bake-off that fits the free cap

Run the few prompts that actually matter across several models on GitHub Models' free tier, then keep the winner, with the daily call budget proven to fit before you start.

Validate an Apple Core AI export entry and skill plugin before you touch a Mac

Check a Core AI model registry entry and the agent-skill plugin manifest offline, so you know the export recipe is well-formed before spending an evening on macOS 27.

Run GLM-5.2 for the bulk, escalate the hard turns to Opus 4.8

Wire a cost-routing config that sends most work to cheap hosted GLM-5.2 and only the hardest turns to Opus 4.8, instead of paying Opus prices for everything.

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.

Teach OpenCode Go your weekly chore once, then run it in minutes

Capture a repeating chore as a reusable OpenCode command backed by the Go plan's models, so a two-hour weekly task becomes a five-minute run.

Let a free model triage your reading: one-line summary + reply flag

Point any OpenAI-compatible tool at an OpenRouter free model so each email/article/report comes back as a one-sentence summary plus a needs-reply flag, and you only open what earns 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.

OpenMontage: run a full AI video pipeline with zero paid APIs

Wire OpenMontage's scripting-to-composition pipeline using only free sources (Piper TTS for narration, Archive.org/NASA/Wikimedia for footage, Pexels for images) so you pay nothing for the orchestration layer, and validate the pipeline config before you run it.

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.

codebase-memory-mcp: wire the knowledge graph, stop re-reading files

Point your MCP client at a codebase-memory-mcp server so your coding agent queries the repo's knowledge graph instead of re-reading files into context on every question, cutting token spend without changing answer quality.

Agent-Reach: throwaway account, least privilege, scan before install

Before letting Agent-Reach install system dependencies and register a skill that logs into platforms with your cookies, encode the safe defaults as a preflight manifest: a throwaway account never your main, cookie-auth risk acknowledged per platform, and a mandatory scan before install.

Vet a SKILL.md before you install it

Treat an agent skill like the untrusted dependency it is: parse its SKILL.md, confirm the frontmatter is well-formed, and surface every executable script it bundles, since the research flagged script-bearing skills as the most dangerous, before you ever let your agent run it.

SkillSpector: fail your CI build on a risky agent skill

Scan every skill you did not write with SkillSpector and gate CI on the result, so a malicious or vulnerable SKILL.md fails the build instead of running with your agent's permissions at runtime.

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.

Sakana Fugu: A/B it on your own task before you migrate

Point an OpenAI-compatible client at the Fugu endpoint and compare it to a single strong model on one hard task you already know the answer to, instead of trusting a benchmark chart.

Scrape politely: honor robots.txt and a crawl delay (the part most skip)

Gate any scraper behind a robots.txt check and a crawl delay so you only fetch what a site allows, at a rate it allows, using nothing but the Python standard library.

Crawl4AI: a page to clean, LLM-ready markdown (no API key)

Write a Crawl4AI run script that turns a page into clean markdown with a cache mode set, and verify the script is valid and shaped right before you point it at a site.

Firecrawl: turn a page into the exact JSON you asked for

Author a Firecrawl extract request that returns schema-structured JSON (not just markdown) and validate the request shape before you spend a crawl on it.

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.

OrcaRouter: only fan out when it is worth it

Gate the expensive fan-out behind a difficulty condition so easy chat stays cheap and only hard requests pay for a panel.

OrcaRouter for coding: judge by passing tests, not by vibes

Fan a hard coding task out to a panel and keep the candidate whose patch actually passes your tests, using the tests_pass arbiter.

Rebuild Fable 5's deep-research fan-out on your own keys (OrcaRouter)

Fan a research prompt out to a panel of models you choose, then fuse or judge the answers with an arbiter, in a routing DSL you version and control.

Track a tool's hype curve across any Substack (no API key)

Count how often a tool or model is mentioned in a Substack's posts over time, so you can see a hype curve rise and fade, using only the public archive.

Serve NVIDIA Nemotron 3 Ultra yourself for high-throughput agents (vLLM)

Stand up the NVFP4 Nemotron 3 Ultra checkpoint as an OpenAI-compatible endpoint for fast, long-running agent loops, validated serve flags + endpoint.

Serve GLM-5.1 yourself for long-horizon agentic coding (vLLM)

Stand up the MIT-licensed GLM-5.1 FP8 checkpoint as an OpenAI-compatible endpoint for long agentic runs, validated serve config + endpoint.

Serve MiniMax M3 yourself for agentic coding (vLLM)

Stand up MiniMax M3 on an 8x H200 node as an OpenAI-compatible endpoint and point any coding agent at it, validated serve flags + endpoint config.

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.

Kilo Code: add an MCP tool and bind it to one mode

Enable an MCP server's tools only on the mode that needs it (a researcher), so its tool definitions don't load into every conversation and burn tokens.

Kilo Code: a mode that can only edit the files you let it

Build a docs mode that can read the whole repo but only write to Markdown, using a fileRegex restriction on the edit group.

Kilo Code: ship a big feature as isolated subtasks with Orchestrator

Define the orchestrator's delegate modes (architect, code, debug) so a large task runs as isolated subtasks, each in its own clean context.

OpenCode: add an MCP tool, then lock it to one agent

Plug in an MCP server (live docs via Context7) but disable it globally and switch it on only for the one agent that needs it, so it does not burn tokens every turn.

OpenCode: run it headless in scripts and CI, with JSON output

Use opencode run non-interactively with --format json and a read-only agent so a pipeline gets machine-readable events and can never edit or execute.

OpenCode: a reviewer subagent gated to exactly the git commands you allow

Define a Markdown agent whose bash access is scoped per command (git diff and grep yes, everything else no) and that can never write.

OpenCode: a model-routed team, cheap to plan, strong to build

Give each agent its own model so planning and review run on a cheap model and only the build runs on your best one.

OpenCode: a read-only Plan pass that cannot touch your files

Separate think from touch: lock the plan agent to read-only (edit + bash deny) so it proposes before it edits, then Tab into build to execute.

Local model chore: read a photo with a vision model, on-device

Snap a receipt, a medication label, or a handwritten note, and have a free offline vision model read out the details so you do not have to squint and retype.

Local model chore: draft a sensitive message in private

Ask a free, offline model to draft or soften a delicate message (a note about money, a reply to a doctor, a careful complaint) knowing the contents stay on your machine.

Local model chore: summarize a long PDF without it leaving your laptop

Attach a 30-page PDF or a dense terms-of-service to a local model and get five plain bullets plus anything you need to act on, with the document staying on your machine.

Local model chore: turn a brain-dump into a clean to-do list

Paste messy meeting notes into a free, offline model on your own laptop and get back an organized to-do list, with nothing leaving the machine.

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.

Repomix + Fable 5: Pack a Repo for a Long-Context Review

Flatten an entire codebase into a single file and let Fable 5 hold all of it at once for a whole-system review.

OpenHands + Fable 5: Autonomous Issue to Pull Request

Hand Fable 5 a GitHub issue and let OpenHands plan, edit, run tests, and open a PR in a Docker sandbox.

Aider + Fable 5: Codebase-Wide Migrations from Your Terminal

Point Fable 5 at a repo and let Aider refactor across hundreds of files as real git commits you can undo.

Khoj + Fable 5: A Second Brain That Knows Your Notes

Point a self-hosted assistant at your documents so Fable 5 can answer from your own notes, not just the internet.

Fabric + Fable 5: Get Through Your Reading Pile

Pipe any article, video transcript, or document into a prebuilt Fabric pattern and have Fable 5 summarize, extract, or analyze it in one line.

Cline + Fable 5: Build or Fix Something Without Writing Code

Use a coding agent inside VS Code that builds and fixes code while you just describe what you want, powered by Fable's stamina.

LibreChat + Fable 5: Show It a Screenshot or a PDF

Run a private, self-hosted ChatGPT-style app where you drop in an image or document and let Claude Fable 5 read it.

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.

Cognee: Knowledge-Graph Memory Over Your Documents

Ingest your documents into a vector index plus a knowledge graph, so an agent can search by meaning and by relationships.

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.

Codex: A Markdown Folder to a Live Docusaurus Docs Site

Drop a folder of markdown into a Docusaurus project and have Codex assemble the site, fix broken links, then deploy a Vercel preview.

Codex: A Data File to a Live Next.js + Recharts Dashboard

Point Codex at a JSON file and have it build a Next.js + Recharts dashboard, then deploy a Vercel preview and return the link.

Codex: Screenshot to a Live Vite + React Landing Page

Hand Codex a screenshot or a brief and have it build a responsive Vite + React landing page, then deploy a Vercel preview and return the URL.

Agent Review Gate: a Schema-Forced Approve or Block in CI

Run a coding agent as a read-only reviewer that returns a schema-forced approve/block verdict, and let CI fail the merge on block.

Self-Healing Test Loop: an Agent that Fixes Until Green

Wrap a coding agent in a bounded loop that re-runs your tests and fixes the code until the suite passes or it runs out of attempts.

Postiz: Plan and Schedule a Week of Social Posts

From one brief, have an agent draft per-channel posts and queue a non-colliding weekly schedule in self-hosted Postiz.

Replaces Buffer

Obsidian × MCPVault: Write a Note from Any MCP Client

Create or patch a note in your Obsidian vault through MCPVault, from any MCP client, with frontmatter preserved.

Obsidian × MCPVault: Read a Note from Any MCP Client

Read a note from your Obsidian vault through MCPVault, from any MCP client, including a fully local LM Studio + open-model setup.

Claude Code Auto Mode: A Classifier Instead of an Allowlist

Set Auto Mode as your default so a classifier reviews each action instead of pre-listing every command.

Claude Code: Lock Down an Unattended Run with Permission Rules

Define exactly what a scheduled or headless Claude Code run may do via settings.json permission rules.

Claude Code Cloud Schedule: Runs With Your Laptop Off

Schedule Claude Code on Anthropic-managed infra at 1-hour-or-coarser cadence, pushing only to claude/ branches.

Claude Code Headless: An Always-On Local Schedule

Run Claude Code headless with -p on an OS-cron schedule so a job survives restarts.

Claude Code /loop: Poll a Deploy on a Fixed Interval

Re-fire a prompt on a valid cron interval inside a live Claude Code session.

Obsidian × MCPVault: The Decision Journal

Log decisions with frontmatter, let Claude update the outcome safely, and read the patterns each quarter.

Obsidian × MCPVault: The Argument Builder

Give Claude a thesis and have it assemble a sourced, ranked argument from everything you've ever written.

Obsidian × MCPVault: The Book Notes System

Dump your highlights and have Claude file the book into your second brain with connections and project-tied takeaways.

Obsidian × MCPVault: The Vault Health Check

A monthly, scheduled audit that finds orphan notes, stale info, and inconsistent tags before your vault rots.

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.

Pi: The Reusable Team Skill

Encode a multi-step task once as an Agent Skill your whole team installs.

Pi: The Reusable Prompt Template

Turn a prompt you retype into a permanent Pi slash command.

Pi: The Safe Diff Reviewer

A code reviewer that reads your staged diff and structurally cannot modify it.

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.

Idea Cross-Pollinator: Find the Links You'd Never Spot

Have Claude search your whole vault and surface non-obvious connections to an idea.

Weekly Review: a Finished Review Instead of a Blank Page

Every Friday, have Claude Code turn your week's note activity into a written review.

Research Ingestion: File a Source Into Your Knowledge Base

Paste an article or transcript into your vault and have Claude summarize, link, and flag contradictions.

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.

Morning Synthesis: a Start-of-Day Note Before Coffee

Schedule Claude Code to read your recent notes and write a daily start-of-day briefing.

Turn a Hand-Drawn UI into Working Code with tldraw

Sketch a screen on an infinite canvas and have a vision model return a live, working version of it.

Dedupe and Rank a Keyword List with Coreutils

Turn a messy keyword dump into a clean, frequency-ranked list using only shell builtins.

Obsidian Vault as the Core of Your Agent Harness

Use an Obsidian vault as the shared memory and control surface for your agents.

Fine-Tune an Open LLM to Make It Yours

Adapt an open-weight model to your domain with a small dataset.

Guaranteed JSON from Local LLMs with Outlines

Force valid, schema-conformant JSON out of any local model.

Vectorless RAG with PageIndex

Build high-accuracy RAG without embeddings, chunking, or a vector DB.

Hermes + NotebookLM "Second Brain"

Pair Hermes with NotebookLM to build a self-researching, self-teaching knowledge system.

Replaces Perplexity Pro

Self-Hosted Self-Improving Agent with Hermes

Stand up a Hermes agent that remembers and improves over time on your own VPS.

Run LLMs Locally to Replace ChatGPT Plus

Serve a capable open model locally with Ollama and drop the ChatGPT Plus subscription.

Replaces ChatGPT Plus

Local Text-to-Speech that Replaces ElevenLabs

Generate natural speech locally with Piper instead of an ElevenLabs subscription.

Replaces ElevenLabs

Local Voice-to-Text that Replaces WisprFlow

Run fully local dictation with whisper.cpp instead of paying for WisprFlow.

Replaces WisprFlow

Persistent Memory for Codex using Obsidian

Give Codex durable, searchable long-term memory backed by an Obsidian vault.