Proposal: Shared Sparse Latent Neural Bus for Local ↔ Cloud Models

Proposal: Shared Sparse Latent Neural Bus for Local ↔ Cloud Models

Idea

Current local-to-cloud AI systems communicate mainly through natural language tokens.

I propose experimenting with a different abstraction:

a learned machine-native neural communication layer between a small local model and a large cloud model.

Instead of:

Local model → text/tokens → API → cloud model

use:

Local hidden state → adapter → shared sparse latent bus → adapter → cloud hidden state

The same interface works in the opposite direction.

Shared neural interface

Let the communication space be a large vector:

Z ∈ R^N

For example:

N = 65,536 – 1,048,576

But only a small number of latent channels are active for each message:

Top-K(Z) << N

For example:

1,048,576 available channels 2,048 active channels

A transmitted neural packet could therefore contain only:

(feature_id, activation)

instead of a dense tensor or token sequence.

This creates a large number of parallel neural communication channels.

Different models, same language

The local and cloud models do not need identical architectures.

Each model has its own adapter:

H_local → Encoder_local → Z

Z → Decoder_cloud → H_cloud

and vice versa.

The latent space Z is shared.

The adapters translate between each model's native hidden representation and the common neural language.

Self-learning protocol

The meaning of the latent channels should not be manually defined.

The protocol should emerge through end-to-end training:

Local model → Z → Cloud model → task result → loss

Gradients train the communication interface so that its internal language evolves toward representations that improve real task performance.

Additional objectives can encourage:

• sparsity;
• independent latent features;
• low bandwidth;
• cycle consistency;
• robustness to missing channels;
• compatibility between model versions.

A possible objective:

L = L_task + λ1 L_sparse + λ2 L_cycle + λ3 L_independence + λ4 L_bandwidth

Mirrored/shared interface

A shared protocol layer could use synchronized weights on both endpoints.

Architecture-specific adapters remain private:

Local model → Local adapter → Shared protocol layer → Z

and:

Z → Shared protocol layer → Cloud adapter → Cloud model

Where appropriate, encoder/decoder transforms could use tied or transposed weights.

Why this may matter

Natural language is a sequential human communication protocol.

A neural model internally represents many things simultaneously:

• intent;
• uncertainty;
• alternative hypotheses;
• relationships;
• memory state;
• planning state;
• candidate actions.

Serializing all of this into text may be an unnecessary bottleneck for model-to-model communication.

A sparse latent bus could transmit this information in parallel.

Relation to current research

This idea is related to active work on:

• latent communication;
• continuous reasoning;
• KV-cache transfer;
• differentiable inter-agent communication;
• cross-model latent alignment;
• sparse autoencoders;
• crosscoders;
• shared latent representations.

The proposed step is to treat the shared latent representation not merely as an internal optimization, but as a persistent machine-native communication protocol between heterogeneous neural systems.

Minimal experiment

A proof of concept could use:

• small frozen local model;
• larger frozen cloud model;
• trainable TX/RX adapters;
• shared sparse latent space;
• Top-K activation;
• quantized latent packets.

Compare against:

1. text-to-text;
2. embedding transfer;
3. dense hidden-state transfer;
4. KV-cache transfer;
5. sparse shared latent communication.

Measure:

• task quality;
• latency;
• bandwidth;
• causal information transfer;
• cross-model compatibility.

The central question is:

Can heterogeneous neural models learn a stable sparse latent language that transfers useful internal state more efficiently than natural-language communication?