Rune Prompt Amplification

RUNE — Prompt Amplification for Hermes

Overview

RUNE turns flat, ambiguous requests into structured AI instructions. In Hermes, this skill is primarily an operating pattern: load it when the agent should silently improve complex prompts, plans, reviews, and strategy work through the RUNE 8-layer architecture.

The repository also includes main.sh, a small shell wrapper around the local RUNE/WAND CLI for terminal workflows. Hermes does not require the wrapper to load this skill, but the wrapper is useful when you want a standalone amplified prompt from the shell.

When to Use

Use this skill for:

• Prompt amplification: “RUNE this”, “improve this prompt”, “make this agent prompt stronger”.
• Planning: multi-step implementation plans, launch plans, decision frameworks.
• Coding and debugging: architecture-first prompts, root-cause analysis, code-review briefs.
• Writing and analysis: articles, executive summaries, product narratives, strategic synthesis.
• Agent design: Hermes prompts, cron prompts, subagent instructions, mesh coordination briefs.
• High-ambiguity tasks where clarifying questions or explicit constraints matter.

Do not force full RUNE ceremony for:

• Greetings.
• Tiny factual answers.
• One-step terminal/file operations.
• Cases where the user explicitly asks for a raw, unmodified answer.

Hermes Operating Mode

Default behavior inside Hermes:

1. Detect complexity. If the request is simple, answer directly. If it is complex, activate RUNE internally.
2. Amplify silently. Do not dump all layers unless the user asks for “RUNE mode”, “show layers”, or a visible breakdown.
3. Ask only useful questions. If missing context materially changes the result, ask a short clarifying question. Otherwise proceed with explicit assumptions.
4. Preserve execution discipline. For build/run/verify tasks, RUNE improves the plan but does not replace real tool execution and validation.
5. Report clearly. Output should be shorter, sharper, and more actionable than the raw prompt would have produced.

When the user asks for visible RUNE, use a compact structure:

## RUNE Pass
- L0 Role:
- L1 Context:
- L2 Intent:
- L3 Governance:
- L4 Cognitive Mode:
- L5 Capabilities:
- L6 QA:
- L7 Output:

The 8 RUNE Layers

Spinoza Validator

Before final output, check four qualities:

• Conatus — Does this increase the user’s agency and ability to act?
• Ratio — Is it coherent, grounded, and internally consistent?
• Laetitia — Is it constructive and clarifying rather than muddy?
• Natura — Does it feel natural, usable, and not overengineered?

If one fails, revise before answering.

Setup for Local WAND CLI

Hermes can load this skill from SKILL.md alone. The CLI wrapper needs the core RUNE repository or the wand executable.

Option A — use local RUNE source

git clone https://github.com/neurabytelabs/rune ~/Documents/GitHub/rune
cd ~/Documents/GitHub/rune
python3 -m pip install -e .

Option B — use package install when available

python3 -m pip install rune-wand

Configure provider

RUNE reads provider settings from environment variables and ~/.rune/config.toml. Never commit real keys.

mkdir -p ~/.rune
cat > ~/.rune/config.toml <<'EOF'
[llm]
api_url = "https://your-openai-compatible-endpoint/v1/chat/completions"
api_key = "your-api-key"
default_model = "your-model"
timeout = 300
EOF

You may also export:

export RUNE_API_URL="https://your-openai-compatible-endpoint/v1/chat/completions"
export RUNE_API_KEY="your-api-key"

main.sh will also source ~/.secrets if present for backwards compatibility, but new setups should prefer explicit environment variables or ~/.rune/config.toml.

Hermes Installation

From this repository:

mkdir -p ~/.hermes/skills/prompt-engineering/rune-prompt-amplification
cp SKILL.md ~/.hermes/skills/prompt-engineering/rune-prompt-amplification/SKILL.md

Then start a fresh Hermes session and load it:

hermes chat -s prompt-engineering/rune-prompt-amplification -q "RUNE this into a launch plan: ship a private beta for my agent mesh"

Current Hermes sessions may not see newly copied skills until a new session starts.

CLI Wrapper Usage

# Default: inscribe / enhance prompt only
echo "Write a blog post about AI" | bash main.sh
bash main.sh "Explain quantum entanglement to a 12-year-old"

# Explicit WAND commands
bash main.sh cast "Design a REST API for a todo app"
bash main.sh validate "My existing prompt text"
bash main.sh grimoire
bash main.sh version
bash main.sh swarm "Evolve the best coding prompt"

The wrapper prefers an installed wand command when available, and falls back to ~/Documents/GitHub/rune/wand.py or $RUNE_DIR/wand.py.

RUNE Task Patterns

Planning

Use:

Apply RUNE internally. Produce a concrete plan with assumptions, ordered steps, likely files, validation, risks, and open questions. Do not implement yet.

Coding

Use:

Apply RUNE for architecture-first implementation. Inspect before editing, preserve user changes, implement in controlled steps, run tests, and report real tool output.

Debugging

Use:

Apply RUNE with systematic root-cause analysis. Reproduce, isolate, hypothesize, test, fix narrowly, and verify the actual failure path is gone.

Agent / Cron Prompt Design

Use:

Apply RUNE to make this autonomous prompt self-contained: role, context, trigger, permissions, tools, stop conditions, output format, and failure reporting.

Governance and Safety

• Do not expose or copy secrets from ~/.secrets, ~/.rune/config.toml, .env, or Hermes config files.
• Ask before destructive actions, external sends, commits/pushes, or service lifecycle changes unless the current instruction clearly grants that scope.
• Keep OpenClaw references as legacy compatibility only; Hermes is the primary target for this skill.
• Treat RUNE as a clarity amplifier, not theatrical decoration. If the layer list makes the answer worse, keep it internal.

Legacy OpenClaw Compatibility

Older installs may still use main.sh as an OpenClaw-style executable skill. Keep the wrapper compatible where practical, but do not shape the primary documentation around OpenClaw. The canonical integration path here is Hermes loading SKILL.md.

Verification Checklist

After editing this repository:

• SKILL.md starts with YAML frontmatter and has name + description.
• Description is under 1024 characters.
• README says Hermes-first and keeps OpenClaw only as legacy.
• package.json has Hermes metadata.
• bash -n main.sh passes.
• bash main.sh version works without requiring an API key.
• bash main.sh grimoire works against the local RUNE repo or installed wand.
• Git diff is reviewed before commit/push.