What Work mode is for

It is Monday at 9:40. Your manager drops three files in chat: last week’s meeting notes, a half-finished partner list, and a slide title that only says “status.” You open ChatGPT, paste the notes, and get a clean summary. Fine. Then you spend the next half hour copying bullets into slides, rebuilding a tiny table by hand, and hunting for the one number that lived only in the partner list. A teammate pings: “Why didn’t you just use Work?” You have used ChatGPT for months. You still treat every job like a conversation.

This is Part 1 of the ChatGPT Work tutorial. The series is for people who already know how to talk to ChatGPT in Chat and now need a clear picture of Work mode: agentic, multi-step office work with apps, files, and deliverables you still own. If orientation is fuzzy (plans, first-week safety, memory), start with Learn ChatGPT from scratch. If Chat vs Work vs Codex still blur in a meeting, keep the ChatGPT product map open. Everyday drafting habits without agent blast radius live in the ChatGPT everyday tutorial. Here we go deep on what Work is for, what it is not, and how to choose it without burning a week of usage on the wrong door.

UI labels, plan packaging, and which surface gets which feature still move. Treat names and rollout notes below as a July 2026 field guide. Re-check openai.com/chatgpt-work, chatgpt.com/work, and help.openai.com the week you write team policy or buy seats.

What you’ll learn

A plain definition of Work as multi-step office work, not “Chat that tries harder”
How Work relates to Chat and Codex on desktop, and why web/mobile parity is plan-shaped
What kinds of jobs earn the agent loop (decks, sheets, docs, multi-file synthesis)
Why Work usually burns more usage than Chat, and how to scope before you start
A chooser table and worked Monday examples you can say out loud
Common mistakes that waste limits or land the wrong artifact in Slack
What Part 2 will make concrete: first agentic task with approvals

Work in one sentence

Work is the agent-shaped mode in ChatGPT for longer, multi-step office jobs. You give it a goal. It can gather context across apps and files you allow, plan steps, use tools and plugins, and produce finished-looking deliverables such as decks, sheets, docs, reports, and related artifacts. You follow progress, answer questions, steer, and approve important actions. You still review before anything is final.

That is different from Chat. Chat is conversational assistance: you ask, you get a reply, you edit, you leave. You remain the operating system. Work is different from Codex too. Codex is the coding agent for software work in projects: repos, diffs, tests, pull requests. Work is knowledge work and office deliverables. Codex is software. Mixing those names in a standup is how three people leave with three different plans under one brand.

Rule of thumb: Chat answers and drafts with you. Work runs multi-step office work toward a deliverable you still check. Codex changes software under review. Pick by the artifact you need when you are done.

What ChatGPT Work is for: multi-step goals, apps and files connected, deliverables such as decks sheets and docs; not…

Why Work exists at all

For years, “I used ChatGPT” meant a chat box. That was enough for subject lines, outlines, and first drafts. Real office work is messier. The status deck needs numbers from a sheet, owners from a meeting note, risks from a Slack thread, and a template your VP already likes. In Chat, you become the glue. You paste, you re-paste, you hope you did not miss the second file that imports the first.

Work exists because multi-step office work wants a different loop: goal, plan, tools, checkpoints, deliverable, review. OpenAI’s product language is blunt about that. Work is an agent designed for longer, multi-step work and finished deliverables. Chat stays for fast, conversational help and everyday questions. Codex stays dedicated to software development and technical work. Same login family. Different job types.

At work, vocabulary costs money. Finance may approve a Plus seat and still be shocked when agent sessions burn capacity. IT may allow browser Chat and still restrict local files or connectors. An analyst who only knows Chat will paste CSVs into a thread while an ops lead expects a multi-file pack in Work. Name the mode. Plans, permissions, and review habits become discussable once the door has a name.

Where Work shows up (desktop, web, mobile)

As of mid-2026, the desktop app is where OpenAI made the three-mode split hardest to ignore. Chat, Work, and Codex live together in the ChatGPT desktop experience on Mac and Windows. That matters for muscle memory: you open one app, then you choose a job type, not a separate brand for every task.

Web and mobile Work are real, but completeness is plan-shaped. Official product pages describe Work as available more broadly on desktop, with fuller web and mobile access on paid tiers such as Plus, Pro, Business, Enterprise, and Edu. Free can be enough to learn the shape of Work on desktop. Day-to-day multi-step office work usually becomes practical when usage budgets support longer agent runs. Do not invent parity in your head. If a teammate’s phone can only check progress while your laptop runs the deep file job, that is normal for this product stage, not a personal failure.

Desktop: deepest workflows

Desktop is the right home when local files, desktop apps, richer browser workflows, and Codex live next door. If the only clean copy of the partner PDF pack is on your laptop, plan on desktop for that job. If you need to sit beside a spreadsheet window and a browser tab while the agent works, desktop is built for that kind of side-by-side friction.

Web and mobile: start, steer, check

Web is still the lowest-friction start for many people: no install, IT can often allow-list a domain, and you can kick off work from a locked-down laptop. Mobile is useful for starting, reviewing, and steering when your plan and app version support it. Treat mobile as “great for check-in and light direction,” not as the place you invent your whole security model for folder access and plugins.

Surface	Best for	Watch-out
Desktop	Deeper Work runs with local files, apps, browser workflows; Chat and Codex in the same install	Update the app; confirm which account is signed in before you grant folders
Web	Starting and steering when install is blocked or files already live in cloud tools	Feature parity with desktop still moves by plan and product stage
Mobile	Check progress, answer a quick question, redirect a task away from the desk	Do not design policy from phone screenshots alone

What Work is good at

Work earns its keep when one careful conversation is not enough and the job is still office work, not a software project. The unit of success is a package you can review: a deck outline with a supporting sheet, a multi-section brief from several sources you provided, a cleaned tracker from messy notes, a first-pass report that still needs a human for numbers and tone.

Examples that belong in Work when your plan, policy, and permissions allow:

Turn a folder of meeting notes into a structured status brief with open questions and owners
Build a multi-section report from several sources you explicitly provide or connect
Produce a first-pass deck plus a supporting sheet of numbers you will verify
Coordinate multi-file office work (docs, sheets, slides) under approvals instead of copy-paste gymnastics in Chat
Run a longer delegated task where intermediate steps matter and you want progress, not one shot of text
Synthesize survey themes, pipeline changes, or launch risks into a share-ready pack (still with your review)

Notice the pattern. Each job has more than one step. Each job wants tools or multiple inputs. Each job ends in something someone else might open. That is the Work lane. A subject-line rewrite is not the Work lane. A one-paragraph “make this friendlier” is not the Work lane. Those stay in Chat, where you already practiced structure and audience in the everyday tutorial.

Chat vs Work: the split that saves usage

People waste money and patience by treating Work as Chat with a longer reply. A longer Chat thread is still a conversation. Work spends more because multi-step agents take more tool calls, more context, and more time. That is not a moral failing of the product. It is why Free can feel generous for chat demos and tight for agent demos.

Chat versus Work quick split: Chat answers in thread with lighter usage; Work plans and acts with tools and higher usage

	Chat	Work
Primary job	Answers, drafts, planning talk, Q&A	Multi-step office work toward a deliverable
How it touches work	You paste or upload; reply stays in the thread	Agent plans, uses tools/apps/files you allow, produces artifacts
What “done” looks like	Text you move yourself	Deck, sheet, doc, brief, or pack you still review
Usage feel	Usually lighter for the same “thinking out loud”	Usually heavier: more steps, more tools, longer runs
Good first job	Rewrite an email from notes	Build a short status pack from notes and a list you own
Bad default	Pretending a long reply already reorganized a folder	Spending agent capacity on a one-line subject fix

If you already burned half your weekly limit on agent demos that were really “rewrite this paragraph,” that is a chooser problem, not a model problem. Scope the job in one sentence before you open Work. “Make it better” is not a scope. “From these three notes I own, produce a 6-slide status outline and a one-page risk table I will verify” is a scope.

Work vs Codex: office files, not shipping code

Codex is for software. If success looks like a green test suite, a reviewable diff, and a pull request description that matches what changed, open Codex. If success looks like a deck your director can open in the afternoon meeting, open Work. You can paste code into Chat. That is still conversation about code. It is not Codex. Work can touch code-shaped files in some office workflows, but it is not the place to pretend you shipped production software without a developer review loop.

This series stays on Work. The later ChatGPT Codex tutorial is where install, first project, and git-friendly habits belong. For now, one hard rule: do not open Work to ship code, and do not open Codex to rewrite a press release.

Approvals, control, and “stay close”

Work is useful because it can act across tools. That is also why it needs adult supervision. Product materials stress that you stay in control: follow progress, answer questions, change direction, and approve important actions. Plan-style modes (where available) let the agent gather context and propose steps before a long run starts. Use that. Approving a plan is cheaper than undoing a half-built mess after the agent already spent your usage budget.

Stay closest when the task touches money, outbound messages, or sensitive files. “Draft the partner email and leave it unsent” is a different risk class from “send the partner email.” “Build a status deck from notes I own” is a different risk class from “open the shared drive and tidy finance exports.” Part 2 of this series walks a first task with approvals on purpose. Part 1 only needs the mindset: agent power without approval habits is how people create confident garbage at scale.

What you still own

Truth of numbers. If a slide becomes a board figure, a human owns the check against source systems.
Names, dates, and owners. Agents invent plausible people and timelines. Your org chart does not care.
Tone and commitments. A polished deck can still promise a date nobody agreed to.
Policy. Personal accounts, Business seats, and Enterprise controls are different trust boxes. Paste rules from Learn ChatGPT still apply.
Send and spend. Auto-send and unsupervised money moves are not “productivity.” They are career fuel.

Usage: Work burns more than Chat

Chat is usually the cheaper way to spend a limit: one prompt, one reply, a couple of follow-ups. Work spends more because multi-step agents take more tool calls, more context, and more “thinking” time. Parallel tools, long projects, and vague goals make the meter spin faster. Free can open the door for orientation. Heavy weekly Work usually wants a paid plan with a real usage budget (Plus, Pro, Go where offered, Business, Enterprise).

Practical habits that protect capacity:

Prefer Chat for language-first jobs until the remaining work is truly multi-step
Write a one-sentence outcome before you start Work
Attach only the files and tools the job needs
Ask for a short plan and approve it before a long run when the product offers Plan mode
If you hit a limit mid-task, export what you already have instead of re-running the whole loop blind
On shared Business seats, heavy Work sessions can be a team cost, not a private hobby

A chooser you can say in one breath

Ask three questions out loud before you switch modes:

Is the main artifact language, office files, or code? Language-only conversation → Chat. Office multi-step deliverable → Work. Repo and software → Codex.
Is one careful conversation enough? If yes → Chat. If you need tools, multiple inputs, and intermediate steps → Work (or Codex for engineering).
Am I willing to review intermediate steps and the final pack? If you need a 30-second subject line, stay in Chat. Agents shine when review is part of the job.

If you pick wrong, stop early. Copy useful text out, open the right mode, and start clean rather than dragging an office agent through a one-line rewrite or a coding agent through a stakeholder email.

Chooser table for real Mondays

Use this when a meeting gets fuzzy. Pick the row that matches the job, not the demo video.

Job you actually have	Default mode	Why
Draft, rewrite, explain, plan, Q&A in a thread	Chat	Conversation is the unit of work; low setup
Multi-step office work with apps, files, slides, sheets, docs	Work	Agent for knowledge work deliverables you still review
Explore a repo, edit files, run tests, open or review a PR	Codex	Coding agent with developer workflows
One short email from notes	Chat	Agent overhead is waste
First-pass status deck from notes and a list you own	Work	Multi-step pack; still low external risk if you do not auto-send
Unclear, sensitive data, or high liability	Slow down: policy + Chat sandbox first	Do not grant folder or app access by default

Worked example: one launch phrase, three doors

Imagine a 30-minute standup. The product manager says, “Let’s use ChatGPT on the launch.” Without a map, four people walk away with four plans.

Alex (PM) opens Chat, pastes the brief, and asks for a timeline critique plus risks for sales. Correct door for that slice of work.

Sam (ops) opens Work, points at meeting notes and an allowed set of partner PDFs, and asks for a one-page risk table plus a first-pass status deck outline. Correct door if policy allows the files and tools involved, and if Sam reviews before anything external leaves the building.

Jordan (engineer) opens Codex against the repo, asks for a dark-mode toggle that matches existing patterns, reviews the diff, runs tests, opens a PR. Correct door.

Riley (data) starts pasting production customer IDs into Chat on a personal Free account because “it’s faster.” Wrong door, wrong account, wrong data. Riley should use approved tools, scrubbed samples, and whatever path IT named for sensitive work.

The phrase “use ChatGPT” was incomplete. The fixed version is longer and clearer: “Alex: Chat for the brief. Sam: Work for the partner pack if legal says yes. Jordan: Codex for the UI change. Riley: no customer IDs in personal Chat, full stop.” That sentence saves two days of crossed wires.

What “finished deliverable” does and does not mean

Marketing likes the word finished. Your career likes the word reviewed. A Work run can produce polished spreadsheets, docs, and slides that look meeting-ready. Looking meeting-ready is not the same as being correct. Treat agent output as a strong intern draft with excellent formatting: fast, useful, still checked.

A useful mental checklist before you present a Work pack:

Do the numbers match sources you control?
Are names, titles, and dates real for your org this week?
Did the agent stay inside the scope you asked for?
Would you put your name under every claim on slide three?
If this pack were wrong, who gets hurt first?

Later parts of this series go deeper on multi-step jobs and result checks. For Part 1, keep the bar simple: Work can assemble a package faster than you can. It cannot own your reputation.

Plugins, apps, files, and the blast radius

Work gets more powerful when it can pull context from tools you already use: files, connected apps, plugins, browser paths on desktop, and similar access you grant. Power without a blast-radius plan is how a learning session becomes an incident report. Start narrow. Prefer copies of non-sensitive materials you own. Prefer “draft and leave unsent” over “send.” Prefer one folder over your entire Documents tree.

If your company has Business or Enterprise ChatGPT, admin controls and workspace policy matter as much as the mode label. Folder access, connectors, and what counts as approved data are not personal taste. They are policy. When money or compliance is real, re-check OpenAI’s current plan matrix and your IT notes rather than a Slack rumor from last quarter.

Common mistakes

Treating Work as “Chat that tries harder”

A longer Chat thread is still a conversation. Work is multi-step agent work with tools and deliverables under review. If your org allows Chat but restricts folder or app agents, those are different policy lines for a reason.

Opening Work for a one-shot rewrite

Subject lines, tone tweaks, and short rewrites belong in Chat. Agent overhead costs usage and attention. Save Work for jobs that need steps, tools, and a package.

Opening Work to ship code

Shipping software is Codex’s lane (plus your review, tests, and merge habits). Work can help with docs around software. It is not a substitute for a coding agent in a real project tree.

Assuming every surface is equal

Desktop, web, and mobile do not always carry the same depth on every plan. Start policy from desktop and web realities, then layer mobile for check-in.

Skipping review because the deck looks pretty

Polish is not truth. Numbers, names, and commitments still need a human. Pretty wrong is worse than ugly honest.

Granting the whole world on day one

First tasks should use low-risk inputs you own. Connect only what the job needs. Stay close on money, messages, and sensitive files. Part 2 turns that into a concrete run.

How this series fits the AMS ChatGPT path

On Analytics Made Simple, ChatGPT learning is a ladder, not a pile of random tips:

Learn ChatGPT from scratch: what it is, plans, first minutes, modes overview, memory, multimodal, connectors, judgment
ChatGPT product map: Chat vs Work vs Codex, Custom GPTs, models, light API notes
ChatGPT everyday tutorial: writing, planning, learning, long docs, email and workplace writing without agent blast radius
ChatGPT Work tutorial (you are here): deep Work mode for multi-step office jobs
Later: Codex tutorial, then Custom GPTs

If you skipped straight here from a marketing page, that is fine. Bookmark Learn and the product map so you do not invent policy from demos. Wider curriculum paths also sit on Learn.

Practice for this week

Do not start with a high-stakes client pack. Do this instead:

Write three jobs from your real week on a sticky note.
Label each Chat, Work, or Codex using the chooser table above.
Pick the lowest-risk Work candidate: a deliverable built from notes you own, not something that auto-sends or touches money.
Confirm which surface you will use (desktop preferred for first deep run) and what plan capacity you actually have.
Stop before you run it. Part 2 is the first agentic task with approvals.

Quick recap

Work is multi-step office work with tools and deliverables you still review
Chat is conversation; Codex is software; Work is office packages
Desktop holds Chat, Work, and Codex together; web/mobile Work is more complete on paid plans
Work burns more usage than Chat; scope in one sentence before you start
Stay close on money, messages, and sensitive files; approve important actions
Not for one-shot rewrites; not for shipping code
Next: first agentic task with approvals (Part 2)

What’s next

Part 2: First agentic task with approvals walks a concrete low-risk run: owned notes into a short status deliverable, tight connections, approval habits, and a review loop before anything leaves your desk. After that, multi-step jobs and result checks (Part 3), then when Work beats Chat and when it does not (Part 4).

Sources

Official product and help materials used for this article (re-check the week you set policy; UI and plan packaging move):

OpenAI: ChatGPT Work for every team (product overview, desktop vs web/mobile availability notes, deliverables and control language)
ChatGPT Work on chatgpt.com (use cases, plan-shaped access, start/steer/review framing)
OpenAI: ChatGPT is now a partner for your most ambitious work (announcement framing for Work as multi-step agent work)
OpenAI Help: ChatGPT Work and Codex (Chat vs Work vs Codex job split; Work for longer multi-step work and finished deliverables)
OpenAI Help Center (live UI steps, plan matrices, and enterprise release notes for your account type)
OpenAI: ChatGPT and chatgpt.com (entry points for plans and product home)
Analytics Made Simple: Learn ChatGPT from scratch
Analytics Made Simple: ChatGPT product map
Analytics Made Simple: ChatGPT everyday tutorial
Analytics Made Simple: Learn