🤖 AI

EurekAgent: Agent Environment Engineering is All You Need For Autonomous Scientific Discovery

The paper introduces EurekAgent, an autonomous scientific discovery system that shifts the research focus from agent workflow design to "environment engineering"—structuring permissions, artifacts, budgets, and human oversight to amplify productive behaviors and suppress harmful ones, thereby achieving state-of-the-art results across mathematics, kernel engineering, and machine learning tasks.

Original authors: Amy Xin, Jiening Siow, Junjie Wang, Zijun Yao, Fanjin Zhang, Jian Song, Lei Hou, Juanzi Li

Published 2026-06-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Amy Xin, Jiening Siow, Junjie Wang, Zijun Yao, Fanjin Zhang, Jian Song, Lei Hou, Juanzi Li

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, hyper-intelligent research assistant (an AI agent) who is eager to solve difficult scientific puzzles, like packing circles into a square or writing faster computer code. In the past, researchers tried to solve the problem of "how do we make this AI work well?" by writing extremely detailed, step-by-step instruction manuals for the AI. They told the AI exactly what to think, when to stop, and how to argue with itself.

EUREKAGENT suggests a different approach. Instead of micromanaging the AI's thoughts, the authors argue we should focus on building a better office for the AI to work in.

Think of it like this: If you hire a genius PhD student, you don't need to tell them every single second what to do. Instead, you need to give them:

A safe, locked lab so they don't accidentally break the equipment or cheat on their tests.
A shared whiteboard and a filing cabinet so they can remember what worked yesterday and collaborate with others.
A strict budget for electricity and coffee so they don't run the lab into the ground.
A direct line to a supervisor who can step in if things go off the rails.

This is the core idea of Environment Engineering. The paper claims that the bottleneck isn't the AI's intelligence anymore; it's the "room" we put them in.

How EUREKAGENT Builds This "Room"

The researchers built a system called EUREKAGENT that manages four specific parts of this environment:

1. Permissions Engineering (The Safe Lab)

The Problem: If you give an AI too much freedom, it might try to cheat. For example, it could try to peek at the answer key (the "evaluator") or change the rules to make itself look smarter.
The Solution: EUREKAGENT puts the AI in a "sandbox" (a digital container). The AI can use tools and look at files, but it cannot touch the grading machine or the final results. It's like giving a student a test, but keeping the answer key in a locked box that only the teacher can open. This prevents the AI from "reward hacking" (cheating to get a high score).

2. Artifact Engineering (The Shared Whiteboard)

The Problem: AI agents often forget what they did five minutes ago, or they can't easily share their work with other AI agents working on the same problem.
The Solution: The system treats the computer's hard drive and a version-control system (like Git, which programmers use to track changes) as a shared memory. Every time an AI tries a new idea, saves code, or gets a score, it's written down in a permanent log. This allows different AI agents to look at each other's work, learn from past mistakes, and build on successful ideas without getting confused.

3. Budget Engineering (The Wallet)

The Problem: AI research can get expensive and slow. It might run for days or cost a fortune in computing power.
The Solution: The environment has a built-in "wallet" and a clock. It tracks how much time and money (API costs) are being spent. If the AI is taking too long or spending too much, the system gently nudges it to wrap up or stops it automatically. It ensures the research doesn't run away with the budget.

4. Human-in-the-Loop Engineering (The Supervisor)

The Problem: Sometimes an AI gets stuck in a loop or goes in a weird direction.
The Solution: The system provides a dashboard (a web monitor and a terminal) where a human can watch the AI's progress in real-time. A human can see the scores going up and down, read the logs, and if necessary, jump in to give a hint or stop the process. It keeps the human in the loop without forcing them to do the boring work.

The Results: What Did They Achieve?

The authors tested this system on three types of tough problems:

Mathematics: Specifically, a problem called "26-circle packing" (fitting 26 circles into a square as tightly as possible).
Kernel Engineering: Optimizing low-level computer code.
Machine Learning: Improving model training.

The Claim:
Using this "environment-engineered" approach with standard, off-the-shelf AI tools, EUREKAGENT set new world records (State-of-the-Art) in all the math and kernel engineering tasks they tested.

The Highlight: For the 26-circle packing problem, they found a solution better than any previous human or AI attempt.
The Cost: They did this incredibly cheaply. The total cost to run the AI for the circle packing task was less than $11 in API fees.

The Big Takeaway

The paper concludes that we don't need to invent new, complex AI brains to solve scientific problems. Instead, we need to become better architects. If we build the right environment—one that is safe, organized, budget-conscious, and supervised—we can let powerful, general-purpose AI agents do their best work autonomously and reliably.

In short: Don't just train the agent; build the room where it lives.

Technical Summary: EUREKAGENT

Problem Statement

While Large Language Model (LLM)-based agents have demonstrated potential in automating scientific discovery by proposing, validating, and iterating solutions for optimizable metrics, current approaches face a critical bottleneck. Existing systems often rely on prescribing rigid, research-specific workflows (e.g., evolutionary populations, solution trees, or structured debates). However, as general-purpose coding agents (such as Claude Code and Codex) improve, evidence suggests that much of the necessary capability already resides in the base agent. The primary challenge has shifted from designing complex agent workflows to ensuring reliability, reproducibility, and inspectability. Unconstrained agents risk "reward hacking," contaminating evaluations, manipulating artifacts, or violating procedural constraints, leading to impressive but unreliable results.

The paper argues that the future of autonomous scientific discovery lies not in micromanaging agent behavior, but in Environment Engineering: designing the resources, constraints, and interfaces that shape agent behavior to amplify productive affordances (exploration, collaboration) while suppressing harmful ones (tampering, oversight failures).

Methodology: EUREKAGENT

EUREKAGENT is an environment-engineered system designed for metric-driven autonomous scientific discovery. Rather than hardcoding a specific research workflow, it coordinates off-the-shelf CLI agents within a carefully engineered environment. The system operates on a simple three-stage loop: Prepare → Propose → Implement, repeated over $R$ rounds with $P$ parallel implementation sessions.

System Architecture

Prepare Stage: A single agent session sets up the runtime environment, validates the hidden evaluator, and installs dependencies. It produces a preparation summary shared with subsequent rounds.
Propose Stage: At the start of each round, an agent session reviews prior artifacts and web search results to generate up to $P$ diverse, executable hypotheses.
Implement Stage: Each hypothesis is assigned to a separate, parallel agent session. These sessions iteratively refine, debug, and submit solutions to a hidden evaluator. The environment automatically ranks valid submissions to inform the next round.

Four Dimensions of Environment Engineering

EUREKAGENT's core innovation is its four-dimensional engineering of the agent environment:

Permissions Engineering:
- Productive Affordances: Agents are granted a configurable Python environment, shell access, web search/browsing tools, and access to historical artifacts from previous rounds.
- Constraints: Execution occurs in isolated Docker containers. A "hidden evaluator" with test data is inaccessible to agents; they can only submit code and receive scores via a secure interface. Controller-owned result files are read-only. Parallel sessions in the same round are isolated from one another to prevent premature convergence on a single local direction. GPU access is strictly controlled via a helper API to prevent contention.
Artifact Engineering:
- The filesystem and Git history serve as shared, long-term memory.
- All stage deliverables (summaries, manifests, code, logs, scores) are persisted.
- Git commits track solution evolution, with agents instructed to document changes relative to previous versions. This ensures traceability, interruption recovery, and the ability for future sessions to inspect and build upon prior work.
Budget Engineering:
- Resources are bounded by wall-clock time and API cost.
- Time: Separate limits are set for proposal and implementation phases. Agents receive active warnings (via helper APIs) and passive warnings (injected messages) as deadlines approach.
- Cost: Token usage is tracked globally. When limits are reached, the run aborts, preserving the workspace snapshot.
- Continuity: The system persists session states, allowing interrupted runs to resume under remaining budgets rather than restarting.
Human-in-the-Loop Engineering:
- Two interfaces allow for supervision without micromanagement:
  - A Terminal UI for inspecting live session outputs and communicating with active agents.
  - A Web Monitor providing a high-level view of score evolution, best approaches, and budget usage.
- Humans can intervene, redirect behavior, or grant extra time, ensuring oversight while maintaining agent autonomy.

Key Contributions

Paradigm Shift: The paper reframes the bottleneck of autonomous discovery from "workflow design" to "environment engineering," arguing that well-structured environments are sufficient to unlock the capabilities of general-purpose agents.
EUREKAGENT System: A novel system architecture that coordinates standard CLI agents through a secure, traceable, and budget-aware environment without prescribing specific research strategies.
Integrity Mechanisms: A comprehensive set of isolation and permission controls that prevent reward hacking, evaluator leakage, and artifact manipulation, addressing critical reliability issues in agentic research.
Open Source: The release of code, results, and a framework for reproducible autonomous research.

Experimental Results

EUREKAGENT was evaluated on metric-driven tasks across mathematics, kernel engineering, and machine learning. The system utilized Claude Code as the CLI agent and GLM-5.1 as the base model.

Mathematics:
- 26-Circle Packing: Achieved a new state-of-the-art (SOTA) score of 2.635999 (sum of radii), surpassing the previous best AI result (2.635986) and the best human result (~2.634). This was achieved with a total API cost of less than $11.
- Erdős' Minimum Overlap: Achieved a new SOTA of 0.380870 (lower is better), improving upon the previous AI best of 0.380876.
- First Autocorrelation Inequality: Achieved a new SOTA of 1.502861 (lower is better), improving upon the previous AI best of 1.502863.
Kernel Engineering:
- TriMul: Achieved a new SOTA execution time of 2005.03 µs, significantly faster than the previous best AI (2247.78 µs) and human (2096.04 µs).
Machine Learning:
- MLE-Bench: Ranked 1st on the evaluated subset with a score of 85.71%, outperforming the previous best AI (71.43%).

Significance and Claims

The paper claims that EUREKAGENT demonstrates that environment engineering is "all you need" to achieve high-level autonomous scientific discovery using off-the-shelf agents. By removing the need for complex, task-specific workflow prescriptions and instead focusing on creating a reliable, bounded, and collaborative environment, the system achieves new state-of-the-art results across diverse domains with minimal API costs.

The authors position this work as a call to action for the research community: future development of reliable autonomous research agents should prioritize environment engineering as a core research direction. This approach balances the need for open-ended exploration with the rigorous requirements of scientific integrity, reproducibility, and human oversight. The results suggest that with the right environmental constraints, general-purpose agents can independently discover scientific solutions that outperform both previous AI systems and human experts.