ThinkAct lets robots “think, then act” — and the payoff is new SOTA across embodied AI benchmarks

 Anyone who has watched today’s end‑to‑end robot policies fail a complex kitchen task knows the weakness: they map pixels to motors with no explicit plan. ThinkAct flips that script. The NTU‑NVIDIA team behind the paper trains a multimodal LLM to write a high‑level reasoning plan, turns that plan into a compact visual‑plan latent, then hands it to a DiT‑based action model that executes at control‑loop speed. The result is an agent that deliberates like GPT‑4o yet moves with the reactivity of classic policies.

---

How ThinkAct pulls it off

Component	What it does	Why it matters
Reinforced visual latent planning	Rewards the reasoning LLM with goal‑completion and trajectory‑consistency signals derived from vision, forcing plans that actually work in the scene.	Bridges abstract language plans to pixel‑level feedback.
Visual‑plan latent	Compresses the entire chain‑of‑thought into a fixed‑size latent that conditions a frozen DiT policy.	Keeps the policy lightweight and allows asynchronous slow‑think / fast‑act loops.
Dual‑system inference	LLM thinks a few times per second; the action model ticks every 20 ms.	Yields real‑time control without sacrificing deliberation.

Benchmark sweep at two skill levels

Suite	Metric	Prev SOTA	ThinkAct
EgoPlan‑Bench2	Acc. ↑	Qwen 2.5‑VL* 66.3	71.4
RoboVQA	Acc. ↑	Qwen 2.5‑VL* 63.5	69.2
OpenEQA	Acc. ↑	OpenVLA 52.1	57.8
SimplerEnv (manip.)	Succ.% ↑	DiT‑Policy 45.2	62.7
LIBERO (manip.)	Succ.% ↑	OpenVLA 48.9	60.3

Qwen 2.5‑VL numbers are the authors’ fine‑tuned baseline.

Few‑shot powers

With just 5–10 demos per LIBERO task, ThinkAct’s policy finetunes to new objects and layouts, beating OpenVLA by 9–12 points.o

---

Why this matters

• Plan‑centric embodied AI. ThinkAct shows that giving agents an explicit, reward‑aligned plan latent trumps opaque end‑to‑end policies for long‑horizon tasks.

• Self‑reflection in the loop. The reasoning LLM can detect a failure mid‑episode, revise its latent plan, and rescue the run — a first for open‑source VLA systems.

• Few‑shot deployment. Labs can adapt to a new kitchen or warehouse with handfuls of tele‑op traces instead of days of retraining.

---

ThinkAct’s code is coming soon, but the project page already hosts videos of robots closing drawers, shifting condiments and answering environment‑specific questions after reasoning out loud. The message is clear: future embodied agents won’t just map images to torque — they’ll think, decide why, then act.

Paper link: arXiv 2507.16815 (PDF)

Gemini 2.5 Flash‑Lite Hits GA: Google’s Fastest, Most Affordable Gemini Model Yet

 

A lightning‑quick sibling joins the Gemini lineup

On July 22, 2025 Google formally declared Gemini 2.5 Flash‑Lite stable and generally available (GA), rounding out the 2.5 family after Pro and Flash graduated last month. Flash‑Lite is engineered to be both the fastest and cheapest Gemini variant, costing $0.10 per million input tokens and $0.40 per million output tokens—the lowest pricing Google has ever offered for a first‑party model. 

Why “Lite” isn’t lightweight on brains

Despite its budget focus, Flash‑Lite pushes the “intelligence‑per‑dollar” frontier thanks to an optional native reasoning toggle. Builders can keep latency razor‑thin for classification or translation and only pay extra compute when deeper chain‑of‑thought is required. The model also ships with Google’s controllable thinking budgets, letting developers fine‑tune response depth via a single parameter. 

Feature set at a glance

• One‑million‑token context window: The same massive prompt length as Gemini 2.5 Pro—ideal for large documents, multi‑day chats, or entire codebases.

• Grounded tool calls: Out‑of‑the‑box connectors for Google Search grounding, code execution, and URL context ingestion.

• 40 % cheaper audio input than the preview release, broadening use cases in multimodal pipelines. 

Speed and quality benchmarks

Google’s internal tests show Flash‑Lite beating both Gemini 2.0 Flash‑Lite and 2.0 Flash on median latency while posting higher accuracy across coding, math, science and multimodal tasks. That makes the model a strong candidate for user‑facing workloads where every millisecond counts but hallucination control still matters—think chat assistants, translation layers or real‑time content moderation. 

Early adopters prove the case

Several partners have already swapped in Flash‑Lite during preview:

• Satlyt cut satellite‑telemetry latency by 45 % and power draw by 30 %.

• HeyGen now translates avatar videos into 180+ languages on the fly.

• DocsHound crunches long demo footage into training docs “in minutes rather than hours.”

• Evertune scans massive corpora of model outputs for brand analysis at production speed. 

Getting started in minutes

Developers can invoke the new model simply by specifying gemini-2.5-flash-lite in the Gemini API, Google AI Studio, or Vertex AI. If you used the preview alias, switch to the GA name before Google retires the preview endpoint on August 25. 

Why this release matters

Flash‑Lite cements Google’s multi‑tier strategy: Pro for maximal reasoning, Flash for balanced workloads, and Flash‑Lite for blazing‑fast requests at commodity prices. With its million‑token window, built‑in tool calling, and turn‑key availability on Google Cloud, the model lowers the barrier for startups and enterprises to embed powerful generative AI into latency‑sensitive products—without blowing their budget.

For AI enthusiasts, Flash‑Lite is a reminder that the race isn’t just about bigger models—it’s about smarter engineering that delivers more capability per chip cycle and per dollar. Whether you’re building a real‑time translator, an automated doc parser, or a fleet of micro‑agents, Gemini 2.5 Flash‑Lite just became one of the most compelling tools in the open cloud arsenal.

Qwen3‑Coder: Alibaba’s 480‑B Agentic Code Model Aims for One‑Million‑Token Repos

 When Alibaba’s Qwen research group dropped the link to “Qwen3‑Coder: Agentic Coding in the World,” AI Twitter lit up in minutes. The post introduces Qwen3‑Coder‑480B‑A35B‑Instruct, a gargantuan 480‑billion‑parameter Mixture‑of‑Experts (MoE) language model in which only 35 B parameters activate per token, making deployment far leaner than raw size suggests. Released on July 22, 2025 with permissive access points on GitHub, Hugging Face, and ModelScope, the model claims state‑of‑the‑art results in agent‑style coding and tool use—rivaling Anthropic’s Claude 4 Sonnet while remaining fully open‑weight. 

Architecture built for truly big code

The Qwen team doubled down on “scaling in three dimensions.” First, tokens: 7.5 T training tokens with a hefty 70 % code ratio to anchor programming skill while preserving math and general reasoning. Second, context: the model handles a native 256 K‑token window and can stretch to 1 M tokens using YaRN extrapolation, making whole‑repository prompts or week‑long chat traces finally practical. Third, synthetic data: Qwen2.5‑Coder was used to rewrite noisy corpora, boosting baseline cleanliness before fine‑tuning even starts. 

Reinforcement learning at industrial scale

Rather than stopping at supervised fine‑tune, Qwen3‑Coder undergoes two novel RL phases. “Scaling Code RL” turns automated unit‑test generation into millions of execution‑checked training rounds—improving code‑run accuracy and even general abilities. Then comes Agent RL, where 20 000 parallel cloud environments simulate real SWE‑Bench tickets. The model learns to plan, invoke tools, and iterate until tests pass, producing best‑in‑class scores on SWE‑Bench Verified without any test‑time tricks. 

Benchmarks and agentic chops

Early numbers show Qwen3‑Coder topping every open‑source competitor on Agentic Coding, Agentic Browser‑Use, and Agentic Tool‑Use tracks; Alibaba positions it as “comparable to Claude Sonnet 4” in practical autonomy. In short, it doesn’t just spit snippets—it reasons across multi‑file repos, calls compilers, and revises until green checks appear. For developers chasing fully automated pull‑request bots, that’s a milestone. 

Meet Qwen Code—your command‑line copilot

To make those agentic skills tangible, the team open‑sourced Qwen Code, a Node‑based CLI forked from Gemini CLI. With a one‑line npm i -g @qwen-code/qwen-code, users gain a prompt‑driven shell that speaks directly to Qwen3‑Coder via an OpenAI‑compatible endpoint. Prefer other tooling? The blog shows drop‑in guides for Claude Code, Cline, and generic REST calls, so the model can slot into VS Code, Git hooks, or CI pipelines in minutes. 

Why it matters

Qwen3‑Coder is more than another “bigger‑is‑better” headline. By combining MoE efficiency, million‑token context, and reinforcement learning tuned for agent workflows, Alibaba delivers a bridge between research hype and developer reality. Hobbyists with a single A100 can experiment with 256 K‑token coding agents, while enterprises get an Apache‑friendly alternative to closed, usage‑metered APIs. For AI enthusiasts, it’s an invitation: wire up Qwen3‑Coder to your build system, hand it a failing test, and watch an open model patch your codebase—all without leaving the command line. The age of end‑to‑end agentic coding just took a decisive step forward. 

KAT‑V1 teaches big models when to think—smarter answers, fewer tokens

 Large language models excel at reasoning—but often over‑reason, spewing page‑long chains of thought that waste tokens and slow latency. Kuaishou’s Tongyi Lab says its new KAT‑V1 solves that inefficiency with an AutoThink paradigm that dynamically switches between explicit reasoning and terse replies based on task difficulty. The result: a 40 B‑parameter model that matches or beats much larger rivals on toughest‑in‑class benchmarks while trimming compute.

Three ingredients behind AutoThink

Building block	What it does	Why it matters
Dual‑regime dataset	A tagging pipeline + multi‑agent synthesis label each sample as reasoning or no‑reasoning, creating paired traces for mode training.	Gives the model a supervised sense of when to think aloud.
MTP‑enhanced knowledge distillation	Multi‑Token‑Prediction transfers fine‑grained reasoning skills from a tutor model with far less pre‑training cost.	Fine‑grained signal without billions of tokens.
Step‑SRPO RL	Reinforcement learning that adds intermediate supervision to GRPO so the agent optimises both mode selection and answer accuracy in one loop.	Aligns “think vs. skip” decisions with final reward.

Benchmark highlights

• LiveCodeBench Pro (leakage‑controlled): tops all open models and edges past OpenAI o3‑mini.

• Math, logic & reasoning suites: consistently equals or beats DeepSeek‑R1‑0528 and Qwen3‑235B‑A22B with 40 % fewer active parameters.

• Token efficiency: AutoThink cuts average response length and thus total token usage (exact numbers vary by task but run tens of percent lower than straight chain‑of‑thought baselines).

Why this matters

• Compute saves tokens, not quality. AutoThink shows you can claw back cost without the typical accuracy drop.

• Controllable verbosity. Developers can enforce hard token budgets or latency targets by toggling mode thresholds.

• Scales up. A 200 B Mixture‑of‑Experts version with 40 B active weights is already training and showing bigger gains, hinting at a fresh scaling path that isn’t just “more parameters.”

Open for business

KAT‑V1 weights, Step‑SRPO code, and the dual‑regime dataset are live on Hugging Face, and the model already powers Kwaipilot, Kuaishou’s internal coding copilot, where engineers report faster completions and fewer hallucinations.

AutoThink is a reminder that the next leap in LLM performance may come not from thinking harder—but from knowing when not to think at all.

Paper link: arXiv 2507.08297 (PDF)

Building Startups at the Speed of AI: Key Takeaways from Andrew Ng’s Startup School Talk

 

1 Speed Is the Leading Indicator of Success

At AI Fund, Andrew Ng’s venture studio, teams launch roughly one startup a month. After hundreds of “in-the-weeds” reps, Ng sees a clear pattern: the faster a founding team can execute and iterate, the higher its survival odds. Speed compounds—small delays in shipping, learning, or pivoting quickly snowball into lost market share.

2 The Biggest Opportunities Live in the Application Layer

Much of the media hype sits with semiconductors, hyperscalers, or foundation-model vendors. Yet the lion’s share of value has to accumulate at the application layer—products that create revenue and, in turn, pay the upstream providers. For AI enthusiasts, building real workflows that users love is still the clearest path to outsized impact.

3 Agentic AI Unlocks Quality (at the Cost of Raw Latency)

Traditional prompting forces a language model to produce output linearly, “from the first word to the last without backspace.” Agentic AI flips that paradigm: outline → research → draft → critique → revise. The loop is slower but consistently yields far more reliable results—crucial for domains such as compliance review, medical triage, or legal reasoning. Ng sees an entire orchestration layer emerging to manage these multi-step agents.

4 Concrete Ideas Trump Grand Generalities

“Use AI to optimize healthcare assets” sounds visionary but is impossible to execute. “Let hospitals book MRI slots online to maximize scanner utilization” is concrete—an engineer can sprint on it this afternoon, gather user feedback, and prove or disprove the hypothesis fast. Vague ideas feel safe because they’re rarely wrong; concrete ideas create momentum because they’re immediately testable.

5 AI Coding Assistants Turn One-Way Doors into Two-Way Doors

With tools like Claude-Code, Cursor, and GitHub Copilot, rapid prototyping is 10× faster and radically cheaper. Entire codebases can be rebuilt in days—a shift that converts many architecture decisions from irreversible “one-way doors” into reversible “two-way doors.” The result: startups can afford to explore 20 proof-of-concepts, discard 18, and double-down on the two that resonate.

6 Product Management Becomes the New Bottleneck

When engineering accelerates, the slowest link becomes deciding what to build. Ng’s teams now experiment with PM-to-engineer ratios as high as 2 PMs per 1 engineer. Tactics for faster feedback range from gut checks and coffee-shop usability tests to 100-user beta cohorts and AB tests—each slower but richer in insight than the last. Crucially, teams should use every data point not just to pick a variant but to sharpen their intuition for the next cycle.

7 Everyone Should Learn to Code—Yes, Everyone

Far from replacing programmers, AI lowers the barrier to software creation. Ng’s CFO, recruiters, and even front-desk staff all write code; each role levels up by automating its own drudgery. The deeper you can “tell a computer exactly what you want,” the more leverage you unlock—regardless of your title.

8 Stay Current or Chase Dead Ends

AI is moving so quickly that a half-generation lag in tools can cost months. Knowing when to fine-tune versus prompt, when to swap models, or how to mix rag, guardrails, and evals often spells the difference between a weekend fix and a three-month rabbit hole. Continuous learning—through courses, experimentation, and open-source engagement—remains a decisive speed advantage.

---

Bottom line: In the age of agentic AI, competitive moats are built around execution velocity, not proprietary algorithms alone. Concrete ideas, lightning-fast prototypes, disciplined feedback loops, and a culture where everyone codes form the core playbook Andrew Ng uses to spin up successful AI startups today.

Qwen3-235B-A22B-Instruct-2507: Alibaba’s New Open-Weight Flagship Redefines Efficient Megamodels

 When the Qwen team hit “post” on X announcing Qwen3-235B-A22B-Instruct-2507—plus a lightweight FP8 variant—the tweet felt less like routine release notes and more like a thunderclap across AI Twitter. The thread promised “better across the board” performance and immediate open-weights access, positioning Qwen as the most aggressive big-model vendor in the open ecosystem. 

Inside the Model

Under the hood, the new model keeps the mixture-of-experts (MoE) recipe that made earlier Qwen3 builds special: 128 experts, but only 8 fire on each forward pass, so just 22 B parameters are active even though the full network tops out at 235 B. That efficiency allows 256 K tokens of native context and enables consumer-grade deployments that once demanded datacenter GPUs. 

Benchmark Shockwaves

Numbers published with the release show why the community’s jaw dropped. On the notoriously tricky ARC-AGI benchmark, Qwen3-235B-A22B-Instruct-2507 scores 41.8 %, eclipsing Moonshot’s freshly minted Kimi K2 by nearly 29 points and edging ahead of Claude Opus 4 in non-thinking mode. Coding (LiveCodeBench v6) jumps to 51.8 %, and reasoning tasks like AIME25 leap to 70.3 %. In most rows of the evaluation table, the new Qwen flags sit comfortably ahead of DeepSeek-V3, o3-mini, and OpenAI’s o1 reference. 

Why an FP8 Build Matters

Alongside the bf16 release, Alibaba published a fully FP8-quantised version. Dropping to eight-bit floats slashes VRAM by roughly 40 % while preserving accuracy, paving the way for single-GPU inference or even multi-GPU laptop rigs. Apache-2.0 licensing means startups can bake the FP8 weights directly into commercial products without costly negotiations. 

Community Reception: K2 Who?

Reddit’s r/singularity lit up within minutes: “Kimi K2 is already irrelevant,” read the top-voted post, linking to the Qwen tweet and highlighting the model’s 4.2× smaller total size yet broader win-rate.  Analysts on Interconnects echoed the sentiment, framing the drop as part of a summer in which Chinese labs “continue to dominate” the open-weight leaderboard and openly court Western builders. 

Beyond Benchmarks: Agentic DNA

Qwen3’s team stresses that the instruct model is tuned for tool-calling and agent workflows. The official model card shows code snippets for integrating with Qwen-Agent and MCP config files, underscoring Alibaba’s push toward practical automation at 262 K-token scale—think mega-docs, legal contracts or multi-day chat histories without windowing hacks. 

Why It Matters

Qwen3-235B-A22B-Instruct-2507 sets a new bar for “open yet frontier-grade.” By decoupling “thinking” and “non-thinking” modes into separate models, Alibaba embraced community feedback while sidestepping latency complaints. The result is a release that:

• outperforms larger proprietary models on knowledge, reasoning, and multilingual tests;

• ships under a permissive license;

• arrives in both bf16 and FP8 flavors for hobbyists and enterprises alike;

• proves that giant MoEs can be resource-friendly—and, crucially, available today.

For AI enthusiasts and builders, the message is clear: grab the weights, spin up your agent stack, and see how far 22 B active parameters can take you. The open-source race just found a new pacesetter.

Gemini “Deep Think” Hits Gold-Medal Performance at the International Mathematical Olympiad

 

From Silver to Gold in Twelve Months

Last year, DeepMind’s AlphaGeometry and AlphaProof systems collectively solved four of six IMO problems, earning a silver-medal equivalent. In July 2025 the research team leap-frogged that result: an advanced version of Gemini running in “Deep Think” mode solved five of six tasks for 35 points—crossing the 2025 gold-medal threshold and setting a new AI milestone.

International coordinators graded Gemini’s written solutions using the same rubric applied to student competitors. According to IMO President Gregor Dolinar, the proofs were “clear, precise, and, in several cases, easy to follow”.

---

What Makes Deep Think Different?

Technique	Purpose	Impact on Performance
Parallel Thinking	Explores multiple proof avenues simultaneously, then merges the strongest ideas.	Avoids dead-end, single-thread chains of thought.
Reinforcement-Learning Fine-Tune	Trains on curated theorem-proving and problem-solving data with reward signals for conciseness and rigor.	Raises success rate on multi-step reasoning challenges.
High-Quality Solution Corpus	Ingests expertly written IMO proofs plus heuristic “tips & tricks.”	Gives the model stylistic and structural templates for clearer presentation.

These upgrades let Gemini run longer “scratch-pads” internally while staying within a feasible compute budget—no multi-day cluster runs were required, unlike earlier systems.

---

Benchmark Significance

• 35 / 42 points → comparable to a top-25-percent human gold medalist.

• Perfect scores on five problems; only one combinatorics task eluded the model.

• Order-of-magnitude speed-up vs. AlphaGeometry 2 + AlphaProof, which needed days of inference in 2024.

While specialized theorem solvers have mastered narrow domains, Gemini Deep Think is a general LLM—capable of chat, code, and multimodal tasks—now showing elite mathematical reasoning.

---

Broader Implications

1. Curriculum Design for AI
   Gemini’s success underscores the value of domain-targeted reinforcement learning on top of large-scale pre-training.

2. Parallel Thinking as a New Primitive
   Instead of a single “chain of thought,” future models may default to branch-and-merge reasoning, akin to how human teams brainstorm proofs.

3. Human–AI Collaboration
   DeepMind notes the technique could become a “proof assistant” for mathematicians—surfacing lemmas or counter-examples at gold-medal quality within minutes.

4. Educational Outreach
   Publishing the solutions provides a free study resource for aspiring IMO contestants and teachers, potentially leveling the global playing field.

---

Limitations & Next Steps

• Interpretability: Despite clearer written proofs, the internal decision tree remains opaque—researchers are now probing why certain branches survive the merge.

• Generalization: Performance on under-represented areas (e.g., functional equations) still lags; future training will widen topic coverage.

• Trust & Verification: Formal proof checkers like Lean are being integrated to machine-verify each Gemini output before publication.

DeepMind plans to open selected Deep Think capabilities via its Gemini API later this year, with safeguards to prevent misuse in academic competitions.

---

Key Takeaway

Gemini Deep Think’s gold-medal performance doesn’t just raise the bar for AI mathematics—it redefines what general-purpose language models can achieve when armed with structured parallel reasoning and tailored RL training. The achievement brings researchers a step closer to AI systems that can tackle longstanding open problems and act as partner mathematicians rather than mere calculators.

ParaStudent teaches a 7-B LLM to “struggle” like a freshman coder

 Large language models ace coding contests, but they rarely mimic the process of bumbling through a CS-101 assignment. With ParaStudent, Mihran Miroyan and colleagues at UC Berkeley show how to make an LLM act less like Stack Overflow and more like a sleep-deprived undergrad. The team fine-tuned Qwen-2.5 Coder 7B on 60 000 timestamped submissions from four semesters of an introductory Python course, then built an evaluation suite that scores outputs on semantics, functional correctness and style. 

Why “student-like” code matters

Personalised tutoring agents, auto-graders and curriculum-design tools need more than perfect solutions; they must anticipate syntax errors, awkward variable names and half-fixed bugs so they can give pedagogically useful feedback. Synthetic data that faithfully captures those quirks could unblock privacy-constrained research or bootstrap new courses with thin enrolment.

Three pillars of ParaStudent

Component	What it does
Fine-tuned model (qwen-student)	Learns error patterns, verbose style and incremental edits by ingesting full submission streams.
Low- vs high-resolution tests	Snapshot evaluation (first/middle/final attempt) and frame-by-frame trajectory tracking reveal where models drift from real learners.
Multi-dimensional metrics	Combines code-embedding distance, unit-test pass rate, AST edit distance and style vectors to judge realism beyond “does it run?”.

Key results

• Closer trajectories. In the shared feature space Φ, qwen-student’s path hugs the real-student curve; GPT-4.1 and instruction-tuned Qwen jump straight from buggy to perfect, skipping the messy middle.

• More human errors. Fine-tuning boosts coverage of common novice mistakes (off-by-one, misuse of max, stray print) by 2-3× versus prompting alone.

• Style diversity. Edit-distance plots show qwen-student makes smaller, more frequent fixes, mirroring midnight-crunch behaviour, while GPT-4.1 rewrites whole files in one sweep.

• Open & lightweight. Training ran on a single A100; code and evaluation scripts are on GitHub.

Take-aways for ed-tech builders

1. Fine-tune, don’t prompt. Prompt-only models default to polished, one-shot answers—great for Stack Overflow, bad for teaching loops.

2. Grade more than tests. Functional pass rate alone misses stylistic growth; ParaStudent’s metrics catch whether a learner’s code looks like a novice even when it finally works.

3. Synthetic data is feasible. A 7 B open model can generate realistic class-size corpora without enterprise GPUs or proprietary APIs.

The authors release all data processing pipelines under a permissive licence, inviting researchers to port the approach to other languages or higher-level courses. Next on the roadmap: privacy-preserving fine-tuning and fully autoregressive “semester simulators” that could stress-test tutoring agents before they ever meet a real student.

Paper link: arXiv 2507.12674 (PDF)

WebShaper turns data generation for web agents into a set-theory science

 LLM-powered web agents nibble at problems once reserved for human researchers, but they’re starving for the one thing that matters—clean, diverse question-answer trajectories. Most teams still scrape pages first and dream up queries later, a workflow that tangles reasoning paths and spawns hallucinated answers. Alibaba’s Tongyi Lab says it has a better recipe: WebShaper, a “formalization-driven” data factory that starts with mathematics, not HTML. 

From ad-hoc scraping to knowledge projections

At the heart of WebShaper is a set-theoretic vocabulary called Knowledge Projections (KP): each KP is the set of entities linked by a single relation ( bornIn, playsFor, etc.). Two operations—union and intersection—let the authors compose arbitrarily deep queries and guarantee that every synthetic problem has a fully specified reasoning graph. The formal spec acts as a skeleton; only then does an agentic “Expander” venture onto the open web to fetch evidence that satisfies each KP node. 

A multi-step agent that grows harder questions

WebShaper starts with 18 k seed Q&A pairs distilled from an offline Wikipedia crawl, then pushes them through n-step expansions. At each step, the Expander retrieves fresh pages, validates candidates, and rewrites the KP tree into a tougher query—controlling complexity like a curriculum designer rather than a random crawler. 

Why it matters

• Broader coverage – formal specs explore search patterns unconstrained by whatever a scraper happened to collect.

• Structural consistency – answers align with the reasoning graph, slashing mismatched Q–A pairs.

• Dial-a-difficulty – KP depth and branching let teams script “easy” or “nightmare” tasks on demand. 

State-of-the-art results with leaner data

Training a 72 B agent on the new dataset catapulted WebShaper-72B to 60.2 % on GAIA’s information-seeking subset, beating Claude-Sonnet, GPT-4.1 and Gemini 2.5 Pro when all models shared the same two browsing tools. Even the 32 B version tops WebDancer and SimpleDR. 

Model	GAIA ↑	Notes
WebShaper-72B	60.2 %	new SOTA
Claude-Sonnet *	58.3 %	proprietary
WebShaper-32B	55.4 %	open
WebSailor	55.3 %	open
GPT-4.1 *	48.5 %	proprietary

* scores reported using the same browsing APIs

Because the formal spec eliminates redundant retrieval, WebShaper needs ~42 % of the tokens consumed by earlier pipelines such as WebDancer, yet still outperforms them on WebWalkerQA. 

Open kits for builders

All resources are public:

• Dataset: on Hugging Face and ModelScope

• Code: GitHub/Alibaba-NLP/WebAgent, including the Expander scripts

• Checkpoints: 32 B & 72 B SFT models ready for RL fine-tuning 

The bigger picture

WebShaper reframes web-agent training as data geometry rather than brute-force scraping. By baking reasoning patterns into the data itself, it closes the loop between question design and answer verification—an approach that could spill over into multi-hop RAG, legal search and even agentic code auditors. The message is simple: if you can formalize the hunt, you can synthesize the bounty.

Paper link: arXiv 2507.15061 (PDF)