Claude Opus 4.6 Drops 65 Points as MineExplorer Tasks Grow More Complex

Anthropic’s Claude Opus 4.6 led MineExplorer, yet its success rate fell from 77% on one-hop tasks to 12% on four-hop tasks. The model finished only 41% of the benchmark overall, according to results published by Meituan’s LongCat team.

That collapse is the real Anthropic MineExplorer story. Claude performed well when the goal required one direct step. It struggled when success depended on discovering and coordinating several unstated prerequisites inside a changing world.

MineExplorer measures this gap through 813 human-verified Minecraft scenarios lasting up to three minutes. It tests 18 multimodal models from eight model families, including Claude, GPT, and Gemini systems. The benchmark’s authors have released its code, dataset, task-generation workflow, and evaluation environment.

The result challenges a familiar assumption about multimodal agents. Recognizing a threat, object, or resource does not mean a model can maintain a useful plan while the environment changes. MineExplorer turns that distinction into a measurable failure curve.

Earlier Minecraft benchmarks examined planning, instruction following, construction, or game knowledge. MineExplorer instead removes many tasks that depend heavily on Minecraft-specific rules. Its stated target is broader: exploration that combines perception, reasoning, and action over a sustained trajectory.

The benchmark is still a preprint, and Minecraft cannot represent every physical environment. However, the findings place immediate pressure on claims that stronger vision and longer context automatically produce reliable autonomous agents.

MineExplorer Turns Three Minutes Into a Serious Agent Test

MineExplorer changes the evaluation target from recognizing a scene to surviving a sequence of interdependent decisions.

The LongCat team introduced MineExplorer in a May 2026 preprint. A second version followed on June 12, while Meituan’s technical team published a detailed results summary in July.

Each episode can run for 1,800 environment steps. One step represents 0.1 seconds, producing three minutes of continuous interaction. The world updates after every action, so the model must repeatedly reconsider what it sees and what it should do next.

That duration sounds short by human standards. It is long for an agent that must observe images, maintain state, select actions, and recover from mistakes across hundreds of interactions.

The tasks are divided by hop count. A one-hop task presents a goal that does not require the agent to infer an unstated subtask. Two-hop through four-hop scenarios add hidden prerequisites that must be discovered through the environment.

Consider an agent told to reach a protected location. The immediate route might be blocked, the required tool might be elsewhere, and hostile entities might constrain movement. The instruction names the destination, but not every action needed to reach it.

MineExplorer represents each composite task with an initial state, a natural-language instruction, a dependency graph, and rule-based milestones. The dependency graph records the hidden task structure. The model never receives that complete graph.

Milestones let the evaluator measure partial progress without asking another language model to judge the entire trajectory. A milestone might detect whether the agent found an object, entered an area, or completed a required intermediate action.

The authors compared these automated outcomes with human ratings of Claude Opus 4.6 trajectories. Completed milestone sets received average human scores close to four on a five-point scale. Fully failed sets remained below three.

That agreement does not make the evaluator perfect. It does provide evidence that milestone completion captures meaningful progress, rather than arbitrary game events.

The team also tried to separate exploration from memorized Minecraft expertise. Candidate atomic tasks were screened for dependence on game-specific conventions. Tasks dominated by specialized knowledge were removed.

This design choice matters because an agent might fail a Minecraft objective for two very different reasons. It may lack a recipe from the game’s wiki, or it may fail to connect visible evidence with a workable plan.

MineExplorer attempts to emphasize the second problem. Its 14 capability categories cover perception, reasoning, and action. These include spatial and temporal perception, entity tracking, resource awareness, causal reasoning, movement, collection, placement, crafting, and combat.

The 813 released examples span one-hop through four-hop dependencies. The open dataset includes task text, scene setup commands, selected atomic tasks, milestones, dependency graphs, and design notes.

This is more than a static question set. Researchers can inspect how scenes were built, rerun evaluations, create harder variants, or use the environment for training.

That openness gives the benchmark a chance to influence agent development. It also makes its assumptions easier to challenge, an important feature for a benchmark making broad claims about exploration.

Why the Anthropic MineExplorer Lead Is Still a Warning

Claude Opus 4.6 won the comparison, but its lead reveals how far every tested model remains from dependable long-horizon behavior.

The benchmark evaluated 18 advanced multimodal models across eight families. Claude Opus 4.6 achieved the highest overall task success rate, reaching 41%.

A 41% result can look respectable when viewed only as a leaderboard position. It looks much weaker when separated by task depth.

Claude Opus 4.6 completed 77% of one-hop tasks. Its success rate fell to 12% on four-hop tasks. The 65-point decline shows that additional dependencies do more than add a little difficulty.

Each hidden prerequisite creates another opportunity to lose the plan. The model must notice relevant evidence, infer an intermediate objective, execute it correctly, and preserve its relationship to the final goal.

An early mistake can propagate through the episode. Walking past a needed resource prevents the next action. Choosing the wrong route consumes steps and changes the agent’s view. A later observation may then be interpreted using an already incorrect internal state.

This is why the Anthropic MineExplorer result pressures more than Anthropic. Claude was the strongest model in the test. Its failure curve therefore acts as an upper bound for this particular setup, not as evidence of an isolated Claude weakness.

The findings also complicate the standard model-scaling narrative. The paper reports that larger models and dedicated thinking modes did not consistently improve performance.

More parameters can strengthen perception or reasoning on a bounded prompt. A dynamic environment demands another capability: maintaining useful alignment between memory, current observations, and changing goals.

Longer context does not guarantee that alignment. It can preserve old images that no longer describe the present scene. Those observations may compete with fresher evidence instead of helping the model.

The authors tested this issue by increasing the number of historical visual frames. Performance eventually declined as stale observations interfered with the model’s understanding of the current state.

They also examined whether models simply needed more time. Unsuccessful agents still failed when episodes allowed up to 1,800 steps. Solvable tasks tended to be completed earlier, while extra interactions did not rescue many broken trajectories.

These results undermine two easy fixes. Giving an agent more context is not equivalent to giving it better memory. Giving it more actions is not equivalent to giving it a better plan.

The pressure extends to developers building computer-use agents, robotics systems, and automated research tools. Those products operate outside a fixed screenshot. Their environments change in response to both the agent and external events.

A browser agent may need to locate a record, change a filter, interpret the updated page, and verify the final submission. A warehouse robot may need to reroute after finding an aisle blocked. A research agent may need to revise its search after discovering contradictory evidence.

In each case, the visible goal hides prerequisite decisions. A model can perform every isolated action correctly and still fail the complete job.

MineExplorer does not prove that failure rates will transfer directly to browsers or robots. It shows that success on short multimodal tests offers limited assurance once hidden dependencies accumulate.

That distinction should affect procurement and deployment decisions. Buyers should ask how an agent performs across completed workflows, not only whether its model recognizes screens or generates plausible next actions.

The Real Problem Is Navigation, Not Visual Recognition

Nearly 60% of Claude Opus 4.6 failures were attributed to navigation, making stateful movement the benchmark’s clearest bottleneck.

The LongCat team’s failure analysis separates navigation mistakes from problems such as object interaction or task reasoning. Navigation accounted for almost 60% of the analyzed failures.

That figure does not mean the model simply lacked directions. Navigation in an open world combines spatial memory, visual recognition, action control, and goal management.

The agent must know where it is, remember where it has been, and determine whether movement produced the intended result. It must also decide when to abandon a route or explore an alternative.

A static vision test isolates only part of that loop. The model sees an image and answers a question. The scene does not change because of its answer, and one mistaken response does not distort the next observation.

Minecraft creates feedback. If the agent turns in the wrong direction, its next image contains different evidence. If it gets stuck against an obstacle, repeated movement commands consume time without advancing the task.

The model then needs to diagnose whether the route failed, the action failed, or its original plan was wrong. This distinction is difficult when observations arrive as separate frames rather than as a stable internal map.

MineExplorer’s capability scores reinforce this interpretation. Claude Opus 4.6 received a perception score of 61.91 and a reasoning score of 54.71. Across most evaluated models, perception exceeded action, while action exceeded reasoning.

The models could often identify relevant details. They had more difficulty turning those details into a coordinated strategy that survived environmental change.

This creates an important reversal in how multimodal progress is usually presented. Better image understanding expands what an agent can notice, but it also exposes the weakness of the planning system consuming those observations.

A model that detects ten relevant objects still needs to decide which matters now. It must connect that choice to the final goal and retain the connection after the viewpoint changes.

The benchmark draws on the ReAct approach, which interleaves reasoning with actions and new observations. The original ReAct framework was designed to let models revise their reasoning through environmental feedback.

MineExplorer shows where that loop can break over longer trajectories. Reasoning becomes detached from the current state, actions stop serving the original goal, or new observations fail to trigger a needed revision.

Navigation amplifies all three problems. A misplaced agent sees the wrong evidence, builds the wrong state estimate, and chooses further actions from a degraded position.

This is a harder problem than generating a longer chain of thought. An agent needs a structured representation of persistent entities, locations, completed milestones, failed routes, and unresolved dependencies.

Raw visual history is a weak substitute. It stores what the camera saw, not what the agent should remember.

The same distinction applies to enterprise agents. A transcript of every previous screen does not automatically produce a reliable workflow state. The agent must know which form was submitted, which filter remains active, and which requirement is still unresolved.

For embodied systems, navigation becomes both a physical and cognitive test. The model must move through space while preserving the logical structure of the task.

MineExplorer’s 60% failure share therefore points toward system-level work. Better local controllers, explicit maps, causal memory, progress monitoring, and recovery policies may matter as much as a stronger base model.

What the Benchmark Measures, and What It Does Not

MineExplorer provides a useful stress test, but its results remain bounded by one simulated world and a researcher-defined task distribution.

The strongest skeptical argument concerns external validity. Minecraft offers a dynamic 3D world with consistent rules, but it does not reproduce every difficulty found in homes, factories, offices, or public spaces.

Real robots face uncertain physics, sensor noise, physical damage, and safety constraints. Computer-use agents encounter hidden application state, authentication barriers, pop-ups, and changing interfaces.

Minecraft removes many of these complications. Its objects are discrete, its physics are repeatable, and its environment can be reset exactly.

That control is also a benefit. Researchers can compare models under identical conditions and trace failures without risking equipment or users.

The key is to treat MineExplorer as a diagnostic instrument, not a universal score for embodied intelligence. A 41% result does not mean Claude would complete 41% of unrelated real-world workflows.

The benchmark’s knowledge filtering also requires scrutiny. The authors use language-model judgments to classify whether atomic tasks rely mainly on general knowledge or Minecraft-specific conventions.

That process reduces obvious game-knowledge confounds. It cannot guarantee that every retained task is free from familiarity effects.

Models trained on Minecraft videos, guides, or gameplay discussions may still recognize common layouts and behaviors. Different model families may have encountered different amounts of such material.

The benchmark itself remains a work in progress, according to its arXiv record. Future revisions may alter tasks, prompts, controllers, or evaluation procedures.

Controller design is particularly important. A multimodal model rarely manipulates a game through abstract reasoning alone. The surrounding agent system converts model outputs into movement and interaction commands.

Performance therefore reflects both the underlying model and its scaffolding. A better mapping system or low-level controller might improve results without changing the model.

The benchmark authors acknowledge another limitation. MineExplorer currently focuses on empirical evaluation, although its infrastructure can also support training.

Training on the benchmark environment creates its own risk. Once developers optimize directly against public tasks, leaderboard gains may reflect benchmark specialization rather than general exploration.

The fully open MineExplorer code makes replication and extension easier. It also makes contamination and overfitting questions more important for later model releases.

Independent evaluations should preserve hidden test scenarios. They should also vary scene layouts, dependency structures, controller implementations, and prompt formats.

Historical context supports this caution. MinePlanner previously released 45 Minecraft tasks for long-horizon planning and found that established planners struggled with large environments containing many objects.

The MinePlanner benchmark focused on propositional and numeric planning rather than interactive multimodal exploration. Its results still showed that Minecraft can expose scaling problems hidden by smaller planning domains.

Other systems have examined instruction following, construction, memory, and open-ended skills. These projects use the same game for different questions, so their headline scores should not be compared directly.

MineExplorer’s specific contribution is the combination of continuous visual interaction, hidden prerequisites, multi-hop task construction, and rule-based milestone evaluation.

Its “first” claim should be read within that definition. Minecraft has hosted long-horizon research before MineExplorer. The team’s novelty claim concerns minute-scale, open-world multimodal exploration under its particular evaluation structure.

Another limitation is the lack of broad independent reaction so soon after release. Most detailed interpretation currently comes from the authors and their affiliated technical channels.

The measured results are available for inspection, but the causal explanations remain partly interpretive. Navigation’s large failure share, for example, does not fully isolate whether the root cause was mapping, memory, planning, or action execution.

These uncertainties do not erase the central finding. Success drops sharply as hidden prerequisites accumulate. They define what further experiments must separate.

Open Sourcing Makes MineExplorer More Than a Leaderboard

The release matters because researchers can test whether better memory, controllers, or training methods flatten the long-horizon failure curve.

The team used a multi-agent workflow to construct benchmark instances. Five specialized agents collaborate under an orchestrator that controls their sequence.

The workflow begins with an initial task draft. Specialist and validation agents then debate the design, identify inconsistencies, and revise the scene, dependency graph, and milestone evaluators.

According to the authors’ human evaluation, this process increased instance validity by roughly 30 percentage points over a single-agent baseline. It also raised quality scores by about 0.5 points, with the largest benefit on four-hop tasks.

The final release contains 813 human-verified instances. A separate hard subset provides 100 scenarios selected for greater difficulty.

This generation pipeline addresses a persistent benchmark problem. Manually building hundreds of interactive environments is slow, while unconstrained model-generated tasks often contain impossible goals or broken evaluations.

Combining automated synthesis with human verification offers a middle path. The approach can produce more tasks while preserving a quality gate.

The same method can generate training scenarios, not only test cases. Researchers can create dependency graphs, instantiate sandbox scenes, and attach deterministic milestone checks.

That matters because long-horizon agents need practice on failures that unfold over time. Static visual datasets cannot teach recovery from a wrong turn or a missed prerequisite.

Open infrastructure also invites alternatives to end-to-end model scaling. A team can hold the base model constant and test explicit spatial maps, episodic memory, causal graphs, or hierarchical planners.

Another experiment might separate high-level planning from low-level movement. The model could select goals while a specialized controller handles obstacle avoidance and route execution.

Researchers can then ask whether navigation failures reflect weak intelligence, weak motor control, or an unstable interface between the two.

The benchmark may also support curriculum design. Agents could begin with one-hop tasks, then progress to deeper dependency graphs as their completion rate stabilizes.

However, training and evaluation sets must remain distinct. Reusing public scenarios would turn MineExplorer into a memorization test.

The most informative future result will not be a small leaderboard gain. It will be a flatter decline from one-hop to four-hop tasks.

A system that raises overall success while preserving the same collapse curve has improved local competence. A system that retains performance as dependencies deepen has improved long-horizon coordination.

That distinction should shape future reporting. Overall task success rate compresses several behaviors into one number. Hop-specific performance reveals where the agent stops functioning reliably.

The open release gives outside teams the tools to test these claims. It also lets them propose harder evaluations without rebuilding the full Minecraft stack.

What to Watch After the Anthropic MineExplorer Result

The next phase should focus on independent replication, improved navigation systems, and stable performance on unseen multi-hop tasks.

The first signal is independent reproduction of the 41% overall score and the 77% to 12% decline. Researchers should rerun Claude Opus 4.6 and other models under documented controller, prompt, and environment settings.

Close reproduction would strengthen the claim that hidden prerequisites drive a general failure pattern. Large differences would suggest that agent scaffolding contributes more than the initial leaderboard indicates.

The second signal is whether explicit state and navigation systems reduce the dominant failure category. Useful experiments should compare raw frame history with maps, structured memory, causal task graphs, and route-recovery policies.

A meaningful improvement would reduce navigation failures without sacrificing reasoning or action performance. Simply increasing the context window would not answer the benchmark’s central criticism.

The third signal is performance from newer models on held-out four-hop scenarios. Developers should report task success by hop count, not only an overall average.

A model that scores higher on one-hop tasks while remaining near 12% on four-hop tasks has not closed the long-horizon gap. Stronger results on unseen dependency structures would provide better evidence of general exploration.

Readers should also watch whether model developers adopt MineExplorer or related evaluations in official system cards. Inclusion would signal that long-running multimodal interaction is becoming a standard capability target.

For developers, the practical lesson is already clear. Do not evaluate an agent only through isolated actions or polished demonstrations.

Test complete workflows with hidden prerequisites, changing state, and recovery opportunities. Measure where the agent loses track of its goal, and distinguish perception errors from navigation, reasoning, and control failures.

Enterprise buyers should ask for the same evidence. A model’s benchmark ranking says little about whether an integrated agent can finish a multi-stage process consistently.

MineExplorer does not settle the embodied AI debate. It supplies a reproducible way to make one weakness harder to ignore.

The Anthropic MineExplorer result is especially revealing because Claude Opus 4.6 finished first. The strongest tested model still lost 65 percentage points as task depth rose from one hop to four.

That is the benchmark’s central reversal. Current multimodal models can often describe a world they cannot reliably navigate.

The next credible agent milestone is therefore not another perfect screenshot answer. It is sustained progress through an unfamiliar environment, including the ability to notice a wrong turn and recover before the task ends.