Workflows

Buzz + Hermes over ACP: prove channel scope bounds what an agent reads, because signing is provenance not authorization

Run Hermes as an ACP channel member inside Block's Buzz workspace without giving it your whole workspace to read, by proving that Buzz's signed event log is complete provenance yet not authorization, so only scoping the agent to one narrow channel bounds what it can read.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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: 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.

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.

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.

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.

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.

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.

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: 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 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.

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.

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.

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.

Local Voice-to-Text that Replaces WisprFlow

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

Replaces WisprFlow