It seems likely to me this was driven by the `ultra` mode in 5.6, which fans subagents to do work. This mode was previously only available in the web UI (what was previously known as pro?)

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.

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. The fact that OpenAIs compaction seems to be much higher fidelity than a lot of other providers makes me inclined to believe this.

If this is true, it doesn't seem far fetched to infer that they might be applying similar techniques to prompting subagents.

I would be curious to see if this way of spawning subagents (encrypted blob) is used when subagents of a different model type is spawned.

▲ radicality a minute ago | parent | next [-]

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)

▲ tpurves 3 hours ago | parent | prev | next [-]

"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.

▲ mparramon 3 hours ago | parent | next [-]

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/

▲ nextaccountic an hour ago | parent | prev | next [-]

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

▲ karma_daemon 3 hours ago | parent | prev | next [-]

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

▲ EGreg 3 hours ago | parent | prev | next [-]

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

	▲	mparramon 3 hours ago \| parent \| next [-]
		Every time a state tries to regulate, it loses to the states that promote instead. Seems to be a better evolutionary strategy.
	▲	michaellee8 3 hours ago \| parent \| prev [-]
		is that called rust? that is the only thing i feel safe to let agents vibe code

▲ TowerTall 3 hours ago | parent | prev | next [-]

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

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

	▲	StilesCrisis 2 hours ago \| parent [-]
		That's not really a language. It was just a reporter dumbing down the idea of "vectors in latent space" which eventually became LLMs.

▲ UltraSane 2 hours ago | parent | prev [-]

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.

▲ wren6991 3 hours ago | parent | prev | next [-]

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?

▲ a-dub 2 hours ago | parent | prev | next [-]

> 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.

▲ dannyw 2 hours ago | parent | prev | next [-]

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.

	▲	embedding-shape 2 hours ago \| parent [-]
		> 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.

▲ alansaber 38 minutes ago | parent | prev | next [-]

This sounds most logical to me.

▲ dist-epoch 3 hours ago | parent | prev [-]

> 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

	▲	hansihe 2 hours ago \| parent [-]
		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.