eva98/eat-gym

EAT Gym

Long-horizon optimization tasks from EAT (Evolving Agent Teams), each at the exact state an EAT run started from, in the Harbor task format: an instruction, a pinned environment, and a verifier that runs the official eval and writes a numeric reward. The reward is the score, not pass / fail: the speedup over the state of the art for the kernel tasks, the RoboDojo score for the policy task.

task	what is optimized	hardware	reward	EAT result
amd_kda_mi350x	Kimi Delta Attention prefill (Kimi-K3, H=12, varlen)	AMD MI350X / MI355X	mean speedup vs vLLM's ROCm KDA kernels, 10 workloads	3.01×
amd_kda_decode_mi350x	fused KDA decode + speculative (MTP) verify (Kimi-K3, GLM-5.3-Flash)	AMD MI350X / MI355X	mean speedup vs the faster of AITER / vLLM HIP decode, 17 workloads	1.60×
b200_kda_int21_clean	KDA forward (Int21, H=64/96), clean room, no web	NVIDIA B200	geomean speedup vs FlashKDA, 6 workloads	3.44×
robodojo_codepolicy	RoboDojo code policy around a frozen Pi_05	4-8 AWS g6e (L40S), external	RoboDojo task score (dev seed)	62.08 (held-out, all 42 tasks; policy)

A failed correctness check scores 0. The traces of the EAT runs (every supervisor and agent transcript, team configs, per-iteration kernels and policies) are in eva98/eat-evolution-traces and the resulting kernels in eat-kernels.

Task layout

<task>/
  instruction.md        the task (program.md) and its rules
  task.toml             metadata (hardware, baseline, readable sources, EAT result), agent / verifier / environment config
  environment/
    Dockerfile          pinned base image + setup.sh
    setup.sh            installs everything (also usable on a bare-metal host)
    README.md           what the environment provides: toolchain, libraries and their versions, reference repositories
    requirements*.txt   the Python packages of the run, pinned
    refs.txt            reference repositories the agents may read (name, url, commit), cloned into /refs
    workspace/          the start state, copied to /app (a git repository): tasks/<task>/, tools/eval_<task>.py, ...
  tests/
    test.sh             restores the protected files, runs the official eval, writes /logs/verifier/reward.json
    protected/          the eval, the reference and the baselines, as the verifier uses them
  eat/                  EAT-only: the team rules the supervisor puts into every agent prompt, the CLAUDE.md row
  NOTICE                third-party code in the task and its license

The agents may run the eval themselves (/app/tools/eval_<task>.py); the verifier runs in a separate sandbox, copies the agent's task directory in (artifacts), puts the protected files back and scores it. The kernel tasks' verifier re-measures the baselines on its own GPU, so scores are comparable across machines; EAT_GYM_RECORDED_BASELINE=1 scores against the latencies recorded in the EAT run instead.

Use

With Harbor (any agent, e.g. Claude Code):

hf download eva98/eat-gym --repo-type dataset --local-dir eat-gym
harbor run -p eat-gym/amd_kda_mi350x -a claude-code -m anthropic/claude-sonnet-5-5

With EAT (a supervisor evolving a team of agents), on a machine with the hardware, install it in Claude Code (/plugin install eat --marketplace caoshiyi/EAT) and ask: "Run the EAT Gym task amd_kda_mi350x on GPUs 0-3 with a $300 budget." By hand: bash <EAT checkout>/ops/fetch_task.sh amd_kda_mi350x amd_kda --setup installs the task as its own repository (eat/task.md, eat/eval.sh, eat/env.sh, the starting code) and runs environment/setup.sh; then start agent_team/launch_stateless.sh inside it as in EAT's SKILL.md.

robodojo_codepolicy needs its simulator fleet first (environment/README.md, set up with fleet/ of eat-robodojo-policy); pass it as ROBODOJO_HOSTS and ROBODOJO_SSH_KEY.

License

Apache-2.0, except third-party code listed in each task's NOTICE (vLLM: Apache-2.0; AITER: MIT; FlashInfer: Apache-2.0; RoboDojo patch: MIT), which keeps its original license and headers. Reference repositories are not included; setup clones them from their public sources at the pinned commits.