ChatGPT Work + Codex for Teaching 2026: What Shipped

OpenAI has shipped the thing teachers have been asking for since GPT-4 landed in classrooms: a workspace layer built for instruction. The ChatGPT Work Codex education rollout adds instructor-controlled workspaces, shared project spaces students can join without sharing an account, and Codex tooling designed for assigning and reviewing coding work. This is a product change with setup steps you can run today, not another position paper. It’s arriving in a week where every other OpenAI headline is a lawsuit or a safety eval, so most people will miss it.

What’s actually new in ChatGPT Work Codex education

The core of the release is the instructor workspace. Previously, a teacher running ChatGPT Work for a department had the same admin surface as a startup ops lead — seats, SSO, retention policy, and little else. The education layer adds a role between admin and member. An instructor can create project spaces, invite students into a specific space rather than the whole workspace, set which models and tools are available inside that space, and see activity at the space level. That last part matters more than it sounds. Instructors get visibility into what a shared space produced without reading every student’s private chat history, which is the compromise most institutions were stuck on.

Shared project spaces are the second piece. A project space bundles instructions, uploaded files, and a connector set into one container, and everything a student does inside that space inherits the container’s configuration. Practically: you upload the course reader, write a system-level instruction that says “answer only from the attached materials and always cite the section,” attach a Google Drive folder of problem sets, and every student conversation in that space starts from those constraints. Students don’t need to be prompt engineers. They need to open the right door.

Third — and this will actually change how CS courses run — Codex now supports assignment-shaped workflows. An instructor points Codex at a repository, defines a task scope, and hands students an environment where the agent works inside a sandboxed clone with a configurable permission profile. Turn the agent down to review-only so it comments on a student’s pull request without writing code, or open it up for a “pair with the agent” exercise where the point is learning to direct it. The Codex classroom setup path uses the same AGENTS.md conventions the CLI already reads, so a repo you configure for your own team works as coursework with no rewrite.

Why ChatGPT Work Codex education matters

• The account problem is solved. Schools have been sharing logins, buying individual Plus seats, or telling students to use the free tier and hope. Space-scoped invitations mean a student joins a course, not an org.
• Grounding beats policing. A project space that only answers from the course reader is a better academic-integrity mechanism than a detector that flags honest students. You change what the tool can say instead of guessing what the student did.
• Codex makes AI-assisted coding gradeable. When the agent runs in a sandboxed clone with a recorded task scope, the diff and the transcript are both artifacts. You can assess how a student directed the agent, which is the actual job skill now.
• Instructor visibility without surveillance. Space-level activity gives a defensible middle position for institutions that can’t legally read student conversations but can’t run ungoverned tools either.
• Config travels. These OpenAI education tools 2026 reuse existing primitives — projects, connectors, AGENTS.md — so course setup is portable between sections, semesters, and colleagues. Export the config, hand it to the adjunct teaching the other section.
• It resets procurement conversations. A named instructor role and space-scoped data boundaries are the two things IT committees have been blocking on. This gives the person championing the pilot something concrete to bring to the meeting.

How to use ChatGPT Work for teachers today

1. Get the instructor role assigned. A workspace admin has to grant it — instructors can’t self-promote. If you’re the admin, do it from Settings → Members, then confirm from the API that the change propagated:

   curl https://api.openai.com/v1/organization/users \
     -H "Authorization: Bearer $OPENAI_ADMIN_KEY" \
     -H "Content-Type: application/json"

2. Create one project space per course section, not per course. Sections diverge — different pacing, different make-up assignments, different students. Name them so they sort: CS210-Fall26-SecA, CS210-Fall26-SecB.

3. Write the space instruction before you invite anyone. This is the highest-leverage twenty minutes in the whole ChatGPT Work workspace guide. A starting template that works across disciplines:

   You are a teaching assistant for CS210: Data Structures.
   
   RULES
   - Answer only from the attached course materials. If the answer
     is not in them, say "That's outside our course materials" and
     name the closest section that is relevant.
   - Never write a complete solution to a graded problem. Ask what
     the student has tried, then give the next single step.
   - Always cite the source: [Reader, section 4.2] or [Lecture 7].
   - If asked to write code, write pseudocode first and ask the
     student to translate it before you produce any real code.
   - If a student says they are stuck for more than two attempts,
     give a worked example on a DIFFERENT but analogous problem.

4. Attach materials, then test the boundary yourself. Upload the reader, syllabus, and problem sets. Then try to break your own rules — ask directly for a graded solution, ask something off-syllabus, ask it to ignore the instructions. If it caves, tighten the wording and retest. Do this before students find the gap, because they will.

5. Set up the Codex repository for coding assignments. Configure the assignment repo with an AGENTS.md at the root. Codex reads it as standing instruction for every session in that repo:

   # AGENTS.md
   
   ## Scope
   Work only in `src/assignments/`. Never modify `tests/` —
   those are the grading tests.
   
   ## Setup
   npm ci
   npm test
   
   ## Rules for this course
   - Explain your plan before editing files.
   - After each change, run `npm test` and report which tests
     moved from fail to pass.
   - Do not add dependencies without asking.
   - Do not modify `.github/workflows/`.

6. Choose the permission profile per assignment. This dial decides what the assignment actually teaches. Review-only for early-semester work where you want students writing every line; full agent access for later projects where the skill under assessment is direction and verification. Students launch into the configured environment with:

   npm install -g @openai/codex
   codex --cd ./assignment-03

7. Require the transcript as a submission artifact. Ask for the code and the session log. Grade the log for whether the student caught the agent’s mistakes. A student who accepted a wrong suggestion and shipped it should score below one who rejected three suggestions and wrote a worse-looking solution they understand.

8. Run a two-week pilot on one section before scaling. Instrument it: a short survey at week one and week two, plus your own read of ten transcripts. Do not roll it out department-wide off a vibe.

How it compares

Capability	ChatGPT Work + Codex	Google Gemini for Education	Microsoft Copilot for Education	Anthropic Claude for Education
Instructor role distinct from admin	Yes, new in this release	Via Workspace admin roles	Via Entra/Teams roles	Limited
Course-scoped shared context	Project spaces with pinned files and instructions	Gems plus Classroom integration	Copilot agents in Teams channels	Projects
Agentic coding coursework	Codex with repo scope and permission profiles	Gemini Code Assist, not education-scoped	GitHub Copilot with education licensing	Claude Code, no classroom layer
LMS integration	Connector-based, no native gradebook	Deep Classroom integration	Deep Teams integration	LTI partnerships
Best fit	CS and technical courses, repo-based work	K-12 and Workspace-standardized districts	Microsoft-standardized institutions	Writing-heavy and seminar courses

The honest read: if your institution already lives in Google Workspace or Microsoft 365, those platforms win on gradebook and roster plumbing. OpenAI wins on the agent. Nobody else ships a classroom-configurable coding agent with per-assignment permission profiles right now, and for CS departments that single capability outweighs the LMS gap.

What’s next

The missing piece is grading. Everything in this release produces artifacts — transcripts, diffs, session logs — and none of it flows into a gradebook. Expect LTI support or a roster-sync API to be the next shoe to drop, because every pilot will ask for it by week three. Until then you’re exporting manually, so build your assignment workflow around a submission you can collect the normal way.

Watch the permission profile system specifically. Right now it’s a coarse dial. The interesting version is per-file or per-directory policy — let the agent write in src/, read but not write lib/, and never touch tests/. The AGENTS.md convention already hints at that shape, and enforcing it at the sandbox level rather than as instruction text would make Codex coding assignments genuinely tamper-resistant instead of merely well-behaved.

The larger question is pricing and access. Education layers historically get introduced on business tiers, then either get their own SKU or quietly become table stakes. If OpenAI wants classroom share it needs an institutional price a department chair can approve without a procurement cycle. Watch for that announcement, and watch whether the free tier gets a student pathway — that decision determines whether this becomes infrastructure or stays a pilot toy for well-funded schools.

Frequently Asked Questions

Do students need their own paid ChatGPT accounts?

No. That’s the point of space-scoped invitations. A student is invited to a specific project space within the institution’s ChatGPT Work workspace rather than provisioned a full seat, so access ties to course enrollment rather than an individual subscription.

Can instructors read student conversations?

Instructors see space-level activity, not individual private chat history. Full conversation access remains an org-admin capability governed by your institution’s retention and privacy policy. Check what your admin has configured before you promise students anything about privacy — the defaults differ at every institution.

Does this stop cheating?

No, and don’t sell it that way. It changes the shape of the problem. A grounded project space that refuses to write graded solutions and cites its sources makes the honest path easier than the dishonest one, and a Codex transcript gives you evidence of process rather than a guess about it. Students who want to bypass it will open a personal account. Design assignments accordingly.

What’s the minimum viable setup for a non-technical instructor?

One project space, one instruction block, and your syllabus plus reader uploaded. Roughly thirty minutes, no CLI, no repo. Everything involving Codex is optional and only relevant if you’re teaching code.

Does Codex work with languages other than JavaScript and Python?

Yes. Codex operates on the repository as it finds it — the language constraint is whatever your setup and test commands in AGENTS.md can run. Java with Maven, Rust with Cargo, and C with Make all work fine, provided the environment can install the toolchain and the test command exits with a meaningful status code.

How do I handle students who don’t want to use AI at all?

Build an equivalent non-AI path into the assignment and say so on the syllabus on day one. This is both an accessibility and a good-faith issue, and it will come up. The cleanest version makes the learning objective language-neutral — “produce a correct implementation and explain your verification method” — so the same rubric grades both paths without a separate assignment.