Down from 2:43.38 on the first full lap. A rule-based driver for the TORCS simulator, improved one measured change at a time over 133 recorded versions. No damage, never off the track.
Entry for AI Racing League – Go FullSpeed with IBM Bob by One Qubit Racing, a team of one: Adriano Torres.
Watch the lapOpen the run viewer
For the judges:Lap videoTechnical summaryUse of IBM BobVideos and certificateRulesGitHub repository
Part 1 of 3
Every version's lap time, then the lap itself.
The numbers on this page are read from data.json, which could not be loaded. Open the page through a web server: run python -m http.server in the site folder and visit http://localhost:8000.
Point at the chart, or use the left and right arrow keys, to read any version.
The simulation is deterministic: running the submitted driver again reproduces the lap's telemetry file byte for byte (python tools/finalize.py --verify runs/run_20261008_223916.csv).
Part 2 of 3
How the driver works, what turned the project, and the tool that replays every lap.
The driver is one Python file of explicit rules. It contains no neural network and no trained model. The example driver supplied with the challenge aims for 300 km/h, never brakes and crashes on its first lap; everything below was built on top of it.
It works like a racing driver who has walked the track beforehand. The plan for the lap is worked out before the race. On the lap, the sensors decide every pedal and steering movement.
Computed before the race, stored by distance from the start line
Read every step, about 21 ms
Sent every step
One mechanism per version, so its effect can be measured. In the final versions each candidate drove 730 laps with its settings and its plan deliberately nudged: 70 for the lap time, compared run by run against the version before, and 660 around the new values to look for a way off the road. Any damage, or any lap with the car's centre past the edge, rejected the version. Of 133 versions, 100 were kept, 11 were kept as groundwork for a later gain and 22 were rejected. The record of every one, with what was learned, is in the changelog.
Each position on the card is one of the 133 versions, in order. A hole is punched for the 36 whose notes say how many races they ran: about 42,900 races between them.
The other 97 versions kept no count, so the true total is higher. For scale, the final check on one late candidate was 730 laps.
For the first 105 versions the car drove on its sensors alone, because we held back track memory until the officials answered. That approach ran out at about 1:13.6: in batch 12 four of five versions were rejected, since a car cannot set up wide for a corner it does not yet know is coming. On 4 October the officials allowed a pre-mapped track, and the question that turned the project came three days later:
Since we can memorize the track can't we precompute the most optimal racing line and adjust that?
The last eight seconds came from that line, the speed it allows and the rulings that let the car use the whole road.
The last 29 versions, with the decision that opened each run of gains.
Part 3 of 3
The technical summary, how IBM Bob was used, the deliverables and the full record.
The driver is a rule-based controller in one Python file. It contains no machine-learning model. Steering, braking, throttle and gear changes come from explicit logic reading the simulator's live sensors: 19 range beams, wheel speeds, engine speed, speed, track position and angle.
The project produced 133 tagged versions on the Corkscrew circuit (3,608 m) between 1 and 8 October 2026. The first completed lap was 2:43.38 (v0.2). The submitted version, v1.33, laps in 1:05.56, which is 97.82 seconds faster, with zero damage and the car's centre inside the track edge for the whole lap (largest |trackPos| 0.862).
Design. Track memory, computed offline from the track's geometry and stored by distance, holds a racing line, the speed it allows and the road's elevation. These are parameters, not replayed actions. Every step the live sensors correct the steering against the line, set the pedals from the car's actual speed against the stored speed, and run anti-lock braking, traction control and the gearbox.
Tooling. A harness runs up to four simulators at once and judges each candidate on hundreds of deliberately perturbed laps. An optimiser tunes single settings, and a pattern check catches steering wobble and on/off pedals. Every version is a Git tag with its telemetry.
Use of IBM Granite. IBM Bob did the analysis, the planning and the reviews described below. The driver's code was written with Claude Code.
Key challenge. On sensors alone the car cannot prepare for a corner it has not seen. The lap time stalled at 1:13.6 until the officials allowed a pre-mapped track.
Rules. Six questions of legality are recorded, each with a fallback version: four confirmed by the officials, two our own reading.
IBM Bob, the coding assistant built on IBM Granite, was this project's analyst, planner and reviewer. Its log holds 13 sessions between 1 and 6 October, and it drafted the outline of this page.
Bob was at its best reading code, analysing data and planning. Its direct edits to the driver's control code were less dependable: in my experience most of them left the lap slower or less stable. That is an impression from working with it, not a measured figure. So I settled early on a division of work. Bob handled analysis, planning and review, and the driver's code was written with Claude Code, with every version measured in the simulator before it was kept.
The driver itself contains no model. Granite helped build it; it does not drive it.
| Version | Lap | Why it matters |
|---|---|---|
| The first completed lap. The supplied driver crashed, so the target speed was dropped to 80 km/h: finish first, go fast later. | ||
| Steering toward where the road is going: the first real steering logic. | ||
| Corner speed that depends on how sharp the corner is, judged from all the range beams. | ||
| The first target, 1:24, beaten the evening it was set. | ||
| The second target, 1:14.72, beaten on sensors alone, close to what sensors alone could do. | ||
| The first use of track memory after the officials allowed it: a speed allowance per corner. | ||
| The turning point: a racing line computed in advance, followed with live corrections. | ||
| The whole lap on the planned line, with its stored speed deciding where braking starts. | ||
| Declared finished: gears, the road's elevation, gentler steering corrections. | ||
| Reopened after watching the lap and seeing unused road. Every corner checked, four widened. |
| Batch | Versions | Best lap | What it worked on |
|---|
Six times the driver began to rely on something whose legality was not obvious. Four were put to the officials and confirmed. Two are our own reading of those answers and were not asked separately. Each one names the version we would submit if it were turned down.
| What the driver does | Since | Status | Fallback |
|---|
On track limits the officials' answer was: Use trackPos between −1 and +1 as the practical sensor-based check. This measures the car's position, rather than whether individual wheels cross the edge.
On the judged lap the car's centre reaches 0.862 at its widest, 1037 m from the start line.