ai

Claude Code Dynamic Workflows will change the way developers code with AI forever.

It fixes all the problems we’ve had to deal with when trying to use the same agent to do everything — or when trying to make multiple agents work together.

It combines hard-coded code and dynamic LLMs in a way we’ve never seen before — to get the absolute best of both worlds.

Dynamic Workflows allows Claude write its own JavaScript orchestration scripts on the fly and spin up tens to hundreds of parallel subagents to tackle giant tasks end-to-end.

It doesn’t just spawn sub-agents randomly — it deploys them in incredible structured and sophisticated ways.

And the sub-agents are not just doing simple divide-and-conquer code generation like we’ve been seeing.

They are intelligently combining themselves in a way that’s perfectly customized to whatever massive task we give them.

Some of them might aggressively review the code another agent generated — some might be there to pick the best code generated among a set of other agents.

Let’s dive deeper into Dynamic Workflows and see all the ways it can level up the workflows of so many developers.

1. Fixes all the biggest failures of single-context LLMs

Traditional AI agents operate inside a single conversation, which creates three major failure modes.

Defeating agentic laziness

Give one agent a task like reviewing 50 files for a security issue and it eventually becomes difficult to track progress.

Tasks get summarized, details are missed, and the model may prematurely declare success.

Dynamic Workflows solve this through decomposition. Instead of one agent handling 50 files, Claude launches 50 focused subagents. Each agent sees only one file and one objective, while the orchestration layer manages the larger task.

Crushing self-preferential bias

In traditional workflows the same model often generates and reviews its own work.

Dynamic Workflows separate these responsibilities. One agent builds, another reviews, and a third may challenge both. Because reviewers operate in independent contexts, they evaluate outputs against the requirements rather than defending previous reasoning.

Preventing goal drift

Long conversations cause important constraints to disappear over time.

Requirements like maintaining backwards compatibility or preserving performance gradually get compressed out of context.

Dynamic Workflows keep agent conversations short and purpose-built, ensuring every worker remains tightly aligned with the original objective.

2. JavaScript-powered deterministic decomposition

This is one of the biggest breakthroughs with Dynamic Workflows.

Claude doesn’t just spawn agents on the fly — it first writes a custom orchestration program.

LLM’s are great but they can be unpredictable — and there is no guarantee on how they tackle a huge goal.

With this JavaScript orchestration layer, the workflow’s structural control flow is 100% deterministic and predictable.

The file calls multiple JavaScript functions, like agent():

• agent(prompt, options): Spawns an isolated subagent. Can enforce structured JSON data using a schema

We know exactly what is going to happen at the high-level — while letting the individual sub-agents decide how they go about the lower-level tasks distributed among them.

Instead of thinking and generating everything on the fly, Claude generates a JavaScript workflow that determines:

• How work is divided
• Which agents are created
• How outputs are verified
• How failures are handled
• How results are synthesized

Because these workflows are standard artifacts, developers can save, modify, version-control, and rerun them. Over time, teams can build libraries of reusable workflow harnesses and custom agent networks tailored to their engineering processes.

3. Advanced multi-agent design patterns

Dynamic Workflows can combine sophisticated agent architectures on demand.

Tournaments

Multiple agents attempt the same problem using different approaches. A separate judging agent evaluates the candidates and selects the strongest solution.

Adversarial verification

A dedicated reviewer is created with one goal: reject the output.

This agent actively searches for security vulnerabilities, logic flaws, hidden assumptions, and edge cases, creating a far more rigorous review process than self-evaluation.

Fan-out-and-synthesize

For large-scale tasks, Claude distributes work across dozens or hundreds of parallel agents operating independently. Once completed, the workflow pauses and synthesizes all outputs into a unified result.

This pattern is ideal for migrations, audits, documentation generation, and repository-wide code changes.

4. Powering massive engineering projects

The scale enabled by Dynamic Workflows is difficult to overstate.

It’s really hard to overstate the sort of massive scale you could get from using Dynamic Workflows.

A prominent example is the Bun runtime migration from Zig to Rust. Using workflow-driven orchestration, approximately 750,000 lines of Rust code were generated while maintaining roughly 99.8% compatibility with the existing test suite.

Projects that would traditionally span multiple quarters can increasingly become automated jobs running in the background for hours or days.

5. Built-in resumability and safety

Long-running workflows require operational reliability.

The runtime continuously tracks workflow state and subagent progress. If a crash or disconnection occurs, execution resumes from the last checkpoint rather than restarting from scratch.

To prevent runaway costs, the system also provides visibility into workflow execution, token consumption, and resource usage, while enforcing limits that stop recursive workflows from spiraling out of control.

Dynamic Workflows represent a shift from prompt engineering to orchestration engineering.

Rather than asking a single AI agent to solve increasingly complex problems, Claude generates a custom execution harness, launches specialized workers, verifies their outputs, tracks state, and synthesizes results.

The future of AI development is not single super-agent.

It’s dynamically generated teams of specialized agents coordinated by software the AI writes for itself.

Claude Code’s Plan Mode is so underrated and underused.

Many developers are just prompting and prompting — they don’t realize how much this absolute beast of feature would take their entire Claude Code experience to the next level.

Plan Mode completely transforms Claude into a different kind of agent with a totally different objective.

Rather than immediately writing code, Claude shifts into a specialized, read-only, planning workflow designed to analyze, design, review, and document a solution before a single file is even touched —

Dramatically improving decision making, context efficiency, and implementation in the most complex and convoluted projects.

1. Plan Mode completely changes Claude’s way of thinking

When Plan Mode is enabled, Claude receives a different set of system instructions that fundamentally change how it approaches problems.

Instead of optimizing for just code generation, it optimizes for planning in four distinct phases.

• Initial Understanding: Explore the codebase and identify relevant files and dependencies.
• Design: Evaluate implementation approaches and trade-offs.
• Review: Validate the proposed design against the realities of the codebase.
• Final Plan: Produce a concise roadmap explaining what should change and why.

It turns into a sophisticated system designer.

2. Genius solution to processing massive repositories

Going through all the files in a large codebase can consume a huge amount of context and tokens.

To avoid this Claude Code uses a specialized, lightweight “Explore” subagent (like Claude Haiku) during the discovery phase.

This lightweight agent is responsible for searching, indexing, and reading files before passing only the most relevant findings back to the primary model.

Instead of stuffing thousands of lines of code into the main context window, the Explore subagent filters out noise and returns only the information needed for planning.

This allows the primary model to spend its context budget on reasoning rather than file exploration.

3. Guaranteed immutability

Another important detail is that Plan Mode is not activated through prompting alone.

When you switch into Plan Mode, Claude’s ability to modify the codebase is restricted by the underlying CLI harness itself. Write operations, file edits, and other mutating actions are removed from its available toolset.

In other words, Claude isn’t simply being asked not to make changes — it literally cannot make them.

This creates a genuinely safe environment for:

• Architecture reviews
• Migration planning
• Security audits
• Refactoring analysis
• Large-scale code exploration

There’s no risk of an accidental file modification while you’re still evaluating options.

4. The plan is a persistent, tangible artifact

The plan doesn’t exist only in the conversation.

Behind the scenes, Claude generates a markdown-based planning artifact that can persist beyond the immediate session. The plan becomes something tangible rather than a temporary stream of thoughts.

You can open it up in your own editor, tweak Claude’s planned steps yourself, and then feed that modified markdown file back into the tool to execute.

It turns planning into a deliverable, which is really powerful.

Instead of reviewing ideas scattered throughout a chat, developers can work from a structured roadmap that can be revised, shared, and reused.

5. Plans can evolve into the engine of the entire project

Many users initially adopt Plan Mode to make coding safer.

Over time, they discover it’s just as useful for documentation.

Because plans are structured markdown artifacts, they naturally evolve into:

• Feature roadmaps
• Migration checklists
• Implementation specifications
• Architecture reviews
• Onboarding documents

In many cases, the plan itself becomes the most valuable output. Even if implementation never happens, the document captures a deep understanding of the system and a clear strategy for future work.

The real purpose of Plan Mode isn’t preventing Claude from writing code.

It’s separating thinking from doing.

By combining a planning-focused workflow, a dedicated exploration subagent, hard platform-level restrictions, and persistent planning artifacts, Claude Code creates an environment where analysis comes before execution — which ends up dramatically improving the quality of the execution.

CLAUDE.md is so much more than most developers realize.

It’s supposed to be a special file for providing persistent instructions and context to Claude Code.

But many developers think they can just dump whatever they like inside it — some feel it’s just a fancy way to avoid writing the same prompts over and over.

Some don’t even ever use it — missing out on one of the most powerful ways to shape how Claude behaves inside a project.

The reality is that CLAUDE.md is far more nuanced than it appears. Understanding a few non-obvious facts about it can completely change how you work with Claude Code, and the results it produces for you.

Here are five things every developer should know about CLAUDE.md.

1. It’s not a README or project summary

Actually not a very good CLAUDE.md:

A README exists to explain a project.

A CLAUDE.md exists to guide an agent working inside that project.

The most effective files don’t try to document everything. Instead they focus on specific expectations, workflows, constraints, and preferred ways of working.

For example:

• Particular project-specific commands to run — or NOT run
• What must happen before code is merged
• Which patterns should be avoided when responding to prompts
• How tasks should be approached

Thinking of CLAUDE.md as documentation often leads to bloated files. Thinking of it as a behavioral contract usually leads to better results.

2. It’s not a system prompt

One common misconception is that CLAUDE.md functions like a system prompt.

It doesn’t.

Claude Code loads the contents of the file into the model’s normal user context — it’s treated as important guidance rather than an untouchable source of truth.

It’s not an unbreakable instruction layer that reigns over every other context.

This is why clear, specific instructions tend to work much better than vague recommendations.

3. There can be more than one CLAUDE.md

Many developers assume there is a single CLAUDE.md at the root of a project.

But actually Claude Code supports a layered memory system.

Instructions can exist at multiple levels and be combined as Claude works through different parts of a codebase.

This makes CLAUDE.md less like a project configuration file and more like a hierarchy of contextual instructions that shapes behavior in different situations.

4. Claude can automatically generate your first CLAUDE.md

A surprising number of developers still start from a blank file.

Claude Code includes an /init command that can inspect a repository and generate an initial CLAUDE.md automatically.

The generated file won’t be perfect, but it provides a useful starting point and can save time by capturing common project information that would otherwise need to be written manually.

For many teams, it’s the fastest way to establish a baseline memory file.

5. CLAUDE.md is only one layer of Claude’s massive memory system

Perhaps the most important thing to know is that CLAUDE.md is not Claude Code’s entire memory system.

It’s just one layer.

Claude can draw context from user-level memory, project-level memory, session context and many other memory sources.

So when Claude successfully remembers how your team works, that behavior is often influenced by more than a single file.

The most interesting thing about CLAUDE.md is that it represents a new way of programming behavior.

Traditional software is configured through code and settings. Claude Code introduces the idea of configuring an agent through natural language instructions.

That’s why two developers can use the same model and get very different outcomes. The difference isn’t the model — it’s the behavior defined by the memory and instructions surrounding it.

Anthropic just shocked the world — they just released the most powerful AI model in human history.

This is Claude Fable 5 — the public-facing version of the monstrous Claude Mythos model that they’re hiding from the public.

There is no contest — this thing completely decimated all the benchmarks out there — Opus 4.8 looks like a toy compared to what this thing can do:

• Dominated several AI model leaderboards within hours of launch
• Migrated a major tech company’s codebase of 50 million lines in less a day — previously took several months of work
• Better than any other model at coding & software engineering

It’s been absolutely wild — People are casually one-shotting entire games, 3D worlds, full-stack apps, and code optimizations that shouldn’t be possible, but here we are.

And to think that this is actually a restricted version?

Imagine having a model so powerful that you literally cant release it to the world without disastrous consequences.

1. The Fable vs. Mythos story: A tale of two twins

It’s definitely one of the most fascinating aspects of this incredible launch.

The Claude Fable 5 and Claude Mythos 5 relationship.

Both models share the same underlying architecture and core capabilities.

The main difference isn’t intelligence — it’s access.

Claude Fable 5

• Released to the general public
• Full reasoning, coding, and agentic capabilities
• Protected by real-time safety classifiers
• Automatically restricted in high-risk domains

Claude Mythos 5

• The unrestricted, god-mode version of the same model
• Available ONLY to vetted organizations
• Accessed through Anthropic’s Project Glasswing program
• Designed for advanced cybersecurity and research applications

Anthropic itself has emphasized that the naming distinction reflects safety boundaries rather than capability differences.

In other words, Fable isn’t weaker model. It’s a safer one.

A pair of identical twins — one allowed to walk freely among the public.

The other considered so dangerous that its access is limited to people responsible for defending critical digital infrastructure.

That alone makes this launch unlike anything we’ve seen before in AI.

2. Absolutely decimates benchmarks

Fable 5’s benchmark results are among the most impressive ever reported for a public AI model.

On Humanity’s Last Exam, one of the toughest AI reasoning tests in existence, Fable scored 64.5% with tools, comfortably outperforming GPT-5.5 (41.4%) and Gemini 3.1 Pro (44.4%).

Its dominance extends to software engineering. On SWE-Bench Pro, the industry’s leading coding benchmark, Fable achieved 80.3%, compared to GPT-5.5’s measly 58.6%.

The model also posted leading scores across computer use, spatial reasoning, cybersecurity, and terminal-based tasks, establishing itself as one of the strongest general-purpose AI systems ever released.

3. Unbelievable long-horizon coding ability

Fable 5 is specially built for massive, complicated tasks that unfold over hours — or even days.

The model can:

• Explore its environment independently
• Build and execute its own plans
• Launch parallel sub-agents
• Monitor its own progress
• Self-correct when things go wrong

The most shocking example comes from Stripe.

The Stripe test

Fable was tasked with working inside a 50-million-line Ruby codebase and completed a codebase-wide migration in a single day—compressing what would normally require months of engineering effort into hours.

It’s just absolutely shocking how crazy things have gotten.

But this is what Anthropic means by long-horizon intelligence: an AI capable of staying focused on complex objectives for hours, not just seconds.

4. Sophisticated real-time Opus hand-off

One of Fable’s most innovative features is something users may never notice.

When the model encounters sensitive areas such as:

• Advanced cybersecurity
• Biochemical research
• Model distillation
• Other high-risk domains

…it doesn’t simply refuse.

Instead, Anthropic’s safety systems automatically hand the conversation off to Claude Opus 4.8, which completes the task under stricter safety constraints.

According to Anthropic:

• Roughly 95% of user sessions run entirely on Fable 5
• Only a small fraction trigger the Opus fallback
• Users receive a seamless experience rather than a hard refusal

It’s a novel approach to AI safety: switch models instead of shutting the conversation down.

5. Why the main Mythos simply had to be locked up

If it’s the same model, why not release it publicly?

Cybersecurity.

Serious cybersecurity concerns.

Anthropic has unambiguously described Mythos 5 as “possessing unprecedented offensive and defensive cyber capabilities”.

Its performance on security-focused benchmarks significantly exceeds previous generations — Mythos-class systems have reportedly helped identify thousands of critical vulnerabilities.

It even uncovered a 27-year-old security flaw in OpenBSD and wrote a remote code execution exploit for a 17-year-old bug in FreeBSD completely on its own.

It is so effective at finding bugs that open-source maintainers literally begged Anthropic to slow down its disclosures because human developers couldn’t write the patches fast enough.

For Anthropic, the risk-reward equation was clear:

• Release a safeguarded version to the public
• Restrict the unrestricted version to trusted partners
• Maintain oversight of the model’s most powerful capabilities

This model is going to completely rip apart everything we thought was possible with AI models and AI-powered software development.

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.

• 2 million token context window (!)
• Brand new goal-centric plan mode
• Innovating new headless automation mode

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 Grok-4.3, which features a 2 million token context window, allow developers to provide:

• 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.

So many developers ignore this Claude Code command — and it only ends up costing them serious drops in agent accuracy later down the line.

The /compact command doesn’t just make your conversation history smaller.

It completely transforms the core context structure to give the agent a deeper understanding of your codebase and goals.

Many AI tools simply truncate old messages when context windows become full — Claude Code treats compaction as a state-preservation system designed to keep long-running coding sessions as coherent as possible.

Sophisticated features like deterministic file rehydration and custom compaction take this from simple summarization to the ultimate boundary between an agent that actually finishes the job and one that collapses under its own weight.

What is the /compact command?

The /compact command is Claude Code’s built-in context management system.

Running:

compresses the current conversation into a smaller working state so the session can continue without storing an excessive amount of low-value context.

Instead of carrying thousands of messages, tool calls, terminal outputs, and discussions forward indefinitely, Claude creates a advanced condensed representation of the project and current task.

1. Way beyond just “compact”-ing

Many AI chat tools handle full context windows by either truncating old messages or generating generic summaries.

The problem is that important decisions disappear.

Claude Code approaches compaction differently. Rather than producing a simple recap, it attempts to create a reconstruction-grade working state.

The summary preserves:

• The current goal
• Important technical decisions
• Problems already solved
• Current implementation progress
• Immediate next steps

Instead of remembering:

We implemented authentication, two bugs were fixed after several tries.

Claude tries to preserve the crucial details that really matter in the overall software engineering process and timeline.

Authentication was moved into middleware to avoid duplicating validation logic across route handlers.

That’s the difference between remembering outcomes and preserving reasoning.

2. File rehydration keeps code always accurate

Traditional summarization works poorly for coding.

A standard summary might remember the high-level story — like “we fixed an auth bug” — but it wipes out the exact code, leaving the AI with total amnesia about what the file actually looks like.

Claude Code solves this through rehydration.

When you compact your history, the CLI throws away the “clutter” (thousands of lines of conversational back-and-forth) to free up memory.

But immediately after wiping the slate clean, it silently re-reads your active files directly from your local disk back into its short-term memory.

The messy chat history gets compressed, but the fresh code is instantly placed right back in front of Claude’s eyes, allowing it to resume working with zero loss of momentum.

3. Compaction operates in three different layers

Claude Code manages context at three levels.

Microcompaction

The system continuously removes low-value information such as:

• Build logs
• Dependency installation output
• Large terminal responses

Auto-compaction

When context usage becomes too high, Claude can automatically compact the session and continue working.

Manual compaction

This is the user-controlled version and is best used at logical boundaries:

• Completing a feature
• Finishing a refactor
• Solving a bug
• Switching tasks

4. Custom compaction

You don’t have to let Claude decide everything.

You can provide instructions directly:

These hints help Claude prioritize what survives compression.

For long-term project memory, use CLAUDE.md.

This file can contain architectural principles, coding standards, and project rules that should persist regardless of how many times the conversation is compacted.

5. The 60% rule

Many users wait until Claude warns them that the context window is nearly full.

That’s usually too late.

A better approach is to compact proactively at around 60–70% context utilization.

At that point:

• Earlier decisions are still highly accessible
• The conversation remains organized
• Claude can create a cleaner, more accurate working state

Think of compaction as preventative maintenance rather than emergency cleanup.

This is just unbelievable.

Imagine having a model that’s:

• More than 5 times cheaper than Claude Opus — yet just as intelligent?
• Blazing fast — up to 15x faster than Claude Opus for heavy prompts and massive context?
• Open-source with open weights to top it all off?

Yeah it’s definitely no surprise how so many people have been going absolutely wild over the few days over the new MiniMax M3.

Look how closely it matches Claude’s and GPT’s capabilities! It’s even better in certain key areas:

I still can’t wrap my head around the absolutely wild feats of endurance and intelligent it displayed during testing — and has been performing ever since then.

This just truly completely shattered the limits of what we thought was possible with open-source models — or any type of model really.

1. Not the same “1 million token context”…

Don’t let AI companies fool you with their loud claims of 1 million token context.

Not all 1 million token contexts are remotely the same — not even close.

Yes they can all process massive codebases, research archives, books, or long-running projects.

But they vastly differ in the quality of processing all that massive data, how much they can actually make sense of, how much they comprehend the interconnectedness of all the data.

And speed. A big, big one.

Most AI models become painfully slow and expensive when dealing with that much information.

M3 uses an innovative new approach called MiniMax Sparse Attention (MSA) that allows it to focus on the important parts instead of wasting resources on everything at once.

This allows M3 to:

• Read huge amounts of information more than 9x faster
• Generate responses more than 15x faster
• Use a fraction of the computing power normally required

The giant context window is no longer just for fancy — it actually becomes a beast in the real world.

And those models that still use slower methods of parsing large token contexts will get absolutely left in the dust.

2. Insane long-horizon ability

MiniMax M3 shocked every with insane feats of autonomy on tasks spanning several hours.

The 12-hour research paper loop: M3 was given a complex AI research paper and spent 12 hours straight reproducing the core experiments. It managed its own context window, parsed charts, wrote code, handled 18 GitHub commits, and generated 23 experimental figures completely unaided.

Self-training models: In another test, M3 was given raw base models and spent 12 hours handling data synthesis, training, and evaluation loops on them entirely on its own.

The 24-hour CUDA optimization: It was assigned to optimize an FP8 GEMM kernel (a notoriously painful low-level GPU operation). Over 24 hours, it autonomously went through 147 benchmark submissions and nearly 2,000 tool calls, boosting hardware peak utilization from a lousy 7.6% to a highly optimized 71.3% — a 9.4x speedup with zero human help.

This is the kind of work you’d normally assign to a high-level engineer or researcher, yet here comes MiniMax M3 doing it all on its own, unbelievable.

3. Punching way above its weight

Despite competing against much larger companies with way bigger resources at their disposal, M3 is posting amazing benchmark results.

• SWE-Bench Pro: 59.0%, edging past GPT-5.5 and Gemini 3.1 Pro
• BrowseComp: 83.5, outperforming Claude Opus 4.7’s 79.3

MiniMax is competing right at the cutting edge, particularly in software engineering and autonomous research tasks.

4. Ultra-competitive pricing

It will undoubtedly be one of the biggest selling points.

All that intelligence and speed and innovation, for such a ridiculously low price.

M3 launched at roughly:

• $0.60 per million input tokens
• $2.40 per million output tokens

That makes it significantly cheaper than many of the most advanced AI models available today.

Just compare to the latest Claude Opus pricing:

• $5.00 per million input tokens
• $25.00 per million output tokens

This will be huge for startups and smaller teams.

Many AI projects fail not because the technology isn’t good enough, but because running them becomes too expensive. Lower costs mean more companies can build products that were previously out of reach.

5. Open weights available to everyone

MiniMax isn’t keeping everything locked behind a proprietary wall.

And open-source availability means:

• Greater transparency
• Community-driven improvements
• Easier experimentation
• More deployment flexibility
• Reduced vendor lock-in

Open models used to trail the very best closed systems — not anymore.

M3 is part of the new wave of the models that completely disrupts the notion of open-source models being inherently weaker.

Why M3 matters

The biggest takeaway from M3 isn’t that it’s smarter than every other model.

It’s that MiniMax is attacking some of the biggest problems in AI at the same time:

• Cost
• Speed
• Long-term autonomy
• Multimodal understanding
• Accessibility through open source

If these early results hold up in real-world use, M3 could become one of the most important AI launches of the year — not because it’s the biggest model, but because it makes powerful AI far more practical for everyone.

Claude Opus 4.8 is absolutely insane.

This is going to fundamentally transform the AI coding ecosystem and the sheer amount of tasks we entrust agents with. You absolutely cannot ignore this.

Claude Opus 4.8 stays perfectly on track across extremely long complex coding sessions:

Like it’s not just way more powerful than Opus 4.7 with so many abilities massively upgraded —

It’s also a much more HONEST model:

It can actually admit when it has no idea what something means — instead of making up nonsense on the fly.

It’s literally FOUR TIMES more likely to catch any potential bugs and flaws in any code it generates.

All thanks to a major breakthrough in AI self-awareness and reliability.

And don’t get me started on the new Dynamic Workflows that turn any Claude-powered agent into a super-powered beast.

It even easily passed the tricky car wash test that’s frustrated so many great models — which shows a serious jump in real-world understanding and logic — something very important for AGI.

1. A massive leap in AI integrity & reliability

One of the biggest problems with modern AI is that models often don’t know when they’re wrong.

They write code with bugs, reach conclusions on incomplete information, and confidently report success even when they’ve failed.

Opus 4.8 was designed specifically to fix this.

The model proactively identifies gaps in its own reasoning instead of rushing toward conclusions…

The model is far more likely to identify uncertainty, flag gaps in its reasoning, and challenge questionable assumptions before proceeding.

• Admitting uncertainty: The model proactively identifies gaps in its own reasoning instead of rushing toward conclusions.
• Catching bugs: Opus 4.8 is 4× less likely than Opus 4.7 to let flaws in code it generated pass without comment.
• Reporting failures honestly: The model achieved a perfect 0% rate of uncritically reporting flawed results in Anthropic’s internal evaluations.
• Pushing back when necessary: Rather than blindly following instructions into failure, it actively questions weak assumptions and incomplete plans.

As AI systems become increasingly autonomous, reliability starts to matter more than raw intelligence.

A model that catches its own mistakes can end up being much more valuable than one that’s simply smarter.

2. Dynamic Workflows change everything

The second major announcement is Dynamic Workflows.

Instead of tackling large projects as a single agent, Opus 4.8 can act as an orchestrator, spawning and managing hundreds of parallel AI subagents simultaneously.

With Dynamic Workflows, Claude can:

• Write orchestration scripts
• Launch hundreds of specialized AI agents
• Distribute work across large codebases
• Verify outputs against existing test suites
• Aggregate results into a final solution

Anthropic showcased this capability by using Dynamic Workflows to help port the Bun runtime from Zig to Rust — a project involving roughly 750,000 lines of code.

Using a swarm of coordinated agents, Claude completed the migration in 11 days and achieved a remarkable 99.8% pass rate on Bun’s existing test suite.

That’s not a chatbot helping write functions.

That’s an AI system coordinating work at the scale of an engineering organization.

3. Completely ridiculous intelligence gains

Unbelievable gains in practically every major benchmark.

But the most eye-catching result comes from USAMO 2026 — one of the world’s most difficult mathematics competitions.

Opus 4.7 scored 69.3.

Opus 4.8 scored 96.7.

That’s NOT normal.

But it didn’t stop there.

• USAMO 2026: 69.3 → 96.7
• SWE-Bench Pro: 64.3 → 69.2
• GPQA Diamond: 84.1 → 88.4
• Humanity’s Last Exam: 35.8 → 44.7
• AIME 2025: 79.4 → 88.9
• GDPval: 1753 → 1890

The pattern is clear: this wasn’t a model that got better at one thing — it got better at almost everything:

• Reasoning
• Coding
• Mathematics
• Scientific problem-solving
• Knowledge work
• Agentic tasks

Virtually every category moved forward — and many of the jumps are unusually large by frontier-model standards.

4. You can now control how hard Claude thinks

Opus 4.8 also introduces manual effort controls across Claude.ai, Claude Code, and the API.

Users can now decide how much compute the model should spend on a problem:

• Low effort for speed
• Medium effort for balanced performance
• High effort for difficult reasoning and coding tasks

This gives users direct control over one of AI’s most important tradeoffs: speed versus intelligence.

5. Fast Mode is faster — and cheaper

Anthropic also upgraded Fast Mode.

The new mode delivers:

• 2.5× faster token generation
• 3× lower cost than previous Claude fast modes

That matters because many AI applications today aren’t limited by intelligence—they’re limited by latency and cost.

Reducing both simultaneously makes entirely new categories of AI products economically viable.

Claude Opus 4.8 isn’t just more intelligent. It’s much more trustworthy now.

The benchmark gains are impressive. Dynamic Workflows is exciting. Fast Mode and effort controls are useful.

But the most important thing Anthropic may have accomplished is teaching a frontier model to recognize when it might be wrong.

As AI starts automating more and more crucial portions of our workflows, this starts to matter more than any benchmark score.

This is something completely different —

Qwen 3.7 Max is going to make such a massive impact on the workflow of so many developers:

This wasn’t launched with the usual displays of fancy benchmarks and claims of better reasoning — even though there’s a LOT to be said about that — almost as good as top Claude models, yet so much cheaper and faster.

Even better than the new Gemini 3.5 — and GPT-5.5 highest thinking mode!

But Qwen 3.7 Max was made specially to address one of the biggest “holy-grail” challenges facing AI agents today:

How do you keep an AI focused for hours without it losing track of its objective?

And from what I’ve been seeing these past few days — it’s been a game-changing success.

1. The shocking 35-hour test

The most impressive thing about Qwen 3.7 Max isn’t a leaderboard score:

It’s endurance.

One of the biggest weaknesses of modern AI systems is context drift—the tendency to lose track of instructions, goals, or prior decisions during long workflows.

Alibaba tested this directly by assigning Qwen 3.7 Max a highly specialized engineering challenge: optimizing a GPU attention kernel it had never seen before.

Then they left it running.

Over roughly 35 consecutive hours, the model:

• Made 1,158 tool calls
• Ran 432 code evaluations
• Diagnosed its own compilation failures
• Tested multiple optimization strategies
• Achieved a reported 10× performance improvement

This Max model maintained coherence and direction throughout the entire process—a critical capability for autonomous software engineering agents.

2. New 1 million token context window

Qwen 3.7 Max also now supports a 1 million token context window to support this incredible long-running ability.

That allows developers to work with:

• Entire code repositories
• Large documentation libraries
• Research archives
• Long project histories
• Multi-day agent memory

in a single context.

The benefit isn’t just memory. It means less summarization, less context compression, and greater continuity across complex workflows.

3. A smart ecosystem strategy

One of the most underrated features is that Qwen 3.7 Max natively supports the Anthropic API protocol.

This means developers can potentially plug it into existing tools such as:

• Claude Code
• OpenClaw
• Anthropic-based agent frameworks
• Internal Claude-compatible enterprise tooling

without rebuilding their entire stack.

Instead of forcing developers into a new ecosystem, Alibaba is reducing switching costs and making adoption easier.

4. Fast, capable, and cheap

Reasoning models are typically slow.

Qwen 3.7 Max reportedly outputs at around 192 tokens per second, significantly faster than many reasoning-focused models that operate closer to 60–70 tokens per second.

Speed matters because agents make hundreds or thousands of decisions. Small latency improvements compound into major productivity gains.

The model also ranks among the top tier of reasoning systems on independent leaderboards while delivering strong performance on difficult benchmarks such as GPQA Diamond and advanced math evaluations.

Perhaps most disruptive is the pricing:

• $2.50 per million input tokens
• $7.50 per million output tokens
• Native prompt caching that can reduce repeated-context costs by up to 90%

For companies building AI agents, that dramatically improves the economics of long-running workflows.

Many AI coding discussions are still focused on the raw intelligence of the models.

But the next wave of competition is about:

• Autonomous software engineering
• Long-horizon planning
• Tool use
• Workflow execution
• Agent reliability

So Qwen 3.7 Max isn’t just another model release, it’s a superior platform for AI agents.

Its defining characteristics aren’t just intelligence—they’re endurance, context, speed, compatibility, and cost efficiency.

And moving forward, these things are going to be far more important than another benchmark victory.

Google just released Antigravity CLI — an upgraded version of Gemini CLI that’s so much more powerful at software development.

Packed with amazing new features and ecosystem integrations, several times faster than Claude Code, and comes with brand new commands for various essential software development tasks.

The new Antigravity CLI in action:

They completely rebuilt the terminal experience around the new way software engineering works in 2026 — multi-agent, asynchronous, persistent, and increasingly autonomous.

From a regular chatbot sitting in a terminal — to a orchestration system for advanced engineering workflows.

1. Dynamic asynchronous subagents change everything

Antigravity CLI uses sophisticated divide-and-conquer — to radically improve performance and code quality for the most complicated tasks.

Main agent delegating a sub-agent to a task in Antigravity CLI:

Many coding assistants still work like linear chatbots. You ask for a change and wait while one agent handles everything sequentially.

Antigravity CLI changes that completely.

The orchestrator automatically breaks large goals into smaller tasks, spawns specialized subagents dynamically, and executes them simultaneously in the background.

You move from working with one assistant to directing an engineering team.

The context advantage is huge too.

Each subagent operates inside its own isolated context window, keeping compile logs, installs, test output, and intermediate work away from the orchestrator context.

This massively improve larger workflows for us developers.

Imagine upgrading frameworks while simultaneously migrating APIs, updating components, generating tests, and validating documentation.

Large refactors stop feeling like events.

2. Built for pure speed with Gemini 3.5 Flash

Gemini 3.5 Flash is much faster than other top-tier models:

Google optimized Antigravity CLI around Gemini 3.5 Flash, with benchmark figures placing output speed around 289 tokens per second — as much as 4 times faster than major competing tools like Claude Code.

That matters because latency compounds in agent systems.

A slow model creates slow planning, slow subagents, slow testing, slow validation, and slower iteration loops.

Everything stacks.

And Google really appears to have optimized specifically for fast orchestration.

This makes multi-file edits, codebase analysis, documentation generation, and architecture migrations feel dramatically faster.

The shorter the loop becomes, the easier iteration becomes.

And iteration drives quality.

3. Persistent isolated local environments

Antigravity CLI also introduces persistent isolated environments.

Instead of constantly rebuilding state every interaction like before, Antigravity agents can preserve files, execution state, and progress across sessions.

This enables workflows like:

• Long-running builds
• Persistent testing environments
• Multi-stage debugging
• Extended implementation sessions

For developers working on larger systems, this could remove huge amounts of setup overhead.

Authentication migrations, distributed debugging sessions, or long validation workflows no longer need constant reconstruction.

Work continues.

State survives.

4. Brand new slash commands

The command system reveals how Google expects developers to use Antigravity.

Not chat-first —

Workflow-first.

/goal tells the system to autonomously execute large objectives without repeatedly asking permission.

Think:

“Upgrade React version.”

“Refactor auth.”

“Migrate architecture.”

Then there is /grill-me, which forces the agent to interrogate you before implementation begins.

It asks about edge cases, requirements, logic gaps, and architecture decisions.

That could prevent a surprising number of specification failures.

Finally /browser gives the agent browser access for testing interfaces and validating outputs.

Frontend workflows start looking much closer to autonomous QA.

5. Deep integration with Antigravity 2.0 and AI Studio

Antigravity CLI shares the same underlying agent harness as Antigravity 2.0 desktop and Google AI Studio.

Desktop, terminal, SDK, and mobile workflows are becoming interfaces over the same runtime.

Imagine walking somewhere, opening AI Studio, speaking through a feature idea, exporting it, then sitting down later and continuing instantly inside agy.

Same state.

Same memory.

Same agents.

Ideas move directly into execution.

6. Live voice transcription inside the terminal

Antigravity CLI embeds Gemini audio models directly into terminal workflows.

You can literally ramble:

“Build dashboard… PostgreSQL… auth… analytics…”

The system transcribes and refines everything into executable objectives automatically.

This could become surprisingly useful during planning and architecture work.

A lot of design thinking happens faster through speech than typing.

Antigravity turns that directly into execution.

And that may be the bigger story.

Less prompting — more directing.