Configure ChatGPT Work and Codex Starting Defaults: Models, Reasoning, Fast Mode, Roles, Local Access, and Cloud Access

Start by separating the experience from the entitlement

OpenAI’s current ChatGPT Work and Codex administration model separates three concepts that are easy to blur during rollout: the product surface a user starts in, the default configuration applied when that surface opens, and the permissions that decide whether the user can actually use the selected model, mode, local capability, cloud capability, browser access, network access, or connected app. This tutorial treats starting defaults as governance and user-experience controls, not as licenses, entitlements, or bypasses around workspace policy.

For this tutorial, Chat means the standard ChatGPT conversation experience where users ask questions, draft content, analyze information, or use configured tools through the ordinary chat interface. OpenAI states that Chat has a separate starting default from Work and Codex, so administrators should not assume a model or reasoning choice for Work and Codex automatically changes the default experience for ordinary Chat sessions.

Work is the ChatGPT mode OpenAI describes for longer multi-step work and finished deliverables. In practical workspace terms, Work is where an employee might ask for a project plan, a policy comparison, a requirements draft, a spreadsheet-style analysis, or a longer synthesis that benefits from a more deliberate starting posture. Work can be available on supported web, mobile, and desktop surfaces, but individual features inside Work still depend on plan, role, permissions, connected-app authorization, and workspace controls.

Codex remains dedicated to software development and technical work. OpenAI describes Codex as separate from Work, including a separate desktop view and history. Codex is not selectable on web or mobile, although OpenAI notes that supported desktop Codex chats may be accessed through the mobile Remote tab. That distinction matters for administrators because “make Codex the default” is not the same request as “give every developer access to local repositories, networked commands, GitHub-triggered work, or unrestricted coding automation.”

This guide compares Chat Mode, ChatGPT Work, and Codex in the unified ChatGPT app, explaining their feature differences, use cases, and productivity workflows. The complete The Complete Guide to ChatGPT Work Mode vs Codex Mode — When to Use Each, Feature Differences, and Productivity Workflows article provides the destination-specific detail for this section’s ChatGPT Work vs Codex decision because it directly contextualizes the distinction readers need before configuring starting defaults separately for Work and Codex.

Operational rule: A starting default can choose the initial posture for eligible users, but it does not grant access to a model, feature, permission, connected source, local file path, network destination, or workspace capability that the member’s plan, role, workspace policy, or app authorization does not already allow.

What workspace owners and admins can configure

OpenAI’s ChatGPT Work and Codex help article says workspace owners and admins can configure Work and Codex starting defaults under Workspace settings → Models. The configurable starting posture includes the starting model, reasoning level, speed, Fast Mode availability, and new-chat behavior for Work and Codex. The same article also makes clear that Chat has a separate starting default, so an administrator should plan two configuration tracks: one for ordinary Chat and one for Work and Codex.

The administrator’s first decision is whether the default should optimize for consistency, speed, deliberation, cost control, supportability, or a narrower pilot. A product organization might start Work with a more deliberate reasoning posture for product-requirements documents, while a support operations team might prefer a faster starting posture for routine draft replies. A development organization might leave Codex more conservative at first if local repository access, network access, or approval policy is still being validated.

Fast Mode should be treated as an availability and workflow control, not as a universal promise of faster completion for every task. OpenAI identifies Fast Mode availability as part of the Work and Codex starting-default configuration, but the actual user experience remains bounded by plan, model availability, workspace policy, and the task surface. Administrators should therefore decide who should see Fast Mode, which workflows should start there, and when users should be trained to move to a more deliberate reasoning level for high-risk or complex work.

Reasoning level should be documented in task language rather than marketing language. For example, a default that favors speed may be appropriate for routine formatting, summarization, and first-draft work; a more deliberate default may be appropriate for contract comparison, architecture review, complex debugging, or multi-source synthesis. The configuration should not rely on users typing “think harder” as a governance mechanism; the starting posture should be explicit, teachable, and testable.

Why starting defaults are governance controls, not entitlements

A starting default changes what an eligible user sees first. It does not change what the user is entitled to use. If a member’s role, workspace configuration, plan, or model access does not permit a capability, selecting that capability as a starting default for a broader population should not be treated as a grant. OpenAI’s documentation is explicit that a starting default does not grant access to a model or feature unavailable to the member’s role.

This distinction is important for auditability. A workspace owner may configure Work and Codex to start with a particular model and reasoning level, but an auditor will still ask which groups could use Work Cloud, which users could use Work Local, whether Codex Local was enabled, whether browser and network access were permitted, and which connected apps could trigger or enrich tasks. The starting default is only one row in the control matrix.

It is also important for user support. If a user reports that they “do not see the default,” the cause may be role-based access, model availability, interface differences, workspace policy, unsupported surface, plan eligibility, or local desktop configuration. Administrators should train support teams to diagnose the entitlement and surface first, rather than repeatedly changing the default and expecting unavailable controls to appear.

This article provides workspace-admin prompts for planning model access, group provisioning, Codex audits, key rotation, and approval checks. The complete 25 ChatGPT-5.5 Prompts for OpenAI Workspace Admins: Model Access, Group Provisioning, Codex Audits, and Key Rotation article provides the destination-specific detail for this section’s OpenAI Workspace RBAC decision because it is the closest fit for role- and group-based administration because it focuses on model access, provisioning, audits, and admin governance.

Build a current-state inventory before changing defaults

Before changing any Work or Codex starting default, create a current-state inventory. The inventory should capture what users can access today, which controls are separate, which settings are inherited from workspace policy, and which workflows depend on connected apps or local desktop access. This step prevents a common rollout error: changing the model or reasoning default while overlooking the separate permission that actually controls the user’s task.

Document local, cloud, browser, and network boundaries separately

Local and cloud language deserves special care because it affects user expectations, privacy review, endpoint management, and incident response. OpenAI distinguishes Work Cloud, Work Local, and Codex Local as separate workspace permissions. An administrator should not summarize these as a single “agent access” switch in policy documents, because each permission can affect different users, surfaces, device assumptions, and support procedures.

For Local Work, explain the boundary in plain operational terms: the desktop app can use user-approved local files, but messages and task context may still be stored in the cloud. That means Local Work is not equivalent to an offline-only processing mode. Security and privacy stakeholders should review what users are allowed to select locally, what data classifications are permitted, and how employees should avoid attaching restricted folders or files outside the approved workflow.

For Codex Local, document that Codex remains a distinct desktop experience with separate history. This helps developer-platform teams avoid promising a web-based or mobile-selected Codex workflow that OpenAI does not describe. If mobile access to supported desktop Codex chats through the Remote tab is relevant to your organization, include it as a viewing or continuation pathway, not as proof that Codex itself is generally selectable on web or mobile.

Browser and network access should be inventoried as independent controls because they change the external exposure of a task. A Work or Codex session that can browse, retrieve external content, interact with connected apps, or access network resources has a different risk profile from a session limited to user-provided context. Administrators should label which workflows may use external data, which require approvals, and which should remain isolated from browsing or network access.

Include connected apps and event-triggered tasks in the opening audit

Connected apps are part of the starting-default conversation because users often experience a task as one seamless workflow even when several permissions are involved. OpenAI states that event-triggered Work tasks can respond to supported Gmail, Slack, and GitHub events for eligible plans, and that connected-app permissions, workspace controls, and approval requirements continue to apply. Therefore, the task may start automatically from an event, but the event does not erase app authorization boundaries or approval requirements.

Enterprise, Edu, and Healthcare administrators have an additional enablement responsibility for event-triggered tasks. OpenAI’s Work and Codex documentation also warns that Healthcare event-triggered tasks are not covered by a Business Associate Agreement and must not process PHI. Healthcare privacy stakeholders should treat that as a deployment boundary, not as a training footnote, and should exclude protected health information from event-triggered Work task designs unless a separate covered workflow is expressly supported under the appropriate healthcare product and agreement.

Scheduled-task sharing also needs precise user communication. OpenAI says sharing a scheduled task transfers instructions, not chat history, local files, folders, device access, connected-app credentials, memories, or workspace permissions. An administrator should include this sentence in rollout materials because users may otherwise assume a shared task carries the full operational context of the original creator, including credentials or local resources that OpenAI says are not transferred.

Opening checklist for the administrator

1. Name the surface: Decide whether the change applies to Chat, Work, Codex, or more than one surface, and remember that Chat has a separate starting default.
2. Confirm authority: Identify the workspace owner or admin responsible for changing settings under Workspace settings → Models.
3. Verify entitlement: Check the relevant plan, role, model access, and feature access before assuming a default will appear for every member.
4. Separate local and cloud: Inventory Work Cloud, Work Local, and Codex Local as distinct permissions with distinct validation requirements.
5. Separate browser and network: Record whether browsing and network access are permitted, limited, or disabled for the workflows being piloted.
6. Map Fast Mode to use cases: Decide which tasks can safely start in a faster posture and which should start with more deliberate reasoning.
7. Review connected apps: Identify Gmail, Slack, GitHub, or other app dependencies and confirm that workspace controls and approval requirements still apply.
8. Write the boundary notice: Tell users that defaults do not transfer credentials, local files, memories, chat history, device access, or permissions.

The next configuration steps should be performed only after this inventory is complete. A clean inventory gives the administrator a defensible baseline for choosing the starting model, reasoning level, speed setting, Fast Mode availability, and new-chat behavior without overstating what the default can grant.

Configure separate Chat and Work & Codex starting defaults without confusing them with access

OpenAI’s Work and Codex help guidance separates the user experiences into Chat, Work, and Codex: Chat remains the general conversation surface, Work is intended for longer multi-step work and finished deliverables, and Codex remains dedicated to software development and technical work. The practical administrator consequence is that a starting default is not a universal model entitlement, not a security exception, and not a replacement for role, workspace, local, cloud, browser, network, or connected-app controls.

Use the following workflow when you are ready to configure the first controlled default set. The steps are written for workspace owners and admins because OpenAI states that owners and admins can configure Work & Codex starting defaults under Workspace settings → Models. If your workspace has delegated administration, regional controls, enterprise policies, or plan-specific limitations, record the actual controls exposed in your tenant rather than assuming another workspace’s settings exist in yours.

Step 1: Decide which defaults belong to Chat and which belong to Work & Codex

Before opening the settings page, write down two separate target states: one for Chat and one for Work & Codex. OpenAI’s documentation says Chat has a separate starting default from Work & Codex, so copying one set of choices into the other can create avoidable support tickets. For example, a team may want Chat to start with a broadly available conversational option while Work & Codex start with a stronger reasoning posture for deliverables and technical work, but that decision must still respect each member’s model access.

This troubleshooting playbook explains how to diagnose GPT-6 Astra availability in ChatGPT Work and Codex through plans, allowances, permissions, CLI state, and app updates. The complete GPT-6 Astra Rollout Troubleshooting Playbook for ChatGPT Work and Codex: Plans, Allowances, Permissions, CLI, and App Updates article provides the destination-specific detail for this section’s Model Access Troubleshooting decision because it matches the marker’s reader outcome by treating missing model access as an entitlement, permission, rollout, and client-version issue.

Step 2: Create a configuration matrix before changing Workspace settings

The configuration matrix is the administrator’s control sheet for the change. It prevents the common mistake of using one administrator account as proof that all roles will see the same result. OpenAI’s Work and Codex guidance is explicit that a starting default does not grant access to unavailable models or features, so the matrix must include both the desired default and the expected access boundary for each population.

For role overrides, use the matrix as an inheritance test rather than a promise that every workspace has the same role controls. The safe rule is: the workspace starting default is the baseline preference, and any role-level access restriction, workspace permission, model unavailability, or surface limitation can prevent the member from using that baseline. If a user’s role does not have access to the selected model or feature, the starting default should be documented as administratively configured but not effective for that user population.

Step 3: Save the Chat starting default first

Open the workspace model settings and configure the Chat starting default before changing Work & Codex. This order gives support teams a clean before-and-after record: if ordinary Chat conversations change unexpectedly, you can isolate the issue before introducing Work and Codex defaults. Record the selected Chat default, the administrator who made the change, the time, the affected workspace, and the reason for the choice.

1. Open the appropriate workspace administration area. Confirm that you are changing the intended workspace, especially if your organization operates separate production, pilot, healthcare, education, or contractor workspaces.
2. Navigate to the model settings area. OpenAI identifies the Work & Codex configuration path as Workspace settings → Models; use the corresponding Chat default control exposed in the same administrative context.
3. Select the Chat starting default. Choose a default that ordinary users are expected to have access to, rather than selecting a model that will immediately fail for the majority of members.
4. Save and record the change. Capture the configuration evidence before testing, because later troubleshooting needs to distinguish a failed save from a user-specific access limitation.
5. Run a fresh Chat test. Use at least one owner/admin account and one non-admin account, then start a new Chat conversation and record the observed starting state.

Do not use an existing Chat thread as proof that the new default works. Defaults are starting behavior, so the defensible test is a newly created conversation after the setting is saved. If your users depend on templates, shared links, scheduled tasks, or old threads, test those workflows separately and avoid claiming that a default change modifies existing context, credentials, memories, local files, or prior conversation history.

Step 4: Configure the Work & Codex starting model, reasoning level, and speed

After the Chat default is stable, configure Work & Codex under Workspace settings → Models. OpenAI states that owners and admins can configure a starting model, reasoning level, speed, Fast Mode availability, and new-chat behavior for Work & Codex in this area. Treat each choice as a separate control because a model change, reasoning change, and speed change can affect different teams in different ways.

When the Work & Codex defaults are saved, do not announce that “everyone now has the new model.” The accurate announcement is that the workspace now has a new starting preference for eligible users where the relevant model, role, surface, and permissions allow it. That wording prevents confusion when a member’s role cannot access the model, when Codex is unavailable on web or mobile, or when a local permission is not enabled.

Step 5: Apply role inheritance rules explicitly

Role inheritance should be tested as an access outcome, not described as a hidden entitlement mechanism. OpenAI’s guidance gives the governing principle: a starting default does not grant access to a model or feature unavailable to the member’s role. Therefore, role overrides and restrictions should be documented as conditions that can narrow or change the effective experience for a member even when the workspace-level default is configured correctly.

This inheritance model is also useful for support triage. If a user says “the default did not apply,” ask which surface they used, which role they have, whether they started a new session, whether they were in Chat, Work, or Codex, and whether the relevant local, cloud, browser, or network permission is enabled. That sequence usually identifies whether the issue is a settings error, an entitlement boundary, a surface limitation, or a misunderstanding of what a starting default can do.

Step 6: Validate Work Cloud, Work Local, and Codex Local separately

OpenAI describes Work Cloud, Work Local, and Codex Local as separate workspace permissions, and it also states that browser use and network access are separate controls. This means an administrator should not bundle all validation into one “agent access” checkbox. A member may have a valid Work & Codex starting model while lacking permission for a local-file workflow, cloud task workflow, browser use, network access, or the Codex desktop view.

For regulated teams, include a short privacy note in the validation record. Local Work may involve local files approved by the user, but that does not mean all processing is local-only. Because OpenAI states that messages and task context may still be stored in the cloud, administrators should align user communications, data classification, and file-handling rules with the workspace’s actual cloud and local configuration.

Step 7: Use a test-user matrix before broad rollout

A test-user matrix is the safest way to catch mismatches before an organization-wide announcement. Select users who represent the real combinations in your workspace: owner, admin, standard member, restricted member, developer using Codex Local, business user using Work Cloud, desktop user using Work Local, and any special-policy group subject to additional restrictions. Each tester should start fresh sessions rather than relying on existing conversations.

Keep test evidence minimal but specific: date, tester role, surface, new-session confirmation, observed starting model, reasoning level, speed, Fast Mode visibility, local/cloud permission state, and any blocker. Do not store unnecessary sensitive content in the rollout record. For developer tests, avoid using production secrets or private repositories unless the user is authorized and the workspace policy explicitly permits that workflow.

Step 8: Configure and test event-triggered Work tasks only after defaults are stable

Event-triggered Work tasks add another layer because they can respond to supported Gmail, Slack, and GitHub events for eligible plans, and OpenAI states that Enterprise, Edu, and Healthcare admins must enable event-triggered tasks. Do not mix event-triggered task rollout with your first model-default change unless you have a separate test plan, because failures can come from connected-app authorization, workspace controls, approval requirements, plan eligibility, or the new starting default.

For Healthcare workspaces, preserve OpenAI’s stated boundary that Healthcare event-triggered tasks are not covered by a Business Associate Agreement and must not process PHI. This is not a model-selection issue; it is a workflow eligibility and data-handling issue. A faster starting mode, a stronger reasoning level, or a successful connected-app test does not convert an unsupported PHI workflow into a permitted one.

Administrator decision rule: roll out starting defaults first, verify ordinary new Chat, Work, and Codex behavior, and only then validate event-triggered Work tasks with connected-app permissions, approval steps, plan eligibility, and regulated-data restrictions documented separately.

When sharing scheduled or event-related task instructions, remind users that sharing transfers instructions but not chat history, local files, folders, device access, connected-app credentials, memories, or workspace permissions. That distinction matters during pilots because a recipient may receive the task instructions but still lack the permissions, credentials, files, or workspace access required to run the same workflow.

Step 9: Publish a short user notice that matches the actual controls

The rollout notice should be precise enough to reduce support tickets. Tell users which starting defaults changed, which surfaces are in scope, and which boundaries remain. Avoid broad claims such as “Codex is now available everywhere,” because OpenAI states that Codex remains a separate desktop view and is not selectable on web or mobile, even though supported desktop Codex chats may be accessible through the mobile Remote tab.

Recommended rollout note structure:

1. What changed:
   - Chat starting default: [administrator-entered value]
   - Work & Codex starting model: [administrator-entered value]
   - Work & Codex reasoning level: [administrator-entered value]
   - Work & Codex speed: [administrator-entered value]
   - Fast Mode availability: [administrator-entered value]
   - New-chat behavior: [administrator-entered value]

2. Who is affected:
   - Eligible users whose role, plan, surface, and workspace permissions allow the selected defaults.

3. What did not change:
   - Starting defaults do not grant unavailable model or feature access.
   - Work Cloud, Work Local, and Codex Local remain separate permissions.
   - Browser use and network access remain separate controls.
   - Connected-app permissions and approval requirements still apply.
   - Sharing task instructions does not transfer credentials, local files, memories, or workspace permissions.

4. Where to report problems:
   - Include the surface used, user role, whether the session was new, and the observed starting model or mode.

End the configuration phase only after the administrator record, role-inheritance matrix, and test-user matrix agree with one another. If they do not, roll back or narrow the rollout rather than training users around inconsistent behavior. The goal is not to force every account into the same experience; the goal is to make the intended starting defaults predictable wherever the user’s role, permissions, surface, and workspace policy allow them.

Validate access surfaces after the starting defaults are saved

After saving Work & Codex starting defaults, validate access as a separate control plane rather than as a side effect of the default model, reasoning level, speed, or Fast Mode configuration. OpenAI’s Work and Codex documentation distinguishes the starting default from entitlement: a default can influence the first state of a new Work or Codex task, but it does not grant a model, mode, local access path, cloud permission, browser capability, network capability, connected-app authority, or event-triggered automation that the member’s role or workspace policy does not already allow.

Use the validation phase to prove three things: first, the expected users land on the intended starting configuration; second, disallowed users remain blocked even when the default points at a capability they cannot use; third, local, cloud, browser, network, and connected-app surfaces behave according to their own permissions. This separation is the operational difference between a clean rollout and an accidental access expansion.

Create a post-change validation matrix for each access surface

Build the validation matrix around actual workspace roles or pilot accounts rather than a single administrator account. An owner or admin account often has broader visibility than a normal member, so it can mask entitlement problems. At minimum, test one workspace owner or admin, one ordinary member in the pilot group, one ordinary member outside the pilot group, and one restricted or guest-like role if your workspace uses such a role. The goal is not to exhaust every identity combination on day one; the goal is to catch the most likely difference between “default selected” and “access actually permitted.”

Validate Work Cloud without assuming it controls local or connected access

Work Cloud is the cleanest surface for confirming the starting model and reasoning posture because it avoids local-file variables. Ask each pilot tester to start a new Work task with the same short instruction, then record the visible starting state and whether the user can complete a small multi-step deliverable. The instruction should be ordinary enough that browser, network, local files, and connected apps are not required; for example, ask for a one-page project brief from information pasted into the conversation.

Validation prompt for Work Cloud:
Create a concise project brief from the information below.
Include objective, stakeholders, risks, next actions, and open questions.
Do not use web browsing, connected apps, or local files.
Use only the information pasted in this message.

Information:
[Paste non-sensitive internal test text approved for this validation.]

The evidence you want is simple: the user can start Work, the task begins with the configured Work & Codex default when available to that user, and the task does not silently acquire browser, network, app, or local-file access. If the starting state differs by role, document the difference as expected or unexpected before opening a support ticket; a workspace member may legitimately lack a model or feature that the default references.

This analysis of OpenAI’s acquisition of Ona examines persistent cloud development environments for Codex and helps teams contrast managed long-running cloud workspaces with local CLI and desktop execution boundaries. The complete OpenAI Acquires Ona: How Persistent Cloud Environments Will Transform Codex for Enterprise article provides the destination-specific detail for this section’s Local vs Cloud Agents decision because the target supplies a precise cloud-environment counterpart for the paragraph’s local-versus-cloud operating decision.

Validate Work Local with explicit local-file approval and cloud-context disclosure

Work Local needs a separate test because local-file access is not the same as cloud Work access. OpenAI states that Local Work can access user-approved local files in the desktop app, while messages and task context may still be stored in the cloud. Your rollout documentation should therefore avoid phrases such as “local-only,” “offline,” or “not stored” unless your organization has confirmed a specific retention and storage interpretation through its own agreement and administrative configuration.

Use a benign local file created for validation, not a real customer record, source-code secret, legal file, medical record, or regulated dataset. The tester should approve only that file or folder, then ask Work to summarize it. If the workflow can proceed without additional file prompts after the user has approved the file, record that as expected local-file behavior; if Work attempts to reach unrelated folders, stop the test and review the local-access boundary.

1. Create a non-sensitive validation file on the tester’s device, such as a short internal policy draft with no personal data, credentials, or regulated content.
2. Open the desktop app with an account included in the pilot group.
3. Start a new Work task and attach or approve only the validation file according to the app’s current file-access flow.
4. Ask Work to summarize the file and list any missing sections.
5. Confirm that the task does not need access to sibling folders, credential files, downloads, browser storage, or unrelated local paths.
6. Record the task ID or administrative evidence available to your workspace without copying sensitive file contents into the rollout log.

For regulated teams, the validation note should explicitly say that local-file approval is user-mediated and that local task context can still involve cloud storage. Healthcare administrators should be especially careful not to treat Local Work as a workaround for clinical or covered-entity restrictions. If a workflow involves protected health information, business associate terms, clinical use, or medical-record custody, validate it under the appropriate OpenAI healthcare offering and your organization’s compliance process rather than under a general Work Local pilot.

Validate Codex Local as a separate desktop software-development surface

Codex Local should be validated with a software-development scenario, not a general writing or project-management prompt. OpenAI describes Codex as dedicated to software development and technical work, and it remains a separate desktop view and history. Work & Codex starting defaults may be configured together, but Codex’s operating context is still different from Work because it is oriented around repositories, code changes, technical investigation, and development workflows.

Run a dry validation on a disposable internal repository or a deliberately simple training repository that your organization is authorized to use. Do not use a production repository containing secrets as the first validation target. Ask Codex to inspect a small function, propose a change, or explain a failing test without permitting broad filesystem access. The pass condition is that authorized users can start Codex Local from the supported desktop surface and unauthorized users cannot bypass their role or workspace restriction merely because the workspace default names a powerful model or reasoning level.

Codex is not selectable on web or mobile according to OpenAI’s Work and Codex documentation. However, supported desktop Codex chats may be accessible through the mobile Remote tab. Your user notice should state this carefully: mobile access to a supported remote Codex chat is not the same thing as starting arbitrary Codex work from mobile, and it does not transfer device-level access, local repository access, or credentials to another user.

Test browser and network controls as separate gates

Browser use and network access deserve their own validation because they are not implied by the starting default. A task may start with the intended model and reasoning level while still being unable to browse, download, call a network resource, or use an external tool. That is often the correct outcome. The administrator’s job is to make sure the outcome matches policy rather than user expectation.

Create two browser/network tests: one that should be blocked or require approval, and one that should be allowed if your workspace intentionally enables the capability. The blocked test might ask the assistant to use the web for a decision that should rely only on internal pasted material. The allowed test, if applicable, should use public, non-sensitive research and should not require sign-in, uploads, external disclosures, or irreversible actions. Record whether the task proceeds, asks for confirmation, or blocks; do not evaluate browser control by whether the answer is useful.

Validate desktop, web, and mobile behavior without promising parity

Work is available on supported web, mobile, and desktop surfaces, but not every surface should be described as equivalent. The desktop app is relevant for local-file workflows; web and mobile are often better validation surfaces for cloud-only Work tasks; Codex remains a desktop-centered separate view, with the mobile Remote tab only for supported desktop Codex chats. Your rollout guide should tell users where to start each class of task, not simply say “use ChatGPT.”

A practical validation sequence is to test the same Work Cloud prompt on web, desktop, and mobile for an eligible pilot user, then test the Work Local prompt only on desktop, and finally test Codex Local only in the desktop Codex view. If a user reports that a feature is “missing,” ask which surface they used before changing the workspace configuration. Many rollout incidents are surface mismatches rather than permission failures.

Validate event-triggered Work tasks only after human-started tasks are stable

Event-triggered Work tasks add another control layer because the task starts from a supported external event rather than from a user’s manual prompt. OpenAI’s Work and Codex documentation identifies supported Gmail, Slack, and GitHub events for eligible plans, while also stating that connected-app permissions, workspace controls, and approval requirements continue to apply. Enterprise, Edu, and Healthcare administrators must enable event-triggered tasks, so pilot users in those environments should not expect triggers to work until the administrator has deliberately turned them on.

This post covers ChatGPT Work webhook prompts for turning Gmail, Slack, and GitHub pull-request events into reviewable automations. The complete 25 ChatGPT Work Webhook Prompts for Gmail, Slack, and GitHub Automation article provides the destination-specific detail for this section’s Event Triggered Workflows decision because it directly expands on event-triggered scheduled tasks and webhook-style workflow automation in ChatGPT Work.

Start with a low-risk event that contains no regulated data, customer secrets, credentials, legal advice, medical facts, or confidential financial information. For Gmail, use a test message from an internal account approved for the pilot. For Slack, use a pilot channel created for validation rather than a production incident channel. For GitHub, use a repository and event type your team is authorized to process. The expected output should be a draft, summary, triage note, or checklist unless your workspace has deliberately approved more consequential actions.

Event-triggered task validation record:
Trigger source: Gmail | Slack | GitHub
Pilot account:
Workspace role:
Connected app authorization confirmed: yes/no
Admin enablement required for this workspace type: yes/no
Approval required before external action: yes/no
Sensitive data excluded from test payload: yes/no
Expected task output:
Observed task output:
Unexpected access or missing access:
Decision: pass | fix configuration | pause rollout

Healthcare workspaces need an additional warning in the validation record: event-triggered tasks are not covered by a BAA and must not process PHI. Do not use a de-identified-looking message as a shortcut unless your privacy team has approved the dataset and the workflow. FedRAMP-bound environments should also treat event-triggered availability and connected-app behavior as environment-specific and confirm the current administrative restrictions before publishing user instructions.

Confirm approvals for consequential actions and connected-app boundaries

Approval behavior is not a cosmetic prompt; it is part of the safety and governance boundary. A task that reads permitted context is different from a task that sends a message, modifies a repository, updates an issue, shares a file, or discloses sensitive information outside ChatGPT. OpenAI’s app-permission model preserves connected-source authorization, workspace controls, role access, action controls, parameter constraints, and approval cards. A less restrictive user permission does not override safety or workspace protections.

Validate approvals with a scenario that should require confirmation, such as preparing an external message from connected content. The task should be allowed to draft when the connected app and workspace policy permit reading, but it should not perform a sensitive external action without the required permission step. If the task blocks, capture the policy reason if visible. If it proceeds without the expected confirmation, pause rollout and recheck whether the action was actually external, whether the app permission was broader than intended, and whether workspace policy needs tightening.

Test shared-task boundaries before encouraging collaboration

Shared tasks are useful for collaboration, but OpenAI’s Work and Codex documentation states an important boundary: sharing a scheduled task transfers instructions, not chat history, local files, folders, device access, connected-app credentials, memories, or workspace permissions. That boundary should appear in your user notice because it prevents two opposite mistakes: assuming a shared task includes everything the original author could access, or assuming sharing is a safe way to delegate credentials and local context.

Validate sharing with two pilot users who have different access. User A should create a benign scheduled task using instructions only. User B should receive or access the shared task and confirm that they do not inherit User A’s connected-app credentials, local folders, memory state, device access, or broader workspace permissions. If User B needs access to the same source, they must connect or be granted access through the normal app, workspace, or repository authorization path.

Close validation with an evidence package and rollback decision

End the access validation phase with a compact evidence package that a workspace owner, security reviewer, or compliance stakeholder can inspect without replaying every test. Include the configuration matrix, tested roles, tested surfaces, pass/fail notes, screenshots or administrative records where your policy permits them, known limitations, and the rollback owner. Do not include sensitive local files, connected-app payloads, credentials, PHI, proprietary source snippets, or full chat transcripts unless your retention policy explicitly allows that evidence.

Your rollout decision should use a simple threshold: proceed only when the intended users can start the intended Work and Codex experiences, unintended users remain blocked, local-file access requires user approval, cloud-context implications are disclosed, browser and network gates behave as configured, event-triggered tasks respect admin and app boundaries, approvals appear for consequential actions, and shared tasks transfer instructions without transferring hidden access. If any one of those controls is ambiguous, keep the pilot group small, correct the configuration or documentation, and rerun the affected validation before expanding access.

Roll out the Work & Codex defaults with a controlled pilot

Treat the Work & Codex starting defaults as a production configuration change, not a cosmetic preference. OpenAI’s help article states that workspace owners and admins can configure a starting model, reasoning level, speed, Fast Mode availability, and new-chat behavior for Work & Codex under Workspace settings, but it also states that a starting default does not grant access to a model or feature unavailable to the member’s role. The pilot should therefore prove two separate outcomes: eligible users start in the intended configuration, and ineligible users are not silently elevated by the default.

Use a small pilot group that represents the real workspace population: at least one owner or admin, one power user of Work Cloud, one desktop user who needs Work Local, one software developer who uses Codex Local, one user with restricted model access, and one user who primarily works from web or mobile. If event-triggered Work tasks are in scope, add a user who can test supported Gmail, Slack, or GitHub events under the actual plan and workspace controls. If Healthcare, Enterprise, Edu, or regulated teams are involved, include a privacy or compliance reviewer before enabling event-triggered tasks, because OpenAI states that Healthcare event-triggered tasks are not covered by a BAA and must not process PHI.

Pilot scope and duration

Run the pilot long enough to observe normal work patterns, not just sign-in behavior. A practical pilot window is one full work week for knowledge-work defaults and two sprint cycles for software-development defaults if Codex Local is heavily used. The objective is not to prove that a selected model or reasoning level is universally best; the objective is to confirm that the starting default, role access, local/cloud permissions, browser and network gates, connected-app approvals, and user communications behave as documented for your workspace.

This tutorial explains GPT-5.6 Sol Fast Mode and its speed, quality, and cost trade-offs for developers building latency-sensitive applications. The complete How to Use GPT-5.6 Sol Fast Mode: Speed, Quality, and Cost Trade-Offs for Developers article provides the destination-specific detail for this section’s Fast Mode Economics decision because it is the exact supporting article for discussing when Fast Mode is economically worthwhile versus when quality or cost constraints should dominate.

Define acceptance criteria before wider deployment

Acceptance criteria should be written as observable controls, not aspirations. A useful criterion is “a restricted member cannot access the configured starting model if that model is unavailable to the member’s role,” because that directly tests OpenAI’s stated boundary that defaults do not grant entitlements. A weak criterion is “the rollout feels simpler,” because it does not catch role leakage, local-file confusion, or event-task misuse.

• Entitlement preservation: No pilot user receives a model, feature, Work Cloud permission, Work Local permission, Codex Local permission, browser access, network access, connected-app access, or event-triggered capability that their role, plan, workspace, app authorization, or approval policy does not already allow.
• Surface separation: Chat defaults remain separate from Work & Codex defaults, and users can explain that a Chat starting default is not evidence of the Work or Codex starting state.
• Local-file clarity: Work Local users understand that approved local files may be used in the desktop app, while messages and task context may still be stored in the cloud according to the product boundary described by OpenAI.
• Codex placement: Developers understand that Codex remains a separate desktop view and history, and that Codex is not selectable on web or mobile even though supported desktop Codex chats may be accessible through a mobile Remote tab.
• Connected-app discipline: Users do not treat event-triggered Work tasks or shared scheduled tasks as a way to transfer credentials, local files, chat history, memories, folders, device access, or workspace permissions.
• Regulated-data exclusion: Healthcare teams confirm that event-triggered tasks are not used to process PHI where OpenAI says the feature is not covered by a BAA.

Capture evidence without collecting unnecessary sensitive content

The evidence package should prove configuration state and boundary behavior while minimizing the capture of private prompts, local files, source code, credentials, medical information, customer records, and connected-app data. Ask testers to capture the starting selection, permission outcome, error or denial message if one appears, and the role or test persona used. Do not ask users to paste sensitive task content into rollout tickets when a redacted screenshot or administrator observation is enough.

{
  "change_id": "work-codex-defaults-rollout",
  "workspace": "named internal workspace",
  "date": "YYYY-MM-DD",
  "configured_defaults": {
    "surface": "Work & Codex",
    "starting_model": "record exact admin selection",
    "reasoning_level": "record exact admin selection",
    "speed_or_fast_mode": "record exact admin selection",
    "new_chat_behavior": "record exact admin selection"
  },
  "separate_permissions_validated": [
    "Work Cloud",
    "Work Local",
    "Codex Local",
    "browser use",
    "network access",
    "connected-app approvals",
    "event-triggered tasks if enabled"
  ],
  "test_personas": [
    "admin",
    "eligible member",
    "restricted member",
    "desktop local-file user",
    "Codex developer",
    "mobile or web user"
  ],
  "exceptions": [
    "record approved exceptions with owner, expiry date, and compensating control"
  ],
  "rollback_owner": "named administrator or change manager"
}

Store the evidence package in the same system used for workspace change management, not in a public chat, issue tracker, or repository. If the rollout includes developers using Codex Local, remind them that local development context may include proprietary source code and secrets; evidence should show that Codex Local was available or unavailable as intended, not expose the underlying codebase.

Rollback plan: return to the previous default without weakening access controls

Prepare rollback before the pilot begins. The safest rollback is to restore the previous Work & Codex starting model, reasoning level, speed, Fast Mode availability, and new-chat behavior while leaving role permissions, Work Cloud, Work Local, Codex Local, browser, network, and connected-app controls unchanged. Do not “fix” a starting-default complaint by broadening access, enabling local permissions, or relaxing app approvals unless a separate risk review approves that change.

1. Record the baseline: Before the change, export or manually capture the existing admin selections and the date, administrator, and reason for the baseline snapshot.
2. Define rollback triggers: Roll back if restricted users appear to gain unintended access, eligible users cannot start critical workflows, local/cloud boundaries are misunderstood at scale, or regulated-data exclusions cannot be enforced.
3. Restore only the default layer: Revert the Work & Codex starting defaults first; do not alter Chat defaults unless the incident involves the separate Chat configuration.
4. Retest a narrow matrix: Validate one eligible user, one restricted user, one Work Local user, and one Codex Local user after rollback.
5. Document residual issues: If failures remain after rollback, classify them as entitlement, role, app authorization, browser/network, local desktop, mobile, or event-triggered task issues rather than continuing to adjust defaults.

User communications that prevent the most common misunderstandings

The rollout announcement should be short, specific, and explicit about what does not change. Users need to know the new starting point, how to switch when their work requires a different available option, and which boundaries remain in force. Avoid telling users that the workspace has “enabled a model for everyone” unless that is true under their role and plan; OpenAI’s documented boundary is that a starting default does not grant access to unavailable models or features.

Recommended internal notice: “We are updating the starting defaults for ChatGPT Work & Codex. New Work and Codex sessions will start with the configured workspace model, reasoning, and speed settings where your role and plan allow them. This change does not grant new model access, local-file access, Codex Local access, browser use, network access, connected-app credentials, or approval bypasses. Chat has a separate starting default. If you use local files in the desktop app, remember that approved files may be used for the task and messages or task context may still be stored in the cloud. Report unexpected access, missing access, or confusing approvals through the normal support channel.”

Send a separate developer note if Codex Local is in scope. That note should state that Codex remains a desktop software-development surface with its own view and history, and that web or mobile availability should not be assumed from Work availability. If mobile Remote access to supported desktop Codex chats matters to the team, describe it as a remote access path to supported desktop Codex chats rather than as full mobile Codex parity.

Exception handling for teams, roles, and regulated workflows

Exceptions should have an owner, reason, scope, expiry date, and compensating control. A permanent exception that simply says “needs higher reasoning” is not operationally useful; a better exception says “release engineering may start Codex Local with the approved deeper reasoning default for migration planning tasks through the end of the quarter, with pull-request review still required.” This keeps the exception tied to a workflow and prevents it from becoming a shadow entitlement model.

Troubleshooting: classify the symptom before changing the default

Most rollout tickets fall into one of five categories: entitlement mismatch, separate-surface confusion, local/cloud misunderstanding, connected-app approval behavior, or client-surface availability. Classify the symptom before editing Workspace settings. Changing the starting model will not fix a missing Codex Local permission, a blocked browser action, a disconnected app, an unavailable mobile surface, or a user role that does not include the selected feature.

• “The default did not appear for me.” Check whether the user is starting Chat instead of Work or Codex, whether the user’s role can access the configured model or feature, and whether the client surface supports the workflow.
• “Codex is missing on web or mobile.” Verify whether the user is expecting Codex to be selectable outside its supported desktop context; OpenAI states that Codex is not selectable on web or mobile.
• “Local files are not available.” Check Work Local permission, desktop-app use, and explicit local-file approval; do not assume Work Cloud permission includes local-file access.
• “A connected app asked for approval.” Treat the approval as a separate app and action-control behavior, not as a failure of the starting default.
• “An event-triggered task did not run.” Confirm plan eligibility, admin enablement where required, connected-app authorization, workspace controls, and approval requirements before changing model or reasoning defaults.

Quarterly review and drift control

Review Work & Codex defaults quarterly or after any major workspace, plan, role, compliance, or operating-model change. The review should compare the configured default against actual usage patterns, support tickets, exceptions, role changes, local-access approvals, connected-app adoption, and event-triggered task use. The output should be a decision to keep, adjust, narrow, or roll back the default; it should not become an automatic ratification of whatever the current setting happens to be.

1. Reconfirm ownership: Name the administrator accountable for Work & Codex defaults and the separate owner for Chat defaults.
2. Retest entitlement boundaries: Use at least one restricted test user to confirm that defaults still do not grant unavailable models or features.
3. Review local and cloud access separately: Confirm that Work Cloud, Work Local, and Codex Local permissions still match business need.
4. Inspect exception expiry: Remove expired exceptions or renew them with a fresh justification and evidence.
5. Validate regulated exclusions: Reconfirm that Healthcare or other sensitive workflows are not using event-triggered tasks in ways that violate the stated BAA and PHI boundaries.
6. Refresh communications: Update user guidance if model names, available reasoning options, workspace roles, supported surfaces, or approval behavior have changed.

Final rollout checklist

The rollout is ready when the evidence shows that the selected Work & Codex starting defaults improve consistency without weakening access boundaries. The administrator should be able to answer four questions from the change record: which starting defaults changed, which users are entitled to the resulting model or feature, which surfaces were tested separately, and what rollback action restores the prior state. If any answer requires guessing from user anecdotes, continue the pilot instead of deploying broadly.

Starting defaults cannot grant unavailable models, override role limits, merge Chat with Work & Codex defaults, enable Work Cloud, enable Work Local, enable Codex Local, authorize local files, bypass browser or network controls, create connected-app credentials, skip app approvals, transfer chat history or memories through shared tasks, make Codex selectable on web or mobile, or remove Healthcare and FedRAMP restrictions. They are useful because they standardize the first step of a session; they are risky only when teams mistake that first step for an access-control system.

Useful Links

• OpenAI Help: ChatGPT Work and Codex
• OpenAI Help article 11750701
• OpenAI Help article 8411955