OpenAI's new Astra model uses recurrent loops to add computational depth, which technically hides AI reasoning in unreadable neural vectors rather than interpretable text. The company argues this poses no new safety risk since the added depth is modest compared to simply building deeper models, but the underlying concern—that AIs could think dangerous thoughts we can't monitor—remains unresolved.

• Neuralese recurrence lets AI loop internal representations (vectors) instead of outputting readable chain-of-thought text, making it impossible to monitor what the AI is actually thinking at scale.
• OpenAI claims Astra's recurrent depth (roughly 240 layers) is only 2x GPT-4's depth, so it's no worse than building a deeper model traditionally—a distinction that matters for safety but not for capabilities.
• Looping the same layers repeatedly is much weaker than adding new real layers; the AI can't learn new knowledge patterns, just apply existing ones more times, limiting the appeal of extreme looping.

TypeSafe AI released Jev, a model that takes text input but outputs confidence scores and probability distributions instead of generated text. It's designed for classification tasks like spam detection and ranking, costs $0.042 per million input tokens with free output, and has already spawned open-source recreations and creative experiments.

• Jev returns structured probabilistic outputs (yes/no scores, rankings, category choices) rather than text, making it fast and cheap—you only pay for input tokens, not output.
• The model trades interpretability for simplicity: you get a floating-point score but no explanation of which signals drove the decision, raising serious concerns about hidden bias in high-stakes use cases like hiring.
• The community has already built unconventional projects with it (a chat model, a game player, a left-pad implementation) and created open-weight alternatives like Kev within days of release.

Researchers propose a metric called NLS depth to quantify how much unobservable reasoning AI models can perform internally, separate from chain-of-thought outputs. This matters because architectural changes could let models do complex reasoning without showing their work, making them harder to monitor.

• Current chain-of-thought monitoring works because models are trained on human text, but new architectures could bypass this by performing reasoning in opaque hidden states instead of readable tokens.
• NLS depth measures the longest computational path that doesn't pass through natural-language outputs (tokens initialized from pre-training), making it possible to assess monitorability risk before a model is even trained.
• The metric deliberately ignores some post-training choices (like RLHF or distillation) to focus on architectural differences, distinguishing between standard transformers and genuinely concerning designs like full-bandwidth transformers that can hide reasoning across entire context windows.

OpenAI's Astra model uses "opaque recurrence," a technique that makes AI reasoning harder to monitor by processing queries in loops rather than linear steps. Safety researchers worry this could scale into a problem where AI reasoning becomes completely invisible.

• Opaque recurrence reduces legible traces of AI reasoning, making chain-of-thought monitoring less effective than current methods
• Safety experts fear the technique could escalate into a "race to the bottom" where labs stop maintaining transparent reasoning altogether
• OpenAI says Astra's use is limited and they remain committed to chain-of-thought monitoring, but Anthropic and Google DeepMind are already exploring the same approach

The author compares DNA genomes and large language model weights as passive information sequences—scores that only become meaningful when processed by cellular machinery or inference engines. Both arise from massive search processes (evolution and gradient descent) that compress vast experiences into lossy representations, leaving much uninterpreted “junk.” This parallel explains why it’s hard to pinpoint where specific functions reside in either genome or model.

• DNA and LLM weights are both inert symbol strings that only produce meaning when run through an interpreter (ribosomes/enzymes vs. inference engines)
• Both are compressed, lossy residues of massive iterative search—4 billion years of natural selection vs. gradient descent over trillions of examples—not literal copies of the experiences that shaped them
• Neither system stores discrete facts or instructions at a single location (no "gene for a hand," no weight for "Paris is the capital of France"); competence is distributed across the whole structure, which is why pinpointing function in either genome or model is so hard

Pingkit is a toolkit designed for training reproducible, capacity-aware models using transformer activations. It offers features for extracting embeddings, training neural architectures, and creating custom probes tailored to specific research needs. The toolkit is integrated with Hugging Face models and provides various utilities for data processing and model training.

• Pingkit extracts embeddings directly from transformer activations for downstream probing/analysis rather than relying on final-layer outputs alone.
• It's built to train "capacity-aware" probes, letting researchers control model complexity to avoid overstating what information is linearly/nonlinearly decodable from activations.
• Integrates with Hugging Face models, so it can plug into existing pretrained transformer workflows without custom extraction code.
• Emphasizes reproducibility, aiming to standardize probing experiments that are often ad hoc and hard to replicate across papers.