In the news.

OpenAI released GPT-6 Astra on September 4, calling it their most intelligent model yet, with state-of-the-art results in computer use, browsing, software engineering, science and professional work. The launch material leans hard on agentic work: multistep workflows across code, browsers and professional software, with the promotional spot showing voice commands driving a computer directly.

One thing worth stating plainly, because search traffic suggests it is the first question people have: this is not AGI, and OpenAI is not claiming it is. Astra is a stronger model with better tool use, better token efficiency and a much lower hallucination rate. That is a meaningful engineering step, not a change in kind.

The price is the headline

Astra costs $10 per million input tokens and $50 per million output tokens. GPT-5.6 Sol was $4 and $20. That is a 2.5x increase across the board, with the existing 90 percent discount on cache reads and 25 percent premium on cache writes unchanged.

Whether that increase is worth paying depends entirely on what you are doing with it, and the independent benchmark data from Artificial Analysis splits cleanly in two.

Story one: coding agents, where it wins

In the Artificial Analysis Coding Agent Index, Astra scores 67 running in Codex. That puts it roughly level with Claude Opus 5 and Claude Fable 5 in Claude Code, and with Muse Spark 1.3 in Muse Code. Fable 5.1 in Claude Code still leads the index at 70.

The interesting number is not the score, it is the efficiency behind it. Astra uses about one third of the tokens of GPT-5.6 Sol at max effort in the same harness, and roughly one fifth of Claude Opus 5 at extra-high effort. Around 70 percent more token efficient than its predecessor.

That efficiency changes the economics. At max effort Astra costs about the same per task as GPT-5.6 Sol while scoring two points higher, and it comes in at less than half the cost of Claude Fable 5 for the same index score. For agentic coding, the higher per-token price is more than absorbed by using far fewer tokens.

Story two: general intelligence, where it does not

In the Artificial Analysis Intelligence Index, Astra scores 61, which is exactly level with GPT-5.6 Sol. It sits five points behind Claude Fable 5.1 at max effort with fallback, and behind Meta's newly released Muse Spark 1.3 at max.

Token efficiency improves here too, by around 10 percent at max effort, but a 10 percent efficiency gain does not absorb a 150 percent price rise. The result is that Astra is roughly 75 percent more expensive per task than GPT-5.6 Sol for equivalent index performance.

The result that deserves more attention

Buried under the pricing debate is the most significant number in the release. On AA-Omniscience, the knowledge and hallucination benchmark, Astra's hallucination rate falls from 92 percent to 51 percent at max effort.

Halving hallucination usually costs you accuracy, because the easiest way to stop being wrong is to stop answering. That did not happen here: accuracy rose four points at the same time. For anyone building systems where a confidently invented answer is expensive, that is a bigger deal than two points on a coding index.

It also gained about 80 Elo on AA-Briefcase, the long-horizon knowledge work evaluation that tests multi-week projects across thousands of source files, and six points on Humanity's Last Exam.

What regressed

Launches rarely advertise this part. Astra lost around 80 Elo on GDPval-AA v2, the benchmark adapted from OpenAI's own dataset covering economically valuable work across 44 occupations, almost exactly offsetting its AA-Briefcase gain. There are two to three point regressions on τ³-Banking (customer support), SciCode (scientific Python), and AA-LCR (long context reasoning over large documents). Presentation Quality Elo also dropped, with GPT-5.6 Sol still leading all models there.

Better analysis, worse presentation, and a wash on economically valuable tasks. Progress in agentic knowledge work is genuinely mixed.

What is new for developers

Three additions stand out for anyone building agents:

• Async tool calling. The model can keep reasoning, call other tools, or answer independent parts of a request while your application runs a tool. Set async: true and return the result later using the original call_id.
• Mid-turn steering. Over a WebSocket connection you can send corrections or changed requirements while the model is working, and completed work is preserved rather than discarded.
• Reasoning effort changes mid-conversation. A configuration_update input item raises or lowers effort without rewriting the prompt prefix, so prompt caching survives.

There is also asynchronous misalignment monitoring that triggers alerts, part of what OpenAI describes as strengthened safeguards for this release.

A few practical limits: the model string is gpt-6-astra, tool calling requires the Responses API, none reasoning effort is not supported, temperature, top_p and top_logprobs must be removed, and Fast mode is unavailable with EU data residency.

How to read this release

Astra is not a general upgrade you switch to everywhere. It is a specialised one.

If you are running coding agents, the token efficiency makes it cheaper per completed task than the model it replaces, and cheaper than the competition at a similar score. If you are doing general question answering, you are paying 75 percent more for the same index performance, and the reason to consider it anyway is the halved hallucination rate rather than the intelligence score.

That is the same routing logic that has applied to every frontier release this year, and it is the case I worked through when Fable 5 and GPT-5.6 launched days apart, and again when Kimi K3 arrived to undercut both. Match the model to the task. The headline score is rarely the number that decides it.

Meta Superintelligence Labs released Muse Glimmer on August 10, 2026, and the interesting part is not the size. It is a 30-billion-parameter multimodal model, distilled from the larger Muse Spark, tuned specifically for always-on local agent workflows, and it ships under a plain Apache 2.0 licence. That last detail matters more than the benchmarks: it is a genuine open-source licence rather than a custom community licence with usage restrictions attached.

The benchmarks Meta is claiming

Meta reports testing across roughly two dozen benchmarks, and says Muse Glimmer outperformed the comparably sized Gemma4-31B and Qwen3.6-27B on about half of them. The headline figures being cited:

• MCP Atlas: 75.5
• DeepSearch QA: 74.6
• WildClawBench: 47.6
• GAIA2: 43.3
• SWE-Bench Pro: 51.2, against 50.2 for Qwen3.6-27B and 36.9 for Gemma4-31B
• AIME 2026: 94.7 percent
• τ³-Banking: 23.5

Read those the way you should read any launch numbers: they are the vendor's own selection, run under the vendor's own harness. The pattern worth noting is that the strongest results cluster in agentic and tool-use benchmarks rather than raw reasoning, which is consistent with what the model was tuned for.

Why a 30B model is the interesting size

The engineering story is compression. At full BF16 precision the weights are around 58 GB, which puts them out of reach of ordinary hardware. Meta quantizes to roughly 4 bits, shrinking the language model to under 20 GB, and adds block-level speculative decoding so responses arrive fast enough to sit inside a real agent loop rather than feeling like a batch job. Meta claims minimal to no degradation on agentic tasks from that compression.

The result is a frontier-adjacent model that runs on one consumer GPU or a reasonably specced Mac. That combination, capable enough to be useful, small enough to self-host, permissive enough to build on, is exactly the case I made in why open weight models are the key to AI sovereignty. Owning the model rather than renting it stops being a principle and starts being a practical option at this size.

How to run it locally

Download the weights: the official model card is at huggingface.co/meta-models/Muse-Glimmer-30B-assistant, with community GGUF builds available for the llama.cpp-based runtimes.

Check your hardware first. Roughly what each tier needs:

Your available memory should comfortably exceed the size of the quantized file you download. If it does not, llama.cpp will still run it using partial RAM or disk offload, but generation slows down noticeably.

The easiest path (Ollama). Install Ollama, then pull and run the model from the terminal. One command to fetch it, one to start chatting, and it exposes a local API on port 11434 that most agent frameworks can point at directly. This is where I would start if you just want to see it work.

If you prefer a GUI (LM Studio). Search for the model inside LM Studio, pick a quantization that fits your memory, and download. It shows you the file size against your available memory before you commit, which saves the usual guesswork, and it can serve an OpenAI-compatible endpoint locally.

On a Mac. MLX is the native path on Apple silicon and makes good use of unified memory, so a machine with 32 GB or more handles the quantized build comfortably.

For servers or fine-tuning. Use transformers or vLLM with the full-precision weights if you have the VRAM, and Unsloth if you want to fine-tune the model on your own data without a multi-GPU cluster. ExecuTorch and llama.cpp cover the edge deployment cases.

A note on the vision side. This is a multimodal model, so the perception encoder and the KV cache both need headroom alongside the weights. If you plan to feed it images, budget memory above the bare model size rather than exactly at it.

The takeaway

Muse Glimmer is a notable release less for what it scores than for what it permits. An Apache 2.0 licence, weights you can download, and a memory footprint that fits a single GPU together mean a small team can build something real on it without asking anyone's permission or paying per token. Whether the benchmark claims hold up under independent testing is the usual open question, and worth waiting a few weeks to see. The licence and the hardware target, though, are facts rather than claims, and they are the part that actually changes what people can build.

Alibaba's Qwen team previewed Qwen 3.8-Max on July 19 at the World AI Conference in Shanghai, and alongside Kimi K3 it's the biggest model announcement of the summer: a 2.4-trillion-parameter, multimodal model that Alibaba claims trails only Anthropic's Claude Fable 5. For now it's a preview, not a general release, and most of the numbers that matter are still missing.

What is confirmed, and what is still a claim

The split matters here. Confirmed: 2.4 trillion parameters in a sparse mixture-of-experts design, text plus visual inputs, and preview access through Alibaba's Token Plan subscription and its Qoder and QoderWork platforms at a reported 10% of standard pricing. The API follows the OpenAI and Anthropic specs, like the rest of the Max line.

Still just a vendor claim: the headline "second only to Fable 5," which Alibaba stated in its own words with no benchmark table to back it, and the fuller modality list. Text plus visual is confirmed, but video, documents, speech, and image generation have all been reported without a published spec sheet, so treat the full list as unsettled.

Not disclosed at all: the active parameters per token, the context window, standalone API pricing, and any open-weight date or license.

Two labs, two opposite bets

What makes this interesting is the contrast with Kimi K3, which shipped days earlier the same week. Moonshot's Kimi K3 arrived as a 2.8-trillion-parameter open-weight release, the largest publicly known open model: you can download it, self-host it, and fine-tune it. Qwen 3.8-Max previewed as a closed, managed service, with an open-weight version promised "soon" but no date named. Same frontier, opposite strategies.

Open weights give you deployment control, fine-tuning rights, and cost management at the GPU level. A closed frontier API gives you the vendor's best model with zero infrastructure to run. I broke down where Kimi K3 actually lands against the proprietary leaders in Kimi K3 vs Fable 5 and GPT-5.6.

The number that's missing

For a sparse MoE model, the figure that decides serving cost and latency is the active parameters per token, how much of those 2.4 trillion actually fire on each request. Alibaba did not publish it. Until it does, there is no honest way to estimate what 3.8-Max costs to run at scale, which is exactly the number production teams need.

The bigger picture

Two models above 2 trillion parameters from Chinese labs in a single week is the real story. Kimi K3 at 2.8 trillion and Qwen 3.8-Max at 2.4 trillion, days apart, is a frontier race compressing its release cycles fast. For buyers, the takeaway is not to rank them yet. Neither has third-party benchmarks, so any head-to-head performance ranking is premature. Note the claims, wait for verifiable numbers, and evaluate on your own workload. We'll publish a full comparison once both have numbers you can actually check.

The long feud between Elon Musk and Sam Altman turned openly personal this weekend, with the two trading insults on X. The theater is new; the substance underneath is not. The exchange landed in the middle of the most crowded, high-stakes stretch the AI industry has seen, and it's a useful snapshot of how many fronts this race is now being fought on at once.

The back story

Musk and Altman co-founded OpenAI in 2015 as a nonprofit research lab. Musk left its board in 2018 after donating tens of millions, and later sued over Altman's move to build a for-profit structure around the lab. A California jury ruled for Altman this year; Musk has said he will appeal. The relationship had already frayed after Musk pulled OpenAI engineers toward Tesla's Autopilot effort, recruited researcher Andrej Karpathy, and pushed, unsuccessfully, to fold OpenAI into Tesla.

The competitive backdrop

What makes this more than gossip is everything happening around it. In the same stretch:

• Dueling launches: xAI shipped Grok 4.5 while OpenAI debuted GPT-5.6 Sol, and both founders spent days promoting their models. For where those models actually land against Anthropic's, see my Fable 5 vs GPT-5.6 comparison.
• Dueling IPOs: SpaceX, which Musk has bundled with X, xAI, and Starlink, completed a record IPO reported to raise around $75 billion, pitching space-based data centers and enterprise AI. OpenAI has filed confidentially for an IPO of its own.
• Lawsuits on lawsuits: Musk sued both Apple and OpenAI, alleging anti-competitive behavior that he says pushed Grok down the app-store rankings. Separately, Apple reportedly sued OpenAI over alleged theft of trade secrets.
• M&A: SpaceX is pursuing a roughly $60 billion all-stock acquisition of the AI coding tool Cursor, aimed squarely at Anthropic's Claude Code and OpenAI's Codex, pending regulatory review.

Any one of those would be a big story. They are all happening at once, to the same two people.

Then it got personal

Against that backdrop, the weekend's posts were pure spectacle. Reacting to news of Apple's suit against OpenAI, Musk revived his "Scam Altman" nickname and piled on, at one point joking that Altman "might literally love scamming more than any human alive." Altman hit back at Musk's space-data-center pitch: "homeboy, you're the one selling public market investors on short-term space datacenters," a post that drew more than 11 million views. Musk's reply leaned into a personal jab about a parole officer. Altman, for his part, reframed the whole thing as a compliment to his new model: "there are a lot of benchmarks that suggest 5.6 sol is the best model in the world right now, but the most reliable way to tell is that elon is obsessed with me again."

The takeaway

Strip away the insults and this is what a maturing, cash-flooded market looks like when a handful of players fight on every axis at once: models, capital markets, app-store placement, talent, acquisitions, and the courts. The personal drama gets the views, but the real signal is the breadth of the competition. When rivals are this evenly matched and this well funded, the fight stops being about a single benchmark and starts being about everything at once. That's good for buyers, who get faster models at lower prices, and exhausting for everyone building in the middle of it. For now, no one in this race gets to coast, and the ones who can't out-ship start trying to out-litigate.

Worth noting: the lawsuits described here are allegations that have not been decided in court.

Google Cloud has published the Open Knowledge Format (OKF), an open specification for packaging a company's internal knowledge so AI agents can actually use it. The simplest way to describe it: a wiki, but built for machines instead of people. OKF takes the context that foundation models need, table schemas, metric definitions, runbooks, the join paths between systems, and stores it as plain markdown files with a little structured metadata, in a portable format no single vendor owns.

The problem it solves

Every team building AI agents hits the same wall. A model is only as good as the context you feed it, and in most organizations that context is scattered: in metadata catalogs with proprietary APIs, in wikis and shared drives, in code comments, and in the heads of the engineers who know how things actually work. So every agent builder reassembles that context from scratch, and the knowledge stays locked inside whatever tool happened to hold it. OKF is an attempt to give that knowledge one open, shared home.

How it works

OKF v0.1 is deliberately plain. It's a directory of markdown files, each with a short YAML header, plus a few conventions. A file might describe a dataset, a table, or a metric. The only required field is type. Markdown links between files create a graph of relationships, so a table can point to the columns and the metrics that depend on it. There's no runtime, no SDK, and no account required. If you have ever kept a folder of markdown notes, you already understand the shape of it.

A wiki, but for AI

The idea isn't new, and Google is candid about the lineage: OKF formalizes the "LLM wiki" pattern that Andrej Karpathy described. His observation is the whole point. Personal wikis fail because humans get bored maintaining them, forget to update cross-references, and won't touch fifteen files to keep one fact consistent. Those are exactly the chores an LLM does not mind. As Karpathy put it, "LLMs don't get bored, don't forget to update a cross-reference, and can touch 15 files in one pass."

So here is the honest comparison with an ordinary wiki:

• A normal wiki is knowledge organized for humans to browse and edit. It's flexible, prose-first, and tolerant of mess.
• OKF uses the same building blocks, pages, links, and plain text, but organizes them so machines can read and maintain them reliably: a required type on every page, structured metadata, and a link graph an agent can follow.

It's less "a new database" and more "a wiki whose full-time editor is an agent." The producer who writes the knowledge and the consumer who reads it are cleanly separated, and because it's just files, the knowledge survives changing tools and vendors.

Why it matters

Two things make this worth watching. First, it's vendor-neutral by design, a format, not a platform, which is the only way a knowledge standard ever gets adopted across an industry. Second, it targets the real bottleneck in agentic AI right now. Models keep getting better; what limits them is context, the specific, messy, internal knowledge that never made it into training data. It's the same problem the context layer of a modern agent exists to solve. Google is shipping reference pieces already, an enrichment agent for BigQuery and a simple HTML visualizer, and has wired OKF into its Knowledge Catalog.

For anyone working where I do, at the seam between operational data and AI, the interesting question is obvious: the same pattern that describes a sales table could describe a plant's tags, its historian, and the meaning behind an alarm. A portable, agent-readable knowledge layer over industrial data is exactly the missing piece between getting the data to the cloud and an agent that can actually answer questions about the plant.

The bottom line

None of this is exotic technology, and that's the point. The bet behind OKF is that the format for agent knowledge should be boring, open, and text, so it can spread. Whether it becomes the standard or just one more proposal depends on adoption, but the problem it names, that agents are starved of the context sitting all around them, is the right one.

On July 9, Anthropic lifted the 5-hour and weekly usage limits on Claude Fable 5 for all users, just days before the model's inclusion in the Pro, Max, Team, and premium Enterprise plans ends on July 12. After that date, extra usage will require credits, priced at $10 per million input tokens and $50 per million output tokens.

The immediate reaction

Developers largely cheered the temporary reprieve, but the mood was mixed. Some read the timing, a generous unlock right before a paywall tightens, as a sign of pressure rather than confidence, with a few calling it a bid to hold users amid intensifying competition. Others simply noted that cheaper rivals are now a serious option: OpenAI's GPT-5.6 and xAI's Grok 4.5 both undercut Fable 5 on price, and switching is easier than it used to be.

Why a rate-limit tweak is really a competitive signal

It's worth stepping back, because a change to usage limits sounds like housekeeping and is actually a market move. In today's AI race, no provider sets pricing or limits in isolation. Every one of them is watching the others: a price cut from OpenAI, a capability jump from xAI, a new tier from Google, and the rest respond within days. Fable 5 is a strong model, but at $10/$50 per million tokens it sits at the premium end (the pricing I broke down in Opus 4.8 vs Fable 5), and GPT-5.6, which runs from $5/$30 down to $1/$6 for its Luna tier, plus Grok 4.5, give cost-sensitive teams a real alternative. Loosening limits right before a paywall is exactly the kind of close-quarters maneuver this market now runs on.

The bigger picture

The takeaway isn't about one rate-limit reset. It's that the frontier has gotten crowded enough that holding users is as hard as winning them. With three or four labs shipping comparable models within weeks of each other, switching costs are falling and pricing power is thin. For buyers, that competition is good news: more capability, lower prices, and providers who have to keep earning your usage. For the providers, the next few quarters won't be easy for anyone. Right now, no one gets to coast.

OpenAI will publicly release its GPT-5.6 family, Sol, Terra, and Luna, on July 10, following U.S. Department of Commerce approval after government testing addressed cybersecurity concerns.

The three models

• Sol: the flagship, aimed at complex reasoning, coding, and agentic tasks, priced at $5 input and $30 output per million tokens.
• Terra: GPT-5.5-level performance at roughly half the cost.
• Luna: optimized for speed and high-volume work.

Early reactions

Early testers have been largely positive. Theo praised Sol's fixes for iOS development and computer use. Others, including Matt Shumer, noted that Claude Fable 5 still edges it out on certain agentic tasks.

Why it matters

The launch ends a limited preview that began June 26 and arrives with enhanced safeguards, a recurring theme as competitive pressure in the AI race keeps rising. For teams choosing models, GPT-5.6 adds a three-tier lineup, flagship, mid, and fast, that maps neatly onto the same route-by-task logic I wrote about in Opus 4.8 vs Fable 5: reserve the expensive flagship for hard, autonomous work, and push routine, high-volume jobs to the cheaper, faster tiers.

StartFragment

Google has introduced TabFM, a zero-shot foundation model built specifically for the structured, tabular data that lives in spreadsheets. Instead of training a fresh model for every dataset, it uses in-context learning to predict missing values from just a few examples, with no manual feature engineering and no hyperparameter tuning.

How it works

Traditional approaches like XGBoost need careful feature engineering and tuning for each problem. TabFM treats the rows of a table as a prompt: you show it a handful of labeled examples, and it predicts the rest in a single pass. The same model handles both classification and regression, so one tool covers "which category" and "what number" questions alike.

Why it matters

• It runs on modest hardware while staying accurate, so it does not demand a GPU cluster.
• Benchmarks indicate it outperforms many specialized models on common scenarios like pricing prediction.
• The one-shot setup means faster answers for data-heavy fields like banking, healthcare, and industrial operations.

The bigger picture

The generative AI wave has mostly touched text, code, and images. TabFM points it at the massive, unglamorous world of plain rows and columns, which is the format most real operational data actually lives in. For anyone sitting on years of spreadsheet and historian exports, that is the interesting part: data analysis without building a bespoke model for every question

EndFragment

Fable 5 is one of the most capable AI models on the market, but for teams and developers outside the US, its pricing can feel steep. The good news: with the right configuration choices, it is possible to cut costs by more than 80% without sacrificing meaningful output quality.

Tune your effort level first

The fastest lever is the model's "effort" setting, available in agent tools like Hermes Agent and Claude Code. The spread between tiers is significant:

• Max effort: about $22.00 per task
• Low effort: about $3.76 per task

That is an 82% reduction simply by stepping down a tier. Testing against a demanding prompt, vanilla JavaScript, physics-based motion, and a seamless 8-second animation loop, showed that even the Low setting produced clean, usable results, though it skipped some of the finer visual detail higher tiers include.

Interestingly, "Max" is not always "best." In side-by-side tests, the High (about $9.18) and Extra tiers frequently produced richer, more layered output than Max, which sometimes rendered overly minimal due to its clean-geometry bias. The practical takeaway: start at High and adjust up or down based on the specific task, rather than defaulting to Max.

Use Fable 5 as an architect, not a laborer

A second strategy goes beyond effort settings: change how the model is used. Instead of having Fable 5 handle a task end to end, planning and execution, reserve it strictly for high-level architecture and reasoning.

Under this workflow:

• Fable 5 designs the plan or blueprint.
• A cheaper or local model (for example Qwen 72B) executes the heavy lifting: coding, tool calls, and repetitive work.

This lets teams tap Fable 5's reasoning strength where it matters most, while routing labor-intensive execution to lower-cost infrastructure.

The bottom line

Frontier-model performance does not have to come with a frontier-model price tag. By calibrating effort levels, often landing in the mid-to-high range rather than Max, and by treating Fable 5 as a planner rather than a full-stack executor, users can achieve elite results while keeping costs under control.