I Tested GPT-6.1 Sol at All Six Reasoning Efforts. Max Wrote the Best Code Twice

OpenAI's GPT-6.1 Sol arrived on September 29, and Codex lets you pick how hard it thinks. For GPT-6.1 Sol my Codex install listed six settings, from low to ultra. The labels tell you very little. Is xhigh worth twice the wait of high? Does ultra do anything max does not? I wanted numbers from real builds, not a vendor chart, so I ran the same prompts at every setting and kept everything.

I used Codex CLI 0.159.0 on a normal Windows laptop: an Intel Core i5-1235U with Iris Xe integrated graphics and 16 GB of memory. The model runs on OpenAI's servers, so the laptop mostly matters for the 3D test, where the result has to run smoothly on it.

Each run used the same command apart from the effort setting: gpt-6.1-sol, Codex's memory feature turned off, an ephemeral session so nothing carried over to the next run, write access limited to one folder, and network access on. The six efforts ran one after another, never in parallel. A script recorded the start and end time, and Codex's own event log recorded every command, file edit and web search plus the final token counts.

Other Codex jobs share the same machine and account. In test 1, my other project's Codex jobs overlapped with medium for about 22 minutes, with high for about 22 minutes and with part of xhigh. In test 2, only the first part of low overlapped. Token counts are unaffected by this. Times may be slightly inflated for those runs.

The prompt, word for word:

Build a website about yourself that showcases all of your capabilities. Go all out.
Do not use any memories, saved preferences or notes from previous sessions. Start from scratch. Work only inside this folder.
When you're finished, summarise what you built and where everything is.

The climb from low to max is steep. Low used 178 reasoning tokens, which is barely any thinking at all, and max used 37,664. Then two things break the pattern. High and xhigh used almost exactly the same amount of reasoning, and xhigh finished five minutes sooner. Ultra used half of max's reasoning and finished 22 minutes earlier.

Every build is a working site. Low's is a one-page "ChatGPT showcase" with a particle sculpture. Medium added its own AI-generated artwork, four working playgrounds and a Lighthouse audit. High built a 12,500-particle sculpture, a poster designer and a CSV analysis tool. Xhigh switched to a mint-and-ivory design with 12 capability areas and opened its own browser tab to show off the result. Max built a real 3D sculpture you can drag, plus four studio tools. Ultra ran 22 browser tests and 24 accessibility scans and added a download of its own source code.

The links open each build exactly as the model made it, rebuilt to run from this site's address. I added only a small dismissible note at the bottom of each page, because several of these pages call themselves "Codex" and none of them is an official OpenAI page.

To judge the code fairly, I copied the six source folders into anonymous folders A to F in random order and removed build output, images, dependencies and any path that hinted at the effort. A separate Claude Sonnet agent with read-only access scored each one from 1 to 10. It never saw which letter was which. I unblinded the scores afterwards. You can read the reviewer's notes for every build at the end of this post.

This is where low falls apart. Its site looks fine, but its main source file is 12.5 KB packed into about 11 lines, one of them 7,291 characters long, and its stylesheet is a single 10.8 KB line. The reviewer called it effectively unreviewable. Medium had the same habit, with a 27 KB main file and lines up to 2,292 characters.

Max got the reviewer's highest marks: a typed logic module with real unit tests for things like quoted CSV fields and HTML injection, small focused components, and a 3D scene that loads lazily and falls back gracefully if WebGL fails. High was the most consistently formatted. Ultra had the deepest browser and accessibility tests but packed whole sections of markup onto single lines.

Build the Colosseum in Rome as an interactive 3D experience in the browser using Three.js. Focus on graphics: go all out on visual quality, realistic lighting, materials, physics and real-world detail.
Build everything in code. Do not download or use any ready-made 3D models, textures or images. It must run smoothly on an ordinary laptop with integrated graphics.
Do not use any memories, saved preferences or notes from previous sessions. Start from scratch. Work only inside this folder.
When you're finished, summarise what you built and where everything is.

The no-assets rule matters. Without it, a capable agent can download a ready-made Colosseum model and the test stops measuring anything. I checked every build folder: none contains a downloaded model, texture or image. The only image files are the models' own screenshots.

The harder brief made low think 26 times more than it did in test 1, and low took longer and thought more than medium. Xhigh and ultra were the only efforts that used Codex's browser-control tool to click through their own scene, 40 and 19 times. Max measured performance itself and reported 55 to 60 frames per second on the ruins and 48 on the full reconstruction, on this laptop's Iris Xe at 1440 by 960. I have not checked those numbers myself yet.

The 3D builds are heavier than test 1. On a laptop, give each one a few seconds to settle, and use its quality switch if it has one.

Max again had the best structure: separate modules for maths, geometry, materials, the model, physics and audio, a stone shader that keeps the masonry grain the same size on every instanced block, real swept-sphere collision for walking, and tests that check the geometry and a triangle budget. Ultra wrote the cleanest, most readable code and the only complete clean-up paths, but runs an ambient-occlusion pass that the reviewer flagged as expensive on integrated graphics. Medium put everything into one 99-line file and re-renders the shadow map every frame, the single most avoidable cost on a laptop.

Max is the real top setting. In both tests max thought the most, took the longest and won the blind review. In test 1 it used more than three times the reasoning tokens of xhigh.

Ultra did not do what its label says. Codex describes ultra as maximum reasoning with automatic task delegation. In both tests ultra made exactly one delegation call, a "wait" with nobody listed to wait for, and never started a helper agent. In test 2 it said it was "building the masonry and landscape in parallel" and later claimed an "independent review". No other agent took part in either. It used about half of max's reasoning tokens in test 1 and about a third in test 2.

The low and medium builds look better than their code. If you only compare screenshots, low and medium look like most of the result for a fraction of the time. The blind review tells a different story. Those were the hardest builds to read and change, with whole apps squeezed into a few enormous lines.

More effort meant more checking. Low checked that its build passed. The higher efforts wrote unit tests, ran browser test suites, audited accessibility and, in two cases, clicked through their own pages with a browser tool. Most of the extra time goes into checking the work, not only into making it.

The sites were never running. Eleven of the 12 final summaries said the site was running on localhost, and the twelfth gave a localhost link to open. In every case the development server had stopped when the run ended. It is a small thing, but it is a false statement in almost every report, and worth knowing before you click a link an agent gives you.

The defaults are sticky. The test 2 builds at low, medium and high look like the same design system: beige stone, an editorial layout and names like "Monument" and "Atlas". The prompt asked for realism, but none of the six went for photorealism.

For a quick prototype you will throw away, low or medium is enough. They finished in 11 to 27 minutes and produced working, decent-looking pages. Do not plan to maintain that code.

For something you will keep and change, use max. It was slow, about an hour per build, but it produced the most maintainable code in both tests, with real tests.

I would not pick ultra for a single build like these. In my runs it never delegated, so I saw no benefit over max. It may behave differently on larger tasks that split naturally into parts, which I did not test.

High and xhigh sit in between and did not separate clearly from each other. If max feels too slow, xhigh is the one I would try first, mainly for its habit of checking its own pages in a browser.

Each effort ran once per test. A second run could come out differently, especially between neighbouring efforts like high and xhigh. The code review is one AI reviewer, not a panel of people. The test counts and Lighthouse scores I quote for each build are the model's own reports, not something I reran. Some runs shared the machine with other Codex jobs, which can stretch their times. And all of this is Codex with a ChatGPT sign-in on one Windows laptop; the API or another setup may behave differently. I have not yet measured the frame rate of the 3D builds myself, and I will add those numbers when I do.

The reviewer was a Claude Sonnet agent with read-only access to anonymous copies labelled A to F. These are its findings, shortened, with the effort level added after unblinding. Scores are code quality, readability and maintainability, plus graphics engineering in test 2, each out of 10.

Which reasoning effort should I use for GPT-6.1 Sol in Codex?

In my two builds, max produced the best code in a blind review both times but took about an hour per build. Low and medium finished in 11 to 27 minutes and looked fine in the browser, but their code was the hardest to read. Use low or medium for throwaway prototypes and max for code you plan to keep.

Is ultra better than max for GPT-6.1 Sol?

Not in my test. Ultra never started a helper agent, used a third to a half of max's reasoning tokens, finished sooner, and ranked third and second in the blind code review. Max ranked first both times.

Does higher reasoning effort make better-looking websites?

Only partly. Low and medium already looked polished. Higher effort added more features, more testing and much better code structure, and that showed up in the code review more than in screenshots.

How long does GPT-6.1 Sol take at max reasoning effort?

In my runs, max took 1 hour 17 minutes for the website and 58 minutes for the 3D Colosseum. Low took 11 and 19 minutes for the same two tasks.

For prices and access details, see the GPT-6 Sol and Luna guide, which includes the GPT-6.1 Sol update. To pick a model for a specific job, use the task-by-task model guide.

Written by

Paras Tiwari

Founder, Spectrum AI Labs

Founder of Spectrum AI Labs — testing AI tools and models, and writing up what actually ships.

More about Paras →