Ask ChatGPT Work to Plan a 5K/10K Running Route: A Playbook from GPT-6 Astra

GPT-6 Astra and ChatGPT Work can now take an address and hand you back a proper circular 5K or 10K running loop — real streets, a real distance, downloadable as GPX and GeoJSON, with an interactive map embedded in the chat. The trick is knowing that they are two different layers doing two different jobs. ChatGPT Work is Open​AI's agentic product tier — announced July 9, 2026, for $20-a-month-and-up subscribers — where a model can keep working for half an hour across files, a shell, and the internet. GPT-6 Astra is the flagship reasoning model that shipped September 3, 2026, hit general availability on September 5 across every paid ChatGPT tier, ChatGPT Work, Codex and the API, and is the model that turns a one-line request into a multi-step, 27-minute route-planning session. This playbook covers the working prompt, the tools the agent actually reaches for (OpenStreetMap, Nominatim, Overpass), the outputs to expect, and the honest caveats — because the workflow is genuinely useful, and because the part nobody shows you is the part that can bite.

The one-paragraph recipe

The request that works, as demonstrated by Simon Willison on September 12, is almost embarrassingly short:

• Prompt: "I live at <my address>. Figure out 5K and 10K running routes from me that loop from my house. Use OSM data."

• What happened next: ChatGPT Work ran with GPT-6 Astra (Max reasoning effort) for 27 minutes, and returned a 5K loop and a 10K loop, each as an embedded interactive map plus downloadable GPX and GeoJSON files.

• The route was real: the 5K result ("El Granada harbor loop 5.1 km") ran from the harbour north along Avenue Granada and Paloma Avenue, east along San Carlos Avenue, south down Francisco Street, and back west along the Coastal Trail.

That last detail is the point of a playbook. This is not a hallucinated list of street names — it is a route that loops, has a plausible distance, and matches the actual road network of the area. When the model was asked how it built it, it answered plainly: "I used Nominatim to locate the address and Overpass to download local OpenStreetMap roads and trails, then calculated the loops locally."

The workflow, in other words, is a real agent run: geocode the address, pull real map data, compute closed loops of the right length, render a visualisation, and export standard interchange formats. If you have wanted a "plan me a route" prompt that actually works, this is the shape of it.

What ChatGPT Work actually is, and why it matters here

ChatGPT Work is not a model. It is the product surface where a model gets to act like an agent: it can execute code, reach the internet, use a headless browser, keep a persistent workspace across sessions, and run for a long time. It split, confusingly, into two forms: Work Cloud (via chatgpt.com or the mobile apps) and Work Local (the desktop app formerly called Codex, which can touch files and programs on your own computer). It is available to subscribers on $20-a-month-and-up plans — free users and $8 Go users get none of it — and Work sessions draw against your Codex allowance rather than your chat allowance.

That is why the route-generation worked where a normal chat turn would fail: the task needs code execution, internet access to geocoding and map-data services, and enough sustained attention to iterate. Normal ChatGPT chat answers in a few seconds and moves on. ChatGPT Work keeps working. The model choice inside Work matters too — Open​AI recommends GPT-6 Astra for exactly the kind of multi-step end-to-end job this is, with reasoning effort configurable up to Max.

So the playbook's first rule: this is a Work task, not a Chat task. Open ChatGPT Work, select GPT-6 Astra, and let the session run rather than expecting an instant answer.

The tools under the hood: OSM, Nominatim, Overpass

None of the real machinery is Open​AI's own. The agent assembled the route from public geographic infrastructure, and it is worth knowing what each piece does — both so you can sanity-check the output and so you could reproduce the pipeline yourself if you ever want to run it outside ChatGPT.

• OpenStreetMap (OSM) is the free, crowdsourced map of the world — the data source for the roads and trails the route follows.

• Nominatim is OSM's geocoding service: it turns a human address ("I live at <my address>") into map coordinates.

• Overpass is the query API for OSM data: the agent used it to download the local roads and trails around those coordinates.

• The loop calculation itself ("calculated the loops locally") ran in the agent's own workspace — taking the raw road graph and finding closed circuits of roughly the right length.

That decomposition is the reproducible core. If you wanted to build the same thing yourself, the pipeline is: geocode with Nominatim, pull a road network with Overpass, compute loops, export GPX/GeoJSON, render with a mapping library. ChatGPT Work just did all of it on your behalf, with no API keys, no routing-library research, and no code you had to write.

What you get back: the visualisation skill and the files

The outputs are the part that makes this feel finished rather than demo-y. On the display side, the agent used ChatGPT's built-in visualize skill to create a self-contained HTML file — in the observed run, /workspace/el-granada-5k-share.html — that embedded the map directly into the ChatGPT UI. The HTML stores the entire route geometry in a <script type="application/json"> element and renders the map with D3.js loaded from a CDN. The skill's content-security policy allows only a specific list of external origins — cdnjs.cloudflare.com, esm.sh, cdn.jsdelivr.net, unpkg.com, fonts.googleapis.com, fonts.gstatic.com, and fonts.bunny.net — and "other origins are blocked and fail silently." That detail matters if you ever inspect a generated file: the map will work with those libraries and silently degrade without them.

On the file side, you get two interchange formats that every GPS app and mapping tool already understands:

• GPX — the standard GPS exchange format. Import it into Strava, Garmin Connect, or any route app and it will render as a followable route.

• GeoJSON — the geospatial JSON format. Use it in QGIS, Leaflet, Mapbox, or any geospatial tooling; it is also the format the embedded visualisation stores its geometry in.

If your goal is a route you can actually run, the GPX file is the deliverable — the embedded map is the proof it is sane, and the GeoJSON is the copy for anything programmatic.

What the demo does not tell you: two real caveats

The route generation is real, but the honest picture of ChatGPT Work comes from its failure modes, and the person who tested it surfaced two of them the same morning.

1. The execution is opaque. The agent's code and its exact steps were not visible in the ChatGPT UI — only the summary explanation ("I used Nominatim… then calculated the loops locally"). For a route, that is fine; for anything consequential, it is a transparency gap you should assume is present. Willison calls it "an anti-feature": you see the result and the model's own account of the result, not the code that produced it.

2. Compaction can erase the work. By the time he asked for a copy of the Python code, the agent could not produce it — the thread had been compacted, and the pre-compaction context was gone. Any long agent session you rely on carries this risk: the thread gets summarised, and artifacts or code that were never saved to a file are no longer retrievable. If you need the code, ask for it as a file during the run, not after.

Neither caveat undermines the playbook — a route plus GPX/GeoJSON exports is exactly the kind of deliverable that survives compaction because it was written to disk. But they set expectations: ChatGPT Work is powerful, not transparent, and not a durable record of everything it did.

Why this matters more than a neat demo

Underneath the running routes is a genuinely new capability worth pricing out: a frontier model that will take a one-line request, do 27 minutes of real multi-step work across geocoding, network queries and local computation, and hand back usable files. That is what "agentic work" means in practice, and it changes what you should expect from a model request. It also changes the cost arithmetic — and this is where the routing angle earns its keep.

In ChatGPT Work, that 27-minute session draws against your subscription's Codex allowance, and on GPT-6 Astra the tokens burn fast. The same model is available per token through the API: GPT-6 Astra lists at $10 per million input tokens and $50 per million output tokens, with a ~1.05-million-token context window, and a long-context tier above 272,000 input tokens at higher rates — vendor list pricing. For an agent loop that keeps the whole session in context, that long-context tier is where the spend lives.

That is exactly the cost a routing layer exists to manage. One API across 200+ models with provider list price passed through at 0% markup means a $10-and-$50 frontier model like GPT-6 Astra sits next to a $4-and-$20 GPT-5.6 Sol on the same key, and you can switch between them with a model string — no second contract, no code change, no per-vendor integration. If you want to prototype a route-planning or other long-horizon agent against the newest model without betting a production path on it, automatic failover lets you run a slice of traffic on it while a proven model stays underneath. And when a vendor cuts a price, the pass-through means the new price is live on our side the same day — the same list price, with no markup layer in between.

The same argument applies to the tooling pattern, not just the model. The OSM/Nominatim/Overpass pipeline the agent used is exactly the kind of thing a developer might want to call deterministically — and if you do build it yourself, you would route the model layer through one endpoint rather than hard-coding a single vendor, so the model that plans the route can be swapped or fail over without rewriting the pipeline.

The playbook, condensed

If you want to reproduce this yourself, the shape is:

• Use ChatGPT Work (not regular chat), with GPT-6 Astra selected at a high reasoning effort.

• Prompt with a real address and the target distances: "I live at <address>. Figure out 5K and 10K running routes from me that loop from my house. Use OSM data."

• Expect it to take tens of minutes, not seconds — and expect it to work on its own.

• Ask for the outputs in file form as it goes: GPX for your watch or app, GeoJSON for anything programmatic, and the visualisation it renders in the chat.

• If you need the code it wrote, ask for it saved as a file during the run — compaction can erase it afterwards.

That last step is the one everyone skips, and the one that actually bites. The model will happily plan your loops all day; it just may not remember the code that did it by the time you ask.

The same key reaches the rest of the catalogue, and you can browse the full model catalogue to see what else sits behind one Open​AI-compatible endpoint.