Astra-Ares shows how lease-based effort routing could cut agent inference costs

The core idea here is economical: not every step in a long coding task needs the same depth of reasoning, so why pay for it? Astra-Ares puts a small routing model — called Jev — between your Codex session and GPT-6, letting it choose the reasoning effort level before each model generation and decide how many subsequent steps that choice should hold. If Jev picks ten steps, it only makes one routing request for that entire stretch. Steps two through ten run on the accepted setting with no additional round trips.

What makes this technically interesting rather than just a wrapper trick is the underlying mechanism. GPT-6 models support a configuration_update between generations that changes reasoning effort without invalidating the prompt prefix used for caching. Astra-Ares exploits that directly: the selected model still talks straight to OpenAI, the original prefix stays intact for cache reuse, and Jev's routing sits entirely outside that network path. The README is careful to note that actual cache hit rates and savings against fixed-effort baselines have not yet been measured — a candid admission that the efficiency argument is theoretical until someone runs the numbers.

Jev's view of the task is deliberately bounded. It sees the original task description, public progress and reasoning summaries, and the last six tool calls with their results trimmed to a thousand local tokens each. The full evaluator request is capped at a 28,000 local-token guard. Private or encrypted reasoning is explicitly excluded. These aren't arbitrary limits — they're the mechanism that keeps Jev's routing calls cheap enough to justify.

The lease system handles failure sensibly. A tool failure or new user input ends the current lease and triggers a fresh decision; there's no hardcoded escalation to high effort on error. Ares reassesses rather than assumes. Transient HTTP errors get at most three retries within a 30-second window, and the system never silently substitutes a model or invents an effort value — a design choice that matters when you're trying to understand what actually ran.

The setup cost is real. You need Node.js 22 or later, Rust via rustup, a C/C++ build toolchain, roughly 10 GB of free disk space, and several minutes to compile a patched Codex CLI that lives separately from your existing installation. Windows is unsupported. macOS on Apple Silicon is the only platform that's been acceptance-tested. The README frames this honestly as an experimental reference implementation, not a polished tool — the author's other projects are described as the ready-to-use ones.

For anyone building agent systems where inference cost scales with task length, the lease-based effort routing pattern is worth understanding even if you never run this specific code. The bounded context design for the routing model is particularly clean: Jev knows enough to make a useful call without needing the full conversation, which is exactly the kind of architectural constraint that keeps a meta-reasoning layer from becoming its own cost problem.