Why Using Astra Inside Claude Code Is the New Meta (& How To Do It)

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, all my hooks and plugins and skills and the board just kept working like before. 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 Sonnet, Opus, and Fable.

It mixes however you want. With the gateway alone, every row is just a model in the picker, so Astra can orchestrate Opus and Sonnet subagents (or Fable, why not), Opus can orchestrate GPT-5.6 executors, or the whole thing runs on GPT end to end: Astra in the main session, every subagent a GPT model too, all on the one ChatGPT login. Add Sidequest on top and the picking stops being manual: each ticket gets routed to a model by the kind of work it is. The board is how I run it, but a plain single session with Astra in it and no subagents at all works exactly the same way.

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 keeps delegating instead of taking over or forgetting the subagents exist halfway through, 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, or most of it. Claude Code takes a gateway credential in place of a claude.ai login, so a ChatGPT-only setup works, with or without the board: Astra alone in one session doing everything, or Astra planning with Luna, Terra and Sol as the executors, every one of them a GPT model on the same login, and the Opus rows in the picker just sit there unused. Claude Code does still make a few small Claude calls of its own (quick summaries, web search, that kind of thing), and on my log that traffic is a rounding error next to the GPT side. I haven’t run it that way myself, but the leftover should fit on a Console account with a few dollars of prepaid credit, no Claude subscription needed. 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, so you see Astra’s answers and actions, not its thinking. Part of that is the model rather than the pipe: Astra’s recurrent-depth reasoning “obscures some or all of the AI’s reasoning” by design, so even Codex shows you less of it than you’re used to.
• Codex’s trick of keeping notes across context windows stays in Codex. Through the gateway you get Claude Code’s normal compaction, and with the executors doing the actual work the 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

For Astra on its own, run these inside Claude Code, in the project where you want to use it:

/plugin marketplace add Eigenwise/eigenwise-toolshed
/plugin install model-gateway@eigenwise-toolshed --scope project
/reload-plugins
/model-gateway:model-gateway

Then ask Claude: “Set up the model gateway for this project. After I finish the ChatGPT login, run setup again to finish configuring it.” Fully restart Claude Code in that project once setup completes, then select:

/model claude-gpt-6-astra[1m]

Installing the plugin is only the first step. Setup connects your account and configures the project; the restart applies that configuration. Keep the [1m] suffix so Claude Code doesn’t assume a 200k window. If the picker row is still missing after setup and the restart, type the command above.

If you want the rest of my setup too, Quartermaster can walk you through it:

/plugin marketplace add Eigenwise/eigenwise-toolshed
/plugin install quartermaster@eigenwise-toolshed --scope project
/reload-plugins
/quartermaster:setup

Accept the Model Gateway setup when offered, finish the ChatGPT login, and let Claude run setup again before you fully restart Claude Code and select Astra. If you tried this earlier and Astra was unavailable, rerun gateway setup to pull the latest proxy, then restart. I keep everything at project or local scope. The setup guide has the manual commands if you need them.

The best model changed hands on a Thursday, but my tooling didn’t have to suffer!

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.