Bootstrap Hermes with PayPerQ (ppq.ai)

Running long sessions costs more than the model's sticker price suggests: every turn re-bills the whole accumulated context, so cost grows with cadence and carried context, not with how much you “did.” This sheet gives the mental model, the key numbers, and a handful of levers — cadence, delegation, and forking — that keep the bill predictable. Read sections 1–3 if you only have a minute; the rest is reference.

Use by hand or to teach someone. Re-verify the price anchor before big decisions. Written from the author's own Hermes workflow — levers, thresholds, and numbers are author-measured, not vendor documentation.

1 · The mental model (3 sentences)

1. Every turn re-sends the whole conversation to the model — accumulated context is a recurring cost, not a one-time cost.
2. The re-send is billed at cache price (1/5 of fresh) only if the previous turn is recent; after a gap of minutes the cache dies and everything re-bills at full fresh price.
3. Output is the premium dimension: ~3.3× fresh input price; output+reasoning typically dominate the realized bill.

2 · Teaching version (one paragraph)

"Every conversation turn re-bills the whole accumulated context. Cache makes that 5× cheaper, but only if you don't pause for minutes. So: keep the main session lean (terse turns, batched calls, short outputs), push any big read into a throwaway subagent that returns a summary, and when the session has grown past ~10–15k tokens beyond its brief, split it at a natural break point with a written handover brief — the split costs cents, the carried context costs dollars. Measure real sessions in state.db instead of guessing, and re-verify prices before trusting the thresholds."

3 · The three decisions

(a) Inline — do it now in the main session: ≤ ~10 tool calls, no single read > ~35k chars (~8k tokens; ~44k chars if the child baseload is ~20k), low risk, no user input needed mid-flight.

(b) Delegate — push to a subagent: any bulk read > ~8k tokens (~35k chars) when ≥10 turns remain.

• Inline pays R fresh once + R × T × carrying-rate recurrence.
• Child pays R fresh once in its own short-lived context; parent carries only the ~2–3k-token summary.
• Worked example: 50k-char read over 20 turns → inline $0.0396 vs delegate $0.0109 — 3.6× cheaper.
• Delegate rules: self-contained goal+context (children see nothing of your conversation), verifiable handle for any external effect, ONE call with a tasks array for parallel items, children return SHORT results (≤ ~2k tok).

(c) Fork — /new with a handover brief: when context beyond the brief exceeds ~10–15k tokens with several turns remaining. The fork itself is nearly free; the real costs are human /new effort and working-state loss — both minimized by the brief convention.

• Fork only at natural break points: completed deliverable, topic switch, or all remaining items user-gated.
• Fork procedure: write YYYY-MM-DD-handover-<slug>.md with Status+reason, bold kick-off formula ("read <file> and execute"), numbered open items with exact commands/paths, evidence paths. Then ask the user to /new and kick off.
• Exception: do NOT fork a deliberate big read-only reference context queried in a tight loop — warm big-context loops are cheap.

Risk beats size: a tiny item touching secrets, destructive ops, or outward-facing sends is user-GO territory, never a cheap inline item.

4 · The numbers (ppq list prices)

f = cache_read / (fresh + cache_read) per session — computable from ~/.hermes/state.db, table session_model_usage.

5 · Cache TTL rule

• No published TTL (Z.ai: only "reasonable time limits, will recalculate after expiration"). Empirically minutes-scale.
• Treat any user gap > a couple of minutes as a full cache miss: the whole accumulated context re-bills fresh on the next turn.
• Consequence: dense bursts beat spread-out pacing — answer back-to-back, then fork at the break instead of idling inside a heavy session.
• Want a measured bound for your account? Needs per-call timestamps from the ppq usage CSV (the Hermes DB records none).

6 · Output discipline

• Terse main-session turns; require children to return short results.
• Batch tool calls into single turns — keeps the cache warm AND dodges the min-billing floor that makes tiny calls pay ~1.8× input rate.
• Output+reasoning is typically the largest share of the realized bill → the #1 lever after cadence.

7 · Anti-patterns

• Pre-summarizing a big file inline "to save tokens" — burns the context you are protecting. Delegate the read.
• Manual /new between every round — forks are cheap but each needs a brief; route work instead, fork only at natural breaks.
• Idling/polling in a heavy session waiting for a timer or a user test — time-gated work belongs to the NEXT session's kickoff.
• Trusting the DB cost estimate for billing — add ~10–15% for reasoning-heavy sessions; for € figures, use the CSV.
• Forking a warm big-context read-only loop.
• Sending a child a huge context block duplicating your whole session — self-contained ≠ everything; give the goal, the exact paths, and the acceptance criteria.

8 · Measure, don't predict

sqlite3 ~/.hermes/state.db \
  "SELECT session_id, input_tokens, cache_read_tokens, output_tokens,
          reasoning_tokens, api_call_count
   FROM session_model_usage ORDER BY rowid DESC LIMIT 10;"
# f = cache_read / (input + cache_read)

A task's context size cannot be assumed in advance — query what IS before tuning thresholds. Also check sessions.parent_session_id for actual child baseloads.

9 · Open caveats (honest unknowns)

• Thresholds are a snapshot — re-verify prices; no repricing alert exists.
• Child baseload ~15k unverified — measure it.
• Cache TTL unpublished; minutes-scale inferred from measured f, not from a vendor number.
• This sheet covers size/cost/risk routing only — privacy-sensitive work needs separate handling layered on top.