Agent rationalization: cross-pollinated hybrids → token-efficient AI playbooks

Scope: fewer tokens + better multi-step reliability, no model retrain.

Corpus: memory/hybrids.jsonl (seed=42, n=15) + memory/hybrids_seed99.jsonl (seed=99, n=15).

Method: re-read story/verbs/media per hybrid; distrust auto score=1.0; merge duplicates into mechanism-named playbooks; reject purpose-mismatches.

1. Executive summary

• 30 hybrids, all auto-scored confidence=1.0 / score=1.0 — scores are not informative. Rationalization is keyword-lexicon + RNG among first hits, not mechanism fit.
• Auto techniques collapse hard: Session codebook 12/30, Priority-priced 5, Delta+stratum 4, Bloom 3, Freeze-plan 2, Hardness router 2, Prefix cache 1, Ping tools 1. Many strong stories (Merkle, metamorphosis, speculative draft-verify, stigmergy traces) were mislabeled as codebook — but the underlying idea (dense codes instead of prose) is correct and under-specified, not wrong.
• After re-rationalization: 12 keep playbooks (incl. elevated dense IR / token compression language), 2 reject patterns, several hybrids reassigned.
• Nothing here is a new computational primitive. Closest priors: dense structured IR, codebooks/DSLs, rolling summary, prompt/result cache, model cascade, RAG budget, tool-minimal I/O, plan-critique, external memory.
• Core representation claim (kept, strengthened): natural-language prose is usually the worst packing of meaning into BPE/WordPiece tokens. Prefer a token compression language: fixed schema STATE, tables, ids, enums, diffs, and session codes — not essay memory.
• Top ROI for our purpose: (1) dense IR / token compression language, (2) rolling summary + delta window, (3) stable prefix + result cache, (4) hardness cascade router, (5) tool-ping / expand-on-demand. Plan/critique remains the top pure-thinking lever (rank 6, still in stack).
• Weekend stack: cached schema+codebook prefix → STATE in dense IR (not prose) → delta window → budgeted admit → route by hardness → tools by id → plan/critique only when escalated → milestone re-encode into the same IR.
• Not found: magical free compression with zero schema design and zero error risk; infinite context; no-retrain soft prompts that beat a good dense system prefix; novelty claims.

2. Corpus stats

Runs

Task tag on both metas: token_efficiency_and_thinking_no_retrain.

Operator frequency (30 hybrids)

Auto-technique frequency (do not trust)

All 30: helps=["token_efficiency","thinking_structure"], identical falsification template, no_retrain=true.

Topic frequency (top 15 names across 120 topic slots)

crystal_growth (5); phase_transition, homeostasis, bloom_filter, gossip, stigmergy (4 each); b_tree, soft_prompt, tides, mycorrhizal_share, diff_patch, tokenization, prompt_cache, crdt, skip_list, slime_mold, river_delta, flocking, circuit_breaker (3 each).

Buckets are balanced by construction (every hybrid is 4-bucket: nature+ai+analogy+cs → 30 each).

Generator limitation (important)

cross_pollinate.py::rationalize matches a fixed TACTIC_LEXICON by substring on topic blob + story, then randomly picks among the first ≤3 hits. That explains inflated scores and codebook domination. Re-rationalization below is story/verb-first, not lexicon-first.

3. Rejected patterns (nothing silent)

Rejected hybrids are not deleted: each is reassigned to a playbook or listed under open_questions / failure in the JSONL.

4. Playbook catalog (≤12)

IDs use s42: / s99: prefixes because both files reuse H0001…H0015.

PB01 — Rolling summary + delta window

PB02 — Stable prefix + result cache

PB03 — Budgeted priority admission

PB04 — Hardness cascade router

PB05 — Freeze-plan then gated critique

PB06 — Bloom / detector gate before deep work

PB07 — Content-addressed expand-on-demand (Merkle ids)

PB08 — Tool ping, don’t paste worlds

PB09 — Stigmergic external traces + memory bank

PB10 — Align-merge multi-view (gated)

PB11 — Metamorphic STATE re-encode + homeostasis

PB12 — Dense IR / token compression language (elevated)

Worked density example (same facts):

# prose (~90+ tokens depending on tokenizer)

We decided to use Postgres for the users table because we need

transactions. Auth is still blocked on the OAuth redirect URI.

Next step is to write the migration.



# dense IR (~35–45 tokens)

D:[db=postgres reason=tx]

F:[users.tbl planned]

O:[auth blocked=oauth_redirect]

N:[write migration]

Codes in legend (once, prefix-cached): D=decisions F=facts O=open N=next.

5. Top 5 ranked for our purpose

Rank key: roughly (token_savings × thinking_gain) / effort, with honesty about implementability next week and A/B ≥20–25% tokens_in without quality collapse.

#1 — Dense IR / token compression language (PB12) [elevated]

Mechanism. Stop storing and exchanging agent memory as English essays. Define a small schema + optional codebook once (in the prompt-cache prefix). All SUMMARY, DELTA, tool observations, and plans are written in that IR. Human-facing prose is a decode step at the edge, not the working medium. This attacks the representation tax: every “the / we should / currently” is a wasted token that also dilutes attention.

Drop-in sketch.

# PREFIX (cached, stable)

IR v1 keys: G=goal F=facts[] D=decisions[] O=open[] N=next[] X=constraints[]

LEGEND: T1=..., E2=...  (session entities; grow only)

Rules: mutate only via field ops; no narrative memory; expand for user only.



# EACH TURN BODY

G: ship billing v1

F: [T1 uses stripe, webhook=/v1/hook]

D: [idempotency=key-header]

O: [PCI review]

N: [add signature verify]

Δ: F+ [rate_limit=100rpm]

Architecture.

[User prose] → encode → [Dense STATE store] → [LLM thinks in IR]

                ↑                              ↓

         decode for human              tools return tables/ids

Falsification. Prose memory vs IR memory, 20 multi-turn tasks; kill if tokens_in not ↓≥25% or success ↓>10% or code-confusion rate high.

Closest prior. Structured STATE; compression dictionaries; DSLs; diff_patch; JSON tool schemas; entity codes.

#2 — Rolling summary + delta window (PB01) — in dense IR, not prose

Mechanism. Dual-timescale context: slow SUMMARY + fast DELTA, but both are PB12 records, not paragraphs. Archive raw log offline.

Drop-in sketch.

SYSTEM: Context is IR only (see prefix schema).

SUMMARY: {G,F,D,O,X}   # compacted IR

DELTA:   patch ops last ≤3 turns

USER: ...

Architecture. [User] → [Orchestrator] → [STATE: summary|delta|archive as IR] → [LLM]

Falsification. 20 multi-turn tasks; ≥20% tokens_in down (often stacks with #1 to more); ≤10% success drop.

Closest prior. Rolling summary / context distill / MemGPT paging / diff_patch.

#3 — Stable prefix + result cache (PB02)

Mechanism. Byte-stable system+schema+codebook+tools for provider cache; hash-keyed reuse of identical sub-answers.

Drop-in sketch.

PREFIX = IR schema + LEGEND + tools  # never churn

TASK body variable only

cache_key=hash(prefix_ver, task_sig)

Architecture. [Router] → [Result cache] → miss → [LLM + prompt-cache prefix]

Falsification. 50 templated tasks; billed tokens ↓≥20%; stale errors ≤2%.

Closest prior. Prompt cache; response cache; shared system prompts.

#4 — Hardness cascade router (PB04)

Mechanism. Easy template/detector → small model → large+tools only on uncertainty.

Drop-in sketch.

if detector(q): return

a, conf = small(q, STATE_IR)

if conf >= τ and not needs_tools: return

return big(q, STATE_IR, tools, plan_mode)

Architecture. [Heuristics] → [Small LLM] → [Big LLM+tools]

Falsification. 100 mixed tasks; tokens/$ ↓≥20%; hard success drop ≤10% vs always-big.

Closest prior. Model routing / FrugalGPT / cascade.

#5 — Tool ping + expand-on-demand (PB08 + PB07)

Mechanism. Tools return rows/enums/ids (IR), never world-dumps; large artifacts behind content ids.

Drop-in sketch.

TOOL out: table|json ≤M rows, short keys

CONTEXT: [{id,title,score}] only

fetch(id) max 3/turn → merge as Δ into STATE_IR

Architecture. [LLM] ⇄ [Tool gateway] ⇄ [Doc store by id] ; [IR STATE]

Falsification. 20 data/codebase tasks; ≥20% tokens_in vs full paste; ≤10% success drop.

Closest prior. ReAct; progressive disclosure; content-addressed packs.

#6 (thinking spear, still in stack) — Freeze-plan then gated critique (PB05)

Same as before; plans written as N:[...] IR bullets, not essays.

Honorable mentions: PB03 budgeted admission, PB06 bloom gate, PB11 metamorphic re-encode into denser IR, PB09 traces as append-only IR log, PB10 multi-view (hard-only).

6. Unified stack (weekend-implementable)

One pipeline, no contradictions. IR is the spine — every other playbook reads/writes the same dense language.

                    ┌──────────────────┐

                    │  Detector / FAQ  │──hit──► return (0 LLM tokens)

                    └────────┬─────────┘

                             miss

                    ┌────────▼─────────┐

                    │ Result cache     │──hit──► return

                    └────────┬─────────┘

                             miss

┌────────────┐      ┌────────▼─────────┐      ┌─────────────────────┐

│ Prefix     │      │ Hardness router  │      │ External memory     │

│ cache:     │─────►│ EASY: small LLM  │◄────►│ SUMMARY+DELTA+      │

│ schema +   │      │ HARD: big+tools  │      │ TRACES — all as IR  │

│ LEGEND +   │      └────────┬─────────┘      │ + content-id index  │

│ tools      │               │                └─────────────────────┘

└────────────┘               │

              ┌──────────────┼──────────────┐

              ▼              ▼              ▼

        [Budget admit] [Tool gateway] [Plan→(crit)→Final]

         IR chunks      tables/ids       IR bullets

              │              │              │

              └──────────────┼──────────────┘

                             ▼

                    patch STATE_IR; append TRACE_IR

                    if tokens>T or milestone:

                       metamorphic re-encode SUMMARY_IR (denser, not essay)

                    user edge: decode IR → prose only when needed

Weekend build order (honest):

1. Hours 0–4: Define IR schema + LEGEND rules; forbid prose memory (PB12).
2. Hours 4–7: Rolling SUMMARY_IR + DELTA patches (PB01 on top of PB12).
3. Hours 7–9: Stable prefix (schema+legend+tools) + result cache (PB02).
4. Hours 9–12: Heuristic router small vs big (PB04).
5. Hours 12–16: Tool row/table caps + fetch-by-id (PB08/07); plan/critique in IR (PB05); milestone re-encode (PB11).
6. Optional day 2: Priority admit (PB03), bloom/FAQ (PB06), cross-session TRACES (PB09).

A/B harness (required): same 20 tasks; log tokens_in/out, success, human rubric; kill stages that fail ≥20–25% tokens / ≤10% quality. Mandatory arm: prose-STATE vs dense-IR STATE.

7. Open questions

1. Best dense IR for your domain — ultra-short key=value vs YAML vs JSON vs custom DSL? Tokenizer-specific density differs (measure with your model’s tokenizer).
2. How large can LEGEND grow before codes themselves need secondary compression / paging?
3. Encode path: deterministic templates vs small model “prose→IR” — error rates?
4. What is the real easy/hard mix of production tasks? Router ROI collapses if almost everything is hard.
5. Provider prompt cache invalidation if LEGEND grows every session (prefix churn)?
6. Multi-view (PB10): small×3+merge vs one big CoT under equal token budget?
7. Cross-pollinator: force tokenization|compression_dict|diff_patch|radix → dense-IR playbook instead of RNG Session codebook.

8. Explicit statement of what was / was NOT found

Found (including correction)

• Token compression languages / dense IRs are real and central — not a sci-fi free lunch, but the right fix for “prose is a terrible packing of meaning into tokens.” Hybrids repeatedly gestured here (tokenization, compression_dict lexicon, diff_patch, radix prefix share, session codebook, seed_bank names); the first pass under-ranked them because auto-labels were noisy. Corrected: PB12 is Top #1.
• Standard engineering levers still stand: move state out of prompt, cache, route, gate, tool-minimal I/O, plan/critique.

Not found

• No magical codec that compresses arbitrary natural language with zero schema, zero legend, and zero ambiguity risk.
• No new learning rule / attention replacement / soft prompt that beats a dense system prefix + tools without training. Soft prompt / activation steering = needs train — skip for now.
• No novelty claim. Dense IR is known (structured prompting, DSLs, dictionaries, diffs) — the win is using it as default agent memory, not inventing a new primitive.
• No trustworthy auto scores (score=1.0 everywhere).
• No always-on multi-agent swarm as a token strategy.
• Discovery packets / atlas were not treated as proven primitives.

Appendix A — Per-hybrid re-map (brief)

End of rationalization. Outputs also in memory/agent_rationalization.jsonl.

Follow-up: focused primitive cross-pollination (dense IR)

A representation-relevant pool and generator were added so analogies hit codecs, not random nature tourism:

• Generator: cross_pollinate_dense_ir.py
• Run: memory/hybrids_dense_ir.jsonl (seed=7, n=24)
• Analysis: memory/dense_ir_primitives.md

Result: cross-pollination rediscovers a small set of IR primitives (legend, typed schema, patch, table, content-id, plan bytecode, gate, trace) that compose the token compression language (PB12) and also structure multi-step thinking. See that doc for the STATE-IR v1 alphabet and ranked implementation list.