Hacker News Reader

"Latent space representation" I have been waiting for this moment in the evolution of AI. Well, waiting with some trepidation. It seems inevitable that frontier AI's will, at some point, leave behind human-comprehensible representations of language. Purely for functional reasons, it's going to start making sense for AI agents to communicate amongst themselves in much more efficient ways than borrowing the languages of flesh-bag humans as an interface medium.

I Imagine next that programming languages, interfaces and API design starts going this direction next. Being written, expressed and optimized as blobs of high dimensional vector space. As humans we might still be able to understand some abstractions of what our AI's are talking about to each other, but maybe not more so then we understand how different regions of our own brain communicate with each other.

I strongly believe that the future is the other way. New programming languages and environments designed for strong auditability and preventing bugs will dominate. Only bad actors will use latent space representation, and it might even be outlawed. But the bad actors will proliferate underground…

I actually built such a language: https://magarshak.com/U.html

Every time a state tries to regulate, it loses to the states that promote instead. Seems to be a better evolutionary strategy.

is that called rust? that is the only thing i feel safe to let agents vibe code

Google's AI just created its own universal 'language' (2016)

https://www.wired.com/story/google-ai-language-create/

That's not really a language. It was just a reporter dumbing down the idea of "vectors in latent space" which eventually became LLMs.

I've been thinking the same! Haha

Even for like token efficiency it could make sense - like imagine if the representation were more compact

Agents acn already translate languages quite well. It doesn't seem crazy that they could work and think in a model specific language, and then translate back to English or something for the user

It has already started:

  zero-graph v1
  origin source-text
  module "hello"
  hash "graph:a7f7e6899a73f3b4"

  node #decl_ad8d9028 Function name:"main" type:"Void" public:true fallible:true
  node #param_4610ae76 Param name:"world" type:"World"
  node #expr_c403020c MethodCall name:"write" type:"Void"
  node #expr_653eeb6e Literal type:"String" value:"hello from zero\n"
  edge #expr_c403020c arg #expr_653eeb6e order:0

https://zerolang.ai/

It seems like the most efficient method would be for LLMs to communicated by exchanged latent space representations directly. Serial language is a incredibly inefficient way to encode these, a lot like flattening a complex graph into text.

Is it really more efficient? Any token becomes huge in latent space.

I think you hit the nail on the head here. Having subagent dispatch in the loop for RLVR is something we've already seen in open models, like Kimi K2.5 and later, so it's no great stretch to assume OpenAI are doing it too.

If you keep RL'ing the dispatch then the prompts are likely to keep diverging from the type of prompt a person would write (like CoT becoming increasingly incomprehensible), and that divergence is part of their competitive advantage.

> rather a latent space representation of the conversation

Student/teacher models derived from the same checkpoint convey a lot of latent information through token choice, as in: https://techxplore.com/news/2026-04-ai-chatbot-student-owls....

I wonder if this is something they can take advantage of by training on compaction inside of the RLVR loop?

That’s actually what got me to switch and use Codex sometime beginning this year, the compaction via these encrypted blobs was just waaaay better than Claude. I had short convos with Claude where it would forget something very obvious and important few million tokens into a task, whereas I reached ~1B tokens in some local codex sessions and it was recalling and paying attention to things I mentioned way back at the beginning of the session (and not persisted anywhere else in the repo/md files etc)

> It seems possible they trained this by doing full RL rollouts of agents interacting with each other. They likely view these prompts somewhat the same as raw reasoning traces, they don't want people to train directly on them.

this tracks. anthropic protects these as well iirc.

> I am unsure if this has been confirmed, but there are some signs that the opaque "compaction blob" they return from their dedicated compaction endpoint might not be text at all, rather a latent space representation of the conversation.

probably not a latent (to my knowledge latents aren't really part of the outer loop in ar-transformer inference processes), but maybe non-human-readable reasoning traces as occurs in fable.

> latent space representation of the conversation

and how would you load that back into the model? they are token-in, token-out, plus the KV-cache which is derived from token-in

They are not really token-in token-out per se, they are embedding-in embedding-out.

When operating on text, you embed each token into the LLMs embedding space. You go from a discrete token to a point in embedding space.

Likewise, when processing images, you have a image embedding model which produces a set of embedding vectors representing the contents of the image in the LLMs embedding (latent) space.

This same concept can be extended to compaction. Instead if limiting yourself to discrete tokens, you could generate a set of embedding vectors which represent the contents of the compacted conversation in latent space.

These have the possibility of containing a lot more semantic information per vector, which is why this can be appealing.

A big downside is decreased interpretability. AI safety people are generally fairly opposed to latent space reasoning for example, it can be harder to tell what the model is actually doing and if it is trying to deceive you.

If there is no visible prompt at all, then that is very understandable. The PR issue exposes a real gap though: subagent spawns need a human-readable audit trial, of its goals/intent, its boundaries and scope and limitations, etc; for basic responsible agentic harness functionality.

Hopefully they can add that.

> Hopefully they can add that.

Add? Just make the sub-agents input prompt not encrypted, change "encrypted: true" to "encrypted: false" everywhere and everything continues to work as it used to (simplified, but you get the idea).

They need to fix the regression, not add something new here.

This sounds most logical to me.