5-second answer: Even with the same model, consumption can vary substantially depending on what is inserted into context on every turn, how many times the model is called, how much tool output is retained, where compaction happens, and how retries are handled. If the model is the engine, a harness such as Codex or OpenCode is the transmission, fuel injection, navigation system, and pit crew combined. The same engine does not guarantee the same fuel economy.
1. “Twice the work in the same 5-hour window” — first, this is an anecdote, not a benchmark
A developer posted on social media that after switching from Codex to OpenCode while still using the same GPT-5.6 Sol through ChatGPT authentication, they felt they could get more than twice as much work done within the same 5-hour and weekly windows.
Replies suggested another harness called pi, questioned differences in context-limit settings, and proposed using routing or telemetry to measure actual consumption.
The most important point is that nobody has proved that OpenCode officially gives you twice as much usage. It is a meaningful observation, but not a controlled comparison.
OpenAI, meanwhile, explains that Codex usage is not based on a fixed message count. It varies with the model, where the task runs, task complexity, context, reasoning, speed, tools, and other factors. Depending on the plan, there may be both 5-hour and weekly limits.
So the phenomenon “changing the harness changed the fuel economy” is entirely plausible in terms of system mechanics.
2. What is a harness? Everything outside the AI brain
If you look only at the model, the story is simple.
Sol = the brain.
But an actual coding agent has a large amount of machinery around that brain.
- how system instructions are assembled
- which files are read
- how many tokens of prior conversation are kept
- how many tools such as shell or GitHub are exposed
- how much tool output is carried into the next turn
- how many retries happen after failures
- how many cycles of plan, implementation, and review are run
- whether context is compacted before overflow
- whether work is delegated to subagents
- when the system decides “done”
This entire package is the harness in the broad sense.
OpenAI itself uses the word “harness” when describing Codex, including the App Server that connects the model, clients, tools, and conversation state.
So:
same model = same system
is false.
It is like putting the same V8 engine into a 2-ton SUV and a lightweight chassis and expecting identical mileage.
3. What usually destroys AI fuel economy is the luggage carried every turn
Agent consumption is not determined only by how many characters the answer contains.
In a long session, every round of reasoning may carry:
- a long conversation history
- a large system prompt
- AGENTS.md and other rules
- MCP tool schemas
- large files read from GitHub
- huge shell logs
- test results
- prior failures
- information for the next retry
Any one of these can be manageable once.
The problem is resending and reinterpreting them 10, 20, or 30 times.
Reading a 100 KB log once may matter less than calling the model repeatedly while carrying roughly 100 KB of active context each time.
There is also the number of turns. If harness A finishes a task in 15 turns while harness B uses 30 turns for plan → confirmation → exploration → re-exploration → review → re-review, the same model can still consume very different amounts.
Fuel economy is broken not only by engine performance, but by:
luggage × round trips × retries
4. Why OpenCode is interesting — ChatGPT authentication, MCP, and compaction in one box
OpenCode's official documentation says that when connecting to OpenAI, users can choose ChatGPT Plus/Pro and authenticate in the browser. This is separate from the path where an API key is entered manually.
OpenCode can also act as an MCP client and connect to both local and remote MCP servers.
That enables configurations such as:
OpenCode → GitHub MCP → database MCP → custom API → other external tools
OpenCode also provides automatic compaction. Its current documentation says automatic compaction is enabled by default and shows an example that keeps a generated summary plus roughly the most recent 15,000 tokens.
That is less like “deleting old conversation” and more like:
keeping history in the warehouse while loading only the necessary cargo for the next deployment.
But it is not magic. OpenCode itself warns that adding MCP servers consumes context through tool schemas and related metadata, and that large MCPs such as GitHub MCP can put significant pressure on context.
Connecting 20 MCP servers and declaring “now I'm invincible” may simply mean the hero has equipped the entire warehouse.
5. Running everything from ChatGPT through MCP is basically the same idea
A setup with ChatGPT in the center, operating GitHub, servers, cloud services, storage, and other systems through MCP or connectors is also fundamentally a “model + harness + tools” architecture.
The wiring is simple:
ChatGPT → MCP / connector → GitHub, server, cloud, storage
ChatGPT makes decisions, MCP provides the hands, and each external service stores real-world state.
OpenCode follows the same idea:
OpenCode → MCP / shell / API → repository, server, cloud
The difference is where conversation state lives, where the tool loop runs, where context gets compacted, and where completion is decided.
So the answer to “Isn't this basically the same as controlling everything from ChatGPT through MCP?” is quite close to yes.
Same architectural idea, different control room.
6. Can ChatGPT delegate work to OpenCode?
OpenCode officially supports acting as an MCP client. In the cited official documentation, however, the explicitly documented entry points for programmatically controlling OpenCode itself are its HTTP/OpenAPI server, SDK, and ACP rather than a generic mode that exposes all of OpenCode as an MCP server.
Running opencode serve starts OpenCode as a headless HTTP server, allowing sessions and agents to be controlled programmatically through OpenAPI. There is also a JS/TS SDK.
So if you want ChatGPT to hand work to OpenCode, a clean design is:
ChatGPT → thin MCP bridge → OpenCode Server → Sol → MCP / shell / API → GitHub, cloud, and other systems
The bridge can expose only a few tools:
- opencode_run_task
- opencode_get_status
- opencode_get_result
That is enough.
The ChatGPT side no longer needs to carry dozens of GitHub tool schemas or huge logs every turn. OpenCode can complete the long-running work locally and return only the final result.
That is where “fuel-efficiency improvement” becomes a system design rather than a vague impression.
7. If you seriously want to cut consumption, reduce how often work returns to the AI
A common mistake is to assume that switching to a cheaper model solves everything.
Model choice certainly matters.
But in long-running automation, it is often just as important to:
- move deterministic operations into scripts
- keep state and receipts on the machine side
- enable only the tools that are actually needed
- summarize or extract long logs before sending them to the model
- avoid rereading the same unchanged files
- store the failure reason and next action as state
- return only ambiguous judgment calls to the high-performance model
- send the human only the final production readback
The ideal division of labor is:
AI = handles ambiguity
script / workflow = executes fixed procedures
GitHub / DB / state = remembers
If the AI has to ask “what was I supposed to do next?” every time, you are paying for another warehouse inventory check on every cycle.
If the machine stores nextAction, the AI only needs to be called when judgment is required.
8. But we still cannot say that OpenCode is always more efficient under the same limit
What OpenAI officially confirms is that Work and Codex share usage limits, that some plans have both 5-hour and weekly windows, and that consumption varies with context, tools, and other factors.
What OpenCode officially confirms is that ChatGPT Plus/Pro authentication is supported.
What the cited official documentation does not provide is a comparison table proving that ChatGPT OAuth through OpenCode is metered with exactly the same internal formula and coefficients as Codex, or that OpenCode always gives a fixed multiple of extra work.
Therefore:
“I got twice as much work done” is an interesting measurement.
“You will always get twice as much” is unverified.
A real comparison should use the same repository, model, task, and completion criteria, then measure:
- total model calls
- input/output tokens
- compaction count
- tool-call count
- wall-clock time
- completed changes
- retry count
- final test result
Instead of asking “how many hours did it last?”, measure what was consumed per successful task.
That is the real fuel economy.
9. Conclusion — in the AI era, wiring matters almost as much as model choice
In the past, the central question was often “Which model is smartest?”
In the agent era, that is no longer enough.
Even with the same model, the amount of useful work can change depending on:
- how context is packed
- the number of tools
- state management
- compaction
- retries
- completion criteria
- division of labor with external workflows
The model is the engine.
The harness is the combined system of fuel injection, transmission, navigation, pit crew, and even trunk capacity.
So “Why is it so different if it is the same Sol?” is actually a very natural question.
And the moment you start connecting several services through MCP, what you are doing changes from “using AI” to:
designing a workplace around AI
The least glamorous but perhaps most powerful conclusion is that the strongest MCP strategy is not “ask AI about everything.”
It is increasing the number of steps that do not need to ask AI at all.
Sources
- [1] OpenAI, Unlocking the Codex harness: how we built the App Server
https://openai.com/index/unlocking-the-codex-harness/ - [2] OpenAI Help Center, ChatGPTプランでCodexを使う
https://help.openai.com/ja-jp/articles/11369540 - [3] OpenAI Help Center, WorkとCodexでのGPT-6 Astraの利用量管理
https://help.openai.com/ja-jp/articles/20001516-managing-usage-with-gpt-6-astra-in-work-and-codex - [4] OpenCode Docs, Providers
https://opencode.ai/docs/providers - [5] OpenCode Docs, MCP servers
https://opencode.ai/v2/docs/mcp-servers - [6] OpenCode Docs, Compaction
https://opencode.ai/v2/docs/compaction - [7] OpenCode Docs, Server / SDK
https://dev.opencode.ai/docs/server/
https://dev.opencode.ai/docs/ja/sdk/ - [8] OpenCode Docs, ACP
https://opencode.ai/v2/docs/cli/acp/
Sources
- OpenAI, Unlocking the Codex harness: how we built the App Server openai.com
- OpenAI Help Center, ChatGPTプランでCodexを使う help.openai.com
- OpenAI Help Center, WorkとCodexでのGPT-6 Astraの利用量管理 help.openai.com
- OpenCode Docs, Providers opencode.ai
- OpenCode Docs, MCP servers opencode.ai
- OpenCode Docs, Compaction opencode.ai
- OpenCode Docs, Server / SDK https://dev.opencode.ai/docs/ja/sdk/ dev.opencode.ai
- OpenCode Docs, ACP opencode.ai
