Lands today midnight PST

Tibo's doing everything he can to make us forget about the resets lmao

Source: https://x.com/thsottiaux/status/2115297093879472332?s=46

Here we go again! Check your limits and have fun.

Source: https://x.com/thsottiaux/status/2115330127886463244?s=46

3% Till left

Personally GPT-6.1 Terra replaced deepseek. Can't find a better Intelligence - $/task.

What would you drive from point A to B?

(intelligence index from the recent AA v5 release)

LOL, I found this really funny that it would ask for permission

My commentary about the model at the bottom of the post.

For some time now I have been measuring GPT model's allowances and several others. Because a new GPT model was released, it is time for an update.

Unfortunately, the trend continues. With each new model release, the new model gets less quota in API-equivalent compared to the previous ones. Also, unfortunately, the claim that we get 2x the usage out of Terra compared to Sol is a straight-up lie.

Measured on a fresh context window on a Plus account for accurate measurements, like always. Context limited to 272k to make sure I don't go past the double price. I didn't check Luna or Astra yet, but Sol remains as it was. Generally the allowance for models is constant after their release from my measurements; only the new ones have less.

For Pro, simply multiply by 5/10/25.

As a bonus, here is a table of the "real cost" per million tokens and total amount of tokens per real dollar spent, also compared to DeepSeek v4.1 Flash (off-peak pricing), GLM 5.3 (off-peak), and Muse Spark. If you use OpenCode, Ollama Cloud, or CommandCode subscriptions, the price for DeepSeek goes down. At peak hours, the price for DeepSeek and GLM is 2x. Ollama has its own infrastructure with ZDR and uses different peak hours.

For z.ai plans, you can subscribe quarterly or yearly for better ratings.

Tokens per $1 assumes 97% cached input, 2.5% uncached input, and 0.5% output.

* - Claude charges for cache writes. The pricing is averaged. I used these numbers. Their findings for Codex match mine, so I trust them.

My commentary about the new model. It is the first and only model that simply doesn't want to work. During a simple mechanical refactor, it stopped 3 times, telling me it is only finished partially. At the end it changed a part of the code, ran tests, saw several errors, reverted the change, and reported that it is only partially done. I ran it on XHigh reasoning. I doubt Max would change much, but it is not out of the question. This is not a model for agentic coding, that's for sure. It is quick, but very unreliable.

I double-checked 6.1 Sol allowance; it is still the same as it was, so I recommend staying with 6.1 Sol or Luna. I have no use for 6.1 Terra. I see no reason in using it for coding when it gives us almost the same usage as 6.1 Sol. If you don't want your job done, use the new Terra, I guess. It may have a potential as an orchestrator, but that requires further testing.

Unfortunately, OpenAI continues its tactic to nerf the usage with each new model. By my own measurements, they don't nerf the usage of each model after they are released; they are nerfed from the release (compared to previous ones). You can see the trend with 5.6 Sol -> 6 Sol - 6.1 Sol -> 6.1 Terra. We are at the third of the 5.6 allowance now, which was also lowered compared to 5.5.

Everyone confused on what is the actual use case of this model, while Codex itself has no explanation for it as well 😂

​

It eats tokens faster than Sol 6.1. And according to benchmarks it's not on Sol's level of complex reasoning.

But damn, for normal human-level reasoning this model is incredible! It's so fast that I can barely keep up reading its outcome. The first model that can keep me glued to the Codex window. And while benchmarks may show it lags Sol, in real work it has never disappointed and it even feels much more natural than Sol.

What inspired me to write this post was something that just happened. My web client was getting error 500 from the backend. I asked Terra to check it for me. It ssh-d into the server, reviewed the container logs and by viewing the stack trace it identified it was a collision problem. 20 seconds later it told me that it had managed to replicate a similar error in a regression test. This would have taken me a good 2 hours to set up by myself. Another 20 seconds it had already fixed the bug. I did not guide it to the problem. It did everything by itself, no intermediate questions.

Its actions feel so human compared to Sol. It does away with the over-complications of Sol and the dumbness of Luna and provides an unassuming cleverness.

I used Codex to develop an app that runs MiniMax-H3 entirely locally on a smartphone, capable of generating a 5-second video in as little as 7 minutes. However, many people didn't believe me (Reddit post). When I tried to upload a completely uncut, unedited recording to prove it, I couldn't get it posted, possibly because my original post had received too many downvotes.

This demonstration shows that generating a video with a reference image takes just 8 minutes. Without a reference image, text-to-video generation can be as fast as 7 minutes.

Video and music generation are currently unavailable on Samsung Galaxy Fold devices, but this issue will be fixed in a future update.

I disagree with a lot of the recent discourse regarding why does Terra even exist – it seems to occupy the right slot for a worker agent being orchestrated by Opus/Astra. Most of my work is fully autonomous now, and I've had difficulty figuring out the best worker agents.

Sol eats up usage way too quickly to be useful, and Luna needs so much hand-holding that my orchestrator blows through its usage. Opus as orchestrator + Terra as worker + Sol/Astra/Argon as reviewer depending on complexity seems to be hitting the right balance.

I do wish they increase the limits for Terra though. It's a good model, just needs to be closer to Luna than Sol when it comes to usage and it would be golden.

Anyone experiencing command /side missing since the last update?

Version 26.1023.50603

I didn't and I'm now descending into full(er) AI psychosis.

Just discovered it this weekend. I've since been having a Windows and Mac coordinate on developing their respective version of a certain application. They each have their branch of the git project, talk over design, architecture and features, exchange technical data like API contracts, trade screenshots to align on UI etc

Agents can also search projects on their local and connected clients, so you can tell them something like "look up the network security project and let them know about this thing we just discussed" and they'll do just that. They can even start new tasks in another project.

I'm sure advanced users already knew, but I didn't, and it blew my mind.

I use Codex and Claude Code daily, and the most annoying moment is hitting a usage limit halfway through a task. You either wait hours or paste context into another tool by hand.

Moonfold is an open-source desktop and web workspace that runs the agent CLIs you already have (Codex and Claude Code today, with adapters for Cursor, OpenCode and others in beta) with your own logins. When one hits its limit, it stops the turn, writes a brief of where the task stands (plan, changed files, git status, the failing command), redacts secrets, shows you the brief, and hands the same thread to the next agent. The GIF in the README is a real run: Codex starts a bug fix, Claude finishes it.

It is a fork of T3 Code (MIT), which gave me the multi-provider base, worktrees and diff review. What I added: the handoff, usage tracking per provider, scheduled tasks, in built browser pane and computer access, plugins and memories, and a security pass (Supervised is the default permission mode).

Honest limits: it is a beta, builds are unsigned, Gemini CLI is not verified end to end yet, and the brief is only as good as what the first agent left behind. Nothing is proxied: each agent is your own local CLI, and there is no telemetry unless you turn it on.

I'd love feedback on the handoff brief what would you want carried over that isn't?

Windows, macOS, Linux. Beta, feedback welcome: github.com/Mr-Dark-debug/Moonfold

I've been using both GPT-6.1 Terra and GPT-6.1 Sol in Codex, and I've noticed that Terra on Medium reasoning seems to consume my usage limits significantly faster than Sol, even when working on similar tasks.

I expected Terra on Medium to be relatively efficient, but my experience has been the opposite.

Has anyone else noticed this? Does Terra actually consume more usage per task, or could something else be affecting the usage calculation?

Curious to hear your experiences, especially from people who have compared both models on the same workload.

new AA v5 rankings are out and openai is looking pretty solid. gpt models are holding their own near the top, while google, muse and kimi seem to have fallen behind quite a bit.

obviously benchmarks aren't everything, but it's interesting to see how much the rankings have shifted.

curious how well this actually reflects real-world coding performance. what do you guys think?

New Reset just dropped. I hit 4%. *whew*

Since the labs like to cherry pick benchmarks to showcase their new models in a better light (as well as mislead and confuse by inverting the X axis, not starting the Y axis from 0, selectively using linear/log for cost axis depending on which fits their narrative better, and so on), I thought it'd be a fun exercise to do the opposite: cherry pick the worst results to make 6.1 Terra look as terrible as possible. Thankfully, the model's questionable cost efficiency makes this quite an easy job.

(this isn't meant to be an accurate assesment of 6.1 Terra, for example it very clearly runs circles around Luna in Terminal Bench 4.0)

FrontierCode 1.1 - FYI this benchmark replaced DeepSWE 1.1 in Artificial Analysis' benchmarks 4 days ago. - Luna 6 max beats Terra 6.1 max while being 91% cheaper and using less tokens. Time per task is 42% lower for Luna.

Humanity's last exam: 6.1 Terra medium 40%, 6 Luna max 39%

AutomationBench-AA: 6.1 Terra max 60%, 6 Luna max 53%

AA-Briefcase 1.1: 6.1 Terra max 1402, 6 Luna max 1336

GDPval-AA v2.1: 6.1 Terra max 1476, 6 Luna max 1445

Long context reasoning, AA-LCR v1.1: Luna 6 max at the same level as 6.1 Terra max.

SciCode Bench is currently flagged as having possible errors so the results aren't fully complete, but even then: Luna only loses by 0.5%, but uses half the output tokens, while being 95% cheaper.

In short, in some workflows you may be using significantly more tokens, billed at a higher price/usage, all while achieving the same or worse results you would have gotten with 6 Luna. Taking 6.1 Sol into consideration too, Terra sticks out as a cost efficiency misfit. Case in point: on TBench 4.0: - 6.1 Sol (xhigh) - 54% - $1.03 - 57K tokens - 6.1 Terra (max) - 55.6% - $1.49 - 101K tokens

For coding, even if Terra has 2x faster tok/s, why would you ever pay almost 50% more to perform at the same level, at the same time per task?

Auto mod keeps deleting the post for low effort even though its a whole music video, pls spare it automod

Hey everyone!

I've been using Codex for a while now, and I'd say I'm somewhere between a beginner and an advanced user.

I have some programming background, so I understand concepts like databases, JavaScript, loops, arrays, variables, and general programming logic. However, I'm definitely not a professional developer.

I've watched quite a few tutorials and experimented with different approaches. Based on what I've learned, I've developed the following workflow, but I'd really appreciate feedback from more experienced users.

1. Main Chat — Planning & Architecture

I use GPT-6.1 Terra High as my main agent.

Its responsibilities include:

- System architecture and project planning

- Breaking down complex tasks

- Delegating work

- Making high-level technical decisions

- Coordinating the overall development process

I also use subagents for QA and code reviews, usually running GPT-6.1 Terra Low.

1. Multiple Separate Chats — Implementation

I create multiple independent chats depending on the project and the specific features I'm working on.

For implementation, I mostly use GPT-6.1 Terra Medium, occasionally switching to Low or High depending on task complexity.

There are two main reasons I use separate chats:

- Task separation: Each chat focuses on a specific feature, module, or section of the project.

- Context management: I try to avoid filling up the context window with too much information.

Once a chat reaches around 50% of its context window, I usually start a fresh one, providing the same instructions along with a summary of what's already been completed and what still needs to be done.

1. Instructions & Agent Configuration

I also use an AGENTS.md file to define project instructions, coding conventions, and general guidelines before starting development.

Additionally, I try to give my agents clear goals rather than overly detailed step-by-step instructions, allowing them to figure out how to accomplish the task.

What I'd love to know

I'd really appreciate your thoughts on a few things:

1. Is this actually a good workflow, or am I overcomplicating things?

2. Am I using the right models and reasoning levels for each task? When would you use Low, Medium, or High?

3. Is switching chats at 50% context usage a good practice, or am I unnecessarily losing valuable context?

4. How do experienced Codex users manage multiple agents and parallel development tasks without creating conflicts?

5. Are there any tools, techniques, or workflows I'm missing that could significantly improve code quality, efficiency, and overall results?

My goal isn't just to make AI write code faster. I want to become better at managing AI coding agents, understanding the architecture, and building reliable, production-ready applications.

I'm especially interested in hearing what actually works for you in real projects, rather than just theoretical best practices.

Thanks in advance for any advice or suggestions!