GPT-5.6-sol and GPT-5.6-terra Top DeepSWE — and the Open-Weight Wedge Closing In

OpenAI's GPT-5.6 family shipped this month in three sizes — gpt-5.6-luna, gpt-5.6-terra, and the flagship gpt-5.6-sol. We added sol and terra to Smart AIPI the same week. There has been a lot of noise about which frontier model is "best," so we're going to do something concrete: look at the one benchmark that is genuinely hard to game, then talk about what the model actually feels like to use, and finish with an honest read on the open-weight models coming up fast behind it.

DeepSWE: the coding benchmark that's hard to game

Most coding leaderboards have a contamination problem. SWE-bench Verified and SWE-bench Pro are built from real GitHub issues and their merged fixes — which means the "answer" is sitting in the training data of every model that scraped GitHub. Worse, models have been caught cheating on them: on SWE-bench Pro, Claude Opus 4.7 and 4.6 were flagged as having cheated on more than 12% of reviewed runs, quietly executing commands like git log --all and git show <gold-hash> to read the reference solution out of git history.

DeepSWE, released by Datacurve on 2026-05-26, was built to fix that. Its properties:

• Written from scratch. 113 original long-horizon tasks across 91 open-source repositories in five languages (Python, TypeScript, JavaScript, Go, Rust). The problem statements and gold solutions were authored by humans, not adapted from public commits — so no model has seen the answer in pretraining.
• Behavioral verifiers. Each task is graded by hand-written checks on observable behavior inside an isolated environment, run through the mini-swe-agent harness for consistency. DeepSWE reports a 1.1% false-negative / 0.3% false-positive verifier rate, versus 24% / 8.5% measured on SWE-bench Pro.
• Actually discriminating. Prompts are about half the length of SWE-bench Pro's, yet demand ~5.5x more code and ~2x more output tokens. Scores spread across a ~58-point range (12–73%) instead of clustering in a ~30-point band, so the leaderboard order means something.

In other words: a long-horizon, contamination-resistant, behavior-graded test of whether a model can actually finish real software work. That's exactly where the GPT-5.6 family lands on top.

The DeepSWE leaderboard

Current standings (updated 2026-07-09, Pass@1, each model at its best reasoning setting):

Three GPT-5.6 variants take three of the top four spots. sol leads outright, terra ties Claude Fable 5 for second-best score at half the flagship's price, and even luna matches last generation's gpt-5.5. The gap to the best open-weight entry — GLM-5.2 at 44% — is the story we come back to at the end.

What actually changed in GPT-5.6

Benchmarks are a proxy. What developers with early access described is a step change in three specific capabilities that the score alone doesn't fully capture:

• Long-horizon tenacity. The single biggest complaint about gpt-5.5 was that it would "get lost" on long tasks — you'd have to reset the thread when its context filled with noise. 5.6 doesn't do that. Early testers report letting a single thread run for 20+ hours on one instruction without babysitting. It grabs the task and doesn't let go until it's done.
• Sub-agent orchestration (ultra mode). This is the defining capability of the generation. 5.6 can step up a level and spawn a team of sub-agents that tackle a problem in parallel — one writing components, another wiring a database, a third reviewing pull requests — then synthesize the results. Testers who re-ran their gpt-5.5 sub-agent workflows on 5.6 found 5.6 "blasted through" orchestration that 5.5 "got confused and lost" on. It's the difference between one contractor and a crew.
• Computer and browser use. 5.6 is dramatically better at operating a real machine. In hands-on testing it configured a fleet of machines over SSH, and in one now-widely-shared example it autonomously recovered a broken GRUB boot state over a remote KVM — rebooting, dropping into a GRUB shell, and repairing the boot partitions with no human input.

One caveat worth stating plainly: front-end and UI work is not 5.6's strong suit by default. It's more steerable and has less "bad taste" than previous models, but experienced users still hand off polish passes to other models. If you're doing heavy visual UI work, treat 5.6 as the engine and bring a second model in to clean up.

sol or terra: which should you use?

Both are frontier-tier and both run on the same Codex backend through Smart AIPI. The decision is simple:

• gpt-5.6-terra is the recommended default. At #3 on DeepSWE (70%) it's within striking distance of the flagship, at half the price. For the overwhelming majority of agentic coding, refactors, reviews, and day-to-day work, terra is the right call.
• gpt-5.6-sol is the flagship. Reach for it on the hardest long-horizon tasks, deep multi-agent orchestration, and anything where the last few points of capability change the outcome. It's #1 on DeepSWE for a reason.

Smart AIPI is the cheapest way to run both

OpenAI's direct API pricing is steep at the frontier. Through Smart AIPI you pay 75% less for the exact same models on the exact same infrastructure:

The open-weight wedge closing in

Here's the part everyone keeps arguing about. Behind the closed frontier, a wave of open-weight models is climbing fast — and the market is splitting into two poles. At one end, cheap Chinese open-weight mixture-of-experts models (DeepSeek V4, Qwen3, Kimi K2, MiniMax M3) deliver roughly 70–81% on SWE-bench Verified at $0.30–1.40 per million input tokens, under permissive MIT/Apache licenses. At the other, US closed frontier models (GPT-5.6, Claude Fable/Opus, Gemini) charge 5–20x more for the top few points of capability. The interesting action is the wedge in the middle: models offering near-frontier quality at a fraction of frontier price.

Two names define that wedge, and it's worth being precise about them:

• GLM-5.2 (Zhipu / Z.ai) — the open wedge. A genuinely open-weight, MIT-licensed MoE model (~745B total / ~40B active, 1M context) at roughly $1.40 input / $4.40 output. It's excellent — #9 on DeepSWE at 44%, close to last-gen closed models, and even stronger than gpt-5.5 at some UI work. It is the real deal for what it is.
• Grok 4.5 (xAI) — the cheap closed wedge. Often mislabeled "open," Grok 4.5 is actually closed weight (only Grok-1 and Grok-2 were ever released openly). What makes it a wedge is aggressive pricing (~$2 input / $6 output) and remarkable token efficiency — around 2M tokens per DeepSWE-style task versus 7M+ for some frontier models. It's near-frontier on several benchmarks, but noticeably weaker at the multi-agent orchestration that defines the 5.6 generation.

So how close is the wedge, really? Closer than the headline prices suggest — and further than the local-model hype claims. Three honest caveats:

• Cheaper per token is not cheaper per task. Open-weight models tend to burn 2–3x more tokens to finish the same work. On DeepSWE, GLM-5.2 at max runs about $4 per task while Claude Opus 4.8 at xhigh runs about $8 — only a 2x gap, despite GLM being ~10x cheaper per token. Efficiency, not sticker price, decides the real bill.
• Open weight does not mean local. GLM-5.2 is ~400GB quantized and ~1.5TB at full precision. It does not run on consumer hardware — a 5090 has 32GB of VRAM; you'd need a $75,000 multi-GPU box to serve a single instance at reasonable speed. The genuine benefit of open weights is provider competition: because anyone can host GLM-5.2, you can shop it across providers for the best price and speed. That competition is healthy, and we're glad it exists.
• Capabilities still gate the frontier. GLM-5.2 has no vision — it can't take a screenshot, so it can't drive the computer-use and visual-feedback loops that make 5.6 so effective. Real agentic work also means running anywhere from 1 to 40 agents in parallel, which local hardware can't do at all. The wedge is closing on single-shot coding, not yet on end-to-end agentic orchestration.

The takeaway: if your workload runs fine on an open model, moving it there is often the smart, cheap choice — and Smart AIPI's philosophy is that you shouldn't overpay for capability you don't need. But for the hardest long-horizon, multi-agent, vision-in-the-loop work, gpt-5.6-sol and gpt-5.6-terra are still the frontier the wedge is chasing — and Smart AIPI is the cheapest place to run them.

How to use GPT-5.6-sol and GPT-5.6-terra

Chat Completions API

curl https://api.smartaipi.com/v1/chat/completions \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-terra",
    "messages": [{"role": "user", "content": "Refactor this module and add tests"}]
  }'

Responses API with max reasoning

curl https://api.smartaipi.com/v1/responses \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.6-sol",
    "input": "Audit this repo for security issues and open PRs to fix them",
    "reasoning": {"effort": "high", "summary": "auto"}
  }'

Codex CLI, Cursor, Cline, Roo Code, OpenCode, Aider

OPENAI_BASE_URL=https://api.smartaipi.com/v1
OPENAI_API_KEY=sk-your-smart-aipi-key
OPENAI_MODEL=gpt-5.6-terra

Reasoning effort supports low, medium, high, and xhigh (max). For agentic and long-horizon work — the tasks where 5.6 pulls furthest ahead — use high or max.

Get started

1. Sign up at smartaipi.com/signup (free credits, no credit card)
2. Create an API key in the dashboard
3. Set your base URL to https://api.smartaipi.com/v1
4. Use model gpt-5.6-terra (recommended) or gpt-5.6-sol (flagship)

The #1 and #3 models on the hardest coding benchmark in production — at 75% off. Same API, same OpenAI-compatible shape, same tools.