Latent Briefing
Share task-relevant orchestrator state with workers through task-guided KV-cache compaction when the inference runtime is controllable.
The skill constrains use to controllable worker runtimes and discloses KV-state access, model-space compatibility, and auditability limitations. It requests no external writes, credentials, or sensitive data. However, it lacks concrete permission boundaries, user confirmation, rollback, and data-governance procedures, so full marks are not justified.
The concepts, preconditions, negative example, tuning risks, and non-fit cases are broadly self-consistent, including an explicit limitation for API-only workers. The skill provides no implementation scripts, key-path tests, or diagnosable runtime error handling; under static calibration the score is capped below 10.
Trigger phrases, audience, use cases, and exclusions are reasonably clear for orchestrator-worker systems, KV compaction, and token explosion. Inputs, outputs, environment compatibility, and Chinese-language usage are not specified in detail. The core function does not depend entirely on an overseas service, so no reachability deduction is applied.
The document includes activation criteria, concepts, a decision framework, practical guidance, examples, limitations, integration notes, references, creation and update dates, author, version, and repository MIT licensing. Maintenance ownership, change history, and update path remain unclear, and referenced public-result claims are not substantiated within the skill.
It can help users decide whether latent KV handoff fits and offers actionable design guidance for task-guided scoring, shared masks, MAD thresholds, and baseline comparisons. It contains no implementation, complete interface, or directly runnable artifact, so substantial engineering work remains and the demonstrated benefit is primarily conceptual.
The skill includes an AM formula, an internal reference note, and links to papers and a public post, providing limited traceability. It lacks key-path tests, independent reproduction, or third-party execution evidence; the public-results statement is marked with a placeholder-style claim identifier, so evidence remains weak.
- Do not treat the stated token savings, accuracy, or compaction-overhead claims as general guarantees; remeasure them on the target models, tasks, and strong baselines.
- Before implementation, verify that the runtime can inspect and rewrite the KV cache and that orchestrator and worker representations are compatible; otherwise use an auditable text handoff or retrieval approach.
What does this skill do, and when should you use it?
Latent Briefing targets hierarchical multi-agent systems where the orchestrator trajectory is repeatedly replayed to workers, causing token growth. Instead of converting that state into a natural-language summary, it retains task-relevant positions in the worker model’s KV cache. The approach combines task-guided queries, one shared mask across layers and heads, and robust median-plus-MAD thresholding. It is suited to inference runtimes that can inspect and rewrite worker KV state, not to text-only hosted APIs.
The skill describes how to represent an orchestrator trajectory in the worker model’s KV state, derive query vectors from the current worker task, score trajectory positions by task-conditioned attention, aggregate scores across layers and heads, create a shared retention mask, and remove low-relevance positions using a robust threshold. It also recommends measuring worker tokens, total tokens, retention rate, accuracy, and compaction overhead to evaluate end-to-end results.
- An engineer building an orchestrator-worker or supervisor-specialist system where workers need prior state without replaying the full trajectory as text.
- A researcher evaluating representation-level state transfer against LLM summarization or RAG.
- A team debugging token explosion in recursive, hierarchical, or tool-heavy agent graphs.
- An evaluator interpreting long-document QA results involving worker-token savings, total-token savings, compaction overhead, and accuracy.
What are this skill's strengths and limitations?
- Directly targets token growth caused by replaying orchestrator trajectories to workers.
- Can preserve task-relevant latent state without serializing the entire trajectory as text.
- Clearly distinguishes KV compaction from prefix caching, summarization, and retrieval.
- Includes practical guidance on thresholds, baselines, latency, and orchestrator variance.
- Requires runtime-level access to inspect and rewrite worker KV state, which text-only APIs generally do not expose.
- Orchestrator and worker representations must be compatible; materially different tokenizers, architectures, or attention layouts may block the approach.
- Compression thresholds are workload-dependent, and aggressive compaction can create accuracy cliffs.
- Public results focus on long-document QA and do not guarantee performance for code, math, or multi-document synthesis.
- The supplied material includes no executable implementation, test suite, or general performance guarantee.
How do you install this skill?
Copy the complete skills/latent-briefing directory into a compatible skills directory, such as .codex/skills/ for Codex, .claude/skills/ for Claude Code, or .agents/skills/ for a generic Agent Skills host. Do not flatten SKILL.md into a single file. The supplied source does not document a standalone installation command or runtime implementation for this skill.
How do you use this skill?
In an environment where the skill is available, a trigger could be: “Design a controllable orchestrator-worker system that shares orchestrator memory through task-guided KV-cache compaction.” Before implementation, confirm access to worker KV tensors, then apply task-guided scoring, shared-mask selection, and workload-specific threshold tuning. The supplied material provides design guidance rather than executable implementation scripts.
How does this skill compare with similar options?
Compared with LLM summarization, Latent Briefing avoids summary latency and abstraction loss but is less human-readable and auditable. Compared with RAG, it does not retrieve external documents; it transfers task-relevant state already built by the orchestrator. Compared with prefix caching, it performs task-conditioned selective retention within the reused trajectory. Structured notes or summaries are better when portability and auditability matter, while text handoff or retrieval is more suitable when the worker runtime is not controllable.