Enable LLM agents to collaborate entirely in latent space by sharing layer-wise KV cache representations instead of text, achieving 4× speedup and 71-84% fewer output tokens while maintaining 14.6% higher accuracy through lossless information preservation in continuous embeddings.
Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.
A direct command skips the review prompt. Inspect the source before running it.
["Multi-Agent Communication","Latent Space Reasoning","Efficient Inference","Working Memory","KV Cache Sharing"]
description
Enable LLM agents to collaborate entirely in latent space by sharing layer-wise KV cache representations instead of text, achieving 4× speedup and 71-84% fewer output tokens while maintaining 14.6% higher accuracy through lossless information preservation in continuous embeddings.
Latent Collaboration in Multi-Agent Systems
Traditional multi-agent systems communicate through text tokens, requiring expensive encoding/decoding cycles and losing information when discrete tokens cannot capture nuanced reasoning. This skill demonstrates how to enable agents to collaborate directly in continuous latent space, sharing internal representations (KV caches) that preserve complete semantic information while achieving dramatic efficiency gains.
The core insight is that latent representations are inherently more expressive than discrete tokens and preserve more information when passed between agents—enabling agents to "think" with each other through embedding space rather than natural language.
Latent Thought Generation: Agents perform auto-regressive reasoning by feeding last-layer hidden states directly back as inputs, generating latent thoughts without explicit token decoding
Working Memory Transfer: Agents share layer-wise KV caches containing both initial context and newly generated latent representations, enabling lossless information preservation
Alignment Matrix: A learned (or precomputed) alignment transformation enables seamless information transfer between agent vocabularies
The system is training-free; it computes the alignment matrix once per task and reuses it across all agent interactions.
Architecture Overview
Latent Thought Module: Generates continuous embeddings representing reasoning without tokenization
KV Cache Management: Tracks and shares cached key-value pairs across agents
Alignment Transformation: Maps representations between different agent models
Sequential/Hierarchical Topologies: Supports various multi-agent configurations
Inference Engine: Routes intermediate representations between agents efficiently
Implementation Steps
The latent collaboration system operates by sharing representations instead of tokens.
1. Extract Last-Layer Hidden States
Capture the continuous representations before tokenization to enable latent thinking.
defextract_hidden_states(model_output, layer_idx=-1):
"""
Extract last-layer hidden states (before output projection).
These continuous representations are richer than discrete tokens.
Args:
model_output: LLM forward pass output
layer_idx: which layer's hidden states to extract (-1 for last)
Returns:
hidden_states: (batch, seq_len, hidden_dim) continuous representations
"""
hidden_states = model_output.hidden_states[layer_idx]
hidden_states
# Access hidden states directly from model forward pass
return
2. Implement Latent Thought Generation
Enable agents to generate reasoning by directly iterating on hidden states.
defgenerate_latent_thoughts(model, initial_hidden_states, num_thoughts=5):
"""
Generate multi-step reasoning in latent space.
Agent produces continuous thought embeddings without token decoding.
Args:
model: LLM with access to hidden states
initial_hidden_states: (1, seq_len, hidden_dim)
num_thoughts: number of latent reasoning steps
Returns:
thought_sequence: List of hidden state tensors representing reasoning steps
"""
thought_sequence = [initial_hidden_states]
for step inrange(num_thoughts):
# Current thoughts become input to next step
current_hidden = thought_sequence[-1]
# Forward pass: model processes latent thoughts# Instead of tokenizing, feed hidden states directly
next_output = model.forward_from_hidden(current_hidden)
# Extract new hidden states (next thought)
next_hidden = extract_hidden_states(next_output, layer_idx=-1)
thought_sequence.append(next_hidden)
return thought_sequence
classSharedKVCache:
"""
Manages KV caches for multi-agent collaboration.
Agents inherit predecessor's cache, enabling lossless context preservation.
"""def__init__(self, num_layers, hidden_dim, cache_size=512):
self.num_layers = num_layers
self.hidden_dim = hidden_dim
# Initialize caches (one per transformer layer)self.kv_cache = [
{'k': None, 'v': None}
for _ inrange(num_layers)
]
defappend_kv(self, layer_idx, new_k, new_v):
"""Add new key-value pairs from agent reasoning step."""ifself.kv_cache[layer_idx]['k'] isNone:
self.kv_cache[layer_idx]['k'] = new_k
self.kv_cache[layer_idx]['v'] = new_v
else:
# Concatenate with existing cacheself.kv_cache[layer_idx]['k'] = torch.cat(
[self.kv_cache[layer_idx]['k'], new_k], dim=-2
)
self.kv_cache[layer_idx]['v'] = torch.cat(
[self.kv_cache[layer_idx]['v'], new_v], dim=-2
)
deftransfer_to_next_agent(self):
"""
Return complete cache for next agent in chain.
Next agent inherits all context (initial + current agent's reasoning).
"""return copy.deepcopy(self.kv_cache)
defget_kv_for_layer(self, layer_idx):
"""Retrieve KV pair for specific layer."""returnself.kv_cache[layer_idx]['k'], self.kv_cache[layer_idx]['v']
4. Compute Alignment Transformation Between Models
Create transformation enabling knowledge transfer between different agent models.
defcompute_alignment_matrix(model_a, model_b, reference_corpus, hidden_dim=768):
"""
Compute learnable alignment matrix for mapping representations.
Enables latent information transfer between agents with different architectures.
Args:
model_a, model_b: Two LLM models to align
reference_corpus: Shared text samples for alignment computation
hidden_dim: dimension of hidden states
Returns:
alignment_matrix: (hidden_dim, hidden_dim) transformation matrix
"""# Forward both models on reference corpuswith torch.no_grad():
hidden_a_list = []
hidden_b_list = []
for sample in reference_corpus:
# Get representations from both models
output_a = model_a(sample, output_hidden_states=True)
output_b = model_b(sample, output_hidden_states=True)
hidden_a = extract_hidden_states(output_a)
hidden_b = extract_hidden_states(output_b)
hidden_a_list.append(hidden_a.mean(dim=1)) # Average over sequence
hidden_b_list.append(hidden_b.mean(dim=1))
hidden_a_all = torch.cat(hidden_a_list, dim=0)
hidden_b_all = torch.cat(hidden_b_list, dim=0)
# Compute alignment via least-squares (or learned with gradient descent)# alignment_matrix @ hidden_a.T ≈ hidden_b.T
alignment_matrix = torch.linalg.lstsq(
hidden_a_all.T,
hidden_b_all.T
).solution.T
return alignment_matrix
5. Sequential Multi-Agent Pipeline
Chain agents together, sharing KV caches and latent representations.
defrun_sequential_latent_collaboration(agents, initial_query, alignment_matrices):
"""
Execute sequential multi-agent reasoning in latent space.
Each agent inherits complete context from predecessors.
Args:
agents: List of LLM models (potentially different architectures)
initial_query: Input text/query
alignment_matrices: Dict mapping (agent_i, agent_j) to alignment matrices
Returns:
final_answer: Text output from last agent
reasoning_trace: Hidden state representations at each step
"""# Initialize first agent with query
shared_cache = SharedKVCache(
num_layers=agents[0].config.num_hidden_layers,
hidden_dim=agents[0].config.hidden_size
)
initial_output = agents[0](
initial_query,
output_hidden_states=True,
use_cache=True
)
current_hidden = extract_hidden_states(initial_output)
reasoning_trace = [current_hidden]
# Sequential agent chainfor agent_idx inrange(1, len(agents)):
current_agent = agents[agent_idx]
previous_agent = agents[agent_idx - 1]
# Transfer cache to current agent
inherited_cache = shared_cache.transfer_to_next_agent()
# Align representations if agents have different architecturesif agent_idx > 0and (agent_idx - 1, agent_idx) in alignment_matrices:
alignment = alignment_matrices[(agent_idx - 1, agent_idx)]
current_hidden = current_hidden @ alignment.T
# Current agent processes with inherited cache
output = current_agent(
inputs_embeds=current_hidden, # Feed hidden states directly
past_key_values=inherited_cache,
output_hidden_states=True,
use_cache=True
)
current_hidden = extract_hidden_states(output)
reasoning_trace.append(current_hidden)
# Update shared cachefor layer_idx, layer_kv inenumerate(output.past_key_values):
shared_cache.append_kv(layer_idx, layer_kv[0], layer_kv[1])
# Final decoding (only once, from last agent)
final_output = current_agent.generate(
inputs_embeds=current_hidden,
max_length=128,
past_key_values=inherited_cache
)
return final_output, reasoning_trace
6. Hierarchical Multi-Agent Architecture
Support tree-structured agent topologies for complex reasoning.
classHierarchicalLatentCollaboration:
"""
Enables tree-structured agent collaboration with latent coordination.
Leaf agents reason in parallel, then aggregate to parent agents.
"""def__init__(self, agent_tree, alignment_matrices):
self.agent_tree = agent_tree # Tree structure: {node_id: (agent, children)}self.alignment_matrices = alignment_matrices
self.cache_tree = {} # Cache for each nodedefforward(self, query, node_id='root'):
"""
Forward pass through hierarchical agent tree.
Children's outputs aggregate to parent's input.
"""
agent, children = self.agent_tree[node_id]
ifnot children:
# Leaf agent: process query
output = agent(query, output_hidden_states=True)
hidden = extract_hidden_states(output)
else:
# Internal node: aggregate children's outputs
child_hiddens = []
for child_id in children:
child_hidden, _ = self.forward(query, child_id)
child_hiddens.append(child_hidden)
# Aggregate children's latent representations
aggregated = torch.cat(child_hiddens, dim=-1)
# Process aggregated representation
output = agent(
inputs_embeds=aggregated,
output_hidden_states=True
)
hidden = extract_hidden_states(output)
self.cache_tree[node_id] = hidden
return hidden, output
Practical Guidance
When to Use Latent Collaboration:
Multi-step reasoning where agents build on each other's analysis
Heterogeneous agent architectures (different model sizes/types)
Scenarios where efficiency is critical (4× speedup valuable)
Complex reasoning tasks benefiting from specialized agent perspectives
When NOT to Use:
Single-agent tasks (simpler solutions available)
Scenarios requiring interpretable text-based communication logs
Tasks where model architectures must remain isolated
Key Hyperparameters:
alignment_computation_strategy: Least-squares vs. learned (least-squares simpler, faster)
cache_sharing_mode: Full vs. selective layer sharing (full sharing faster but uses more memory)
num_agents: Longer chains → better reasoning but higher latency
hidden_dim: Model-dependent; larger dims preserve more information
Efficiency Metrics:
Expected speedup: 4-4.3× for sequential chains of 3-5 agents
Token reduction: 71-84% fewer output tokens vs. text-based coordination
Memory overhead: ~15-20% additional for shared caches
Integration Pattern:
Latent collaboration integrates into multi-agent RL systems where agents coordinate on shared tasks. Use as internal reasoning mechanism alongside external action policies.
