In this article
OpenAI added two-hour and eight-hour completion windows to the Responses API on November 17. A team that can wait pays 30 percent or 40 percent less in model-token charges than Standard processing. The request is accepted now, completes later, and shares a rate-limit pool with background and batch work.
On the same week, LangChain reported that more than 70 percent of runs on its Managed Deep Agents service now start from schedules rather than an ad hoc human prompt. The model is no longer only a synchronous dependency behind a chat box. It is becoming a worker that wakes up on a clock, carries state across runs, asks for attention, and acts through credentials that may outlive the initiating conversation.
That shift makes the control plane part of the product. The control plane decides when work starts, which identity it uses, which tools it may call, how much it may spend, what history remains valid, and when a person must review the result. Model quality still matters, but a capable model inside a weak control plane can create cheap, fast, persistent mistakes.
The claim is testable. It weakens if discounted queues remain useful only for independent batch jobs, scheduled agents fail to retain user value, and centralized tool controls add no measurable safety or operating benefit. This week’s releases do not prove the control plane is solved. They show where the engineering work has moved.
Time is now an API parameter and a budget
OpenAI’s completion windows are not just a pricing change. They separate acceptance from completion and make deadline tolerance explicit. A report needed before an afternoon meeting can use the two-hour tier. An overnight document review can use eight hours. An interactive request stays on the default path.
This creates a scheduling problem that model APIs previously hid. The application needs an admission policy, a durable response identifier, a deadline, and a recovery path if the result arrives after it is useful. It also needs to distinguish a long agent run from a set of independent requests. OpenAI recommends Batch for work that can be submitted together, while background mode supports multi-turn workflows in which a result determines the next tool call.
The same release introduced a second operational contract. Starting with GPT-6.2, the Responses API can drop reasoning items after a mid-conversation prefix edit. Editing an earlier developer message, changing certain model settings, or altering prior tool context can therefore increase cost, latency, or error rates because the model must reconstruct work. OpenAI’s migration guidance recommends an append-only pattern and exposes transformations that report which reasoning items were removed.
The practical design is a versioned run envelope. Persist the immutable prefix, model and tool configuration, completion deadline, budget, and response ID together. Append configuration changes as events instead of silently rewriting history. If a run is resumed with a new policy, record that as a new execution epoch. Otherwise, operators cannot tell whether a quality change came from the model, a discarded reasoning item, or a scheduler that resumed stale work.
Proactive agents spend human attention
LangChain’s account of proactive agents is vendor evidence, but it exposes the right bottleneck. Its internal GTM Agent watches leads, schedules briefs, and drafts outbound messages. Robin watches pull requests and can decide when to join a thread. These systems initiate work without a fresh prompt, then ask a person to review or approve only selected actions.
The scarce resource is no longer just tokens. It is review capacity. Every check-in has an arrival rate, a service time, and a cost if it waits. A proactive agent that produces twenty low-value approvals per day can be less useful than one that produces three well-ranked decisions, even if the first has better task accuracy.
Teams should measure the review queue as an application metric. Record how often the agent wakes, how many runs produce no action, how many check-ins are opened, time to decision, rejection and rewrite rates, and outcomes after approval. A falling notification count is not automatically good; the agent may be missing important events. A useful control plane makes both noise and silence observable.
LangChain also launched coding-agent outcome attribution on November 18. It links model spend and traces to pull requests or merge requests and separates merged, open, closed, and unattributed work. A merged change is not a complete productivity measure, since review and investigation may produce no patch. It is still more decision-useful than token volume alone. The important pattern is to attach cost to an outcome that a team can inspect, then keep the unattributed remainder visible rather than forcing every run into a success label.
Tool governance needs identity at each call
On November 19, LangChain introduced LangSmith Tool Gateway in public beta. The service centralizes credentials, tool allowlists, per-user policy, review requirements, and trace records. Its example retailer has more than 50 MCP servers exposing over 1,000 tools. A store assistant should act with an associate’s identity, while a 3 a.m. inventory reconciliation job should use a service identity and a much smaller tool set.
That is a real architecture boundary. Authentication establishes an identity. Authorization limits what that identity can do. The agent’s current goal and session history determine whether an otherwise allowed call is appropriate now. A gateway can enforce the first two deterministically and supply evidence for the third, but vendor material does not show false-block rates, policy-evaluation latency, or incident outcomes.
Before centralizing tool access, test three failure modes. First, verify that a user token cannot be substituted for a service token after a resume. Second, confirm that an agent sees only the current allowlist, even if an older tool schema remains in its context. Third, make policy denial durable, so a retry or fallback provider cannot turn a blocked call into an allowed one.
The package can run before the policy does
The sharpest counterexample to application-layer governance arrived on November 17. Malicious versions 1.26.1 and 1.26.2 of Microsoft’s agent-framework package were published to PyPI. StepSecurity’s static analysis found a credential stealer installed through a .pth startup hook. Python processed the hook whenever the interpreter started, even if the application never imported the framework.
Elastic Security Labs says its monitor detected the first release six minutes after publication. Both malicious versions were removed within the hour, but the payload could read environment variables, credential files, process environments, and identity endpoints. Detection speed reduced exposure; it did not make an affected environment trustworthy.
This incident sits below the agent’s tool policy. A perfect allowlist cannot protect credentials that malware steals during interpreter startup. The control plane therefore begins at build and release provenance: lock dependencies by hash, isolate builds from production identities, verify artifacts before promotion, record the exact environment attached to every run, and rebuild rather than merely downgrade after compromise. Treat short-lived package exposure as a credential incident, not only a dependency bug.
The root cause remains under investigation. Wiz attributes the publish path to compromised Microsoft release-pipeline material, while the public evidence does not establish how that material was obtained. The durable lesson does not depend on that attribution. Signed or officially named packages still require provenance checks, restricted publisher authority, and rapid revocation.
Routing convenience redistributes trust
Hugging Face changed its Inference Providers routing on November 16 so language-model requests now pass through OpenRouter. The router can select among more than 80 providers using live price, speed, and reliability data, then retry with another provider. Customers can disable providers and see which provider served a request. Existing custom provider keys no longer work for language models through this path.
The unchanged application API is the benefit and the risk. A retry can improve availability, but it can also move data, latency, and failure behavior across providers. Teams need provider allowlists, regional and retention constraints, per-provider evaluation, and a trace that records the actual route. Model identity alone is no longer enough to reproduce an incident.
This also changes procurement. A platform that once brokered discovery and billing now makes runtime placement decisions. The useful comparison is not only price per token. It is price per accepted outcome under the organization’s permitted route set, including retries and quality variance.
Architecture radar
- Adopt selectively: Explicit completion windows for delay-tolerant work. Put deadline, cancellation, and late-result policy in the run record before using the discount.
- Trial: Microsoft’s generally available Durable Task extension can persist agent sessions, checkpoints, human waits, and external events across failures. Provider documentation says completed work can resume on another worker without repeating steps. Test partial side effects and concurrent resumes before accepting that guarantee for a consequential workflow.
- Trial: A central tool gateway for multi-user agents. Measure policy latency, false blocks, credential mix-ups, and audit completeness before expanding the tool catalog.
- Trial: Isolated worktrees for concurrent agent sessions. Qwen Code v0.28 starts new Web Shell sessions in separate worktrees by default and supports explicit branch creation or handoff. This reduces file collisions, but it does not sandbox credentials or external side effects. Test stale-base conflicts, duplicated actions, and cleanup after abandoned sessions.
- Assess: Provider routers that retry transparently. Require route-level provenance and evaluate the providers that can actually receive traffic.
- Watch: Low-concurrency decode optimization. vLLM’s November 18 MonoKernel results report 1.20 to 2.26 times higher interactivity across several AMD configurations, with gains narrowing as concurrency rises. The architecture is relevant to agents because each generated action sits on the next tool call’s critical path, but every model and hardware recipe needs its own accuracy and capacity check.
Research and open-source shortlist
- Read: METR’s November 20 capability update combines longer, more realistic tasks with explicit uncertainty. Its agents improve quickly on coding and optimization, yet perform worse than human experts on judgment-heavy tasks where feedback is slow or unclear. That is the strongest reason to design review queues around uncertainty, not task length alone.
- Test: Thinking Machines Lab’s Inkling 2 Mini is a 26.4 billion parameter open-weight looped model with 3.4 billion active parameters and an approximately 20 GB checkpoint. The lab reports shorter visible reasoning as internal loops increase. Test task quality, local latency, and monitorability together rather than treating local execution as the only decision.
- Watch: MLPerf Training v6.1 adds a Qwen3.5-397B post-training workload using group relative policy optimization. The round has broad hardware participation and a peer-reviewed suite, but benchmark training time still does not predict the reliability or economics of a production agent workflow.
- Ignore for now: Cross-vendor claims that one new model is the default winner. Google’s November 18 Gemini 4 Neon has an independent Artificial Analysis result at its highest thinking level, while vendor tables for Neon, GPT-6.2, Qwen4-Max, and MAI Code 2 use different settings and task mixes. Run the workflow and route that will exist in production.
Hype, evidence, and disagreement
Anthropic reported on November 17 that Claude agents solved two open problems in black-hole physics. The company says one result was formally verified in Lean, multiple agents reached related answers, and a physicist checked the main results. Those are stronger artifacts than a prose-only claim.
They are not the same as independent scientific acceptance. Anthropic organized the work, supplies the model, and published the account. Formal verification establishes that a proof follows from its encoded assumptions; it does not establish that the formal statement captures the intended physical question. The right status is consequential and inspectable, with outside review pending.
The disagreement matters because long-running research agents amplify both productivity and review debt. Six weeks of parallel work can produce a result that no person could reasonably audit from chat transcripts. The control plane must preserve problem definitions, agent branches, failed approaches, formal artifacts, and expert review decisions. Otherwise, autonomy creates an evidence bottleneck at the moment the result becomes most important.
Stay Sharp: use Little’s Law for the review queue
Ward Whitt’s 1991 paper, A Review of L = λW and Extensions, explains why average work in a stable system equals arrival rate multiplied by average time in the system. An illustrative agent queue that receives six review requests per hour and holds each for two hours therefore carries twelve open requests on average.
The law does not rank requests, prove that a system is stable, or describe a queue during a surge. It is a diagnostic: if scheduled agents create approvals faster than reviewers resolve them, backlog must grow. A faster model can worsen the problem by increasing arrivals.
What changed in the past year is the arrival process. Schedules, background completion windows, and tool gateways can now create review work without a person initiating each run. Review capacity therefore belongs in the control plane, not in an after-the-fact staffing estimate.
Apply the concept in four steps:
- Measure arrival rate and review time by risk class, including abandoned and expired requests.
- Set a bounded work-in-progress limit and an explicit service target for each class.
- Define backpressure before the limit is breached: slow low-value schedules, cancel stale work, or require a higher-value trigger.
- Track missed important events and harmful approvals so lower arrival volume cannot masquerade as better autonomy.
A design review should ask which event raises a request’s risk class, which work slows first, how abandoned requests affect the measurements, and which miss metric prevents the scheduler from hiding important work. An agent earns a wider operating envelope only when it reduces unnecessary arrivals without increasing missed events or harmful approvals.
What changed in the mental model
The old deployment picture put a model behind an application and treated scheduling, identity, and review as integration details. The more accurate picture has two coupled systems. The execution system generates and acts. The control system admits work, binds identity, preserves provenance, allocates budget, and meters human attention.
That distinction changes ownership. Model evaluation belongs with application outcomes. Package provenance belongs with the run record. Review capacity belongs in reliability planning. A control-plane incident can invalidate an otherwise correct model result.
Watch next week
- Whether completion-window users publish late-result, cancellation, and queue-saturation behavior.
- Whether proactive-agent deployments report review arrival rates and missed-event rates, not only scheduled-run share.
- Whether Microsoft publishes a confirmed root cause and release-pipeline remediation for the malicious packages.
- Whether tool gateways report policy latency, denial accuracy, and credential-isolation evidence from production.
- Whether independent physicists confirm that Anthropic’s formal statements match the claimed black-hole problems.
Long-running agents do not remove operations from the product. They turn operations into user experience. The systems that win will not merely complete more work. They will make time, authority, cost, and review legible enough that teams know which work to trust.