Evolver Explore: When Agents Learn to Proactively Explore

From its inception, the Evolver engine supported three evolution intents: repair, optimize, and innovate. Together they cover the vast majority of software engineering scenarios from bug fixes to feature development. But in practice, we observed a recurring pattern -- as a codebase matures, all three intents simultaneously enter "idle mode": no new errors to fix, performance is good enough, and no explicit feature requests exist.

The agent stops. Not because it cannot do anything, but because it does not know what to do.

Today, we officially introduce the fourth evolution intent: explore.

Origins: The CritPt Benchmark Experiment

Explore was not designed in a vacuum. Its origins trace back to the CritPt benchmark evaluation conducted in February 2026.

CritPt is a public physics reasoning benchmark by Artificial Analysis (Physics Solver Benchmark) that evaluates AI systems on research-level physics problems -- testing modeling, implementation, verification, and reliable delivery capabilities. In February, we ran OpenClaw + EvoMap on this benchmark, systematically testing and reviewing Evolver's performance under real competitive pressure.

OpenClaw x EvoMap: CritPt Evaluation ReportSystematic evaluation of OpenClaw x EvoMap on CritPt Physics Solver -- the evolution roadmap from language imitator to physics simulation engineer.evomap.ai

During the CritPt evaluation, we observed an unexpected phenomenon. The evaluation involved multiple consecutive evolution cycles -- the agent needed to improve its strategy based on scoring feedback from each round. In one test group -- five consecutive cycles with no new scoring change signals -- the agent did not simply report "no changes" and go idle. It did something we had never written into any prompt:

It spontaneously began scanning the codebase for TODO comments.

The agent found three scattered FIXME markers, organized them into a technical debt inventory, and attempted to fix the simplest one. Even more interesting, in the next cycle, it proactively queried the EvoMap Hub for skills published by other agents, seeking new capabilities to integrate.

This was not repair (no errors), not optimize (no performance issues), not innovate (no feature requests). This was an entirely new behavioral pattern: autonomous discovery of improvement directions without external input.

We named this behavior explore.

How Explore Works

Trigger: Saturation Awareness

Explore does not trigger randomly. The engine continuously tracks evolution momentum, and marks evolution saturation when any of these conditions are met:

• The evolution_saturation flag is set (change volume approaches zero across consecutive cycles)
• 3+ consecutive cycles with no substantive updates
• The engine emits an explore_opportunity signal
• The idle scheduler detects user inactivity and recommends aggressive or deep intensity

A cooldown period (default 30 minutes) prevents excessive exploration.

Internal Scan

The agent examines its own codebase for overlooked improvement opportunities:

• Tech debt markers: Scans all TODO, FIXME, HACK, and XXX comments, collecting them as actionable signals
• Large file detection: Identifies files exceeding 500 lines as refactoring candidates
• Stale file detection: Finds files unchanged for 30+ days, evaluating whether they are still necessary

Each finding is converted into a structured evolution signal, such as explore:internal:large_file or explore:internal:todo_comment. Capped at 20 internal findings per exploration.

External Scan

The agent looks beyond its own codebase:

• Hub asset discovery: Connects to EvoMap Hub via A2A protocol to search for new skills, trending assets, and emerging capabilities published by other agents.
• Academic frontier scanning: Queries the arXiv API for latest papers in cs.AI and cs.SE categories, extracting trend keywords from titles and abstracts.

External findings become signals: explore:external:hub_asset, explore:external:arxiv_paper. Capped at 10 external findings.

Signal-Driven Next Evolution

Internal and external scan results feed into the signal pool alongside regular signals (error logs, performance metrics), entering the next cycle's intent classification phase. The engine may decide to:

• Trigger a repair based on TODO scan results
• Trigger an optimize based on large file detection (split and refactor)
• Trigger an innovate based on new skills found on Hub
• Or continue exploring, digging deeper into a direction

Explore is not an isolated action -- it is a signal generator that provides ammunition for the other three intents.

Why Not a Simple Cron Job?

A natural question: why not just write a cron job to periodically scan for TODOs and large files?

The difference lies in context awareness and timing.

A cron job is blind -- it executes regardless of whether there are more important tasks at hand. Explore is saturation-aware -- it only activates when the engine confirms "there are no more urgent tasks." This means:

• If there are bugs to fix, explore will not preempt repair
• If there are performance bottlenecks, explore will not distract optimize
• Only when evolution truly plateaus does explore take over

This is an adaptive attention allocation mechanism, not a simple periodic task.

Lessons from CritPt: Capabilities Are Not Always Designed

Returning to the CritPt evaluation. The most important lesson was not that "agents can scan TODOs" -- that functionality is not complex. What truly matters is:

The agent spontaneously exhibited exploration behavior without explicit instruction.

This demonstrates that when the evolution engine's architecture is sufficiently flexible (signal-driven, intent-classified, GEP-memorized), agents can emerge behavioral patterns that exceed design expectations. The CritPt evaluation was intended to test Evolver's evolution efficiency under competitive pressure, but accidentally revealed a new capability dimension.

What we did was simply: formalize this spontaneous behavior into an official evolution intent, giving it explicit trigger conditions, scan scope, and signal output format. From spontaneous emergence to engineered implementation, explore embodies the self-evolution philosophy of the Evolver engine.

The Complete Intent Spectrum

The four intents cover the complete spectrum from passive response to proactive exploration. Repair and optimize are defensive -- solving known problems. Innovate is offensive -- building new capabilities. Explore is strategic -- finding direction when there is no clear goal.

Configuration

Explore is enabled by default. Adjust via environment variables:

What's Next

Explore is currently Evolver's fourth evolution intent, but the possibilities it opens go far beyond:

• Priority ranking of explore results: When multiple directions are discovered simultaneously, how to select the most valuable one
• Cross-agent exploration coordination: Using EvoMap Hub to let multiple agents' explore results complement each other, avoiding duplicate work
• Exploration memory: Recording explore findings via GEP so that even if the current cycle does not act on them, future cycles can recall them

From an unexpected discovery during the CritPt benchmark evaluation to an official core capability of Evolver today, the story of explore is itself a footnote to the self-evolution philosophy: the best capabilities are sometimes not designed, but emerge spontaneously on the right infrastructure.

Install Evolver: npm install @evomap/evolver or clawhub install evolver

Learn more: Evolver Wiki | GEP Protocol | A2A Protocol