GreenPT/trained-shorthand-report

Trained Shorthand for Agent-to-Agent Communication — Report

Current version: v4 (translator–worker). The v1 encoder/reader report is preserved below.

v4: translator–worker architecture

We fine-tuned Qwen3.5-9B (LoRA) agents to exchange messages in a terse learned slot-marker shorthand. In v4 the work is split: a translator converts English task descriptions into shorthand specs (and shorthand reports back to English), while a worker executes the shorthand natively in an agentic loop against a pytest sandbox — no decompression inside the loop.

User (English task)
   ▼
TRANSLATOR  (GreenPT/shorthand-translator-v4)  EN → slot-marker shorthand spec
   ▼
WORKER  (GreenPT/shorthand-worker-v4)  shorthand-native loop:
   <act>read / <act>edit <fix> / <test> / <done> / <need>
   ▼
TRANSLATOR  shorthand done-report → English summary

Translator LoRA	GreenPT/shorthand-translator-v4 (r=64, 3 epochs, 8,649 rows)
Worker LoRA	GreenPT/shorthand-worker-v4 (r=64, 3 epochs, 11,532 rows)
Dataset + scripts	GreenPT/shorthand-agent-comm
Teacher	Qwen/Qwen3.5-397B-A17B via HF Inference Providers (:deepinfra)

Measured on the full 195-task held-out set (2026-09-02, pytest-verified, all systems token-accounted on identical tasks; raw records: v4_bench_heldout.jsonl + v4_bench_heldout_a2.jsonl in the dataset repo):

System	Success	Median tok/task	Mean tok/task
A — vanilla 9B, minimal prompt	5.6% (11/195)	421	460
A2 — vanilla 9B, worked-example prompt	79.5% (155/195)	293	308
B — translator + shorthand worker	60.0% (117/195)	1,436	1,769

Verdict: on this benchmark the v4 shorthand loop loses on both axes — ~5.3x more tokens per task (median, paired) AND 19.5pp lower success than a properly-prompted vanilla English loop (B was cheaper on 0/195 tasks). The token-savings hypothesis for agentic loops is not supported here.

• Why B costs more: the shorthand steps themselves are short, but the boundary calls dominate — translator encode + decode (~250 tok each way) and the code-synthesis call that turns the worker's one-line <fix> into real code (full file in, full function out).
• Why B loses tasks: the <fix>-line → synthesis round-trip is lossy; it fails on edge-case snippets the English baseline solves by writing code directly (last_n 0/19, slugify 0/20, mean_positive 2/18 for B; A2 gets 19/19, 16/20, 16/18). B also doesn't recover from real test failures (its training trajectories are all-successful); 12/78 B failures falsely report <done>.
• System A (minimal prompt) is the prompt-artifact control: it never follows the protocol (bare edit with no code, read loops; 5.6% comes entirely from the one snippet whose test passes on the buggy code). A2 shows the same base model works fine with a worked-example prompt.
• B per-snippet: 100% on clamp, count_words, flatten, parse_date, pct_change, safe_get, to_cents; dedup 27%; mean_positive 11%; 0% on last_n, retry_fetch, slugify.
• An earlier 20-task smoke reported "100% success"; that number is not borne out by the full run and is withdrawn.

Training data: 2,883 trajectories, 92–98% teacher-validity, 195 held-out.

v4 costs (measured): teacher API $1.68 + ~$7 GPU (session 3) + ~6.8 a100-hours eval (session 5, incl. one OOM-killed attempt); project GPU total ≈ 23 a100-hours.

Try it: Gradio demo (demo/app.py in the code repo) shows the EN→SH translation, the worker's shorthand loop step-by-step, and the SH→EN report with live token counters. Usage examples: GUIDE.md in this repo.

---

v1 report: encoder + reader

Executive summary

We fine-tuned Qwen3.5-9B agents (LoRA, TRL) to exchange messages in a terse learned shorthand — an encoder compresses verbose agent messages ~2.5x and a reader acts on the shorthand directly. Across 500 held-out tasks in 4 task families, the trained pair matched baseline accuracy on reasoning-centric tasks (math, coding) at 2.5x fewer receiver-context tokens, but failed to compress data-dominant messages (tool JSON must survive verbatim, so slot markers only add overhead) and expanded the one family (handoff) whose task design was broken. One of four families (handoff) is reported as invalid.

Verdict: marginal-to-win, family-dependent — a real but narrow result: trained shorthand is a genuine token win for reasoning/prose messages, not a universal compression.

	Verbose (baseline)	Trained shorthand	Change
Coding (pytest)	85 tok → 100.0%	34 tok → 100.0%	−60% tok, = acc
CoT/math (exact)	81 tok → 100.0%	32 tok → 100.0%	−61% tok, = acc
Tool relay (prog.)	232 tok → 89.2%	273 tok → 99.2%	+18% tok, +10pp acc
Handoff (judge)	51 tok → invalid*	105 tok → invalid*	+106% tok

* Handoff tasks referenced a CSV whose contents were never provided; both models scored near the floor. This is a task-design flaw (messages pointed at a file instead of carrying it), not evidence about shorthand. Excluded.

Headline findings

1. Trained shorthand works where compression has room. The encoder learned to drop articles, filler and boilerplate while preserving every constraint, number, path and identifier verbatim — the reader executed at 100% accuracy on coding (pytest-verified in a sandbox) and math (exact match) at ~2.5x fewer tokens.
2. Data-dominant messages don't compress — and shouldn't. Tool-relay JSON is payload: the reader must see records verbatim to compute correct totals. Shorthand on this family expanded messages +18% while also raising accuracy +10pp (fielded reformatting aids extraction) — a real trade-off, not a free win, and the honest recommendation is to keep tool JSON verbatim.
3. One family (handoff) was broken by design, not by the method. Tasks pointed at a CSV that was never in the message. Both conditions scored near the floor on it; it is excluded from all conclusions and flagged for a re-run with payload-bearing messages.

v1 costs

Item	Amount
Teacher API (397B, data-gen + pilots + judge)	$6.16 + ~$2
GPU (17 l40sx1 jobs, incl. failed/rerun)	see GreenPT billing page
Total	≈ $8

What failed (honest list)

• 2 OOM crashes during encoder LoRA on l40sx1 (adapter-merge VRAM spike) — retried on cpu-basic, succeeded.
• 1 API 402 (credits depleted mid-run) — retried after top-up, succeeded.
• Coding scoring bug: initial run scored 0.0% because raw model output (module + tests concatenated) was written wholesale to mod.py; the module alone imports fine but the appended test section references names defined in the test file. Fixed by extracting only the module portion. 16 records were mis-scored and corrected; the reported 100% is from the fixed scorer.
• Handoff task design flaw: 51/118 tasks asked the model to summarize a CSV it could not see. Invalid — excluded from all conclusions.

v1 artifacts

Artifact	Where
Encoder LoRA	GreenPT/shorthand-encoder
Reader LoRA	GreenPT/shorthand-reader
Dataset (train + held-out)	GreenPT/shorthand-agent-comm
Raw eval outputs	dataset repo (eval_baseline.jsonl, eval_short.jsonl, eval_out.jsonl)

Lessons (carried into v4)

1. Write test files to a separate path from the module under test; never overwrite mod.py with model output that includes test code.
2. Extract, don't trust: always extract the module portion from model output before writing to disk (fixed scorer: 16 mis-scored records).
3. Handoff messages must carry the payload, not reference it.
4. Set PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True on l40sx1 — two OOM crashes were fragmentation, not capacity.
5. enable_thinking=False is required for Qwen3.5 chat templates in eval; without it the model spends the entire budget on <think>.