Scouting Baselines#

This page describes the classical reference stack of the Field Scouting Task. The stack contains the reference paths, the reference driver, the planners, the training environment and the seeded evaluation. The reference driver defines the reference quantities of the task.

All parts run in ACRES Core (ACRES Core). The game can drive the same missions as a cross-check. The code is in Learning/acres_learn. In the learning framework, this stack controls the mission, and the learned residual corrects the reference driver.

Reference Paths#

A plan gives these items for each field, in order: the entry, the direction and two points on the loop (see below). The reference path is a GoTo leg, a Scout leg for each field and a Return leg (tasks/scouting/routes.py).

Routes go forwards. The Polaris turns no tighter than 5 m. Thus the search uses the directed edges of the transit graph. A move from one edge to the next is permitted only where the heading turns by at most 120°.

The route code measures the headings over the last 4 m and the first 4 m of the two edges. The vehicle uses reverse only to turn (see below). An entry link is the short edge from a junction to its loop point.

It has the heading with which the vehicle entered it. Thus the turn onto a loop is the angle between the lane that brought the vehicle and the direction of the loop. For routing, graph edges are split where they pass within 6 m of a loop (approximately 930 split points). Thus a vehicle can join or leave a loop where a lane runs adjacent to it. The cost tables share the cost of an edge over its pieces by length.

Turns on the loops. Some lanes are dead ends. Some lanes run along the loop in the wrong direction. Such a lane needs a U-turn. The vehicle turns on the loop where this is possible.

It can join the loop at each point near the graph. These points are the entries and the other nodes within 8 m over drivable ground.

It then drives along the loop to the entry where its Scout starts. After it comes back to that entry (the field is scouted), it can drive on along the loop to such a point and leave there. The planner prices those loop arcs at the cost per metre of the loop.

Turnarounds and three-point turns. A route can still reverse. The reversal can be inside the path. It can also be at the start or the end of the path, over the first and last 6 m. There the path turns against the loop that the vehicle leaves or joins. Two cases exist:

The path only goes out and back along the same line, for example on a link to a node adjacent to the lane. The reversal is then cut out, if the cut leaves no turn sharper than 120°.
In each other case, a manoeuvre replaces the reversal. It goes from a pose up to 40 m before the reversal to a pose up to 40 m after it. The route code takes the better of two manoeuvres. A turnaround is the Dubins path (Dubins 1957) of 9 m radius. A three-point turn is the Reeds–Shepp path (Reeds and Shepp 1990, all 48 words; tasks/scouting/reeds_shepp.py) of 6 m radius, driven forwards and backwards.

The two manoeuvres have the same conditions and scores:

The plan box of the Ranger stays 0.5 m clear of obstacles. On backward stretches the box points backwards.
The reference point stays 2.5 m inside the tile.
The centre goes no more than 5 m into crop.
The score of a turnaround is its length.
The score of a three-point turn is its forward length, plus two times its backward length, plus 10 m for each change of direction.
Each metre on crop counts 25 times.
The two poses must be at least 90° apart in heading, on each side of the turn of the reversal.
Each pose must be at a place where the path turns by less than 45° over 3 m. Thus no corner comes immediately after the manoeuvre.

The route code then rounds each one-direction stretch separately, with a Gaussian of 2 m along the path. The points where the direction changes are stops.

Departures. The first metres of a transit leg can turn more than 45° from the heading of the vehicle. This occurs at H, which points north while the lane leaves to the west. It also occurs off a loop by a link at an angle.

Such a leg starts with the shortest Dubins arc from the pose of the vehicle onto the path 6-40 m ahead. The arc must pass the checks of the turnaround. Its radius is 9 m, or 7.25 m or 5.5 m where 9 m does not fit. At the departure from H, the largest cross-track error of the reference driver decreased from 6.2 m to 1.1 m.

Home. A vehicle that returns to H arrives with its front towards the garage. No forward path of that radius ends within 20° of the heading of H (out of the garage) without contact. On each such path the plan box touches the building 3 m behind H. Thus the completion test also accepts the opposite heading (episode.home_heading_reversed_ok). This is a departure from the first version of the specification.

The decision of September 2026 kept it with the reverse gear. The Return ends with a straight run-in of 12 m, or 8 m or 5 m where 12 m does not fit. The run-in ends at the nearest pose where the brush guard is 1 m clear of the building.

The brush guard is 3.4 m ahead of the rear axle. That pose is 1.25 m short of H. The speed limit of the last 35 m is 2 m/s. Thus the heading becomes stable.

Reference Driver#

tasks/scouting/reference_driver.py is pure pursuit (Coulter 1992) of the base_footprint on the reference path. The look-ahead is \(L = \mathrm{clip}(4 + 1.2\,v, 4, 9)\) m. The driver sends the two task commands at intervals of 0.1 s.

The speed follows the profile of the path:

The class limits: 5 m/s on lane and verge, 3 m/s on the edge band.
A cap at the 4 m/s cruise speed.
\(v \le \sqrt{1.5 / \lvert\kappa\rvert}\) in corners.
\(v \le 0.06 / \lvert d\kappa/ds\rvert\) where the curvature changes. At the rate of the laboratory follower, the steering changes the curvature by approximately 0.08 1/m per second.
Braking at 1 m/s² towards each lower limit and towards the stop.
The driver reads the profile 0.5 s ahead of the vehicle.

All 118 loop laps were the basis for the look-ahead value. These are the two directions of each field, second lap from a flying start. The median largest cross-track error is 0.89 m. The median RMS is 0.31 m.

The SteeringCmd contains the rate and acceleration limits of the steering wheel that the path follower of the laboratory sends: 171.9 deg/s and 1000 deg/s². The values come from its recorded drive-by-wire commands (configs/scouting_v1.json, actions). With the default 100 deg/s of the firmware, a lateral controller oscillates. The steering then needs 3.6 s from straight to full lock.

Reverse. The driver drives a path with changes of direction one stretch at a time:

Each stretch ends in a stop. The profile brakes to 0 at its end.
The next stretch starts when the vehicle is stopped (below 0.15 m/s) within 0.8 m of the stop. A vehicle that stopped a little past the stop counts by its projection onto the stop.
The projection never looks past the current stretch.
Backwards, the driver drives the same pure-pursuit arc through a point 3 m behind the vehicle. \(\kappa = 2y/d^2\) is correct in the two directions, because the centre of the arc is on the same side.
The backward speed is at most 1.5 m/s. The command is signed (negative).
spec.GearManager changes the sign into the gear, as for each policy. The sequence is a stop, a GearCmd R or L at standstill and 1.1 s for the shift.
While the vehicle is stopped at the start of a stretch, the speed command cannot decrease. The ULC reads a decreasing reference at standstill as a stop and holds the brake. The value of the profile decreases slowly as the vehicle rocks. This stalled the first drives.

The ULC in the Polaris model runs its velocity loop along the engaged gear. A negative command in R is a backward speed (Acres/Source/Acres/AcresUtvModel.cpp). At walking speed the ULC oscillates by approximately ±0.5 m/s in each direction on grass, as it does forwards.

Missions and Rewards#

tasks/scouting/mission.py follows one vehicle through its mission, step by step, from the numbers of the simulator. It records:

The phase. A GoTo ends within 2 m of its entry. It also ends when the projection is on its last 2 m inside the corridor. In its last 12 m, it also ends on the loop, within 2 m, in the first 12 m of the loop. A Scout ends when the vehicle is again at its entry. A Return ends with the completion test.
The progress along the leg. This is the projection near \(s^*\). The projection looks no further than 12 m ahead. Thus the crossing of a turnaround does not skip a part of the path. The projection does not go past the next change of direction before \(s^*\) arrives there.
The gear changes and the distance driven backwards.
The covered checkpoints and the milestones.
The reward terms of rewards.py, each summed for the episode.
The status of termination.py.

"Leaving the map" is a wheel off the tile, where the terrain ends. The first version tested the reference point, and then also the centre of the front axle. The environment, the evaluation and the cross-check in the game use the same tracker.

eval/reward_check.py measures the reward scales of the specification with the reference driver in ACRES Core. It measures the terms of one step in three places. The first is the E_ref lane at 4 m/s. The second is a straight line through a planted field. The third is the longest edge-band stretch of the loops. It also measures the sums of each term over the episodes of the reference driver.

Environment#

envs/scouting.py contains ScoutingVecEnv. It is a Gymnasium vector environment over one ACRES Core batch.

Action. The two numbers of the specification in [-1, 1]: curvature, and signed ULC velocity (−1.5 to 6 m/s). The gear follows the sign through spec.GearManager.
Observation. A dict of the groups of the specification (tasks/scouting/observations.py). The groups are proprioception (13), path (117), map crop (64 × 64 × 5) and LiDAR (360). The LiDAR group is the planar scan of ACRES Core.
Path group. 16 points 2 m apart in the body frame with class, speed limit and direction of travel. Then the distance that remains, the phase and the remaining time.
Map crop. An egocentric crop with the channels crop, edge band, lane or verge, obstacle and soil water.
Reward. The sum of the terms. info["reward_terms"] holds each term.
End of an episode. A failure terminates the episode. A timeout (1.5 T_ref) truncates it.
Reset. The environments reset themselves (the same-step autoreset of Gymnasium). info["final_info"] holds the ended episode with the sums of its terms.
Missions. A callable gives the missions: SingleFieldMissions for the single-field stages of the flat-policy curriculum, FixedMissions for given plans.
Log. With log_dir, the environment writes each episode as an MCAP episode log. The game replays it (-EpisodeReplay=).

from acres_learn.envs.scouting import ScoutingVecEnv, SingleFieldMissions
env = ScoutingVecEnv(64, SingleFieldMissions(fields=train_fields), energy_ref_j=e_ref, seed=0)
obs, info = env.reset()
obs, reward, terminated, truncated, info = env.step(env.action_space.sample())

Planners#

Cost tables (planners/costs.py). The reference driver drives each directed transit edge (992) one time in ACRES Core, under a condition set. It also drives each loop in the two directions (118). Each drive has a flying start 15 m before the segment (kept on the tile). Each drive records:

\(E_\text{fuel}\), \(E_\text{ground}\) and the time.
The peak sustained slip: the mean of the driven wheels over 1 s.
The deepest rut: 65 % of the deepest sinkage, as the farm keeps it.
Whether the vehicle was stuck.
Whether the drive reached its end.
For a loop: the share of the checkpoints of its field that the vehicle passed within the coverage radius.

A drive removes its edge or loop direction in each of these cases:

The vehicle was stuck.
The drive did not arrive.
The sustained slip exceeded 0.3.
The rut exceeded 8 cm.
A loop drive covered less than 95 % of its checkpoints.

One condition set needs approximately 100 s of CPU. The cache holds the tables for each condition set and map in Acres/Saved/Learning/costs/<map hash>/<condition>.npz.

Option graph (planners/options.py). Each requested field is a cluster of options (entry, direction), up to 12. The cost of a loop is its drive. The transit legs are the turn-limited routes above.

They use \(J = E_\text{fuel} + \lambda_g E_\text{ground}\) of the tables for each edge, with the best join and leave points. A necessary U-turn is a three-point turn. It costs as much as 60 m of lane at the median J per metre of the network.

Solvers (planners/solvers.py):

Solver	Method	Range
Exact	Dynamic programming over subsets of fields (Held and Karp 1962, generalised). The state is the set of completed fields and the last option.	\(n \le 12\), approximately one second
Brute force	All field orders, with a layered shortest path for the options. It is the check of the DP.	\(n \le 7\)
OR-Tools	The routing solver with one disjunction for each field and guided local search. The assignment relaxation gives a lower bound and the gap.	Larger \(n\)
Nearest first, as listed	Greedy baselines.	All \(n\)

Evaluation#

Splits (eval/splits.py, frozen in configs/splits_v1.json). The fields are in nine strata. A stratum is an area tercile crossed with the lane-bound share of the loop (under 50 %, 50-90 %, at least 90 %). Each stratum gives its share to the test split (10) and the validation split (6), by largest remainders. The draw uses seed 20260930. The draw runs again with the next seed until the test split has at least two fields under 50 % lane-bound.

Split	Fields
Train (43)	F02, F03, F07, F08, F09, F10, F11, F12, F13, F14, F15, F17, F18, F19, F20, F22, F23, F24, F25, F27, F29, F30, F31, F33. F35, F36, F37, F38, F39, F40, F41, F45, F46, F48, F49, F50, F51, F52, F53, F54, F55, F58, F59
Validation (6)	F04, F26, F28, F42, F56, F57
Test (10)	F01, F05, F06, F16, F21, F32, F34, F43, F44, F47

The split comes from the map products of 30 September 2026. python -m acres_learn.eval.splits --write draws it again by the same rules on a rebuilt map. A test checks the frozen file against the rules.

Suite (eval/suite.py). The suite has 200 missions, 40 of each size \(n \in \{1, 2, 3, 5, 8\}\). The missions alternate between three types: all fields seen in training, one held-out field among training fields, and all fields held out. Each mission runs under the three condition sets, which gives 600 runs. evaluation.seed is the seed.

Condition Set	Definition
Dry	Soil water 0.5 of the range from wilting point to field capacity (the default of the farm).
Wet	Soil water 1.15, past field capacity.
Hardware shift	Dry, with the straight-ahead angle of the steering wheel 3° off and the wheel speed read 10 % high.

Scores (eval/scorers.py). The scorers calculate each score of the evaluation table that ACRES Core can measure:

Success and coverage.
Fuel for each mission and for each km, and ground loss.
\(J\) and regret.
Crop outside the edge band, and crop inside it against \(A^\text{edge}\).
Time, and time over \(T_\text{ref}\).
Stuck and collisions for each 100 missions.
The closest obstacle and the smoothness of the commands.

Each score is a mean with a 95 % interval (percentile bootstrap; Wilson for rates). The groups are planner, condition set, mission size and seen or held-out fields. The regret counts complete missions only. Workers are not in ACRES Core. Thus only the game can give the worker distance of the safety score. Latency and imagination are for the vision models.

Runs (eval/run.py). For each condition set, the run makes the tables and the plans. It drives the optimal plans first. Their objective is \(J^*\) and their time is \(T_\text{ref}\). Then it drives the plans of the other planners against them. The report is report.md and report.json with each aggregate, and results.json with each run.

--freeze writes the \(T_\text{ref}\), \(J^*\) and plan of each optimal mission to configs/scouting_reference_v1.json, with the hash of the map products. Later runs and the environment read them from there, if they use the same map products. --fresh measures them again. configs/scouting_v1.json holds the frozen \(E_\text{ref}\) (reference.energy_ref_j).

cd Learning
python -m acres_learn.eval.reference --energy-ref                         # E_ref
python -m acres_learn.eval.run --single-field --freeze --out <dir>        # every field alone, optimal plan, dry
python -m acres_learn.eval.run --regret-check 60 --out <dir>              # DP against brute force, n = 2..7
python -m acres_learn.eval.run --freeze --out <dir> [--log-episodes]      # the 600 runs, three planners
python -m acres_learn.eval.reward_check --out <dir> --episodes <dir>/results.json
python -m acres_learn.eval.game_crosscheck --fields F53,F42,F49,F24,F39 --out <dir>   # the packaged game, lockstep

Cross-check in the game (eval/game_crosscheck.py). The same single-field missions, plans and driver run one time in ACRES Core and one time in the packaged game. The game runs in lockstep through its simulator-control channel and its drive-by-wire bridge. These are the channels that acres_sim carries for ROS 2. Each game mission starts from a world reset.

The game records it as an episode log. The fuel and the ground loss of the game come from the energy ledger of the log. Its crop comes from the farm events of the log, sorted by the ground classes. The coverage and the end of the episode come from the same tracker on the poses of the game. The cross-check does not read collisions from the game.

Results#

The map products of 1 October 2026 have the hash dc4af5f51f316987. They keep 6 m from the edge of the tile and 3-4 m from obstacles. The loop of a narrow lane is along its middle. Hairpins through crop have one rounded turn (Scouting Map Products).

The results come from ACRES Core on the dry cost tables. The outputs are in Acres/Saved/Evidence/cleanup-2026-10-02/Acres/Saved/work/mapfix (local summary files). The frozen reference quantities are in configs/scouting_v1.json and configs/scouting_reference_v1.json.

Reference quantities. \(E_\text{ref}\) = 2689.8 J for each step. This is fuel 2589.2 J plus ground loss 100.6 J for each 0.1 s. The measurement covers 470 steps of the E_ref lane (dry grass lane) at a measured 4.27 m/s. The ULC becomes stable a little above its 4 m/s. A second measurement on these products gave 2689.77 J, the same value.

The frozen file holds \(T_\text{ref}\) and \(J^*\) for the 59 single-field missions (dry). The single-field stages of the flat-policy curriculum use them. The 600 runs of the suite below used the previous products. The frozen file does not hold them for these products. Thus the suite missions of a learned driver get no regret until a new run of the suite.

Single-field missions: 59 of 59 complete (dry, optimal plan).

Measure	Value
Time	6.3-28.0 min (median 14.9)
Coverage	At least 95.8 % (F35)
Crop outside the edge band	Median 6.3 m² (mean 15.9; F14 140 m² on its 2.2 km loop along the edge of the tile)
Largest cross-track error	Median 3.4 m. At most 8.6 m, with one exception: F45.
Closest obstacle	Median 1.7 m (at least 1.4 m, F49)
Reverse	39 of the 59 missions reverse at some point: 100 gear changes, median 8.3 m backwards for each such mission, at most 25 m

On F45, the tracker loses the path in the five-point turn that starts the Return. The driver completes the mission.

Regret check: 0. The check compares the exact DP with brute force on 60 random field subsets of 2-7 fields (dry cost tables). The largest relative difference is 3.7 × 10⁻¹⁶ (floating point). Brute force takes up to 0.18 s at 7 fields. The DP takes 1.9 ms.

The previous map products are those of 30 September 2026. Their hash is 0d3310d8b0c613cc by the first definition of the hash, which covered only the sources and the parameters. Each condition set had its own cost tables from drives. The original run recorded its outputs under Acres/Saved/work/phase4/final. Those raw outputs are not part of this release.

Measure	Value (Previous Products)
Single-field missions	59 of 59 complete
Time	6.3-27.4 min (median 15.0)
Coverage	At least 97.1 % (F50)
Crop outside the edge band	Median 8.1 m² (mean 15.4, F14 146 m²)
Largest cross-track error	Median 3.4 m (at most 8.7 m)
Closest obstacle	Median 1.7 m (at least 0.9 m)
Reverse	36 of the 59 missions reversed at some point: 84 gear changes, median 8.2 m backwards for each such mission, at most 28 m
Regret check	0 (2.1 × 10⁻¹⁶)

Five dead-end fields failed before the reverse gear. All five are complete with it. F04, F26, F37 and F45 use a three-point turn (two gear changes, 5-8 m backwards). F08 turns on its loop.

The 600 runs used the previous map products. No run of the suite exists for the current products. They are 200 missions × 3 condition sets. The reference driver drives the plan of each planner.

The intervals are 95 % intervals. The regret counts complete missions only. \(J\) and the time count all missions. Thus a planner whose large missions fail shows a smaller mean.

Planner	Condition	Success	Regret	J (MJ)	Time / T_ref	Fuel (l/km)	Crop outside (m²)	Collisions /100
Optimal	dry	0.96 [0.92, 0.98]	0	57.5 [54.1, 61.0]	1.00	0.262 [0.259, 0.264]	44.3 [38.7, 50.0]	0.5 [0.1, 2.8]
Optimal	wet	0.99 [0.96, 1.00]	0	60.3 [56.7, 63.8]	1.00	0.272 [0.271, 0.273]	39.4 [35.0, 43.9]	1.0 [0.3, 3.6]
Optimal	hardware shift	0.96 [0.93, 0.98]	0	57.2 [53.7, 60.7]	1.00	0.272 [0.271, 0.273]	43.0 [37.9, 48.6]	3.0 [1.4, 6.4]
Nearest first	dry	0.82 [0.76, 0.87]	0.026 [0.020, 0.033]	54.9 [51.1, 59.0]	0.99 [0.96, 1.03]	0.265 [0.262, 0.269]	34.1 [30.5, 37.9]	3.0 [1.4, 6.4]
Nearest first	wet	0.89 [0.83, 0.92]	0.029 [0.024, 0.034]	61.1 [56.9, 65.1]	1.04 [1.01, 1.07]	0.275 [0.273, 0.276]	34.8 [30.7, 39.0]	3.0 [1.4, 6.4]
Nearest first	hardware shift	0.89 [0.83, 0.92]	0.027 [0.022, 0.032]	59.4 [55.5, 63.3]	1.06 [1.04, 1.08]	0.274 [0.272, 0.275]	35.0 [31.2, 39.0]	3.0 [1.4, 6.4]
As listed	dry	0.89 [0.84, 0.93]	0.054 [0.044, 0.066]	61.1 [56.7, 65.1]	1.07 [1.04, 1.09]	0.264 [0.260, 0.267]	34.3 [30.4, 38.1]	2.5 [1.1, 5.7]
As listed	wet	0.90 [0.85, 0.93]	0.054 [0.045, 0.064]	64.8 [60.3, 69.1]	1.08 [1.06, 1.11]	0.273 [0.272, 0.275]	32.2 [28.4, 36.0]	2.5 [1.1, 5.7]
As listed	hardware shift	0.89 [0.83, 0.92]	0.052 [0.042, 0.061]	62.3 [57.9, 66.5]	1.10 [1.08, 1.13]	0.272 [0.271, 0.273]	31.6 [28.2, 35.3]	0.5 [0.1, 2.8]

By mission size (all three condition sets, 120 runs each):

Planner	Fields	Success	Regret	Time / T_ref
Optimal	1 / 2 / 3	1.00 / 1.00 / 0.98	0	1.00
Optimal	5 / 8	0.93 [0.87, 0.97] / 0.94 [0.88, 0.97]	0	1.00
Nearest first	1 / 2 / 3	1.00 / 1.00 / 0.88 [0.80, 0.92]	0.003 / 0.014 / 0.029	1.00 / 1.01 / 1.03
Nearest first	5 / 8	0.75 [0.67, 0.82] / 0.69 [0.60, 0.77]	0.041 / 0.066	1.06 / 1.04
As listed	1 / 2 / 3	1.00 / 1.00 / 0.91 [0.84, 0.95]	0.003 / 0.013 / 0.033	1.00 / 1.01 / 1.07
As listed	5 / 8	0.82 [0.74, 0.88] / 0.73 [0.65, 0.80]	0.099 / 0.153	1.17 / 1.17

Held-out fields make no difference to the reference driver. The optimal planner has 0.97 on missions of seen fields and on missions with held-out fields. The held-out fields are there for the learned drivers.

The numbers show these facts:

The planner becomes more important as missions grow. Nearest first costs 3 % more objective than optimal on average and 7 % at 8 fields. The order as listed costs 5 % and 15 %. The other planners fail more frequently. Most of these failures are timeouts: 98 of their 147 failures. Their paths are longer against a \(T_\text{ref}\) that the optimal plan sets. The next causes are collisions and, for nearest first, deep in crop (17). The orders of nearest first make more turnarounds between fields.
The optimal plans reverse frequently. 83 % of the optimal runs use the reverse gear (4.3 gear changes and 19 m backwards for each mission). A three-point turn priced at 60 m of lane is frequently cheaper than a drive around a loop to leave it in the correct direction.
Crop is not in the objective. On the same missions, the optimal plans crush 6 m² more crop outside the edge band than nearest first. This compares the 515 pairs that both planners completed. \(J\) counts only fuel and ground loss. The cheaper entries and directions cut more corners.
The failures of the reference driver (17 of 600 optimal runs) have two causes and one single case.
- F50 (the lawn strips that remained after T23). Its loop reaches 34 of its 35 checkpoints within 8 m. The 95 % rule of the build permits one miss. Anticlockwise from entry 2, the driver passes checkpoint 1 at 8.1 m (7.4 m by the path). Thus the field is not scouted, and 6 dry missions time out. Wet and hardware shift remove that loop direction. Its table drive also scouts only 94 %.
- F52. All 9 collisions occur on its loop: 1 dry, 2 wet and 6 hardware shift. The 3° offset of the steering wheel adds cross-track error. 8 collisions occur during the Scout and 1 when the vehicle leaves along the loop. There the loop passes obstacles approximately 2 m from the reference path. The nearest obstacle of the reference point is 2.3 m at the collision.
- One mission (S5-16) times out in dry and in hardware shift.

Reward Check#

eval.reward_check uses the reference driver in ACRES Core, on the map products of 1 October 2026. Values of the previous products are in brackets where they are different. The baseline scores above do not use the reward.

Measurement	Spec	Measured
Step reward at 4 m/s on the E_ref lane (dry)	+0.45	+0.517 (progress +1.067 at 4.27 m/s, time −0.25, energy −0.30)
Crop term straight through a corn field	−5	−4.96; the step reward −4.58 before the presence term: crossing crop never pays
Crop term on the longest edge-band stretch	−0.2	−0.161 (−0.155); the step reward at 3.1 m/s +0.019 before the presence term (left as it is, decided)
Crop presence (−1 a step with any part of the plan box, shrunk by 0.5 m, in crop outside the edge band)	−1 in crop, 0 on lane and edge band	−1.000 straight through corn (step reward −5.583). 0 on the E_ref lane (step reward +0.517 unchanged). −0.015 on the longest edge-band stretch (F14), step reward +0.004 (+0.009). Without the shrink it was −0.415 there, and the step reward was −0.390. The plan box reached past the 2 m band on 41 % of the steps
Progress over milestones per single-field episode (median)	> 5	75.9 (75.4)

Limitations#

Three-point turns. The driver does a three-point turn at walking speed with two stops and two shifts (approximately 15-25 s each). The cost tables do not drive these turns. The planner prices a U-turn at 60 m of lane. The route code checks their paths on the ground classes and obstacles of the map products. No drive tests them before the mission.
Tracking. The largest cross-track error of the reference driver on the loops is approximately 1-2.5 m, at their tightest corners. The crop that it crushes outside the edge band is a part of its baseline scores.
Two loops of the previous map products caused most of the failures of the reference driver in the 600 runs. The loop of F50 covers its checkpoints with one to spare. The loop of F52 passed obstacles approximately 2 m away. The current products keep the loop of F52 2.74 m clear, which is the maximum that the trees in its lobe permit. Each other loop but that of F49 is 3.66 m or more clear. F50 is unchanged.
The Return of F45 starts with a five-point turn. The short link of its exit leaves the loop in the opposite direction. The planner does not price such a turn: a link under 6 m has the heading with which the vehicle entered it. The progress of the tracker stops 1 m short of one of the cusps. Thus the remaining Return reads as off the path. The reference driver completes it. The training aid "lost" ends a learned driver there.
Leg costs are sums of drives for each edge. The table drives do not include the turns between edges, the loop arcs (priced per metre) or the turnarounds.