Codex CLI 0.162.0 Adds Custom-Provider Capability Overrides—Why Live Web and Remote Compaction Still Need Proof

The 8 October 0.162.0 event: a narrow configuration change, precisely dated

OpenAI published the stable Codex command-line interface (CLI)A text-based interface for running commands and tools. Open glossary entry release rust-v0.162.0 on 8 October 2026, and its release notes list configuration of live-web-access and remote-compaction capabilities for custom Responses-compatible providers as a new feature. This is a release-note claim about client configuration capability, not a certification of a particular third-party provider. The OpenAI release record for the exact rust-v0.162.0 tag gives the publication time as 18:55:59 Coordinated Universal Time (UTC)The internationally agreed standard for world time, used here to identify the time reference in timestamps and offsets. Open glossary entry. Its relevant bullet reads: “Configure live web access and remote compaction capabilities for custom Responses-compatible model providers.” This article is locked as of 13 October 2026; the dated release, rather than a moving latest-release reference, is the starting point for examining the event. [Release: 0.162.0]

For readers managing Codex through an organisation’s gateway, the immediate news value is therefore administrative precision. A configuration discussion can now refer to the announced provider-level capability overrides rather than assuming that a custom connection behaves like a built-in provider. That is useful even before anyone changes production settings: it gives the upgrade reviewer a specific subject to investigate. It is not a reason to merge the client upgrade, provider configuration and permission to use a new feature into a single approval.

In this story, the client is only one part of the proposed operating arrangement. A gateway may sit between that client and an upstream model service, while the administrator chooses how Codex addresses the provider. Keeping those roles separate avoids a misleading reading of “custom provider”: the phrase names a configuration relationship, not a class of services that OpenAI has collectively tested or approved.

What the terminology means—and what it does not establish

OpenAI Developers’ advanced configuration documentation, an undated page accessed on 13 October 2026, describes a model provider as defining how Codex connects to a model: its base Uniform Resource Locator (URL)The address used to identify and access a resource on the web. Open glossary entry, wire application programming interface (API)A documented way for software systems to exchange requests and results. Open glossary entry, authentication and optional Hypertext Transfer Protocol (HTTP)A standard request-and-response protocol for exchanging representations and related metadata between web clients and servers. Open glossary entry headers. In ordinary terms, a custom provider is the connection definition an administrator supplies for a chosen model service. That definition tells the client where and how to communicate; it is not itself an inventory of everything the service can do.

“Responses-compatible” is the qualifying phrase in the release announcement. It refers to compatibility with the Responses interface, not merely to a service that can return conversational text. OpenAI Developers’ undated gateway compatibility requirements, accessed on 13 October 2026, explicitly distinguish that interface from working Chat Completions or Anthropic Messages endpoints. For this foundation, the operational implication is limited: a different API shape cannot be assumed to fall within the announced change just because it also accepts prompts.

A capability declaration is a statement the client can use when deciding how to handle a provider. It is best understood as configuration input, not as an observation from the remote system. This distinction matters because the administrator writes the declaration, whereas the gateway and upstream service must actually handle the relevant interaction. A configuration review can establish what a file says. Establishing what the deployed service does requires evidence of that service’s behaviour; the two activities answer different questions.

Hosted web search means a search tool supplied through the hosted model interaction, rather than an ordinary local command fetching a page. OpenAI Learn’s undated web-search documentation, accessed on 13 October 2026, separates hosted search from sandboxed local command networking. That distinction prevents an administrator from treating the release as a general network-access change. Permission to run local commands, or access connected systems, is not implied by the provider capability vocabulary.

Remote compaction, in the merged change, refers to sending compaction_trigger items through the Responses endpoint rather than using local compaction. Here, the term identifies a capability whose treatment is configurable; it does not describe a measured improvement. Neither the release bullet nor the supplied implementation evidence justifies a promise about context gains, response speed, cost or reliability. A reader evaluating the upgrade should keep those possible evaluation questions separate from the narrower fact that the client has an override surface for this path.

These translations leave an important uncertainty intact. “Compatible”, “declared” and “working” are not interchangeable labels. Compatibility describes the required interface relationship; declaration describes the administrator’s chosen configuration; working describes an observed outcome under specified conditions. The release provides a reason to inspect that relationship, but it does not collapse all three labels into one status.

The implementation source adds location, not a deployment certificate

The implementation describes the new custom-provider override location as model_providers.<id>.capabilities, with external_web_access and remote_compaction settings for Responses-compatible providers. This is the documented configuration shape from the merged change, not copy-and-paste deployment advice. The provider must be Responses-compatible; a different API shape is outside the stated change. OpenAI’s merged capability-override pull request, dated 2 October 2026 and accessed on 13 October 2026, is the implementation-level source for that description. [Add capability overrides for custom model providers]

The sequence of dates also matters. A merged implementation record dated 2 October and a stable release published on 8 October are not competing release dates. They describe different events in the development and publication history. An upgrade note should cite the stable tag for the distributed event and the pull request for implementation detail. Substituting one date for the other would make it harder for colleagues to identify which artefact the review concerns.

Source selection should follow the question being asked. “What did this release announce?” belongs with the tagged release notes. “Where is the override described?” belongs with the merged change. “What does current administrator guidance require?” belongs with the relevant documentation, carrying its access date. This division is especially useful when an internal discussion mixes a dated announcement with documentation that may have changed after publication.

The current documentation used here is undated and was accessed on 13 October 2026. It can inform an administrator’s present review, but it is not proof that every sentence appeared on the 8 October release day. Consequently, references to that guidance should be written as current documentation statements, not retroactively attributed to the release. This is a small editorial distinction with a practical effect: it preserves an accurate record of what supports each decision.

After completing the 0.162 capability inventory, use Codex CLI 0.157 Upgrade: Background Server, Conversation Forks, Remote Import, and Network Policy, which outlines a controlled procedure using a Git checkpoint, status and permissions review, disposable-branch testing, evidence capture, rollback, and human approval. Editorially, those are useful controls for a custom-provider qualification run, not proof that any declared 0.162 capability operates.

A hypothetical company gateway: a reply is a starting point

Hypothetical example—not an observed deployment. Suppose a company already routes a basic Codex prompt through its own gateway and receives a short text reply. Its administrator sees the new release bullet and asks whether colleagues can now use live web search or remote compaction through the same connection. The existing reply establishes only the limited result described in this scenario: one basic interaction returned text. No search request or compaction interaction has been supplied as evidence.

The first useful change is to the administrator’s question. Instead of asking “Does our gateway work with Codex?”, the administrator can ask “Which announced provider capability do we intend to configure, and what evidence would justify that declaration for our intended connection?” This is a recommendation about framing the review, not a product feature. It makes the proposed change inspectable without implying that the hypothetical gateway has passed any qualification.

Imagine that the company’s change request originally says, “Upgrade Codex to enable web search.” That wording would assign an outcome to the client upgrade which the release does not establish. A more accurate hypothetical request would say, “Review the custom-provider capability overrides in rust-v0.162.0 and determine whether our intended search path merits qualification.” The second formulation leaves the service capability unresolved and creates a clear task for the administrator.

A separate hypothetical request might concern compaction rather than search. It should state that the team wants to assess the remote path, not that the path will reduce resource consumption or make long sessions more reliable. Those proposed benefits would require their own evidence. Keeping the request centred on the capability avoids turning a configuration announcement into an unsubstantiated business case.

The basic reply also does not reveal which upstream route handled the interaction. OpenAI Learn’s undated gateway connection guide, accessed on 13 October 2026, warns that a response alone does not prove the route. In the hypothetical company, the administrator should therefore avoid treating the model’s self-description as a deployment record. Route attribution belongs in the later evidence work, not in an inference drawn from the wording of an answer.

For this example, a useful preliminary note would distinguish three things: the client version being considered, the provider connection under discussion and the capability being investigated. It would not include credentials, personal data or production prompt contents. The note’s purpose is to keep the question specific enough to assign, not to create a miniature deployment guide or collect sensitive information before it is needed.

How to write an upgrade note that preserves the uncertainty

Suggested editorial procedure. Begin the internal note with the exact stable tag and publication timestamp, then identify the particular release bullet under review. This anchors the work to a retrievable artefact and prevents later readers from confusing it with another client version. Keep the note focused on this capability announcement; do not append unrelated release items as if they jointly prove better gateway compatibility.

Next, record the implementation reference separately from the release citation. That separation lets a reviewer inspect whether a statement concerns the announcement or a configuration detail. It also provides a place to mark unanswered questions without altering the release quotation. A missing answer about the organisation’s service should remain a missing answer, rather than being filled with an assumption based on the field name.

Use evidence-status language deliberately. “Documented in the merged change” is appropriate for the override location. “Proposed for review” is appropriate for an administrator’s intended edit. “Not yet established for our connection” is appropriate where the record contains no relevant behaviour evidence. These labels are suggested writing conventions; they are not Codex interface statuses or official certification categories.

A hypothetical short note could read: “We are reviewing the provider capability change associated with rust-v0.162.0. Our existing connection evidence concerns a basic text interaction only. Search and remote-compaction behaviour remain outside that evidence. The designated administrator will decide whether to commission further qualification before approving a capability change.” This sample is intentionally an unresolved record, not a fictional success report.

Do not make the note more confident by attaching a provider’s general compatibility claim without checking its relevance. A service description may concern another interface, another model or another deployment arrangement. This article names no third-party gateway as supporting the change, because the assigned evidence does not establish such a combination. The appropriate question is whether evidence matches the intended arrangement, not whether the vendor uses familiar terminology.

Also separate the upgrade decision from feature distribution. An organisation may have reasons to review or adopt a client release that are independent of these overrides. Conversely, considering a capability does not require treating it as approved for every user. The suggested review record should make those decisions distinguishable so that a client-version change is not silently interpreted as permission to activate a remote feature.

Keep configuration vocabulary separate from access authority

The provider description includes authentication, but that does not make a gateway credential a general authorisation mechanism. The OpenAI Learn connection guide, undated and accessed on 13 October 2026, states that a model gateway credential does not authorise access to tools or connected systems. Administrators should therefore avoid wording such as “the new provider capability grants tool access”. The release under discussion concerns provider capability configuration, not a replacement for the organisation’s other access decisions.

Suggested handling rule. Keep secret values out of review prompts, draft examples and published change notes. If a colleague needs to review the connection structure, describe the authentication method without pasting the credential. This recommendation preserves the distinction between information needed to reason about the change and information used to authenticate a live request. Nothing in the release announcement requires exposing the latter to explain the former.

Search material needs a similarly clear boundary. OpenAI Learn’s web-search guidance, undated and accessed on 13 October 2026, treats retrieved results as untrusted input. In an administrator’s review, a page or response may be evidence to inspect, but instructions embedded in that material should not become instructions to the reviewer or assistant. A retrieved claim about compatibility is something to evaluate, not authority to modify the configuration.

To qualify the Responses-compatible route for a particular provider, client, and model, frame the record with GPT-5.5-to-GPT-5.6 Migration: Evals, Permissions, Rollback, and Sign-Off, whose operating-model passage divides work into behaviour, permissions, evidence, and named-owner sign-off and calls for representative tasks, with the input, instructions, tool permissions and expected output contract held constant. Editorially, borrow this evaluation method only; the target’s GPT-5.5 retirement discussion does not establish 0.162 provider support.

The remaining work is deliberately staged. First comes an inventory of the relevant capability surfaces and their documented limits. Then comes examination of the end-to-end contract for the intended connection. Finally, a human owner decides whether the evidence supports a controlled distribution decision. Those later tasks should not be compressed into this release announcement: the foundation establishes why they are necessary and which dated event prompted them.

For an administrator reading the news on 13 October 2026, the actionable starting point is a precise review question, not an automatic feature activation: does the organisation have enough information to evaluate the newly configurable path for its intended provider? The answer can remain unresolved while the release fact remains clear. That distinction allows a useful upgrade discussion without inventing a test result, declaring a vendor compatible or promising behaviour the official announcement does not establish.

Inventory the two capability surfaces before editing a production configuration

The immediate administrative task is to identify what is being declared, where that declaration belongs and which questions the declaration leaves unanswered. Treat this as a configuration inventory, not an instruction to enable features in production. This procedure is an editorial recommendation based on the assigned OpenAI sources, locked as of 2026-10-13; it does not report a deployment or a qualification run. Its useful output is a reviewable draft and a claim ledger, with unresolved provider behaviour kept visible rather than converted into assumed support.

Begin with a read-only copy of the relevant configuration, stripped of credentials, personal data and unnecessary internal addresses. Record the installed Codex CLI version, the selected provider identifier and the model alias separately. These are proposed inventory fields, not evidence that any feature works. If an administrator cannot identify which provider entry a user actually selects, editing a capability block is premature: the proposed change may describe a different route from the one the user intends to exercise.

OpenAI’s merged capability-override change, examined as of 2026-10-13, supplies the bounded configuration shape: model_providers.<id>.capabilities for custom Responses-compatible providers. For the inventory, replace <id> with the identifier from the reviewed configuration, not a gateway’s marketing name or an upstream model’s self-description. The scope is the stated Responses-compatible provider path; do not translate the fragment into another API shape and assume equivalent behaviour.

Record explicit values and omissions as different states

For this override, external_web_access = false prevents hosted web search from reaching the live web, while omission preserves existing provider defaults. This does not establish search availability or grant command-network access, and it does not tell an administrator what an unspecified default is for a particular provider. OpenAI’s override implementation is the source for this distinction, as examined on 2026-10-13. In the inventory, use “omitted; provider default not established” where the evidence does not identify the default, rather than substituting a guessed Boolean value. [Add capability overrides for custom model providers]

A practical editorial method is to maintain separate columns for “present in the reviewed file” and “intended in the proposed draft”. An absent line is a finding about the file, not automatically an instruction to insert one. Likewise, a reviewer’s intention to restrict a feature is not evidence that the intended entry is selected or applied. Keeping these two columns separate exposes a common ambiguity: an administrator may believe a restriction is explicit while the configuration under review merely leaves the corresponding setting unstated.

For each omitted setting, record the reason for retaining or changing that omission. Suitable hypothetical entries include “retain pending provider-default evidence” or “propose explicit value for administrator review”. Neither entry should be labelled a successful restriction test. The purpose is to make the decision legible before anyone modifies the live configuration. If the evidence is missing, the inventory should preserve that uncertainty and assign an owner to resolve it, rather than treating silence as either support or prohibition.

The documented remote-compaction values are v2, which sends compaction_trigger items through the Responses endpoint, and unsupported, which uses local compaction. Whether the actual provider accepts and handles the item still requires qualification; the source does not promise improvements in context length, cost, latency or reliability. These semantics come from OpenAI’s remote-compaction implementation description, examined as of 2026-10-13. Inventory the exact string, including whether it is present at all, without expanding this bounded list into undocumented modes or defaults. [Add capability overrides for custom model providers]

For compaction, add an evidence question alongside the requested value: “What information establishes that this provider path handles the corresponding behaviour?” This is a preparation question, not a test result. A draft can accurately express an administrator’s requested route while leaving the implementation question unanswered. Avoid adding projected savings or longer usable conversations to the change request. Such expectations would introduce claims that the supplied implementation description does not substantiate, and would obscure the narrower reason for proposing the setting.

When documenting the remote-compaction option, add a provenance-and-review entry informed by Secure Agent Compaction Summaries and Cross-Context Deception, which defines a compaction summary as shortened prior conversation, tool activity, decisions, constraints, and unresolved work, and confines reported jailbreak-like summary behaviour to unreleased Astra-family training rather than final Astra or production traffic. Editorially, that supports checking a remote handoff artefact rather than treating a declared option as sufficient evidence.

Keep standalone search in a separate inventory entry

Standalone web search for a custom provider is a separate documented opt-in: it defaults to false, remains under development and off by default, and setting it true does not itself enable search. The provider needs a compatible endpoint, and the selected model and runtime must also support standalone search; configured search mode and managed restrictions remain in force. OpenAI Developers’ advanced configuration documentation and OpenAI Learn’s web-search documentation are undated pages accessed on 2026-10-13. Their current wording must not be presented as proof that every detail was documented on the release day. [Advanced configuration: Custom model providers; Web search]

Put supports_standalone_web_search on its own line in the inventory, with its own source and unanswered questions. Do not merge it with the capability block merely because both names concern search. The administrative benefit of two entries is accountability: one reviewer can identify the requested provider declaration, while another can establish which endpoint, model and runtime are being discussed. A single “web enabled” checkbox would erase distinctions that the official documentation requires the administrator to retain.

Use six separate review fields for a proposed standalone-search path: declaration, endpoint, selected model, runtime, configured search mode and managed restrictions. In this editorial worksheet, a completed declaration field should not automatically complete the other five. For example, a hypothetical record might say “draft declaration prepared”, “endpoint evidence outstanding” and “managed policy owner identified”. Those are preparation statuses, not observations of working search. Their value lies in identifying exactly which missing information prevents a coherent feature proposal.

The search-mode field also needs an owner. An administrator proposing a provider entry may not be the person authorised to change organisation-managed restrictions. Record the applicable policy reference or a non-sensitive description of its scope, and identify the responsible human role. Do not infer that changing the provider draft changes the policy. If the proposed use depends on a restriction being altered, make that a separate approval dependency rather than quietly incorporating it into the capability edit.

Illustrative drafts: show the proposed edit without pretending it is deployable

The following hypothetical fragment uses review_gateway as an illustrative provider identifier. It is draft-only, contains no credentials and is not a complete connection configuration. It shows how a reviewer could isolate a proposed capability block from unrelated authentication and routing details. It does not establish that the identifier exists, that the installed client applies the draft or that a gateway implements either feature. The chosen values are review inputs, not reported outcomes.

# Hypothetical, illustrative and draft-only.
# Not a complete provider configuration.
[model_providers.review_gateway.capabilities]
external_web_access = false
remote_compaction = "unsupported"

A useful review annotation for this fragment would be: “Proposed entry for the provider identifier under review; compare with the selected provider before any edit.” That wording keeps the job bounded. The reviewer should inspect the difference between the existing file and the draft, including whether an existing table is being amended or a new one proposed. Do not append a second block blindly to a production file. This article has not established the surrounding configuration or validated its syntax in a particular installation.

The next hypothetical fragment represents a different proposed draft, not an addition to the first. It illustrates the remote option discussed in the implementation source. Keeping alternatives separate prevents a review document from looking like a complete file containing competing declarations. A reviewer should retain only the relevant candidate in the eventual change proposal, after the provider identity and the intended scope have been checked.

# Hypothetical alternative; illustrative and draft-only.
# Do not combine blindly with the preceding fragment.
[model_providers.review_gateway.capabilities]
external_web_access = false
remote_compaction = "v2"

For standalone search, use a separate draft excerpt so its source is apparent. The example below illustrates the provider-level setting described by the current advanced configuration documentation. It deliberately omits a base address, authentication fields and model selection: those details belong to the reviewed environment and should not be invented to make an excerpt appear complete. The accompanying review question is whether this declaration merits further investigation for the intended endpoint, model and runtime.

# Hypothetical standalone-search proposal.
# Illustrative, draft-only and incomplete.
[model_providers.review_gateway]
supports_standalone_web_search = true

Do not use these excerpts as substitutes for the actual configuration review. A proposed table name should be reconciled with the provider identifier already recorded, and every proposed setting should be tied to its source. Keep secrets out of prompts, excerpts and review comments; use non-secret identifiers for discussion. If a reviewer needs authentication context, record the responsible credential-management role or reference without copying a credential into the draft. These are editorial handling recommendations, not claims about the protection provided by the product.

Separate hosted search from command and integration connectivity

OpenAI Learn’s undated web-search guide, accessed on 2026-10-13, distinguishes the hosted search tool from sandboxed local command networking. It describes cached search as using an OpenAI-maintained index rather than fetching arbitrary pages live, and identifies live search for work dependent on current information. For this inventory, record the intended information source and search mode without treating either as a description of shell traffic. A request for current information and permission for a local command to contact a host are different administrative questions.

During the hosted-web check, keep browser access out of the provider capability conclusion by contrasting it with ChatGPT Browser Extension Controls for Chrome, Edge, Brave, Opera, and Vivaldi, which describes a local Chrome-family integration subject to confirmation prompts, website permissions, workspace settings, and browser-level extension permissions, with a documented feature difference for Opera side chat. Editorially, this distinction prevents the administrator from treating browser-profile access as hosted web-search evidence.

Create a separate connectivity note for shell commands and for Model Context Protocol (MCP)A protocol for connecting artificial intelligence applications with tools and data sources through defined interfaces. Open glossary entry servers, apps, connectors or browser integrations relevant to the intended workflow. The purpose is to stop reviewers attributing permissions from one surface to another. The web-search guide states that search-domain filters do not govern command traffic, apps, connectors or MCP servers. Therefore, do not describe a hosted-search restriction as a sandbox network-proxy rule or use a search-domain list as evidence of restrictions on those other connections.

OpenAI Learn’s undated gateway connection guide, accessed on 2026-10-13, also says a model gateway credential does not authorise access to tools or connected systems. In an inventory, the useful consequence is to give those systems their own owner and permission reference. A hypothetical record could state “MCP connection reviewed separately by the integration administrator”; it should not state “covered by gateway capability settings”. No claim about the actual integration’s availability follows from either note.

Search material itself also needs a handling note. The web-search guide treats web results as untrusted input. As an editorial procedure, mark retrieved text and supplied configuration excerpts as data to be examined, not instructions to follow. A page asking an operator to reveal a credential or alter restrictions should not become part of the configuration procedure. When source material informs a consequential operational decision, the named human reviewer remains responsible for evaluating that material and approving the action.

Build a claim ledger that exposes provider-specific unknowns

The ledger below is a proposed editorial template, not an OpenAI certification form. It links each configuration statement to the kind of evidence that supports it, while keeping the missing provider-specific information in a dedicated column. References to earlier paragraphs avoid duplicating their field semantics. Populate the ledger with the exact reviewed entry and a source access date; do not turn a documentation citation into a “passed” status for a gateway that has not been assessed.

Give every unknown a precise question rather than a broad “compatibility pending” label. “Which runtime is selected?” can be answered by configuration evidence; “does that runtime implement the requested feature?” requires different evidence. Splitting the questions prevents an inventory update from appearing to resolve behaviour simply because a name has been supplied. Similarly, distinguish a model alias from the upstream model it is intended to represent. At this stage, both can be recorded without claiming that routing has been verified.

Add a provenance note when evidence comes from current documentation rather than the release or implementation change. A hypothetical ledger entry could read: “Current documentation statement; undated; accessed 2026-10-13; not attributed to the release-day text.” This protects the news account’s chronology while allowing the administrator to use the current guidance. If two sources answer different questions, retain both instead of forcing one to support the other. An announcement, a field description and a present-day operational condition serve different evidential purposes.

End the inventory with a reviewed proposal, not an enablement claim

The recommended hand-off is a compact package: the sanitised current excerpt, one proposed draft, the ledger and a list of unresolved questions with responsible roles. Mark the draft as unapproved until a named administrator has reviewed its consequences. For an illustrative organisation, that role might be “gateway change owner”; the actual record should identify the accountable person through the organisation’s normal process. Preparing this package does not authorise production distribution or decide whether an optional feature should be enabled.

Before handing it over, check that no statement silently crosses from intent to outcome. “Proposed declaration” is different from “supported feature”; “source documents this value” is different from “our route handles it”. Remove unsupported claims about better performance or broader access, and leave unresolved defaults visible. The next assessment can then examine the relevant end-to-end contract using a clearly identified combination. This inventory’s narrower achievement is to make that assessment possible without confusing configuration vocabulary, effective permissions and evidence of behaviour.

Why a capability declaration is not evidence: the documented end-to-end contract

The administrator’s next question is not whether a capability flag appears in a configuration file, but what evidence would establish that the intended request survives the complete path. That path includes the installed Codex CLI, the gateway build, the selected model alias, the upstream model and the intervening transport. This chapter compares OpenAI’s documented assessment criteria; it is not a benchmark or a hands-on comparison. No gateway was exercised for this article, and the criteria below imply no pass rate, performance advantage, price difference or availability finding.

A provider declaration, a health check, a /v1/models response, a Chat Completions reply or one plain-text response is insufficient proof of Codex gateway compatibility. For the API and provider-credential gateway path, OpenAI specifies POST /v1/responses; a working Anthropic Messages endpoint also does not establish Responses compatibility. Nor does a generic gateway connection automatically inherit built-in-provider metadata adjustments. These boundaries come from OpenAI Developers’ gateway compatibility requirements and OpenAI Learn’s gateway rollout guide, both undated and accessed 2026-10-13. They describe the current assessment boundary, not a retrospective statement that every requirement appeared on release day. [Gateway compatibility requirements; Roll out a gateway]

Editorial recommendation: treat each preliminary response as evidence for the narrow question it answered. A health response can inform an investigation into reachability; a model listing can inform an investigation into advertised names. Neither should be promoted into evidence about conversation state or tool execution. Record the original question beside the observation so that a later reviewer cannot mistake “the service answered” for “the proposed Codex workflow is supported”. This distinction matters when connection troubleshooting and feature qualification are performed by different teams.

Define the assessment unit before comparing evidence

Suggested assessment method: create one record for one exact client-version, gateway-build and model-alias combination. Include the client surface developers will actually use, the intended route, the resolved upstream model and any relevant model-catalogue revision. OpenAI Learn’s undated rollout guide, accessed 2026-10-13, directs administrators to use the same CLI or desktop surface as developers. For this article’s CLI-focused reader, an observation from a separate HTTP utility should therefore remain supplementary evidence rather than a substitute for the intended client path.

A useful hypothetical record heading would read: “Codex CLI 0.162.0; gateway build under review; internal model alias under review; upstream mapping pending confirmation.” This is an illustrative record, not a deployment description or a claimed result. Leaving the mapping pending makes the missing evidence visible. Filling it with the model’s own conversational self-description would obscure the question: which upstream route actually handled the request? The record should distinguish an administrator-supplied label from a route supported by gateway records.

Keep configuration identity separate from evidence identity. The former describes the proposed settings; the latter identifies the requests, responses and gateway records used to assess them. A reviewer needs to know whether an observation belongs to the same build and alias mapping as the proposal. A copied transcript without that association may be useful for debugging, but it cannot answer a version-specific compatibility question. This is an editorial evidence-management recommendation, not a claim that Codex generates such a record automatically.

A documentation-led assessment matrix

OpenAI’s documented qualification boundary requires incremental Server-sent events (SSE)A mechanism through which a server sends new data to a web page as messages over an established connection. Open glossary entry with response.completed, continuation with replayed input (and previous_response_id when the selected transport uses it), and a full function-call/result/final-answer loop. These streamed events must have their delivery examined, rather than inferred from a finished answer. The assessment must concern the actual client, gateway and model combination proposed for use; acceptance of a request field alone does not establish upstream implementation. These requirements are documented in OpenAI Developers’ compatibility requirements and OpenAI Learn’s rollout guide, both undated and accessed 2026-10-13. [Gateway compatibility requirements; Roll out a gateway]

The following matrix is an editorial assessment template derived from those two sources. Its evidence questions are proposed ways to organise review, not instructions that were executed for this article. Each row remains independent: a convincing observation in one row does not settle the others. The “unresolved” column explains what an administrator should avoid concluding from incomplete evidence.

Use the matrix as a map of missing evidence, not as a scorecard. Counting completed rows would create a misleading impression that several strong observations can compensate for an absent essential behaviour. A streaming record cannot compensate for a lost tool result, for example. The reviewer’s job is to identify which contract surfaces the proposed workflow depends on and which remain unexamined; the later distribution decision belongs to a named human owner, not to an aggregate percentage.

Read the request shape, not just the answer

The request-shape row concerns what crossed each boundary. OpenAI Developers’ undated compatibility requirements, accessed 2026-10-13, make upstream capability support a separate question from gateway acceptance. An administrator should therefore ask for evidence that distinguishes client submission, gateway handling and upstream interpretation. These are different points in the path. If the only retained artefact is the final prose, the reviewer cannot determine which request items were preserved or whether the intended feature was exercised.

Hypothetical failure — an accepted field without implementation: imagine an upstream service accepts a feature-related request item without returning an error, but does not perform the corresponding operation. This is an illustrative failure mode, not an allegation about any provider. The resulting text could look ordinary while offering no evidence about the declared capability. The assessment question is therefore not simply “was the request accepted?” but “what record shows that the intended operation was handled?” If that record is absent, mark the capability unresolved rather than inferring support from silence.

For the newly configurable feature paths, keep this distinction attached to the relevant operation. Search evidence should identify the search behaviour under assessment; compaction evidence should identify the compaction path under assessment. Neither should borrow credibility from a successful unrelated request. This chapter does not prescribe how to enable those operations or claim that a particular upstream implements them. It establishes why baseline Responses evidence and feature-specific evidence must be recognisable as different entries.

Separate stream delivery from stream termination

Hypothetical failure — a proxy buffers the complete answer: suppose an intermediary receives successive upstream events but withholds them until the response is finished. The user eventually sees coherent text. That visible answer does not resolve the incremental-delivery row, because it says nothing about when the client received the events. No vendor is claimed to behave this way here. The example illustrates why an assessment must examine the stream at the receiving client, not merely trust an upstream declaration that streaming was requested.

Suggested evidence format: retain a redacted event-order record showing the client-facing progression and its ending. Record enough context to associate it with the assessed request, without retaining credentials or unnecessary prompt content. Do not turn this into a latency benchmark: the question here is whether delivery is incremental, not whether one route is faster than another. If observations exist only on the upstream side of an intermediary, state that limitation explicitly rather than assuming equivalent downstream delivery.

For the incremental-response record, separate streaming evidence from user steering and use Codex CLI 0.159 Opt-In Instant Interrupt and Sandbox Guardrails, whose release-change table says opt-in instant_interrupt lets new input steer a response or long-running code-mode call, while warning it does not prove default enablement, safe interruption, rollback, or correctness. Editorially, record those observations separately so an interaction control is not mislabelled as custom-provider streaming support.

Termination deserves its own evidence entry because a stream can produce useful text yet leave the client without the expected completion signal. Conversely, a recognisable ending says nothing by itself about whether earlier content arrived progressively. Keep both observations in the same request record, but do not merge their meanings. This makes it easier to locate a disagreement between a client transcript and gateway event records without describing every interrupted or incomplete interaction as a model failure.

Inspect continuation as structured history

A follow-up assessment should ask what information the second turn requires from the first. A vague conversational follow-up may be answered plausibly even when part of the prior state is absent. As an editorial method, define a bounded dependency that the reviewer can identify in the retained conversation record. The purpose is not to assess general reasoning quality; it is to establish whether the relevant prior material is present on the continuation path.

Hypothetical failure — the follow-up loses tool-result history: imagine that an initial interaction produces a function result, but the next request omits that result from the replayed conversation. The model may still generate an answer, yet the assessor lacks evidence that it used the intended history. This is not a reported gateway defect. The useful review action is to trace the missing item across the client and gateway records, rather than judge compatibility from whether the follow-up sounds confident or fluent.

For previous_response_id, the limiting phrase is “when the selected transport uses it”. Do not require an identifier-based artefact from a path that does not use that mechanism, and do not treat replay evidence from one path as proof for another. A proposed record should name the transport and explain which continuation mechanism is being assessed. If the mechanism is uncertain, resolve that uncertainty before interpreting the observation; otherwise, a reviewer may ask for the wrong evidence or overlook a relevant state dependency.

Follow the tool loop across its boundaries

The function-call row needs linkage, not simply a list of tool-related messages. A useful editorial evidence structure connects the call identity and arguments to the corresponding result, then identifies the final response associated with that result. This allows a reviewer to distinguish a model’s request to perform an action from the action’s execution and from the model’s subsequent use of its output. Each stage answers a different question; none should be silently inferred from another.

Permission to execute is a separate boundary. OpenAI Learn’s undated provider-credential connection guide, accessed 2026-10-13, states that a model gateway credential does not authorise access to tools or connected systems. An assessment record should therefore describe the scope of the tool interaction without implying that gateway configuration granted that scope. Consequential actions require human review and appropriate authorisation; an assistant’s generated function call is not an approval decision.

Tool arguments and results may contain information that is inappropriate for a broadly shared compatibility report. As an editorial recommendation, retain only the structural detail needed to connect the stages, with a human reviewer checking redactions before export. Removing every identifier can make the loop impossible to audit, while keeping full payloads can disclose unnecessary data. The evidence design should resolve that tension deliberately; it should not ask users to paste credentials or sensitive operational material into prompts.

Verify the resolved route and its metadata

Hypothetical failure — an alias maps to a different upstream model: imagine an internal alias remains unchanged while the gateway routes it to a different upstream model. A configuration review based only on the alias would miss the change. This is an illustrative routing risk, not an observed deployment. The assessment should reconcile the requested alias with the resolved route using gateway records. Asking the model to name itself would not resolve the discrepancy.

OpenAI’s undated rollout guide, accessed 2026-10-13, notes that custom aliases may require a matching version-specific model catalogue. The practical editorial question is whether the catalogue describes the model actually reached, rather than merely the label presented to the user. Record any unresolved mismatch as a metadata issue. Do not assume that metadata associated with a familiar built-in model name will be applied correctly to a custom alias.

Route evidence also bounds the lifespan of the assessment. If an alias can resolve differently after a gateway change, an old record should not be read as evidence for the new mapping. This does not require inventing a universal expiry period. Instead, the record can identify the route and build it covers, allowing the responsible administrator to recognise when a later proposal falls outside its scope. The subsequent chapter addresses the human decision about distribution; here the task is to make the scope intelligible.

Keep authentication and failure causes distinguishable

OpenAI Developers’ undated compatibility requirements, accessed 2026-10-13, include authentication and useful error behaviour in the gateway assessment. These are not cosmetic details. A reviewer needs to understand whether a failure concerns credentials, routing, a request or an upstream capability, rather than treating every unsuccessful interaction as the same incompatibility. The source establishes the assessment category; the reporting structure below is an editorial recommendation.

A proposed error record can contain the assessed combination, the intended operation, a redacted response description, the apparent boundary at which it failed and any remaining uncertainty. Keep “apparent” where the evidence is incomplete. A client-visible error alone may not identify the component that caused it. Conversely, a gateway-side explanation should be connected to the same client request before it is accepted as the explanation for that interaction. Do not invent expected error codes or promise that every gateway will expose equivalent diagnostic detail.

Credential attribution should use a non-secret identifier in the report, not the credential value. The human administrator responsible for access should be able to check that the intended identity was used, while readers of the compatibility assessment should not receive reusable secrets. Authentication evidence does not settle access to separate integrations, and it is not a security certification. Its narrower purpose here is to make the model-request path attributable and its failures interpretable.

Place hosted search evidence on the correct boundary

Hosted Codex web search is distinct from sandboxed local command networking; cached search uses an OpenAI-maintained index, while live search is configured for current-information work. OpenAI Learn’s undated web-search documentation, accessed 2026-10-13, also treats web results as untrusted input. Provider capability configuration must not be presented as changing network permissions for shell commands, MCP servers, apps or connectors. Search-domain filters likewise must not be interpreted as governing those separate traffic paths. [Web search]

That distinction changes the evidence question. A successful local network command would answer a question about that command’s environment, not about the hosted search operation. For a search-dependent assessment, a reviewer should identify the intended search mode and the applicable managed restrictions alongside the relevant feature evidence. This is a proposed reporting method, not a claim that search is available for the assessed combination. Retrieved text remains data to evaluate, not instructions to alter configuration, reveal credentials or override the administrator’s review boundary.

The completed matrix should leave the reader with a precise account of what is documented, what has yet to be demonstrated for the proposed combination, and which evidence would resolve each gap. It should not end with an automatic approval based on fluent output. A named human administrator must review consequential configuration choices and any resulting access implications. The next stage is the bounded qualification and distribution decision; this stage supplies the contract against which that decision can be reasoned about.

A controlled qualification decision: prove one combination, then decide whether to distribute

OpenAI recommends recording evidence for each deployed client, gateway and model combination and verifying the route with a real Responses request and gateway records; its compatibility requirements also cover authentication and useful errors. This is a recommended controlled qualification run, not a claim that this research performed one. The basis is OpenAI Developers’ Gateway compatibility requirements and OpenAI Learn’s Roll out a gateway, both undated and accessed 2026-10-13. For custom model aliases, align the alias and version-matched catalogue metadata with the deployed upstream model. The operational question is whether a particular proposed configuration has enough evidence for a bounded deployment, not whether a gateway deserves a universal compatibility label. [Gateway compatibility requirements; Roll out a gateway]

Editorial recommendation: turn the assessment criteria from the preceding chapter into a small, reviewable qualification package. Give it a defined scope, a responsible administrator and an explicit stopping point. The package should describe the intended client, the route it will use, the baseline behaviours to inspect and any optional capabilities being considered. Do not begin by distributing capability settings to users and then treating their absence of complaints as evidence. A controlled run should produce material that another authorised reviewer can inspect before approving a pilot.

The procedure below is an editorial adaptation of OpenAI’s documentation, locked as of 2026-10-13. It is neither an executed test report nor a promise about any provider. It deliberately separates baseline gateway qualification from optional search and compaction qualification. That separation allows an administrator to decline an optional feature without obscuring a useful baseline finding, or to reject the entire proposed combination when the underlying connection cannot be adequately evidenced.

Prepare a bounded run with a named owner

Recommended preparation: nominate a human operational owner before issuing a test credential. That person should approve the test scope, identify who may inspect the records and decide whether any resulting configuration can leave the test environment. A separate reviewer can examine the evidence, but responsibility should not disappear into a shared channel or an automatically generated report. Decisions affecting developer access, data handling or production configuration require human review; an assistant may organise observations but should not sign the deployment decision.

Use an isolated test environment and a credential scoped to the intended qualification work, where the organisation’s credential controls permit that scope. Record a non-secret credential reference and its authorised purpose, not the credential value. Keep secrets out of prompts, configuration examples, repositories and exported evidence. Before the run, identify how the credential will be withdrawn and who can perform that action. Isolation and scoping are recommended controls here, not assertions that every gateway offers identical credential-management features.

Select the exact surface that the intended users will run. For this release assessment, record the installed Codex CLI version rather than merely writing “Codex”. If a desktop client is also proposed, give it a separate evidence entry rather than assuming the CLI result transfers. Include the operating environment, relevant configuration revision and gateway build or deployment identifier. These details make later disagreement tractable: the reviewer can distinguish a change in the client from a change in the gateway instead of comparing two vaguely described “working” installations.

Record the provider identifier, requested model alias, expected upstream model, transport and route before sending the first request. Identify which authorised gateway records can confirm the resolved route. Do not ask the model to identify itself and use that answer as routing evidence. If the alias resolves dynamically, document the rule and the resolved destination for the run. An alias whose meaning can change without a configuration edit needs a change-control trigger of its own, because yesterday’s evidence may no longer describe today’s request.

Suggested evidence layout: create separate entries for the proposed configuration, baseline observations, optional-capability observations, unresolved questions and the human decision. Each observation should identify the request or session it concerns, the evidence location and the reviewer’s interpretation. Store sensitive source material only in the organisation’s approved evidence system; put a redacted reference in the review record. This layout is illustrative. Its purpose is to prevent a configuration declaration, an observed response and an approval from being compressed into one ambiguous “passed” field.

Run the baseline without optional capabilities

The official connection guide intentionally disables web search in its initial gateway connection example and says feature support should be verified before enabling it; its simple response test does not settle streaming, tools or follow-up behaviour. This is an explicit staged-testing recommendation from OpenAI documentation, not evidence that search is unavailable for all custom providers. The source is OpenAI Learn’s undated Use API/provider credentials through a gateway, accessed 2026-10-13. Following that staging keeps the first investigation focused on the connection rather than mixing route, authentication and optional-feature questions into one request. [Use API/provider credentials through a gateway]

Recommended first check: send a small, non-sensitive request from the selected client surface, then correlate it with the authorised gateway records. A hypothetical prompt might be “Reply with the word connected”. No particular response is claimed here. The evidence question is whether the expected credential attribution and route can be associated with this request, and whether the intended client receives a usable response. If the route cannot be established, pause the qualification even if the answer looks correct; otherwise subsequent observations may concern an unintended upstream destination.

Next, inspect a streaming request through the normal proposed routing path. In the observation record, separate what the client displayed from what the gateway forwarded. Use the documented server-sent events (SSE) criteria from OpenAI’s rollout guidance as the inspection target: incremental delivery and the terminal response.completed event. Record the event evidence available to the reviewer without inventing a latency threshold. If instrumentation cannot distinguish an incremental stream from a buffered answer, mark the check unresolved rather than inferring the transport behaviour from a plausible-looking final response.

For the local tool check, prepare a disposable directory containing only a harmless synthetic text file. Hypothetical example: the file contains a short list of colour names, and the prompt asks Codex to read it using an authorised read-only local operation and report the list. The administrator should approve the directory and operation before execution. Do not include production files, credentials or personal data. This example narrows the task sufficiently to examine the tool cycle without turning the qualification run into a general exploration of the workstation.

Inspect the whole tool interaction, not just the final list. Preserve a redacted trace showing the requested function, its identifier, the corresponding tool result and the final response that follows it. Distinguish a proposed call from an executed operation, and distinguish execution from successful submission of its result. Local permission approval remains a separate human-controlled boundary: the existence of a model gateway credential does not grant permission to run arbitrary local actions. A missing link in this trace should remain an explicit open issue.

Follow that interaction with a second turn whose answer depends on the synthetic file result. A hypothetical follow-up could ask for the same list in reverse order without rereading the file. Inspect whether the relevant earlier input and tool result are preserved across the follow-up, including previous_response_id where the selected transport uses it. The proposed check concerns continuation, not the model’s ability to guess a short list. If the answer happens to be plausible but the retained history cannot be inspected, the record should state that limitation.

Then conduct bounded negative checks using deliberately invalid test material, not a real credential belonging to another person. Try an invalid credential and, separately, an invalid model alias within the isolated scope. Record whether the evidence lets an administrator distinguish authentication failure from model-selection or routing failure. Avoid copying raw credential-bearing headers into the report. The purpose is to establish whether failures are operationally interpretable, not to provoke production incidents or claim that any particular error wording is guaranteed.

Stop when a baseline requirement remains unsupported or an unexpected route appears. Preserve the diagnostic evidence, withdraw the test credential if appropriate and assign the unresolved question to a human owner. Repeating requests without changing the investigation can generate more data without resolving the cause. A useful stopping record identifies which stage could not be evidenced, which configuration was active and what additional inspection would be needed before resuming. It does not convert an unexplained failure into a broad claim that the provider can never work.

Review evidence handling before widening the scope

Recommended review: inspect what the run has placed in client and gateway records before inviting more users. Prompts, synthetic file contents, tool arguments, tool results and any later search excerpts may appear at different points in the path. Ask the responsible administrator which records exist, who can access them, how long they are retained and whether they can be exported. This is a data-handling review, not a security certification or a legal conclusion. Unanswered retention questions should be visible in the operational decision.

Redaction should preserve the relationships needed for diagnosis. For example, consistently substituted request identifiers can still let a reviewer match a tool call to its result without exposing the original identifiers or unrelated session content. Remove credentials and unnecessary personal information before sharing the package. If redaction removes the evidence needed to establish routing or continuation, keep the full material in the approved restricted location and have an authorised reviewer examine it there. Do not make a stronger claim than the retained evidence supports.

Add search and compaction only as separate extensions

Optional extension recommendation: consider search or remote compaction only after the baseline checks have sufficient evidence. Open a distinct extension entry for each capability, with its own proposed configuration, evidence question and approval boundary. Consult OpenAI Developers’ undated Advanced configuration: Custom model providers and OpenAI Learn’s undated Web search, both accessed 2026-10-13, alongside the release-linked implementation. This keeps current documentation visibly separate from the dated release artefacts; it does not imply that every current documentation statement appeared on release day.

For search, retain the configured mode and the applicable managed restrictions as part of the evidence package. Record who has authority to change them and whether the proposed test is intended to exercise live or cached behaviour. Choose a non-sensitive information task with an explicit freshness requirement if live retrieval is the subject of qualification. Inspect the actual tool path and available request records rather than treating a confident answer about recent information as proof of retrieval. A correct-looking answer alone does not identify how the information was obtained.

Keep hosted and standalone search observations separate where both are under consideration. In each entry, ask whether the actual provider, selected model and runtime handle the declared path, and what evidence supports that answer. A setting such as supports_standalone_web_search is configuration evidence, not execution evidence. Treat returned pages and excerpts as untrusted data: any instructions within them are material to analyse, not authority to change the test or reveal information. A human reviewer should verify consequential conclusions drawn from those sources.

For remote compaction, identify in advance how an authorised reviewer would recognise that the declared path was exercised and handled. Use non-sensitive synthetic conversation material, and retain the relevant request-item and subsequent-continuation evidence if the run reaches that path. The implementation reference is OpenAI’s release-linked pull request, Add capability overrides for custom model providers. Merely accepting a configuration value or request item is not enough. If the path cannot be observed, record “not demonstrated” rather than claiming success or inventing a way to force it.

Do not attach context-length, cost, speed or reliability benefits to the compaction extension. Those are separate questions requiring their own evidence, and this documentation-led article provides none. The narrower decision is whether the intended interaction is supported for the recorded combination and whether the administrator has sufficient visibility to approve its limited use. A completed baseline run can remain valuable even when that optional question cannot be answered.

Recommended failure rule: if capability evidence is incomplete, leave the optional capability disabled or return to an explicitly reviewed capability-disabled configuration. Do not assume that deleting an override creates the intended restriction; review the resulting configuration rather than guessing the provider’s defaults. Define who may authorise another attempt and what new evidence would justify it. This is an editorial fail-closed procedure, not a claim that Codex automatically performs this rollback or enforces the organisation’s decision.

A hypothetical go/no-go record for the human decision

The following is a hypothetical decision template, not a deployment record or an observed result. A proposed organisation could use it to make the distinction between baseline qualification and optional capability qualification explicit. Leave outcome fields undecided until the evidence has been reviewed. The operational owner’s name and approval date belong in the organisation’s controlled record, not in a public article or a prompt containing other sensitive material.

Assessment identity

Exact client surface and version; configuration revision; gateway deployment identifier; provider identifier; model alias; resolved upstream model; route; transport; matching catalogue revision where applicable.

Baseline evidence

References for connection attribution, streaming, the read-only tool cycle, follow-up history and separate invalid-credential and invalid-alias checks. Record unresolved items individually.

Optional evidence

Separate search and remote-compaction entries, including proposed declarations, search mode and restrictions, observed path evidence and limitations. “Not attempted” and “not demonstrated” are valid descriptive entries, not passes.

Data-handling review

Approved evidence location, redaction review, access responsibility, retention decision and any outstanding questions about records or exports.

Operational decision

One of the three outcomes below, signed by the named human owner, with the authorised scope and any excluded capability stated explicitly.

• qualified for limited pilot — the owner judges the evidence sufficient for the specifically recorded pilot scope. State which capabilities are included, which users or test group are covered and what observations would stop the pilot. This is a local operational decision, not a vendor certification.
• baseline works but capability unqualified — baseline evidence is sufficient for the owner’s bounded purpose, but search, remote compaction or both lack adequate evidence. Record those capabilities as excluded from the authorised configuration rather than silently carrying them into the pilot.
• not qualified — the evidence is insufficient for the proposed baseline or the unresolved issues prevent approval. Identify the blocking questions and the responsible investigator without implying that every other client, model or route would have the same result.

For a worked decision question, imagine that the reviewer has baseline evidence but cannot establish whether the intended remote-compaction path occurred. No outcome is asserted for this hypothetical case. The owner should ask whether a capability-disabled pilot is within the approved scope; if so, the second outcome describes that boundary more accurately than an unrestricted approval. If optional compaction is essential to the proposed use, the missing evidence may instead prevent approval of that proposal. The requirement, not enthusiasm for the upgrade, determines the decision.

Distribute only the reviewed configuration, then requalify changes

Before distributing a custom-provider configuration, set the secret-handling and non-production canary boundary with Codex CLI 0.158 Guidance on OAuth Client Secrets and WebSocket Bearer Tokens, which describes Model Context Protocol support for pre-registered authentication clients configured with a client-secret option and bearer-token protection for direct exec-server WebSocket connections, alongside redacted configuration evidence and multi-operating-system canary guidance. Editorially, apply that distribution discipline without inferring that the gateway itself supports any 0.162 capability.

Recommended distribution boundary: the signed decision should refer to the exact configuration revision proposed for distribution, including the matching custom model catalogue where applicable. Pin the Codex version under assessment to 0.162.0 rather than describing it as “latest”. Retain the catalogue identity and alias mapping beside it. Before distribution, compare the artefact users will receive with the reviewed artefact so that an unrelated edit, optional flag or changed alias does not enter under the earlier approval.

Store evidence by the full assessed combination, not just by gateway name. A practical record index can associate the client version, gateway deployment, model alias, upstream model, route and policy revision with the decision. Keep the optional-capability entries attached to that same combination. This makes a later administrator’s question answerable: “Does this evidence describe the configuration I am about to deploy?” It also prevents one successful investigation from becoming an undocumented permission to enable the capability on other models.

Define requalification triggers before the pilot begins. Recommended triggers include a client update, gateway transformation change, alias remapping, upstream model change, catalogue change or relevant search-policy change. Review the affected checks again rather than assuming all earlier observations survive. Preserve the old decision so that rollback has a known reference, but do not portray that reference as proof of behaviour under newly changed infrastructure. Assign a human owner to authorise both the update and any return to the earlier reviewed configuration.

The release’s operational value is therefore bounded by the administrator’s evidence and decision process. The new vocabulary can be evaluated without being mistaken for an implementation guarantee. A useful closing upgrade record states what configuration was reviewed, what paths were actually evidenced, what remains disabled and who approved the resulting scope. Keep those recommendations separate from OpenAI’s documented product behaviour, and keep the decision narrow enough that a later change can be identified and reassessed.

Useful Links

• Release: 0.162.0 — the dated release reference.
• Add capability overrides for custom model providers — implementation-level configuration evidence.
• Advanced configuration: Custom model providers — provider configuration and capability conditions.
• Web search — search modes and restrictions.
• Gateway compatibility requirements — the documented assessment boundary.
• Roll out a gateway — controlled rollout checks.
• Use API/provider credentials through a gateway — initial connection guidance; API means application programming interface.