ハーネスエンジニアリングで月面着陸させてみた

"""自動フィードバック実験の初期状態。"""
def control(state: dict[str, float]) -> dict[str, float]:
    """現在の状態からメインエンジンと姿勢制御の出力を返す。"""
    # 最初はエンジンを使わない。もちろん墜落する。
    return {"throttle": 0.0, "turn": 0.0}

lunar-lander-harness/
├── agent-workspace/
│   ├── AGENTS.md　　  　　  　　  　// 作業用の目次とルール
│   ├── controller.py　　  　　  　　// AIが編集するファイル
│   └── docs/
│       └── mission.md　　  　　    // プロジェクトのミッション定義
├── harness/
│   ├── evaluate.py　　  　　  　　  // 評価プログラム
│   ├── simulator.py　　  　　  　　 // 観測プログラム
│   └── starter_controller.py　　  // 初期状態のcontroller.py
├── harness/
│   ├── iteration-00      　　　　  // 最初の結果
│   └── iteration-0n      　　　　  // n回目のラウンドの結果
│       ├── controller.py　　  　　 // ラウンドごとのcontroller.py
│       ├── evalutation.json　　   // 20回の着陸観測結果
│       └── trajectory.svg        // 軌跡描画
└── run_harness.py　　  　　  　　  // ハーネスプログラム

制御コードを評価する
        ↓
評価結果をJSONにする
        ↓
JSONを添えてCodexを実行する
        ↓
Codexがcontroller.pyを修正する
        ↓
候補コードを再評価する
        ↓
改善なら採用する
悪化なら最良コードへ戻す
        ↓
合格なら終了、失敗なら次の実行へ戻す

# Codex環境確認
cd /path/to/project
python3 --version
codex --version
codex login status

# Codex動作ディレクトリのGit初期化
cd agent-workspace
git init
cd ..

command = [
    "codex",
    "exec",
    "--json",
    "--sandbox",
    "workspace-write",
    "--ignore-user-config",
    "--ignore-rules",
    "-m",
    "gpt-5.6-sol",
    "-C",
    str(WORKSPACE),
    prompt,
]

def prompt_for(round_number: int, feedback: dict) -> str:
    return f"""月面着陸ミッションの改善ラウンド{round_number}です。

前回の外部評価結果を以下に示します。

```json
{json.dumps(feedback, ensure_ascii=False, indent=2)}
```

AGENTS.mdとdocs/mission.mdを読み、評価結果を踏まえて
controller.pyを1回改善してください。
"""

{
  "successes": 0,
  "total": 20,
  "quality_score": 58.36,
  "failure_reasons": {
    "vertical_speed_too_high": 20,
    "horizontal_speed_too_high": 17,
    "outside_landing_zone": 15,
    "angle_too_large": 2
  }
}

feedback = evaluate(0)

for round_number in range(1, MAX_ROUNDS + 1):
    run_codex(round_number, feedback)
    feedback = evaluate(round_number)

    if feedback["passed"]:
        termination = "target_reached"
        break

    if improvement_has_stopped(feedback):
        termination = "no_progress"
        break
else:
    termination = "max_rounds"

python3 run_harness.py

round 0: 0/20 quality=58.36

{
  "passed": false,
  "successes": 0,
  "total": 20,
  "success_rate_percent": 0.0,
  "target_successes": 18,
  "quality_score": 58.36,
  "failure_reasons": {
    "vertical_speed_too_high": 20,
    "horizontal_speed_too_high": 17,
    "outside_landing_zone": 15,
    "angle_too_large": 2
  },
  "average_fuel_on_success": null,
  "failed_scenarios": [
    {
      "scenario_id": 1,
      "success": false,
      "reason": "outside_landing_zone,horizontal_speed_too_high,vertical_speed_too_high",
      "elapsed_seconds": 9.0,
      "final_x_error": 6.057,
      "final_horizontal_velocity": 2.94,
      "final_vertical_velocity": -19.08,
      "final_angle_degrees": 0.427,
      "fuel_remaining": 42.0
    },
    ...(省略)...
  ]
}

"""自動フィードバック実験の初期状態。"""


def control(state: dict[str, float]) -> dict[str, float]:
    """現在の状態からメインエンジンと姿勢制御の出力を返す。"""
    # 最初はエンジンを使わない。もちろん墜落する。
    return {"throttle": 0.0, "turn": 0.0}

"""月面着陸船のフィードバック制御器。"""

import math


def _clamp(value: float, lower: float, upper: float) -> float:
    return max(lower, min(upper, value))


def control(state: dict[str, float]) -> dict[str, float]:
    """位置と速度を収束させながら、低速かつ直立した接地を目指す。"""
    altitude = max(0.0, state["altitude"])
    x_error = state["target_x"] - state["x"]
    horizontal_velocity = state["horizontal_velocity"]
    vertical_velocity = state["vertical_velocity"]
    angle = state["angle_degrees"]
    angular_velocity = state["angular_velocity_degrees"]
    gravity = max(0.01, state["gravity"])
    max_thrust = max(gravity + 0.01, state["max_thrust"])

    # 最大能力を使い切らない降下曲線に追従させ、外乱への制動余力を残す。
    braking_acceleration = max(0.35, 0.55 * (max_thrust - gravity))
    stopping_altitude = max(0.0, altitude - 0.8)
    desired_vertical_velocity = -max(
        0.55, min(12.0, math.sqrt(2.0 * braking_acceleration * stopping_altitude))
    )
    vertical_gain = 1.15 if altitude < 20.0 else 0.85
    requested_upward_acceleration = gravity + vertical_gain * (
        desired_vertical_velocity - vertical_velocity
    )

    # 高度がある間に横位置を合わせ、低高度では横速度の停止を優先する。
    if altitude > 35.0:
        max_horizontal_speed = 5.0
        position_gain = 0.28
        velocity_gain = 0.75
        angle_limit = 24.0
    elif altitude > 10.0:
        max_horizontal_speed = 2.5
        position_gain = 0.34
        velocity_gain = 1.0
        angle_limit = 15.0
    else:
        max_horizontal_speed = 1.0
        position_gain = 0.40
        velocity_gain = 1.35
        angle_limit = 6.0

    desired_horizontal_velocity = _clamp(
        position_gain * x_error, -max_horizontal_speed, max_horizontal_speed
    )
    requested_horizontal_acceleration = velocity_gain * (
        desired_horizontal_velocity - horizontal_velocity
    )

    # 必要な横加速度を傾斜角に変換する。接地直前は成功角度内に制限する。
    attitude_reference = math.degrees(
        math.atan2(
            requested_horizontal_acceleration,
            max(gravity, requested_upward_acceleration),
        )
    )
    attitude_reference = _clamp(attitude_reference, -angle_limit, angle_limit)

    attitude_error = attitude_reference - angle
    turn = _clamp(0.075 * attitude_error - 0.18 * angular_velocity, -1.0, 1.0)

    # 傾斜による鉛直推力損失を補償する。低高度では微小な速度超過にも強く応答する。
    tilt_cosine = max(0.55, math.cos(math.radians(angle)))
    throttle = requested_upward_acceleration / (max_thrust * tilt_cosine)
    if altitude < 6.0 and vertical_velocity < -1.35:
        throttle += 0.12 * (-1.35 - vertical_velocity)
    throttle = _clamp(throttle, 0.0, 1.0)

    return {"throttle": throttle, "turn": turn}

round 0: 0/20 quality=58.36
round 1: 1/20 quality=83.02 changed=True guardrails=[]
round 2: 1/20 quality=79.65 changed=True guardrails=[]
round 3: 1/20 quality=78.41 changed=True guardrails=[]

def evaluation_score(evaluation: dict) -> tuple[int, float]:
    return evaluation["successes"], evaluation["quality_score"]

candidate_score = evaluation_score(candidate_evaluation)
best_score = evaluation_score(best_evaluation)

if candidate_score > best_score:
    attempt_status = "improved"
    accepted_as_best = True

    best_round = round_number
    best_evaluation = candidate_evaluation
    best_controller = CONTROLLER.read_bytes()
else:
    attempt_status = (
        "regressed"
        if candidate_score < best_score
        else "unchanged"
    )
    accepted_as_best = False

    CONTROLLER.write_bytes(best_controller)

def feedback_for_codex(
    best_round: int,
    best_evaluation: dict,
    last_attempt: dict | None = None,
    last_attempt_status: str | None = None,
) -> dict:
    feedback = {
        "controller_state": "controller.pyは現在の最良コードです",
        "best_round": best_round,
        "best_evaluation": best_evaluation,
    }

    if last_attempt is not None:
        feedback["last_attempt_status"] = last_attempt_status
        feedback["last_attempt_evaluation"] = last_attempt

    return feedback

今回の変更は評価が悪化したため棄却し、
controller.pyを最良コードへ戻しました。
同じ方向の調整を繰り返さず、
別の改善方法を検討してください。

python3 run_harness.py

round 0: 0/20 quality=58.36 accepted=True
round 1: 0/20 quality=44.34 changed=True accepted=False status=regressed guardrails=[]
round 2: 0/20 quality=75.7 changed=True accepted=True status=improved guardrails=[]
round 3: 0/20 quality=78.41 changed=True accepted=True status=improved guardrails=[]
round 4: 4/20 quality=82.42 changed=True accepted=True status=improved guardrails=[]
round 5: 20/20 quality=97.28 changed=True accepted=True status=improved guardrails=[]

開始相当: 15:25:03
終了:     15:32:27
所要時間: 約7分24秒