Tari Ibaba

This is completely crazy — how can a model be this good?

OpenAI is sending shockwaves across the entire AI ecosystem with the new GPT-6 Astra.

The things it’s doing are really scary.

It has destroyed so many benchmarks now — rendered them obsolete — the benchmarks were not even good enough to properly measure how intelligent it is.

So many major models dropped in the past few days and this is by far the best.

It’s already the best coding model in the world.

And not just coding but so many other things like 3d graphics and world generation.

1. This is basically AGI

This was just shocking.

An unbelievable 99.9% on ARC-AGI-3 — a benchmark tests whether an AI can face a new problem and figure out how it works.

Compare to a measly 7.8% from GPT-5.6 Sol — and 30.2% from Opus 5.

Even human testers couldn’t compare — the average human tester scored around 48%.

And once again we see another occurrence of a really important AI trend.

Astra didn’t get this huge jump from intelligence aloneOpenAI also gave it a much better state-preserving harness.

The harness helps Astra keep track of what it has learned as it works through a long task. It doesn’t have to keep starting over or rebuild its understanding from old context.

The model is getting smarter. But the system around the model is also getting much better.

2. It’s already a coding monster

Astra is also ridiculously good at coding.

On Terminal-Bench 4.0 it scored 57.9%. Claude Fable 5.1 scored 55.8% while GPT-5.6 Sol managed just 37.3%.

Astra also did it cheaper.

Its estimated API cost per task was around 9% lower than Sol and 63% lower than Fable 5.1 at the tested settings.

Then there’s DeepSWE v1.1.

This benchmark tests difficult software engineering work inside real codebases.

Astra scored 74.1%. Sol scored 72.7% while Fable 5.1 scored 67.4%.

3. Much better instruction following

Astra is also better at knowing when it needs more information.

If your instructions aren’t clear it is more likely to ask a question instead of guessing.

That sounds small — until you give an AI control of your computer.

4. Massive upgrade in computer use

This might be Astra’s most important improvement.

On OSWorld 2.0 Astra scored 72.6% and took around 40 minutes per task.

Compare to Sol which scored 65.7% and took around 75 minutes.

So Astra spent about 47% less time per task while getting more tasks right.

That’s a huge jump.

Astra also scored 92.7% on ScreenSpot-Pro. This benchmark tests whether an AI can find the right buttons and other elements inside screenshots of professional software.

Then there’s Agents’ Last Exam.

It tests AI agents on real professional work like financial modeling. It also covers engineering and media production.

Astra scored 59.3%.

Claude Opus 5 scored 55.5%. Sol scored 53.6%.

Astra also used around 65% fewer output tokens than Opus 5 at their highest-scoring settings.

AI isn’t just getting better at answering questions anymore.

It’s getting better at doing the work.

5. Astra is scarily good at hacking

This is where things get a little scary.

On ExploitBench Astra scored a perfect 100%.

The benchmark tests whether an AI can turn known software vulnerabilities into working exploits.

Sol scored 78.5%.

Astra got every one.

Its cyber skills are now so strong that OpenAI classifies Astra as its first broadly released model to reach its “Critical” cybersecurity capability level.

But here’s the interesting part.

OpenAI also ran an ExploitGym honeypot test.

The researchers placed vulnerable targets outside the agent’s assigned task. They then checked whether the AI would attack them to reach its goal.

Sol exploited those honeypots in 48.2% of relevant runs.

Astra did it 0% of the time.

So Astra is much better at hacking — but it also seems much better at knowing what it shouldn’t hack.

That’s a very important combination.

Overall this is definitely going to be one of the most transformative models of 2026.

This is HUGE.

The new Claude Fable 5.1 is absolutely insane.

It absolutely dominated every single model on the AI Arena Leaderboard — ranking an undisputed #1 👇

The gap is so massive, wow — Anthropic just unlocked a new standard of model intelligence.

And it’s much cheaper than Fable 5 — yet much more intelligent — just look at the massive difference on the leaderboard.

It found deep hidden bugs in codebases that humans couldn’t find for several years.

And it comes with an even more powerful sibling model.

1. Exceptional long-horizon coding and debugging ability

Fable 5.1 is amazing at working on hard problems for hours without losing focus.

It’s exceptional at long-horizon tasks — jobs that involve many steps and tools and can take hours to finish.

And some of the early tests are wild.

In one case Fable 5.1 reportedly found a rare software bug that engineers had struggled to fix for almost five years. It traced the problem back to an external vendor library.

In another test Ramp gave Fable 5.1 a machine learning problem and left it running for 38 hours.

The model reviewed its results and spotted a problem with its earlier work. It changed direction and launched six experiments overnight — then came back with its findings and next steps.

2. Much cheaper and more intelligent than Fable 5

There’s one obvious problem with an AI agent working for 38 hours…

It can get expensive.

Fable 5.1 keeps its base API price at $10 per million input tokens and $50 per million output tokens.

But Anthropic cut prompt cache read costs by 75% — from $1 to just $0.25 per million tokens.

This matters for AI agents because they often reuse the same information. That could include source code or instructions and project documents.

Instead of paying full price to process that information again and again the agent can use cached context.

Anthropic says this can cut typical Fable 5.1 costs by around 25%. For heavily agentic workloads the savings can reach about 45%.

So Anthropic isn’t just making agents that can work longer — it’s making them cheaper to run.

3. Much better at finding security bugs

Anthropic also reworked Fable 5.1’s cybersecurity safeguards — cutting false positives by 60%.

That means security engineers should hit fewer unnecessary refusals when scanning code for vulnerabilities.

Fable 5.1 can now find security flaws directly in source code — including potential zero-day vulnerabilities.

But Anthropic still limits higher-risk tasks like turning those flaws into usable exploits.

4. Granular adaptive thinking

Fable 5.1 also gives developers more control over how much effort the model puts into a problem.

It uses adaptive thinking.

Developers can change its reasoning effort during a conversation without breaking the prompt cache.

That’s useful because not every part of a long task needs the same amount of thinking.

Finding a strange bug might need deep reasoning. Changing a simple configuration file probably doesn’t.

So developers can use more compute when Claude hits something difficult — then dial it back for easier work.

That gives them more control over speed and cost.

5. Fable 5.1 has an even more powerful sibling

Anthropic also launched Claude Mythos 5.1 — a sibling model.

Anthropic says Fable 5.1 and Mythos 5.1 use the same underlying model. What changes is the safety layer around them.

Fable 5.1 is the version most people can use.

Mythos 5.1 targets vetted researchers who work in sensitive areas like advanced cybersecurity and life sciences. Those researchers can use capabilities that Anthropic restricts more heavily in Fable.

It’s an interesting idea — the intelligence stays largely the same while the safety boundaries change depending on who uses it.

Claude Fable 5.1 is hands-down going to be one of the most game-changing releases of the year.

This new Qwen 3.8 Flash Next model is an incredible positive sign of where the AI race is heading.

The model seriously punches above its weight in so many ways.

It’s beating Claude models that cost so much more to train and have several hundreds of billions more in parameter size.

Can you believe it — this model only activates like 6 billion parameters at a time — yet it’s matching up to all those massive closed-source models with trillions of parameters.

Barely beat by Claude Fable and GPT-5.6 Sol:

Qwen3.8-Flash-Next scores 56 on Artificial Analysis’ Intelligence Index, far above the median score of 29 for open-weight models of a similar size.

This is what’s so incredible about it — it’s not the absolute smartest model out there — but it’s hands down one of the most efficient.

We saw this with GLM-5.3 too — companies are no longer so obsessed with absolute intelligence and parameter size — they are now competing in radical efficiency and innovative training techniques.

And it’s just a new model or typical update — it’s actually a stepping stone for the future generation.

Qwen 3.8 Flash Next is actually an experimental preview of the upcoming revolutionary Qwen 4 model.

And Alibaba (the makers) refused to follow the same old formula of training a bigger model and spending more and more on compute.

They didn’t focus on parameters — instead they redesigned several fundamental parts of the model from the ground up to drastically improve the efficiency.

Qwen3.8-Flash-Next’s 62.5% score on SWE-bench Pro, compared with Claude Opus 4.6 Max’s score of 53.4%, demonstrates the model’s highly competitive performance on complex, real-world software engineering tasks

And what you get is a model with frontier-level benchmark performance that can run entirely on local hardware and costs dramatically less to train than its predecessor.

You can run it entirely locally

Qwen3.8-Flash-Next is also open-weight, meaning you can download and run quantized versions without relying on a cloud API.

Community MLX builds are already running it on Apple Silicon.

Current conventional 4-bit builds generally require around 100GB of unified memory — but you can run it on much less powerful devices by increasing the quantization.

Apple’s new M5 Ultra Mac Studio is particularly powerful for running models locally. You can configure it with as much as 512GB of unified memory and 1.2TB/s of memory bandwidth.

So with enough memory you can run Qwen3.8-Flash-Next completely locally: no per-token API fees and no private documents or prompts leaving your computer.

It cost roughly one-ninth as much to train

Alibaba says training Qwen3.8-Flash-Next needed only around one-ninth of the training cost of Qwen3.7-Plus — even with the newer model outperforming its predecessor across several important areas.

That efficiency comes from a radically different architecture.

The model’s main network contains 125 billion parameters, accompanied by roughly 51 billion parameters of N-gram embeddings.

But it only activates around 6 billion parameters per token.

That’s possible because Qwen3.8-Flash-Next uses a sparse Mixture-of-Experts (MoE) architecture. Instead of running the entire network for every token, it dynamically routes each token through only the experts required for that particular computation.

The result is enormous overall model capacity without paying the computational cost of activating everything simultaneously.

Completely rebuilt architecture

MoE isn’t the only major change.

Qwen3.8-Flash-Next introduces fundamental changes across attention, residual connections, embeddings and optimization.

Its hybrid attention architecture combines Gated DeltaNet, a form of linear attention, with a new mechanism called Qwen Sparse Attention (QSA).

Rather than repeatedly examining everything inside an enormous context window, QSA uses a lightweight indexer to locate relevant information.

That helps the model maintain high inference speeds and relatively low memory requirements across extremely long prompts. It natively supports 262,144 tokens, extendable to 1 million tokens using YaRN.

Alibaba has also introduced Gated Residual, which expands the residual stream into four dynamically controlled branches, and billions of N-gram embedding parameters that increase capacity without requiring equivalent active computation.

It all comes down to one thing:

More intelligence without proportionally more compute.

This is really a preview of Qwen 4

And this might be the most important part.

Alibaba calls Qwen3.8-Flash-Next an early preview of the architecture that will power Qwen4.

So as a developer you get to test these ideas before the full Qwen4 family arrives.

The direction is pretty clear.

For years AI companies mostly chased better models by adding more parameters and more compute.

Qwen3.8-Flash-Next asks a different question.

What if you could get much more intelligence from much less compute?

If this really is the foundation for Qwen4 — things are about to get very interesting.

The biggest limitation of every AI coding assistant isn’t intelligence.

It’s not how much code it can right or how fast it responds.

It’s context.

What happens as software projects grow?

Conversations become longer, repositories become larger, and the amount of information the model needs to juggle explodes.

Architecture decisions, coding conventions, debugging discoveries, terminal output, documentation, and previous discussions all compete for the same finite context window.

That’s why Claude Code attacks this problem from multiple directions to generate the highest quality code possible.

It doesn’t just give you a larger context window — it provides wide of range of tools that intelligently manage what the model knows, remembers, and carries forward between sessions.

Let’s look at five of most powerful context management features, from quick context branching, to automatic features that most developers take for granted.

1. Your context shouldn’t increase with every new message

I made this mistake a lot in the past.

I would ask Claude Code a lot of small, unrelated questions in the middle of a long coding session.

Questions that would become a permanent part of the context — despite having no long-term value beyond the moment I asked them.

I didn’t realize how much context I was wasting.

But thankfully we have now have the /btw command to fix this exact problem in Claude Code.

It lets you ask a quick side question that has full visibility into your current conversation without adding the question or answer to your chat history. Instead, Claude shows the response in a temporary overlay that disappears when you’re done.

Asking questions on our changes with /btw:

That means you can ask things like:

• “What was that config file called?”
• “Why did we choose this approach?”
• “Which function handles authentication?”

…without cluttering your main conversation.

When we press Enter, the btw message disappears and we’re back to our normal conversation:

For long-running coding sessions, /btw helps keep your context focused on the implementation while still giving you instant access to everything Claude already knows about your project

2. Your Claude Code sessions don’t have to start from zero

You don’t have to being every new conversation with Claude Code from scratch.

Its Auto Memory system allows Claude to accumulate useful project knowledge over time.

As you correct mistakes, establish workflows, or repeatedly teach it project-specific conventions, Claude can save those learnings automatically and reload them in future sessions.

Instead of repeatedly explaining things like:

• build commands
• debugging workflows
• environment quirks
• preferred implementation patterns

Claude gradually learns them itself.

Over time, the assistant becomes increasingly tailored to your project with almost no manual effort.

3. Claude can’t figure everything out by itself

You can teach Claude Code how it’s done.

If Auto Memory learns automatically, CLAUDE.md is where you teach Claude deliberately.

It’s like permanent briefing document for your project.

Rather than re-explaining your coding standards, testing strategy, deployment workflow, or naming conventions every session, you simply write them once inside a CLAUDE.md file.

A sample CLAUDE.md file for Claude Code:

Every new conversation begins with that context already loaded.

A good CLAUDE.md might include:

• coding conventions
• important design decisions
• common team-specific workflows
• “always” and “never” rules

The more mature a project becomes, the more valuable this file gets.

4. What does Claude Code do when context gets out of hand?

Most AI tools simply start forgetting earlier parts of the discussion as context approaches the limit.

Claude Code does something much smarter — automatic context compaction.

As the context window fills up, it automatically compresses older portions of the conversation into a concise summary while preserving the important decisions, discoveries, and reasoning that led there.

Instead of carrying hundreds of thousands of tokens forever, Claude keeps the essential information while freeing space for new work.

This allows coding sessions to continue far longer without suffering the dramatic quality drop that often occurs when context windows become overloaded.

5. What can *you* do when context gets out of hand?

Claude doesn’t have sole control — you can also take manual control of your context — with multiple commands.

The /compact command tells Claude to summarize the current conversation immediately.

It’s perfect after finishing a large feature or debugging session. You preserve everything important while dramatically reducing context usage before moving on to the next task.

But somethings you don’t even want any previous conversation at all.

That’s where /clear comes in.

It starts a fresh conversation with an empty context window while still keeping your persistent project knowledge—such as CLAUDE.md instructions and Auto Memory—intact.

Think of it as wiping the whiteboard clean without forgetting everything you’ve learned about the project.

Claude Code’s approach isn’t just about having more context — it’s about using context intelligently.

Together all these features let Claude spend its attention on what matters most, making long-running development sessions feel remarkably consistent even as your projects grow in size and complexity.

Wow so we just discovered who was behind the incredible Ox Alpha stealth model all along!

It turned out to be none other than GLM-5.3 Flash from Z.ai in the end — so many Google fanboys were really disappointed from it not being Gemini.

It’s an absolutely incredible model that completely destroys its GLM-5.2 predecessor and other top-tier models — while being several times faster.

GLM-5.3 Flash has one of the lowest hallucination rates of all the models — and it’s more powerful than all the models in this list with lower hallucination rates:

GLM-5.3 Flash ranked an incredible 4th place on the AI Arena web dev leaderboard — despite several times cheaper than all the models above it:

“GLM-5.3-Flash delivered a major leap on DeepSWE v1.1, scoring 63.4 versus GLM-5.2’s 46.2 and outperforming Claude Opus 4.8 (58.0) and DeepSeek-V4-Vision-Exp (59.3), while coming within reach of Gemini 3.7 Flash (65.3) and GPT-5.6 Terra (69.6) — a remarkable result for an open-weight model built around efficient inference.”

And the shocking thing is that it does all this while being more than 900% more efficient than GLM-5.2 in operating costs.

GLM-5.3-Flash delivers a remarkable leap in cost efficiency, operating at roughly one-tenth the cost of GLM-5.2 — an improvement of more than 900% in operating-cost efficiency

And the secret behind this massive improvement lies in its state-of-the-art architecture.

GLM-5.3 Flash uses a new sparse attention technique to dramatically improve how the underlying transformer model processes text.

By combining linear attention for efficient local processing with sparse attention for selective long-range retrieval, GLM-5.3-Flash maintains strong long-context performance while significantly reducing the computational cost of traditional attention

Z.ai also built something called IndexPool to drastically reduce the amount of memory it uses — making it more than 4 times more efficient than even the standard GLM-5.3.

Through IndexPool, GLM-5.3-Flash compresses key representations across long contexts, cutting attention computation by roughly threefold and shrinking the KV cache by 4.4× compared with GLM-5.3 — significantly reducing the computational and memory costs of long-context inference.

Then there’s the Mixture-of-Experts design which lets it only activate the actual parameters it needs for every task.

Through its Mixture-of-Experts architecture, GLM-5.3-Flash contains 320 billion parameters while activating only 18 billion for each token — delivering the capabilities of a massive model without requiring its entire parameter set for every computation

So with all this you can definitely see why its so much more efficient than so many other models.

And with all this innovation and intelligent, it still comes with completely open weights — with the highly permissive MIT license.

Released as fully open weights under the permissive MIT license, GLM-5.3-Flash gives developers broad freedom to deploy, modify, and commercialize the model, with native integration across leading inference frameworks including SGLang and vLLM

So you can download and run it locally — though this one is definitely way too massive for an everyday PC.

And there’s something really fascinating that happened.

Before the official launch Z.ai secretly released GLM-5.3-Flash as Ox Alpha through OpenCode and OpenRouter. Millions of developers tested the model without knowing who was behind it.

And now Z.ai is saying that they processed all that traffic on state-of-the-art Chinese-made AI chips.

And it’s not just about the chips themselves — but how they made the made the model run on the chips.

They used sophisticated techniques like quantization and parallelism — to reduce memory usage and elevate performance.

By combining W8A8 quantization, tensor parallelism and specialized worker pools for different stages of inference, Z.ai built a highly optimized serving system that improved end-to-end performance by 3× while making large-scale deployment significantly more efficient

Z.ai says GLM-5.3 helped its engineers improve a lot of code and infrastructure they used to run GLM-5.3-Flash.

That means we are also getting closer and closer to the possibly ominous singularity stage — where AI starts becoming intelligent enough to improve itself — which leads to an more intelligent AI that can improve itself even better and so on.

All in all this is going to be such a game changing model in the AI ecosystem.

The new Grok 4.6 model is amazingly good at coding.

Elon Musk’s xAI trained it on billions of real developer interactions and and code editing patterns — thanks to their recent acquisition of the Cursor IDE.

It now performs as good as top-tier models like GPT-5.6 and Opus 5 the vast majority of the time — yet it’s multiple times cheaper.

And Grok 4.7 is already coming very soon too — with big promises of it “exceeding all current models” from Musk.

Grok 4.6 scores an incredible 5th place on the AI Arena Leaderboard — despite being much cheaper than most of the model above it — only Qwen 3.8 Max is as cheap as it (same price).

On CursorBench v3.2, Grok 4.6 Extra High took the top spot with 70.8%, edging out Fable 5 Max at 70.5% and Opus 5 Max at 70.0%, while comfortably beating GPT-5.6 Sol Max at 67.2%

It comes with major upgrades in software engineering and long-horizon agentic coding.

Grok 4.6 combines frontier-level benchmark performance with aggressive pricing, long-running agent capabilities, deep Cursor integration, and stronger visual application development.

It can carry out the most complex tasks in the most complicated codebases imaginable.

Grok 4.6 is designed to execute extended, multi-step workflows. It can use tools, navigate large codebases, research unfamiliar topics and maintain context across long sequences of actions.

It also has much stronger self-verification.

Grok 4.6 is much better at checking its own homework: xAI reports more self-testing and verification on long-running tasks, alongside a jump from 54% to 65.9% on DeepSWE v1.1 and 47.1% to 57.5% on APEX-Agents versus Grok 4.5.

And this fixes one of the biggest weaknesses of autonomous AI agents: small mistakes accumulating across long workflows.

It also has a 500K context window — something I was really surprised about — cause these days 1 million is like the standard. But it’s still quite a lot.

With a 500,000-token context window, Grok 4.6 can keep roughly 375,000 words of text in context at once—equivalent to about five full-length novels—giving long-running agents far more room to work without losing the plot

It’s a lot more intelligent than it’s predecessor — even though it costs exactly the same — giving much more intelligent per unit cost.

It scores 61 on the Artificial Analysis Intelligence Index, up from Grok 4.5’s 56 and placing it among the highest-performing models in SpaceXAI’s published comparison.

Grok 4.6 was trained from the ground up on the actual real-world code and developer patterns from Cursor — so it could achieve the best results possible as a coding agent.

Its training included high-quality engineering data and supervised fine-tuning trajectories covering software engineering, reasoning, STEM and agent workflows.

It used sophisticated techniques like reinforcement learning to deeply understand how we actually code and work as developers.

SpaceXAI then applied agentic reinforcement learning across environments including general coding, kernel optimization, web development and computer-aided design.

It also amazing at coding with visual input data — which makes it especially powerful for web design and frontend development.

Give it a high-level product idea, and the model can establish an application’s structure and visual language, implement its core interactions and then refine the result through subsequent iterations.

You can build unbelievably sophisticated games and 3d web experiences with very little prompting.

You can just describe what you want to build and let the Grok-4.6-powered agent work out all the architecture, interface and implementation.

xAI is still a serious contender in the AI race — and Grok 4.6 is definitely worth giving a try, for coding and many other use cases.

The crazy thing is that nobody knows exactly who is behind it — just a cryptic name of Ox Alpha.

But it’s already scoring amazingly in several benchmarks — even beating Claude Fable and GPT-5.6 Sol in critical areas.

An initial evaluation using 10 DeepSWE coding tasks found that Ox Alpha completed eight, producing an 80% result on that subset. In the same comparison, Claude Fable 5 scored 65%, GLM-5.3 62%, Grok 4.6 62%, and GPT-5.6 Sol 52%.

Some people think it’s Gemini 3.5 Pro or 4, others are saying it has to be GLM-6.

But they’re literally offering the first 100 trillion tokens of usage for free — so clearly they have to be a huge company with deep pockets.

Backed by a provider claiming an unprecedented serving capacity of 100 trillion tokens per day, Ox Alpha offers near-unlimited free inference at an industrial scale that allows developers to run massive agentic workflows and long-horizon tasks without compute bottlenecks

And of course it has a 1 million token context window — something that’s quickly becoming standard across models.

Maybe they temporarily removed the “safeguards” to avoid being detected like this? 😅

One of Ox Alpha’s biggest features is its 1,048,576-token context window, alongside an output limit of approximately 131,072 tokens.

So it will have more than enough room for all your massive codebases.

That makes it particularly interesting for AI agents. Developers can feed the model substantial software repositories, documentation, issue histories, and specifications in a single context.

It also has full multimodal reasoning.

Ox Alpha isn’t limited to text. It natively supports text, images, and video, alongside tool calling and structured outputs.

So for example you can provide a UI wireframe and ask the model to implement it, or feed it a video recording of a software bug instead of explaining the problem manually.

It also uses the sophisticated Mixture-of-Experts (MoE) architecture — which let’s it achieve the intelligence of a massive model at a fraction of the computational cost and latency.

By deploying a Mixture-of-Experts architecture that routes tokens through approximately 40 billion active parameters out of a massive 744 billion total parameter pool, Ox Alpha delivers the world-knowledge capacity of a ultra-large model with the high inference speed needed to process up to 100 trillion tokens daily

I’ve really been noticing this growing trend of releasing stealth AI models — and I can definitely see why they do this.

When you don’t know who exactly is behind the model, you’re less likely to suffer from a preconceived bias of models from a certain company being better or worse.

Releasing a model without revealing its creator gives AI companies an enormous blind test. Developers benchmark it, discover weaknesses, stress-test its infrastructure, and compare it with competitors without being influenced by the company behind it.

And of course it’s also great for marketing — especially in a case like this that the model is doing particularly well — like a mysterious genius that every is going crazy about.

It also creates powerful marketing. Instead of announcing Ox Alpha with a conventional launch event, its creators have given the internet a mystery to solve.

It’ll be really interesting to see who the creators end up being and what more they have in store for us and the AI race.

It was only a matter of time.

This new local model is sending shockwaves across the entire AI ecosystem.

The new Qwen 3.8 27b model just shattered the boundaries of everything we thought was possible with local AI models.

A model that’s small enough to run on a local Macbook for FREE — yet matching up amazingly with supercomputer-powered models like Claude Opus 4.6 Max.

You can power Claude Code and all your agentic tools at zero cost.

A local model is now beating all these recently released top-tier models that run in the most powerful data centers in the world:

Qwen3.8-27B delivers frontier-level agent performance at a fraction of the size, scoring 61.7% on SWE-bench Pro and 84.3% on OSWorld-Verified versus Claude Opus 4.6 Max’s reported 53.4% and 72.7%, while also surpassing Qwen3.7-Plus (57.6% and 73.3%) on key agentic benchmarks

It’s really exciting to see where the AI landscape is heading — we’ve seen open-source models catch up with closed-source models — now we are starting to see local models start to give major competition to cloud-hosted models.

This is by far the most efficient AI model ever created — we’ve never seen this level of intelligence from a model this tiny.

At 27 billion parameters, Qwen3.8-27B can be compressed to roughly 16–19GB with GGUF quantization — putting it within reach of high-end consumer GPUs like the NVIDIA RTX 4090 and 5090, as well as Apple Silicon Macs with enough unified memory.

The improvements are unbelievable in coding and autonomous agent tasks.

Qwen3.8-27B scores 61.7% on SWE-bench Pro, up from 53.5% for Qwen3.6-27B and ahead of Qwen3.7-Plus at 57.6%. On DeepSWE 1.1, the jump is even larger: 42.2 versus 13.3 for its predecessor.

Computer use is equally impressive.

Qwen reports 84.3% on OSWorld-Verified and 81.9% on AndroidWorld, benchmarks that test whether AI agents can visually understand and operate desktop and mobile interfaces.

Qwen3.8-27B is built from the ground up to see an interface, reason about what to do, use tools, write software and execute long sequences of actions.

And does all of this with breathtaking speed — thanks to its unusual hybrid architecture, which combines something called Gated DeltaNet with conventional Gated Attention.

Normally, AI models get super slow and laggy when you feed them long documents or big files — because the their transformer algorithm usually forces them to re-read and compare every single word to every other word.

Qwen 3.8 fixes this slowdown by using a smart 3-to-1 tag-team system across its 64 layers:

• 3 Fast-Skimmer Layers (DeltaNet): These three layers zip straight through long lines of text at high speed, saving a ton of computer memory.
• 1 Deep-Thinking Layer (Standard Attention): The fourth layer steps in to double-check the details, making sure the AI still understands exact meanings and relationships between words.

This makes it way more efficient at processing massive amounts of text — which invaluable for the 1 million token context window support that it has.

It also optimizes its speed with Multi-Token Prediction (MTP) — which lets it predict and verify multiple tokens at once rather than generating everything strictly one token at a time.

Qwen 3.8 also gives you granular control over reasoning.

You can adjust reasoning_effort between xhigh, medium and low — or disable extended thinking entirely using enable_thinking.

So you can low reasoning for simple operations, then switch to xhigh when debugging something difficult — or disable thinking altogether when maximum speed matters.

Qwen3.8 also supports preserve_thinking — which lets its reasoning state persist across multi-turn conversations.

For long-running agents, this massively reduces redundant reasoning and improves KV-cache utilization — instead of repeatedly reconsidering the same information.

That level of sophistication in runtime reasoning control is highly unusual among open models — especially for its incredibly lean size.

Qwen3.8-27B is also a native vision-language model — capable of understanding text, images and video.

It scores 91.1% on OmniDocBench 1.5, demonstrating strong performance on complex documents, while its vision system can handle charts, STEM diagrams, screenshots and other visual information.

Qwen also supports hour-scale video understanding, with configurable frame sampling allowing developers to balance detail against computational requirements.

Put everything together and the significance becomes clearer.

A 27 billion parameter model can now rapidly write and debug software, operate computer interfaces, analyze documents, understand images and video, reason autonomously, maintain thinking state and process enormous contexts—all on hardware you can own.

We can clearly see where all this is heading — frontier-class capabilities are beginning to escape the datacenter.

Wow this is huge.

Elon Musk’s xAI just released a brilliant new coding agent with unbelievable new features — and the developer community has been going absolutely wild.

Grok Build is here to unleashed the full power of the most advanced Grok models in every software development task imaginable.

With a new goal-centric plan mode and headless automation mode

And these are just a few of everything this new Grok Build brings to the table.

Sub-agents working in parallel in Grok Build:

Let’s take a look at 5 of these features and the massive benefits they provide in our development workflows.

1. Industry-leading 2 million token context window

Context is still biggest limitations of current coding agents.

Large projects often contain huge codebases, extensive documentation, configuration files, and dependency trees that exceed what most AI models can effectively keep in memory.

Grok Build is powered by top-tier Grok models like Grok 4.20, which features a 2 million token context window, let’s us give it:

• Entire codebases
• Large documentation sets
• Technical specifications
• Dependency chains
• Historical implementation notes

all within a single session.

Instead of constantly re-explaining project structure, the model can maintain a much deeper understanding of the system it is working on.

2. Headless automation mode

Headless automation will completely transform how you approach development.

Instead of requiring an interactive terminal session, Grok Build can run inside:

• CI/CD pipelines
• Cron jobs
• Automation scripts
• Build systems

This allows engineering teams to automate routine development work.

For example, Grok Build could:

• Review pull requests overnight
• Refactor legacy code
• Update documentation
• Identify technical debt
• Perform maintenance tasks

without requiring a developer to actively supervise every step.

3. Plan mode lets you see everything

One of the biggest frustrations with autonomous coding agents is that they can spend twenty minutes modifying files before you realize they misunderstood the task.

Grok Build introduces a structured Plan Mode to solve this problem.

Before editing a single file, the agent generates a detailed execution plan showing:

• Which files will be modified
• The implementation steps
• Dependencies between tasks
• Areas of potential risk

Developers can review the plan, rewrite steps, leave comments, or approve it entirely.

Only after approval does Grok Build begin making changes, which are then presented as clean Git diffs.

So we end up with workflow that keeps humans in control while still benefiting from automation.

4. Parallel subagents and Git worktrees

Complex features often require changes across multiple parts of a project.

Rather than handling everything sequentially, Grok Build can split a large task into smaller pieces and launch up to eight specialized subagents to work simultaneously.

To avoid conflicts, each subagent operates inside its own Git worktree and branch.

This provides several advantages:

• Faster execution through parallel work
• Isolation between agent tasks
• Fewer merge conflicts
• Easier review and validation

Instead of multiple agents fighting over the same files, each works independently before the final results are merged together.

5. Works with all the tools you already use

Your skills, your hooks, your AGENTS.md, your plugins, everything.

MCP

Grok Build supports Anthropic’s Model Context Protocol out of the box.

This allows teams to connect the agent directly to:

• Internal APIs
• Proprietary databases
• Documentation systems
• Custom tools and workflows

Rather than forcing organizations to change their infrastructure, Grok Build can plug into what already exists.

ACP (Agent Communication Protocol)

It also supports Agent Communication Protocol (ACP).

ACP enables external tools and IDEs to communicate directly with the agent environment, making integrations with platforms like VS Code, Cursor, JetBrains, and custom developer tools significantly easier.

What makes Grok Build interesting isn’t any single feature — it’s how these features work together.

The massive context window helps the agent understand entire systems. Plan Mode adds transparency and control. Parallel subagents accelerate execution. MCP and ACP provide extensibility. Headless mode enables automation beyond the desktop.

Together, they push AI beyond simple code generation and toward something much closer to a true software engineering agent.

DeepSeek just released a revolutionary new open-source Claude Code competitor — but it’s so much more than that.

The new DeepSeek Harness is not just trying to be a coding agent.

It’s not even trying to compete in models or features or settings or commands.

It’s trying to compete at the AI operating system layer — the harness layer.

It’s the harness layer that really makes AI coding possible — the layer that transforms any model into an autonomous agent.

AI models on their own are very intelligent but can only chat — they need a high-quality harness to let them read files and make network requests and extend themselves with plugins and skills — like what an Operating System does for a very powerful processor.

So DeepSeek Harness is trying to be the most powerful operating system ever made — that maximizes any model to its full intelligence potential to give you the best and fastest results possible.

It’s unbelievably flexible — you can basically replace or customize every single thing.

Tools like Claude Code and Cursor let you swap models and add new extensions.

But DeepSeek Harness goes much much further — everything is a plugin — everything:

• Model adapters
• Permission systems
• Session storage
• File-system access
• Tool definitions
• Agent orchestration logic
• Even the agent execution loop itself

List of connected plugins in a DeepSeek Harness:

You are not locked into a predefined way of building agents — you can even connect it with other harnesses like Claude Code.

You can assemble your own agent stack from interchangeable components — we’ve had tech stacks, now we have agent stacks in 2026.

You can even embed an entire agent system inside a larger workflow — Agent-in-Agent Orchestration.

For example a DeepSeek Harness workflow could:

• Use Claude Code for software development
• Call OpenAI Codex for specific coding tasks
• Route research to another agent
• Coordinate everything through a parent orchestrator

And the harness itself is not limited to DeepSeek models.

It supports OpenAI-compatible API endpoints — which allows you to mix and match models across providers.

So like for example:

• DeepSeek for reasoning
• A vision model for image analysis
• Claude for writing
• Local open-source models for privacy-sensitive tasks

The framework focuses on orchestration rather than locking users into a single model ecosystem.

Four purpose-built runtime modes

Instead of changing model intelligence, DeepSeek Harness changes the environment around the model.

Standard mode

General-purpose execution for everyday workflows.

Code mode

Optimized for long-running software engineering tasks, including:

• Planning
• Coding
• Debugging
• Testing
• Multi-step implementation

Minimal mode

A lightweight, sandboxed environment designed for benchmarking and evaluations such as:

• SWE-bench
• TerminalBench
• Research experiments

Creator mode

Perhaps the most experimental runtime.

Creator Mode allows agents to:

• Inspect plugins
• Modify plugins
• Compose new plugins
• Reconfigure parts of their own environment

Rather than simply using tools, agents can actively reshape the harness itself.

State-of-the-art generative UI

DeepSeek Harness also includes dsh-genui, a system for generating interactive user interfaces.

Instead of responding only with text or Markdown, agents can render:

• Graphs
• Dashboards
• Visualizations
• Interactive widgets
• Sandboxed mini-applications

This allows agents to present information through purpose-built interfaces rather than lengthy text outputs.

Unprecedented transparency

A major focus of DeepSeek Harness is visibility.

The framework ships with a local web interface that exposes operational details often hidden in other agent systems.

Live operational metrics

Developers can monitor:

• Token usage
• Tokens per second
• Tool calls
• Step counts
• Total turns
• Prompt cache hit rates

All metrics are available in real time.

Interactive trajectory timelines

The UI also provides a detailed audit trail showing:

• Every reasoning step
• Tool inputs and outputs
• Sub-agent activity
• Execution latency
• Context assembly details

This makes debugging, optimization, and governance significantly easier.

Built for long-running, low-cost agents

Long-running agent workflows are typically expensive because context grows over time.

DeepSeek Harness tackles this through:

• Optimization around DeepSeek V4-Flash
• Aggressive prompt caching

In extended sessions, cache hit rates reportedly reach as high as 95–100%. As a result, large portions of prompts and conversation history can be reused instead of being repeatedly processed.

What this means is huge as a developer:

• Multi-hour coding agents become affordable
• Multi-agent systems can run continuously
• Complex workflows incur far lower costs
• Long context histories become less expensive to maintain

DeepSeek Harness is not trying to be just another AI agent framework.

It is attempting to become a flexible orchestration layer for the entire agent ecosystem, with key innovations like:

• A true “everything is a plugin” architecture
• Agent-in-agent orchestration
• Model-agnostic composability
• Four specialized runtime modes
• Native generative UI support
• Deep operational transparency
• Extremely cost-efficient long-running execution

As AI systems become more complex and multi-agent workflows become more common, orchestration is starting to matter as much as model intelligence itself.

DeepSeek Harness is one of the strongest signals so far that the future of AI infrastructure will be built around composable systems, not just increasingly powerful models.