Chapter 14: Seven-Round Run Map

A complete timing breakdown of the first 7 iterations (rounds) of a game run, showing every step the agent executes and its estimated wall-clock cost. Includes analysis of two realistic optimizations: async strategist and loop delay reduction.

Note (since this analysis was written). Two of the optimizations below have shipped: the strategist runs asynchronously (Optimization A) and loop_delay now defaults to 0.3 s (Optimization B). The executor also gained a single-shot path for routine turns (one roundtrip instead of the agentic tool loop — see Chapter 4 §4.3). The tables below keep the original loop_delay = 1.0 s / always-tool-loop baseline so the optimization math in §14.5 stays self-consistent; treat them as the methodology, not today’s wall-clock.

14.1 Per-Step Timing Reference

Every iteration executes the same pipeline. Steps marked conditional only run on specific turns.

Config defaults (from config.py): loop_delay=0.3 (the tables below use the pre-optimization 1.0 baseline — see the note above), strategist_interval=10, detection_imgsz=640, adaptive_sahi=False, full_sahi_interval=5 (only consulted when adaptive_sahi=True), action_delay=0.05, max_tool_iterations=7, executor_effort="low".

Detection mode (v6). The agent now runs a single forward pass at imgsz=640 on every turn (adaptive_sahi=False) — SAHI lowers real F1 at retina resolution (see Chapter 7 §7.4). The per-round “full/adaptive SAHI” distinctions and the millisecond detection figures in the timelines below are illustrative/historical from the pre-v6 design; treat detection as one constant single-pass cost per turn regardless of round.

14.2 Round-by-Round Overview

14.3 Detailed Timeline

Round 1 — First Iteration (Heaviest)

Round 1 total: ~8.75 s

Rounds 2–4, 6–7 — Normal Iterations

Normal round total: ~3.5 s

Round 5 — Normal Iteration

Pre-v6 this round forced a full SAHI scan (iteration % 5 == 0). With adaptive_sahi=False there is no forced full scan, so Round 5 is now an ordinary single-pass turn — identical in shape to Rounds 2–4.

Round 5 total: ~3.5 s

14.4 Cumulative 7-Round Timeline

Total 7-round run: ~29.8 s

Time distribution across the full run:

The executor API calls dominate, followed by the sleep delay and the single strategist call on round 1.

14.5 Optimization Analysis

Optimization A: Async Strategist

Problem: The strategist call on round 1 blocks the loop for ~5 s (3–8 s range). This is the single most expensive step in a 7-round run at 16.7% of total time.

Proposal: Fire the strategist as a background asyncio.create_task(). The executor continues immediately with default/previous goals. When the strategist response arrives, goals update asynchronously.

Current (blocking):
  Round 1: ... → [Strategist 5000ms] → [Executor 2000ms] → ...
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                  Total: 7000ms sequential

Proposed (async):
  Round 1: ... → [Executor 2000ms with default goals] → ...
                  [Strategist 5000ms in background..........]
                  ^^^^^^^^^^^^^^^^
                  Total: 2000ms (strategist completes during round 2)

Impact on round 1:

Tradeoffs:

Verdict: Realistic. Saves 5.0 s on a 7-round run (16.7% improvement). The default goals are reasonable for early Dark Age play and closely match what the strategist would generate anyway.

Optimization B: Loop Delay Reduction

Problem: The 1000 ms loop_delay sleep accounts for 7.0 s across 7 rounds (23.4% of total time). It runs every single iteration.

Why it exists: Prevents rapid-fire inputs to the game and allows the screen to update between iterations.

Analysis: The pipeline already introduces ~1.5–3.5 s of natural latency per iteration:

• Detection: 150–234 ms
• Executor API loop: 1000–3500 ms
• Action execution: 200+ ms with built-in delays (action_delay=0.05s, BUILD_SETTLE_DELAY=0.15s)

The game renders at 60 fps (16 ms/frame). The screen fully updates within 50–100 ms of any action. The existing action-level delays already pace inputs.

Three scenarios:

Verdict: Reducing to 0.3 s is safe and realistic. Saves 4.9 s on a 7-round run (16.4% improvement). Eliminating entirely (0.0 s) is viable but carries minor risk of stale screenshots.

Combined Impact

With both optimizations, a 7-round run drops from ~30 s to ~20 s — a one-third reduction in wall-clock time with no loss of gameplay quality.

14.6 Variability and Edge Cases

The timings above assume a clean run with no alarms. Real runs may vary:

14.7 Visual Timeline (7 Rounds)

Time (s)  0         5         10        15        20        25        30
          |---------|---------|---------|---------|---------|---------|
Round 1   [===STRATEGIST====][EXEC][ACT][SLEEP]
Round 2                                          [DET][EXEC][ACT][SLP]
Round 3                                                               [DET][EXEC][ACT][SLP]
Round 4                                                                                    [DET][EXEC][ACT][SLP]
Round 5                                                                                                         [DET][EXEC][ACT][SLP]
Round 6                                                                                                                                [DET][EXEC][ACT][SLP]
Round 7                                                                                                                                                     [DET][EXEC][ACT][SLP]

Legend: DET = detection (single-pass @640, every turn)  EXEC = executor API  ACT = action execution  SLP = sleep
        STRATEGIST = Sonnet API call (text — resources via local OCR; only round 1 in a 7-round run)