ChatGPT Space vs Shared Projects: A Permission-Aware Guide to Pages, Agent Edits, and Collaboration

Evidence checkpoints

Documented point: 29 September 2026: OpenAI’s DevDay developer-conference documentation introduced ChatGPT Space as a place to bring files and Pages together, draft/revise with ChatGPT, edit directly, and invite collaborators to view, comment, or edit. This is launch documentation; it does not establish availability for every plan, device or account. [official source 1]

Documented point: 29 September 2026: OpenAI’s DevDay recap says Space and Pages are available to Pro, Business, and Enterprise users; web/desktop supports Page creation, editing, and collaboration, while mobile supports finding, reading, and sharing Pages, with mobile creation/editing coming soon. This is an OpenAI product announcement, not independent testing or proof that the rollout is complete for every eligible user. [official source 1]

Documented point: As accessed on 1 October 2026, Space documentation says linked files retain their own permissions, while content copied or summarized onto a Page is visible to collaborators with Page access. Permission options depend on recipient, account, and workspace; removing a direct invite does not necessarily remove inherited access. [official source 1]

Documented point: As accessed on 1 October 2026, the Space agent guide says Keep Updated is unavailable at launch; recurring work must be separately configured, then checked through its saved schedule and an actual run. This does not certify agent accuracy, authorise autonomous approval or publication, or guarantee access to an optional Dots agent or Codex in Space. [official source 1]

Documented point: As accessed on 1 October 2026, official Projects documentation describes shared Projects as a context hub for chats, uploaded files, and custom instructions; shared Projects use project-only memory. This is not a benchmark or direct feature-equivalence source; unsupported comparisons must be marked not comparable. [official source 1]

Source and availability note: OpenAI introduced ChatGPT Space on 29 September 2026 in its DevDay documentation. The announcement described Space as a place to bring files and Pages together, draft and revise with ChatGPT, edit work directly, and invite collaborators to view, comment or edit. OpenAI’s DevDay recap and Space feature documentation, accessed on 1 October 2026, described Space and Pages as available to Pro, Business and Enterprise users. This is documented availability, not proof that rollout has reached every eligible account, region or managed workspace.

The same dated sources draw an important device boundary. Web and desktop support creating, editing and collaborating on Pages. Mobile supports finding, reading and sharing Pages, while mobile creation and editing were described as coming soon or unsupported at launch. Do not plan a mobile-authoring workflow until the current product documentation and the target devices confirm that it works. Workspace administrators may also restrict availability or sharing, so a plan name alone is not an entitlement check.

The cited official sources do not establish a current service incident, degradation or incident-free status. They should therefore not be used as evidence that Space is operational at the moment a team starts work. Before a time-sensitive pilot, check OpenAI’s current service-status information and confirm that the feature opens in the intended workspace. If either check fails, postpone the pilot or use an already approved workflow; do not interpret a missing control as proof of its intended permission state.

This guide is a documentation-led product-fit analysis, not a hands-on benchmark. It does not claim that Space is faster, more accurate or more productive than a shared Project. It also does not establish a Space-specific price, usage allowance, geographic matrix or service-level agreement. Those are separate purchasing and operational questions that the cited records do not answer.

Start with the object the team needs to share

The most useful distinction is not “new product versus old product”. It is the unit of work around which people need to collaborate. A Page is an editable document. A Space groups Pages and accessible material around a topic or team, although OpenAI’s documentation says that a Page can also be created on its own. A shared Project is a context hub organised around chats, uploaded files and custom instructions.

This difference changes the centre of gravity of the work. In a Page-led workflow, the shared document is the object that people read, edit and comment on. Supporting material exists to help maintain that document. In a Project-led workflow, the continuing collection of project chats, uploaded files and instructions supplies the shared context for subsequent conversations. Both can support collaborative knowledge work, but the official records do not describe them as interchangeable containers.

Consider a policy team maintaining a launch-readiness brief. If the deliverable must have stable sections, directly edited wording, comments and a readable current version, the living object is a document. That points towards a Page pilot. If the team instead needs a bounded place for several related conversations, reference files and standing instructions such as “answer for the procurement team”, a shared Project more directly matches the documented structure.

Decision rule: choose the surface whose primary object matches what colleagues must return to. If they must return to a shared document, evaluate Space and Pages first. If they must return to a collection of project-scoped chats and context, evaluate a shared Project first. If both are required, do not assume automatic interoperability or synchronisation. Define which surface holds the authoritative output and treat any movement of content between surfaces as an explicit, reviewed operation.

When deciding whether a Space or a shared Project suits a living document, first establish what Projects already provide. The ChatGPT Projects conversations files and custom instructions guide covers how Projects organise conversations, files and custom instructions, giving the comparison a clear Projects baseline without suggesting that it explains Spaces.

Workspace, Space and Page are not synonyms

OpenAI’s Space overview distinguishes the signed-in ChatGPT workspace from a Space. The workspace is the person’s or organisation’s ChatGPT environment. A Space is a collaboration surface within an environment where Space is enabled. Treating those terms as equivalent can produce a serious planning error: being a member of an organisation’s workspace does not by itself prove access to every Space, Page, linked source or sharing role.

A Page is more granular than a Space. Sharing a Space can grant access to its Pages, while sharing one Page is a separate action. OpenAI’s collaboration documentation also says access can be inherited from a parent Page or Space. Consequently, the visible direct invitation on one Page may not be the complete explanation of a person’s effective access.

Use a simple naming test before setup:

1. Write the name of the signed-in workspace in which the work is intended to live.
2. Write the proposed Space name, if a Space is needed.
3. Write the Page title that will contain the shared deliverable.
4. List the people who need access to the Space as a whole.
5. List those who need access only to the individual Page.
6. Identify any parent Page or Space from which access might be inherited.

For example, “Business workspace / Product Operations Space / Q4 launch decision Page” identifies three separate layers. A legal reviewer might need access only to the decision Page, while product operations staff may inherit access through the Space. That example is a suggested design, not a guarantee that every account will offer the same roles or labels.

Decision rule: if the team cannot identify which layer grants each collaborator access, do not add sensitive or consequential material. Resolve the access path first. Removing a direct invitation does not necessarily remove inherited access, so direct-invite removal is not a sufficient offboarding test.

A living Page is different from a chat transcript

A living Page is intended to remain readable and directly editable as the shared output evolves. OpenAI’s release notes dated 29 September 2026 say a user can turn a conversation into a Page, start from a template or write directly in Space. The same release entry says collaborators can edit the same Page and leave comments, with each person using their own ChatGPT.

That does not mean a Page exposes the creator’s entire conversation history, private memory or account. OpenAI’s Space documentation says sharing a Page does not share private chats or memory. It does mean that material placed on the Page is visible to people who have Page access. The privacy boundary follows what has been written, copied or summarised into the shared object.

A practical test is to ask what a new collaborator should encounter first. If that person should open one structured brief and see the current proposition, evidence, unresolved questions and proposed decisions, a Page is the more direct documented fit. If the person should inspect several project conversations and continue asking questions against common files and instructions, a shared Project is the clearer documented fit.

For example, a Page might contain these maintained sections:

• purpose and scope;
• current proposal;
• evidence and source references;
• open questions;
• review comments;
• decisions requiring named human approval.

A shared Project might instead contain separate chats for requirements, risks and stakeholder questions, accompanied by uploaded files and project instructions. Neither structure is inherently superior. The trade-off is between a document-centred collaboration surface and a chat-and-context hub.

Decision rule: if contributors need to refine exact wording in a common artefact, use the Page criterion. If their main activity is conducting and retaining multiple context-bound conversations, use the Project criterion. Do not choose Space merely because a document began as a chat; conversion into a Page changes the shared object and requires a fresh content and permission review.

Documented comparison: Space and Pages versus shared Projects

The following comparison is limited to official OpenAI documentation accessed on 1 October 2026. It is not a feature benchmark and does not assume parity where the cited documentation provides no matching evidence. “Not directly comparable” means the cited records do not support a responsible equivalence claim; it does not mean that a capability is absent.

How to read an “unknown” without turning it into an assumption

A comparison table can create false confidence when an empty cell is interpreted as “no”. In this guide, an unknown means only that the cited official documentation does not document a directly comparable behaviour. For example, the Space sources explain how separately linked files retain their own permissions. The Projects article describes uploaded files, but that is not sufficient evidence for a line-by-line comparison of every source-permission scenario.

Use a three-state classification for each requirement:

1. Documented match: an official source directly supports the required behaviour.
2. Documented mismatch: the official source explicitly says the behaviour is unavailable or different, such as mobile Page editing at launch.
3. Unresolved: the cited source does not answer the requirement, so the team must inspect current official documentation or verify the behaviour in an eligible environment.

Suppose a team requires external reviewers to comment without editing and also requires those reviewers to open a linked repository file. Page commenting may be documented where that role is offered, but source-file access remains a second permission question. The requirement is not satisfied until both are confirmed. The team must not copy restricted content onto the Page merely to bypass the source system’s access controls.

Decision rule: an unresolved requirement cannot be counted as supported. If it is essential, pause selection until it is verified. If it is optional, record it as a pilot question and keep the pilot’s content non-sensitive.

Choose by collaboration pattern, not by feature count

Feature counting obscures how work moves between people. A Page may be attractive because it has direct editing and comments, while a Project may be attractive because it gathers chats, files and instructions. The more reliable choice comes from tracing the intended collaboration pattern from input to approved output.

Pattern A: one maintained brief with multiple contributors

Assume a cross-functional team maintains a weekly operational brief. Researchers add evidence, a programme lead edits the current position, and reviewers comment on wording. The approved output must be readable without reconstructing several chats. This is a Page-shaped requirement because the common object is the maintained brief.

A bounded evaluation procedure is:

1. Define one non-sensitive brief with a named owner and a fixed review period.
2. List which participants need to read, comment or edit.
3. Decide whether the Page should stand alone or inherit access through a Space.
4. Use only material that participants are authorised to share.
5. Keep restricted source files linked rather than copying their contents merely for convenience.
6. Ask collaborators to confirm that they can open the Page with the expected effective permission.
7. Require the owner to review every consequential human or agent-suggested change before the document is relied on.

The trade-off is that the Page becomes a new disclosure surface. Even when a source file remains separately protected, a sentence copied or summarised from it onto the Page can be seen by Page collaborators. The Page owner must therefore review the content itself, not just the source link.

Fit rule: select a Page pilot when clarity of the current shared document outweighs the overhead of maintaining its content and permissions. Reject the pilot if the team cannot reliably determine who can see copied or summarised material.

Pattern B: several related conversations with common context

Assume a procurement group needs separate chats for supplier questions, requirement interpretation and internal planning. All conversations should use the same uploaded files and custom instructions, and the group wants context bounded to the shared work rather than members’ outside memory. This is a Project-shaped requirement according to OpenAI’s Projects documentation.

A practical selection procedure is:

1. List the conversations that must remain distinct.
2. Identify the common files and project instructions they should use.
3. Confirm that project-only memory is the desired context boundary.
4. Decide which members need Chat access and which need Edit access under the current Projects controls.
5. Define where final, approved text will live if a chat response is not itself the authoritative record.

The trade-off is that a context hub is not automatically the same thing as a maintained document. If the final decision has to be reconstructed from several chats, the team may still need an approved system of record. The official sources do not establish that a shared Project and Space Page synchronise with one another, so do not design a workflow that depends on such synchronisation.

Fit rule: select a shared Project when the continuing value lies in related project conversations using common files and instructions. If the deliverable must be edited as one stable shared document, add an explicitly governed document step rather than assuming the Project supplies an equivalent Page.

Pattern C: a source-rich Page with mixed permissions

Assume a Page summarises research from three files. One file is available to everyone, one is restricted to managers, and one may not be redistributed. Space documentation creates a precise distinction: a link to a file retains that file’s permissions, whereas content copied or summarised onto the Page is visible to people who can access the Page.

The safe procedure is to classify each source before using it:

• Linkable and broadly readable: link it and verify that intended collaborators can open it.
• Linkable but restricted: link it only if the Page audience understands that separate access is required; do not present the link as evidence everyone can inspect.
• Permitted to summarise: add only the authorised summary, then review whether the Page audience is allowed to see it.
• Not permitted to redistribute: keep its contents out of the Page and out of prompts.

A collaborator’s inability to open a linked file is not evidence that the Page has hidden the file incorrectly. It can reflect the file’s own permission boundary. Conversely, a collaborator’s inability to open the source does not make a copied summary private; once the summary is on the Page, Page access governs visibility of that summary.

Fit rule: use Space only if the team can manage both layers: access to the Page and access to each linked source. If the operating model assumes that all Page members automatically receive linked-file access, it conflicts with the documented permission model.

Pattern D: a Page expected to update itself

A team may want a “living document” to mean a document that revises itself continuously. That interpretation is not supported by the launch-specific agent guidance. OpenAI’s Space agent guide said, as accessed on 1 October 2026, that Keep Updated was unavailable at launch. Writing an instruction on a Page does not itself establish a recurring task.

If recurring work is essential, separate the requirements:

1. First decide whether a Page is the right human-readable destination.
2. Then determine whether the account has an approved scheduling capability outside the Page instruction.
3. Inspect the saved schedule, timing and enabled state.
4. Observe an actual run rather than assuming configuration equals execution.
5. Check whether the expected update appeared and whether its sources remained accessible.
6. Require a human to review any consequential change before publication or action.

The trade-off is operational overhead. A separately scheduled and reviewed update may be useful, but it is not an autonomous guarantee of freshness or correctness. If the business requirement demands certified, unattended publication, the cited Space documentation does not establish that fit.

Fit rule: reject Space as a solution to “continuously self-updating document” if that expectation depends on Keep Updated being available at launch. A Page can still be a living document in the ordinary sense that people and available agents revise it over time, subject to review.

Use a weighted decision sheet before creating anything

A small team can avoid an unsuitable choice by scoring requirements rather than features. The score should represent fit to the team’s work, not a claim about general product quality. Use three values: 2 for a documented match, 1 for an unresolved or partial match, and 0 for a documented mismatch. Give essential requirements twice the weight of optional ones.

Suggested criteria include:

• the authoritative output must be one directly editable document;
• contributors need comment-level participation where available;
• access may appropriately be inherited through a parent Page or Space;
• the team can govern copied and summarised source material;
• participants can work on web or desktop where creation and editing are supported;
• the work instead depends on several project-scoped chats;
• uploaded files and custom instructions must form common conversational context;
• project-only memory is required;
• mobile authoring is mandatory;
• unattended continuous updating is mandatory.

For example, a communications team might mark “one directly editable document” as essential, “comments” as essential, “several continuing chats” as optional and “mobile authoring” as optional. That profile favours evaluating a Page, provided current access and permissions can be confirmed. A research support team might make “several shared chats”, “common uploaded files” and “project-only memory” essential; that profile favours a shared Project.

Do not total the score blindly. Any zero on a non-negotiable requirement is a stop condition. Mobile Page authoring at launch is an example: if every contributor must create and edit from mobile, other Page strengths do not cure that mismatch. Similarly, if the team cannot prevent unauthorised summaries from being copied onto a Page, the collaboration model is unsuitable regardless of convenience.

Decision rule: use scores to expose trade-offs, but let mandatory requirements override the total. Record unresolved items as questions to verify, not as unverified assumptions.

Deciding how people and proposed agent work should share a Page raises a separate question about when specialist agents should coordinate, and the Codex multi-agent orchestration collaboration and concurrency guide covers sub-agents, collaboration tools and concurrency, which helps separate human coauthoring from coordinated agent work rather than describing Pages themselves.

Apply a permission-aware choice before the pilot

Product fit and permission fit are separate gates. A Page may be the right document surface yet still be inappropriate for a particular audience or source set. OpenAI’s collaboration documentation describes View, Comment and Edit permissions where offered, but says available options can vary with recipient, account and workspace. It also warns that access can be inherited.

Before selecting Space, create an access hypothesis on paper:

This is an example planning artefact, not a promise that every role appears for every recipient. The verification must occur in an eligible environment. If the intended “comment only” option is unavailable, do not grant edit access merely to keep the pilot moving unless the added authority is acceptable and approved.

Inherited access deserves its own check. Suppose an editor was directly invited to a Page and also belongs to the containing Space. Removing the direct Page invitation may leave Space-derived access intact. The correct test is not “was the invitation removed?” but “what access can the person still exercise, and through which path?”

Decision rule: choose a Page only when the effective permission—not merely the intended role—matches the work. For security, privacy, financial, employment, government or other consequential material, require a responsible human owner to review access, sources, proposed edits and final decisions. An agent response, sharing label or administrator title is not a substitute for that review.

Stop conditions: when not to choose Space for this job

A sound guide needs rejection criteria. Do not start the Page pilot if any of the following applies:

• The intended account does not show Space as enabled, even if its plan appears among the documented eligible plans.
• The workflow requires mobile creation or editing and current official documentation or the target device does not confirm support.
• The team needs a guaranteed continuously updating Page and is relying on Keep Updated, which the launch guidance said was unavailable.
• The owner cannot determine whether access is direct or inherited.
• The team intends to copy restricted information onto the Page to work around a linked file’s permissions.
• The workflow assumes that sharing a Page shares a person’s private chats or memory, or assumes the reverse error that Page content remains private from Page collaborators.
• The team requires an undocumented integration or automatic synchronisation with shared Projects.
• The use case depends on a particular agent, connected source or app action that has not been enabled and authorised in the target workspace.
• The team cannot provide human review for consequential edits, approvals or publication.

In these cases, the fallback is not automatically a shared Project. Reapply the unit-of-work test. A Project is suitable only if chats, uploaded files, custom instructions and project-only memory meet the actual requirement. Otherwise, retain the organisation’s existing approved document or case-management process.

Keep untrusted data and secrets out of prompts. A shared Page is not a safe place for credentials, access tokens, private keys or material that participants are not authorised to receive. Connected content can also carry misleading or malicious instructions; product safeguards do not eliminate prompt injection (hidden content that tries to redirect an assistant) or third-party risks. Treat external text as data to assess, not as instructions that an agent should automatically follow.

Final selection rule for this stage: proceed to a bounded Page pilot only when the authoritative output is a living shared document, current eligibility and device support are confirmed, effective access can be reviewed, source permissions can be respected, and a named human will approve consequential changes. Prefer a shared Project when the core need is a project-scoped hub of chats, uploaded files and custom instructions using project-only memory. Where neither description satisfies a mandatory requirement, choose neither rather than inventing interoperability or relying on an announced capability that is not yet documented as available.

Calculate access from every route, not only the invitation

A Page’s sharing panel may show a direct invitation, but that invitation is not necessarily the collaborator’s only route to the content. OpenAI’s Space collaboration documentation, accessed 1 October 2026, says access can be direct or inherited from a parent Page or Space. “Effective access” therefore means the permission a person can actually exercise after all applicable routes have been considered.

Use this distinction:

• Direct access comes from sharing the particular Page with a person or eligible recipient.
• Inherited access comes from a containing object, such as the parent Space or parent Page.
• Effective access is the practical result after direct and inherited routes are combined and the recipient’s account and workspace restrictions are applied.

For example, Priya might have direct Comment access to a Page but Edit access inherited from its parent Space. Removing the direct Comment invitation would not necessarily remove Priya’s access, because the inherited route could remain. The official collaboration guide expressly warns that removing a direct invitation does not remove access inherited from a parent Page or Space.

The safe decision rule is: never treat the direct invitation list as a complete access list. Before sharing sensitive or consequential material, trace the Page upwards through any parent Page and its Space, then confirm the recipient’s actual permission. Do the same after changing or removing access.

Separate Page ownership from control of the surrounding Space

The person maintaining a Page should not assume ownership makes its audience independent of the surrounding structure. A Page can be shared separately, but placing it under a shared parent can introduce inherited access. Conversely, sharing one Page need not mean that every other Page in the Space is shared with the same recipient.

Before placing a Page in a hierarchy, record four items:

1. the Page owner or accountable maintainer;
2. the Page’s parent, if it has one;
3. the Space in which the Page sits;
4. the people or groups who can reach it through each level.

Consider a Page owner preparing a supplier assessment. The Page is intended for three procurement staff, but its parent Space is available to a wider programme team. A direct invitation to the three staff does not narrow the audience if the programme team already inherits access through the Space. The owner should either accept the wider audience, change the parent-level arrangement where authorised, or place the assessment somewhere whose inherited audience matches the intended readership.

This is an information-architecture decision as much as a sharing decision. A broadly shared Space is suitable for broadly reusable material. It is a poor parent for a Page whose content must remain limited to a smaller review group unless the documented controls in that actual workspace produce the intended restriction.

Decision rule: if the Page’s intended audience is narrower than the parent’s audience, stop and inspect inheritance before adding content. Do not rely on a narrower-looking direct invite as proof of narrower effective access.

Before assuming that a Page inherits access from a shared Space, it is worth separating workspace authorisation from personal credentials and task state, and the shared Codex Cloud workspace permissions guide shows how workspace permissions differ from personal secrets and task state in Codex Cloud, which frames that boundary without asserting identical Page behaviour.

Interpret View, Comment and Edit as different capabilities

OpenAI’s collaboration documentation, as accessed 1 October 2026, defines View, Comment and Edit access where those options are offered. The available roles can vary with the recipient, account and workspace, so these labels must not be presented as universal choices for every invitation.

Permission	Appropriate use	Main trade-off	Review question
View	Reading a published brief, reference Page or approved status note	The recipient can consume the Page but cannot use comments or direct edits to contribute through that role	Does the person only need the current content, or must they supply feedback inside the Page?
Comment	Reviewing a proposal, raising questions or requesting corrections without directly rewriting the Page	Feedback remains separate from the maintained text, so an editor must decide what to incorporate	Is controlled review more important than immediate co-authoring?
Edit	Maintaining a genuinely co-authored working document	Collaboration is more direct, but accidental or unapproved changes become a greater operational concern	Is the recipient authorised to change the shared record rather than merely advise its owner?

Use the least-capable role that still supports the work. A policy reviewer who should identify omissions may need Comment, not Edit. A communications colleague responsible for maintaining approved wording may need Edit. A stakeholder who only needs the final timetable may need View.

This is not a claim that lower access eliminates disclosure risk. A viewer still sees material placed on the Page. Comment access can still expose all content visible on that Page. The role determines permitted interaction, not whether the shared text is confidential.

For financial approval, recruitment, security response, government services, healthcare, legal work or other consequential decisions, a Page role must not substitute for organisational authority. A person who can edit a Page is not thereby authorised to approve expenditure, select a candidate, make a legal determination or issue an official decision. Require a named human reviewer to verify both the substance and the authority for any consequential action.

Recipient type can change the options that are actually available

Do not write a sharing procedure that assumes every colleague, team, external person or account will receive the same menu of roles. According to OpenAI’s collaboration documentation accessed 1 October 2026, permission options depend on the recipient, account and workspace. Administrator settings can also constrain sharing.

A robust invitation procedure should therefore be outcome-based rather than label-dependent:

1. Identify the named recipient or intended group.
2. Choose the minimum role offered that supports their task.
3. Save the invitation or change.
4. Re-open the access information and check what was recorded.
5. Ask the recipient to open the Page through their own signed-in account.
6. Have them perform only the expected low-risk action: open, leave a harmless test comment, or make a reversible test edit.
7. Confirm that an action above the intended role is unavailable.
8. Remove the test content and record the check.

This procedure is a suggested verification method, not a guarantee that every interface exposes identical controls. If the expected role is not available, do not approximate it by granting broader access. Reconsider the collaboration method or ask an authorised workspace administrator to inspect the applicable setting.

For example, a lead wants a partner organisation to comment on a draft. If only broader access is available for that recipient configuration, the correct response is not automatically to grant Edit. The lead could collect feedback through an approved alternative, provide a separately prepared non-sensitive copy, or revise the collaboration boundary. The decision turns on whether the broader permission is acceptable, not on convenience.

Decision rule: absence of the desired permission is a stop condition, not permission to choose the nearest more powerful role.

Use an effective-access ledger for the pilot

A short ledger makes inherited and source permissions reviewable. It should describe the intended state and the state confirmed by a human, rather than copying confidential content into an access register.

Item	Record
Page	Stable name or approved internal identifier
Accountable owner	Named person or maintained organisational role
Parent Page	None, or the relevant parent
Parent Space	Space name and its intended audience
Direct recipients	Named recipients and intended roles
Inherited recipients	People or groups who gain access through a parent
External linked sources	Source owner and separately verified audience
Copied or summarised source content	Whether the copied material is suitable for every Page collaborator
Human verification	Reviewer, date and result
Next review trigger	Membership change, parent move, new source, role change or publication milestone

Keep secrets, credentials, access tokens, private keys, authentication codes and unnecessarily identifying personal data out of this ledger and out of prompts. Record a safe reference to a controlled source instead. If a task cannot be completed without exposing a secret in a prompt, stop and use an approved secure process.

The ledger should not be treated as a live reflection of the product. It is evidence of a check at a point in time. Recheck after a Page is moved, a Space’s audience changes, a direct invite is removed, a source file changes owner, or an external collaborator leaves.

Work through a page-owner, parent-Space and external-file scenario

Use the following generic scenario to understand the combined permission paths. It is an example method, not a report of product testing.

• Page owner: Alex maintains a quarterly planning Page.
• Parent Space: the Page sits in “Programme Planning”, whose members include the core planning team.
• Direct recipient: Morgan is invited to the Page to comment.
• External file: the Page links to a spreadsheet held in a separately controlled source.
• Page content: Alex also writes a short summary of selected spreadsheet figures on the Page.

There are at least three independent questions. First, can Morgan reach the Page directly? Secondly, does Morgan—or anyone else—reach it through the parent Space? Thirdly, can each Page collaborator open the external spreadsheet under that source system’s own permissions?

Step 1: state the intended audience before checking controls

Alex writes the intended result without relying on current interface labels:

• the core planning team may edit the Page;
• Morgan may read and comment but should not edit;
• no other person should receive access merely because Morgan was invited;
• the spreadsheet remains limited to separately authorised source users;
• the summary placed on the Page may be read by everyone who can access the Page.

This statement exposes a crucial distinction: Morgan may be allowed to see the summary without being allowed to open the linked spreadsheet. The summary is Page content; the spreadsheet is a separately permissioned source.

Step 2: trace direct access

Alex checks Morgan’s direct invitation and selects Comment if that option is offered for Morgan’s recipient and workspace combination. Alex then confirms the saved result rather than assuming the selection took effect.

If Morgan already has direct Edit access from an earlier phase, adding or changing another route needs careful review. The practical question is not which invitation was touched most recently, but which capability Morgan can still exercise after all routes are counted.

Step 3: trace inherited access from the parent

Alex reviews the membership and sharing of “Programme Planning”. If Morgan is also a Space member with Edit access, Morgan’s effective Page capability may be broader than the direct Comment invitation suggests. Removing Morgan’s direct invitation would still not prove removal if Space membership remains.

The same check applies to everyone else in the parent Space. A contractor who was never directly invited to the quarterly Page may nevertheless be able to reach it through inherited access. The owner should compare the full parent audience with the intended Page audience.

If the audiences do not align, Alex must resolve the mismatch before adding restricted information. Depending on the controls actually offered, that might mean choosing a more appropriate parent, revising parent membership through an authorised owner, or using a different approved collaboration surface. It does not mean assuming that the Page’s direct-sharing entry overrides inheritance.

Step 4: check the external file independently

OpenAI’s Space collaboration documentation, accessed 1 October 2026, says linked files retain their own permissions. A link displayed on the Page therefore does not establish that Morgan can open the spreadsheet. Equally, Page access should not be described as exposing the linked file automatically.

Alex asks the source owner to verify who is allowed to open the spreadsheet. Morgan then attempts to open it using Morgan’s own authorised account. If access is denied, Alex chooses among three legitimate outcomes:

1. leave the link in place and make clear that the source is restricted;
2. request source access through the organisation’s approved process, if Morgan genuinely needs it;
3. remove the link or restructure the Page if its presence is confusing or inappropriate.

Alex must not paste credentials, session cookies, access tokens or confidential source material into a prompt to work around the file restriction. Nor should a collaborator ask ChatGPT to reproduce information from a source they are not authorised to access.

Step 5: treat the written summary as shared Page content

The linked spreadsheet and the summary are governed differently. The spreadsheet keeps its source permissions. According to the same documentation, content copied or summarised onto a Page is visible to collaborators who can access that Page.

Alex must therefore review the summary itself against the Page’s whole effective audience. If the summary contains figures that only spreadsheet-authorised users may see, merely removing the link will not solve the disclosure: the restricted figures have already been copied into the shared Page.

The appropriate question is not “Can everyone open the original?” It is “May everyone with Page access see this copied or derived content?” If the answer is no, Alex should remove or suitably generalise it before sharing, subject to organisational policy and human review.

When deciding whether source material should be linked or copied into a Page, it helps to consider which context stays shared across tools, and the ChatGPT and Codex shared context guide looks at shared context, memory, Projects and cross-platform workflows as conceptual background, without documenting how Pages handle linked or copied sources.

Step 6: perform a human permission check

The owner and an authorised reviewer should inspect the effective state. For sensitive data, the reviewer should be someone responsible for the relevant information, not merely another editor who happens to have access.

A suggested check is:

1. Alex confirms the Page’s direct recipients.
2. Alex confirms the parent Page and Space audiences.
3. Morgan opens the Page using Morgan’s own account.
4. Morgan leaves a harmless example comment.
5. Morgan checks that direct editing is unavailable if Comment is the intended effective role.
6. A core planning editor makes and reverses a harmless example edit to confirm Edit access.
7. Morgan opens the spreadsheet link and reports whether the source system grants or denies access.
8. The source owner independently confirms whether that result matches the approved source permissions.
9. Alex and the information owner review every copied or summarised item for the Page’s wider audience.
10. Alex records the date and outcome without placing confidential details in the ledger.

This check is mandatory for the scenario because neither documentation nor the owner’s intent proves the organisation’s actual configuration. For security, privacy, financial, employment, government, healthcare or other consequential material, require explicit human approval before sharing, publishing or acting on the Page.

Step 7: test removal through every route

Suppose Morgan’s review ends. Alex removes the direct Page invitation. That is only the beginning of the check.

Alex must ask:

• Is Morgan still a member of the parent Space?
• Does a parent Page still confer access?
• Does another permitted sharing route remain?
• Does Morgan retain separate access to the spreadsheet?
• Has any Page content been copied elsewhere under a different audience?

The removal test should be performed through Morgan’s own account after the authorised changes have been saved. If Morgan can still open the Page, the owner should locate the remaining route rather than repeatedly deleting and recreating the direct invitation.

Decision rule: access is removed only when a human check shows that every relevant route has been removed or deliberately retained. “Not listed as a direct recipient” is not sufficient evidence.

Do not confuse a linked source with information placed on the Page

The linked-versus-copied distinction should govern what a team imports into its first Page. A link acts as a reference to a separately controlled item. Copied text, extracted figures and written summaries become part of the Page’s visible content.

Treatment	Who can see it?	Operational consequence
Link to a source file	Page collaborators can see the link, but opening the source remains subject to the file’s own permissions	Verify source access separately; do not promise that every collaborator can open it
Verbatim passage copied to the Page	People with Page access can see the copied passage	Check that the Page audience is authorised to receive it
Summary written from the source	People with Page access can see the summary	Review derived facts as potentially sensitive even when wording differs from the source
Aggregate or redacted statement	People with Page access can see the resulting statement	Have a qualified human verify that aggregation or redaction is sufficient for the intended audience

Summarisation is not a permission-preserving mechanism. A short summary can reveal the same restricted fact as a long source. For example, “Three employees are under formal investigation” may disclose sensitive employment information even if names and the original case file are omitted. A qualified human must decide whether the statement is appropriate for the Page audience.

Use a source-handling procedure before adding material:

1. Identify who owns or controls the source.
2. Identify the Page’s complete effective audience.
3. Decide whether the Page needs a link, a quotation, a summary or no inclusion at all.
4. Check whether each proposed copied or derived fact may be disclosed to that audience.
5. Remove unnecessary personal, confidential or secret information.
6. Ask the responsible human to approve consequential or sensitive material.
7. Recheck after the audience or source classification changes.

Decision rule: use a link when collaborators should encounter the source system’s own permission check. Copy or summarise only when every effective Page recipient is permitted to receive the resulting information and the duplication serves a defined purpose.

Keep private chats and private memory distinct from shared Page text

OpenAI’s Space feature documentation, accessed 1 October 2026, says sharing a Page does not share private chats or private memory. The September 2026 release notes also describe collaborators as using their own ChatGPT. A shared Page should therefore not be described as giving collaborators access to the owner’s account, conversation history or personal memory.

That boundary does not make everything associated with Page work private. Anything deliberately written, pasted, copied, summarised or generated onto the shared Page is visible to people with Page access. Comments and edits made within the shared object should likewise be treated as collaborative content, not as a private conversation with the owner’s ChatGPT.

Consider this example:

• Alex has a private chat containing rough notes about staffing.
• Alex shares a planning Page with Morgan.
• The act of sharing the Page does not, by itself, share Alex’s private chat or private memory.
• If Alex copies a staffing conclusion from the private chat onto the Page, that conclusion becomes visible to the Page audience.

The privacy boundary follows the content, not its origin. Material does not remain private merely because it began in a private conversation. Before turning chat material into Page content, reread it for personal data, confidential assumptions, unsupported claims and information that the intended audience should not receive.

A useful pre-publication question is: Would every person with effective Page access be permitted to read this sentence if it arrived in an ordinary shared document? If not, do not place it on the Page.

Use separate review gates for personalisation and shared evidence

Private memory or prior chats may influence a user’s individual interaction, but collaborators should not assume they can inspect or rely on that private context. Shared work should contain the evidence, definitions and decisions needed by authorised readers, subject to source permissions.

For example, an editor should not write “Use the assumptions from my previous chats” and expect collaborators to verify the Page. Instead, the editor should add the permitted assumptions explicitly, cite or link the authorised sources, and label unresolved points. If those assumptions cannot safely be shared, they should not silently underpin a consequential shared decision.

Trade-off: making evidence explicit improves collaborative review but also makes that evidence visible to the Page audience. If the evidence cannot be disclosed, reduce the audience, use an approved restricted source, or keep the decision outside the Page. Do not obscure the source boundary by asking ChatGPT to paraphrase restricted information.

Review agent contributions under the same permission model

An agent-assisted revision does not create a new exemption from Page access rules. Text added to the Page becomes Page content and should be reviewed for everyone who can access it. Available agents and connected tools depend on access, according to OpenAI’s Space agent guide accessed 1 October 2026; the existence of a Page does not prove that a particular agent can reach every linked source.

Use agents as proposed-edit collaborators:

1. Give a bounded task using non-secret, permitted material.
2. Specify whether the requested output is a comment, a proposed passage or a direct Page change where supported.
3. Ask for uncertainties and source gaps to be marked rather than guessed.
4. Review the response and every Page change.
5. Check copied facts against their authorised sources.
6. Check that no restricted source content has been exposed to the Page’s broader audience.
7. Require a named human to approve consequential conclusions and external actions.

An example instruction might be: “Using only the material already authorised for this Page, propose a three-bullet summary. Mark any claim that lacks a visible source. Do not add personal data or infer missing figures.” This is a suggested prompt, not a guarantee of accuracy or compliance. A human must compare the proposal with the sources and inspect the final Page.

If an agent cannot open a linked file, do not bypass the restriction by pasting secrets or restricted extracts into the prompt. Either obtain authorised access through the source owner, provide a permitted non-sensitive extract, or leave the source-dependent task to an authorised human.

Set review triggers instead of relying on a one-off audit

Permission review is not complete forever. The relevant audience can change when membership, hierarchy, source access or content changes. Use event-based checks rather than an arbitrary claim that permissions are “set”.

Recalculate effective access when:

• the Page is moved beneath a different parent;
• the parent Space gains or loses members;
• a direct recipient’s role changes;
• a direct invitation is removed;
• an external collaborator joins or leaves;
• a new linked file is added;
• linked material is copied or summarised onto the Page;
• the Page begins to contain financial, employment, security, government or other consequential material;
• an agent proposes or applies a substantial revision;
• the document moves from drafting to approval or publication.

At each trigger, compare intended access with confirmed effective access. Record mismatches and stop sharing or publication until an authorised human resolves them. If the product’s available controls cannot produce the required boundary, choose a different approved process rather than weakening the requirement.

Apply a final effective-permission gate

Before the pilot Page is used for real work, its owner should be able to answer all of these questions:

• Who owns the Page and who is accountable for its content?
• Which people have direct access, and at what verified role?
• Which people inherit access from a parent Page or Space?
• Does any recipient have broader effective access than the direct invitation suggests?
• Which files are merely linked and governed by separate permissions?
• Which source facts have been copied or summarised into shared Page content?
• Can every effective Page recipient legitimately see that copied or derived content?
• Has a human tested access through the intended recipient accounts?
• Has removal been checked across direct and inherited routes?
• Are private chats and private memory being kept distinct from material deliberately placed on the Page?
• Have agent changes been reviewed against the source and audience?
• Has an authorised human approved any security, privacy, financial, employment, government or other consequential use?

If any answer is unknown, label it unresolved and pause the affected sharing or decision. The practical standard is not that the sharing panel looks plausible; it is that a human has traced direct access, inherited access, linked-source access and copied-content visibility, then confirmed the result with the relevant recipients and information owners.

Run a bounded Page pilot before widening access

A useful first pilot should test one collaboration pattern, one permission boundary and one proposed agent edit. It should not attempt to migrate a department’s documents, connect every available source or automate publication. The pilot is bounded when its owner can name the Page, its intended recipient, the permitted evidence, the requested change, the reviewer and the conditions for stopping.

Use a low-risk document whose temporary incompleteness or accidental internal visibility would not create a material consequence. Suitable examples include a draft meeting agenda, an internal glossary built from non-sensitive material, or a retrospective template containing no personal performance information. Do not begin with payroll, customer credentials, unreleased financial figures, medical information, recruitment decisions, disciplinary records, government casework or security incident details. Those subjects require the organisation’s own controls and qualified human review; a small product pilot is not an authorisation to process them.

OpenAI’s launch documentation of 29 September 2026 describes Pages as directly editable documents on which people can collaborate and leave comments, while ChatGPT can help draft or revise them. The DevDay recap dated the same day documented Space and Pages for Pro, Business and Enterprise users, subject in practice to account, workspace and administrator conditions. It described web and desktop as supporting Page creation, editing and collaboration. Mobile could find, read and share Pages at launch, while mobile creation and editing were still described as coming soon. Check current official documentation and the target workspace immediately before the pilot rather than treating that launch position as permanent.

Define the test on one control sheet

Before creating or sharing anything, record the pilot in a short control sheet outside the Page or in an approved administrative record. This separates the test’s governing conditions from the content being tested. A Page editor should not be able to change the success criteria unnoticed merely by editing the Page.

An example control sheet could contain the following fields:

Field	Example entry	Decision rule
Pilot object	Draft agenda for an internal process-review meeting	Use one Page, not a folder-wide or Space-wide migration.
Owner	Named knowledge-work lead	One person remains accountable for access and final text.
Collaborator	One named colleague who needs to comment	Do not invite a group merely for convenience.
Intended permission	Comment, if that role is offered for this recipient	Grant the least capability that completes the test.
Source	One approved internal guidance file	Check the file’s access separately from Page access.
Agent task	Propose a clearer ordering for three agenda items	No unsupervised publication or consequential decision.
Human reviewer	Page owner	Review the reply, changed content and comments before acceptance.
Stop condition	Unexpected inherited access, unavailable role or inaccessible source	Pause rather than compensate by copying restricted material.

The example is intentionally narrow. A comment-only recipient tests discussion without giving that person direct editing capability. An editing pilot is reasonable when co-authoring is the feature under evaluation, but it increases the number of changes the owner must inspect. The decision rule is simple: choose Comment when feedback is sufficient; choose Edit only when the collaborator must alter the Page itself and the owner can review those alterations.

Do not put passwords, access tokens, private keys, authentication cookies, confidential personal records or other secrets into the Page, a prompt, a comment or a connected-source request. Treat source text and collaborator comments as untrusted input. They may contain mistaken instructions, misleading claims or text that attempts to redirect an agent. Connected tools and product safeguards do not eliminate prompt-injection, privacy, retention or third-party risks.

Create one low-risk Page with a visible evidence boundary

Create a single Page using an eligible web or desktop environment. The official release notes dated 29 September 2026 say a user can turn a conversation into a Page, start from a template or write directly in Space. For a permissions pilot, beginning with a blank Page is usually easier to audit because it avoids unintentionally carrying material from a prior conversation into the shared object.

Give the Page a title that identifies both its purpose and its non-final status. For example, Process review agenda — pilot draft — not approved is more useful than Agenda. Put a short scope note at the top:

Example Page notice: This Page is a low-risk collaboration pilot. It contains a proposed agenda based on the linked internal guidance file. The owner must review agent suggestions, collaborator comments and source access before using the agenda. It is not an approved policy or meeting instruction.

This notice is a suggested method, not a product-enforced control. It helps readers interpret the content but does not override Page permissions, prevent copying or prove that a reviewer has approved the draft. If a formal approval record is required, use the organisation’s designated approval system.

Add only enough content to make the proposed change assessable. A practical Page structure is:

1. Purpose: one sentence defining the meeting’s intended outcome.
2. Draft agenda: three to five numbered items.
3. Evidence: the linked source and a note explaining what it supports.
4. Open questions: matters requiring human confirmation.
5. Change record: a brief note of the requested agent edit and its disposition.

Do not paste the full source merely to make the pilot self-contained. According to the Space collaboration documentation accessed on 1 October 2026, a linked file retains its own permissions, whereas content copied or summarised onto a Page is visible to collaborators who can access that Page. The distinction is operational: linking tests whether each person has authorised source access; copying distributes that selected content through the Page’s audience.

Use a label beside the source, such as Linked source — separate permission required. Then add only a non-sensitive statement needed for the test, if sharing that statement is authorised. The label does not change permissions, but it helps prevent a collaborator from interpreting the visible link as proof that they can open the underlying file.

Invite one collaborator with the narrowest useful role

Open the Page’s current sharing controls and inspect the roles actually offered for the named recipient. Official Space documentation accessed on 1 October 2026 defines View, Comment and Edit access, but also says that recipient, account and workspace conditions can affect the options available. Do not write a procedure that assumes every role or link-sharing mode appears in every environment.

If the collaborator only needs to flag ambiguity, select Comment where that role is available. If the person only needs to confirm that the final text is readable, View may be enough. If the test specifically concerns co-authoring, use Edit. Record the saved role in the pilot control sheet after sharing; recording the role requested before saving is not evidence of the role that took effect.

Next, inspect whether the recipient already has access through a parent Page or the surrounding Space. Direct and inherited access are separate routes. Removing a direct invitation may not remove access inherited from a parent or Space. A clean one-person pilot therefore requires two observations: the role shown on the invitation and the collaborator’s effective access after all inheritance is considered.

Ask the collaborator to open the Page using their own account and report what they can actually do. They should not borrow the owner’s session or credentials. A suitable check is:

• Can the collaborator open the Page?
• Can they perform the intended action, such as adding a comment?
• Can they perform an action that should be unavailable, such as directly rewriting Page text under a comment-only role?
• Does their access appear to come from a direct invitation, a parent Page or the Space?
• Can they open the separately linked source using their own authorised account?

The negative check matters. Confirming that a comment can be added does not establish that editing is blocked. Conversely, an inability to edit is not a defect when Comment was the intended permission. The pilot passes the permission stage only when the permitted action works, the disallowed action does not work, and the source’s independent access matches the intended audience.

If the collaborator unexpectedly has broader access, stop before adding more material. Check inherited routes and workspace sharing settings. Do not attempt to “fix” the problem merely by deleting the direct invitation, because inherited access may remain. If the intended role is unavailable for that recipient, either choose a recipient type for which the required control is documented and authorised, reduce the sensitivity of the Page, or end the pilot.

Specify an agent change as a proposal, not an instruction to approve

After the human access check, define one agent task whose quality can be judged from the visible Page and its permitted source. Avoid an open-ended request such as Improve this document. It obscures what the agent may change and makes review unnecessarily broad.

A bounded request identifies the target, allowed transformation, protected content and expected response. For example:

Example proposed-edit request: Propose a revised order for agenda items 2–4 so that background is discussed before decisions. Preserve the meeting date, owner names and quoted policy wording. Do not add facts that are not present on this Page or in the linked source. Explain each proposed move in a comment or response before the change is accepted.

This example does not guarantee that an agent will follow every constraint or that the result will be correct. The Space agent guide, as accessed on 1 October 2026, says available agents and connected tools depend on access and directs users to review replies, proposed edits and Page changes. Treat the response as draft work even if it appears polished.

If the interface offers a way to ask for a change on selected content, select only the relevant agenda items rather than the entire Page. A selection-level request narrows the material exposed to the task and reduces the review surface. If the workflow uses a mention in a comment or an instruction embedded on the Page, make the requested output and protected fields equally explicit. A stored instruction is context; it is not an approval mechanism.

Where an agent or connected tool is not available to the account, recipient or workspace, do not infer that the Page is defective. Record the unavailable capability and continue with the human collaboration portion, or stop if agent editing is the feature being evaluated. The cited documentation does not establish universal access to every agent, Dots assistant, connected app or Codex capability in Space.

To keep proposed agent changes reviewable in a Page workflow, each request should be a small, understandable unit of work, and Codex task decomposition for agent-ready subtasks explains how to break complex projects into agent-ready subtasks, which supports scoping edits for review without offering Page approval controls.

Review the response, Page content and comments separately

An agent interaction can leave evidence in more than one place. Review the conversational response, the Page text and any comment thread as separate records. A correct-looking explanation does not prove the Page received the same change, and a changed Page does not prove the rationale was sound.

Use this three-pass procedure:

1. Response pass: read the agent’s explanation. Identify every claimed source, inferred fact and proposed move. Reject unsupported additions even when they improve the prose.
2. Content pass: compare the Page before and after the proposal using the version or change information that is actually available in the target environment. Check dates, names, quotations, numerical values, links, headings and omissions.
3. Comment pass: read open comments from both the collaborator and agent. Resolve only those whose substance has been verified; do not treat “resolved” as equivalent to “correct”.

If the product shows version information, note which visible version or state the reviewer examined. Do not invent version numbers or assume a particular version-history interface. If a reliable before-and-after view is not available, preserve an approved copy through an organisation-sanctioned method before requesting the change, or manually compare the narrow selected passage. The decision rule is that the owner must be able to identify what changed; otherwise, reject the edit and restore the last reviewed text.

For the agenda example, the review should answer concrete questions. Did the proposed order place background before decisions? Were the date and owner names unchanged? Was quoted wording preserved exactly? Did the agent introduce a new claim about policy, timing or responsibility? Does its explanation match the edit that appears on the Page? Any failed protected-field check is a reason not to accept the proposal.

Comments need their own disposition. A collaborator might write, Should item 3 name the approving team? That is a question, not evidence that a particular team has authority. The owner should verify the answer with the authorised source or responsible person before changing the Page. If verification is unavailable, retain it under Open questions rather than asking the agent to guess.

For security, privacy, financial, employment, government, healthcare, legal or other consequential material, require review by an appropriately authorised human before action, distribution or approval. An agent must not be the sole decider, and a collaborator’s ability to edit does not establish their authority to approve. The pilot’s owner should distinguish authorship, factual verification and formal approval in the change record.

A concise example entry is:

Example change record: Proposed change: reorder agenda items 2–4. Agent response reviewed by Page owner. Protected fields checked: date, names and quotation. Collaborator’s authority question remains open pending confirmation from the process owner. No approval or external publication authorised by this review.

This is an example record, not a product-generated audit trail. If the organisation requires immutable logs, regulated records or formal sign-off, verify that its approved systems and workspace configuration meet those requirements. Do not infer compliance merely from comments or visible editing history.

Verify the linked source from the recipient’s account

Page access and linked-source access must be tested independently. Ask the invited collaborator to follow the source link using their own signed-in account. The valid outcomes are not simply “works” or “fails”; each outcome implies a different content decision.

Observed outcome	Interpretation	Next action
The collaborator can open the Page and source	Both access paths appear available to that person at that time.	Continue, while retaining separate ownership and access records.
The collaborator can open the Page but not the source	Page sharing did not grant file access.	Request source access through its owner, replace it with an authorised source, or limit claims to shareable evidence.
The collaborator can open a Page summary but not the source	The summary is shared Page content even though the file remains restricted.	Confirm that distributing the summary itself is authorised; otherwise remove it.
The collaborator can open the source but not the Page	Source permission does not imply Page permission.	Review the Page invitation and inherited routes without changing the source.
The collaborator has broader source access than expected	The issue belongs to the source’s permission system, not only the Page.	Stop and refer access correction to the source owner or administrator.

Do not solve inaccessible evidence by pasting it into the Page. That action changes the distribution boundary: collaborators who can see the Page can see the copied or summarised material. The correct choice depends on authorisation, not convenience. If the recipient legitimately needs the underlying source, obtain access through the source system. If they only need an authorised extract, record who approved that extract and review it for sensitive details before placing it on the Page.

Also confirm that the invitation reached the intended recipient. Similar display names, forwarding addresses or group aliases can make a visually plausible recipient incorrect. Use the organisation’s approved identity-verification method and ask the recipient to confirm from their own account. Do not send sensitive sample content merely to test identity.

Close the pilot with a removal and retention check

A pilot is incomplete until the owner examines what happens when collaboration ends. Remove the direct invitation after the review window, then ask the collaborator to check access again. If access remains, inspect inheritance from the parent Page or Space. The official collaboration documentation specifically warns that removing direct access does not necessarily remove inherited access.

Do not describe successful removal until every known route has been checked. The result may be one of three things: access ended as intended; access remains through an authorised parent route; or access remains unexpectedly and requires administrator or owner action. Record the actual state, not the intended state.

Then decide what to do with the Page. Keep it only if there is a named owner, a continuing purpose and an appropriate review interval. Otherwise remove or archive it using the workspace’s approved process. Retention follows applicable workspace policy and configuration; this guide cannot establish a particular organisation’s retention or deletion behaviour.

The pilot passes only if all of the following are true:

• the named collaborator received the intended effective permission;
• a disallowed action was unavailable;
• the linked source’s separate access was understood and checked;
• copied or summarised content was authorised for the Page audience;
• the agent’s response, resulting content and comments received human review;
• protected fields and factual claims were verified;
• the owner could identify the current reviewed state;
• direct and inherited access were checked during removal; and
• no automatic update or approval was assumed.

A failed pilot is still informative. If the required permission is unavailable, inheritance cannot be narrowed, the evidence cannot be shared safely or changes cannot be reviewed adequately, do not widen the audience. Choose a different document boundary, keep the work in an approved source system, or use a shared Project if the real need is continuing conversational context rather than a jointly maintained document.

A bounded Space Page pilot should be judged before wider rollout, so that a learning trial is not mistaken for a production model, and enterprise AI agent orchestration from pilot to production discusses the broader move from pilot projects to production deployment, offering a scaling frame for that decision rather than a Page implementation guide.

Use a shared Project when continuing chat context is the job

The alternative pilot should test a different working object rather than trying to reproduce a Page inside a Project. Official Projects documentation, accessed on 1 October 2026, describes a shared Project as a context hub for chats, uploaded files and custom instructions. It also says shared Projects use project-only memory, meaning they do not draw on individual members’ memories or context outside that Project.

Choose this route when the team’s immediate need is a continuing series of conversations that should use common project context. Examples include separate chats for requirements questions, meeting preparation and issue triage, all grounded in the same uploaded files and custom instructions. Choose a Page-led Space pilot when the primary deliverable is one maintained document on which people need to view, comment or edit directly.

A bounded shared-Project alternative can use the same low-risk subject:

1. Create one Project for the internal process-review meeting.
2. Add only the approved reference file or files needed for the test.
3. Write custom instructions that define the meeting purpose and prohibit unsupported claims.
4. Start one chat to draft agenda options and another to list unresolved questions.
5. Invite one collaborator with the access role actually offered and appropriate for the task.
6. Ask the collaborator to continue one chat using the shared project context.
7. Review outputs and file access before using any proposed agenda.

The practical distinction is what the team returns to. In the Page pilot, members return to a document whose wording and comments are the shared object. In the Project pilot, they return to project-scoped chats, files and instructions. A Project may produce text that later becomes a document, but the cited documentation does not make that equivalent to Page permissions, Page comments or inherited Page/Space access.

Do not transfer undocumented assumptions between the products. The supplied official Projects source does not establish a directly comparable rule for separately linked files, a matching mobile creation matrix or identical permission names. Mark those points as not directly comparable. Evaluate each product’s current controls in the intended workspace.

Use this decision rule after both bounded exercises: select Space and a Page if reviewers need one visible, directly maintained document with Page-centred comments and permissions; select a shared Project if the durable unit of work is a set of related conversations grounded in common files and instructions. If both are needed, define a hand-off rather than duplicating uncontrolled copies—for example, exploration in a Project followed by human-reviewed transfer of an approved draft into a Page.

That hand-off creates a new review boundary. Before moving text, verify citations, remove private or irrelevant conversational material, confirm that the Page audience may see the copied content and identify the owner responsible for later updates. Project-only memory should not be described as a Page property, and Page sharing should not be described as exposing a user’s private chats or personal memory.

Keep recurring work separate from Page editing

Do not claim that a Page automatically updates. Although product descriptions may use broad language about living or updating work, the more specific Space agent guide accessed on 1 October 2026 states that Keep Updated is unavailable at launch. It says recurring work must be configured separately in ChatGPT and then verified through the saved schedule and an actual run.

Writing update this every Monday on a Page, in a prompt block, in a comment or in agent instructions does not by itself prove that a scheduled task exists. It may communicate an intention to a reader or agent, but intention is not execution. Keep the Page-editing pilot and any scheduling pilot as two distinct tests with separate owners and acceptance criteria.

If recurring work is authorised and available in the account, use this verification procedure:

1. Define the recurring task outside ambiguous prose. Record the intended source, cadence, time zone, target output and human reviewer.
2. Configure it through the separate scheduling capability actually available. Do not invent a control or assume availability from the presence of a Page.
3. Inspect the saved schedule. Confirm that the task exists, is enabled, has the intended timing and names the expected destination or output.
4. Check source authority again. The schedule must not bypass the permissions of linked files, connected accounts or recipients.
5. Observe an actual run. A saved schedule is evidence of configuration, not evidence that execution or Page updating succeeded.
6. Review the produced content. Compare it with the authorised source, inspect omissions and unsupported claims, and require human approval before consequential use.
7. Check the destination. Confirm where the output appeared; do not assume that it changed the Page unless the observed run shows that result.
8. Test pause or removal. Verify that disabling the schedule prevents later runs, subject to the controls actually shown.

For example, a team may want a weekly digest of non-sensitive process updates. The Page can state the desired digest format, but the schedule must be created separately. The owner should inspect the saved cadence and enabled state, wait for an authorised test run, verify the source material used, review the resulting digest and confirm whether anything was written to the Page. Until those checks are complete, label the Page as manually maintained.

Do not use a first scheduling test for security alerts, payment instructions, employment actions, regulatory submissions, public statements or government decisions. Such work requires authorised human review and the organisation’s established systems. Even for low-risk material, keep untrusted source instructions and secrets out of prompts, and do not permit an agent-generated update to become an autonomous approval or publication step.

The final decision gate is evidence-based: a Page is current only to the date and state a human has reviewed; a schedule exists only when its saved configuration is visible; a recurring process works only after an actual run has been checked; and an update is acceptable only after its content, sources, destination and audience have been verified.

Final decision matrix: shared Page, isolated Project, or neither

This matrix is a documented product-surface comparison, not a hands-on benchmark. It reflects OpenAI documentation published or accessed up to 1 October 2026. Availability, controls and client support can change, so the final decision must be based on what the intended owner and collaborators can actually access in the target ChatGPT workspace.

Decision criterion	Choose a shared Page in Space	Choose a shared Project	Choose neither	Verification before proceeding
Primary work product	The team needs one directly editable document, such as a maintained brief, handbook, plan or decision record. Comments and differentiated View, Comment or Edit access are relevant where those roles are offered.	The work is organised primarily around continuing chats, uploaded files and custom project instructions. Project-only memory is important because the shared context should remain within that Project.	The required output is a controlled record that must remain in an approved records, publishing or document-management system, and no authorised process exists for using ChatGPT as a drafting surface.	Write a one-sentence description beginning “The shared object is…”. If the answer is a document, evaluate a Page first. If it is a body of project-scoped conversations and context, evaluate a Project first. If neither product can satisfy the organisation’s handling rules, stop.
Collaboration model	Several people need to read, comment on or edit the same Page, each through their own ChatGPT account. The owner is prepared to review direct and inherited access.	Members need access to common chats, files and instructions within a shared context hub. The cited Projects documentation describes Chat or Edit access rather than the Page role model.	The team needs a role, approval chain, guest-access model or publication control that is not shown in the available interface or established by the official documentation.	Record the minimum role needed by each participant. Do not infer that every recipient can receive every role. Confirm the saved permission from the owner’s side and the effective permission from the recipient’s side.
Context and memory boundary	The team understands that sharing a Page does not expose the owner’s private chats or personal memory, but anything written, copied or summarised onto the Page becomes visible to people who can access it.	The team specifically wants shared work to use project-only memory. OpenAI’s Projects documentation says a shared Project does not access members’ memories or context outside that Project.	The proposed workflow depends on an undocumented assumption about personal memory, cross-project context or access to another person’s private account data.	List every expected context source. Label it as Page text, linked material, Project chat, uploaded Project file, custom instruction or unsupported assumption. Reject any design whose operation depends on the final category.
Source permissions	The owner can distinguish links from copies. A linked file retains its own permissions; text copied or summarised onto the Page follows Page visibility.	The needed materials can be handled as Project chats, uploaded files and instructions under the organisation’s approved process. The cited documentation does not establish an equivalent linked-file permission rule for Projects.	Collaborators must not see the source text, but the intended workflow requires reproducing or summarising that text in a shared object.	Have one intended recipient open each linked source separately. Then review the Page for quotations, extracts and summaries that disclose information even when the original link remains inaccessible.
Permission inheritance	The owner can trace access inherited from a parent Page or Space and is willing to test removal through every route.	The owner prefers membership and context management at Project level and has verified the controls shown for that Project.	The organisation cannot identify who may inherit access or cannot perform a reliable offboarding review.	Remove a test user’s direct invitation, then check whether parent-Page or Space membership still provides access. A successful removal requires the user to lose every access route that the policy says should end.
Agent-assisted editing	ChatGPT or another access-dependent agent may propose revisions, but a named person will inspect the response, resulting Page changes and relevant comments before acceptance.	artificial intelligence (AI)Computer systems designed to perform tasks that normally require human intelligence, such as understanding language, recognising patterns, or making predictions. Open glossary entry-assisted discussion should occur mainly through project-scoped chats using the Project’s files and instructions.	The process requires autonomous approval, publication, payment, hiring, dismissal, entitlement, safety or compliance decisions without qualified human review.	Assign a reviewer before invoking an agent. If no accountable person can compare a proposed change with its sources and authority limits, do not allow the change into the working record.
Recurring updates	A Page may contain instructions or receive reviewed edits, but recurring work will be configured separately where supported. The owner will verify the saved schedule and an actual run.	A Project may hold the context for recurring discussion, but the cited documentation does not establish a Project scheduling guarantee.	The business requirement depends on a Page continuously updating itself without separate scheduling and operational checks.	Under the Space agent guide accessed on 1 October 2026, Keep Updated was unavailable at launch. Treat an instruction written on a Page as text, not as proof of a scheduled task.
Client requirement	Creation and editing can be performed on web or desktop. Mobile-only participants need only the documented find, read and share functions.	The Project’s required functions have been confirmed on every client the team intends to use; the cited documentation does not provide a matching mobile comparison.	The workflow requires mobile Page creation or editing before current official documentation confirms that support.	Test the actual client for the intended action. Do not convert “coming soon” into a launch date or implementation promise.
Plan and workspace eligibility	The account is on a documented eligible plan and Space is enabled. As of the research date, OpenAI named Pro, Business and Enterprise.	The participants can create or join the required shared Project under their current account and workspace settings.	The necessary product is absent, disabled by an administrator, unavailable to a recipient or unsupported by the organisation’s policy.	Check the target account rather than relying on plan name alone. A launch announcement does not prove that rollout, regional access or administrator approval is complete for a particular user.
Retention and governance	The Page and its copied content can be retained under the target workspace’s policy, and the owner has an archive, deletion or handover procedure.	The Project’s chats, files, instructions and membership can be governed under the target workspace’s approved retention process.	No responsible owner can establish the applicable workspace policy, preserve required records or delete material when authorised to do so.	Ask the workspace administrator or policy owner to confirm the actual retention configuration. Product documentation is not proof of a customer’s settings or legal obligations.
Consequential use	The Page is a collaboration and evidence surface, not the sole authority for security, privacy, financial, employment, government, health, legal or other consequential decisions.	The Project is used to assemble context and discussion, with decisions routed to qualified people and approved systems.	The proposed use would allow generated content to trigger a consequential decision without human verification, source checking and required organisational approval.	Define the point at which work leaves ChatGPT and enters the authoritative process. Require human review at that boundary and again before any irreversible action.

Decision rule: choose a shared Page only when the maintained document is the centre of work and its effective permissions can be demonstrated. Choose a shared Project when shared chats, files, instructions and project-only memory are the centre of work. Choose neither when a mandatory access, retention, approval, client or source-control requirement remains unverified. A feature’s presence is not enough; the workflow must also fit the organisation’s actual configuration.

Apply a three-gate selection procedure

Gate one: prove eligibility and client support

1. Identify the owner’s plan, workspace and client.
2. Confirm that Space or shared Projects are visible and enabled in the account that will own the work.
3. Repeat the check for at least one representative collaborator, especially if that person belongs to a different account type or workspace.
4. Confirm that the intended action is supported on the intended client. For Pages, the launch documentation distinguishes web or desktop creation and editing from mobile finding, reading and sharing.
5. Record the date of the check because rollout and support may change.

Example: a lead intends to create and revise a Page from a desktop client, while two travelling reviewers need only to read and share it on mobile. That arrangement fits the documented launch split if the relevant accounts expose Space and the required sharing controls. It does not establish that those reviewers can comment or edit on mobile. If mobile editing is mandatory, the pilot should pause until current official documentation and the actual client confirm it.

Trade-off: designing around documented launch support may restrict where editing occurs, but it avoids making an operational process depend on a “coming soon” capability. If web or desktop access is unacceptable, neither option should be selected merely to preserve the original project timetable.

Gate two: prove the information boundary

1. Inventory the material proposed for use: original files, links, pasted passages, summaries, personal data and generated text.
2. For a Page, distinguish content placed on the Page from files that are only linked. The former is visible according to Page access; the latter retains the source file’s permissions.
3. Check whether each collaborator is authorised to receive both the Page text and every separately protected source.
4. Remove secrets, credentials, authentication tokens and other material that should not be exposed to a model or collaborator. Keep untrusted data and secrets out of prompts.
5. If connected sources are involved, verify the user’s actual source access and the workspace’s app settings. Being able to view a Page does not grant access to a linked source.

Example: a Page links to an internal planning file and contains a three-paragraph summary of it. A contractor cannot open the file but can view the Page. The inaccessible link does not protect the summary: the contractor can read whatever has been written on the Page. The owner must either authorise that disclosure, remove or redact the summary, or exclude the contractor from the Page.

Decision rule: if the workflow relies on collaborators seeing a summary while being barred from the information conveyed by that summary, the design is internally inconsistent. Change the content or the audience before sharing.

Gate three: prove accountable review

1. Name the Page or Project owner and a backup owner or handover contact.
2. Define which participants may draft, comment, edit or approve outside ChatGPT.
3. Require source comparison for factual changes and a separate authority check for policy or decision changes.
4. Record unresolved claims as open questions rather than allowing generated wording to make them appear settled.
5. Route security, privacy, money, employment, government and other consequential matters to qualified human reviewers and the organisation’s authorised systems.

Example: an agent proposes changing a supplier-risk statement from “review pending” to “approved”. A fluent rewrite does not supply approval authority. The reviewer should reject or revert the status change unless the designated approver and authoritative record support it. The same principle applies whether the proposed wording appears in a Page or a Project chat.

Choose neither when the collaboration surface would become the wrong authority

“Neither” is a positive governance decision, not a product failure. A Page or Project can help prepare material without becoming the system that authorises or records the final action. Select neither as the primary working surface in any of the following cases:

• Unresolvable audience conflict: participants need access to the shared document, but copied or summarised material would disclose information they are not authorised to receive.
• Unknown effective permissions: the owner cannot determine whether access comes from a direct invitation, a parent Page, a Space or another route.
• Unsupported client dependency: completion depends on mobile Page creation or editing while the current documented and observed client does not support it.
• Unverified retention: nobody can establish the applicable workspace policy or meet the organisation’s required preservation, deletion or legal-hold process.
• Autonomous consequential action: generated text would approve expenditure, alter employment status, grant government benefit, publish security advice or make another high-impact decision without qualified human review.
• Secret-dependent prompting: the task cannot be performed without placing passwords, tokens, private keys or similarly sensitive secrets in a prompt.
• Required control absent: the process depends on a role, audit facility, application action or compliance integration that has not been confirmed for the target workspace.

A practical alternative is to keep authoritative records in the approved system and use ChatGPT only with permitted, minimised material for a bounded draft. For example, a team may draft a non-sensitive outline in a Page, export or transfer the reviewed text through an approved process, and conduct formal approval in its records system. This is an example workflow, not a guarantee that export, integration or approval features are available in a particular account.

Plan, workspace and client caveats that can reverse the choice

OpenAI’s DevDay recap of 29 September 2026 and the Space feature documentation accessed on 1 October 2026 described Space and Pages for Pro, Business and Enterprise users. That statement must not be extended to Free, Go, Plus, Education, Healthcare, every market or every account. It also does not override administrator settings or prove that rollout has reached an otherwise eligible user.

Use this availability check immediately before a pilot:

1. Open the official Space feature and release documentation and note any change to the named plans.
2. Check whether Space is enabled in the target signed-in workspace.
3. Ask the relevant administrator whether sharing or permission changes are restricted.
4. Check the owner’s web or desktop client for Page creation and editing.
5. Check each required mobile action separately; do not treat reading, sharing, commenting and editing as interchangeable.
6. Verify the recipient’s actual role options, because account, workspace and recipient type can affect what is offered.

Enterprise controls require particular care. The Enterprise documentation accessed on 1 October 2026 says that disabling new sharing can block new shares and permission changes while leaving existing shared access in place. Therefore, an administrator should not treat “sharing disabled” as proof that all previous recipients have lost access. Existing Pages and Spaces require a separate access review.

An Admin role also must not be treated as automatic access to every compliance interface, connected source or application action. App authorisation, source permissions and sensitive compliance access are separate questions. Confirm each control with the responsible administrator rather than inferring it from a broad role name.

Retention, sharing and offboarding review

The Enterprise guide says retention follows workspace policy. That is a direction to inspect the customer’s policy, not a universal retention period. The cited documentation does not establish a single Space-specific retention duration, deletion guarantee or legal-hold behaviour for every plan.

Before sharing

• Record the owner, purpose and intended lifespan of the Page or Project.
• List all intended recipients and the narrowest useful role for each.
• Review inherited access from the surrounding Space or parent Page.
• Classify every source as linked, copied, summarised, uploaded or generated.
• Remove secrets and unnecessary personal or confidential information.
• Confirm that the workspace’s retention and sharing policy permits the material.
• Require human review for consequential content before it is relied upon or transferred elsewhere.

During collaboration

• Review access when the audience, parent structure or information sensitivity changes.
• Inspect agent edits rather than approving them solely because they are well written.
• Check citations and linked evidence from the recipient’s account where source access matters.
• Keep a short access ledger recording direct access, inherited access, source-file access, date checked and reviewer.
• Do not paste untrusted instructions from external content into prompts without inspection. Safeguards do not eliminate prompt injection (hidden content that tries to redirect an assistant) or third-party risk.

At handover, removal or closure

1. Transfer ownership or operational responsibility through an authorised process where required.
2. Remove the departing participant’s direct access.
3. Check parent Page and Space access separately.
4. Test the participant’s effective access rather than assuming the invitation removal was sufficient.
5. Review linked source permissions independently; loss of Page access does not itself prove loss of source access, and the reverse is also true.
6. Apply the workspace’s approved archive, retention or deletion procedure.
7. Record unresolved copies or derived summaries in other authorised systems.

Worked example: an editor leaves a programme. The owner removes the editor’s Page invitation, but the editor remains a member of the parent Space. Documentation indicates that inherited access can remain, so the removal is incomplete. The owner must review and, if authorised, remove the Space-level route as well. The owner must then check any separately linked file in its source system. Only after all relevant routes have been reviewed should the offboarding record state that access has ended.

Frequently asked questions about documented limits

Is Space better than a shared Project?

No universal ranking is supported by the cited official documents. A Page is the clearer candidate when the working object is an editable shared document with comments and Page-oriented permissions. A shared Project is the clearer candidate when the working object is a collection of shared chats, uploaded files and custom instructions using project-only memory. Choose against a stated collaboration pattern, not the newer product or the longer feature list.

Does sharing a Page reveal the owner’s private chats or memory?

OpenAI’s documentation says Page sharing does not expose private chats or personal memory. However, content written, copied or summarised onto the Page is visible to people with Page access. Review the Page itself for disclosure; do not assume information remains private merely because it originated in a private chat.

Can every collaborator receive View, Comment or Edit access?

Do not assume so. The Space collaboration documentation describes those roles where offered, but says available options can depend on the recipient, account and workspace. Select the narrowest role shown, save it, and have the recipient confirm the effective result.

Does removing a direct invitation revoke access?

Not necessarily. Access inherited from a parent Page or Space may remain. Trace and test every route. Disabling new sharing at an Enterprise administration level also does not, according to the cited guide, automatically remove existing shared access.

Can a collaborator open every file linked from a Page?

No such guarantee is documented. Linked files retain their original permissions. Test each important link from the collaborator’s account. Conversely, remember that copied or summarised source material on the Page may be readable even when the original file is not.

Will Page instructions make the Page update itself?

They should not be treated as a schedule. The Space agent guide accessed on 1 October 2026 says Keep Updated was unavailable at launch. Recurring work must be separately configured where supported, after which the owner should inspect the saved schedule, timing and enabled state, observe a real run and verify the resulting update.

Can an agent approve or publish its own changes?

The cited official documents do not authorise that conclusion. Treat agent work as proposed content. A human must review the response, edits and evidence before acceptance. Security, privacy, financial, employment, government and other consequential decisions require qualified human judgement and the organisation’s formal approval process.

Is Space available on mobile?

The 29 September 2026 recap and feature documentation described mobile support for finding, reading and sharing Pages, while creation and editing were unsupported at launch or described as coming soon. Recheck current documentation and the actual client. Do not infer a mobile editing date.

Does an eligible plan guarantee access?

No. The launch sources named Pro, Business and Enterprise, but entitlement can still depend on rollout, workspace enablement, administrator controls and other conditions. The cited documentation does not provide a geographic availability matrix.

Does Space have a documented standalone price or usage rate?

The cited documentation does not establish a Space-specific price or metering model. Do not import prices or usage assumptions from Codex or any other product. Confirm current commercial terms through the account’s authorised purchasing route.

Does an administrator automatically gain all compliance or connected-source access?

No such automatic grant should be assumed. The Enterprise documentation distinguishes administration from sensitive compliance access, while connected applications and source permissions have their own controls. Verify the exact role and authorisation required for each operation.

Are Pages a replacement for shared Projects or conventional document systems?

The official sources do not support a replacement claim. Pages and Projects have different documented centres of work. An organisation may also require an external document, records or publishing system to remain authoritative. Decide where drafting, review, approval, publication and retention occur rather than forcing one surface to perform every role.

Unknowns that must remain explicit

Unknown	Why it cannot be assumed	Action
Complete regional availability	The cited official documents do not provide a geographic matrix.	Check current official availability and the target account. Do not publish a country list without a current official source.
Rollout completion for an eligible plan	A product announcement is not proof that every account has received the feature.	Verify Space in the owner’s and representative recipients’ accounts.
Current mobile editing support	Launch documentation said creation and editing were coming soon or unsupported at launch.	Recheck the feature page, release notes and actual mobile client before making mobile editing part of the process.
Exact role options for every recipient	Permission choices depend on account, workspace and recipient.	Inspect and test the offered role rather than standardising an assumed role list.
Space-specific cost or metering	No cited source establishes a Space price or usage schedule.	Use current account and procurement information; do not estimate from another product.
Customer-specific retention and audit configuration	Documentation says retention follows workspace policy but does not prove any customer’s settings.	Obtain confirmation from the responsible administrator or governance owner.
Availability of a particular agent, named assistant or connected tool	Agent and tool access depends on plan, market, workspace settings and authorisation.	Confirm the capability in the target environment and provide a manual fallback.
Directly equivalent linked-source behaviour in Projects	The cited Projects source does not establish a matching rule for the linked-file model documented for Pages.	Mark the comparison as not directly comparable and test the intended Project workflow separately.
Reliability or accuracy of generated edits	The documentation describes collaboration functions, not an accuracy benchmark or certification.	Use source comparison, subject-matter review and formal approval where required.

Status at the time of writing

A final approval record for the lead

Before adopting either surface, complete a short record that another reviewer can understand without reconstructing the pilot:

Chosen surface

Shared Page, shared Project, or neither.

Reason

One sentence identifying the primary shared object and why the selected surface matches it.

Owner

The person accountable for access review, content review and closure.

Audience

Named groups or individuals, with the minimum required role and any inherited route.

Information boundary

What may be written or uploaded, what may only be linked, and what must remain outside prompts and shared content.

Human review boundary

Who checks generated edits, who approves consequential claims and which external system records the final decision.

Client and eligibility evidence

The plan, workspace and clients checked, with the date.

Retention and closure

The applicable policy, review date and procedure for handover, removal, archive or deletion.

Outstanding unknowns

Any feature, permission, cost, region, integration or compliance detail that remains unverified.

Sample decision record: “Use one shared Page for the reviewed programme brief because the maintained document, comments and differentiated access are the centre of work. Keep restricted source files linked rather than copied, but remove any summary that would disclose restricted information. Use web or desktop for editing. Treat agent revisions as proposals reviewed by the programme owner. Keep formal financial approval in the authorised finance system. Recheck inherited access and retention at the end of the pilot.” This is an example of a governance record, not a promise that every stated control is available in every account.

Final decision rule: proceed only if the team can demonstrate eligibility, a safe information boundary and accountable human review. If any gate remains unknown, narrow the pilot or choose neither until it is resolved. Do not compensate for a missing control with an informal promise, and do not treat generated confidence as evidence.

Useful Links

• OpenAI DevDay 2026 documentation
• OpenAI DevDay 2026 recap
• ChatGPT Space feature page
• ChatGPT release notes
• Collaborate in ChatGPT Space
• Work with agents in ChatGPT Space
• Manage ChatGPT Space and shared Pages
• Projects in ChatGPT