{"slug": "using-gpt-6-astra-inside-claude-code-is-the-new-meta", "title": "Using GPT-6 Astra Inside Claude Code Is the New Meta", "summary": "OpenAI's GPT-6 Astra, released Thursday, is now being used by developers as the orchestrator model inside Anthropic's Claude Code harness, a setup that combines OpenAI's frontier model with Anthropic's agent framework. The integration, enabled by a free MIT-licensed plugin called Eigenwise Toolshed's model-gateway, routes GPT requests to OpenAI on a ChatGPT subscription while other requests pass through to Anthropic, allowing users to avoid paying for separate API keys. Early users report Astra excels at planning and delegating tasks to cheaper subagents, making it the best orchestrator model they've used, though the long-term viability remains to be seen.", "body_md": "# Using GPT-6 Astra Inside Claude Code Is the New Meta\n\nOpenAI 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.\n\nThat’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.\n\nThe plumbing is one plugin from my marketplace, the [Eigenwise Toolshed](https://github.com/Eigenwise/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*.\n\n## Why Not Just Use Codex\n\nThe obvious move is to run Astra in *Codex*, and *Codex* is really good now. I did use it for a while.\n\nThe 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.\n\nMoving 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.\n\n## Astra Is a Very Good Orchestrator\n\nThe 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.**\n\nThat 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](https://openai.com/index/gpt-6-astra/) 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.\n\nThree days is three days. But the reason I started writing this on day one is that the difference was obvious by Friday lunch.\n\n## The Expensive Model Plans, Cheaper Models Do the Work\n\nThis 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.**\n\nThat’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.**\n\nSo 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.**\n\nYou don’t even need the Anthropic half. *Claude Code* [takes a gateway credential](https://code.claude.com/docs/en/llm-gateway-connect) 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.**\n\n## What It Looks Like Day to Day\n\nIt looks like nothing, which is sort of the point.\n\n```\n/model claude-gpt-6-astra[1m]\n```\n\nThat’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.**\n\nThe `claude-` prefix on the id is one of two tricks in the whole setup. *Claude Code* [ignores](https://code.claude.com/docs/en/llm-gateway-protocol) 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.\n\n## The Window Claude Code Doesn’t Know About\n\nAstra’s context window is [1,050,000 tokens](https://developers.openai.com/api/docs/models/gpt-6-astra) 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.\n\n*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.\n\nIn 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.\n\n## A Few Gotchas\n\nNone of these have made me switch back, but you’ll run into them:\n\n- 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](https://en.wikipedia.org/wiki/GPT-6_Astra) “obscures some or all of the AI’s reasoning” by design, so even*Codex* shows you less of it than you’re used to.\n- *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.\n- 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.\n- 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.\n\n## Where to Get It\n\nThree commands inside *Claude Code*, in this order:\n\n```\n/plugin marketplace add Eigenwise/eigenwise-toolshed\n/plugin install quartermaster@eigenwise-toolshed --scope project\n/quartermaster:setup\n```\n\nThe 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](https://eigenwise.github.io/eigenwise-toolshed/getting-started/model-gateway/) has the raw commands. **I keep everything at `project` or `local` scope**, never `user`.\n\nThen:\n\n```\n/model claude-gpt-6-astra[1m]\n```\n\nIf 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.\n\nThe best model changed hands on a Thursday. **My tooling didn’t notice, and neither did my invoice.**\n\nAnd 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](https://eigenwise.io/contact).", "url": "https://wpnews.pro/news/using-gpt-6-astra-inside-claude-code-is-the-new-meta", "canonical_source": "https://eigenwise.io/writing/using-gpt-6-astra-inside-claude-code-is-the-new-meta", "published_at": "2026-09-07 00:00:00+00:00", "updated_at": "2026-09-07 18:32:06.306825+00:00", "lang": "en", "topics": ["artificial-intelligence", "large-language-models", "ai-tools", "ai-agents"], "entities": ["OpenAI", "GPT-6 Astra", "Anthropic", "Claude Code", "Eigenwise Toolshed", "ChatGPT"], "alternates": {"html": "https://wpnews.pro/news/using-gpt-6-astra-inside-claude-code-is-the-new-meta", "markdown": "https://wpnews.pro/news/using-gpt-6-astra-inside-claude-code-is-the-new-meta.md", "text": "https://wpnews.pro/news/using-gpt-6-astra-inside-claude-code-is-the-new-meta.txt", "jsonld": "https://wpnews.pro/news/using-gpt-6-astra-inside-claude-code-is-the-new-meta.jsonld"}}