OpenAI announced a new reasoning model called Astra on Monday, and it works differently than anything they’ve shipped before. Instead of the sequential, chain-of-thought reasoning that powered o1 and similar models, Astra uses something called “recurrent depth.” Think of it as letting the model loop back on itself, revisiting and revising its own reasoning rather than marching forward in a straight line.

The technical details are still thin, but the basic idea is that Astra can operate outside the linear step-by-step process that characterized most reasoning models. Traditional reasoning models generate a chain of thought, one step logically following the previous one. Recurrent depth lets the model circle back, refine earlier steps, explore alternative branches, and generally behave less like a calculator and more like a person actually thinking through a hard problem.

That flexibility worries AI safety researchers. The concern isn’t that recurrent depth is inherently dangerous. It’s that it makes the model’s reasoning process harder to follow and harder to constrain. Sequential reasoning has problems, but at least you can inspect the chain of thought and see where things went wrong. With recurrent depth, the model’s internal state becomes more opaque. You lose some visibility into how it arrived at an answer.

Why This Matters for Developers

If you’re building on OpenAI’s API, Astra probably isn’t available yet. OpenAI tends to release these models to research partners and enterprise customers first, then roll them out more broadly. But the shift to recurrent depth suggests where reasoning models are headed, and that has implications for anyone building AI-powered applications.

The good news: recurrent depth should make models better at complex reasoning tasks. Problems that require backtracking, exploring multiple approaches, or reconsidering earlier assumptions should get easier. That’s useful for things like code generation, debugging, mathematical proofs, and strategic planning.

The bad news: it’s harder to guarantee the model won’t do something you don’t want. Sequential reasoning models already have alignment problems, but at least you can audit the chain of thought. With recurrent depth, you’re trusting the model to navigate a more complicated internal reasoning process, and you have less visibility into what’s happening under the hood.

For now, this is mostly a research concern. But if recurrent depth becomes the standard approach for reasoning models, developers will need new tools for monitoring and constraining model behavior. The techniques that worked for chain-of-thought reasoning won’t necessarily transfer.

What Else Shipped This Week

llm-gemini 0.34 added support for Google’s new Gemini 3.8 Flash model, which comes with three thinking levels: low, medium, and high. Simon Willison tested it on pelicans and found noticeable differences in output quality across the three levels. If you’re using the llm CLI tool, this is a straightforward upgrade. The plugin also fixed a bug where async responses weren’t recording the resolved model version.

HiddenLayer raised $100M to build security tools for AI deployments. The company focuses on monitoring not just AI agents but also the tools and add-ons they use. As enterprises actually start putting AI agents into production, the security surface area expands fast. An agent with access to internal APIs, databases, or third-party services can do a lot of damage if it behaves unexpectedly. HiddenLayer’s bet is that existing security tools aren’t built for this, and enterprises will pay for something purpose-built. Series B, led by existing investors, exact valuation undisclosed.

Polars 2.0 is in pre-release. If you’re still using pandas for data manipulation, Polars is the fast, modern alternative written in Rust. Version 2.0 is a major release with breaking changes, so don’t upgrade production code without testing. The full release notes are on pola.rs, but the headline features are better lazy evaluation, improved SQL support, and a bunch of performance wins. Worth checking out if you work with dataframes and care about speed.

GitHub published two blog posts about AI development. One explains their cost optimization strategy for Copilot, which is actually interesting if you care about token efficiency. The other tries to decode “new AI lingo” like loops, harnesses, and squads. That one reads like a marketing exercise, but the cost optimization post has useful details about why shorter outputs sometimes cost more and how GitHub reduces wasted work across the coding task lifecycle.

The OpenAI news is the one to watch. Recurrent depth is a real departure from how reasoning models have worked, and if it delivers better performance, other labs will copy it. That means more capable models, but also more complicated alignment challenges. If you’re building production systems on top of reasoning models, keep an eye on how this plays out.