Weekly Hallucinations: DeepSeek V4.1 Flash, Meta Muse, and My Verdict After Comparing GPT-6 Astra With Fable 5.1

For the past two weeks, I’ve been putting GPT-6 Astra and Fable 5.1 through their paces on real projects. In the end, I picked one, but I’ll still be working with both.

OpenAI published a solution to the Navier–Stokes problem, one of the seven Millennium Prize Problems. The company’s internal model constructed an example in which a fluid initially at rest, under the influence of a smooth external force, develops a singularity in finite time: its velocity grows without bound even though its energy remains finite. Alongside the write-up, OpenAI released a formalization in Lean, a system for machine-checking mathematical proofs.

About 10,000 agents worked on the solution simultaneously. Over 88 hours, they exchanged 2.7 million messages and generated roughly 130 billion output tokens. Different groups explored different approaches and shared intermediate results, while Codex collected useful findings for subsequent attempts. After that, GPT-6 Astra spent another 17 hours translating the proof into Lean and verifying it.

No need to bring the million dollars to the cashier just yet. The Clay Mathematics Institute says the problem appears to have been solved, but nobody is rushing to recognize it. The work has to be published in a recognized mathematical journal, then undergo at least two years of scrutiny and receive general acceptance from the community. OpenAI itself is not claiming the prize.

OpenAI began the experiment after rumors that mathematicians Levent Alpöge and Tristan Buckmaster had made progress on two Millennium Prize Problems. Their work concerned a related problem for the Euler equations with an external force; OpenAI’s system separately solved a version without such a force, and then the Navier–Stokes problem. The company says the agents had not seen the other researchers’ work and that Buckmaster’s Codex queries could not have entered the training data of the model used. In mathematics, Lean can verify a chain of reasoning, but it does not assign authorship or priority.

Here, Astra was verifying a huge result produced by another model. My verdict after working with Astra and Fable 5.1 is an awkward one: for everyday development, I’m choosing Fable for now, but if I had to keep just one model for everything, I’d pick Astra.

With Astra, it feels as though both the power and the variance have been cranked up at the same time. Tech blogger Theo described it as a model capable of producing an incredible solution and then making one of the dumbest mistakes imaginable on the very next task. Fable, he says, more often just does what you asked.

Fable understands intent better and more often produces code that can be merged right away. In my tasks, getting to a pull request took an average of two additional passes after Fable, versus six after Astra. On the other hand, Astra migrated one project from TypeScript to Rust and got the test pass rate above 80%. I still wouldn’t leave it running autonomously for a long stretch without tests or checkpoints.

In a field test, 105 bugs were hidden across two repositories. Astra found and fixed 48, Fable 43, and GPT-5.6 Sol 42. That small edge doesn’t settle anything yet: a single run doesn’t show whether the models caught the same defects or whether their patches broke neighboring code. The test’s author ultimately gave implementation to Astra and review to Fable or Sol, because the models turned out to have different blind spots.

Astra dug deeper into a broken environment in a comparison on a real ML task, built a more rigorous experimental setup, and preserved a detailed trail for reproducibility. Along the way, it also confidently introduced an encoding bug and changed the environment on its own. Fable wrote clearer code, followed the requirements more precisely, and prepared a report that identified a pattern the experiment’s author had missed.

In computer control, Astra wins decisively. It is fast and autonomous enough to run continuously on a separate Mac Mini without requiring a manual click after every step. It also handles dozens of subagents better and reorganizes its work more quickly after feedback. Fable is more reliable at following predefined skills and constraints. In interfaces, it more often delivers an original, finished page on the first try, while Astra still likes assembling yet another neat template. Audio and video editing can stay with humans for now: the results from both are practically unusable.

In Artificial Analysis, the top-tier versions tied for first place: 53 points on the overall index and 62 on the coding-agent index. An Astra task on the overall index cost $3.26 and 27,000 output tokens. Fable required $7.63 and 78,000. Their base API pricing is identical, $10/$50, but cached input costs $0.25 for Fable and $1 for Astra. So in long sessions where the same context is constantly reread, Fable may turn out cheaper. The $200 Codex subscription still feels to me like it provides noticeably more compute than the comparable Claude plan.

That’s how I work now: Fable formulates the requirements and acceptance criteria, Astra implements the plan or pulls the project out of a dead end, then Fable checks adherence to the constraints and readability. The final say goes to tests, the browser, or some other external criterion. Without one, agents can keep correcting each other forever while arguing about style.

OpenAI is already turning this pairing from a user habit into a platform. The new Agents API gives developers the same harness, meaning the control layer for context, tools, and subagents that Codex runs on. An agent can live in an OpenAI sandbox, customer infrastructure, or a partner environment, keep working on a task for several days, run code, and save intermediate files. There is no separate charge for the API itself; you pay for models, tools, and containers.

Dozens of agents quickly run into memory limits, especially when each one drags along a long history. KV-cache stores intermediate data for all previously read tokens so the model doesn’t have to recompute the context at every next word. With a million-token context, that tail can easily consume memory faster than the model weights themselves.

vLLM demonstrated Hybrid HiSparse for models with sparse attention. As long as there is room on the GPU, the KV-cache stays there. Under load, cold pages move into system RAM, while a small hot buffer containing the necessary fragments remains on the accelerator. On GLM 5.3 with a million-token context and one node with eight H200s, at a configured 32 parallel requests, conventional offloading sustained 5–6, while Hybrid HiSparse sustained 19–25. The authors measured this on a single configuration, but the difference is large enough to be worth testing on your own traffic.

DeepSeek built a new model around the same problem. In DeepSeek V4.1 Flash, the main network has 552 billion parameters, plus another 196 billion in Engram, a memory table the model accesses selectively. Together with the accelerated decoding module DSpark and a vision encoder, the full build on Hugging Face totals 763B. During input processing, the model activates only 8 billion parameters, and during generation, 16 billion. The context window is one million tokens, the model accepts images directly, and the weights are available under MIT.

The architecture is called Causal Encoder-Decoder: the first 20 layers build a representation of the input, while the next 20 generate the response and use a shared compressed KV-cache. In the technical description, DeepSeek specifies 890 bytes of cache per token, one quarter of V4 Flash; the required SSD capacity has been reduced eightfold.

Peak API pricing is $0.30/$1.20 per million tokens, with cache hits costing $0.006. During off-peak hours, all three rates are cut in half. The old V4 Flash identifiers already route requests to the new model, and starting September 14, V4 Pro requests will also go to it until the next Pro release. The version number increased by just 0.1, but the model inside was replaced almost entirely.

OpenAI updated its image generator. ChatGPT Images 2.5 promises latency up to 50% lower than Images 2.0 and better preservation of faces, composition, and reference details across a series of edits. You can place a comment directly on the relevant area of an image, or use Sketch to rough out object placement by hand. The model is available on all ChatGPT plans, ChatGPT Work, and Codex.

Two versions appeared in the API. GPT-Image-2.5 Flare is designed for fast iteration, while Sunburst spends longer thinking through precise and complex edits. Judging by my experience with interfaces, the image only solves half the problem here: Astra can quickly assemble a working page and test it in the browser itself, but Fable is still more consistent when it comes to taste and a finished layout. The image generator doesn’t erase that difference, but it does spare both models from trying to draw the entire world as a gradient card.

Jacob Coxon, a pretraining researcher who spent the past three years at OpenAI and Anthropic, left the company and accused both labs of recklessly racing toward self-improving superintelligence. In his assessment, many people at OpenAI underestimate the stakes, while Anthropic understands the risks but still wants to get there first because it doesn’t trust its competitors.

By September 14, the main post had reached 171 million views, 797,000 likes, 205,000 reposts, and 20,000 replies. Even Senator Bernie Sanders responded: he promised to introduce a bill banning the development of superintelligence and pausing work on AI.

Anthropic published an analysis of four incidents in which Claude, during cybersecurity testing, reached real third-party systems. In every case, a contractor mistakenly left internet access open even though the models had been tasked with finding vulnerabilities in an isolated environment with no external network access. The usual safety restrictions had deliberately been disabled for the evaluation. Each run lasted from 10 to 34 hours and involved a single Claude instance, not a swarm of agents.

The most serious case involved Claude Mythos 5. The model registered a malicious package on PyPI, released three versions, and waited for installations. The package was run on 15 systems. Anthropic believes these were isolated scanners operated by security companies. One scanner exposed credentials, and Claude used them to log into a vendor’s production database. PyPI removed the package in less than an hour.

Anthropic identifies two failures: the model forced evidence of the real internet into a convenient simulation narrative and kept pursuing the task despite the possibility of harm. Pre-release auditing had not detected this behavior. METR received access to logs and employees for an independent investigation. The initial agreement runs for eight weeks and may be extended. The test conditions were artificial, safeguards were disabled, and internet access was present because of a configuration error. But it was the real internet and real third-party systems.

Meta released Muse, a personal agent that keeps working after the app is closed, opens a browser, fills out forms, sends emails, and pays for purchases. Each Muse lives in a separate cloud virtual machine together with the user’s data. Passwords and payment details are stored separately: the agent can use them but cannot see the actual values.

Meta placed a second agent, Sentinel, between Muse and the internet. It checks external actions, asks for confirmation before sending an email or making a purchase, and keeps a complete log. For now, the product is launching in the US on iOS, Android, and muse.ai, while the promised Confidential VM with full-machine encryption will arrive later. After the Anthropic story, a separate virtual computer and a bouncer at the door look like the minimum viable setup for a personal agent, not presentation decoration.

Stay curious.

I write about artificial intelligence, language models, and tools for developers. I test models and services on real-world tasks and share my findings in my Telegram channel.