Anthropic Launched Claude Duet, the First Proactive AI Agent From a Frontier Lab. It Doesn't Wait for You to Ask — and That Inverts the Activation Model for Every AI Product.

The Decision Layer Has a Dedicated Home

On October 22, 2026, OpenAI moved its Decisions API to general availability, running on GPT-6 Luna, at $0.10 per million input tokens with no charge for output tokens. The endpoint does not return generated text. It returns typed answers — predicates, choices, or scores — at speeds OpenAI claims are up to ten times faster than calling GPT-6 Luna through the standard Responses API.

ProPakistani's coverage of the earlier beta launch described the endpoint as focused on "questions with bounded answers," designed to help applications and agents make near real-time decisions from text, images, and structured inputs. That description understates the architectural significance of what OpenAI has shipped.

The Decisions API is not a performance optimization on the LLM API. It is the first dedicated decision layer in the enterprise AI agent stack — a purpose-built endpoint for the class of questions that agent architectures ask continuously and that do not require a paragraph of generated text as the answer. At $0.10 per million input tokens with free output, it is also the cheapest inference option in OpenAI's catalog by a significant factor, and it is purpose-built for the use case where cost matters most: real-time routing, scoring, and classification inside an agent loop that runs at every workflow step.

What the Decisions API Is and What It Isn't

The Decisions API solves a specific problem in agent architecture that has been addressed by workarounds since the first production agent deployments.

A production AI agent running complex tasks makes hundreds of routing and classification decisions per task. Should this message be escalated or handled autonomously? Is this user input within the agent's defined scope? Does this document match the criteria for the next workflow step? What priority tier is this incoming request? Each of these questions has a bounded answer — it is one of two to ten choices, or a probability, or a score on a defined scale. None of them requires a generated text response.

For the past two years, agent builders have handled these routing questions in one of three ways: hard-coded rule logic (fast but brittle), calling a standard LLM API and parsing the text response (slow and expensive), or maintaining a separate classification model on internal infrastructure (accurate but operationally complex to maintain). The Decisions API is the fourth option: a purpose-built hosted endpoint that returns typed probabilistic answers at commodity prices without any of the three tradeoffs.

The three output types cover the full taxonomy of agent decision questions:

Predicate: Returns a probability between 0 and 1 that a statement is true. Example: probability that this customer message indicates urgency. Example: probability that this document contains personally identifiable information. The predicate type is correct for binary or continuous classification where the agent needs confidence information to calibrate its next action, not just a yes/no binary.

Choice: Returns a selected option from a developer-defined set, with confidence scores for each option. Example: which customer tier does this inquiry belong to — support, billing, technical, or sales? Example: which workflow state does this document belong to — draft, review, approval, or complete? The choice type is correct for routing decisions, categorization, and any case where the outcome space is enumerable and defined by the developer.

Score: Returns a numeric rating on an ordered scale or rubric. Example: quality score for generated content against an evaluation rubric. Example: priority score for a support ticket on a 0–10 scale. The score type is correct for evaluation, ranking, and prioritization tasks.

The GA release, announced October 22, added image inputs alongside text and structured JSON, expanded the question limit to 400 per single request from 200 in the beta, added prompt caching, and introduced US and EU inference residency options. The context window is 1,050,000 tokens, supporting large-document classification use cases that were previously impractical at the Decisions API's latency and price point.

The Architecture Pattern: Planner Plus Decision Layer

The architecture pattern that the Decisions API formalizes has been described consistently across developer documentation and implementation guides since the beta. The canonical pattern separates an agent architecture into two distinct layers with different model requirements:

The planning layer uses a high-capability frontier model — GPT-6, Claude Opus 5.5, or equivalent — for tasks requiring genuine reasoning: understanding intent, generating multi-step plans, synthesizing information across contexts, producing outputs the user interacts with. The planning layer runs infrequently per user session — typically five to twenty calls for a complete task — and tolerates the latency and cost of frontier model inference because it does the work that actually requires frontier intelligence.

The decision layer uses the Decisions API for the high-frequency routing and classification decisions between planning calls: which tool to invoke next, whether an action is within the agent's defined scope, which workflow branch to follow, what priority tier this incoming request belongs to, whether this output meets the quality threshold to proceed. The decision layer runs at every workflow step and cannot tolerate frontier model latency or cost.

The economic model for this architecture is compelling:

An agent that makes ten planning calls and one hundred decision calls per user session spends more than 90% of its per-session inference budget on planning at frontier prices. The Decisions API reduces the decision layer calls from frontier cost to commodity cost without changing what the decision layer does. For agents running at scale — thousands of daily sessions — this arithmetic changes the unit economics model from marginal to clearly profitable.

The Latency Argument

The 10x speed advantage OpenAI claims for the Decisions API over the standard Responses API endpoint is the latency argument that enables real-time applications.

A production agent handling a customer service interaction in real time cannot run a full frontier model inference call at every routing decision. If each decision call adds 500–800ms of latency, a session with one hundred decision calls accumulates fifty seconds of invisible wait time before any user-facing action is taken. An agent designed to feel instantaneous cannot carry that overhead without breaking the user experience.

The Decisions API's reported latency of approximately 150ms per response — even accounting for variance — represents a structural threshold. At 150ms, an agent making fifty decision calls accumulates 7.5 seconds of cumulative decision overhead, a budget that fits inside the latency expectations of a real-time professional productivity tool. At 500ms, the same agent's decision overhead alone exceeds user tolerance thresholds before any substantive planning call has been made.

The Competitive Context: Cloudflare, Typesafe, and the Decision Layer Market

The Decisions API is not the first purpose-built decision layer in the enterprise AI agent market. Cloudflare's Clef decision model product launched earlier in 2026 with a similar bounded-answer architecture, positioned as an edge-deployed decision layer running close to the user for minimal geographic latency. Typesafe AI's Jev, which raised $870 million in its September 2026 round, is the most-funded competitor in the dedicated decision layer space, with a different architecture emphasis on enterprise governance and full audit logging.

Each approach has different strengths in the tradeoff between performance, governance, and ecosystem integration:

For enterprises in regulated industries — financial services, healthcare, legal — Typesafe Jev's audit logging and on-premises deployment option addresses governance requirements that OpenAI's cloud-hosted implementation does not currently match. Enterprise AI agent trust concerns are directly connected to the ability to produce a complete audit trail of agent decision logic for regulatory review. The Decisions API's output log, without additional infrastructure, does not satisfy the audit requirements of a federally regulated financial institution.

For enterprises already running GPT-6 workloads on OpenAI's platform, however, the Decisions API represents the minimum-friction path to a tiered agent architecture. The same API credentials, the same billing relationship, the same SDK — the only change is the endpoint and the question format.

The launch of the GA Decisions API also extends OpenAI's pricing tiering strategy into the lowest tier of the inference cost curve. OpenAI now offers a complete tiered inference stack: Decisions API at $0.10/M for bounded decision answers, GPT-6.1 Sol at approximately one-fifth frontier cost for reasoning tasks that don't require the highest capability, GPT-6 at frontier pricing for the most demanding planning and generation tasks. Enterprise buyers can architect a single-vendor agent stack across the full capability-cost spectrum without leaving the OpenAI platform.

The DevDay to GA Timeline: What Changed

The Decisions API moved from concept to GA in less than thirty days — a timeline that reflects OpenAI's assessment of the endpoint's readiness and the developer demand it observed during the beta.

OpenAI's DevDay 2026 announcement on September 29 introduced the Decisions API in limited preview with a 200-question limit, text inputs only, and no prompt caching. The public beta launched October 6 with these constraints intact. The GA on October 22 added image inputs, the 400-question limit, prompt caching, and the two residency options.

The compressed timeline is significant for enterprise buyers: it signals that OpenAI received sufficient validation from beta users that the core capabilities were production-ready, and that the enterprise residency requirement was the primary blocking factor for GA readiness — not model quality or API stability. The fact that agentgateway.dev had already integrated the /v1/decisions endpoint routing into its agent infrastructure by October 12 — ten days before GA — suggests the developer ecosystem was building on the beta endpoint at scale before the official GA announcement.

The Enterprise Adoption Playbook

For enterprise teams evaluating the Decisions API, the correct starting point is architectural mapping: which specific decision points in the current agent implementation are best suited for a dedicated decision layer?

1. Audit current agent call logs for routing calls. Every production agent makes decisions between LLM calls that could be handled by a decision layer — intent classification, scope enforcement, tool selection, workflow routing. Pull the call log from the current agent's most common workflows and tag every call where the output is not generated text but a routing, classification, or scoring decision. For most production agents, 60–80% of total API calls by volume are routing decisions that qualify.

2. Calculate the cost and latency impact of migrating those calls. For each tagged call, calculate the per-call cost under the current architecture (frontier model tokens consumed by a routing call) versus the per-call cost under the Decisions API ($0.10 per million input tokens, free output). Multiply by daily call volume to get the monthly infrastructure cost difference. For agents with high decision call frequency, the savings are typically 70–90% on those specific calls.

3. Define the question set for the three highest-volume routing decisions. The Decisions API requires predefined answer sets for choice and score output types. Start with the three highest-volume routing decisions — those currently consuming the most frontier model tokens on classification work — and define the question specification: output type (predicate, choice, or score), the answer options for choice types, and the scale definition for score types.

4. Build the policy layer on top of the decision layer output. The Decisions API returns a probability, choice, or score. The policy layer — the application code that determines what action to take given that answer — remains the application's responsibility. Define the business rules: at what probability threshold does a predicate trigger escalation? What score threshold triggers a quality rejection? The Decisions API narrows the answer space; the policy layer applies the downstream logic.

5. Instrument decision layer accuracy against ground truth. Decision layer accuracy drifts as input distributions change over time. Build a sampling pipeline that compares Decisions API outputs against human-labeled ground truth on a weekly cadence for the highest-stakes decision types. Set an accuracy floor below which the decision type routes to the planning layer instead. A Decisions API call that is wrong 15% of the time on a scope enforcement question is worse than a frontier model call that is wrong 1% of the time — the speed and cost advantage only holds when the accuracy meets the application's accuracy requirement for that decision type.

6. Plan for governance requirements before production in regulated industries. For financial services, healthcare, and legal deployments, the decision layer's output log is part of the AI agent's audit trail. Ensure logging infrastructure captures the complete request and response for every Decisions API call — question set, input, output probabilities, and the downstream action taken. Regulators evaluating AI agent compliance will ask for this evidence. If the current OpenAI Decisions API logging does not satisfy these requirements, evaluate whether Typesafe Jev's enterprise governance tier addresses the gap before choosing an architecture.

What the GA Release Means for Agent Economics in 2027

The broader significance of the Decisions API GA is what it signals about the trajectory of enterprise AI agent infrastructure costs entering 2027.

In 2024, the primary cost driver for production AI agents was the frontier model call per step. In 2025, as frontier model prices fell 80–90%, the bottleneck shifted to architecture: agents using frontier models for every decision — including simple routing calls — were still paying ten to fifty times what the decision complexity warranted. The Decisions API addresses that architecture cost directly.

Enterprise AI budget scrutiny entering 2027 is focused on demonstrable ROI. The Decisions API gives CFOs and IT procurement teams a concrete cost reduction lever: the same routing decisions that currently run at frontier model prices can run at commodity prices for bounded questions without sacrificing accuracy. For agents running at scale — thousands of daily sessions — that price differential is frequently the difference between a unit economics model that works and one that doesn't. The infrastructure cost argument for the Decisions API is not marginal. It is the difference between AI agents that are economically viable at the usage levels enterprises actually need and agents that require subsidized pricing to avoid destroying the unit economics of the products they power.

Takeaway

Takeaway: OpenAI's Decisions API GA on October 22, 2026 creates a dedicated decision layer in the enterprise AI agent stack: $0.10 per million input tokens with no output charge, returning typed predicates, choices, and scores at up to 10x the speed of standard GPT-6 Luna calls, with image and text inputs and a 1,050,000-token context window. The endpoint does not replace the planning layer — frontier reasoning still requires frontier models — but it eliminates the economic and latency penalty of running hundreds of agent routing decisions through frontier inference. For enterprise teams, the adoption playbook starts with auditing current agent call logs for routing calls that can migrate to the decision layer, calculating the per-call cost difference at scale, defining the question sets for the three highest-volume routing decisions, and building the policy layer that translates Decisions API typed outputs into downstream agent actions. The governance requirement — full decision log for regulated industry audit trails — is the non-negotiable prerequisite that Typesafe Jev currently addresses more completely than the OpenAI implementation. For enterprises already on the OpenAI platform in unregulated industries, the Decisions API is the cheapest and fastest path to a tiered agent architecture that matches model capability to decision complexity across the full workflow cost curve.