Audit every source of per-turn input token cost on a Hermes Agent instance. Measure each, rank by cost, act on the top consumers.

Every turn, Hermes injects these blocks into the system prompt before the user's message:

On-demand (not per-turn): full SKILL.md via , deferred tool schemas via , reference files via .

The health metric is overhead ratio: overhead tokens divided by the model's context window. The absolute number matters for cost; the ratio matters for quality.

Why the ratio matters: Three studies confirm that input length degrades model performance independent of content quality:

Cost compounding: Overhead is paid every turn. At 10k tokens over 100 turns, that is 1M input tokens spent on overhead alone. Reducing overhead by 2k tokens saves 200k tokens per 100-turn session.

Run the audit script to get real numbers:

python3 -c "
import yaml, pathlib, glob, os, re

files = glob.glob(os.path.expanduser('~/.hermes/skills/**/SKILL.md'), recursive=True) total_desc = 0; count = 0; by_cat = {} for f in files: try: text = pathlib.Path(f).read_text() m = re.match(r'^---\n(.?)\n---\n', text, re.DOTALL) if not m: continue fm = yaml.safe_load(m.group(1)) if not fm: continue desc = fm.get('description', '') if not desc: continue cat = f.split('/skills/')[1].split('/')[0] by_cat.setdefault(cat, [0,0]); by_cat[cat][0] += len(desc); by_cat[cat][1] += 1 total_desc += len(desc); count += 1 except Exception: pass avg = total_desc // max(count, 1) K = int(os.environ.get('SKILL_RETRIEVAL_TOP_K', '6')) print(f'Skills: {count} total, {total_desc} chars in descriptions') print(f' Top-K per turn: {K*avg} chars ({Kavg//4} tokens) at K={K}') print(f' By category (top 5):') for cat, (sz, cnt) in sorted(by_cat.items(), key=lambda x: -x[1][0])[:5]: print(f' {sz:>6} chars ({cnt:>2} skills) {cat}')

config_path = os.path.expanduser('~/.hermes/config.yaml') if not os.path.exists(config_path): print(' Config: ~/.hermes/config.yaml not found — skipping disabled/compression stats') else: try: with open(config_path) as fh: cfg = yaml.safe_load(fh) if cfg is None: cfg = {} disabled = cfg.get('skills',{}).get('disabled',[]) or [] print(f' Disabled: {len(disabled)} skills (saves ~{len(disabled)*avg} chars)') comp = cfg.get('compression',{}) or {} print(f' Compression: threshold={comp.get("threshold")}, target_ratio={comp.get("target_ratio")}, protect_last={comp.get("protect_last_n")}') except Exception as e: print(f' Config parse error: {e}') "

For memory provider counts (if Mnemosyne is installed):

```bash
python3 -c "
import sqlite3, os, glob
for db in glob.glob(os.path.expanduser('~/.hermes/**/mnemosyne.db'), recursive=True):
    conn = sqlite3.connect(db); c = conn.cursor()
    for t in ['working_memory','episodic_memory','canonical_facts','memoria_facts']:
        try:
            c.execute(f'SELECT COUNT(*) FROM {t}'); print(f'  {t}: {c.fetchone()[0]} rows')
        except: pass
    conn.close()
"

Done: skill descriptions, disabled count, and compression config measured. Tool schemas (#1) and behavioral rules (#2) are fixed costs — estimate from the model's system prompt or check in-session for the total. The script measures the variable sources (#6, #7); the fixed sources (#1-#5) require in-session inspection.

Sort all sources by tokens per turn. The typical ranking:

Done: sources ranked. Top 3 are the optimization targets.

Done: at least one optimization applied to each top-3 source.

Re-run the audit script from step 1. Compare token estimates before and after.

Done: before/after delta reported. If no meaningful reduction, the remaining overhead is structural (system prompt + behavioral rules) and cannot be reduced without config changes.