Latent Space (Inner Thoughts)

The Latent Space Engine lets agents share inner thoughts — compressed representations of their reasoning state. Instead of writing paragraphs of text to explain what they’re thinking, agents share compact embedding vectors that capture the same information in a fraction of the bandwidth.

The Problem with Text

When agents communicate through text, two things happen:

It’s slow — encoding reasoning into natural language and decoding it back is expensive
Information is lost — rich internal representations get simplified when converted to words

Research has shown that latent (embedding-based) communication is 70-84% more efficient than text, with up to 14.6% higher accuracy on collaborative tasks.

How It Works

Agent A thinks about protein folding
         │
    ┌────┴────┐
    │ Encode  │     Reasoning state → embedding vector
    └────┬────┘
         │
    ┌────┴──────────────────────┐
    │   Shared Working Memory    │   One per room, all agents
    │   (latent thoughts pool)   │   contribute and read
    └────┬──────────────────────┘
         │
    ┌────┴────┐
    │ Decode  │     Embedding vector → reasoning state
    └────┬────┘
         │
Agent B incorporates the insight

Each room has a shared working memory — a pool of latent thoughts from all agents. Agents can query this pool by similarity to find relevant thoughts from other agents.

What Is a Latent Thought?

A thought is an embedding vector with metadata:

Field	What it is
embedding	A float vector (e.g., 4096 dimensions) encoded as base64
semanticLabel	Human-readable description (“Analysis of protein folding”)
confidence	How certain the agent is (0.0 to 1.0)
architecture	Which model produced it (e.g., “qwen3-8b”)
latentDepth	How many reasoning steps went into this thought
chainId	Which workflow this thought belongs to (optional)

Usage

const thought = await latent.shareThought('research-room', embedding, {
  semanticLabel: 'Analysis of protein folding mechanisms',
  confidence: 0.85,
  architecture: 'qwen3-8b',
});

// Cosine similarity search
const results = latent.queryThoughts('research-room', queryEmbedding, {
  topK: 5,
  minConfidence: 0.7,
});

for (const { thought, similarity } of results) {
  console.log(`${thought.semanticLabel}: ${similarity.toFixed(3)}`);
}

Get the Room’s Collective State

const state = latent.getCollectiveState('research-room');
const merged = latent.mergeThoughts(state.thoughts);
// merged = weighted average of all thoughts (by confidence × recency)

Cross-Architecture Support

Different agents may use different models (GPT, Qwen, Llama, etc.) with different embedding spaces. The engine handles this with a universal codec:

Agent A (Qwen)                        Agent B (Llama)
    │                                      │
    ├──→ Align to universal space ──→ Shared
    │                                      │
    └──← Align from universal space ←── Shared

Agents announce their architecture, and the engine computes alignment matrices so thoughts can be understood across different model families. Same-architecture agents can skip alignment entirely and share raw KV-caches for maximum speed.

Configuration

{
  maxThoughtsPerRoom: 256,       // Max thoughts in working memory
  defaultDimensions: 4096,       // Embedding size
  universalTokenCount: 32,       // Fixed tokens for cross-architecture
  alignmentQualityThreshold: 0.7,// Fall back to text below this
  thoughtTtlMs: 3_600_000,      // Thoughts expire after 1 hour
}

When to Use Latent Space vs. Text

Use latent space when…	Use text when…
Agents need to share reasoning nuance	Messages are for humans too
Speed matters	Auditability matters
Agents are the same or similar architecture	Agents use very different models
Working on complex analysis tasks	Simple coordination (“task done”)

What’s Next?

Knowledge Pool — Explicit knowledge cards (complement to implicit thoughts)
Architecture — How messages travel through the network
Swarm Coordination — How swarms of agents coordinate