# AI Dev Weekly #25: GPT-6 Astra Arrives, Kotlin Agents Reach 1.0, Copilot Adds Enforced Permissions > Source: > Published: 2026-09-10 09:38:03+00:00 *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. 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](https://developers.openai.com/api/docs/guides/latest-model) adds three API capabilities that matter more than another benchmark table: `configuration_update` item 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](https://openai.com/index/gpt-6-astra/) 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](https://www.aimadetools.com/blog/gpt-6-astra-explained/?utm_source=devto) covers pricing, rollout, and tool support, while [Astra vs GPT-5.6 Sol](https://www.aimadetools.com/blog/gpt-6-astra-vs-gpt-5-6-sol/?utm_source=devto) handles the model-routing decision. 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](https://developers.googleblog.com/announcing-adk-for-kotlin-10-building-production-ready-ai-agents-in-kotlin-android-and-beyond/) is especially interesting on Android: 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. 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: The crucial property is precedence. According to the [GitHub changelog](https://github.blog/changelog/2026-09-09-enterprise-managed-permissions-for-github-copilot-agent-operations/), 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. 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](https://developer.nvidia.com/blog/nvidia-pair-virtual-inference-router-expands-available-compute-on-your-local-network/) 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](https://www.aimadetools.com/blog/nvidia-pair/?utm_source=devto) covers routing and security boundaries, and [PAIR vs plain Ollama networking](https://www.aimadetools.com/blog/nvidia-pair-vs-ollama-networking/?utm_source=devto) helps decide whether you need it. *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](https://app.kit.com/forms/9198516/subscriptions).* *Previous issue: [AI Dev Weekly #24](https://www.aimadetools.com/blog/ai-dev-weekly-024-gemini-38-fable-51-agent-plugins-copilot-exclusions/?utm_source=devto)* 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. 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. 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. No. PAIR routes separate requests to eligible nodes. Each complete model and request must fit on the single machine selected to run it. *Originally published at [https://www.aimadetools.com](https://www.aimadetools.com/blog/ai-dev-weekly-025-gpt-6-astra-adk-kotlin-copilot-permissions-nvidia-pair/?utm_source=devto)*