Astra Flash Orchestrator cuts GPT-6 Astra input 98.9%, its maker says

Why it matters

The package turns a common agent-cost tactic into an installable Codex workflow: reserve the frontier model for judgment and send repetitive implementation to a cheaper worker. Its headline result still rests on one uneven field comparison.

Ethan+ (@ethanplusai) released an open-source Codex orchestration package that delegates implementation work to DeepSeek V4.1 Flash while reserving GPT-6 Astra for planning, architecture and final review.

The developer, who is based in St. Petersburg, Florida, described the package on September 21st after experimenting with ways to stretch Astra's usage allowance. Ethan+ says the resulting workflow reduced Astra input by 98.9% per 1,000 implementation and test lines during one local build.

That figure comes from a single field comparison, rather than a controlled benchmark. It still puts numbers around a strategy that coding-agent users increasingly face: an expensive frontier model can supervise the work without spending its context window discovering files, editing routine code and rerunning tests.

Ethan+ has built several agent tools before this release. His GitHub projects include Jarvis, a voice assistant for Claude Code, and Harvey, an autonomous sales agent. Astra Flash Orchestrator applies the same workflow-first approach to OpenAI's coding environment.

Astra plans, DeepSeek builds

The package divides a coding job into three stages. Astra defines the scope, produces the design and writes task briefs. DeepSeek V4.1 Flash explores the repository, implements each task, runs tests and reports the evidence. Astra then reviews the patch and either accepts it or requests corrections.

The workflow runs through a custom astra_flash_builder role and Codex Router. Its installer adds a skill under ~/.agents/skills/, places the worker role under the user's Codex agents directory and adds a scoped policy block to AGENTS.md. The installation can be previewed before files are changed, creates backups and produces an undo receipt.

The package requires Python 3.11 or newer, a Codex client with native subagent support and an existing Codex Router configuration for DeepSeek V4.1 Flash. It does not configure provider credentials, rewrite Codex's main configuration or run paid inference during installation.

That distinction matters because the workflow sends repository context and tool output to the selected DeepSeek provider once an authorized task begins. The repository advises users to keep API keys out of assistant chats and notes that agent instructions and Git worktrees do not create an operating-system security boundary.

OpenAI's own GPT-6 Astra guidance says the model may delegate less often than a developer wants and recommends explicitly specifying when subagents should be used. Ethan+'s package turns that prompting advice into a fixed operating policy, with Astra expected to dispatch substantial implementation while retaining control of sensitive architecture, security, payment and production decisions.

The 98.9% claim has limits

The project's benchmark notes compare three phases of a local build captured on September 19th. An all-Astra phase produced 34,425 implementation and test lines while consuming about 294.5 million Astra input tokens. A later "thin orchestration" phase produced at least 47,949 lines using 4.6 million Astra input tokens and about 1 billion Flash input tokens.

Normalized by measured implementation lines, Ethan+ calculated a 98.9% reduction in Astra input and a 97% to 97.7% reduction in API-equivalent compute cost. His September 21st post separately says a seven-hour build consumed 2% of his weekly Astra allowance, compared with a five-hour build that used more than 28%.

The comparison does not establish that the package will cut another developer's usage by the same amount. The phases covered different work. The all-Astra run included research, browser, deployment and account tasks that generated little source code, while some work from the thin-orchestration phase had been submitted without final acceptance when measurement stopped. The benchmark also uses lines of implementation and test code as its denominator, which does not measure correctness or task difficulty.

The price gap behind the result is independently verifiable. OpenAI lists GPT-6 Astra at $10 per million uncached input tokens, $1 per million cached input tokens and $50 per million output tokens. DeepSeek's current pricing places V4.1 Flash at $0.15 to $0.30 per million uncached input tokens, $0.003 to $0.006 for cached input and $0.60 to $1.20 for output, depending on the time of day.

Those are API rates, while Ethan+'s weekly-allowance comparison came from subscription usage. The package's cost table therefore estimates what the recorded tokens would cost through the APIs; it does not represent his actual Codex bill.

Astra Flash Orchestrator remains an early release, and the repository explicitly says its measured savings are not guaranteed. The useful contribution is the routing policy itself: expensive model judgment is concentrated at the beginning and end of each task, while a worker priced at a small fraction of Astra handles the long implementation loop.