GPT-6 Astra Running Routes Worked, but the Code Disappeared

GPT-6 Astra spent 27 minutes generating running routes from Simon Willison’s home, then delivered maps and downloadable files that matched his request. The successful result made the missing evidence more striking. ChatGPT Work showed him the finished route, but not the Python code or complete execution history behind it.

Willison had requested 5K and 10K loops that started and ended at his address. He told ChatGPT Work to use OpenStreetMap data. According to his running route account, the agent returned an embedded visualization, GPX downloads, and GeoJSON files.

The task is an unusually concrete example of agentic AI becoming useful outside conventional office work. It joined geocoding, map-data retrieval, graph analysis, route selection, file generation, and visualization within one conversation.

Yet the result also exposed a conflict at the center of AI agents. A system can finish a difficult task while leaving its user unable to reconstruct how it reached the answer.

That conflict matters more than the route itself. OpenAI presents GPT-6 Astra as a model for extended computer work, where users delegate complex goals rather than request isolated answers. Such delegation raises the value of execution records, intermediate files, and reproducible code.

The GPT-6 Astra running routes example therefore tests two promises at once. Astra appears capable of completing a specialized geospatial workflow. ChatGPT Work appears less prepared to preserve the evidence needed to inspect that workflow afterward.

GPT-6 Astra Running Routes Joined Several Tools Into One Result

The important change was not that an AI suggested a jogging path, but that it assembled a usable geospatial deliverable from a short request.

Willison asked the system to locate his address and calculate two loops using OpenStreetMap data. A loop needed to begin and end at the same location while remaining reasonably close to a target distance.

That is harder than asking a mapping service for directions between two fixed points. The agent first needed a geographic starting coordinate. It then needed a local network of roads and trails that a runner might use.

ChatGPT later told Willison that it used Nominatim to locate the address. Nominatim is a geocoder, meaning it converts a written place or address into geographic coordinates.

The system said it used Overpass to download nearby OpenStreetMap roads and trails. The Overpass API provides structured queries against OpenStreetMap data, including geographic features and their descriptive tags.

The remaining work reportedly happened locally. The agent needed to transform map elements into a connected network, identify candidate loops, estimate their lengths, and select routes near five and ten kilometers.

Willison did not receive the implementation, so those specific algorithmic steps remain an informed reconstruction. The agent’s short explanation did not identify its graph library, search method, route-scoring rules, or filtering logic.

The visible outputs were more concrete. ChatGPT Work generated a 5.1-kilometer harbor loop and displayed it within the conversation. It also supplied GPX and GeoJSON files, two common formats for exchanging route geometry.

GPX is an XML-based format supported by many fitness devices and mapping applications. GeoJSON represents geographic features using JSON, making it convenient for web maps and software pipelines.

The embedded map was itself a generated artifact. Willison found that ChatGPT had created an HTML file containing route geometry and JavaScript that rendered the visualization with D3.

The HTML stored the geometry inside an application data element. That meant the displayed route was not merely a static screenshot. It contained coordinates that software could read and redraw.

This combination matters because it crosses the boundary between an answer and a finished deliverable. A list of street names would still require substantial work before a runner could use it.

The generated files could be imported elsewhere, inspected, or transferred to compatible devices. The map gave the user an immediate visual check without requiring another application.

OpenAI describes ChatGPT Work as an agent for longer, multi-step tasks and finished deliverables. Its current Work documentation distinguishes that experience from ordinary conversational assistance.

The route task fits that definition closely. It began with a natural-language goal, used external data, performed local computation, and returned several coordinated outputs.

However, success at that level changes what users need from the interface. Once an agent performs meaningful computation, its process becomes part of the product, not disposable background activity.

Why This Small Mapping Task Matters

The route is a compact demonstration of how AI agents can turn specialist workflows into ordinary requests.

Building such a route manually would usually involve several tools. A user might geocode an address, download map data, configure routing software, inspect candidate paths, and export the chosen geometry.

Each stage requires a different form of knowledge. Geocoding requires awareness of place-search services. OpenStreetMap extraction requires query syntax or a suitable interface.

Route calculation introduces graph concepts such as nodes, edges, path weights, and connectivity. File export requires knowledge of the formats accepted by fitness and mapping applications.

ChatGPT Work apparently coordinated those parts without asking Willison to supervise each technical choice. The interface let him describe the outcome instead of prescribing a complete implementation.

That is the central value proposition of a general agent. It can select and combine tools according to a goal, rather than limiting the user to a predetermined workflow.

The timing is also significant. OpenAI introduced Astra with an emphasis on coding, browsing, computer use, and complex professional work. Its Astra launch page presents the model as capable of producing files, plots, websites, and other completed artifacts.

OpenAI reports that Astra scored 72.6 percent on its cited OSWorld 2.0 configuration. GPT-5.6 Sol scored 65.7 percent under the same reported setup.

The company also says Astra completed those simulated computer tasks in roughly 40 minutes, compared with roughly 75 minutes for GPT-5.6 Sol. Those remain company-reported benchmark results, not independent validation of Willison’s route.

Still, the 27-minute running task gives those broader claims a recognizable shape. The model did not simply operate a familiar website or fill fields in a standard form.

It apparently improvised a workflow around open geographic infrastructure. It chose services, downloaded data, ran calculations, created portable files, and built a custom presentation layer.

That flexibility pressures two categories of software. The first consists of specialized consumer tools built around fixed route-planning interfaces.

A general agent does not need to replace those products completely. It can instead handle unusual requests that rigid interfaces struggle to express.

A runner might ask for a loop near a precise distance, avoid a particular road, favor trails, pass a water fountain, or finish before sunset. Natural language can combine those constraints easily.

The second pressured category is the traditional chatbot itself. Once users see an agent complete such work, a text-only answer begins to feel incomplete.

They expect generated files, interactive views, editable calculations, and a record of the steps performed. The deliverable becomes the standard against which the conversation is judged.

OpenAI’s September release notes describe Astra as an improvement for multi-step work. They also state that ChatGPT Work can use local files and supported website tools with permission.

The route example suggests that these capabilities can reach beyond office documents. They can support personal projects with technical requirements that previously demanded custom software.

That does not make the output automatically trustworthy. It makes verification more important because the agent can now produce artifacts that look complete enough to use immediately.

The Main Conflict Is Capability Versus Auditability

ChatGPT Work completed the requested job, but it did not preserve enough visible evidence for the user to reproduce the result.

Willison asked how the route had been created after receiving the deliverables. ChatGPT provided the high-level explanation involving Nominatim, Overpass, and local calculations.

That explanation identified the broad architecture. It did not reveal which service endpoints were contacted, what queries were submitted, or which map tags were treated as runnable.

It also did not reveal how candidate loops were generated. A routing script might use shortest-path searches, waypoint sampling, cycle detection, optimization, or several combined methods.

Those choices influence the final route. They can determine whether the system favors paved roads, coastal trails, crossings, steep segments, or paths with incomplete access information.

Willison then asked for the Python code. ChatGPT could no longer provide it, apparently because the conversation had undergone compaction.

Compaction condenses earlier context so a long-running agent can continue within its available context window. It can help the system remain operational, but details may disappear from active context.

Willison argued that systems using compaction should preserve the original material. He also wants agents to be able to retrieve that material through tools when a later request requires it.

His criticism identifies an interface problem rather than a model-intelligence problem. The system may have produced sound code and still failed to provide an adequate record.

This distinction is essential. Model capability answers whether an agent can complete a task. Auditability answers whether a person can understand, verify, repeat, or challenge that completion.

For casual ideation, a concise summary of the process may be enough. For generated routes, financial calculations, research datasets, or business files, it often is not.

A useful audit trail does not require exposing private chain-of-thought reasoning. It can consist of operational evidence that belongs to the task.

That evidence could include generated scripts, terminal commands, data-source URLs, timestamps, tool responses, warnings, intermediate files, and the versions of relevant libraries.

Such records differ from hidden internal reasoning. They document observable actions and transformations, much like a build log documents how software was produced.

The route’s HTML survived because it was part of the final deliverable. The Python implementation did not, even though it was arguably more important for verification.

This asymmetry encourages users to trust presentation over provenance. A polished map can look authoritative while concealing assumptions that materially affect safety and accuracy.

The issue becomes sharper when an agent works for 27 minutes. A longer task can involve more state, more tool calls, more intermediate decisions, and more opportunities for silent failure.

Users should not need to predict which artifact they will want later. The system should preserve a structured task package before context compression removes important details.

A strong package would connect each output to its origin. The GPX file should be associated with the exact script, source data, parameters, and execution that produced it.

This is similar to maintaining an AI workflow with traceable inputs and outputs. The subject differs, but the record-keeping principle remains the same.

The fundamental opponent in this story is therefore capability versus auditability. Astra delivered an impressive outcome, while the surrounding product failed to make that outcome fully inspectable.

OpenStreetMap Adds Policy and Safety Questions

A route can be technically valid while remaining unsuitable, unsafe, or inconsistent with the policies governing its data sources.

The generated result relied on OpenStreetMap, a collaborative geographic database whose coverage and tagging vary by location. Its openness makes unusual workflows possible, but it does not eliminate uncertainty.

A road or trail can exist in the database without being appropriate for every runner. Access restrictions, temporary closures, surface conditions, lighting, crossings, construction, and local hazards may be missing or outdated.

A graph calculation can also produce a connected loop that looks sensible on a screen but performs poorly on the ground. Connectivity alone does not establish comfort or safety.

The missing source code prevents outsiders from checking how the agent handled those factors. It is unclear which highway classes were permitted or whether private-access tags were excluded.

It is also unclear whether the agent recognized sidewalks, pedestrian restrictions, unpaved surfaces, stairs, ferry connections, or trail sections with limited access.

Willison reported that the system produced exactly what he requested. That is useful firsthand evidence about task completion, but it is not a comprehensive validation of route quality.

The example includes only one user, one area, and one pair of requested distances. The article did not report a field test, elevation analysis, accessibility review, or independent comparison.

The geocoding step creates another concern because an exact home address is sensitive information. Users should understand where an agent sends that address and which logs may retain it.

OpenAI says Work can use files, browsing, and task context according to the permissions of the selected environment. Managed accounts can also be subject to organizational retention and governance settings.

The cited route account does not establish which Nominatim deployment the agent contacted. It therefore cannot confirm what logs, limits, or retention practices applied to that request.

If the agent used the public OpenStreetMap Foundation service, the Nominatim policy would matter. The policy limits heavy use and requires identifiable requests and appropriate attribution.

The policy also places restrictions on automatically generated generic geocoding services. One personal lookup is different from deploying a mass-market routing product, but agents must distinguish those cases.

Overpass introduces similar operational considerations. Its public servers support small projects but can become overloaded, according to the Overpass guidance.

That guidance encourages regular or commercial users to cache requests, reduce consumption, use extracts, or operate suitable infrastructure. Public endpoints are shared resources, not unlimited agent backends.

An auditable execution record would help resolve these questions. It could show the exact endpoints, request headers, query counts, attribution, and response sizes.

Without that record, the user cannot confirm whether the agent respected the relevant service policies. The finished files offer little evidence about how the data was acquired.

Safety also requires presenting routes as suggestions, not verified instructions. A runner should inspect unfamiliar segments and account for current local conditions before relying on an automatically generated loop.

The system should expose route assumptions in plain language. It might state that it excluded private roads, favored pedestrian paths, accepted unpaved trails, and lacked current closure data.

Those disclosures are not decorative disclaimers. They help users decide whether the output matches their needs and whether further checking is necessary.

A route-generation agent also needs a way to report uncertainty. If map tags conflict or a trail’s access status is unclear, that ambiguity should survive into the final deliverable.

Astra’s result shows that open map data can support sophisticated personal tasks. The missing trace shows why access to open data does not substitute for transparent execution.

What Transparent Agent Work Should Preserve

The next test for ChatGPT Work is whether successful tasks become reproducible project records instead of disposable conversations.

The most immediate signal will be persistent access to generated code and commands. Users should be able to reopen a completed task and retrieve every artifact created during execution.

This does not require displaying constant terminal output by default. A compact interface could show the result first while retaining a complete activity record behind an inspection control.

The second signal will be provenance attached to each deliverable. A file should identify the inputs, tools, transformations, and warnings associated with its creation.

For the GPT-6 Astra running routes task, provenance would connect the GPX and GeoJSON files to the same route calculation. It would also preserve the relevant OSM query and generated Python script.

The third signal will be better handling of context compaction. A compacted conversation should retain a recoverable archive even when the model no longer carries every detail actively.

The agent could search that archive when a user asks what happened earlier. This would separate efficient active context from durable task history.

These changes would strengthen OpenAI’s transparency claims without exposing private model reasoning. OpenAI says Astra emphasizes alignment, task boundaries, and clearer behavior during delegated work.

Operational records would make those claims testable at the product level. Users could inspect whether an agent stayed within scope instead of relying only on its summary.

Competitors building general agents face the same challenge. Faster task completion and better benchmark scores will matter less when users cannot verify business-critical outputs.

Developers already expect reproducible environments, version histories, and logs. Knowledge workers will develop similar expectations as agents begin producing analyses, presentations, datasets, and operational changes.

The interface should also allow users to export a complete task bundle. That bundle could contain the prompt, approved permissions, scripts, logs, source references, artifacts, and a concise execution summary.

A shareable bundle would improve collaboration. A colleague could review the method without reconstructing the entire conversation or trusting a screenshot.

It would also support correction. If a route included an unsuitable trail, the user could identify the responsible rule and rerun the workflow with a revised constraint.

Persistent records would make agent work cumulative. A successful 5K route could become the starting point for later requests involving hills, surfaces, lighting, or seasonal closures.

Without those records, every follow-up risks becoming a fresh inference. The agent might generate a different method while presenting it as a continuation of the original task.

The underlying achievement should not be minimized. A short natural-language instruction produced two loop distances, an interactive map, and portable geospatial files in 27 minutes.

That is a credible example of a general agent coordinating tools for a specific personal objective. It illustrates why finished deliverables can matter more than fluent answers.

The case also shows that output quality cannot be the only success measure. Users need durable evidence when an agent’s process affects the reliability, safety, or legality of its work.

Future GPT-6 Astra running routes should therefore be judged by two outcomes. Did the route meet the request, and can the user reconstruct exactly how it was produced?

If OpenAI adds durable execution histories, artifact provenance, and recoverable pre-compaction records, this example will look like an early product gap. If it does not, hidden work will become a larger liability as agents take on higher-stakes tasks.

The practical response is to ask for evidence while the task is still active. Request the script, source endpoints, assumptions, intermediate files, and verification notes alongside the final deliverable.

That habit should not remain necessary forever. A mature agent interface should preserve those materials automatically and let the user decide when to inspect them.

The route worked. The next milestone is making the work behind it as portable, reviewable, and durable as the GPX file itself.