AI release analysis
GPT-6 Astra and Claude 5.5: pick a model per job
For a long, tool-heavy agentic job, Rubix currently starts with GPT-6 Astra. For a small job you can check, such as choosing a queue label, a smaller model like Claude Haiku 5.5 may do it for less. Make that choice per job, not per product: define each job, test candidate models on it, and count the cost of the finished job, including the router you have to maintain and the review someone still does.

What changed with GPT-6 Astra
OpenAI introduced Astra in September 2026, highlighting its work with computers, code, documents, spreadsheets and presentations. We'd assess that claim over a whole assignment. The model might need to move between several of those tools and still keep track of what you asked it to deliver; a good answer in one chat message doesn't show how well it does that.
A quick date note: the announcement page now also mentions other GPT-6 releases, including GPT-6.1 Sol. This is our view on Astra for this kind of work as of 17 October 2026. We're not using 'Astra' as shorthand for whichever model happens to be newest.
Where the Claude 5.5 releases stand
Here's where the releases stand as of 17 October 2026. Anthropic announced Opus 5.5 on 22 September, pointing to improvements in performance, communication and efficiency on complex work. Sonnet 5.5 followed on 28 September, aimed at faster, well-scoped everyday jobs. Those are Anthropic's launch claims. We haven't published a Rubix test comparing the two.
The kind of work we'd give it
Say the job is to understand a codebase, make an agreed change and check that it works. Halfway through, the agent finds something that changes its plan. We'd want it to handle that, keep the original goal in mind and explain anything it couldn't verify. Research and document work can get messy in much the same way. That's the sort of assignment we have in mind when we recommend Astra.
That's our team's preference. We haven't published a controlled comparison of competing models on client work or established that Astra wins every one of those jobs. We'd still test it on your workload before committing to it.
A tiny classification call is a different buying decision. If a smaller model reliably sorts a message into an approved category or completes a simple data transformation, use the checks for that task to judge it. We'd be perfectly happy with that choice. Our preference for Astra doesn't mean every step in a product needs a large model.
The small jobs are worth a look
Haiku 5.5 followed on 7 October. Anthropic pitches it for smaller jobs at high volume, including classification, summaries and compaction, and added an adjustable effort setting for this generation. The launch material also points to larger models for more complex agentic coding.
Choosing one of five approved queue labels would be a reasonable place to try it. The input is small, and you can check whether the answer is right. Swapping the model across the whole support workflow in one go makes the comparison much harder. If something gets worse, which part of the job caused it?
Pick the job before you pick the model
In a made-up support request, a customer asks for an invoice copy. Sending it to billing is a fairly small job. Working out why the customer's account records disagree could involve a much longer investigation. We'd define those jobs separately, then choose what runs each one. There also needs to be somewhere for a request that doesn't fit: another model or a person, depending on what needs doing.
A model saying 'I'm confident' gives the application very little to check. We'd validate the category against the allowed set, check the required fields and verify that the cited source supports the answer. If the evidence doesn't settle it, leave the result unresolved so another model or a person can review it.
| Example job | Candidate evaluation | What stays outside the model's authority |
|---|---|---|
| Tag an incoming request | Small model against an approved category set | Access to records beyond the authenticated account |
| Summarize supplied documents | Small or mid-size model with source checks | Deciding that an absent fact must be true |
| Investigate conflicting records | Stronger model with a reviewable evidence trail | Resolving a consequential business decision alone |
| Change a live customer record | Application validation and authorized approval | Granting its own permission to write |

Someone has to look after the router
The split can create its own problems. Suppose the first model summarises the message and drops a detail the next model needs. Or a retry picks a different route and now the request is in two queues. Keep the original input available to the next step, with the right permissions, and save the route history. Otherwise, finding out where things went wrong becomes its own little investigation.
You also have to maintain the combinations. Update a model and the routes using it need testing again. Add a fallback and you've added another path that can fail. For a product with low volume and a job that keeps changing, we might start with one model. The extra engineering time could cost more than the calls you're trying to save.
At Rubix Labs, we'd add routing when we can name the job moving to it and show that the change helps. Our current preference for Astra on complex agentic work still leaves room to try Claude's smaller models on a bounded task. We haven't published a comparison proving the best mix across vendors, so we'd test that mix on the work in front of us.
Yes, we like the resets
Getting more allowance can let you carry on with the job you've already started. That's part of why we like working with OpenAI's tools, alongside what the model can do.
Just don't put 'OpenAI will probably reset us again' in the delivery plan. Its current guidance ties promotional resets to eligibility and timing, and doesn't promise future offers. Automatic and banked resets work differently as well. Check the allowance on the account and the terms of the actual offer before counting on it.
Also, the allowance you use to build an app and the capacity that runs the app are separate things. A Work or Codex reset can help you finish development. It doesn't pay the product's API bill or increase its API limits. That side still needs its own budget and capacity plan.
Give it context, and control its access
Give the agent enough detail to take the job seriously. For a code change, we'd include the branch, expected behavior, checks to run, tools it can use and whether it can publish. 'Improve the app' leaves a lot for it to guess. For a report, explain who will read it, which sources it may use and what decision the evidence should help them make.
Then consider a less friendly source. A page the agent opens could contain instructions telling it to do something else. The author of that page hasn't earned permission to run your workflow. Access limits need to live in the application around the model, with a way to review proposed changes and recover from the recorded work. Asking nicely in the prompt isn't enough to enforce that.
This is part of the work Rubix covers in agentic systems: connecting the data and tools, deciding the business rules and putting approvals in the right places. A more capable model is welcome, but somebody still has to decide what it can reach and what it can change.
What did the finished job cost?
When you price the experiment, follow a job to the end. Include retries, fallbacks, retrieval and verification, plus the time someone spends fixing the answer. How long did the customer wait? A cheaper first call is nice, but it doesn't tell you what the finished job cost.
Use examples that fit the actual jobs you're routing. Include ambiguous requests, malformed outputs and legitimate requests the model refuses. Save the chosen route and why it was chosen with each run. If an update changes the answers, that record gives you a way to see which path changed.
We'd keep the split if the quality holds up and the saving survives review and maintenance. If somebody has to repair the answer every other time, there's more work to do before calling this a cheaper setup.
Try it on a real assignment
Try Astra on a complete job your team actually needs done. Keep the starting input and acceptance conditions fixed so the comparison means something. Count the actions, corrections and human review behind the result. Then try a changed requirement or an unavailable dependency. Those interruptions tell you a lot about how the agent handles a job that stops going to plan.
Keep the examples it got wrong, with a note of what someone had to fix. Next time you're deciding between Astra and another setup, you'll have actual work to compare. If a different model does your jobs better, that's a good reason to choose it. Our recommendation is a place to begin the evaluation.