Magic Cloud Now Supports GPT-6 Astra

Part of our AI agent builders series — the overview lives at AI Agent Builders.

Magic Cloud now supports GPT-6 Astra.

OpenAI opened the model to the public this morning. The commit that added it to Magic landed at 09:54 the same morning, and it is two lines long. If you run a managed cloudlet, gpt-6-astra is already in the model dropdown under Machine Learning. If you self-host, pull and restart.

That the commit is two lines is the actual story, and I will get to it. First the model.

What GPT-6 Astra is

OpenAI's own line is "Anything you can do on a computer, Astra can do for you. Fast."

It is the successor to the GPT-5.6 family, the Sol, Terra and Luna models Magic has supported since they shipped. OpenAI is calling it the most intelligent and aligned model in the world, and for once the benchmark table backs the marketing. It saturates ARC-AGI-3 at 99.9 percent, scores 98 percent on FrontierMath Tier 4, and is state of the art on computer use, browsing, software engineering and science. Greg Brockman said it is "not unreasonable to feel that we are now in the AGI era". I will leave that judgement to you.

The developer facts, which are what matters for Magic:

	GPT-6 Astra	GPT-5.6 Sol
Model id	`gpt-6-astra`	`gpt-5.6-sol`
Context window	1,050,000 tokens	1,050,000 tokens
Max output	128,000 tokens	128,000 tokens
Input price	$10 per million	$5 per million
Output price	$50 per million	$30 per million
Cached input	$1 per million	$0.50 per million
Knowledge cutoff	April 30, 2026	December 2025
Tool calling	Native, Responses API	Native, Responses API

So it is twice the price of Sol, with the same context window and the same native tool protocol. It is not a cheap model. It is the model you reach for when the task is hard enough that a smarter brain saves more than it costs, and for the kind of work people do in Magic that happens more often than you would think.

There is one more thing worth knowing. Astra is the first model to reach the Critical tier for cybersecurity capability under OpenAI's Preparedness Framework. In plain words, it can find and exploit vulnerabilities nobody has published. The public model has those capabilities gated, and it went through a voluntary US government review before release. Keep that in mind for the second half of this article.

Why the commit is two lines

In April, when GPT-5.5 arrived, adding a model was also small, but the chat engine underneath was still the old text protocol. The model was asked to type a FUNCTION_INVOCATION block, Magic parsed it, ran the file, and fed the result back. That protocol worked on every model OpenAI ever shipped, right up until reasoning models started ending their turn instead of typing the block.

Yesterday I published the rewrite. Every AI function in Magic is now a native OpenAI tool, described from the Hyperlambda file itself, and the whole chat slot speaks the Responses API and nothing else. The consequence I did not plan for is that a new model is now a configuration entry, not an integration. Astra speaks the same tool protocol as Sol, Terra and Luna, so supporting it means telling Magic its context size and its price. That is the two lines.

case:gpt-6-astra
   add:x:@.dp/#
      .
         tokens:int:1050000
         chat:bool:true
         input_price:decimal:10
         output_price:decimal:50

Everything else, function calling, widgets, chained tool calls inside one turn, the History tab showing you every call and every result, reasoning effort triggered by "think hard", works on Astra exactly as it works on the 5.6 models, because none of it was ever model-specific.

What it changes for agents on Magic

Magic is a platform where the model does real work. It creates files, generates Hyperlambda, inspects databases, runs SQL, builds APIs, creates widgets, scrapes websites, drives a browser, and wires the pieces together. Every one of those is a tool call, and every step in a long task is a place where a weaker model loses the thread.

Astra's headline gains are exactly in that territory. Multi-step workflow completion, task adherence, and understanding what you actually meant rather than what you literally typed. In Chat Ops on the dashboard, where a root user's tools are the entire workflow catalogue, that translates into asking for outcomes rather than steps.

Create a CRUD API for this database, secure it by role, and give me the OpenAPI spec
Build an AI agent around these endpoints and add a widget for the pipeline view
Scrape these three pages, turn the result into training snippets, and vectorise the type
Read this module, tell me what it does, and write the documentation
This endpoint returns 500 on empty input. Find it and fix it

On the 5.6 models these run well. On Astra they should run with fewer corrections from you, which is the whole cost argument at $50 per million output tokens. The model that gets it right in one pass is cheaper than the model that gets it right in three.

For the Hyperlambda Generator the picture is different, and I want to be honest about it. The generator is a fine-tuned model of its own, and it is not Astra. What Astra improves is the prompting side, the part where an agent works out what to ask for. The verifier that checks every generated slot against the live function registry does not care which model wrote the prompt.

What it does not change

This is the part I care about most, and it is why I keep writing the same section in every model announcement.

A model that can find unknown vulnerabilities is now on general release. It is gated, and OpenAI is careful, but "gated" is a promise made by the model vendor about the model. It is not a property of your system. Sooner or later a model with those capabilities, from OpenAI or from someone else, will be talking to your backend, and on that day the question is not how well aligned the model is. The question is what your runtime lets it do.

On Magic the answer has not moved. The model proposes, the runtime decides.

Generated Hyperlambda compiles to a tree whose nodes bind only to explicitly whitelisted capabilities. A slot that is not in the registry cannot be expressed, let alone executed. Every endpoint is gated by role-based access control that runs at execution time, not at prompt time. The tool catalogue the model sees is built per type and per user before the request goes out, so a function that is not in the catalogue does not exist as far as the model is concerned, and it cannot be reached by guessing a filename. Root capabilities stay root. The AI does not get authority because it asked well.

I wrote up the sandbox in August, and there is a standing $100 bounty for anyone who breaks out of it. Nobody has. If Astra is as good at exploitation as its ExploitBench score says, it is welcome to try, inside the same boundaries as everyone else.

More capable models make this architecture more important, not less. The whole point of putting the boundary in the runtime rather than in the prompt is that it does not degrade when the model gets smarter.

How to switch

Open the dashboard, go to Machine Learning, open the type, and pick gpt-6-astra from the model dropdown. That is it. The type's system message, functions, training snippets and widgets carry over unchanged, because the model list in Magic is a list of prices and context sizes, and nothing about your type was ever tied to a model.

If you want to check it is working, send the type a prompt that should trigger a function and watch the History tab. You should see the tool call, its arguments, and its result, in one turn.

If you have not yet ported your system messages from the old FUNCTION_INVOCATION blocks, yesterday's article has the checklist. Astra will work without it, but the instructions you wrote next to the old blocks are stripped until you move them.

Conclusion

Magic Cloud now supports GPT-6 Astra.

It is the most capable model OpenAI has shipped, it costs twice what Sol does, and it is a two-line change to Magic because the engine underneath stopped caring which model it talks to.

Astra brings the intelligence. Magic brings the runtime that decides what the intelligence is allowed to touch.

That is still the combination.

Magic is MIT-licensed and open source. The commit is in github.com/polterguy/magic. If you would rather not run the upgrade yourself, a managed cloudlet already has it.