Same Model, Twice the Work? Why OpenCode vs Codex Can Stretch Your ChatGPT Usage Limits Differently (Harness and MCP Explained)

A developer posted on social media that after switching from Codex to OpenCode, still running the same GPT-5.6 Sol through ChatGPT sign-in, it felt like they…

How reading tools work

Listen reads the article aloud. Speed read shows phrases in sequence at your chosen pace. Language practice compares available translations. Save keeps a bookmark in this browser; find it in the player’s bookmarks. Play this article as Breakout turns its own words into bricks for you to knock out.

Share this article
Same Model, Twice the Work? Why OpenCode vs Codex Can Stretch Your ChatGPT Usage Limits Differently (Harness and MCP Explained)
AI-generated image

The short answer: Even with the exact same model, how much of your limit you burn depends on what gets stuffed into the context every turn, how many times the model is called, how much tool output it keeps dragging along, and when it compacts. If the model is the engine, a harness like Codex or OpenCode is the transmission, fuel injection, GPS and mechanic rolled into one. Same engine doesn't mean same gas mileage.

1. "Same 5-hour limit, twice the work": first, this is one person's experience, not a benchmark

A developer posted on social media that after switching from Codex to OpenCode, still running the same GPT-5.6 Sol through ChatGPT sign-in, it felt like they got more than twice as much done within the same 5-hour and weekly limits.

In the replies, people recommended another harness called pi, wondered whether the context-limit settings were different, and said they'd want routing or usage tracking to see what was actually being spent.

The most important point: nobody has proven that OpenCode officially gives you 2x the usage. It's an interesting observation, not a controlled test.

What OpenAI does say is that Codex usage isn't a fixed number of messages. It varies with the model, where the task runs, how complex it is, the context, the reasoning, the speed and the tools. Depending on the plan, there's both a 5-hour window and a weekly window.

So the idea that "switching harnesses changed my mileage" makes a lot of sense given how the system works.

2. What's a harness? Everything outside the AI's brain

If you only look at the model, it's simple:

Sol = the brain.

But a real coding agent surrounds that brain with a lot of machinery:

  • how the system instructions are put together
  • which files get read
  • how many tokens of past conversation are kept
  • how many tools (shell, GitHub, etc.) the model is shown
  • how much tool output is carried into the next turn
  • how many times it retries after a failure
  • how many rounds of plan, implement and review it runs
  • whether it compresses the context before it overflows
  • whether it splits work off to subagents
  • when it decides it's "done"

That whole package is the harness, in the broad sense.

OpenAI itself uses the word "harness" for Codex and describes an App Server that connects the model with each client, the tools and the conversation state.

So:

same model ≠ same system

Put the same V8 in a 2-ton SUV and in a light car, and you won't get the same mileage.

3. What kills an AI's mileage is usually the luggage it hauls on every turn

An agent's usage isn't just about how many words it writes back.

In a long session, every round of reasoning can carry:

  • a long conversation history
  • a big system prompt
  • AGENTS.md and project rules
  • MCP tool definitions
  • lots of files pulled from GitHub
  • huge shell logs
  • test results
  • past failures
  • info for the next retry

Once, that's no big deal.

The problem is sending and re-reading it 10, 20, 30 times.

Reading a 100KB log once often hurts less than calling the model over and over while dragging around 100KB worth of context.

On top of that, if harness A finishes a job in 15 turns while harness B burns 30 turns on plan → check → explore → explore again → review → review again, you'll obviously see a gap, even with the same model.

Mileage isn't just about the engine. It falls apart through:

luggage × round trips × retries

4. Why OpenCode is interesting: ChatGPT sign-in, MCP and compaction in one box

According to OpenCode's docs, when you connect OpenAI you can pick ChatGPT Plus/Pro and sign in through your browser. That's offered separately from typing in an API key.

OpenCode can also act as an MCP client and add both local and remote MCP servers.

So you can set things up like this:

OpenCode → GitHub MCP → database MCP → your own API → other external tools

OpenCode also has automatic compaction, which swaps the older active context of a long session for a checkpoint. The current docs show automatic compaction turned on by default, with an example that keeps a generated summary plus roughly the last 15,000 tokens.

It's less "delete the old conversation" and more:

keep the history in the warehouse, but only load what you need for the next run

It's not magic, though. OpenCode itself warns that each MCP server you add eats context with its tool definitions, and that big ones like GitHub MCP can fill it up fast.

Plug in 20 MCP servers and call it "maxed out," and you've basically equipped your hero with the entire warehouse.

5. Running everything from ChatGPT through MCP is pretty much the same idea

A setup where ChatGPT sits in the middle and works GitHub, servers, cloud services and storage through MCP or connectors is, at its core, also "model + harness + tools."

As a wiring diagram, it's simple:

ChatGPT → MCP / connector → GitHub, servers, cloud, storage

ChatGPT makes the calls, MCP is the hands and feet, and each service holds the real-world state.

Same with OpenCode:

OpenCode → MCP / shell / API → repository, server, cloud

The difference is where the conversation state lives, where the tool loop runs, and where the context gets compressed.

So "Isn't this basically the same as running everything from ChatGPT over MCP?" Pretty much, yes.

Same blueprint, different brand name on the control room.

6. So can ChatGPT hand work off to OpenCode?

OpenCode officially supports the "uses MCP" side. On the other hand, the docs cited here don't spell out a mode that exposes OpenCode itself as a general MCP server. What they do clearly offer is an HTTP/OpenAPI server with an SDK, or an ACP entry point.

With opencode serve, you can run OpenCode as a headless HTTP server and control sessions and agents through OpenAPI. There's a JS/TS SDK too.

So if you want ChatGPT to pass jobs to OpenCode, a clean setup looks like this:

ChatGPT → thin MCP bridge → OpenCode Server → Sol → MCP / shell / API → GitHub, cloud, etc.

The bridge only needs to expose a tiny set of tools:

  • opencode_run_task
  • opencode_get_status
  • opencode_get_result

That's about it.

Instead of hauling dozens of GitHub tool definitions and giant logs into ChatGPT every time, OpenCode finishes the long hands-on work and sends back only the final result.

That's the moment "better mileage" becomes a design choice instead of luck.

7. If you really want to cut usage, cut how often you go back to the AI, not the AI itself

The most common mistake is thinking a cheaper model will fix everything.

Model choice does matter, of course.

But for long-running automated work, this kind of split often matters even more:

  1. hand predictable, step-by-step jobs to scripts
  2. keep state and receipts on the machine side
  3. turn on only the tools you actually need
  4. summarize or pull out the key parts of long logs before giving them to the model
  5. don't reread the same file again and again
  6. save the failure reason and the next action as state
  7. send only the fuzzy judgment calls back to the high-end model
  8. send only the final check of what actually went live back to the human

The ideal setup:

AI = handles the fuzzy stuff

scripts / workflows = run the steps that are already decided

GitHub / database / saved state = remembers things

If you make the AI figure out "wait, what was I doing next?" every time, it starts a full warehouse inventory every time.

Have the machine write down the next action, and you only need to call the AI when you really need it.

8. But "OpenCode always gets you more out of the same limit" can't be said yet

What OpenAI's official docs confirm: Codex and Work share a usage limit, some plans have a 5-hour window and a weekly window, and usage varies with context, tools and so on.

What OpenCode's official docs confirm: you can sign in with ChatGPT Plus/Pro.

But neither side's official docs say whether ChatGPT sign-in through OpenCode is metered by OpenAI with exactly the same formula and internal weights as Codex, and there's no chart saying OpenCode always gets you X times more.

So:

"I got twice as far" is an interesting real-world report.

"You'll always get twice as far" is unconfirmed.

Best not to mix those up.

If you want a real comparison, use the same repo, same model, same task and same definition of "done," and track:

  • total number of model calls
  • input/output tokens
  • number of compactions
  • number of tool calls
  • actual time on the clock
  • number of changes completed
  • number of retries
  • final test results

Don't ask "how many hours did I get?" Ask how much did each successful task cost?

That's your real mileage.

9. Bottom line: after picking a model, the next big lever is the wiring

It used to be all about "which model is the smartest."

In the age of agents, that's not enough.

Even with the same model, how much work gets done changes with:

  • how the context gets packed
  • how many tools there are
  • how state is tracked
  • compression
  • retries
  • how "done" is decided
  • how work is split with outside workflows

The model is the engine.

The harness is the whole system: fuel injection, transmission, GPS, pit crew, even trunk space.

So "why is the same Sol so different?" is actually a very natural question.

And the moment you start wiring up multiple services with MCP, what you're doing shifts from "using AI" to

designing a workplace around the AI.

And the bluntest truth of all: the best MCP setup isn't the one that asks the AI about everything.

It's the one that adds more steps where you don't need to ask the AI at all.

Sources


References (8)

  1. OpenAI, Unlocking the Codex harness: how we built the App Server openai.com
  2. OpenAI Help Center, Using Codex with your ChatGPT plan help.openai.com
  3. OpenAI Help Center, Managing usage with GPT-6 Astra in Work and Codex help.openai.com
  4. OpenCode Docs, Providers opencode.ai
  5. OpenCode Docs, MCP servers opencode.ai
  6. OpenCode Docs, Compaction opencode.ai
  7. OpenCode Docs, Server / SDK https://dev.opencode.ai/docs/ja/sdk/ dev.opencode.ai
  8. OpenCode Docs, ACP opencode.ai

AdBooks on this topic

This article contains affiliate links (ads). About advertising As an Amazon Associate I earn from qualifying purchases.

If this article helped you, you can support the site. Support

Read this today

Each one answers a question readers of this article tend to ask next.

Browse all articles

Find other articles

All articles

Mendoi-chan

Who runs this site

Mendoi-chan

She turns friction at work and in everyday life into clear structure and practical next steps.