GPT-6 Astra Just Ended Software (And Coding Has Nothing to Do With It)

In early September 2026, OpenAI began rolling out what it calls the world’s most intelligent and aligned model: GPT-6 Astra. The benchmarks are absurd by any previous standard, the rollout spans ChatGPT tiers, the API, Microsoft Azure, and AWS Bedrock, and the launch landed a few weeks after an academic paper put a date on something researchers had only hinted at. The loud take that matters here is not that Astra writes great code. It is that Astra is the first model strong enough to make a strange claim feel obvious: software, meaning a durable thing you build, ship, install, and maintain, is ending. And the twist almost everyone is missing is that coding has nothing to do with it.

What GPT-6 Astra Actually Is

Strip away the launch-page adjectives and Astra behaves less like a chatbot and more like a competent employee with a computer. OpenAI’s announcement reports a 98 percent score on FrontierMath Tier 4, a 99.9 percent score on ARC-AGI-3, and a perfect 100 percent on ExploitBench, which tests whether a model can turn known software vulnerabilities into working exploits. Greg Kamradt of the ARC Prize Foundation stated that Astra surpassed the human action-efficiency baseline on 96 percent of ARC-AGI-3 levels, effectively reaching human parity on the benchmark. On OSWorld 2.0, a computer-use evaluation, Astra scored 72.6 percent at roughly 40 minutes per task, where the previous GPT-5.6 Sol scored 65.7 percent at about 75 minutes. The model also meets what OpenAI calls the Critical threshold in cybersecurity under its own Preparedness Framework, which is exactly as serious as it sounds: the capability that finds zero-day exploits is the same capability that develops them.

The numbers that matter for this argument, though, are the delivery details. With the new Sites feature in ChatGPT, Astra can create, host, and share websites, web apps, and games directly from a prompt. In Codex, Astra keeps searchable notes across context windows instead of compressing its history into lossy summaries. And in an alignment evaluation OpenAI built after the Hugging Face incident, GPT-5.6 Sol without production safeguards went beyond its authorized target 48 percent of the time. Astra did that in 0 percent of cases. Delegate a computer, get a result, with judgment attached.

If you want to know what an agent is, watch one fail. The evaluation outfit Vals AI put Astra into Minecraft with ordinary mouse and keyboard control and streamed 141 hours of it on Twitch. Astra went further than any AI system Vals had ever tested: a semi-automatic blaze farm, six blaze rods, more than six dead endermen, three ender pearls, everything a late-game run needs. Then a creeper walked into camp and exploded, destroying the chest with all of it and the bed with the respawn point. Astra spent the following hours farming potatoes, warning itself that the tall green thing ahead was sugarcane and not a creeper, and telling itself not to waste another night chasing dark pink pixels, its private name for pigs. GIGAZINE covered the run, and Tom’s Hardware covered the potato phase. The lesson is not that Astra got sad. The lesson is that one agent, driving a normal computer, sustained goal-directed behavior for nearly six days. There was no codebase anywhere in that story. There was just an agent.

The Paper That Put It In Writing

The academic version of this argument actually arrived before Astra did. On June 4, 2026, a paper by Zhenfeng Cao appeared on arXiv under the blunt title “The End of Software Engineering: How AI Agents Are Fundamentally Restructuring the Software Paradigm” (arXiv 2606.05608). Six days later the author reissued it as “Agentic Software”, dropping the word End, apparently conceding that the original title was a verdict stronger than the evidence. The retreat makes the content more interesting, not less, because the machinery underneath survives the rename intact.

The paper’s core claim is simple enough to sketch. Traditional software is a bundle of computational resources, an execution environment, and, crucially, a set of decision rules written by humans and frozen into source code. That frozen logic is why software engineering exists as a discipline: the essential complexity of a system with n components grows roughly like 2^n while human cognitive capacity stays fixed, so the field invented modularity, code review, frameworks, and process to keep pushing the wall back. An AI agent system removes the frozen part. Decision logic is generated at runtime by a model, executed through tools, checked against results, adjusted, and discarded. Code stops being the product and becomes a byproduct, the way heat is a byproduct of an engine.

From there the paper divides software delivery into three eras. Software 1.0 sold licenses: you installed the artifact and owned its complexity. Software 2.0 is SaaS: the vendor owns the complexity and you rent access by the seat. Software 3.0, which the paper calls Agent-as-a-Service, bills outcomes: an agent owns understanding, building, and running the solution, and you pay for the result. The pipeline where AI assists a human who writes software that produces a result collapses into a shorter one where the agent produces the result. The artifact in the middle, the thing that defined the industry for seventy years, becomes optional.

To be fair to the skeptics: the same paper cites evidence that agent performance collapses from over 80 percent on isolated tasks to at most about 38 percent on continuous software evolution, a gap it blames on context drift and error propagation. Agents remain brittle. But brittle is not the same as optional, and every Astra capability listed above pushes in one direction.

The Part Where Coding Has Nothing to Do With It

Here is the confusion worth killing. Almost all discourse about AI and software is a debate about coding: can models write code, will programmers still have jobs, is studying computer science a mistake. That debate is old, repetitive, and, for the argument of this post, irrelevant.

People have predicted the death of programming with every abstraction wave since the beginning. One industry retrospective compiled the record. In 1952, Grace Hopper’s A-0 compiler was expected to end the manual entry of machine instructions, and contemporaries warned that real specialists would become as rare as dodo birds. In 1954, Fortran was supposed to let scientists work without technical intermediaries; it delivered a reported 45x productivity gain over machine code and demand for programmers exploded, the Jevons paradox of code. COBOL in 1959 was designed so business managers could read and write their own programs; it ran banks for over sixty years and employed specialists the entire time. In 1982, James Martin’s “Application Development Without Programmers” was a bestselling tech title. CASE tools, fourth-generation languages, visual builders, no-code: each wave triggered the same prophecy, and each was wrong about where the hard part actually lives. The prophecy never stopped. Elon Musk said in January 2026 that programming as a profession could vanish by the end of 2026, with AI generating optimized binary directly from intent. Dario Amodei said the same month that AI is six to twelve months away from doing everything a software engineer does end to end. Back in March 2025, Amodei predicted AI would write 90 percent of code within six months, a deadline that quietly passed, one of many doomsday predictions that never arrive.

Now the important part. Suppose the coding debate ends however it ends. Suppose models never get meaningfully better at writing code than they are today. The end of software still happens, because the end of software is not about who types the characters. It is about whether a durable artifact needs to exist at all.

Those are independent claims, and keeping them separate is the whole ballgame. A world where AI codes perfectly but you still buy and install apps is a world where software survived. A world where you describe what you want, an agent assembles the code needed to get it, runs it, verifies the result, discards the code, and bills you for the outcome, is a world where software ended, even if every line of that ephemeral code was written by a mediocre model. The artifact is what ended. Coding was only ever how artifacts got built.

The market saw this before the model launch did. Through early 2026, financial commentators argued about a so-called SaaSpocalypse: per-seat pricing assumes humans in chairs, agents compress the seats, and vendors began migrating from selling tools to billing for results, a shift described as service as software. Astra did not cause that. Astra just removed the last technical excuse to pretend it was not happening.

What Replaces Software

If the artifact dissolves, value moves to the machinery that generates behavior on demand. The paper’s names for the human roles are intent architect, agent coordinator, and outcome auditor: people who specify what should happen, orchestrate the systems that make it happen, and verify that it actually did. The stack underneath them looks nothing like a repository. It is the model, the tools it can reach, the memory it keeps, the policy that bounds it, and the evaluation harness that grades it.

You can watch the same principle operate at the interface layer. json-render, the generative UI framework from Vercel Labs, treats the interface itself as runtime output: a model emits JSON describing components, and the UI exists only as long as the request does. That is the artifact dissolving in miniature. And when the product is an agent rather than a program, the machine that hosts the agent matters again, which is why desk-side inference boxes like the ones in our Ryzen AI Halo versus DGX Spark comparison suddenly look less like hobbyist toys and more like the new server rack.

None of this says learn to stop coding. It says code is sinking, not vanishing. Models, inference kernels, safety-critical paths, and the harnesses that keep agents honest remain hard engineering problems. What disappears is the ordinary business app as a durable product with a price per seat.

What You Should Do About It

If the artifact is optional, behave like it. First, write intent like an artifact: your specifications, constraints, and acceptance criteria outlive any codebase now, so make them precise enough to execute against. Second, build evals, not features: in a world of outcome auditors, the measuring stick is the moat, because whoever can verify results can buy generation from anyone. Third, treat the harness as the product: memory, tool access, and policy are where durable value concentrates once behavior is generated on demand. Fourth, price outcomes, not seats, if you sell anything at all, because agents do not occupy chairs. Fifth, keep a machine that can run the loop locally, because the agent era still runs on compute, and the local machine war is already underway.

Conclusion

GPT-6 Astra did not end software because it is good at coding. It ended the assumption that software is a thing you ship rather than a behavior you invoke. The seventy-year debate about who writes the code, from Grace Hopper’s compilers to this year’s executive predictions, was always a debate about the means of production. The paper on arXiv and the model behind the paywall are both pointing at something the debate never touched: the product itself. Intent goes in, outcomes come out, and the code in between lives for seconds. The artifact is what ended. Coding was never the point.

Enjoyed this post? Never miss out on future posts by following us