Agents API, Full-Duplex Voice, SWE-2 and Copilot Auto Routing: The Week in AI Dev
OpenAI's managed Agents API and GPT-Live-1 voice layer, Cognition SWE-2 efficiency claims and Copilot Auto routing preferences, with practical notes on cost, security and evaluation.
This article is published in English.
Sources: AI Dev Weekly #26: Agents API, Full-Duplex Voice, SWE-2 and Cost-Aware Copilot
Models have stopped being the whole product. OpenAI now rents out the managed agent loop that powers Codex, along with a voice layer that keeps the conversation going while an agent works in the background. Cognition's SWE-2 tries to finish coding tasks with fewer wrong turns. GitHub Copilot lets developers pick a leaning between cheap and strong rather than selecting models one by one. A shared question runs through all four: what should a team own in its agent stack, and what should it hand off? The coverage here spans September 10 to September 17.
1. OpenAI puts the Codex harness behind the Agents API
On September 10, OpenAI put the Agents API into public beta. It is a managed runtime for durable agent work and shouldn't be mistaken for the Agents SDK under a new name. OpenAI takes on session orchestration, context compaction and recovery, while the application provides tools and decides how the agent fits into the product.
OpenAI's overview splits the design into four pieces: the agent's configuration, the environment it runs in, a durable session and the stream of events and items passing through that session. Updates can come by streaming or by webhook. A session accepts new work on top of what it already knows, so nothing restarts from a blank context.
The architecture guide spells out where execution happens. There are three choices:
- Without an environment, the harness reaches remote MCP connections and function tools that the application handles itself. A shell and workspace files aren't available.
- In an OpenAI-hosted environment, OpenAI sets up the sandbox where code runs, files get edited and artifacts are produced.
- In a self-hosted environment, an executor on your own infrastructure connects in while OpenAI still operates the harness. Provisioning, reconnecting, shutting down and keeping files all become your duty.
The last option isn't self-hosting the whole agent. Moving execution into a private network doesn't move the managed orchestration layer along with it.
The bill adds up the selected model's API rates, normal tool fees and standard container rates when OpenAI hosts the sandbox. A realistic budget counts the entire run with subagents and retries, since a session is much more than one model reply.
The security documentation also cautions that agent-written code can read any credentials exposed to its environment. The application's API key should stay outside the sandbox, outbound destinations should be restricted and third-party credentials should be brokered where possible. A sandbox doesn't protect a secret once it has been injected into the process.
Takeaway: The build-versus-buy math changes here. Session recovery and compaction cost a lot to maintain, so renting them is reasonable. Authoritative business data and sign-off on irreversible actions belong in the application itself. Beginning with a read-only investigator is wiser than jumping to an agent that fixes things. The real comparison is between buying a coding workspace and embedding an agent runtime in one's own product.
2. GPT-Live-1 separates conversation from work
GPT-Live-1 became generally available in the API that same day. Its headline feature is full duplex. The voice model listens while it talks, so the spoken exchange continues while a backend agent works through reasoning and tools.
In OpenAI's getting-started material, Realtime is the contrast case, with one model covering speech, reasoning and tool choice. Live lets the backend be picked separately. Someone can ask about an order, fix a detail mid-lookup and receive the answer without a dead-air pause for the tool call.
The delegation guide describes two modes:
- Responses delegation: Live drafts requests for a configured OpenAI backend and feeds the answers back into the call.
- Client delegation: the application builds the context, runs its own agent or service and hands back the outcome. Choose this when routing or checks must happen before backend output reaches the voice model.
Client delegation carries a subtle integration requirement: delegation events hold metadata, not the task text. Backend requests should be built from transcript events and application state, since the event isn't a ready-made command payload.
According to the model page, voice sessions cost $0.05 a minute, billed by the second, and backend model and tool use come on top. Ten minutes of conversation therefore costs $0.50 for voice alone, before reasoning, tools or hosting.
Either way, permissions, confirmation and task state stay with the application. Even with backend results under review, nothing forces the voice model to remain silent during validation, so testing should look at what the assistant says before an action is confirmed and not only at whether the tool finally succeeds.
Takeaway: Voice turns into an interface over an agent instead of a tightly coupled speech pipeline, which suits support workflows and hands-free developer collaboration. A first evaluation should probe interruptions, changed instructions during a slow lookup and whether the assistant correctly separates requested from completed. Natural conversation is only valuable if task state stays truthful. That question differs from the choice of speech-to-text engine.
3. Cognition SWE-2 aims for fewer turns, not only a higher score
Cognition announced SWE-2 on September 10. It ships first in Devin Desktop and the CLI, with Devin Web and Fusion next. According to the launch post, the model is post-trained from Kimi K3 and picks up multiple reasoning-effort levels inside one reinforcement-learning run.
The operational number stands out. On FrontierCode 1.1 Main at medium effort, SWE-2 needed 58% fewer turns and cost 81% less than SWE-1.7. Cognition gives SWE-2 a 50.0% score there, yet only 27.3% on Terminal-Bench 4, well behind the strongest models in its own comparison.
Those evaluations come from the publisher and mix public results with internal runs in model-specific harnesses, so they don't amount to an independent, uniform leaderboard. The announcement doesn't include standalone SWE-2 API pricing or downloadable weights.
Takeaway: The valuable skill for a coding agent is knowing when exploring ends and editing starts. Skipping repeated repository reads and redundant tool calls can matter more than shaving token prices. Fewer turns doesn't always mean better work, because it may reflect skipped verification. A balanced trial includes a small bug fix, a migration and a refactor that must preserve behavior, tracking what got accepted, which tests were missed, what reviewers corrected and how the product was really used. The thing to test is the Devin capability available today, not a standalone endpoint that doesn't exist.
4. Copilot Auto gets a cost-versus-quality control
GitHub introduced three Auto routing preferences on September 14. Efficiency targets lower cost, Balance weighs cost, quality and latency together, and Intelligence favors quality. Per the announcement, VS Code, Copilot CLI and the Copilot app are getting it gradually.
Two limits come from the Auto documentation. Routing continues to honor plan access and administrator policies, and it works along natural cache boundaries so cache-related costs don't grow. An organization's restricted-model policy isn't overridden.
A preference is not a spending cap either. Efficiency may pick a more capable model when a task needs one, and Intelligence doesn't guarantee the largest model for every response. The selected model and actual usage deserve inspection before conclusions are drawn from the label.
Takeaway: The setting beats making every developer memorize a ranking of models, though it clouds comparisons unless routing choices are logged. Running identical representative tasks under each preference and comparing cost per accepted change, latency and reviewer effort yields real data. Explicit model choice remains appropriate wherever results must be reproducible. Routing preference and billing policy are separate questions.
Quick hits
- VS Code agent automations. Version 1.137 brings recurring hourly, daily and weekly tasks as a public preview. Maintenance reports or draft pull requests suit a first try, and the rules for overlapping runs should be set beforehand. Weekly release notes also list HydraFusion's local, cloud and compound routing under the CLI's experimental menu, a separate thing from the Auto preferences described above.
- Copilot code review. During rereview it closes comments it has already handled, and it gets shell tools for builds, tests and focused scripts, running behind the agent firewall. GitHub also adds an agent ensemble for Lite reviews. Extra validation helps, but requiring human review is a different repository setting.
- API key governance. OpenAI introduced organization and project controls on September 15 that restrict new key creation to service accounts, user-owned project keys or nothing at all. Organization rules take precedence and keys already issued stay as they are. Key-expiry controls from September 10 appear in the API changelog. Blocking new keys doesn't rotate old credentials.
Common questions
Is the Agents API just the Agents SDK renamed? No. The API supplies an OpenAI-run harness and durable sessions, whereas the SDK gives building blocks for orchestration the application controls. The API is still a public beta.
Is the backend agent included in GPT-Live-1 pricing? It isn't. Voice runs $0.05 per minute, billed per second, while backend model and tool usage is billed apart.
Can SWE-2 be downloaded or called through its own API? The launch announcement published neither weights nor standalone API pricing, so evaluation has to go through the documented Devin surfaces.
Does choosing Efficiency fix the monthly bill? Not at all. It steers routing without capping spend. Charges depend on which model gets picked, so usage should be measured and budgets enforced on their own.