OpenAI shipped GPT-6 Astra on Thursday. By the next day, I had it running as the model driving my Claude Code sessions: planning the work, handing it out, reading what came back. Nothing else in my setup moved. Same hooks, same skills, same plugins, same board. Only the model in the driver’s seat changed, and it’s on the ChatGPT subscription I was already paying for.
That’s the meta now, and I think it holds for a good while: OpenAI’s best model, inside Anthropic’s harness, with cheaper models doing the grunt work underneath. You don’t have to pick a camp anymore.
The plumbing is one plugin from my marketplace, the Eigenwise Toolshed, free and MIT. model-gateway is a small local proxy that Claude Code talks to instead of talking to Anthropic directly. Requests for a GPT model go to OpenAI on your ChatGPT login, everything else passes straight through to Anthropic on your normal claude.ai login. No API keys, nothing to pay for twice, and the GPT models just show up in the /model picker next to Opus.
Why Not Just Use Codex #
The obvious move is to run Astra in Codex, and Codex is really good now. I did use it for a while.
The thing is, Claude Code is the best agent harness around right now, and it’s not close. It runs hooks on roughly 32 lifecycle events where Codex has about a dozen, and the extra ones (file changed, worktree created, task completed, config changed) are exactly what serious plugins are built on. Plugins can ship subagents that run in their own git worktrees, LSP servers, background monitors, and executables that join the shell’s PATH while they’re enabled, on top of the skills and MCP servers you’d expect. Everything I’ve built over the past year lives on that surface: twenty-odd plugins, hooks that fire on every single turn, a ticket board that dispatches work to subagents, rules that re-inject themselves when they apply.
Moving to a new model takes a minute. Moving everything built around the model takes a week I’m never going to spend. So the model and the harness are two separate decisions, and this week I got to make them separately: OpenAI’s frontier model, Anthropic’s harness, and my own stuff on top, untouched.
Astra Is a Very Good Orchestrator #
The way I run Claude Code, the main session almost never writes code. It’s the orchestrator: it holds the plan, files tickets, dispatches each one to a subagent in its own worktree, reads the report that comes back, and decides whether to accept it or send it back. The main session is running the most expensive model with the scarcest resource in the whole setup, its own context window, so every file it reads “just to do this one quickly” is planning capacity it no longer has.
That job wants a specific kind of model. It has to stay on the plan for hours, take a steering message without treating it as a brand-new goal, ask a question when the answer would change the outcome and shut up when it wouldn’t, and not wander off to do the work itself. OpenAI’s own launch post leans on exactly these traits, staying oriented as a task evolves and asking focused questions only on consequential decisions, and I usually discount launch posts. On this one, they’re right. After a weekend of Astra in the orchestrator seat, running a board of tickets through cheaper executors and reviewing their reports, it’s the best I’ve had in that chair. It’s frugal with words and it doesn’t lose the thread when I redirect it. And it delegates instead of grabbing the keyboard, which is the single hardest thing to get a coding model to do.
Three days is three days. But the reason I started writing this on day one is that the difference was obvious by Friday lunch.
The Expensive Model Plans, Cheaper Models Do the Work #
This only stays affordable because Astra almost never writes code. It’s the most expensive model OpenAI sells: on the API it’s $10 per million input tokens and $50 out, two and a half times GPT-5.6 Sol. The subscription allowance is finite, and a frontier model at high effort eats through it. So you want Astra spending its tokens on judgment, and nothing else.
That’s what the board is for. Sidequest, the other core plugin in the Toolshed, classifies every ticket by what kind of work it is, and the kind of work picks the model. Reading code to answer a question goes to GPT-5.6 Luna, a standard change to Terra, debugging to Sol, and the two hardest tiers go to Astra itself, at high and at xhigh. Reviews go to Opus, because a reviewer from a different model family doesn’t share the writer’s blind spots, and that’s worth more to me than any saving. You describe your kinds of work once, and from then on you never choose a model per task again.
So on a normal day Astra plans, three or four GPT-5.6 executors build in parallel in their own worktrees, Opus reviews, and I integrate. The gateway logs every request it routes, and since Friday morning that log has 4,492 Astra requests against 16,207 on the GPT-5.6 tiers underneath (11,167 Terra, 3,434 Sol, 1,606 Luna). So the frontier model, orchestrator seat plus the hard tickets, is about one request in five, and all of the decisions. That’s the best-of-both-worlds bit: the smartest model where smart matters, cheap models everywhere else, all of it inside one client, and every model on the roster comes from a subscription I’d have anyway.
You don’t even need the Anthropic half. Claude Code takes a gateway credential in place of a claude.ai login, so a ChatGPT-only setup works: Astra plans, Luna and Terra and Sol execute, and the Opus rows in the picker just sit there unused. I keep both subscriptions because I want that cross-family review. But the reason to be in Claude Code is the harness, and the harness costs nothing.
What It Looks Like Day to Day #
It looks like nothing, which is sort of the point.
/model claude-gpt-6-astra[1m]
That’s Astra running the session. Then I talk to it like I always have: “build X”, “the checkout throws on Safari, by the way”, “review what the executor did on ticket 12.” The board files the tickets, the executors pick them up on whichever GPT-5.6 tier fits, Astra reads what comes back, and I read Astra. When I want Opus to look at something, I switch mid-conversation and switch back. Both providers live in the same session and neither one knows about the other.
The claude- prefix on the id is one of two tricks in the whole setup. Claude Code ignores any gateway model whose id doesn’t start with claude or anthropic, so the gateway adds the prefix on the way out and strips it on the way back. The [1m] suffix is the other one, and it needs its own section.
The Window Claude Code Doesn’t Know About #
Astra’s context window is 1,050,000 tokens on the API. Through the ChatGPT subscription backend it’s a bit less: the gateway probed it Friday morning and got a 200 at 920,012 input tokens and a 413 at 935,012 (“Your input exceeds the context window of this model”), so it advertises 920k and keeps its own sentry at 880k as a backstop.
Claude Code ignores all of that. Any model id it doesn’t recognise is assumed to be 200k and auto-compacted at 200k, and the window a gateway advertises is never consulted. On 2.1.261, the build I’m on, a CLAUDE_CODE_MAX_CONTEXT_TOKENS value in the settings file doesn’t reach that resolver either. The one thing it does honour on an unknown id is the [1m] suffix, which it reads as a 1M-context alias. So the picker row is claude-gpt-6-astra[1m], the gateway strips the suffix before forwarding, and the session gets a window that’s actually close to the real one instead of compacting at a fifth of it. Type the bare id without the suffix and everything still routes, you just compact four times as often as you need to.
In practice the orchestrator rarely gets near either limit. The executors carry the long tool loops in their own windows, and I cap auto-compaction at 325k on my own machine anyway. The number that matters for the orchestrator is how far it gets before it forgets the plan, and Astra gets a lot further than 200k would let it.
A Few Gotchas #
None of these have made me switch back, but you’ll run into them:
- You don’t get a reasoning stream. The Codex backend doesn’t return thinking blocks into Claude Code ’s UI, soyou see Astra’s answers and actions, not its thinking. Part of that is the model rather than the pipe: Astra’srecurrent-depth reasoning “obscures some or all of the AI’s reasoning” by design, so evenCodex shows you less of it than you’re used to.
- Codex ’s trick of keeping notes across context windows stays inCodex . Through the gateway you getClaude Code ’s normal compaction, and with the executors doing the actual workthe orchestrator’s window rarely fills up anyway , so I haven’t missed it.
- The allowance is finite. Astra counts against the same subscription budget as everything else. Keep it in the orchestrator seat and it lasts. Let it write code all day and it won’t.
- It sits downstream of OpenAI’s client fingerprinting, which they’ve tightened before. When that happens GPT requests fail until the proxy underneath ships a fix , and Claude models keep working the whole time.
Where to Get It #
Three commands inside Claude Code, in this order:
/plugin marketplace add Eigenwise/eigenwise-toolshed
/plugin install quartermaster@eigenwise-toolshed --scope project
/quartermaster:setup
The third one is where the gateway happens. Quartermaster notices it isn’t configured and offers to set it up, so say yes, sign in to ChatGPT when the browser opens, and restart the session. If you only want the GPT rows in your picker and none of the board stuff, skip Quartermaster and install model-gateway@eigenwise-toolshed on its own; the setup guide has the raw commands. I keep everything at project or local scope, never user.
Then:
/model claude-gpt-6-astra[1m]
If the row isn’t in the picker yet, type it anyway, it routes fine. The reason it can be missing: Claude Code only re-fetches a gateway’s model list when it’s holding an API-key credential. On a claude.ai login it reads ~/.claude/cache/gateway-models.json and never refreshes it, which is how mine sat on a month-old list of 19 models for a day while the gateway underneath already had Astra. The gateway writes that cache itself now whenever its list changes, but Claude Code reads it once at startup, so new rows need a restart, and /reload-plugins doesn’t count.
The best model changed hands on a Thursday. My tooling didn’t notice, and neither did my invoice.
And if you’re at a company trying to get real value out of your AI stack, this is a big part of what I do: the plugins, routing, and review loops that make Claude Code productive on your own codebase and your own model budget. If you’d want a hand getting it working, feel free to reach out.