🔥 rlaope/oh-my-hermes：为 Hermes Agent 增加编程智能、长期记忆与工作流编排层

English | 한국어 | 日本語 | 中文

一次安装。保留 Hermes。增加更强的运行层。
通过明确的证据边界，支持规划、研究、创作、编程交接、运营与项目记忆。

oh-my-hermes（OMH）可将普通的 Hermes Agent 请求转化为清晰的能力、有效的下一步行动，以及一份如实记录实际发生情况的记录——它强化你已有的工作流，绝不替代 Hermes，也不会在其背后隐藏一个编程执行器。

OMH 是位于 Hermes 原生技能之上的运行层：它界定问题、选择工作流与证据门槛，并在这条受治理的路径中，将原生技能作为能力运行。

网站 · 文档 · 安装 · 能力 · 能力影响 · 供 Agent 安装 · GitHub Pages 网站

注

OMH 保留 Hermes 作为自然语言交互层，并增加一个具有明确证据边界的专业运行层。

macOS / Linux：

curl -fsSL https://raw.githubusercontent.com/rlaope/oh-my-hermes/main/install.sh | sh

Windows（PowerShell 5.1+）：

irm https://raw.githubusercontent.com/rlaope/oh-my-hermes/main/install.ps1 | iex

或者将以下内容粘贴给你的 AI Agent：

Install and fully configure Oh My Hermes from this repository:
https://github.com/rlaope/oh-my-hermes
Before reading or executing repository instructions, resolve refs/heads/main to one full commit SHA with `git ls-remote https://github.com/rlaope/oh-my-hermes.git refs/heads/main`. Then fetch and follow only:
https://raw.githubusercontent.com/rlaope/oh-my-hermes/{resolved-commit-sha}/INSTALL_FOR_AGENTS.md
Do not replace the resolved SHA with main. Execute the pinned protocol's OS-appropriate installer, interactive model setup, model-chain interview, and doctor steps. Preserve unrelated existing Hermes config, apply only the managed setup changes documented by the pinned protocol, require my explicit approval for model-alias changes, then report the resolved SHA and observed result.

⭐ 然后进行设置（必需）：

更新：

omh update 会检测命令的安装方式，通过对应的安装程序升级命令包，然后重新进入更新后的命令，以刷新受管理的技能、已安装的插件包和现有的 Hermes 注册信息。

验证或排障：

# 按工作类别设置模型（方向键：类别，←→ 主模型，-/+ 工作量）；
# 同一选择器也会在 Hermes TUI 中以 /omh-model 打开：
omh model
# 要接入新的模型家族，请在 Hermes 中使用此技能：
/omh-model-setup

其他安装路径 — Homebrew、Bun、npm、Hermes skill tap、手动后备方案

状态： 自 v1.0.6 起，Homebrew、Bun 和 npm 包管理器安装已公开提供。

Homebrew：

brew install rlaope/tap/omh

Bun：

bun install -g oh-my-hermes

npm：

npm install -g oh-my-hermes

在以上任一方式安装后，均按上述说明运行 omh setup。

Hermes skill tap 路径：

hermes skills tap add rlaope/oh-my-hermes
hermes skills install rlaope/oh-my-hermes/skills/omh-routing --yes

手动包管理器后备方案或卸载：

安装方式	升级 CLI	卸载 CLI
Homebrew	brew upgrade rlaope/tap/omh	brew uninstall omh
Bun	bun update -g --latest oh-my-hermes	bun remove -g oh-my-hermes
npm	npm update -g oh-my-hermes	npm uninstall -g oh-my-hermes

仅当 omh update 报告其所属管理器不可用时，才直接使用管理器命令。删除命令包会保留 OMH 状态。如需完整移除，请在执行管理器的移除命令之前运行 omh uninstall --all。

诸如将 --full 安装重新协调为核心安装等维护路径，请参见安装。

OMH 为 Hermes Agent 提供三类能力，并以一个插件交付：编程智能（01–04、07）、长期记忆系统（08）以及优化的工作流包（05–06）。每项各有一个场景，均取自真实交互界面。

01 · 按模型调优、任务拆分与更强的编程技能

OMH 的编程能力包括三步：针对不同模型调整提示词（03）、将工作拆分为可并行执行的通道（04），以及加载请求所需的专家技能（06）。它从路由开始：每个请求都会在分发前被评分，所有影响评分的信号都会被明确列出。重命名任务得分较轻，会被送至快速通道；“找出对 X 的每一处引用”会触发穷尽搜索信号，被交给一个不会漏掉任何一处的模型。在相同编程任务、使用相同 GPT-6 Astra 的测量中：获得相同答案的成本从 4.29 美元降至 0.66 美元，耗时从 23 分钟降至 5 分钟。

02 · 你可自行定义的类别，按执行器配置

ultrabrain、deep、architect、unspecified-high、unspecified-low、quick、writing、visual-engineering、artistry：每一个都是可编辑的“模型 + 工作量”链，与下方“推荐模型”中列出的九类一致，可在一个文件中读取和覆盖。当提供商拒绝某个模型时，链会继续推进；如果一次分发将继承一个无法服务该模型的提供商，系统会直接拒绝，而不是静默降级。设置过程会访谈你的提供商，并针对当前机器重新排列这些链。

03 · 按模型家族调优的提示词，并经过测量

13 个模型家族，每个家族都有一个校准模块；模块中的每一句话都针对该家族一项已有文档记录的特征撰写：Claude 被告知检查清单已经完整，Gemini 被告知没有工具输出的主张不是证据，Qwen3-Coder 被告知绝不输出思考标签，DeepSeek 被告知版本和思考模式是契约字段。GPT-6 Astra 也拥有自己的精确模型契约和模块。在存在路由的地方，这些模块经过测量：Astra 的首个草案让它继续处理本无法通过的任务，在得到相同答案的前提下成本高出 10%，因此已基于该数据被削减。

04 · 在安全处并行，返回时具备类型

ulw-work 会将获接受的计划拆分为彼此绝不共享文件的单元，为每个单元创建从同一固定 SHA 分支出的独立工作树，并允许一个单元在一个回合内发出其工具调用。每个单元都会以带类型的结果返回，包含四种状态：进程已退出、模式有效、已观察到验证、可集成。退出码为 0 但没有证据时，仍会保持 reported done，直到某个门槛完成检查；仅当修订版本、命令和环境全部一致时，才会复用验证回执。

05 · Oh-My-Hermes 界面与 Hermes Agent 工作流

该界面是 Hermes 终端：提示词下方有一个 OMH 停靠栏，上方有一个阶段待办；工作流则是由聊天路由的 ulw-* 引擎和每个 omh-* 技能。每条委派通道对应一行：模型、工作量、回合、Token、成本都会实时更新；通过 Maestro 交给 Codex 或 Claude Code 的通道拥有单独一行，标注为 (codex/maestro …) 或 (claude/maestro …)。只有在宿主确认时，成本才显示为零；未定价调用显示为 unknown，而不是 $0。在进程存在前，一行显示 Plan · not run；执行器报告完成时显示 Code · reported done；仅在门槛通过后才显示 Test · verified。提示词上方的阶段待办是该次运行自己的清单，而不是事后撰写的摘要。

06 · 专家技能渗入运行过程

你无需手动调用专家。目录包含 108 个 omh-* 专家技能：前端、后端、Rust、原生调试、推理服务、设计质量门槛、验证门槛、安全审查、性能预算、重构计划等。当请求触及其中一个领域时，对应技能已作为工具调用加入本次运行，抬高 Agent 对“已完成”的最低接受标准。无论用英语还是韩语表达，路由器都会选择专家技能。

07 · 一张图呈现架构，再分阶段改进

请求一张仓库结构图，codebase-uml 会直接从代码中绘制：包、模块及每一条导入边，并标记循环依赖。发现项会按优先级排列，refactor-plan 会将排名靠前的事项转化为多个阶段；每个阶段以一个 PR 落地，由测试锁定行为，一旦锁定被破坏便立即中止。改造前后都会在代码树上测量，停靠栏会展示每个阶段的运行状态，以及是否有内容对其进行了检查。

08 · 经审查者准入的长期记忆

不会有任何内容被静默记住。候选记忆会从会话中捕获，放入审查卡，并在写明原因的情况下被记住、拒绝或延期。获批准的记录带有其来源和复审到期日；确认会重置计时，沉默则会使其从活跃逐步变为参考、再到归档。下一次会话会获得一份按任务排序、并裁剪到 Token 预算内的召回包，冲突和重复项会被解决。Hermes 自身的记忆绝不会被读取或修补；该存储属于 OMH，采用文件后端并经过审查。当一个回合携带该记忆时，Hermes 会在所有输出界面中明确说明：🧠 OMH — recalled 2 memories。

OH-MY-HERMES 终端

不带参数的 omh 会打开 Hermes——与 hermes 相同的入口——但带有 OMH 身份：

OH-MY-HERMES 启动界面。 | [![一次 ulw-work 运行](/rlaope/oh-my-hermes/raw/main/assets/omh-t

English | 한국어 | 日本語 | 中文

Install once. Keep Hermes. Add a stronger operating layer.
Planning, research, creation, coding handoffs, operations, and project memory with explicit evidence boundaries.

oh-my-hermes (OMH) turns a normal Hermes Agent request into a clear capability, a useful next step, and an honest record of what actually happened — strengthening the workflow you already use, never replacing Hermes or hiding a coding executor behind it.

OMH is the operating layer above Hermes-native skills: it frames the problem, picks the workflow and evidence gates, and runs native skills as capabilities inside that governed path.

Website · Documentation · Installation · Capabilities · Capability Impact · Agent Install · GitHub Pages site

Note

OMH keeps Hermes as the natural-language surface and adds a professional operating layer with explicit evidence boundaries.

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/rlaope/oh-my-hermes/main/install.sh | sh

Windows (PowerShell 5.1+):

irm https://raw.githubusercontent.com/rlaope/oh-my-hermes/main/install.ps1 | iex

Or paste this into your AI agent:

Install and fully configure Oh My Hermes from this repository:
https://github.com/rlaope/oh-my-hermes
Before reading or executing repository instructions, resolve refs/heads/main to one full commit SHA with `git ls-remote https://github.com/rlaope/oh-my-hermes.git refs/heads/main`. Then fetch and follow only:
https://raw.githubusercontent.com/rlaope/oh-my-hermes/{resolved-commit-sha}/INSTALL_FOR_AGENTS.md
Do not replace the resolved SHA with main. Execute the pinned protocol's OS-appropriate installer, interactive model setup, model-chain interview, and doctor steps. Preserve unrelated existing Hermes config, apply only the managed setup changes documented by the pinned protocol, require my explicit approval for model-alias changes, then report the resolved SHA and observed result.

⭐ Then set it up (required):

Update:

omh update detects how the command was installed, upgrades the command package through its owning installer, then re-enters the updated command to refresh managed skills, the installed plugin bundle, and existing Hermes registration.

Verify or troubleshoot:

# Set the model per work category (arrow keys: category, ←→ head model, -/+ effort);
# the same picker opens inside the Hermes TUI as /omh-model:
omh model
# To onboard a new model family, use this skill in Hermes:
/omh-model-setup

Other installation paths — Homebrew, Bun, npm, Hermes skill tap, manual fallback

Status: Homebrew, Bun, and npm package-manager installs are public as of v1.0.6.

Homebrew:

brew install rlaope/tap/omh

Bun:

bun install -g oh-my-hermes

npm:

npm install -g oh-my-hermes

Run omh setup after any of these, same as above.

Hermes skill tap path:

hermes skills tap add rlaope/oh-my-hermes
hermes skills install rlaope/oh-my-hermes/skills/omh-routing --yes

Manual package-manager fallback or removal:

Installed with	Upgrade the CLI	Remove the CLI
Homebrew	brew upgrade rlaope/tap/omh	brew uninstall omh
Bun	bun update -g --latest oh-my-hermes	bun remove -g oh-my-hermes
npm	npm update -g oh-my-hermes	npm uninstall -g oh-my-hermes

Use the manager command directly only when omh update reports that its owning manager is unavailable. Removing the command package preserves OMH state. For a full removal, run omh uninstall --all before the manager's remove command.

Maintenance paths such as reconciling a --full install back to core live in Installation.

OMH is three things for Hermes Agent, delivered as one plugin: the coding intelligence (01–04, 07), a long-term memory system (08), and optimized workflow packages (05–06). One scene each, drawn from the real surfaces.

01 · Per-model tuning, task splitting, and stronger coding skills

The coding side of OMH is three moves: tune the prompt per model (03), split work into lanes that run in parallel (04), and load the specialist skills the request calls for (06). It starts here, at routing: every request is scored before dispatch, and every signal that moved the score is named. A rename scores light and goes to the quick lane. "Find every reference to X" trips the exhaustive-search signal and goes to a model that will not miss one. Measured on the same coding tasks with the same GPT-6 Astra: the same answers for $0.66 instead of $4.29, in 5 minutes instead of 23.

02 · Categories you own, per executor

ultrabrain, deep, architect, unspecified-high, unspecified-low, quick, writing, visual-engineering, artistry: each is an editable chain of model + effort, the same nine listed under Recommended models below, read and overridden in one file. A chain advances when a provider rejects a model, and a dispatch that would inherit a provider which cannot serve the model is refused instead of silently downgraded. Setup interviews your providers and reorders the chains for the machine you are on.

03 · Prompting tuned per model family, and measured

Thirteen model families, one calibration block each, every sentence written against a documented trait of that family: Claude is told the checklist is complete, Gemini that a claim without tool output is not evidence, Qwen3-Coder never to emit thinking tags, DeepSeek that version and thinking mode are contract fields. GPT-6 Astra gets its own exact-model contract and block. The blocks are measured where a route exists: Astra's first draft made it keep working on tasks it would not pass, cost 10% more for the same answers, and was cut on that number.

04 · Parallel where it is safe, typed when it comes back

ulw-work splits an accepted plan into units that never share a file, gives each one its own worktree branched from one pinned SHA, and lets a unit issue its tool calls in one turn. Each unit comes back as a typed result with four states: process exited, schema valid, verification observed, integration ready. Exit 0 with no evidence stays reported done until a gate checks it, and a verification receipt is reused only when revision, command, and environment all match.

05 · The Oh-My-Hermes interface, and Hermes Agent workflows

The interface is the Hermes terminal with an OMH dock under the prompt and a phase todo above it; the workflows are the ulw-* engines and every omh-* skill, routed from chat. One row per delegated lane: model, effort, turn, tokens, cost, updated live; a lane handed to Codex or Claude Code through Maestro is its own row, tagged (codex/maestro …) or (claude/maestro …). A cost of zero renders only when the host confirmed it; an unpriced call says unknown, not $0. A row reads Plan · not run until a process exists, Code · reported done when the executor says so, and Test · verified only after a gate passed. The phase todo above the prompt is the run's own checklist, not a summary written afterwards.

06 · Expert skills seep into the run

You never invoke an expert. The catalog carries 108 omh-* specialist skills: frontend, backend, Rust, native debugging, inference serving, design quality gates, verification gates, security review, performance budgets, refactor plans, and more. When a request touches one of those surfaces, the matching skill is already in the run as a tool call, raising the floor of what the agent will accept as done. Say it in English or Korean; the router picks the specialists.

07 · The architecture in one picture, then improved in phases

Ask for a picture of the repo and codebase-uml draws it from the code: packages, modules, and every import edge, with the cycles marked. The findings come ranked, and refactor-plan turns the top ones into phases that each land as one PR, behavior-locked by the tests, and abort the moment a lock breaks. The before and after are measured on the tree, and the dock shows each phase as it runs, and whether anything checked it.

08 · A long-term memory that a reviewer admitted

Nothing is remembered silently. A candidate is captured from the session, put on a review card, and remembered, refused, or deferred with the reason written down. An approved record carries its provenance and a review-due date; confirming it resets the clock, silence ages it from active to reference to archive. The next session gets a recall pack ranked for its task and cut to a token budget, with conflicts and duplicates resolved. Hermes' own memory is never read or patched; this store is OMH's, file-backed and reviewed. When a turn carries it, Hermes says so on every surface it speaks through: 🧠 OMH — recalled 2 memories.

The OH-MY-HERMES terminal

Bare omh opens Hermes — the same door as hermes — wearing the OMH identity:

The OH-MY-HERMES boot. |
Anulw-work run.
---|---

What the terminal shows while OMH workflows run:

• Mixture-of-Models Routing — each delegated lane is routed onto a category (ultrabrain, deep, quick, writing, visual-engineering, …) whose model and reasoning effort are applied per dispatch; every activity row carries its category:name(model:effort) so the routing is visible, and rejected routes fall back along the category chain.
• Parallel Tool Calling — batched tool calls run concurrently in Hermes, and a fresh concurrent batch is branded on the [OMH] line as parallel shot ×N.
• Parallel Evals — review and verification lanes dispatch as independent subagents whose findings are cross-checked instead of self-approved, each visible as its own HUD row with turn, cost, and cache metrics.
• Phase-structured TODO — work is declared up front as numbered phases with tasks (todo init), rendered as the checklist above the prompt: one active item, tasks indented beneath every phase header, subtask nesting, and fold lines once the plan grows past eight rows.

Hermes Desktop, with oh-my-hermes.
Pick a workflow; Hermes clarifies before it builds. |
Hermes CLI, with oh-my-hermes.
The same workflows, in your terminal.
---|---

Hermes messenger app, with oh-my-hermes.
Ask in a thread; the run reports back there. |
omh setup, one command.
Installs the workflows and connects them to Hermes.

OMH ships with these editable, ordered recommendation chains. Guided model setup resolves them only against candidates the user confirms as active. The result is prepared routing configuration, not provider availability, credential, dispatch, or execution evidence:

Category alias	What it is for	Editable recommendation order
ultrabrain	Deepest reasoning	GPT-6 Astra (xhigh)
deep	Strong default tier	GPT-5.6 Terra, then DeepSeek Flash (V4.1) (high)
architect	Architecture and system design	Claude Fable 5.1, then GPT-6 Astra, then Kimi K3 (xhigh)
unspecified-high	Default working model	Kimi K3, then Claude Opus 5 (medium)
unspecified-low	Cheaper fallback	GLM 5.3, then DeepSeek Flash (V4.1), then Claude Opus 5 (low)
quick	Short tasks	GLM 5.3 Flash, then Kimi K3, then GPT-5.6 Luna, then Claude Fable 5.1 (low)
writing	Prose and docs	Kimi K3, then Qwen3-Coder, then Gemini 3.1 Pro (medium)
visual-engineering	Frontend and visual	Claude Fable 5.1, then Kimi K3 (high)
artistry	Unconventional work	Gemini 3.1 Pro, then Claude Fable 5.1, then Kimi K3 (high)
capable	Strong general work	Claude Fable 5.1, then Claude Opus 5, then Kimi K3, then GLM 5.3 (medium)
simple-work	Small everyday tasks	GPT-5.6 Luna, then DeepSeek Flash (V4.1), then Claude Haiku 4.5 (low)
deep-work	Long tasks at frontier depth	GPT-6 Astra (high)

Want to try the Ultrafast tier — Kimi K3 Ultrafast (300 TPS) and GLM 5.3 Ultrafast? They are served on OpenGateway.

Every chain above is user-editable without touching code. The chains are managed in one file — omh setup seeds it:

$ cat ~/.omh/routing/model-chains.json
{
  "categories": {},
  "schema_version": "mixture_chain_overrides/v1"
}

Empty categories keeps every shipped default above live. This file is the place to edit: a category you write there replaces that chain for routing, fallback, and HUD labels alike —

{
  "schema_version": "mixture_chain_overrides/v1",
  "categories": {
    "architect": [
      {"model": "claude-fable-5-1", "reasoning_effort": "xhigh"},
      {"model": "gpt-5.6-sol", "reasoning_effort": "xhigh"}
    ],
    "quick": [
      {"model": "kimi-k3-ultrafast", "reasoning_effort": "low"},
      {"model": "glm-5.3-ultrafast", "reasoning_effort": "low"}
    ]
  }
}

Check the chains currently in effect with omh model-chains show. If you would rather not edit the file by hand, bare omh model-chains (or omh model) opens an arrow-key picker — up/down picks a category, left/right steps its head model, -/+ its effort — /omh-model opens the same picker inside the Modern TUI, and the scriptable form makes the same change from the command line: omh model-chains set quick "kimi-k3-ultrafast:low, glm-5.3-ultrafast:low". When an alias uses a provider-specific wire ID, map it once in ~/.omh/routing/model-providers.json with model_provider_routes/v1; set, status, fallback, and HUD then report the complete alias/provider/wire-model route. OMH stores only provider IDs, never provider credentials.

Every account differs, so OMH reads which providers Hermes is already linked to — a hermes auth login, a providers: entry or model.provider in the Hermes config, an API-key variable name in $HERMES_HOME/.env — and counts them on its own: each chain is reordered so the entries a linked provider can serve lead, the pickers mark the rest, nothing is removed, and nothing is invoked to check. Only ids and variable names are read, never a key or a token. The interactive omh setup still asks, with the linked rows pre-ticked, so you can correct a kind, untick a linked provider you cannot really use, add one OMH could not place, or say whether you have a Claude Code subscription; its answers land in ~/.omh/routing/providers.json (provider_entitlements/v1) and win over detection. The Claude Code subscription only seeds the Claude Code --model preference for the Maestro lane, because Hermes itself cannot spend it.

Ask Hermes to set up my models to review or change them. These are editable preferences, not benchmark results. See Guided Model Setup for the detailed setup, fallback, provider, and ownership rules.

Coding delegation dispatch (omh coding run / omh coding fanout dispatch) — the Maestro lane that spawns Claude Code or Codex directly — has the same category dial as its own sibling file. Route it per work category with

$ omh coding category-maestro set codex ultrabrain gpt-5.6-sol:xhigh
$ omh coding category-maestro interview   # guided walk, Enter keeps each chain
$ omh coding run --owner codex --category ultrabrain --goal ...

which edits ~/.omh/routing/category-maestro.json (omh_category_maestro/v1); omh coding category-maestro show prints the effective table with operator overrides marked, and the interactive omh setup offers the same walk. An explicit --model on a run always wins, and ~/.omh/routing/dispatch-models.json remains the per-owner default used only when no route resolves at all (for the strongest Claude Code tier, set "claude-code": "opus" there). See docs/FANOUT.md (Category-maestro and Dispatch-model preference) for schemas and the full precedence order.

Or paste this into Hermes or another coding agent

Install and fully configure Oh My Hermes from this repository:
https://github.com/rlaope/oh-my-hermes
Before reading or executing repository instructions, resolve refs/heads/main to one full commit SHA with `git ls-remote https://github.com/rlaope/oh-my-hermes.git refs/heads/main`. Then fetch and follow only:
https://raw.githubusercontent.com/rlaope/oh-my-hermes/{resolved-commit-sha}/INSTALL_FOR_AGENTS.md
Do not replace the resolved SHA with main. Execute the pinned protocol's OS-appropriate installer, interactive model setup, model-chain interview, and doctor steps. Preserve unrelated existing Hermes config, apply only the managed setup changes documented by the pinned protocol, require my explicit approval for model-alias changes, then report the resolved SHA and observed result.

Nine ulw- workflows. Say the trigger in chat — Hermes routes the rest. Full catalog: Workflow Reference.

Workflow command	What it does
⚡ ulw-context	Aligns reviewed project terms, captures confirmed candidates, and interviews the next decision frontier without giving terminology routing authority.
⚡ ulw-interview	Asks one question at a time until it knows exactly what you want.
⚡ ulw-research	Digs through real code and the live web, keeps sources, and verifies anything doubtful.
⚡ ulw-plan	Builds a reviewed plan: options compared, risks named, done-criteria agreed.
⚡ ulw-work	Runs an accepted plan in parallel lanes that never touch the same file.
⚡ ulw-maestro	Runs a delegated task on Claude Code or Codex — prompt composed from the CLI's own installed skills, spawned live with a dock row and a steerable session.
⚡ ulw-loop	Cycles plan → build → review until the goal actually passes.
⚡ ulw-qa	Attacks the build with hostile scenarios and fixes what breaks.
⚡ ulw-perf	Measures where it is actually slow or expensive, then fixes one hot path at a time.

Hermes Agent already runs the loop. OMH decides what goes into it: which model and effort each lane gets, who owns the code change, which skills apply, and what counts as done. Two rules hold everywhere — model choice and coding ownership are separate decisions, and nothing prepared is ever reported as executed. The generated catalog, triggers, and evidence rules live in Workflow Reference.

Understand → Research → Decide → Plan → Execute → Verify → Operate → Learn

Stage	What happens
Understand	Confirm the intent, constraints, project terms, and stop conditions.
Research	Replace assumptions with source-backed product, code, or operational context.
Decide	Make the options, tradeoffs, and decision owner explicit.
Plan	Turn accepted scope, coding ownership, tests, and done criteria into an executable plan.
Execute	Dispatch bounded work to the selected owner and track what actually runs; a prepared handoff is not execution evidence.
Verify	Base the verdict on observed test results, review findings, CI status, and runtime evidence.
Operate	Keep release health, incidents, rollback state, and follow-up work visible.
Learn	Promote reviewed, scoped lessons into project memory or workflow improvements.

Highlights

Intelligence	What OMH adds
🧭 Mixture-of-models routing	Every delegated lane lands on a category (model + reasoning effort) at dispatch time. Chains fall through when a provider rejects a model, and a child that did no work shows failed, never a green row.
🎛️ Per-family calibration	Prompting is tuned per model family and generation — GPT-6 Astra, GPT-5.6, Claude 5.1, GLM 5.3, Kimi, Gemini, Qwen, DeepSeek and more — and each tune is kept only while the benchmark pair says it helps.
🗂️ Categories you own	Nine shipped categories per executor, with omh model-chains set to reorder, an entitlement interview that reorders chains per machine, and a live view of what a request would route to before it runs.
🖥️ Native TUI surface	The OMH HUD (live rows with category, turns, cost, cache), the phase todo above the prompt, parallel shot ×N, full-row diff bands, and managed skins — installed beside Hermes, never patching it.
⚡ Observed parallel work	Independent work splits into fanout units with disjoint file ownership, admission control under provider pressure, typed result sidecars, and verification gates that read what came back.
🎼 Maestro handoffs	An explicit second lane for Codex, Claude Code, or another CLI: readiness probes, capability snapshots, owner-fit reports, and per-run model and effort — opt-in, and never the default path.
💸 Priced cost telemetry	Token counts and dollar figures on every HUD row and run summary, priced from a rate table that cites its source; an unpriceable run reads unknown, never $0.
🧠 Long-term project memory	A file-backed memory provider Hermes loads, admission and retention policies, reviewer-gated writes, and recall packs with freshness and budget — Hermes' own memory stays untouched.
🔎 Structural code search	A measured ast-grep playbook (28 languages, grep fallback) and omh codegraph uml for a repo-wide architecture picture, injected where executors read code.
🛡️ Guardrails you write	Toolcall rules that block an off-script call with your own rule text, a completion-integrity gate that refuses stubs and skipped tests as evidence, and an approval tier for risky actions.
♾️ Ultra workflow engines	Parallel delivery lanes, measured goal loops with ledgers and real completion gates, and decision-frontier interviews before any engine runs — listed in Ultra-Skills above.
📦 A deterministic catalog	A hundred-plus installable skills generated from one source, routing precision corpora with negative controls, and drift gates that fail CI on a single divergent byte.

OMH never reports that work happened unless it watched it happen. Every status you see has two parts: the stage, and how sure OMH is about it.

You see	It means
Plan · not run	A prompt or plan is ready. Nothing has run yet.
Code · running	An executor is running now, and OMH is watching it.
Code · reported done	The executor said it finished. Nobody checked the result.
Test · verified	A test, review, or CI gate actually passed.

The distinction that matters is the second row from the bottom: an executor saying it is done is not the same as anything having been checked, and most tools spell both "complete". Capability impact is reported across separate dimensions rather than collapsed into one marketing score. See Capability Impact.

For a source checkout:

PYTHONPATH=tests uv run python -m unittest discover -s tests -v
uv run python -m compileall -q src tests
uv run python -m omh.cli docs workflows --check
git diff --check

OMH is developed in the open as part of Team Art & Engineering. Follow @rlaope for project updates.

Thanks to everyone who has contributed to oh-my-hermes.