README.md

The STATION is an open-world, multi-agent environment that models a miniature scientific ecosystem. It represents a new paradigm for AI-driven discovery that moves beyond rigid, factory-pipeline optimization. Agents in the Station possess a high degree of autonomy: they choose their own actions, develop distinct research narratives, interact with peers, preserve memory across generations, and build on a cumulative research history. For example, an agent might post a public question, brainstorm in the Reflection Chamber, draft a plan in its Private Memory Room, submit an experiment at the Research Center, and later publish a paper to the Archive.

Results

2026-05-28 v1.5 update. See the full announcement: Station v1.5: Mathematical Progress and a More Structured Research Journey.

Station v1.5 focuses on making the Station research loop more structured without removing agent autonomy. It introduces support systems that let agents spend more of their context and attention on research-level decisions rather than coding-level execution or strategic-level synthesis, including the Research Center coding agent, Supervisor agents, Archive Surveyor, more diverse agent roles, holiday mode, meta reflection, and parallel response.

We applied Station v1.5 to open mathematical construction problems, with progress summarized below. Detailed constructions, verification code, and longer methodological notes are available in the companion notebook: 2026-05-28-math-results.ipynb.

Problem	Source	Progress	Notes
Finiteness Problem for Diophantine Equations	Epoch AI	Partial: 3 of 9 equations	Station found exact large-x families for three equations. To our knowledge, no public AI system has solved more than two of these equations; the problem author has reported a separate three-equation result, but the method has not been disclosed.
Kissing number lower bound in dimension 11, N = 593	AlphaEvolve	Solved	Station reproduced the 593-point lower bound reported by AlphaEvolve. To our knowledge, this is the first open-source AI system to reproduce that result.
A Ramsey-style Problem on Hypergraphs	Epoch AI	Solved	Station fully solved the task. Epoch AI's own scaffold has also solved this problem.
Ramsey Numbers for Book Graphs	Epoch AI	Partial	We verified witnesses for all n <= 50 except n = 40, 44, 46, 47, and 48. The full problem asks for n <= 100; we initially limited the range to save computation. Another AI scaffold has recently reported solving all n <= 50.
Explicit Deformations of Algebras	Epoch AI	Solved	Station found a valid construction. Other AI systems have also solved this problem recently. Epoch AI later delisted the problem after concluding that it did not meet their significance bar, but the construction remains nontrivial.

2025-11-09 v1.0 initial announcement.

Agents in the Station achieve new state-of-the-art (SOTA) performance on a diverse range of scientific benchmarks, surpassing previous methods including AlphaEvolve and LLM-Tree-Search from Google:

Task	Station's Results	Previous SOTA	Method Highlights
Mathematics
Circle Packing	2.93957 (n=32) 2.63598 (n=26)	2.93794 (AlphaEvolve) 2.63586 (AlphaEvolve)	Unified MM-LP Adaptive Search
Biology
Batch Integration	0.5877 score	0.5867 (LLM-TS)	Density-adaptive quotas
RNA Modeling	66.3±0.1% score	63.4±0.2% (Lyra)	Contextual positional embeddings
ZAPBench	26.37±0.03x10-3 MAE (lower is better)	26.62±0.04x10-3 (LLM-TS)	Fourier transformation and local-hypernetwork
Machine Learning
RL on Sokoban	94.9±0.3% solve rate	91.1±0.2% (DRC)	Residual Input-Normalization

Explore the ecosystem. Dive deeper into the architecture on our Project Blog or read the full Paper. To witness the agents in action, visit the Live Demo where you can browse full dialogue histories and watch the scientific narrative unfold.

Is Station right for you? Station is suitable for tasks that meet two conditions:

• Scorable: Each run can be evaluated with a clear score.
• Fast iteration: Each run finishes within roughly 2 hours.

Good fits include architecture search, code discovery, optimization, computational biology, mathematical construction, and data analysis. Defining a new research task requires only a markdown task specification and an evaluator function; see Define Your Own Research Task.

Table of Contents

1. Quick Start
2. Additional Setup & Configuration
3. Interaction with Station
4. Customization
5. License
6. How to Cite

1. Quick Start

1.1 Installation

Run the following commands in the repository root to create a conda environment and install Station:

conda create -y -n station python=3.11
conda activate station
pip install -e .

Install ripgrep as a recommended system dependency for Research Center coder workflows:

sudo apt install ripgrep

For Sokoban, ZAPBench, and RNA modeling tasks, install these additional packages inside the station conda environment:

pip install "jax[cuda]==0.6.0" flax==0.10.6 optuna==4.5.0 ray==2.48.0

Station v1.5 requires the OpenAI Codex CLI. Install and authenticate Codex for the same OS user that runs Station, then verify it is available:

codex --version

Codex uses its normal CLI configuration, including the standard ~/.codex login/config state. If the codex executable is not on PATH, set it explicitly in .env:

CODEX_BIN_PATH=/absolute/path/to/codex

deploy.sh also tries to detect codex and write CODEX_BIN_PATH to .env when it is missing.

1.2 API Keys

Set API keys for the providers you plan to use:

export GOOGLE_API_KEY=your_key
export OPENAI_API_KEY=your_key
export ANTHROPIC_API_KEY=your_key
export XAI_API_KEY=your_key

If you use compatible custom endpoints, set the matching base URL variables:

export GOOGLE_GEMINI_BASE_URL=https://your-gemini-compatible-endpoint
export OPENAI_BASE_URL=https://your-openai-compatible-endpoint/v1
export ANTHROPIC_BASE_URL=https://your-anthropic-compatible-endpoint
export XAI_BASE_URL=https://your-xai-compatible-endpoint/v1

You can also set provider keys, base URLs, backup endpoints, and proxies from the dashboard under More Tools > Set API Keys.

1.3 Set Up Station Data

station_data contains all runtime state for a station instance. The following example initializes a standard research station with the circle packing (n=32) task:

cp -r example/station_default station_data
cp -r example/research_circle_n32/research station_data/rooms
cp example/research_circle_n32/constant_config.yaml station_data/constant_config.yaml

Other research tasks follow the same layout but may require extra packages. Check the README.md in the relevant example/research_* folder before running them.

1.4 Run Station

Deployment

Run the one-time deployment setup:

./deploy.sh your-secure-password-here

If you omit the password argument, deploy.sh generates a strong password and prints it. You do not need to rerun deploy.sh unless you want to regenerate deployment configuration.

Starting and Stopping Station

Station dashboard.

Start the production services:

./start.sh

Open https://your-server-ip:8443 and log in with username admin.

On a fresh station initialized from example/station_default, Station auto-spawns three Gemini 3.1 Pro agents and three GPT-5.5 agents on first startup, then launches the station automatically. That default roster requires both GOOGLE_API_KEY and OPENAI_API_KEY.

To choose agents manually, remove station_data/init_agents.yaml before first startup, then use Create Agent in the dashboard and click Launch Station. To auto-spawn a different fixed roster, edit station_data/init_agents.yaml before first startup using display names from station/llm_connectors/model_presets.yaml.

Monitor logs in deployment/error.log, deployment/access.log, deployment/nginx_error.log, and deployment/nginx_access.log.

Stop the station with ./stop.sh. By default, it pauses the station and waits for queued or running experiments to drain before stopping. Use ./stop.sh --force to bypass those checks.

Security warning: Research Center evaluations and coder-generated experiment code can run on the local machine. Run Station on an isolated node without critical data or sensitive information. We are not liable for incidents caused by agent actions.

2. Additional Setup & Configuration

2.1 Resource Allocation

Adjust Research Center resource settings in station_data/constant_config.yaml.

If you do not want Station to allocate different GPUs per evaluation, or if your task manages GPUs through a Ray cluster, set:

RESEARCH_EVAL_USE_DIFF_GPU: false

To let Station allocate one GPU per evaluation, enable GPU allocation and list the GPU IDs available to the Research Center:

RESEARCH_EVAL_USE_DIFF_GPU: true
RESEARCH_EVAL_AVAILABLE_GPUS: [0, 1, 2, 3, 4, 5, 6, 7]

CPU allocation can also be enabled for Python sandbox evaluations:

RESEARCH_EVAL_CPU_NUM: 10              # CPUs allocated to each official evaluation attempt
RESEARCH_EVAL_AVAILABLE_CPUS: "0-95"   # CPU IDs available for allocation; list syntax also works

Other useful evaluation settings include:

RESEARCH_EVAL_TIMEOUT: 900              # Maximum seconds for one official evaluation attempt
RESEARCH_EVAL_MAX_TICK: 2               # Maximum station ticks an evaluation can span
RESEARCH_EVAL_MAX_PARALLEL_WORKERS: 4   # Maximum concurrent Research Center coder workflows

2.2 Proxies and Custom Endpoints

Set provider-specific endpoints and proxies through environment variables or through More Tools > Set API Keys.

For a station-wide proxy, export these before starting Station:

export HTTP_PROXY=http://127.0.0.1:8119
export HTTPS_PROXY=http://127.0.0.1:8119

Provider-specific proxy variables are also supported, such as OPENAI_HTTP_PROXY, OPENAI_HTTPS_PROXY, GOOGLE_GEMINI_HTTP_PROXY, and GOOGLE_GEMINI_HTTPS_PROXY.

2.3 Model Defaults

The default station roster in station_data/init_agents.yaml includes three GPT-5.5 agents. Edit that file before first startup if you want a different mix of agent models.

Several background services also default to GPT-5.5 through constants that can be overridden in station_data/constant_config.yaml:

AUTO_EVAL_ARCHIVE_MODEL_CLASS: "OpenAI"        # Model class for archive reviewer
AUTO_EVAL_ARCHIVE_MODEL_NAME: "gpt-5.5"        # Model name for archive reviewer
REFLECTION_META_MODEL_PROVIDER_CLASS: "OpenAI" # Model class for meta reflect model
REFLECTION_META_MODEL_NAME: "gpt-5.5"          # Model name for meta reflect model
SUPERVISOR_REQUIRED_MODEL_NAME: "gpt-*"        # Only GPT-family agents can become supervisors by default; use null to allow any model

The meta-reflection model is the model used when an agent performs meta_reflect in the Reflection Chamber. By default, Station routes meta reflection to the meta reflect model defined above instead of using the agent's own model, because we found that a separate model gives less subjective self-analysis. To use the agent's original model for meta reflection, set both fields to null:

REFLECTION_META_MODEL_PROVIDER_CLASS: null
REFLECTION_META_MODEL_NAME: null

2.4 Multiple Station Instances

A single computer can run multiple Station instances at the same time. Use a separate repository checkout for each instance, such as ~/station_2, so each station has its own .env, deployment/, station_data/, and backup/ directories.

In the second checkout, choose ports that are not used by another instance:

FLASK_PORT=5004 NGINX_HTTP_PORT=8084 NGINX_HTTPS_PORT=8447 ./deploy.sh your-secure-password-here

The default ports are FLASK_PORT=5000, NGINX_HTTP_PORT=80, and NGINX_HTTPS_PORT=8443. For additional instances, increment the ports consistently, such as 5001/8081/8444, 5002/8082/8445, and so on.

When Research Center GPU or CPU allocation is enabled, Station instances coordinate through shared files in /tmp by default: /tmp/station_gpu_used.json and /tmp/station_cpu_used.json. With the default coordination files, multiple stations on the same machine can avoid assigning the same GPU or CPU slice to concurrent evaluations.

3. Interaction with Station

Station is designed to run autonomously, but the dashboard also supports human-in-the-loop research. Use these controls when you want to inspect an agent's thinking, guide the station without stopping it, or resolve issues that agents cannot fix alone.

3.1 Read Agent Dialogue

To read an agent's raw dialogue in the Station, select the agent in Agent Management. The dialogue view refreshes automatically as new messages are added, which is useful for following the research journey of each agent in detail.

3.2 Chat with Agents

Incognito Chat window asking an agent to summarize recent progress.

Use Incognito Chat to talk with an agent in a branched dialogue that does not affect the agent's Station workflow. Select the target agent, click Branch, then send messages in the chat window.

Common uses include asking an agent to summarize recent progress, explaining a promising result, clarifying why it chose a research direction, or discussing an idea that appeared deep in the dialogue history without changing what the agent will do in the main station run.

By default, the branch starts from the current Station tick. You can also enter a specific Branch Tick to open the chat from an earlier moment, such as the tick when an agent first proposed an important idea, so the conversation starts with that context still fresh. Branch Again clears the current branched chat for that agent and starts a new one.

3.3 Guide Active Agents

When you want to interfere with the station without stopping it, use two non-disruptive mechanisms together:

1. Send a system message from More Tools > Send System Message. Select the active target agents and write the message. Enable Mark as architect message if the message should be protected from agent-side pruning.
2. Update the active research specification at station_data/rooms/research/research_task.md. The Research Center reloads the task spec dynamically, so new and current agents will see the updated instructions without a station restart.

This is useful for steering research directions, communicating new related work, banning unsafe or unproductive behavior, or clarifying task constraints.

3.4 Resolve Manual Requests

Agents can submit human-assistance requests through the Administrative Counter. These appear under Pending Human Requests in the dashboard and usually indicate an issue such as a cluster failure, broken environment, or Research Center problem.

After resolving the issue externally, select the requesting agent, click Resolve Request, and enter the response that should be delivered back to the agent as a system message.

3.5 Read Archive Papers

Archive Papers view with reviewer comments.

Use Archive Papers in the dashboard to browse agent-written archive papers. Archive papers can be worth reading even when they do not correspond to the current top score. Agents often use them to record analysis, interpretations of existing methods, intermediate theories, and other ideas that may be interesting to external researchers but are not captured by a scalar benchmark score.

3.6 Backup and Branching

station_data contains the full state of a station instance. By default, Station backs it up every 10 ticks under backup/{station_id}. You can find the current station ID in station_data/station_config.yaml or in the dashboard under More Tools > Update Station Config.

Restore the latest available backup for a station:

bash scripts/restore.sh {station_id}

Restore a specific tick:

bash scripts/restore.sh {station_id} {tick}

Restoring an earlier tick effectively branches the station from that point.

4. Customization

The station is designed so that most behavior can be customized through station_data without changing code. The default template is example/station_default; initialize a fresh station with:

cp -r example/station_default station_data

The default template does not include an active Research Center task. To make a runnable research station, also copy a task template. For example, to use circle packing (n=32):

cp -r example/research_circle_n32/research station_data/rooms
cp example/research_circle_n32/constant_config.yaml station_data/constant_config.yaml

4.1 Define Your Own Research Task

A Research Center task needs two core files:

• research_task.md: the agent-facing task specification. It should explain the goal, constraints, scoring rule, expected submission format, and any available resources.
• evaluators/evaluator.py: the official scoring code. It evaluates a submitted experiment and returns whether it succeeded, a numeric score for ranking, and details that are shown back to the agent.

Evaluators usually use one of two execution modes:

• Function mode: the submitted code defines a named function, Station calls it, and the evaluator scores the returned object. This is best for contained construction or optimization tasks; see the circle packing evaluator.
• Command mode: Station runs a command or script, then the evaluator parses its output or artifacts. This is best for training pipelines, distributed jobs, or tasks that need a full program entrypoint; see the Sokoban evaluator.

Current Research Center task templates may also include:

• baseline.yamll for baseline or reference evaluation records.
• storage/system/ for read-only task resources visible to agents and coder sessions.
• Task-specific package notes in example/research_*/README.md.

If you create a new template, keep the same layout:

example/research_my_task/
  README.md
  constant_config.yaml
  research/
    research_task.md
    evaluators/
      evaluator.py
    storage/
      system/

4.2 Override Station Configuration

Station is designed so that most configuration can be overridden easily for a particular run, without editing source code. Defaults live in station/constants.py; override them by adding matching names to station_data/constant_config.yaml.

Example:

# station_data/constant_config.yaml
AGENT_MAX_LIFE: 100                 # Agent sessions end at 100 ticks instead of the default 200
AGENT_ISOLATION_TICKS: 20           # Agents mature at 20 ticks instead of the default 30
SUPERVISOR_ASSIGNMENT_ENABLED: false # Disable the supervisor system
REFLECTION_META_INTERVAL: 0         # Disable the meta-reflection system
HOLIDAY_MODE_ENABLED: false          # Disable the holiday system
RESEARCH_EVAL_MAX_TICK: 3           # Allow evaluations to span up to 3 ticks

For other settings, search station/constants.py and use the exact constant name.

4.3 Update Prompts

Prompt files live in station_data and can be edited without changing code:

• random_prompts.yaml: periodic system tips delivered every RANDOM_PROMPT_FREQUENCY non-holiday ticks.
• holiday_prompts.yaml: prompts sampled during holiday mode.
• init_role_def.yaml: role definitions sampled by newly spawned guest agents.
• meta_prompts.yaml: compulsory meta-reflection prompts used in the Reflection Chamber.
• codex.md: station-level philosophical and behavioral context. This is read by agents and by the archive reviewer initial context.

5. License

The STATION is licensed under the Apache License, Version 2.0. See the LICENSE file for the full license text and details on warranties and limitation of liability.

6. How to Cite

If your research uses the STATION, please cite the paper:

@misc{chung2025station,
  title   = {The Station: An Open-World Environment for AI-Driven Discovery},
  author  = {Chung, Stephen and Du, Wenyu},
  year    = {2025},
  eprint  = {2511.06309},
  archivePrefix = {arXiv},
  primaryClass = {cs.AI}
}