, , , , and agy all run the same agent loop and share the same habits — AGENTS.md, slash commands, plan mode, approvals and . Learn the common parts once and you can use any of them.
A like or is one program, but it goes by three names depending on how you look at it: , and . Learn these three words first and the rest of this page reads easily.
Claude CodeCodexHermes Agent One program, three names
Seen as something a person uses
A tool is something you use. Claude Code and Codex are tools that let a person use a computer and . Such a tool is also called an agent coding tool (agentic coding tool).
You → Tool → Computer + AI
Seen as a model plus a harness
An agent is an AI that works through many steps on its own. In the broad sense, an agent is a and a harness put together — writes it as "Agent = Model + Harness". So when a model runs inside Claude Code, together they are an agent.
Agent = Model + Harness
Seen as everything except the model
In the broad sense, a harness is everything except the AI model: any AI tool that wraps a model and puts it to work. The harness reads files, runs commands, asks for and hands the results back to the model. That makes Claude Code, Codex and all harnesses.
Harness = Agent − Model
At first people simply called these programs tools. Now they say harness when they mean the part wrapped around the model, and agent when they mean the whole thing at work with the model inside. All three names are right, and they point to the same program.
See Agent = Model + Harness in detailAgent = Model + Harness. If you're not the model, you're the harness.
LangChain — The Anatomy of an Agent Harness (new window)
Every piece of , setting and that is not the model belongs to the harness. A model alone only predicts text. The harness turns it into an agent that can read files, run commands and stop when the work is done.
What you talk to in the terminal
Thinks — reads everything it is given and predicts the next words or a
Everything else — builds the input, runs the tools and keeps the loop going
Claude Code, Codex, , , and agy are all harnesses. Each wraps a different model — Claude, , , Grok, Kimi, or with OpenCode almost any model — but every harness does the same jobs. That is why the habits on this page carry from one tool to the next.
Harness — three viewsFollow one real request through a — "Fix the signup button that does nothing and add a test". The model and the harness take turns until the work is checked.
Arrows go in order. The thick arrow is the loop — every tool result goes back to the model. The dashed arrow is taken only when the model answers with text and no tool call.
Step 1 · You
You type the request and press Enter. The harness wraps your words as a user message — the last item of the input.
{"type": "message", "role": "user",
"content": [{"type": "input_text",
"text": "Fix the signup button that does nothing and add a test"}]}Step 2 · Harness
Before the model sees your words, the harness gathers what it needs — its own instructions, the list of tools the model may call, a note about the sandbox and when to ask for approval, your AGENTS.md files, and the working folder and shell. In later rounds the whole conversation so far goes in too.
instructions base instructions for the model
tools shell · update_plan · web_search · mcp__…
input
developer <permissions instructions> sandbox · approval
user AGENTS.md (project root → cwd)
user <environment_context> cwd · shell
user "Fix the signup button …"Step 3 · Model
The harness sends the input to the model. The model answers in only one of two ways — a message for you, or a tool call, a small request such as "run this shell command". The model cannot touch your computer itself.
{"type": "function_call", "name": "shell",
"arguments": "{\"command\":\"rg -n signup src\"}",
"call_id": "call_1"}Step 4 · Model Harness
To fix the button the model first has to find it, so it asks for reading tools — search the code with rg, list folders, read the file. Claude Code calls this phase "gather ".
$ rg -n signup src
src/components/SignupButton.jsx:8: <button type="button">Sign up</button>
src/api/auth.js:21:export async function signup(email, password) {Step 5 · Harness
The harness checks permissions. Allowed and inside the sandbox? It runs. Not allowed yet? It asks you first. Then it adds the call and its output to the conversation and asks the model again. This return trip is the loop, and it can turn dozens of times for one request.
{"type": "function_call_output",
"call_id": "call_1",
"output": "src/components/SignupButton.jsx:8: …"}Step 6 · Model Harness
Once it understands the code, the model asks for an edit — new text for part of a file. The harness writes it and you see it as a . Claude Code saves a checkpoint before each edit so you can rewind.
--- a/src/components/SignupButton.jsx
+++ b/src/components/SignupButton.jsx
- <button type="button">Sign up</button>
+ <button type="button" onClick={() => signup(email, password)}>
+ Sign up
+ </button>Step 7 · Model Harness
Next the model asks to run the test or the build in the shell. A command that can change things outside the folder is exactly where approval and the sandbox matter.
$ npm test -- SignupButtonStep 8 · Model
The model reads the test log. If a test fails, it goes back to reading code and editing (steps 4 and 6) and runs the test again — until the test passes, or until it stops and asks you because it is stuck.
FAIL SignupButton.test.jsx
✕ calls signup when clicked
… fix → run again …
PASS SignupButton.test.jsx
✓ calls signup when clickedStep 9 · Model Harness
When the model answers with text and no tool call, the turn ends. The harness shows the summary and gives control back to you. A good report says what changed, the test result and what was not checked.
{"type": "message", "role": "assistant",
"content": [{"type": "output_text",
"text": "Connected the button to signup() and added SignupButton.test.jsx. npm test passes."}]}Each round adds the tool call and its result, and the whole list is sent again. The — the most a model can read at once — slowly fills up.
In Codex the old input is an exact prefix of the new one, so the can reuse earlier work. Changing the tools, the model, the sandbox, the approval mode or the working folder in the middle of a conversation breaks that prefix and makes the next request slower.
When the conversation gets too long, the harness replaces it with a shorter summary and keeps going. Codex does it automatically once a limit is passed. Claude Code does it automatically too, and you can run /compact with a focus. Rules from early in a chat can get lost — keep lasting rules in AGENTS.md.
The model only asks. Whether a command runs, waits for your approval or is blocked is decided by the harness. In Codex the sandbox covers its own shell tool — MCP tools must enforce their own limits.
| Topic | Codex | Claude Code |
|---|---|---|
| Name | The agent loop — and tool calls repeat until an assistant message ends the turn. Source (new window) | The loop — gather context, take action, verify results, and the phases blend together. Source (new window) |
| Conversation | Every request sends the whole history again, so each request stands on its own. Source (new window) | Every message, tool use and result is saved in a file under ~/.claude/projects, so you can resume or fork. Source (new window) |
| Compaction | Automatic once auto_compact_limit is passed, through a special compact . Source (new window) | Automatic near the limit. /compact with a focus keeps what you need. Source (new window) |
| Safety | The sandbox and approval rules are told to the model and enforced on the shell tool. Source (new window) | Permission modes (Shift+Tab) plus checkpoints that undo file edits. Source (new window) |
Codex details come from the OpenAI article and Claude Code details from Anthropic's docs. The other tools run the same loop but have not published the same level of detail.
Every cell links to where we checked it — an official page, or the tool's own output on 2026-10-26.
Commands change often. "Not confirmed" means we could not find it on an official page or in --help — not that it is missing.
AGENTS.md is a plain file in your project. The agent reads it before your first word, so you never have to repeat the rules.
# AGENTS.md
## Run
- npm install, then npm run dev
## Test
- Run npm test before you finish. Every test must pass.
## Style
- React function components, 2-space indent.
## Do not touch
- .env, the database folder and package-lock.json
## Report
- List the changed files, the test result and anything you did not check.Its own file is CLAUDE.md. It reads AGENTS.md only when there is no CLAUDE.md in the folder or above it. To keep both, put @AGENTS.md in CLAUDE.md.
Source (new window)From the down to the current folder, joined in that order, and the closer file wins. file ~/.codex/AGENTS.md. 32 by default.
Source (new window)AGENTS.md in the project and ~/.config/opencode/AGENTS.md. It falls back to CLAUDE.md when there is no AGENTS.md.
Source (new window)AGENTS.md (and CLAUDE.md) in every folder from the root to where you work. Deeper files win.
Source (new window)AGENTS.md or .kimi-code/AGENTS.md in the project, plus ~/.kimi-code/AGENTS.md for every project.
Source (new window)AGENTS.md and GEMINI.md in any folder, plus .agents/rules. Global rules live in ~/.gemini. All found rules are combined.
Source (new window)
A normal request ends as soon as the model stops calling tools. sets a instead — the agent keeps working, round after round, until the condition is met.
/goal Every test passes and the signup button calls signup(). Do not change the database.
Sets a completion condition. Claude keeps working until it is met, judged impossible, or stopped by an error. Works with -p too.
Source (new window)A persistent target Codex tracks while a larger task runs (the goals feature, on by default).
Source (new window)No built-in /goal yet — use custom commands instead.
Source (new window)/goal with an objective and an optional --budget, plus status, pause, resume and clear.
Source (new window)Starts an autonomous goal, with status, pause, resume, cancel and more.
Source (new window)When the agent tries to stop, blocks the stop and asks it to check its own work and continue.
Source (new window)
Most bad results come from a request that leaves out something the agent cannot guess. Six questions — who, what, when, where, why and how — catch most of those gaps.
“The button is broken. Fix it.”
Which button? Broken how? How will we know it is fixed? The agent has to guess, and it may change the wrong file.
5W1H does not guarantee a good result, but it covers most cases. When the agent still has to ask you something, the missing piece is usually one of the six.
AI Course — prompt engineeringSplit the work. AGENTS.md holds what every request needs. The holds only what this one request needs.
How to test, coding style, what not to touch, how to report
Who, what, when, where, why and how of this one request
The agent reads both
You stop typing "run the tests, do not touch the database" in every message.
Move from Claude Code to Codex or Kimi and the rules come along.
The file lives in , so every person and every agent follows the same rules.
When the agent repeats a mistake, add one line to AGENTS.md instead of explaining it again.
The same moves work in almost every tool. The exceptions are in the comparison table.
cd my-project
claude · codex · opencode · grok · kimi · agy
/init
Claude Code writes CLAUDE.md. Not confirmed for Grok and agy.
/plan
OpenCode — press Tab for the Plan agent.
/model
OpenCode — /models.
/compact
/goal
Not in OpenCode.
claude -c · opencode -c · grok -c · kimi -c · agy -c
codex resume --last
claude -p · grok -p · kimi -p · agy -p
codex exec · opencode run
claude mcp · codex mcp · opencode mcp · grok mcp · agy mcp
Kimi — /mcp inside the chat.
Checked on 2026-10-26 against the official docs and the installed CLIs (--help). Commands change, so read the official docs too.
The same can be used in many forms — this page covers the three most common: a in the terminal, a desktop app and a VS Code extension. They are not the only ones: depending on the tool, you can also use it in other editors such as JetBrains, in a web browser, in a phone app, inside Slack or GitHub, or in your own program through an . Pick the form that suits you, follow the four common steps below, and only swap the command, download or extension ID for each tool.
The choice guide follows the comparison in the OpenAI Codex docs — CLI (new window) · Desktop app (new window) · VS Code extension (new window)
A CLI is the form you drive with commands in the terminal. One install line is enough, and every tool follows the same four steps. Pick only the line that fits your computer.
Open a terminal — Terminal on and , PowerShell on .
Copy the install line that fits your computer from below, paste it and press Enter. If you already use Homebrew or , you can use that line instead.
Open a new terminal and run the 'Check' command from the card below to see the .
Move into your project folder (cd) and type the card's 'Start' command. The first time, a opens so you can sign in or paste an .
macOS · Linux
curl -fsSL https://claude.ai/install.sh | bash
Windows (PowerShell)
irm https://claude.ai/install.ps1 | iex
Homebrew
brew install --cask claude-code
npm
npm install -g @anthropic-ai/claude-code
macOS · Linux
curl -fsSL https://chatgpt.com/codex/install.sh | sh
Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://chatgpt.com/codex/install.ps1 | iex"
Homebrew
brew install --cask codex
npm
npm install -g @openai/codex
macOS · Linux
curl -fsSL https://opencode.ai/v2/install | bash
Homebrew
brew install anomalyco/tap/opencode-v2
npm
npm install -g @opencode/cli
macOS · Linux
curl -fsSL https://x.ai/cli/install.sh | bash
Windows (PowerShell)
irm https://x.ai/cli/install.ps1 | iex
macOS · Linux
curl -fsSL https://code.kimi.com/kimi-code/install.sh | bash
Windows (PowerShell)
irm https://code.kimi.com/kimi-code/install.ps1 | iex
npm
npm install -g @moonshot-ai/kimi-code
macOS · Linux
curl -fsSL https://antigravity.google/cli/install.sh | bash
Windows (PowerShell)
irm https://antigravity.google/cli/install.ps1 | iex
… | bash and irm … | iex run a script from the internet on your computer straight away. Use only the official addresses listed here, and do not run look-alike commands you find elsewhere.
A desktop app is the form you drive with windows and buttons. Download and install it without a terminal, then organize several tasks on screen. Not every tool has an official desktop app.
Download the app for your (macOS, Windows or Linux) from the official site and install it.
Open the app and sign in with that company’s account.
Open the project folder you want to work on, or create a new project.
Write the task and hand it over, then check the chat, results and changed files on screen. You can run several tasks side by side.
Claude Desktop — Code
You use in the Code tab of the . No separate CLI install is needed; a paid plan is required.
Download (new window) Official install guide (new window)Codex app
Available for macOS (Apple Silicon) and Windows (Microsoft Store). If you installed the CLI, codex app opens it too.
Download (new window) Official install guide (new window)OpenCode Desktop
Download (new window) Official install guide (new window)We could not find an official desktop app.
Install as a CLIWe could not find an official desktop app.
Install as a CLIGoogle Antigravity
is itself a code editor () — it runs on macOS 12 or later, Windows 10 and 11, and Linux.
Download (new window) Official install guide (new window)A VS Code extension adds an agent panel inside your code editor. Install it from the extension and ask about the code you select.
In VS Code, open the Extensions view — +Shift+X (Cmd+Shift+X on macOS).
Search for the extension name or below and click [Install]. You can also install it from a terminal with code --install-extension.
Open the agent panel from the new icon in the sidebar or at the top of the editor, and sign in.
Select code and ask for an explanation, a fix or tests, then review the changes beside the source before you accept them.
Claude Code for VS Code
Extension ID anthropic.claude-code
code --install-extension anthropic.claude-code
Codex – OpenAI’s coding agent
Extension ID openai.chatgpt
code --install-extension openai.chatgpt
opencode
Extension ID sst-dev.opencode
code --install-extension sst-dev.opencode
We could not find an official VS Code extension.
Install as a CLIKimi Code
Extension ID moonshot-ai.kimi-code
code --install-extension moonshot-ai.kimi-code
Google Antigravity
Extension ID Google.google-antigravity
code --install-extension Google.google-antigravity
If your terminal says the code command is not found, run "Shell Command: Install 'code' command in PATH" from the VS Code Command Palette (Ctrl+Shift+P · Cmd+Shift+P).
The CLI, desktop app and VS Code extension only look different — inside, the same agent runs the same loop. So most of what the "What tools share" tab teaches — AGENTS.md, approvals, and 5W1H — carries over as is. Commands and addresses were checked against the official docs on 2026-10-26; if they have changed, follow the official guide.
See what tools shareAnthropic and OpenAI each publish best practices for their coding tool. Put side by side, they say almost the same thing: pick a strong model at High effort, give the a way to check its work, keep lasting rules in a file and keep the clean. This tab joins the two guides into one (checked 2026-10-26).
Both let you choose the and how hard it thinks (effort). A stronger model at a higher level does better on hard work but is slower and uses more of your plan. For development, start with these two settings.
Opus 5.5Effort High
lowmediumhigh — recommendedxhighmaxopus is the latest Opus (Opus 5.5 on the ). Its default effort is medium, so raise it to high yourself. sonnet suits everyday and haiku simple jobs; fable (Fable 5.1) is for the hardest, longest work and must be chosen by hand.
{
"model": "opus",
"effortLevel": "high"
}claude --model opus --effort high/model · /effortGPT-6.1 SolEffort High
lowmediumhigh — recommendedxhighmaxultragpt-6.1-sol gives near-Astra results at a lower cost, when your account has it. gpt-6-astra is for the hardest end-to-end work and gpt-6-luna for focused, repeated jobs. The 's low is called Light in the app, and ultra works with .
model = "gpt-6.1-sol"
model_reasoning_effort = "high"codex -m gpt-6.1-sol/modelSmall, repeated jobs (renaming, a typo, a log line) run faster and cheaper on a lower effort or a lighter model. Raise it to xhigh or max — or pick fable or gpt-6-astra — only for long, difficult, multi-step work, and come back to High afterwards.
These six habits appear in both official guides. Each card shows how to do it in and in .
Say the goal, the context (files, docs, the full error — attach files with @), the limits and when it is done. Point to an existing pattern to copy. Keep investigations narrow so the agent does not read hundreds of files.
@file · cat error.log | claude -p "…"@fileFor work that touches many files or that you do not know well, switch to plan mode, read and plan, adjust the plan, then build. For a big feature, let the agent interview you and write a spec. If you can describe the change in one sentence, skip the plan.
Shift+Tab · claude --permission-mode plan/plan · Shift+TabGive it something that passes or fails — tests, a build, a to compare — and ask it to show the evidence. Before you call the job done, have a fresh reviewer read the .
/code-review/reviewRules you repeat go into AGENTS.md or CLAUDE.md — short, with the build and test commands. Knowledge needed only sometimes becomes a , outside information comes through , and must-happen steps become hooks.
CLAUDE.md · .claude/skills · claude mcp addAGENTS.md · .agents/skills · codex mcp addUse one conversation per piece of work, clear it between unrelated tasks and compact long ones. If two corrections fail, start fresh with a better request — a clean session beats a long one full of failed attempts.
/clear · /compact · /btw · /rewind/new · /compact · /forkRun it from scripts and without the chat screen, give each parallel job its own , and do your own work while it runs instead of watching every step. Schedule a recurring job only after it works reliably by hand.
claude -p · git worktreecodex exec · git worktreeGoal: Remove an item from the cart when its quantity becomes 0.
Context: @src/cart.ts @tests/cart.test.ts — the total is NaN today.
Constraints: Keep the public API. No new packages.
Done when: a new test covers quantity 0 and the tests pass.
Show me the test output as evidence.Goal · context · limits · done when, plus the evidence you want to see. Replace the files and the goal with your own.
The Claude Code guide lists five failure patterns and the Codex guide eight. Joined by meaning, they make ten. The chips show which official list each comes from.
Mixing unrelated tasks in one conversation, or running a whole project in one chat — the context fills with noise.
Claude CodeCodex CLI
Fix: One conversation per clear outcome; clear or open a new one between unrelated tasks.
Habit 5 — Keep the context cleanCorrecting the same thing again and again — the context fills with failed attempts.
Claude Code
Fix: After two failed corrections, start fresh with a better first request that includes what you learned.
Habit 5 — Keep the context cleanStuffing lasting rules into every request, or letting the rules file grow so long that important rules get lost.
Claude CodeCodex CLI
Fix: Move lasting rules into AGENTS.md or CLAUDE.md and keep it short; delete what the agent already does right, or turn it into a hook.
Habit 4 — Keep lasting rules in filesTrusting work you cannot check — no build or test commands given, so the code looks right but misses .
Claude CodeCodex CLI
Fix: Always give a way to check (tests, scripts, screenshots) and write the build and test commands down. If you cannot check it, do not ship it.
Habit 3 — Let it check its own workAsking it to "investigate" with no limit — it reads hundreds of files and fills the context.
Claude Code
Fix: Narrow the scope in the request, or hand the investigation to a subagent.
Habit 1 — Ask with four partsSkipping the plan on complex, multi-step work.
Codex CLI
Fix: Start in plan mode and agree on the plan before any code changes.
Habit 2 — Plan hard work firstGiving the agent full access to your computer before you understand the .
Codex CLI
Fix: Start with the default and loosen them only when you need to.
Habit 4 — Keep lasting rules in filesRunning several live jobs on the same files at once.
Codex CLI
Fix: Give each parallel job its own Git worktree.
Habit 6 — Scale up and work in parallelScheduling a recurring job before it works reliably by hand.
Codex CLI
Fix: Run it by hand until it is reliable, then schedule it.
Habit 6 — Scale up and work in parallelWatching the agent step by step instead of working in parallel.
Codex CLI
Fix: Hand the job over with a clear and do your own work meanwhile.
Habit 6 — Scale up and work in parallelChecked in the official documents on 2026-10-26. The recommended models are SONUB's choice as of November 2026; models change often, so check the model pages too.
Every request sends the whole conversation to the model again, so the bigger the , the faster your plan limit runs out. This tab shows how to read your usage, when the limit comes back, what fills the context, and how to compact at about 400k instead of 1M. Commands and settings were checked in the official docs on 2026-10-26.
A subscription does not count messages one by one — it gives a usage allowance that refills over time windows. Look at the numbers before a long task, not after you hit the limit.
Check with/usage/context
/usage shows your plan usage bars and what used them (skills, , servers) over the last day or week; /context shows how full the context is right now.
Refills every 5 hours weekly
A rolling 5-hour window and a weekly window. When you hit a limit, the message shows the reset time, for example “resets 3:45pm”.
Source (new window)Check with/status/usage weekly
/status shows the model, this session's token usage and your remaining limits; /usage daily or /usage weekly shows token activity. The usage dashboard (chatgpt.com/codex/settings/usage) shows the reset times.
Refills every 5 hours weekly
Plus and Business have a 5-hour window (Pro has none at the moment), and weekly limits may also apply.
Source (new window)Check withopencode stats --days 7 --models
opencode stats shows tokens and cost by day and by model.
Refills every 5 hours weekly monthly
OpenCode Go splits the monthly limit: up to 20% in 5 hours, 50% in a week and 100% in a month.
Source (new window)Check with/usage/context
/usage shows your credit usage and /context shows how much of the context is used.
Refills not in the official docs
The official docs do not say when the limit resets.
Source (new window)Check with/usage
/usage shows token usage, how full the context is and your quota.
Refills every 5 hours weekly monthly
The usage API reports a 5-hour, a 7-day and a monthly window, each with its reset time.
Source (new window)Check with/usage/context
/usage (or /quota) shows the requests and tokens left for each model; /context shows what fills the context.
Refills every 5 hours weekly
Google AI Pro refills every five hours until the weekly limit; without Pro or Ultra the quota refills weekly.
Source (new window)Before you pay for extra usage, use what is already free.
Codex — open /usage and redeem an earned reset if one is available. It resets your rate limit without buying credits.
/usage
Claude Code — when a limit stops a task, keep the session open. It waits and continues the task by itself after the reset (on by default; choose with /rate-limit-options or the autoContinueAtUsageLimit setting).
/rate-limit-options · autoContinueAtUsageLimit
The context has two parts. The base context is loaded before you type anything and goes with every request. The conversation sits on top of it and grows with every request, every file read and every command output.
Keep it at 6% or less (SONUB rule). Open a new conversation and look at /context (, agy) or /status () before asking anything.
Each answer, each file the reads and each command output is added. Nothing leaves until the conversation is compacted or cleared.
Base context over 6%? Turn off MCP servers you do not use, remove unused skills and plugins, and keep only the rules every request needs in CLAUDE.md and AGENTS.md.
replaces the older conversation with a summary so the session can go on. Details are lost, and the summary request itself reads the whole conversation.
The tool compacts by itself when the context reaches a threshold. You choose that threshold with the settings in step 4.
Compact at a good break point and say what to keep, for example: /compact Focus on the failing test and the files we changed.
When the next task is unrelated, open a new conversation instead (, /new). It costs nothing and drops everything old.
| Tool | Compact by hand | Start fresh | Automatic — setting | By default |
|---|---|---|---|---|
| Claude Code | /compact |
/clear |
autoCompactEnabled · autoCompactWindow |
On by default. With a 1M model it compacts at about 967K unless you set a window. |
| Codex CLI | /compact |
/new |
model_auto_compact_token_limit |
Compacts at model_auto_compact_token_limit; when it is not set, at the model default. |
| OpenCode | opencode api post /api/session/<id>/compact |
— | compaction.auto · compaction.buffer |
On by default. Keeps 15% of the limit (at least 16k) free and the last ~15,000 tokens beside the summary. |
| Grok Build | /compact |
— | auto_compact_threshold_percent |
Compacts at 85% of the context window by default. |
| Kimi Code | /compact |
— | loop_control.reserved_context_size |
Compacts when the free space drops below loop_control.reserved_context_size. |
| Antigravity CLI | not in the docs | — | not in the docs | Compacts older turns into checkpoint summaries by itself; the docs show no command or setting for it. |
Today's models can hold 1M tokens, but you do not have to fill them. If the tool compacts at about 400k, every request carries less and the same plan lasts longer.
Both official docs tie usage to context size. Claude Code: token costs scale with context size, and the full conversation is sent with every request. Codex: longer sessions that hold more context use significantly more per message. A request near 900K carries about twice as much as one near 450K. With a subscription, people say this lets you use the AI about twice as much — that is a common report, not an official number.
{
"autoCompactWindow": 444000
}Compacts when the context reaches 444,000 tokens, for every model (allowed range 100k–1M). A window saved for one model with /autocompact comes first — check with /context in a new conversation.
/autocompact 444k · claude --autocompact 444k/contextmodel_context_window = 500000
model_auto_compact_token_limit = 475000model_context_window tells Codex the window is 500,000 tokens, and model_auto_compact_token_limit compacts at 475,000 (95% of it). Check with /status in a new conversation.
/statuscompaction.buffer is the free space kept below the model limit — with a 1M model, 600000 starts compaction at about 400k.
{
"compaction": { "buffer": 600000 }
}auto_compact_threshold_percent is the percent of the window that starts compaction — 40 is about 400k on a 1M window.
[session]
auto_compact_threshold_percent = 40The default window is 256K (KIMI_MODEL_MAX_CONTEXT_SIZE 262144), already smaller than 400k — nothing to change.
The docs show no setting for the window or the compaction point — it compacts by itself.
About 400k and 6% are SONUB rules, not official recommendations — the official docs only explain the settings.
Commands, settings and defaults were checked in these official docs on 2026-10-26.