GPT-6 Astra Tackles 27-Minute Geospatial Task, Revealing Context Compaction Risks

Software engineer and researcher Simon Willison tasked ChatGPT Work, running OpenAI's GPT-6 Astra (Max) model, with generating 5K and 10K running loops from his home address using OpenStreetMap data. The agent operated autonomously for 27 minutes before returning functional interactive visualizations alongside downloadable GPX and GeoJSON files, demonstrating remarkable long-horizon execution while exposing severe observability gaps when the system discarded its own code.

Key points

• GPT-6 Astra worked autonomously for 27 minutes to query Nominatim, pull Overpass OpenStreetMap data, and calculate custom running routes.
• The agent generated interactive D3 map visualizations, GPX files, and GeoJSON files within an embedded workspace file.
• OpenAI's interface concealed the underlying Python execution logs from the user during the job.
• Post-run context compaction deleted the generated code, preventing the user from retrieving or auditing the execution script.

What happened

Willison initiated the task on September 12, 2026, directing the model to identify running routes that loop directly from his residential address using OpenStreetMap (OSM) data. The system ran continuously for 27 minutes, orchestrating multiple steps behind the scenes. According to the agent's explanation, it resolved the street address via the Nominatim geocoder, downloaded local road and trail networks through the Overpass API, and executed local algorithmic calculations to plot the requested loops.

The final deliverables included an embedded interactive map and exportable files in standard GPX and GeoJSON formats. To render the map, the model activated an internal visualization skill, assembling a dedicated file named `/workspace/el-granada-5k-share.html`. The generated markup embedded route geometry inside a dedicated JSON script tag and rendered the visual layout using D3 pulled from an allow-listed content delivery network.

Despite the successful route generation, the session highlighted a frustrating operational black box. The interface suppressed the Python scripts and terminal output while the agent worked. When Willison subsequently prompted the agent to produce the exact code used to calculate the loops, the model could no longer retrieve it because the thread had undergone context compaction.

The backstory

Agentic workflows in modern foundation models have shifted from rapid conversational exchanges to sustained, asynchronous problem-solving. Early autonomous setups frequently drifted or halted due to strict context window limits and execution timeouts.

To support extended multi-step tasks without exceeding memory thresholds or ballooning inference costs, model providers introduced automated context compaction. This architectural technique summarizes or truncates earlier intermediary tokens—such as API responses, scratchpads, and execution logs—retaining only what the system deems necessary to finish the user prompt. When applied aggressively without persisting intermediate artifacts, compaction turns generative environments into ephemeral black boxes.

The opacity problem in autonomous agents

Willison described the inability to view running code as an "anti-feature," identifying a structural tension between consumer-facing chat interfaces and developer requirements. For power users and technical enterprises, the real value of an autonomous agent lies not merely in the final output file, but in the reproducible methodology behind it.

Hiding operational steps prevents practitioners from evaluating route quality, verifying data provenance, and auditing computational efficiency. If an enterprise relies on an agent to process location metrics or financial records, blind trust in an uninspectable 27-minute runtime introduces compliance and reliability risks. Teams cannot know whether the model picked optimal paths or brute-forced calculations through brittle heuristics without seeing the Python code.

The structural cost of lossy compaction

Compaction is a pragmatic necessity for token economics, yet lossy pruning breaks workflow reproducibility. When an agent discards its intermediate execution scripts, users lose the ability to iterate on the generated program, parameterize the logic, or port the solution into external production pipelines.

Platforms employing compaction need to maintain the original raw text and expose those uncompacted artifacts through agent tool calls. Without an explicit persistent storage layer for generated code and raw tool outputs, enterprise developers are forced to treat multi-minute agent runs as one-off disposable scripts rather than durable software assets.

What builders and businesses should do

• Require explicit file-system persistence for all generated code, intermediate outputs, and tool logs during agentic workflows.
• Implement dual-track context architectures that compact conversation context while preserving full execution traces in accessible sidecar storage.
• Demand granular UI inspection panels from agent vendors to monitor long-running background tasks in real time.
• Validate third-party API usage in autonomous workflows to avoid rate limits when agents run long-horizon scraping loops.

The bottom line

As autonomous models extend runtimes into tens of minutes, platform architectures will be judged on auditability and state preservation rather than raw reasoning capabilities alone.