Lesson 12.712.7 How today's tools realize it

How Claude Code does it. Claude Code is the Code tab in the Claude desktop app. A session is one conversation tied to a folder, on your computer (Local) or on Anthropic's machines (Cloud), where it keeps going after you close the app.⁶

1. Open the Claude desktop app and choose the Code tab. If you do not have the app yet, download it, and 0.2.4 shows how to set it up.

2. Choose Open folder… and pick brightline-ap.

3. In the row under the message box, look at the environment selector, and keep Local.

4. Send: "What does this folder hold, and how is it tested? Do not change anything." Then read the cards beside the chat.

   

5. Ask: "Is there a folder next to this one called live-export? Tell me if you could not check."

6. Click + New. Your first session is still in the sidebar, and clicking it resumes it.

What you should see. A session in brightline-ap, on your computer, that describes the folder and changes nothing, and both sessions in the sidebar. If the agent looks next door, or asks to, you have seen that the folder is not a wall.

How Codex does it. Codex is a mode of the ChatGPT desktop app. A chat runs in the folder you open, on this computer, in a git worktree on this computer, or in the cloud, from an environment you set up once.⁷

1. Open the ChatGPT desktop app, open the ChatGPT dropdown, and select Codex. If you do not have the app yet, download it, and 0.2.4 shows how to set it up.
2. Choose Open folder and pick brightline-ap. Set Work in to This computer.
3. Send: "What does this folder hold, and how is it tested? Do not change anything."
4. Ask: "Is there a folder next to this one called live-export? Tell me if you could not check."
5. Choose New chat. Your first chat is still in the sidebar, and opening it lets you continue.

What you should see. A chat in brightline-ap, on this computer, that describes the folder and changes nothing, and both chats in the sidebar. If it looks next door, you have seen that the folder is not a wall.

How OpenCode does it. You open a folder as a project, and a background server on your computer runs the session there, with no vendor cloud and no sandbox.⁸ You pick the model and set the safety rules yourself. By default almost everything is allowed, so this first section only asks questions, and the next one sets the rules.

1. Download OpenCode Desktop, install it and open it.
2. Choose Add project and pick brightline-ap.
3. Type /connect in the message box, and connect a model. One of OpenCode's free models is enough.⁹
4. Send: "What does this folder hold, and how is it tested? Do not change anything."
5. Ask: "Is there a folder next to this one called live-export? Tell me if you could not check."
6. Start a new session with /new. Your first session is still on the home screen, and clicking it resumes it.

What you should see. A session in brightline-ap that describes the folder and changes nothing. If it asks to look next door, you have seen that the folder is not a wall.

How Claude Code does it. A mode sets what Claude may do without asking, and you can change it at any time. Manual asks before edits and commands. Accept edits edits files and runs common file commands inside the folder, even deleting a file. Plan reads and proposes, and edits nothing.¹⁰

1. Find the mode selector under the message box, read the modes, and set Manual, the ladder's "Ask before acting".

   

2. Send the git message. Before your first yes, ask: "What does this command do?" Approve each command when you agree with what it does.

3. Switch to Plan and send the second message. Read the plan against your check, and correct what is off.

4. Switch to Accept edits and tell it to go ahead. Then ask it to run the tests and commit.

What you should see. A first commit, a command you asked about before you approved it, a plan you read before any file changed, and passing tests.

For the exam. The modes, the three settings files and their order, and that a deny rule beats an allow rule, all in the details.

How Codex does it. Two controls work together. The sandbox sets what commands can reach, and approvals set when Codex stops to ask.¹¹ This sandbox is a limit on the commands, not the throwaway machine of 12.3. Under Ask for approval, it reads, edits and runs commands inside the project without asking, and it asks before it edits files outside or uses the internet.¹² So it will not stop before each edit, which is one more reason to put the folder under git first. /plan has it propose an approach before editing.¹³

1. Open the permissions control under the message box, and choose Ask for approval.
2. Send the git message. Commands that stay inside the project may run without asking, so read each one in the chat, and ask: "What does that command do?"
3. Run /plan to turn plan mode on, and send the second message. Read the plan against your check, and correct what is off.
4. Run /plan again to turn it off, and tell it to go ahead. Then ask it to run the tests and commit.

What you should see. A first commit, a command you asked about, a plan you read before any file changed, and passing tests.

How OpenCode does it. Ordered rules allow, ask or deny each action, and the last matching rule wins.¹⁴ By default almost everything is allowed, so you write the rules first, in a file called opencode.jsonc. The build agent works, and the plan agent explores and proposes.¹⁵

1. Write the rules before anything changes. Ask the agent to create opencode.jsonc in the folder with this, and to tell you in plain words what each rule does. They set edits, shell commands and folders outside the project to ask.

   {
     "permissions": [
       { "action": "edit", "resource": "*", "effect": "ask" },
       { "action": "shell", "resource": "*", "effect": "ask" },
       { "action": "external_directory", "resource": "*", "effect": "ask" }
     ]
   }

2. In the build agent, send the git message. Before your first yes, ask: "What does this command do?" Approve each command when you agree with what it does.

3. Switch to the plan agent with /agent and send the second message. If it asks to edit a file while it plans, say no. Read the plan against your check, and correct what is off.

4. Switch back to build and tell it to go ahead. Then ask it to run the tests and commit.

What you should see. A first commit, a command you asked about before you approved it, a plan you read before any file changed, and passing tests.

How Claude Code does it. Claude Code reads AGENTS.md when a session starts, as long as there is no CLAUDE.md. A CLAUDE.md replaces it, and the line @AGENTS.md pulls it back in.¹⁶ These files are context, not enforcement, so a rule that must never break also goes in a settings file, where a deny rule holds in every mode.¹⁷

1. In Manual, ask Claude to read the project and draft a short AGENTS.md that says never to write to data/. Read the draft, and keep only what is true and what the agent cannot guess.

2. Click + New and ask: "Without opening any file, what must you never do in this project? Name the file that told you." It should name your rule and AGENTS.md.

3. See what a CLAUDE.md changes. Ask Claude to create a CLAUDE.md that holds one line of notes. Start a fresh session and ask the same question. It should no longer know your rule.

4. Bring the rule back. Ask Claude to replace everything in CLAUDE.md with the one line @AGENTS.md. Ask again in a fresh session.

   

5. Back the rule with a setting. Ask Claude to create the project's settings file, .claude/settings.json. Settings files are written in JSON, a fixed text format that programs read:

   {
     "permissions": {
       "deny": ["Edit(/data/**)"]
     }
   }

6. Test it. Switch to Accept edits and ask Claude to change one value in a file under data/. If it refuses because of AGENTS.md, say: "Try the edit anyway, to test the setting." If the edit goes through, ask Claude to undo it and to check the settings file. Switch back to Manual.

7. Add a saved prompt. Ask Claude for a skill that runs your tests and reports the count. Run it by typing / and its name.

8. Ask Claude to commit everything, so the next section starts clean.

What you should see. A fresh session that names your rule, loses it when a CLAUDE.md appears, and has it again after the import. An edit under data/ that Claude says a permission rule denied, not one it chose not to make.

For the exam. The four levels of CLAUDE.md, imports up to four levels deep, when AGENTS.md is read, /init, and where skills and subagents live, all in the details.

How Codex does it. Codex reads your AGENTS.md before it does any work, from your home folder and then from each folder from the project's top down.¹⁸ The words guide it. In the default setup nothing else guards a file inside the project, because the sandbox allows writes there. A beta setting can now protect one path, which the details describe.¹⁹

1. Run /init in the message box, and read the AGENTS.md it drafts. Ask Codex to add the line "Never write to data/."
2. Start a New chat and ask: "Without opening any file, what must you never do in this project? Name the file that told you." It should name your rule and AGENTS.md.
3. Ask Codex to change one value in a file under data/. Watch what it does. If it refuses, its reading of your words stopped it, and nothing else did. If it makes the change, ask it to put the file back.
4. Add a saved prompt. Ask Codex for a skill that runs your tests and reports the count.
5. Ask Codex to commit everything, so the next section starts clean.

What you should see. A fresh chat that names your rule. In the default setup, only the words guard data/, so if Codex refused the edit, the words are what stopped it.

How OpenCode does it. OpenCode reads AGENTS.md and not CLAUDE.md, from your global file and from the folders above where you work.²⁰ The words guide it, and a deny rule in opencode.jsonc enforces them.¹⁴

1. Run /init, or ask the build agent to draft AGENTS.md. Make sure it says never to write to data/, then read and trim it.

2. Start a new session with /new and ask: "Without opening any file, what must you never do in this project? Name the file that told you." It should name your rule and AGENTS.md.

3. Back the rule with a setting. Ask the agent to add this as the last rule in opencode.jsonc, because the last matching rule wins, and approve the edit:

   { "action": "edit", "resource": "data/*", "effect": "deny" }

4. Test it. In the build agent, ask for one change to a file under data/. If it tries a shell command instead, that falls under the rule that asks, so say no. If the edit goes through, ask it to undo the edit and to check opencode.jsonc.

5. Add a saved prompt. Ask the agent for a skill that runs your tests and reports the count.

6. Ask the agent to commit everything, so the next section starts clean.

What you should see. A fresh session that names your rule, and an edit under data/ refused without asking you.

How Claude Code does it. Each session starts with fresh context, which fills with the conversation, the files read and the commands' output. Claude summarizes on its own when it is full, and /compact lets you choose when.⁶ Checkpoints, which /rewind restores, undo Claude's own edits, and git keeps the lasting history.²¹

1. Choose the effort for the job. This job is small, so open the model picker under the message box and set Effort to low. Set it back when you finish.

   

2. Type /context in the message box. Ask it to add one line to the README that says where the data files are. Then type /context again, and see what grew.

3. Take the change back. Run /rewind, select the message you sent, and choose Restore code.

4. Run /compact, then ask what the task was.

5. Hand over. Send: "Write what is done and what is left into NOTES.md, and commit." Click + New and send: "Read NOTES.md. What is left to do?"

What you should see. A context that grows, a change taken back, a compacted session that still knows the task, and a clean session that knows what is left because it was written down.

For the exam. /context, /compact, /rewind and what it cannot take back, the default model and the effort levels, all in the details.

How Codex does it. Each chat keeps its own context. /status shows how full it is, and /compact summarizes it.¹³ There is no /undo. You take a change back in the review pane, or with git.²²

1. Choose the effort for the job. This job is small, so open the model and reasoning control under the message box and move it toward Faster. Set it back when you finish.
2. Run /status. Ask it to add one line to the README that says where the data files are. Run /status again, and see what grew.
3. Take the change back. Open the review pane and choose Revert all. It holds every uncommitted change, so check that this line is the only one.
4. Run /compact, then ask what the task was.
5. Hand over. Send: "Write what is done and what is left into NOTES.md, and commit." Start a New chat and send: "Read NOTES.md. What is left to do?"

What you should see. A context that grows, a change taken back, a compacted chat that still knows the task, and a clean chat that knows what is left because it was written down.

How OpenCode does it. A circle in the session header shows how full the context is.²³ OpenCode summarizes on its own near the limit, and /compact does it when you ask.²⁴ /undo restores files from snapshots, which are not a backup, so commit anything you want to keep.²⁵

1. Choose the effort for the job. /model shows the models you can use. This job is small and needs no stronger model, so keep the one you have.
2. Ask it to add one line to the README that says where the data files are. Watch the circle in the session header, and see what grew.
3. Take the change back with /undo. /redo cancels the undo before you send your next message.
4. Run /compact, then ask what the task was.
5. Hand over. Send: "Write what is done and what is left into NOTES.md, and commit." Start a new session with /new and send: "Read NOTES.md. What is left to do?"

What you should see. A context that grows, a change taken back, a compacted session that still knows the task, and a clean session that knows what is left because it was written down.

How Claude Code does it. Each session has its own context and its own changes, and a worktree gives it its own copy of the project.⁶ A subagent does a side task in its own context and hands back a summary, using the same usage limits.²⁶ A side chat can read the session and adds nothing back to it.

1. Click + New, turn on Worktree in the row under the message box, and send the first brief.

2. Do the same again, and send the second brief.

3. While one works, open a side chat (Cmd+semicolon on macOS, Ctrl+semicolon on Windows) and ask how far along it is.

4. When the first is done, hand a check to a helper. Ask: "Use a subagent to check this change against AGENTS.md and report only rule breaks"

   

5. Review each one against its brief. Read the Changes card and run /code-review.

6. Start a session in the main folder, with Worktree off, and send: "Merge each worktree's branch into main, one at a time. Tell me each branch name first, and run the tests after each merge."

What you should see. Two sessions that never touched each other's files, a side chat that added nothing to the session, a helper's summary, and a main branch that holds both changes with passing tests.

For the exam. Subagents, their file and built-in kinds, forks, nested sessions, projects and what a cloud thread loads, and that messages between sessions carry text only, all in the details.

How Codex does it. Parallel chats use worktrees so they do not change the same files.⁷ Subagents work in their own threads, inherit the parent's sandbox, return summaries and use more tokens, the units in which model use is measured and billed.²⁷ /side opens a side chat.¹³

1. Start a New chat, select Worktree under the message box, and send the first brief. A worktree chat starts with no branch, so add: "Commit on a new branch."
2. Do the same again, and send the second brief.
3. While one works, run /side and ask how far along it is.
4. When the first is done, ask: "Spawn an agent to check this change against AGENTS.md and report only rule breaks"
5. Review each one against its brief. Run /review, which reports findings and changes nothing.
6. Start a chat in the main folder, without a worktree, and send: "Merge each worktree's branch into main, one at a time. Tell me each branch name first, and run the tests after each merge."

What you should see. Two chats that never touched each other's files, a side chat that added nothing to the chat, a helper's summary, and a main branch that holds both changes with passing tests.

How OpenCode does it. You keep parallel work apart with worktrees, because a session can run in its own copy of the folder.²⁸ Inside a session, subagents do side tasks in child sessions with fresh context,¹⁵ and /btw asks a side question without adding it to the conversation.²⁹

1. On the new-session screen, click the git branch, choose New worktree, and send the first brief.
2. Do the same again, and send the second brief.
3. While one works, ask a side question with /btw: how far along is it?
4. When the first is done, ask: "Ask the explore subagent to check this change against AGENTS.md and report only rule breaks"
5. Review each one against its brief, in the Review tab.
6. Start a session in the main folder, not a worktree, and send: "Merge each worktree's branch into main, one at a time. Tell me each branch name first, and run the tests after each merge."

What you should see. Two sessions that never touched each other's files, a side question that added nothing to the conversation, a helper's summary, and a main branch that holds both changes with passing tests.

How Claude Code does it. claude -p runs one task headless, from a command with nobody watching. Nobody is there to answer a prompt, so what it may do is granted before it starts.³⁰ The desktop app cannot do this, so scripts use the command-line version, which you install separately.³¹

1. Install the command-line version with Anthropic's steps.

2. Click Terminal in the session's title bar. It opens in your folder. Type claude and log in, then leave it by typing /exit. Paste this whole command, press Enter, and it runs one task with nobody watching:

   claude -p "Run the tests and report whether every test passed, and how many ran." \
     --allowedTools "Bash(npm test),Bash(npm test *)" \
     --output-format json \
     --json-schema '{"type":"object","properties":{"passed":{"type":"boolean"},"tests":{"type":"integer"}},"required":["passed","tests"]}'

   

3. Run it without its --allowedTools line, by pasting this:

   claude -p "Run the tests and report whether every test passed, and how many ran." \
     --output-format json \
     --json-schema '{"type":"object","properties":{"passed":{"type":"boolean"},"tests":{"type":"integer"}},"required":["passed","tests"]}'

   Write down why the test command was refused.

What you should see. A JSON result with passed true. Then a second one with passed false, because the test command was denied with nobody there to approve it. If your settings make Auto your default, the second run can go through instead.

For the exam. claude -p, the three output formats, --json-schema and structured_output, --allowedTools, and --bare, all in the details.

How Codex does it. codex exec runs one task from a script, read-only unless you tell it otherwise, and prints only its final message. --json streams each event, and --output-schema shapes the answer.³²

1. Install the Codex command-line tool. In a terminal in your folder, type codex and sign in, then leave it by typing /quit.

2. Run one task with nobody watching:

   codex exec "Run the tests and report whether every test passed, and how many ran."

3. Ask for something the read-only default does not allow:

   codex exec "Add one line to the README that says where the data files are."

4. Allow what it needs, and run it again:

   codex exec --sandbox workspace-write "Add one line to the README that says where the data files are."

What you should see. An answer about the tests, or a report that the read-only default stopped it running them. Then a run that could not write, with the README unchanged, because nobody was there to widen its limits. Then a run that added the line, because you allowed it before it started.

How OpenCode does it. opencode run sends one task and prints the reply, as JSON if you ask. Nobody can approve anything, so a rule that says ask becomes a refusal.³³ The opencode command is the same agent as the desktop app, connected to the same background server.⁸

1. Open a terminal and install the command-line version: curl -fsSL https://opencode.ai/v2/install | bash.

2. In your folder, run one task with nobody watching:

   opencode run --format json "Run the tests and report whether every test passed, and how many ran."

   The rules in opencode.jsonc set shell commands to ask, so this run is refused.

3. Allow only the tests. In the desktop app, ask the agent to add this rule to opencode.jsonc, after the rule for shell commands, and approve the edit. Then run the same command again:

   { "action": "shell", "resource": "npm test*", "effect": "allow" }

What you should see. A first run refused, with a line saying the permission request was rejected. Then a second run that ran the tests, with its reply in JSON events.

The workspace.

• Claude Code is the Code tab in the Claude desktop app, on macOS, Windows and Linux (beta).³⁴
• Before the first message you pick an environment, a folder, a permission mode and a model.⁶
• Each session runs Local, in the Cloud, over SSH (on another computer you reach over the network), or in WSL (Linux inside Windows), and a Cloud session keeps going after you close the app. A Worktree setting gives a session its own git worktree. You can save a setup you reuse as an environment.⁶
• A panel beside the chat shows where the session runs, what it is running, what it changed and how full its context is.⁶
• A Browser pane lets Claude start your app, open it and check its own changes.⁶ On macOS, an iOS Simulator pane, in public beta, does the same for a phone app, in local sessions only.³⁵
• If your project has a web page, you can ask Claude to open it in the Browser pane.

Permissions and plans.

• The desktop app shows five modes, and the command line adds dontAsk. Manual asks before edits and commands. Accept edits edits files and runs common file commands without asking: mkdir, touch, rm, rmdir, mv, cp and sed, inside the folder. Plan proposes a plan and edits nothing. Auto lets a background check review each action and block risky ones.¹⁰
• Bypass permissions is for sandboxed containers or virtual machines only, and on Pro, Max and Ultra it appears only after you turn it on in the app's settings.¹⁰
• Auto is the starting mode for new command-line sessions on every plan. Anthropic's permission-modes page dates this from version 2.1.283.³⁶ Its changelog says 2.1.283 started only third-party providers and sessions with telemetry off in Auto, and 2.1.284 every plan.³⁷ The desktop app reads the same settings and remembers the mode you pick for each folder, except Plan, which lasts for the current session only.⁶
• Rules live in settings files: ~/.claude/settings.json (you, every project), .claude/settings.json (the project, committed for the team) and .claude/settings.local.json (you, this project, kept out of git), with your organization's settings above all three. The order, highest first, is managed, then command line, then local, then project, then user, and lists such as permissions.allow are merged.³⁸
• A rule names a tool and a pattern, such as "Edit(/data/**)" in deny. Rules are checked deny, then ask, then allow, so an allow rule never overrides a deny rule. A committed file's deny rules apply at once, and its allow rules wait until you trust the folder. Edit deny rules also cover shell file commands Claude Code recognizes, such as sed, but not a script that opens the file itself.¹⁷

Rules files.

• From version 2.1.277, Claude Code reads AGENTS.md with nothing else to set up, as long as there is no CLAUDE.md or CLAUDE.local.md in the folder or above it.¹⁶ By default, a CLAUDE.md, .claude/CLAUDE.md or CLAUDE.local.md replaces AGENTS.md for Claude Code.¹⁶
• /init drafts a CLAUDE.md,¹⁶ and when we tried it on 1 November 2026, in version 2.1.314, it still wrote one beside an existing AGENTS.md, with no import. Keep your rules in one place with a CLAUDE.md that holds @AGENTS.md, with any lines for Claude Code alone below it.¹⁶
• /memory lists your instruction files and opens them for editing. It lists a project CLAUDE.md row even when no such file exists, so that row proves nothing.¹⁶ /context shows what loaded at launch, under Memory files,¹⁶ and works in the Code tab too.⁶ The Project instructions setting in /config can make Claude Code read both files.¹⁶
• CLAUDE.md has four levels: your organization's managed file, ~/.claude/CLAUDE.md for you in every project, ./CLAUDE.md or ./.claude/CLAUDE.md for the project, and ./CLAUDE.local.md for you in this project only. Files in the folders above where you start load at launch, and those in subfolders load when Claude works there. All of them are joined, from the top folder down. @path imports another file, relative to the file that imports it, up to four levels deep.¹⁶
• A skill is a folder with a SKILL.md file in .claude/skills/ or ~/.claude/skills/. /<name> runs it, with $ARGUMENTS for what you type after the name, and Claude can load it on its own unless the file says disable-model-invocation: true. Custom commands were merged into skills, and old .claude/commands/ files still work.³⁹
• Auto memory is the notes Claude writes for itself, per repository, and its start loads into every session.¹⁶ /doctor prompt-audit reports problems such as instructions written for older models, references to files or commands that do not exist, and files that contradict each other. It changes nothing until you ask.¹⁶ /skill-doctor shows what each skill costs in context.⁴⁰ /output-style sets how answers are written.⁴¹
• A mod is a plugin made of small JavaScript or TypeScript functions, called hooks, that run inside Claude Code. Each hook reacts to an event, such as a tool call, a prompt or part of the screen being drawn.⁴² It can watch the event, change it, or answer it, for example by refusing a command. So a mod can add a pane or a band above the prompt, add a command, hold a risky command until you decide, or send one step to a different model. Some of Claude Code's own features, such as /diff, are mods.⁴³ You can ask Claude to write one. It saves the files outside your repository, asks before each one in Manual and Accept edits modes, and loads the mod only in that session.⁴⁴ Anthropic says mods are not sandboxed. A mod can read your files and secrets, see every prompt, and approve a tool call before you are asked. So install mods only from authors and marketplaces you trust, and before you enable one, run claude plugin validate, which lists the events it handles and what it asks Claude Code to do.⁴³
• In a terminal in your folder, claude then /memory lists the instruction files loaded. /doctor prompt-audit is worth running every few weeks.

Context and sessions.

• The default model on paid plans is Opus 5.5, and effort runs from low to max.⁴⁵
• /context shows what fills the context and /compact summarizes it.⁶
• /rewind takes back files Claude edited with its own tools, but not a file that only shell commands changed.²¹ It can also leave behind files that only a subagent edited.²¹ Git is still the record of what changed, as far as you committed it.
• A cheaper session can still get a stronger second opinion. /advisor opus lets a cheaper model consult Opus at key moments. It is experimental, and on a subscription its use counts toward your plan's usage limits.⁴⁶

Many sessions.

• Claude automatically uses built-in subagents when appropriate, and each one's requests count toward the same usage limits as your main conversation. A deny rule such as Agent(Explore) in your settings stops Claude from using that subagent.²⁶
• Two sessions can sit side by side. A side chat reads the main session and adds nothing back, and you cannot return to it after you close the app.⁶
• A subagent is a file in .claude/agents/ with a name, a description, its tools and its model, and it runs in its own context. It can also run as a fork, a copy of the conversation so far. Explore, Plan and general-purpose are built in. Explore and Plan start without your project instructions, so put any rule they need in the brief.²⁶
• In local and SSH sessions, Claude can start a task in a nested session that reports back, and can suggest a side task you start with one click.⁴⁷
• On the Pro, Max and Ultra plans, Projects, in public beta and rolling out gradually, so you may not see them yet, run a coordinator that starts threads in the cloud. Cloud threads load the repository's CLAUDE.md but not its skills or its permission rules.⁴⁸ Anthropic's page does not mention AGENTS.md there, so a repository used this way keeps a CLAUDE.md that imports it.
• Messages between sessions carry text only, never history.⁴⁹ Put what a worker needs in its brief.
• The Changes card shows the diff, and /code-review reviews your branch and uncommitted changes and reports findings.⁵⁰

Outside the app.

• claude -p "<task>" runs one task headless, from a command with nobody watching. Concept 12.8 explains headless runs. --output-format returns text, json or stream-json, which streams each event as a line of JSON, and --json-schema puts a matching answer in a structured_output field.³⁰
• A headless run starts in Manual mode, unless a setting chooses another mode, and denies what needs approval, so list what it may do with --allowedTools.³⁰ In a folder you have never trusted, a headless run shows no trust prompt: the project's hooks still run and its MCP servers connect, while its allow rules are ignored.³⁰
• For a script that must behave the same on every machine, use bare mode. Anthropic recommends --bare for scripts, which skips your CLAUDE.md, skills, hooks and memory. It does not use your subscription login, so it needs an API key, and Anthropic says it will become the default for -p, so a script that relies on your login may need a change later.³⁰
• /goal sets a condition, such as "all tests in test/auth pass". Claude keeps working until the condition is met, the checking model judges it impossible, or an error you must fix clears the goal. After each turn, a small fast model reads the conversation and judges the condition. It does not run commands or read files itself, and a goal does not change the permission mode.⁵¹ Concept 12.8 explains why its "done" is a second opinion.

The workspace.

• Since July 9, 2026, Codex is a view inside the ChatGPT desktop app⁵² for macOS and Windows, with Linux in preview.⁵³
• A chat runs on your computer, in a git worktree, or in the cloud, from a cloud environment you set up and publish once. A cloud chat does not automatically get your computer's local files, running processes, browser sign-ins or VPN access.⁷
• A built-in Browser lets Codex open your local web app, take screenshots and check its work.⁵⁴ There is no iOS simulator pane, but the Computer Use plugin can operate other apps.⁵⁵
• If your project has a web page, you can ask Codex to open it in its Browser.

Permissions and plans.

• Ask for approval is OpenAI's recommendation. Approve for me asks only about actions it detects as potentially unsafe, Full access gives unrestricted access to the internet and any file on your computer, and Custom (config.toml) uses the permissions set in config.toml. Without asking, Ask for approval lets it read files, make edits and run commands in the working folder. Even so, .git, .agents and .codex stay read-only, so a commit or a new skill may ask first.⁵⁶¹²

• Behind them sit a sandbox (read-only, workspace-write or full access) and an approval policy, set in config.toml.¹¹ The two lines that set them:

  sandbox_mode = "workspace-write"
  approval_policy = "on-request"

• A beta setting can now protect one path. Permission profiles in config.toml can mark a path read or deny, and a narrower rule stays in force even when a broader path is writable.¹⁹ They may change, and any sandbox_mode in a loaded config replaces them, so the two lines above would cancel a profile.

• /plan turns plan mode on or off.¹³

Rules files.

• /init in the message box drafts an AGENTS.md.¹³ Codex reads AGENTS.md from its home folder, ~/.codex by default, then from each folder from the repository's root down to the one you start in, joined root first.¹⁸ It builds that list when the session starts, so a rule in a subfolder counts only if you start there or below. An AGENTS.override.md wins over AGENTS.md in the same folder, and Claude Code does not read it.¹⁶
• Skills use a SKILL.md folder in .agents/skills/.⁵⁷ Plugins⁵⁸ bundle skills, MCP servers (connectors to other tools, Chapter 17) and hooks.⁵⁹
• We found no advisor and no audit of your instruction files in OpenAI's documentation. The nearest thing to mods is Plugin Extensions, which add interfaces to ChatGPT.⁵³

Context and sessions.

• GPT-6 Astra is the most capable model. GPT-6.1 Sol comes near it at a lower cost, GPT-6.1 Terra is fast and efficient, and GPT-6 Luna is the most efficient.⁶⁰ You choose the model, and we found no automatic routing to a cheaper one,⁶¹ though Codex cloud selects its model automatically.⁵³

Many sessions.

• /goal sets what done looks like and shows progress,⁶² and /side opens a side chat.¹³
• The app shows each subagent's work and the summary it returns. A subagent takes the parent's model and effort unless set, and always the parent's sandbox.²⁷ Ultra, on supported models, splits a complex task across subagents that work in parallel.⁶⁰ Subagent work uses more tokens, the units in which model use is measured and billed.²⁷
• /review checks your uncommitted changes or your branch and reports findings by priority without changing files.²²

Outside the app.

• The open-source Codex command-line tool runs codex exec headless, read-only by default, and can return JSON that matches a schema.³²
• For every change, a pipeline can run it. OpenAI offers a GitHub Action for CI, the system that runs checks on every change.⁶³

The workspace.

• OpenCode is a free coding agent under the MIT license.⁶⁴ You install it, pick a model⁶⁵ and set its safety rules yourself.¹⁴ OpenCode Desktop, still labeled beta, talks to a background server on your computer.⁸ It runs locally on your machine, with no vendor sandbox.⁶⁶
• For a model, bring your own API key, sign in with a ChatGPT Plus or Pro plan, run a local model,⁶⁵ or buy OpenCode's Go plan ($10 a month).⁹ Since version 2.2.3, released October 30, 2026, a built-in Claude Agent provider uses your Claude Code login and models: install Claude Code, run claude auth login, then choose Claude Agent in /connect.⁶⁷
• Desktop has tabs, a browser pane the agent drives with screenshots,²⁸ and a Timeline setting, Changed files, that shows each turn's changed files and diffs once you turn it on. You can fork a session from any message.⁶⁷

Permissions and plans.

• Permission rules allow, ask or deny an action, set in opencode.jsonc or opencode.json. By default it can reach files outside the project, unless a rule says ask.¹⁴
• OpenCode does not sandbox the agent. Its security policy says permission prompts are not isolation, and recommends a container such as Docker, or a virtual machine.⁶⁶ The default rules allow almost everything,¹⁴ browser actions do not ask one by one,²⁸ and OpenCode's web page says its local server is password-protected by default,⁶⁸ while its security policy says server mode is unauthenticated without a password.⁶⁶⁶⁸
• Before your first task, set edits and shell commands to ask, keep OpenCode updated, treat plugins as code you choose to run, and never expose its server to a network.

Rules files.

• OpenCode reads AGENTS.md, and version 2 does not read CLAUDE.md.²⁰ The version 2 documentation lists no /init, but version 2.2.5 ships one, for guided AGENTS.md setup.²³
• Commands are markdown files in .opencode/commands/.⁶⁹ Skills use SKILL.md in .opencode/skills/, and OpenCode also reads .claude/skills/ and .agents/skills/.⁷⁰ Plugins can hook into tool calls⁷¹ and add Desktop panels, which is still experimental.⁷²

Context and sessions.

• OpenCode compacts on its own near the limit.²⁴ Snapshots are not a backup.²⁵

Many sessions.

• The built-in general and explore subagents run in child sessions with fresh context, not the parent's conversation, and custom agents can each have their own model.¹⁵ The Changed files timeline, or git diff, also shows what changed.⁶⁸

Outside the app.

• --auto approves everything not explicitly denied, and deny always holds. opencode run has no schema flag, so the answer is in its text events.³³

Claude Code needs a Pro, Max, Ultra, Team, Enterprise or Console account, and the free plan does not include it.³¹ On Pro, Max and Ultra it shares usage limits with Claude chat.⁷⁴

Codex is on every ChatGPT plan, including Free, where it uses GPT-6 Luna. Plus is $20 a month. Pro plans are $100, $200 or $500 a month, and currently have no five-hour limit.⁷⁵

The software is free.⁶⁴ You pay your model provider or OpenCode's plan, unless you run a local model⁶⁵ or one of OpenCode's free models.⁹