AI Dev Weekly is a Thursday series where I cover the week's most important AI developer news, with my take as someone who actually uses these tools daily.
Four different layers of the agent stack changed this week. OpenAI introduced GPT-6 Astra for the hardest tool-rich work. Google made its Kotlin agent framework production-ready. GitHub gave enterprise administrators permissions that local settings cannot weaken. And NVIDIA released a local inference router that spreads independent agent calls across computers you already own.
1. GPT-6 Astra raises the ceiling and the bill
OpenAI introduced GPT-6 Astra as its highest-capability model for complex reasoning, coding, computer use, research, and document creation. The API model ID is gpt-6-astra, with a 1,050,000-token context window, 128,000 maximum output tokens, and low through max reasoning levels.
The official model guide adds three API capabilities that matter more than another benchmark table:
- asynchronous tool calls, so the model can continue independent work while your application runs a slow tool;
- mid-turn steering over a WebSocket connection, preserving completed work when requirements change;
-
reasoning updates without breaking the prompt cache, using a
configuration_updateitem to change effort during a conversation.
These features are aimed at long-running systems, not one-shot chat. Async tools require the application to track pending calls and return results with the original call ID. Mid-turn steering needs event handling that distinguishes new instructions from tool results. Neither feature makes concurrency safe automatically.
Standard pricing is $10 per million input tokens, $1 per million cached input tokens, and $50 per million output tokens. Cache writes cost $12.50 per million. Batch and Flex are half the standard rates, while Fast mode is twice the standard price.
There is also a long-context cliff. Requests above 272,000 input tokens charge the full request at 2x input and cache rates and 1.5x output rates. A 300K-token prompt is not billed at the standard rate for the first 272K.
OpenAI's launch announcement describes a staged rollout across the direct API, ChatGPT, Azure, and AWS Bedrock. GitHub separately made Astra generally available in Copilot on September 4 for eligible plans. Those are different availability surfaces, so check the exact account and endpoint before migrating.
My take: Astra is an escalation model, not a cost-blind default. The new coordination features can reduce idle time and preserve work during long tasks, but they also create more application state to test. Compare cost per accepted result against Sol or Terra, including tool retries and reviewer time. Our GPT-6 Astra guide covers pricing, rollout, and tool support, while Astra vs GPT-5.6 Sol handles the model-routing decision.
2. Google's Agent Development Kit for Kotlin reaches 1.0
Google released ADK for Kotlin 1.0 on September 9. The core is generally available and reaches feature parity with the Python and Java ADK cores. It supports hierarchical multi-agent systems, context compaction, resumable sessions, long-running tools, human confirmation flows, and Java interoperability.
The framework is built around Kotlin Multiplatform and is not limited to Android. Server-side JVM teams can use it without adopting a Python agent service. Kotlin Symbol Processing generates tool schemas from @Tool and @Param annotations at compile time, avoiding runtime reflection and making schema mismatches easier to catch during builds.
The official announcement is especially interesting on Android:
- LiteRT-LM can run local models;
- Firebase AI Logic provides cloud reasoning;
- Room can persist sessions across process restarts;
- AppSearch can hold semantic memory;
- confirmation flows can pause sensitive tools and resume after user approval.
Release labels still matter. The Kotlin core and LiteRT-LM integration are listed at 1.0.0, while the ML Kit Android extension in Google's example is 1.0.0-beta. A framework reaching GA does not promote every optional backend to the same status.
My take: This is the most practical mobile-agent release in months. Android developers can keep orchestration, persistence, and approval flows in the language and architecture they already use. Start with one resumable agent and explicit tool confirmation before reaching for a hierarchy of agents. Production readiness depends more on lifecycle recovery and deterministic tool boundaries than on agent count.
3. Copilot permissions can now override local auto-approval
GitHub made enterprise-managed permissions for Copilot agent operations generally available on September 9. Administrators can centrally mark operations as blocked, approval-required, or allowed without a prompt.
The controls cover:
- shell commands;
- file reads and edits;
- network domains.
The crucial property is precedence. According to the GitHub changelog, managed restrictions cannot be weakened by user settings, workspace settings, auto-approval, or a previously saved approval. Enterprises can also define different policies for different teams.
The controls are GA in the Copilot app, Copilot CLI, and VS Code sessions using Agent Host. GitHub also added enterprise-managed sandbox policies to Copilot for JetBrains on September 8, but that sandbox feature remains in public preview. It can govern filesystem and network access, proxy behavior, developer tools, and macOS Keychain access.
Permissions and sandboxing solve related but distinct problems. A permission policy decides which requested actions may proceed. A sandbox limits what the process can reach even if an action is attempted. Mature deployments need both, plus repository protections and secret controls.
My take: This is the follow-through last week's content exclusions needed. Context exclusions decide what the agent may read as input; managed permissions decide what it may do; a sandbox limits the operating environment. Test all three with deliberate canaries because a settings page is not proof that enforcement works on every client.
4. NVIDIA PAIR turns spare PCs into a local inference queue
NVIDIA released the open-source Personal AI Router, or PAIR, in beta. It presents familiar Ollama and LM Studio endpoints while routing independent inference requests across compatible machines on a trusted local network.
PAIR discovers paired nodes, tracks engine readiness and installed models, chooses an eligible machine, and streams the response back to the application. Existing agents can keep using an Ollama-compatible or OpenAI-compatible endpoint without integrating a new cluster API.
The NVIDIA technical overview documents support for Windows, macOS, and Linux systems with GeForce RTX 20 Series or newer GPUs, RTX PRO workstations, DGX Spark, and Apple M4 or newer silicon.
The boundary is important: PAIR does not pool VRAM or split one model across machines. Each request runs from start to finish on one node, and that node must already have the requested model. It improves throughput when multiple agents or users create independent calls. It does not make a single oversized model fit or make one generation inherently faster.
NVIDIA reports that a five-subagent demonstration finished in 8 minutes 48 seconds across three devices versus 18 minutes on one RTX Spark laptop. That is a vendor demonstration of concurrent scheduling, not an independent inference benchmark.
My take: PAIR is useful when your local bottleneck is a queue, not model size. It is a poor reason to buy more hardware, but a good way to use compatible machines you already own. The full NVIDIA PAIR guide covers routing and security boundaries, and PAIR vs plain Ollama networking helps decide whether you need it.
Quick hits
- K2 Horizon: IFM released six Apache-2.0 models from 0.9B to 375B-A23B, with a broader transparency package spanning training data or recipes, code, and intermediate artifacts. Some promised artifacts remain forthcoming in individual repositories, so “fully open” still requires file-by-file verification. See our K2 Horizon guide.
- MiniCPM5-2B: OpenBMB released a compact 2B-class model with 131K context, tool use, coding, and formats for GGUF, MLX, GPTQ, and LiteRT. Its benchmark claims are publisher-reported, but the range of deployable artifacts makes it worth testing for on-device agents. See our MiniCPM5-2B guide.
- DeepSeek V4.1 Flash: DeepSeek signaled a release around September 10, but its official English changelog had not provided a stable release entry with final status and migration details during this edition's research window. Treat preview aliases and routing reports as unconfirmed until the primary documentation updates.
That's it for this week. Next Thursday: real Astra cost-per-task data, early Kotlin ADK lifecycle reports, and whether DeepSeek turns its V4.1 preview into a clearly documented release.
Want this in your inbox? Subscribe to AI Dev Weekly.
Previous issue: AI Dev Weekly #24
FAQ
Is GPT-6 Astra generally available in the OpenAI API?
OpenAI documents gpt-6-astra for the API but describes access as a staged rollout across accounts and platforms. Check your project's model list. GitHub Copilot's separate Astra availability is GA for eligible plans.
Is ADK for Kotlin 1.0 only for Android?
No. Its Kotlin Multiplatform core supports server-side Kotlin and Java interoperability. Android-specific modules add local models, Firebase AI, Room persistence, AppSearch memory, and mobile integrations.
Can a developer bypass GitHub's managed agent permissions?
GitHub says enterprise-managed restrictions take precedence over user and workspace settings, auto-approval, and saved approvals. Administrators should still test enforcement across every enabled client.
Does NVIDIA PAIR combine GPU memory across computers?
No. PAIR routes separate requests to eligible nodes. Each complete model and request must fit on the single machine selected to run it.
Related Articles
- K2 Horizon Explained
Originally published at https://www.aimadetools.com
Top comments (1)
Some comments may only be visible to logged-in visitors. Sign in to view all comments.