loop

Compare original and translation side by side

🇺🇸

Original

English

🇨🇳

Translation

Chinese

/ar:loop — Autonomous Experiment Loop

/ar:loop — 自主实验循环

Start a recurring experiment loop that runs at a user-selected interval.

启动一个按用户选择的间隔重复运行的实验循环。

Usage

使用方法

/ar:loop engineering/api-speed             # Start loop (prompts for interval)
/ar:loop engineering/api-speed 10m         # Every 10 minutes
/ar:loop engineering/api-speed 1h          # Every hour
/ar:loop engineering/api-speed daily       # Daily at ~9am
/ar:loop engineering/api-speed weekly      # Weekly on Monday ~9am
/ar:loop engineering/api-speed monthly     # Monthly on 1st ~9am
/ar:loop stop engineering/api-speed        # Stop an active loop

/ar:loop engineering/api-speed             # 启动循环（提示选择间隔）
/ar:loop engineering/api-speed 10m         # 每10分钟
/ar:loop engineering/api-speed 1h          # 每小时
/ar:loop engineering/api-speed daily       # 每日约9点
/ar:loop engineering/api-speed weekly      # 每周一约9点
/ar:loop engineering/api-speed monthly     # 每月1号约9点
/ar:loop stop engineering/api-speed        # 停止活跃循环

What It Does

功能说明

Step 1: Resolve experiment

步骤1：解析实验

If no experiment specified, list experiments and let user pick.

如果未指定实验，列出所有实验供用户选择。

Step 2: Select interval

步骤2：选择间隔

If interval not provided as argument, present options:

Select loop interval:
  1. Every 10 minutes  (rapid — stay and watch)
  2. Every hour         (background — check back later)
  3. Daily at ~9am      (overnight experiments)
  4. Weekly on Monday   (long-running experiments)
  5. Monthly on 1st     (slow experiments)

Map to cron expressions:

Interval	Cron Expression	Shorthand
10 minutes	`/10 * * *`	`10m`
1 hour	`7 * * * *`	`1h`
Daily	`57 8 * * *`	`daily`
Weekly	`57 8 * * 1`	`weekly`
Monthly	`57 8 1 * *`	`monthly`

如果未通过参数提供间隔，展示以下选项：

选择循环间隔:
  1. 每10分钟 （快速循环 — 可实时监控）
  2. 每小时     （后台运行 — 稍后查看结果）
  3. 每日约9点   （夜间实验）
  4. 每周一     （长期运行实验）
  5. 每月1号     （慢速实验）

对应Cron表达式：

间隔	Cron表达式	简写
10分钟	`/10 * * *`	`10m`
1小时	`7 * * * *`	`1h`
每日	`57 8 * * *`	`daily`
每周	`57 8 * * 1`	`weekly`
每月	`57 8 1 * *`	`monthly`

Step 3: Create the recurring job

步骤3：创建重复任务

Use

CronCreate

with this prompt (fill in the experiment details):

You are running autoresearch experiment "{domain}/{name}".

1. Read .autoresearch/{domain}/{name}/config.cfg for: target, evaluate_cmd, metric, metric_direction
2. Read .autoresearch/{domain}/{name}/program.md for strategy and constraints
3. Read .autoresearch/{domain}/{name}/results.tsv for experiment history
4. Run: git checkout autoresearch/{domain}/{name}

Then do exactly ONE iteration:
- Review results.tsv: what worked, what failed, what hasn't been tried
- Edit the target file with ONE change (strategy escalation based on run count)
- Commit: git add {target} && git commit -m "experiment: {description}"
- Evaluate: python {skill_path}/scripts/run_experiment.py --experiment {domain}/{name} --single
- Read the output (KEEP/DISCARD/CRASH)

Rules:
- ONE change per experiment
- NEVER modify the evaluator
- If 5 consecutive crashes in results.tsv, delete this cron job (CronDelete) and alert
- After every 10 experiments, update Strategy section of program.md

Current best metric: {read from results.tsv or "no baseline yet"}
Total experiments so far: {count from results.tsv}

使用以下提示调用

CronCreate

（填充实验详情）：

你正在运行autoresearch实验"{domain}/{name}"

1. 读取.autoresearch/{domain}/{name}/config.cfg获取：target、evaluate_cmd、metric、metric_direction
2. 读取.autoresearch/{domain}/{name}/program.md获取策略和约束条件
3. 读取.autoresearch/{domain}/{name}/results.tsv获取实验历史
4. 执行：git checkout autoresearch/{domain}/{name}

然后严格执行一次迭代：
- 查看results.tsv：哪些方法有效、哪些无效、哪些尚未尝试
- 对目标文件进行一处修改（基于运行次数升级策略）
- 提交：git add {target} && git commit -m "experiment: {description}"
- 评估：python {skill_path}/scripts/run_experiment.py --experiment {domain}/{name} --single
- 读取输出结果（KEEP/DISCARD/CRASH）

规则:
- 每次实验仅做一处修改
- 绝不修改评估器
- 如果results.tsv中出现5次连续崩溃，删除此定时任务（CronDelete）并发出警报
- 每完成10次实验后，更新program.md中的Strategy部分

当前最佳指标：{从results.tsv读取或填写"尚无基准值"}
已完成实验总数：{从results.tsv统计}

Step 4: Store loop metadata

步骤4：存储循环元数据

Write to

.autoresearch/{domain}/{name}/loop.json

json

{
  "cron_id": "{id from CronCreate}",
  "interval": "{user selection}",
  "started": "{ISO timestamp}",
  "experiment": "{domain}/{name}"
}

将以下内容写入

.autoresearch/{domain}/{name}/loop.json

：

json

{
  "cron_id": "{CronCreate返回的ID}",
  "interval": "{用户选择的间隔}",
  "started": "{ISO时间戳}",
  "experiment": "{domain}/{name}"
}

Step 5: Confirm to user

步骤5：向用户确认

Loop started for {domain}/{name}
  Interval: {interval description}
  Cron ID: {id}
  Auto-expires: 3 days (CronCreate limit)

  To check progress: /ar:status
  To stop the loop:  /ar:loop stop {domain}/{name}

  Note: Recurring jobs auto-expire after 3 days.
  Run /ar:loop again to restart after expiry.

已为{domain}/{name}启动循环
  间隔：{间隔描述}
  Cron ID：{id}
  自动过期：3天（CronCreate限制）

  查看进度：/ar:status
  停止循环：  /ar:loop stop {domain}/{name}

  注意：重复任务会在3天后自动过期。
  过期后可重新运行/ar:loop以重启循环。

Stopping a Loop

停止循环

When user runs

/ar:loop stop {experiment}

Read
```
.autoresearch/{domain}/{name}/loop.json
```
to get the cron ID
Call
```
CronDelete
```
with that ID
Delete
```
loop.json
```
Confirm: "Loop stopped for {experiment}. {n} experiments completed."

当用户运行

/ar:loop stop {experiment}

时：

读取
```
.autoresearch/{domain}/{name}/loop.json
```
获取cron ID
使用该ID调用
```
CronDelete
```
删除
```
loop.json
```
确认："已停止{experiment}的循环。已完成{n}次实验。"

Important Limitations

重要限制

3-day auto-expiry: CronCreate jobs expire after 3 days. For longer experiments, the user must re-run
```
/ar:loop
```
to restart. Results persist — the new loop picks up where the old one left off.
One loop per experiment: Don't start multiple loops for the same experiment.
Concurrent experiments: Multiple experiments can loop simultaneously ONLY if they're on different git branches (which they are by default — each experiment gets
```
autoresearch/{domain}/{name}
```
).

3天自动过期：CronCreate任务会在3天后过期。对于长期实验，用户必须重新运行
```
/ar:loop
```
以重启循环。实验结果会保留——新循环会从旧循环中断的地方继续执行。
单实验单循环：不要为同一个实验启动多个循环。
并发实验：仅当多个实验位于不同Git分支时（默认情况下每个实验对应
```
autoresearch/{domain}/{name}
```
分支），才能同时运行循环。