ChatGPT on KnightLi Blog

After Google I/O, Should You Subscribe to GPT or Gemini? A Comparison for Regular Users and Developers

Thu, 21 May 2026 08:33:14 +0800

After Google I/O 2026, choosing an AI subscription has become more complicated.

The old question was simpler: for writing, Q&A, coding, and file analysis, most people looked at ChatGPT first; if they were deeply tied to Google Search, Android, Gmail, Docs, or YouTube, they would then consider Gemini. That has changed. At I/O, Google put Gemini 3.5 Flash, Gemini Omni, Antigravity 2.0, Gemini API Managed Agents, Google AI Studio, and AI Ultra into one broader subscription story. Gemini is no longer just an optional alternative; it has become a serious competing ecosystem.

This article does not compare abstract benchmark scores. It answers a practical question: should regular users, developers, content creators, and enterprise users subscribe to GPT / ChatGPT, or to Gemini / Google AI?

Note: AI subscription prices, quotas, regions, and model availability change quickly. This article was written on May 21, 2026. Before subscribing, always check the current OpenAI and Google pages.

The Short Answer

If you only want one primary subscription, use this logic:

Daily writing, Q&A, file analysis, office work, and mixed Chinese-English tasks: prioritize ChatGPT Plus.
Heavy coding, Codex usage, complex reasoning, and project-level code tasks: prioritize ChatGPT Plus / Pro, then decide whether to upgrade based on quota.
Deep use of the Google ecosystem, including Gmail, Docs, Drive, Android, and Search: prioritize Gemini / Google AI Pro.
Video, AI imagery, Google Flow, YouTube Shorts, and Gemini Omni: prioritize Google AI Pro / Ultra.
Antigravity, Gemini API Managed Agents, and workflows from AI Studio to Android: focus on Google AI Pro / Ultra.
Enterprise teams: do not compare only personal plans; look at Business / Enterprise, Workspace, permissions, audit, and data boundaries.
Limited budget: one paid primary subscription plus another platform’s free tier or pay-as-you-go API is usually better than two high-end subscriptions.

In one sentence: GPT is still the stronger default productivity and coding assistant; after Google I/O, Gemini looks more like a system-level AI suite inside the Google ecosystem.

What Changed for Gemini After Google I/O

Google I/O 2026 made Gemini’s value depend on much more than the Gemini App itself.

Several changes matter:

Gemini 3.5 Flash: Google positions it as a fast model for prompt-to-action workflows and real agent tasks.
Gemini Omni: creates content from arbitrary input, currently starting with video, with multimodal creation and natural-language iterative editing.
Google Antigravity 2.0: an agent-first development platform for multi-agent orchestration and coding.
Gemini API Managed Agents: lets developers create hosted agents that can reason, use tools, and execute code through the API.
Google AI Studio: moves from a prompt playground toward mobile, Android native app generation, and Antigravity project export.
Google AI Ultra: a new $100/month tier after I/O, aimed at developers, technical leads, knowledge workers, and advanced creators.

More importantly, Google moved Gemini App usage from traditional daily prompt limits toward a compute-used model. Complex video, code, and long-context tasks consume more quota, while simple text tasks consume less. Quotas refresh every five hours until weekly limits are reached.

That shows Google is trying to package Gemini subscriptions as an entry point for “model + app + creation + development tools + Google ecosystem.”

Who Is ChatGPT / GPT Best For Now?

ChatGPT remains very strong, especially for people who treat AI as a daily workhorse.

According to OpenAI’s current pricing page and help documentation, ChatGPT Free includes basic capabilities such as GPT-5.5 Instant. Plus provides GPT-5.5 Thinking, higher message and upload limits, stronger image generation, deep research, agent mode, projects, tasks, custom GPTs, and expanded Codex usage. Pro provides higher limits, GPT-5.5 Pro, higher Codex usage, and the largest deep research and agent mode capacity.

ChatGPT is especially suitable for:

Writing, summarizing, translation, and editing.
Complex Q&A and structured analysis.
File upload, spreadsheet analysis, and research reports.
Coding Q&A, code review, and refactoring advice.
Using Codex for repository-level tasks.
Multilingual content production.
Users who care about model quality and response stability but are not deeply tied to Google products.

For regular users, ChatGPT Plus is still the safest primary subscription. It covers a wide range of work, has a low learning curve, and handles Chinese and English tasks evenly.

For developers, the key part of ChatGPT is not only chat, but Codex. OpenAI’s help documentation says Codex can be used with eligible ChatGPT plans, with usage limits varying by plan. If you use Codex heavily for code edits, PRs, refactoring, or test fixes, you need to include Codex quota in your subscription decision.

Who Is Gemini / Google AI Best For Now?

After Google I/O, Gemini’s advantage is clearer: it is more deeply bound to the Google ecosystem.

Google AI subscriptions are no longer only model quota inside the Gemini App. They also include Gemini Omni, Google Flow, Antigravity, AI Studio, some YouTube Premium / Lite benefits, and Workspace / Android / Search ecosystem capabilities. Google also expanded AI Ultra into a $100 and higher-tier subscription line, emphasizing developers, technical leads, knowledge workers, and advanced creators.

Gemini is especially suitable if:

You deeply use Gmail, Docs, Drive, Sheets, Slides, and Android.
You want AI inside Google Search, YouTube, and Workspace.
You care about Gemini Omni, Google Flow, video generation, and video editing.
You want to try Antigravity, Gemini API Managed Agents, and AI Studio mobile.
You need ultra-long-context document understanding.
You build Google ecosystem apps, Android native apps, or Workspace automation.

Google’s help page says Gemini Apps context windows increase with subscription level: 32K without an AI plan, 128K with AI Plus, and 1 million with AI Pro and AI Ultra. AI Pro / Ultra also provides higher usage limits, more features, and some early access capabilities.

If your work already lives in the Google ecosystem, Gemini’s value becomes much larger. Otherwise, subscribing to Gemini only as “another chatbot” may not be more cost-effective than ChatGPT.

How Regular Users Should Choose

The easiest trap for regular users is subscribing to multiple platforms just because a new model was announced.

A more rational choice starts with your main use case.

If you mainly do:

Writing.
Research.
Summaries.
Reading PDFs.
Email.
Resume editing.
Language learning.
Daily Q&A.

Choose ChatGPT Plus first. It is more general-purpose, has clearer task boundaries, and does not require deep ecosystem lock-in.

If you mainly do:

Heavy Gmail / Docs / Drive / YouTube / Android use.
Want AI directly inside Google’s ecosystem.
Want to try Gemini App, Daily Brief, Google Search AI, and YouTube content Q&A.
Need long-context reading of Google documents.

Choose Google AI Pro first.

If you are a light user, start with the free tiers on both platforms and pay only after you clearly hit limits. Do not subscribe to a high-end plan just because you might use it someday.

How Developers Should Choose

Developers fall into two broad groups.

The first group mainly asks coding questions, fixes bugs, writes scripts, and reads repositories. For them, start with ChatGPT Plus / Pro + Codex.

Reasons:

Codex is tied to the ChatGPT account.
ChatGPT is stable for code explanation, refactoring, tests, and error analysis.
Plus already covers many daily development tasks.
Pro is better for high-frequency, long-running, complex repository tasks.

The second group builds around the Google ecosystem, agent platforms, Android, Workspace, or Gemini API. For them, start with Google AI Pro / Ultra.

Reasons:

Gemini 3.5 Flash is a key post-I/O model for agent workflows.
Antigravity 2.0 is Google’s agent-first development platform.
Managed Agents can create tool-using agents with isolated Linux environments through the API.
AI Studio connects more naturally with Android, Workspace, and Antigravity.

For full-stack developers, the most practical combination is usually:

ChatGPT Plus as the main tool for daily code and documentation.
Gemini free tier or AI Pro for Google ecosystem tasks, long context, and new video / agent capabilities.
Use APIs pay-as-you-go, and do not treat a personal subscription as a production API budget.

How Content Creators Should Choose

For content creators, the answer depends on what you create.

If you mainly do:

Copywriting.
Headlines.
Scripts.
Articles.
Image-and-text content.
Research organization.
Multilingual rewriting.

ChatGPT Plus is still very reliable.

If you mainly do:

Video generation.
Short-video ideas.
AI imagery.
YouTube Shorts.
Google Flow workflows.
Multimodal asset assembly.

Gemini / Google AI Pro or Ultra deserves more attention. After I/O, Gemini Omni and Google Flow are Google’s core offerings for creation.

If your budget is limited, subscribe to one text-first primary tool, then use the other platform’s free tier or a short-term subscription to test video capabilities. Video model quotas, queues, duration, resolution, and regional limits change quickly, so do not plan long-term production around them too early.

How Enterprises and Teams Should Choose

Enterprises should not choose like individual users.

What enterprises really need to examine is not “which model is stronger this week,” but:

Whether data is used for training.
Whether SSO, MFA, and RBAC are available.
Whether audit logs exist.
Whether internal knowledge connections are supported.
Whether plugins, connectors, and agent permissions can be controlled.
Whether the product meets compliance requirements.
Whether it integrates with the existing office suite.

If a company already heavily uses Google Workspace, Gemini enterprise plans are naturally worth evaluating. If the team has already built processes around ChatGPT, Codex, OpenAI API, and internal toolchains, OpenAI Business / Enterprise is the more natural fit.

Engineering teams also need to separately evaluate Codex, Antigravity, Gemini API Managed Agents, MCP, CI/CD, code permissions, repository access, and audit.

When You Need Pro / Ultra

Many people do not actually need a high-end tier.

Typical signs that you need ChatGPT Pro:

You use ChatGPT for long periods every day.
Plus limits are often insufficient.
You use Codex heavily.
You often run deep research, agent mode, and complex reasoning.
You need higher-end models such as GPT-5.5 Pro.

Typical signs that you need Google AI Ultra:

You use Gemini, Flow, and Antigravity frequently.
You need higher Gemini / Antigravity usage limits.
You create videos, AI imagery, or long-context research.
You deeply depend on the Google ecosystem and early access to new features.
You need Gemini Spark, Project Genie, or higher-tier subscription benefits.

If you only ask a few questions a day or occasionally write articles or edit code, Plus / Pro or AI Pro / Ultra may not be necessary.

The Most Cost-Effective Subscription Strategy

This combination is usually better:

Choose one paid primary subscription first.
Use the other platform’s free tier.
Pay for API only when you actually need API usage.
Turn high-consumption features such as video, agents, and deep research on and off monthly instead of subscribing all year blindly.
Review once a month: did you really use the quota?

Common combinations:

General office work: ChatGPT Plus + Gemini free tier.
Google ecosystem users: Google AI Pro + ChatGPT free tier.
Developers: ChatGPT Plus/Pro + Gemini API/AI Studio as needed.
Video creators: Google AI Pro/Ultra + ChatGPT free tier or Plus.
Enterprise teams: do not piece together personal plans; evaluate Business / Enterprise / Workspace plans directly.

Checklist Before Subscribing

Before paying, confirm these points:

Is the plan available in your region?
Is the model you need included in the plan?
Are Codex, Antigravity, Flow, and Omni actually available?
Do video features have region, age, queue, or resolution limits?
Is API usage included in the subscription, or billed separately?
Do file upload, context window, agent mode, and deep research have limits?
Do the privacy settings meet your project requirements?
Do you already have Google One, Workspace, ChatGPT Business, or school / company benefits?

Be especially careful: a personal subscription does not mean free API usage, unlimited commercial use, or enterprise compliance.

Summary

After Google I/O, Gemini is much more competitive, especially in video, multimodality, the Google ecosystem, Android, AI Studio, and Antigravity. But ChatGPT remains the steadier general-purpose choice, especially for daily writing, complex Q&A, file analysis, coding assistance, and Codex workflows.

The simplest judgment is:

If you do not know which to choose: start with ChatGPT Plus.
If you are a deep Google user: choose Google AI Pro.
If you are a heavy developer: compare Codex and Antigravity against your actual workflow.
If you are a video creator: look first at Gemini Omni, Flow, and Google AI Pro / Ultra.
If you are an enterprise user: choose by compliance, permissions, audit, and existing office ecosystem, not model hype.

More AI subscriptions are not automatically better. The more economical path is to define one primary workflow, then use other platforms as supplements instead of opening a long-term subscription after every product keynote.

References:

How Did AI Agents Evolve? A Complete 2022-2026 Five-Generation Timeline

Sat, 16 May 2026 19:19:52 +0800

AI Agents did not appear overnight.

At the end of 2022, ChatGPT was still mainly a chat window. By 2026, agents had begun to gain tool calling, file operations, computer control, long-term memory, remote collaboration, and persistent execution. In four years, they moved from “models that answer questions” toward “digital workers that can move tasks forward.”

If we look at the timeline, AI Agents have roughly gone through five generations. Each generation solved the previous one’s core limitation, while creating new bubbles and new safety problems.

Overview: five generations of Agents

Stage	Time	Keyword	Capability shift	Core problem
Generation 0	Late 2022 - early 2023	Chat box	Generates text, but cannot act	Model and real world are disconnected
Generation 1	Mid-2023 - late 2023	Tool calling	Outputs structured calls, connects APIs and RAG	Open-loop execution and task drift
Generation 2	Late 2023 - 2024	Engineered workflows	Planning, state, reflection, and multi-agent collaboration	Workflows are easy to copy; low-code bubble
Generation 3	2024 - 2025	Computer Use	Sees screens, clicks, and operates GUIs	Permission, safety, and misoperation risks
Generation 4	2025 - 2026	MCP / Skills / persistence	Tool networks, long-term context, and professional skills	Persistent execution expands the risk radius
Generation 5 preview	After 2026	Loops and world models	Stronger memory, validation, and physical action	Governance becomes harder

Late 2022: Generation 0, the ChatGPT chat-box era

Generation 0 begins with the release of ChatGPT on November 30, 2022.

This generation was not yet a real Agent. It had strong language generation ability, but it was mostly trapped in a chat box. It could write Python code, but not run it on your computer. It could plan a trip, but not book tickets. It could tell you how to edit a file, but not enter the file system and make the change.

Its capability boundary was clear:

understand natural language;
generate articles, answers, code, and plans;
no active access to fresh data;
no stable access to internal company knowledge;
no external action;
no long-term task state.

The core issue was the break between model capability and the real world. It could think and speak, but not act.

This stage also produced the first bubble: prompt engineers, prompt template markets, prompt courses, and prompt certifications. Early models were indeed sensitive to prompts, but the market mistook a temporary patch for a long-term moat.

As GPT-4-level models, system prompts, function calling, and better product defaults matured, many prompt templates lost scarcity. This pattern would repeat: a new capability creates a middle layer; the next generation internalizes it; the middle layer evaporates.

Mid-2023: Generation 1, tool calling wakes up

The keyword for Generation 1 is tool calling.

In June 2023, OpenAI released function calling. Developers could describe function names, purposes, parameter types, and JSON Schema. After understanding a user request, the model could output a structured JSON call instead of ordinary natural language, and an external system would execute it.

The architectural significance was large: the model started moving from a brain that only talks to a brain that can drive external tools.

Key capabilities included:

choosing tools based on user intent;
outputting structured arguments;
calling external APIs;
feeding API results back into the model;
using RAG to access external knowledge;
forming early personas through plugins and knowledge bases.

At the same time, RAG and vector databases became popular. They addressed the model’s lack of fresh information, private enterprise materials, and internal knowledge. The system retrieved relevant document chunks, injected them into context, and let the model answer from those materials.

The basic Agent structure became:

who you are: system prompt and persona;
what you know: knowledge base, RAG, private documents;
what you can do: function calling, plugins, external APIs.

The most dramatic bubble of this generation was AutoGPT. It showed an attractive idea: the user gives a broad goal, and AI breaks it down, searches, writes files, evaluates, loops, and stops when it believes the work is done.

But AutoGPT quickly exposed the problem. It lacked state constraints, stopping conditions, and reliable feedback. Tasks drifted, APIs were called with bad arguments again and again, and bills could be burned by huge numbers of model calls. The lesson was simple: tools plus an infinite loop do not make a production-grade Agent.

Late 2023 to 2024: Generation 2, engineered workflows

AutoGPT’s failure taught the industry that models cannot simply be left to improvise. Complex tasks need structure.

Generation 2 is about engineered workflows. An Agent became not just one model call, but a software system with state, control flow, and evaluation.

Key capabilities included:

task planning: breaking large goals into steps;
state management: tracking where work stands;
reflection and revision: generating, reviewing, and improving;
tool orchestration: switching between tools;
human-in-the-loop: asking for confirmation at key points;
multi-agent collaboration: dividing roles.

A typical pattern is ReAct, or Reasoning + Acting. The model reasons, calls a tool, observes the result, and then reasons again. The Agent no longer acts blindly; each step has auditable logic and feedback.

Common agentic workflow patterns emerged:

reflection: generate, review, revise;
tool use: choose search, databases, code execution, and enterprise APIs;
planning: decompose goals and track state;
multi-agent collaboration: product, developer, tester, reviewer roles.

The value of Generation 2 was putting model capability inside a controllable process. A well-designed workflow can sometimes make a smaller model produce more stable results than a single large-model call.

This generation also produced the low-code Agent platform bubble. Many tools used drag-and-drop interfaces to combine prompts, RAG, plugins, and flows. They lowered the building barrier, but if a workflow can be copied cheaply, the platform itself has a weak moat.

Low-code tools can capture early demand, but a demand window is not a defensible wall.

2024 to 2025: Generation 3, Computer Use reaches real interfaces

The keyword for Generation 3 is Computer Use.

Earlier tool calling relied mostly on APIs. What an Agent could do depended on what developers had connected. But many real-world apps do not have clean APIs, or their APIs are incomplete, closed, or inconsistent.

Computer Use lets models look at screens, click, and operate GUIs. The general computer interface itself becomes a tool.

Key capabilities included:

recognizing screen content;
clicking buttons, typing text, switching windows;
operating web and desktop software;
reading repositories, editing files, running tests;
inspecting terminal output and errors;
behaving more like a real engineering assistant.

This pushed Agents from “using connected tools” toward “operating software like a person.” It also made coding agents closer to real workflows: read a project, change code, run tests, and continue from errors.

But the trust boundary expanded. If AI operates a computer, it can click the wrong button, delete the wrong file, submit the wrong form, or be manipulated by webpage text, documents, and UI instructions. Prompt injection becomes a file-operation, permission, and system-safety problem.

Vibe coding debates also concentrated in this stage. Fast AI-generated projects feel exciting, but without tests, evaluation, permissions, and deployment boundaries, fast prototypes can become fast incidents.

Generation 3’s lesson: the closer an Agent gets to real operations, the more it needs sandboxing, approvals, rollback, and least privilege.

2025 to 2026: Generation 4, MCP, Skills, and persistent digital workers

Generation 4 is about persistence, connection, memory, and specialization.

The focus is not only stronger single tasks. Agents start to have long-term context, tool networks, professional skills, and a sense of time. They become less like helpers in one chat and more like digital workers that can continue working.

MCP addresses tool connection. It lets Agents connect to file systems, databases, browsers, design tools, project management tools, and enterprise systems in a more standardized way. Once the protocol stabilizes, many “tool-connection middle layer” products get compressed.

Skills address professional method. Tools tell an Agent what it can do; skills tell it how to do the work. A good skill is not just a prompt. It packages domain workflows, constraints, checks, common pitfalls, and tool-call order.

Key capabilities included:

long-term memory: storing preferences, project rules, and history;
project context: understanding repositories, docs, and work rules;
tool networks: connecting through MCP, APIs, browsers, and file systems;
professional skills: packaging task methods through Skills;
persistent execution: waiting, waking, reminding, and following up;
remote collaboration: users can return from different devices to approve and steer.

This generation starts to feel like an employee:

identity and responsibility boundaries;
long-term context;
professional work methods;
time awareness;
tool permissions;
ability to continue work without being watched.

But the more it resembles an employee, the more its risk radius resembles an employee’s. Persistent execution, local data access, secrets, tool calls, and task handling move security from the edge to the center.

One point matters especially: text is also an attack surface. If an Agent reads and follows Markdown, documentation, skill packs, or webpages, malicious text can change its behavior. Prompt injection becomes a supply-chain, permission, and execution-safety problem.

Generation 4’s lesson: persistent Agents need governance, not just capability.

After 2026: Generation 5 preview, loops, internal memory, and world models

Generation 5 is not established history yet. It is an extrapolation from the previous four years.

The first direction is more complete closed loops.

A mature Agent needs at least three loops:

execution loop: verify after each action, rollback, revise, and retry if needed;
time loop: track long-term goals across multiple wake cycles;
cognitive loop: know what is certain, what is guessed, and what is outdated.

The second direction is internal memory.

Most memory so far is outside the model: RAG, vector stores, chat logs, local files, and memory.md. If future model architectures support persistent state across sessions, Agent memory systems may be rebuilt.

The third direction is world models.

Many Agents today are still reactive: observe, respond, observe again. High-risk tasks require the model to simulate consequences. Before changing a database script, it should think about data loss, rollback failure, and compatibility issues, not learn only after an accident.

The fourth direction is embodiment.

Earlier generations mainly happened in digital space: APIs, screens, files, browsers, and enterprise tools. The next step may extend Agent action into the physical world, including robots, device control, industrial systems, and standardized physical interfaces.

Generation 5 will need to solve not only how Agents execute tasks, but how they understand consequences, manage long-term state, and stay reliable inside a larger risk radius.

Six patterns behind the timeline

First, base-model capability remains the ceiling. An Agent is not magic outside the model; it is a way to release model capability through engineering systems.

Second, engineered architecture amplifies model capability. Planning, verification, reflection, revision, evaluation, and permission control are closer to deliverable work than one-shot generation.

Third, open protocols reshape value distribution. Once MCP, Skills, and project-context standards stabilize, competition shifts from “who connected the tool first” to “who accumulated real domain capability.”

Fourth, the hidden main line of Agent evolution is expanding human-machine trust. From trusting text, to API calls, to workflows, to computer operations, to persistent execution, each generation pushes the risk radius outward.

Fifth, every generation’s accidents become the next generation’s rules. AutoGPT’s loops pushed structured orchestration; vibe coding failures pushed evaluation-driven development; production deletions pushed least privilege and sandboxing; skill poisoning pushed supply-chain safety.

Sixth, the Agent ecosystem repeatedly booms and collapses. New capabilities create temporary middle layers, and model or platform internalization later removes them. Mistaking a time window for a moat is dangerous.

The real moat

The real moat in AI Agents is not packaging a new capability first.

More reliable moats include three things.

First, vertical depth. Do you truly understand an industry’s workflow, risks, exceptions, and responsibility boundaries? General models can learn concepts, but they may not replace hard-earned domain execution experience.

Second, a data flywheel. Can you collect high-quality feedback from real usage and improve workflows, evaluation, fine-tuning, and product decisions?

Third, user trust. Will users hand you higher-value, longer-running, riskier work, or only treat you as a one-off tool?

If a platform or base model absorbs a capability, the products that still retain process, feedback, responsibility boundaries, and trust are more likely to survive. Many others are temporary bubbles.

Final note

From 2022 to 2026, AI Agent evolution was not “models getting better at chatting.” It was “humans becoming willing to hand more work to AI.”

A mature Agent is not the system most eager to execute automatically. It is the system that knows when to execute, when to verify, when to pause, and when to ask a human.

To judge whether an Agent product has long-term value, ask one question: when the next model or platform builds this capability in, what remains?

If the answer is domain workflow, real data, verifiable results, and user trust, there may be long-term value.

Codex Mobile Remote Access: Use the ChatGPT App to Follow Coding Tasks on Your Mac

Sat, 16 May 2026 17:42:40 +0800

In mid-May 2026, OpenAI brought Codex remote access into the ChatGPT mobile app. The point is not to write code on a phone. It is to let you follow and steer Codex while it keeps working on a Mac.

Think of it as a mobile approval and monitoring surface: Codex still reads the project, runs commands, edits files, and checks test results on the computer; the phone is used to review progress, answer questions, add instructions, and approve actions.

For people who often let Codex run longer tasks, this is useful. You no longer need to sit in front of the Mac waiting for Codex to ask for approval or get stuck.

What it can do

According to OpenAI’s Codex remote connections documentation, mobile access can:

start new threads in projects on the host, or continue existing ones;
send follow-up instructions, answer questions, and steer active work;
approve commands and other actions;
review outputs, diffs, test results, terminal output, and screenshots;
receive notifications when Codex completes a task or needs attention;
switch between connected hosts and threads.

So the mobile app is not just a small chat box. It connects to the actual Codex work context on the host.

Requirements

First, you need Codex access in the ChatGPT account and workspace you want to use. The phone and Mac must use the same account and workspace.

Second, install the latest ChatGPT mobile app on iOS or Android. If Codex does not appear in the app, update ChatGPT first.

Third, the host currently needs to be a Mac that is awake, online, running the Codex App, and signed in to the same account and workspace. OpenAI’s documentation says mobile setup and device control currently require Codex App for macOS; setup is not available from Codex CLI or the IDE Extension.

Fourth, complete any required MFA, SSO, or passkey flow. In a ChatGPT workspace, an admin may also need to enable Remote Control access.

This makes the feature a mobile control layer for Codex App on macOS, not a generic remote desktop or a universal Codex connection for every environment.

Limits of Codex mobile remote access

The feature is convenient, but the limits matter.

First, it currently needs a macOS host. The phone connects to Codex App running on a Mac, not directly to Codex CLI, the IDE Extension, or any Linux / Windows development machine.

Second, the host must stay online. The Mac needs to remain awake, connected to the network, and running Codex App. If it sleeps, loses network access, or closes Codex, the remote session can disconnect.

Third, connection uses a QR-code setup flow. You start Set up Codex mobile on the Mac, scan the QR code with your phone, and finish setup in ChatGPT. It is not a simple “enter host address” flow.

Fourth, remote actions still go through approvals. You can approve commands and actions from the phone, but you should read what Codex is asking to do before confirming, especially for terminal commands, file edits, tests, and external access.

In short, it is for following up after you leave the computer. It is not a full development environment replacement and should not be treated as unattended remote control.

How to connect

Start from Codex App on the Mac:

Open Codex on the Mac.
Select Set up Codex mobile in the sidebar.
Codex enables remote access for this host and shows a QR code.
Scan the QR code with your phone to open the Codex mobile setup flow in ChatGPT.
Confirm the same ChatGPT account and workspace.
Complete any required MFA, SSO, or passkey verification.
After setup succeeds, the Mac appears in Codex on your phone.

After connection, use Settings > Connections in Codex on the Mac to manage connected devices. You can also configure whether the computer stays awake, whether Computer Use is enabled, and whether the Chrome extension is installed.

What the phone is good for

The phone is best for approvals, course corrections, and result review.

Approvals are the obvious case: Codex asks to run a command or continue an action, and you can decide from the phone.

Course correction is just as useful. If Codex misunderstood the task, chose the wrong direction, or hit a failing test, you can send a short instruction and let it continue.

Result review is the third case. You can inspect diffs, test output, terminal logs, and screenshots without returning to the computer.

The value is not “coding on a phone”; it is turning the phone into a small control surface for engineering work that still runs on the host.

Common issues

If the host does not appear on your phone, confirm that Codex App is running on the Mac, Allow other devices to connect is enabled, and both devices use the same ChatGPT account and workspace.

If the approval request does not appear, open the ChatGPT mobile app, go to Codex, scan the QR code again, or restart setup from the host. Workspace users should also confirm that Remote Control access is enabled by an admin.

If the remote session disconnects, check whether the Mac slept, lost network access, or closed Codex App.

If authentication blocks setup, complete MFA, SSO, or passkey prompts first. In enterprise environments, workspace permissions may require admin help.

Best use cases

It fits users who run longer Codex coding tasks, want to approve commands away from the desk, manage multiple projects or threads, and already use a Mac as the main development machine.

It is less useful if you mainly use Windows or Linux, only use Codex CLI or an IDE Extension, expect the phone to be an independent development environment, or work on an unstable network.

My take

Codex mobile remote access is not about moving development to a phone. It is about making the waiting time around Codex more manageable.

Previously, long Codex tasks often stopped at approval, clarification, failing tests, or direction changes. Now those moments can be handled from the ChatGPT mobile app, while the Mac continues to do the actual engineering work.

If you already use Codex heavily on a Mac, this is worth enabling. If you only ask occasional coding questions, the value will be less obvious.

References

What Is ChatGPT File Library? File Storage, Limits, and Privacy Boundaries

Sat, 16 May 2026 17:40:14 +0800

ChatGPT File Library is the file library inside ChatGPT.

Previously, files uploaded to a conversation were mostly useful for that one chat. With File Library, files you upload or files created by ChatGPT can be saved to your account, found later, downloaded, deleted, or referenced again in a new conversation.

This makes ChatGPT feel more like a persistent workspace, not just a temporary chat box.

Latest availability

According to OpenAI’s May 14, 2026 ChatGPT Release Notes, File Library is expanding to Free and Go users, including users in the European Economic Area. OpenAI also added storage management across plans.

One detail matters: the dedicated File storage and Library help page still showed an older availability statement when checked, saying the Library was for Plus, Pro, and Business users outside the EEA, Switzerland, and the UK, and web-only.

Help pages can lag behind release notes. This article follows the newer May 14, 2026 Release Notes: File Library has started expanding to Free, Go, and more regions, but actual visibility still depends on rollout, region, and app version.

What it saves

ChatGPT can save files you upload or create, including:

documents;
spreadsheets;
presentations;
PDFs;
images;
files generated by ChatGPT.

Generated images still appear in the Images tab. File Library is more like a central place to manage uploaded and generated files.

If you often ask ChatGPT to analyze PDFs, organize spreadsheets, create documents, or work with presentations, this reduces repeated uploads and makes reuse easier.

Adding files to a new chat

In supported clients, you can open the attachment or add menu near the composer and choose Add from library, then select a saved file.

The Release Notes also mention Library and Recent files in the composer across Web, iOS, and Android. That means mobile clients can continue using saved or recent files too.

Finding and managing files

On the web, Library is available from the left sidebar. You can review uploaded and generated files, filter by type or source, and manage storage.

The help page lists filters such as uploaded files, generated files, images, documents, spreadsheets, presentations, and PDFs.

Storage management is available from Settings > Storage, and files can also be deleted directly from Library.

Storage by plan

OpenAI’s May 14, 2026 Release Notes list these capacities:

Plan	File Library storage
Free	500 MB
Go	4 GB
Plus	20 GB
Business	20 GB
Pro	100 GB

This storage includes uploaded files and files created by ChatGPT, such as documents, spreadsheets, presentations, and images.

For light users, 500 MB is enough for some PDFs, screenshots, and small documents. Heavy users should treat 20 GB or 100 GB more like a real working library and manage it regularly.

Per-file limits

OpenAI’s help page lists these file limits:

files uploaded to GPTs or ChatGPT conversations can be up to 512 MB each;
text and document files can contain up to 2 million tokens;
CSV or spreadsheet files are usually around 50 MB, depending on row size;
images can be up to 20 MB each.

These are separate from account storage. Even if your account has free space, a single file cannot exceed its own limit.

Deleting and downloading

Files stay in your account until you delete them.

In Library, select a file and use delete or the trash icon. OpenAI’s help page says deleted files are removed from the account immediately and scheduled for permanent deletion from OpenAI systems within 30 days, unless they have been de-identified and disconnected from the account or must be retained for security or legal obligations.

Files can also be downloaded from Library. If you often ask ChatGPT to generate documents, spreadsheets, or presentations, download and cleanup will become normal maintenance.

Temporary Chat does not save files

Files uploaded in Temporary Chat are not saved to your account or Library.

This is important. File Library is designed for reuse; Temporary Chat is better for temporary, sensitive, or one-off tasks where you do not want long-term context.

If a file is only for a quick question and should not be kept, use Temporary Chat. If you will reuse it, Library is more convenient.

Data and training settings

OpenAI’s help page says files and chats follow your settings and data controls.

If Memory is enabled, files and chats may help ChatGPT remember useful information across conversations. For consumer services, if Improve the model for everyone is enabled, OpenAI may use content submitted to ChatGPT, including uploaded files, to improve model performance. This can be turned off in Settings > Data Controls.

File Library is not a local folder. It is a cloud account feature, so think carefully about which documents should be uploaded.

Good and bad use cases

Good fits:

analyzing the same PDFs or reports over time;
reusing course materials, meeting notes, or product documents;
continuing to edit files generated by ChatGPT;
reusing the same source material across conversations;
turning ChatGPT into a lightweight knowledge workspace.

Poor fits:

highly sensitive identity documents, contracts, medical records, or financial statements;
using it as a formal cloud backup;
letting old files accumulate without cleanup;
uploading company internal documents without checking data controls.

My take

The value of ChatGPT File Library is not just a file list. It changes ChatGPT from a one-off chat tool into a workspace with persistent materials.

That also creates new habits: clean up old files, watch storage, distinguish normal chats from Temporary Chat, and review data controls.

If you often use ChatGPT for documents, spreadsheets, and research materials, File Library saves time. If you only upload sensitive files occasionally, be more careful.

References

OpenAI's New Realtime Voice Models: GPT-Realtime-2, Live Translation, and Streaming Transcription

Sat, 09 May 2026 10:58:47 +0800

On May 7, 2026, OpenAI introduced a new generation of voice models for the Realtime API. The point is not only to make AI sound more natural, but to let voice agents understand, reason, call tools, translate, and transcribe during a live conversation.

The update includes three models:

GPT-Realtime-2: the main model for realtime voice agents, with stronger reasoning, tool calling, and longer context.
GPT-Realtime-Translate: a live speech translation model that supports 70+ input languages and 13 output languages.
GPT-Realtime-Whisper: a low-latency streaming speech-to-text model for captions, meeting notes, and realtime workflows.

If early voice assistants were mostly “ask once, answer once,” this release moves closer to a voice interface that can listen and act at the same time.

GPT-Realtime-2: the main model for voice agents

GPT-Realtime-2 is built for live voice interactions. It does not just answer questions; it needs to keep context while the user speaks, changes direction, interrupts, or adds constraints, and then call tools when needed.

Officially highlighted capabilities include:

Short preambles before a response, such as “let me check that,” so users know the system is working.
Parallel tool calls for calendars, search, orders, support systems, and other multi-tool workflows.
More natural recovery behavior when something fails.
A context window increased from 32K to 128K for longer conversations and more complex task flows.
Better retention of specialized terminology, proper nouns, and medical vocabulary.
More controllable tone and delivery, such as calm, empathetic, confirmational, or upbeat responses.
Adjustable reasoning effort: minimal, low, medium, high, and xhigh, with low as the default.

This means developers can use voice agents in more demanding products, not only simple Q&A. A support agent can listen while checking an order; a travel app can give next steps after a flight change; a real estate assistant can filter listings and schedule a tour from spoken requirements.

Live translation for multilingual voice products

GPT-Realtime-Translate is designed for live speech translation. People can speak in their own language while the other side hears translated speech and sees realtime transcripts.

Clear use cases include:

Multilingual customer support.
Cross-border sales and pre-sales conversations.
Online education and live events.
International meetings and hosting.
Creator and video platform localization.

The hard part of live translation is not only accuracy. It also requires low latency, natural pauses, tone preservation, accent handling, and domain vocabulary. OpenAI is emphasizing cross-language conversations that feel closer to natural speech, instead of waiting for an entire segment before translation begins.

Streaming transcription: voice content enters workflows immediately

GPT-Realtime-Whisper is the new streaming speech-to-text model. Its value is turning speech into usable text while it is happening, instead of waiting for a recording to finish.

Common applications include:

Live meeting captions.
Classroom and broadcast captions.
Realtime meeting notes.
Continuous dictation input for voice agents.
Follow-up workflows in support, healthcare, recruiting, sales, and other high-volume voice scenarios.

For products, streaming transcription shortens the time from spoken words to actionable text. Captions appear faster, notes can be generated during the conversation, and downstream workflows such as summaries, task extraction, and CRM updates can start earlier.

Pricing and availability

All three models are available in the Realtime API. Official pricing is:

Model	Price
`GPT-Realtime-2`	Audio input $32 / 1M tokens, cached input $0.40 / 1M tokens, audio output $64 / 1M tokens
`GPT-Realtime-Translate`	$0.034 / minute
`GPT-Realtime-Whisper`	$0.017 / minute

OpenAI also says the Realtime API supports EU Data Residency and is covered by its enterprise privacy commitments. For European businesses or products with data residency requirements, that is worth evaluating separately.

What this means for developers

The key shift is that voice is becoming part of the product interaction layer, not just an input/output layer.

In many earlier voice features, speech was converted to text, and text responses were converted back into speech. The hard middle layer is intent understanding, interruption handling, context tracking, tool calls, tool transparency, and graceful recovery.

GPT-Realtime-2 tries to move more of that capability directly into the realtime voice model. For developers, the question is not only answer quality, but whether the model can support sustained conversations and multi-step tasks.

Products that are especially worth testing include:

Customer support voice agents.
In-car and mobile voice assistants.
Travel, booking, real estate, finance, and other services that need conversation plus lookup.
Multilingual meetings and cross-border communication tools.
Live captions, meeting notes, and call quality systems.

Safety and disclosure still matter

OpenAI says the Realtime API includes multiple safety layers, such as active classifiers over sessions and the ability to stop policy-violating conversations. Developers can also add their own guardrails through the Agents SDK.

One easily missed requirement is disclosure: developers should make it clear when end users are interacting with AI, unless that is already obvious from the context.

This matters in support, sales, education, healthcare, and similar scenarios. The more natural voice becomes, the more important product boundaries become: users should know they are talking to AI, and understand when speech may be recorded, transcribed, or used to trigger tools.

Summary

OpenAI’s Realtime API update moves live voice from “can listen and speak” toward “can listen while working through tasks.”

GPT-Realtime-2 handles more complex voice agents, GPT-Realtime-Translate handles live cross-language communication, and GPT-Realtime-Whisper handles low-latency transcription. Together, they cover the three basic capabilities most voice products need: conversation, translation, and transcription.

If you are building support, in-car, meeting, education, cross-border communication, or mobile voice assistant products, this release is worth testing. The important question is not only whether the model sounds natural, but how it performs in long conversations, interruptions, tool calls, failure recovery, and cost control.

Reference:

OpenAI: Advancing voice intelligence with new models in the API

What Is the Difference Between GPT-5.5, GPT-5.5 Instant, GPT-5.5 Thinking, and GPT-5.5 Pro?

Thu, 07 May 2026 21:59:33 +0800

OpenAI now separates GPT-5.5 into clearer usage tiers: Instant, Thinking, and Pro.

Many people mix up GPT-5.5, GPT-5.5 Instant, GPT-5.5 Thinking, and GPT-5.5 Pro. The short version: GPT-5.5 is the overall name for this generation of model capabilities. Instant is the fast everyday model, Thinking is the deeper reasoning mode, and Pro is a heavier research-grade mode.

Quick Comparison

Name	What It Is	Best For	Speed/Cost	Availability
GPT-5.5	Main GPT-5.5 model/family name; in ChatGPT it usually maps to the capability positioning of GPT-5.5 Thinking	Complex work, code, research, analysis, tool use	Heavier than Instant, but more capable	Plus, Pro, Business, Enterprise
GPT-5.5 Instant	Fast default model, replacing GPT-5.3 Instant	Daily Q&A, writing, summarization, light coding, quick lookup	Fastest and most quota-efficient	Gradual rollout to all ChatGPT users
GPT-5.5 Thinking	Deep reasoning mode	Hard problems, long-context analysis, complex code, research, document-heavy tasks	Slower, but more reliable reasoning	Paid users can select it manually
GPT-5.5 Pro	Heavier research-grade mode	High-risk or high-precision tasks: law, business, education, data science, scientific analysis	Slowest and heaviest, optimized for quality	Pro, Business, Enterprise, Edu

If you only want one rule:

Fast everyday tasks: use GPT-5.5 Instant.
Complex reasoning and code analysis: use GPT-5.5 Thinking.
Especially hard, important, or accuracy-sensitive work: use GPT-5.5 Pro.

What Is GPT-5.5

When people say GPT-5.5 by itself, they usually mean the overall capability of the GPT-5.5 generation, not a single fixed button.

OpenAI positions GPT-5.5 as a stronger model for real work. Its improvements focus on:

agentic coding;
complex code debugging;
research and synthesis;
generating documents, spreadsheets, and presentations;
computer use and cross-tool work;
sustained reasoning and self-checking in long tasks.

In ChatGPT, users do not usually see a vague GPT-5.5 button. They see more specific options: Instant, Thinking, and Pro. So if someone says “I am using GPT-5.5,” it is worth asking: Instant, Thinking, or Pro?

GPT-5.5 Instant: Default, Fast, Everyday Use

GPT-5.5 Instant is the new fast default model. OpenAI’s official announcement says it begins replacing GPT-5.3 Instant as the default ChatGPT model and is available in the API as chat-latest.

It is suitable for:

everyday chat;
quick Q&A;
ordinary writing;
article summarization;
email rewriting;
light code explanation;
simple tables and lists;
tasks that do not need long reasoning.

Instant’s main advantages are speed and default availability. You do not need to manually select a reasoning mode every time, and ordinary questions do not pay a higher latency cost.

It also changes the default tone: OpenAI emphasizes that GPT-5.5 Instant answers more clearly and concisely, with stronger personalization. For ordinary users, that makes it better as the model you leave open all day.

The caveat is that Instant is not the strongest mode. For complex math, long code, architecture design, multi-file analysis, or serious research, it may switch to Thinking automatically, or you may need to select Thinking manually.

GPT-5.5 Thinking: The Main Mode for Complex Tasks

GPT-5.5 Thinking is the reasoning mode better suited to complex tasks.

It fits:

code debugging;
architecture design;
multi-step reasoning;
long-document analysis;
academic material organization;
business scenario planning;
data-analysis explanation;
tasks that require comparison, tradeoffs, and verification.

Thinking spends more time reasoning. The OpenAI Help Center says that when GPT-5.5 Thinking or GPT-5.5 Pro starts reasoning, it may first show a short preamble explaining what it plans to do. Users can also add instructions while the model is still thinking to adjust direction early.

In ChatGPT, when manually choosing Thinking, users can also adjust thinking time. According to the official explanation, Plus and Business users can use Standard and Extended; Pro users also have options such as Light and Heavy.

My interpretation: Thinking is the default choice for serious work. Whenever a task involves multiple steps, long context, or higher accuracy requirements, it is more suitable than Instant.

GPT-5.5 Pro: Research-Grade, Heavier, More Rigorous

GPT-5.5 Pro is the mode for harder problems and higher-precision work.

It fits:

legal material analysis;
business research;
education and curriculum design;
data science;
scientific literature synthesis;
deep review before high-risk decisions;
multi-document, multi-constraint, multi-round verification tasks.

In the GPT-5.5 announcement, OpenAI says early testers found GPT-5.5 Pro to improve over GPT-5.4 Pro in completeness, structure, accuracy, relevance, and usefulness, especially in business, law, education, and data science.

The downside is also clear: Pro is slower and heavier, and it is not meant for every small question. It is more like an expert reviewer or research partner than a daily chat entry point.

Pro also has special tool-support limitations. The OpenAI Help Center says Apps, Memory, Canvas, and image generation are not available in Pro. If your task needs those ChatGPT features, Instant or Thinking may be the better choice.

Tool Support Differences

According to the OpenAI Help Center, GPT-5.5 Instant and GPT-5.5 Thinking support common ChatGPT tools, including:

Web search;
Data analysis;
Image analysis;
File analysis;
Canvas;
Image generation;
Memory;
Custom Instructions.

GPT-5.5 Pro is more focused on research-grade reasoning, but not all ChatGPT tools are available. Pay particular attention:

Apps are unavailable;
Memory is unavailable;
Canvas is unavailable;
image generation is unavailable.

So when choosing a model, do not only ask “which one is smarter.” Also ask which tools you need.

Context Window Differences

The OpenAI Help Center describes ChatGPT context windows roughly as:

Mode	Context Window
GPT-5.5 Instant	Free: 16K; Plus/Business: 32K; Pro/Enterprise: 128K
GPT-5.5 Thinking	Usually 256K when manually selected on paid plans; up to 400K on Pro

This means:

Instant is enough for ordinary chat and short documents;
Thinking is better for multi-file work, multi-round research, and long-codebase analysis;
for especially long, complex, high-precision tasks, Pro users can use a larger context and heavier reasoning.

How to Choose

Everyday Q&A

Use GPT-5.5 Instant.

It is fast, smart enough, and good for quick questions, quick writing, and quick edits.

Writing, Summarizing, Email Editing

Start with GPT-5.5 Instant.

If the article is long, needs structural rewriting, or requires multiple rounds of proofreading, switch to GPT-5.5 Thinking.

Coding and Debugging

Use Instant for simple code explanation.

Use Thinking for multi-file debugging, architecture design, and complex error analysis. For very difficult long-running engineering problems, consider Pro.

Research and Material Analysis

Use Thinking for ordinary material organization.

For law, business, scientific research, and data science tasks that need higher precision, Pro is more suitable.

Tasks Requiring Image Generation, Canvas, or Memory

Prefer Instant or Thinking.

Do not automatically choose Pro, because Pro does not support some ChatGPT tools.

Short Conclusion

GPT-5.5 Instant is the everyday default model: fast, clear, quota-efficient, and suitable for most ordinary tasks.

GPT-5.5 Thinking is the main mode for complex work: code, research, long documents, analysis, and multi-step reasoning.

GPT-5.5 Pro is the high-precision research mode: suitable for harder and more important tasks that need more rigor, but with more limits on speed and tool support.

GPT-5.5 itself is more like the overall name for this generation. In practice, the real choice is whether you select Instant, Thinking, or Pro in ChatGPT.

GPT-5.5 Instant announcement: https://openai.com/index/gpt-5-5-instant/
GPT-5.5 announcement: https://openai.com/index/introducing-gpt-5-5/
GPT-5.5 in ChatGPT Help Center: https://help.openai.com/en/articles/11909943-gpt-53-and-gpt-55-in-chatgpt

How ChatGPT, Claude Code, and Gemini memory mechanisms differ

Thu, 07 May 2026 14:47:17 +0800

“Memory” is becoming increasingly important in AI products. It marks the shift from one-off conversations to long-term collaboration: you do not need to reintroduce your background, repeat your preferences, or ask the model to understand the same project again and again.

But memory does not mean the same thing in every product. ChatGPT, Claude Code, and Gemini all try to help AI remember longer, but their goals, storage locations, transparency, and use cases are very different.

As of May 7, 2026, they can be roughly understood as three types:

ChatGPT is more like personal assistant memory.
Claude Code is more like engineering project memory.
Gemini is more like Google ecosystem context.

ChatGPT: long-term preferences around the person

ChatGPT memory is mainly designed for personal collaboration. It cares about who you are, what you prefer, and what you work on over time.

OpenAI currently separates ChatGPT memory into saved memories and chat history.

saved memories are important pieces of information ChatGPT stores, such as your name, preferences, goals, common tech stack, and writing habits. You can explicitly ask it to remember something, and it may also save information from conversation when it thinks it will be useful later.

chat history lets ChatGPT reference past conversations when answering. It does not mean every chat becomes a permanent memory. Instead, ChatGPT can search past conversations for relevant context when needed.

So ChatGPT’s core logic is: understand the same user across sessions.

Typical examples include:

“Keep code examples concise for me.”
“I mainly use Python and TypeScript.”
“I am writing a Hugo blog about AI tools.”
“I prefer conclusions first, then details.”

These memories are not bound to one project. They follow the account and the user’s working habits.

Memory Sources: making personalization more visible

OpenAI emphasized Memory sources in its May 2026 update.

The purpose is not to add another type of memory, but to show users what sources ChatGPT referenced when personalizing a response. According to OpenAI help documents, Memory Sources may show:

Past chats.
Saved memories.
Custom instructions.
Files in the file library.
Emails from connected Gmail.

Files and Gmail visibility depend on plan, region, and connection status. OpenAI also states that Memory sources may not show every factor that influenced a response, but they help users understand and manage personalization.

This matters. The more AI can “remember you,” the more users need to know what it used to answer. Otherwise personalization becomes a black box: it seems to know you, but you do not know why.

ChatGPT’s advantage is cross-session, cross-topic understanding of personal preferences. The risk is that memories can become outdated, or users may forget an old memory is still affecting answers. It is worth periodically cleaning saved memories and old chats.

Claude Code: around codebases and engineering rules

Claude Code memory is more engineering-oriented. It cares less about a user’s everyday preferences and more about how this codebase should be changed.

Claude Code has two memory mechanisms that are easy to confuse:

Explicit project memory: CLAUDE.md.
Automatic project memory: Auto Memory.

CLAUDE.md is the most basic and stable project memory file. It can live at the project root or inside subdirectories. Claude Code reads these files as project instructions and operating rules.

Good content for CLAUDE.md includes:

Common build, test, and lint commands.
Code style and naming rules.
Project architecture notes.
Module boundaries and risky areas.
Team conventions and commit workflow.

If CLAUDE.md is stored in the repository, it can be committed to Git and shared as a team agent guide. This is completely different from ChatGPT’s cloud-based personal memory.

Claude Code Auto Memory: accumulating project experience

Claude Code also has Auto Memory. Its goal is to let Claude automatically accumulate project knowledge across sessions without requiring users to write every note manually.

According to Claude Code documentation, Auto Memory lets Claude save notes while working, such as build commands, debugging discoveries, architecture notes, code style preferences, and workflow habits. It does not save every session, but judges what may be useful later.

One common misconception is that Auto Memory writes by default to .claude/memory.md in the project root. Official documentation says each project has its own memory directory under the user’s home directory, with a path like:

`1`	`~/.claude/projects/<project>/memory/`

MEMORY.md loads the first 200 lines or 25KB at the start of each conversation, while detailed content may be split into other topic files. Auto Memory files are local Markdown files, and users can view, edit, or delete them through /memory.

This makes Claude Code memory more like a local project knowledge base. It is closer to the codebase than ChatGPT’s personal memory, and more dynamic than a plain CLAUDE.md.

But Auto Memory is local to the machine. It does not naturally follow the repository to other machines or cloud environments. For team-shared stable rules, put them in the repository’s CLAUDE.md.

Gemini: around Google ecosystem context

Gemini’s memory logic is different again.

Gemini also supports saved information and past-chat references. Google help documents say users can save information about life, work, or preferences, and Gemini can reference past chats before answering. When it uses this information, the response may show sources such as Your saved info or Previous chats.

But Gemini’s differentiation is not only “saving a few preferences.” It is Google ecosystem integration.

With user authorization and feature availability, Gemini can access context from connected Google apps such as Gmail, Google Drive, Docs, and Sheets. Its advantage is not making users teach it every item manually, but turning existing Google account data into searchable work context.

A typical difference:

ChatGPT remembers: “I have been repairing an LTO tape drive recently.”
Gemini may find the purchase confirmation email in Gmail or read repair notes from Drive.

This does not mean Gemini can unconditionally read all Google data. It depends on account type, region, permissions, connected apps, Keep Activity settings, and product availability. Enterprise and school accounts may also be controlled by Google Workspace administrators.

More accurately, Gemini memory is a combination of saved info, past chats, and connected Google ecosystem data.

Core differences

Dimension	ChatGPT	Claude Code	Gemini
Core object	Person and preferences	Project and codebase	Google account and ecosystem data
Typical memory	Preferences, background, long-term goals	Architecture, commands, conventions, debugging experience	Saved info, past chats, Gmail/Drive/Docs context
Storage form	Memory and chat context in OpenAI account	`CLAUDE.md`, `MEMORY.md`, local Markdown files	Google account activity, saved info, connected app data
Transparency	Memory sources show part of the source	Markdown files can be opened and edited	Managed through source prompts, Gemini Apps Activity, and Google settings
Cross-project ability	Strong, follows user account	Weak, mainly follows project or local project memory	Strong, depends on Google data and permissions
Team sharing	Not suitable for direct sharing	`CLAUDE.md` can be shared through Git	Mainly depends on Workspace and permissions
Best for	Personal preferences and long-term assistant behavior	Long-term coding projects and agent collaboration	Google Workspace retrieval and cross-tool work

How to choose

If you want AI to remember who you are, what style you prefer, and how you usually work, ChatGPT memory is more suitable.

It is good for saving personal preferences such as writing style, tech stack, answer format, professional background, and long-term project direction. Its focus is reducing self-introduction cost so each new conversation can start faster.

If you want AI to remember how a codebase should be changed, which commands work, and which traps to avoid, Claude Code is more suitable.

Put stable rules into CLAUDE.md for team sharing. Let Auto Memory assist with dynamic experience. Important decisions should still be organized into documentation or CLAUDE.md, not left only in local automatic memory.

If most of your materials live in Gmail, Drive, Docs, and Sheets, Gemini’s ecosystem context has an advantage.

It is useful for finding old emails, organizing Drive documents, and connecting calendar and office materials. The key to using Gemini is not repeatedly reminding it in chat, but making sure the relevant app connections, permissions, and activity settings are correct.

A practical division of labor

You can divide them like this:

ChatGPT remembers general personal preferences.
Claude Code remembers engineering knowledge for a repository.
Gemini retrieves materials from your Google ecosystem.

In other words, ChatGPT is like a personal secretary, Claude Code is like a senior engineer inside the project, and Gemini is like an indexer for your Google account.

There is no absolute winner. They have different goals.

The biggest mistake is mixing them together. Personal preferences do not always belong in project memory; project architecture does not always belong in cloud personal memory; and Google ecosystem retrieval does not mean the model has truly understood you long-term.

Short Take

The next stage of AI memory is not simply “remember more.” Memory needs layers, visibility, and control.

ChatGPT focuses on cross-session personalization. Claude Code focuses on code project continuity. Gemini focuses on Google ecosystem context. Good long-term AI collaboration does not put all information into one black box; it keeps different kinds of memory in the right places.

Put personal preferences in personal memory, engineering rules in the codebase, and historical materials in the original document and email systems. AI’s job is to call the right context when needed, not mix everything into one pile.

What ChatGPT Release Notes reveal about OpenAI's product rhythm

Thu, 07 May 2026 14:31:22 +0800

OpenAI’s ChatGPT Release Notes page is a direct way to observe the product rhythm of ChatGPT. The page continuously records changes to ChatGPT models, features, account security, app integrations, and client experience.

As of May 7, 2026, the page shows the latest update as “yesterday,” with the newest entries concentrated on May 5, 2026. They may look like ordinary updates, but together they show where ChatGPT is heading: a more reliable default model, more controllable memory, deeper office workflows, and stronger account security.

Latest focus one: memory sources become visible

The first May 5 update is about ChatGPT memory improvements.

OpenAI says Plus and Pro users will gradually receive more personalized and continuous responses. ChatGPT can better use past chats, saved memories, available files, and connected Gmail context to provide more tailored suggestions, recommendations, and next steps.

The value of this capability becomes clear in long-term use. If a user is working on a project, writing a series of posts, following a set of emails, or repeatedly handling similar work, the most annoying part is re-explaining the background every time. Stronger memory is meant to reduce that repetition.

But the stronger memory becomes, the more users need to know what context the model used. That is why OpenAI is introducing memory sources. Users can see relevant saved memories, past chats, custom instructions, and, in certain cases, referenced files and Gmail messages under a response.

If information is outdated, inaccurate, or no longer relevant, users can correct it, delete it, or mark it as not relevant.

Personalization is not just “knowing you better”

When people talk about AI personalization, they often focus only on whether the model understands them better. But sustainable personalization must answer three questions:

Can users see what the model referenced?
Can users edit or delete that information?
Can users turn memory off when they do not need it?

The release notes clearly say memory sources are only shown inside the user’s own account experience, and are not exposed when a chat is shared. Users can also delete chats, use temporary chats, turn memory off, disconnect apps, and manage whether content is used to improve models.

This shows OpenAI is not only adding personalization capability. It is also adding control surfaces. For a long-term assistant, that step matters.

Latest focus two: GPT-5.5 Instant becomes the default model

On the same day, OpenAI also began rolling out GPT-5.5 Instant as ChatGPT’s new default model, replacing GPT-5.3 Instant for all users.

The release notes describe the model update in practical terms: more accurate, clearer, more concise, better at image understanding and STEM questions, and better at deciding when to use web search.

Default model updates have a large impact. Most users do not switch models every day. The ChatGPT quality they feel is the quality of the default model. If the default model has fewer hallucinations, less filler, and fewer pointless follow-up questions, the actual experience improves noticeably.

OpenAI also says GPT-5.5 Instant reduces overformatting and unnecessary decorative content. This may seem small, but it is close to everyday use. Many users do not need a fully structured essay. They need an accurate, direct, actionable answer.

Paid users can continue using GPT-5.3 Instant for three months before it is retired.

Latest focus three: ChatGPT enters Excel and Google Sheets

The third May 5 update is the global launch of ChatGPT for Excel and Google Sheets.

This feature puts ChatGPT into the sidebar of Microsoft Excel and Google Sheets, allowing users to build, update, and understand data inside spreadsheets. Official scenarios include trackers, budgets, formulas, multi-tab files, scenario work, and spreadsheet cleanup.

This shows ChatGPT is not staying inside a chat window. It is moving into places where users already work.

For office users, spreadsheets are a very common work surface. Many companies, teams, and individuals keep business data not in complex data platforms, but in piles of Excel and Google Sheets files. If ChatGPT can understand data, write formulas, organize multiple sheets, and explain results next to the spreadsheet, the barrier is much lower than copying everything into a chat window.

OpenAI also reminds users to review outputs before relying on formulas or analysis. That is realistic: AI can speed up spreadsheet work, but it cannot take full responsibility for financial, operational, or business judgments.

Late April groundwork: security and model selection

Looking back, the April 30 Advanced Account Security update is also worth attention.

It is an optional security setting for personal ChatGPT accounts. When enabled, the account uses stronger sign-in methods such as passkeys or compatible security keys, and disables weaker paths such as password sign-in, email or SMS sign-in codes, and email-based account recovery. It also includes recovery keys, shorter active sessions, login notifications, and session management controls.

This shows ChatGPT accounts are becoming more important. As files, memories, app connections, email, spreadsheets, and work projects enter ChatGPT, account security is no longer just a login issue. It relates to the user’s long-term work context.

On April 28, OpenAI also moved model selection closer to the composer and put Thinking and Pro model thinking effort controls into the model picker. This is a typical product detail change: as the number of models grows, users need an easier way to choose the right tool before sending a message.

Another late-April direction: faster ordinary answers

On April 22, ChatGPT introduced Fast answers.

This feature is for common information queries. When a question does not need personalization and ChatGPT has a high-confidence answer, it can return results faster. Fast answers do not reference past chats or memory, and users can turn them off in personalization settings.

This may look opposite to stronger memory, but it is the same product logic: different questions need different handling.

Some questions need long-term context, such as “help me continue planning that project from last week.” Others only need a fast and accurate answer, such as “what are the Seven Wonders of the World?” The former needs memory and context; the latter needs speed and clarity. ChatGPT is separating these paths.

Product rhythm is changing

These release notes show that ChatGPT updates are no longer only model releases.

Updates now cover:

Default model quality.
Memory and personalization.
App connections and office add-ins.
Account security.
Model selection and interaction entry points.
Fast answers and mobile experience.

This means ChatGPT is moving from a single AI chat product into a more complete work platform. Model capability is still important, but product experience, context management, tool entry points, account security, and third-party integrations now matter just as much.

Short Take

The most interesting part of these ChatGPT Release Notes is not one specific update, but the direction they form together.

OpenAI is making ChatGPT faster, more context-aware, more present in office workflows, and also more controllable and secure. GPT-5.5 Instant improves default answer quality, memory sources explain personalization, Excel and Google Sheets bring ChatGPT into real work files, and Advanced Account Security protects heavier account usage.

Going forward, ChatGPT’s competitiveness will not depend only on model parameters. It will also depend on whether OpenAI can organize these updates into a stable, clear product experience that users are willing to trust with long-term context.

ChatGPT Release Notes update: memory sources, GPT-5.5 Instant, and spreadsheet add-ins

Thu, 07 May 2026 14:30:15 +0800

OpenAI’s ChatGPT Release Notes page was updated in early May 2026. The latest batch focuses on three things: memory sources and stronger personalization in ChatGPT, GPT-5.5 Instant becoming the new default model, and the global launch of ChatGPT for Excel and Google Sheets.

Taken together, these updates point in a clear direction: ChatGPT is continuing to move from a chat entry point toward a more continuous, more personalized, and more office-native work assistant.

Memory sources make personalization more transparent

The most important update is memory sources.

OpenAI says ChatGPT Plus and Pro users are beginning to receive stronger memory improvements. ChatGPT can better pull relevant context from past chats, saved memories, available files, and connected Gmail apps to provide more tailored ideas, recommendations, and next steps.

This means users do not have to repeatedly explain project background, preferences, habits, or existing materials in every new conversation. For long-term writing, project planning, research organization, learning, and teamwork, continuity becomes stronger.

But the stronger personalization becomes, the more important transparency becomes. That is why OpenAI is introducing memory sources, so users can see what information helped personalize a response. Users can click the Sources icon under a response to view relevant saved memories, past chats, and custom instructions. Plus and Pro users may also see files from their library and referenced emails from connected Gmail.

If some information is outdated, irrelevant, or wrong, users can correct it, delete it, or mark it as not relevant.

Memory control is still the key

OpenAI also notes that memory sources may not show every factor that shaped a response, and that it will keep improving the view.

That matters. Memory sources are not a complete “model thinking log.” They are a product interface for understanding personalized context. They improve visibility, but cannot fully expose every factor that influenced an answer.

For privacy and control, OpenAI says memory sources only appear inside the user’s own account experience. If a user shares a chat, the sources do not appear in the shared chat. Users can also delete chats, use temporary chats that do not use or update memory and do not appear in history, turn off memory, disconnect apps at any time, and manage whether their content is used to improve models.

This shows ChatGPT personalization is following a clearer path: make the assistant more aware of the user, while also giving the user ways to see and manage why it answered that way.

GPT-5.5 Instant becomes the default model

The release notes also confirm that GPT-5.5 Instant is rolling out as the new default ChatGPT model, replacing GPT-5.3 Instant for all users.

The default model update improves several areas:

Accuracy.
Clarity and concision.
Image understanding.
STEM answers.
Deciding when to use web search.

OpenAI emphasizes that GPT-5.5 Instant is more factually reliable, especially for prompts where accuracy matters. It also gives tighter and more direct answers, reduces unnecessary follow-up questions, and lowers clutter from overformatting and decorative content.

For users, this may not be as visible as a new feature button, but it changes the feel of opening ChatGPT every day: fewer detours, less verbosity, and less formatting piled onto simple questions.

Personalization and the default model now work together

For Plus and Pro users on the web, GPT-5.5 Instant can also use context from past chats, files, and connected Gmail more effectively.

This is part of the same product direction as memory sources. The model is not only “smarter.” It should also know, when appropriate, what you worked on before, what you care about, and what materials you already provided. When continuing a project, writing a plan, organizing email information, or making suggestions based on past preferences, ChatGPT can ask fewer repeated questions.

Paid users can continue using GPT-5.3 Instant for three months through model configuration settings before it is retired.

ChatGPT for Excel and Google Sheets

Another important update is the global launch of ChatGPT for Excel and Google Sheets.

It brings ChatGPT into a sidebar inside Microsoft Excel and Google Sheets, so users can build, update, and understand data in place. OpenAI mentions use cases including:

Trackers.
Budgets.
Formulas.
Multi-tab files.
Scenario work.
Spreadsheet cleanup.

Where available, it also supports Skills and apps.

The meaning is straightforward: a lot of office data does not live in a specialized BI system. It lives in Excel and Google Sheets. Putting ChatGPT into the spreadsheet sidebar is more natural than asking users to copy and paste into a chat window, and makes it easier to enter real workflows.

Usage limits and installation

The release notes say Free and Go plans include limited usage, while Plus and Pro use the same agentic usage limits as Codex. Users can buy additional credits if they need to go beyond plan limits.

Installation is also direct: install ChatGPT for Excel from Microsoft Marketplace or ChatGPT from Google Workspace Marketplace, then sign in with an eligible ChatGPT account.

OpenAI also reminds users to review outputs before relying on formulas or analysis. That point is important. AI can speed up spreadsheet work, but formulas, budgets, financial work, and business analysis still need human review.

Recent update pattern

Looking at the release notes from late April to early May, ChatGPT’s direction is clearer.

On April 30, OpenAI introduced Advanced Account Security for personal ChatGPT accounts, adding stronger sign-in requirements and account protections, including passkeys, security keys, recovery keys, shorter sessions, and login notifications.

On April 28, model selection moved closer to the composer, making it easier to choose a model before sending a message. Thinking effort controls for Thinking and Pro models were also moved into the model picker.

On April 22, ChatGPT introduced Fast answers for common information queries that do not require personalization and where the model has a high-confidence answer. Fast answers do not reference past chats or memory, and users can turn them off in personalization settings.

These updates all serve the same goal: make ChatGPT better for frequent everyday use. It should be fast when speed matters, personalized when context matters, and provide security and visibility controls when needed.

Short Take

The point of this ChatGPT Release Notes update is not one single feature. It is the continued shaping of the product.

GPT-5.5 Instant improves the default answer quality. Memory sources make personalization more visible. Excel and Google Sheets add-ins put ChatGPT inside office spreadsheets. Advanced Account Security and model picker changes strengthen account protection and interaction design.

ChatGPT is becoming a longer-term work layer. It remembers more context, enters more tools, and handles more daily tasks. The next questions are whether personalization transparency is clear enough, whether office add-ins remain stable in real complex spreadsheets, and whether users can keep a healthy balance between convenience and control.

GPT-5.5 Instant launches: ChatGPT's default model gets more accurate, shorter, and more personal

Thu, 07 May 2026 14:28:40 +0800

OpenAI released GPT-5.5 Instant on May 5, 2026 and began rolling it out as the default model for all ChatGPT users.

The keywords in this update are not “bigger” or “flashier.” They are closer to everyday use: more accurate answers, clearer and shorter responses, a more natural tone, and better use of context users have already shared. For ChatGPT, changes to the default model matter especially because they affect the experience most people actually use every day.

Why the default model matters

Instant is ChatGPT’s daily driver model. Many users do not manually switch models or study the differences between them. Their experience of ChatGPT is the quality of the default model.

So GPT-5.5 Instant is not just another model name. It moves the base experience forward. OpenAI says the update makes everyday interactions more useful and smoother: stronger answers across topics, tighter conversations, and better use of existing context when appropriate.

This kind of improvement is less dramatic than a large multimodal launch, but for hundreds of millions of users, a default model that makes fewer mistakes, writes less unnecessarily, and asks fewer pointless follow-up questions is a major product change.

Fewer hallucinations and more reliable answers

OpenAI puts accuracy first.

In internal evaluations, OpenAI says GPT-5.5 Instant produced 52.5% fewer hallucinated claims than GPT-5.3 Instant on high-stakes prompts covering medicine, law, and finance. On especially difficult conversations users had flagged for factual errors, inaccurate claims were reduced by 37.3%.

These numbers matter. They show OpenAI is not only trying to make the model more fluent, but also continuing to reduce factual errors. In areas such as medicine, law, and finance, a model cannot merely sound smooth. It has to be more cautious and invent less.

This does not mean users should treat ChatGPT as a replacement for professional advice. A more accurate model still needs verification, sources, and human judgment in high-risk contexts. But as a product experience, better factual reliability in the default model reduces many everyday risks.

Stronger everyday task performance

GPT-5.5 Instant also improves across daily tasks.

OpenAI mentions better analysis of photo and image uploads, stronger STEM answers, and better judgment about when to use web search. The last point is important. Many users do not care whether the model internally calls a tool. They care whether the answer is fresh, accurate, and clearly explained.

If the model can better decide which questions need web search and which can be answered directly, users do not have to keep saying “look it up.” ChatGPT feels more like a proactive assistant than a chat box waiting for explicit instructions.

OpenAI’s math example also points in this direction. GPT-5.5 Instant initially accepts an incorrect solution, but then checks the result, finds the algebra error, and solves the corrected equation. The important point is not that it never makes a mistake, but that it has a better chance of catching and repairing one during the reasoning process.

Shorter answers, not less substance

OpenAI also emphasizes that GPT-5.5 Instant gives tighter, more direct answers while keeping useful content and ChatGPT’s friendly tone.

This matters for a default model. AI response fatigue often comes not from too little information, but from too much structure, too much setup, and too much formatting. A simple question can become five headings and a dozen caveats, which feels unnatural.

GPT-5.5 Instant aims to reduce unnecessary verbosity and overformatting, ask fewer unneeded follow-up questions, and avoid decorative clutter. For daily office work, writing advice, life questions, and quick explanations, these changes often matter more than one benchmark score.

Shorter does not mean shallower. A good default model should judge whether the user needs one practical sentence, an explanation, or a full plan. GPT-5.5 Instant is moving toward steadier judgment on that balance.

Personalization keeps improving

Another main thread is personalization.

OpenAI says Instant is now better at using context from past chats, files, and connected Gmail, when available, to make responses more relevant. It decides when extra personalization can improve an answer and searches past conversations faster, so users do not need to repeat background as often.

This is valuable for long-term ChatGPT users. When planning, writing, selecting tools, organizing projects, or continuing a workflow, users may already have provided preferences, constraints, and context in earlier chats. If the model can pick up naturally, it reduces repeated explanation.

But personalization has to come with transparency and control. Otherwise users do not know why the model suddenly references a preference or which memories are shaping an answer.

Memory sources make personalization more visible

OpenAI is also introducing memory sources across all ChatGPT models.

The feature lets users see which context was used to personalize a response, such as saved memories or past chats. If something is outdated, inaccurate, or no longer wanted, users can delete or correct it.

OpenAI also says memory sources are not shown to others when users share a chat. Users can delete chats they do not want cited, edit saved memories in settings, or use temporary chats that do not use or update memory.

This matters. The more personalized an AI assistant becomes, the more it needs to explain “what I used to answer you.” Memory sources may not show every factor, but they move part of personalization out of the black box.

Availability

GPT-5.5 Instant is rolling out from the announcement day to all ChatGPT users, replacing GPT-5.3 Instant as the default model. In the API, it corresponds to chat-latest.

Paid users can continue using GPT-5.3 Instant for three months through model configuration settings before it is retired.

Enhanced personalization from past chats, files, and connected Gmail is rolling out first to Plus and Pro users on the web, with mobile support coming later. OpenAI plans to expand it to Free, Go, Business, and Enterprise in the following weeks. Memory sources are rolling out on the web for ChatGPT consumer plans and will come to mobile later. Availability of specific personalization sources may vary by region.

Short Take

GPT-5.5 Instant is an upgrade to the default ChatGPT experience.

It is not only about stronger model capability. It adjusts accuracy, answer density, tone, context use, and personalization transparency together. For ordinary users, the most direct change should be: less fluff, fewer factual errors, and better continuity with your background.

For OpenAI, this is another step in the evolution of the default assistant. ChatGPT is becoming less of a tool that starts from zero every time and more of a long-term assistant that can remember preferences, understand context, know when to search, and let users manage those memory sources.

Why ChatGPT Says 'This Chat Was Flagged for Possible Cybersecurity Risk' and What to Do

Wed, 06 May 2026 00:17:00 +0800

When using ChatGPT or similar large language models, you may occasionally see a notice: “This chat was flagged for possible cybersecurity risk.” This means the platform’s automated safety system has detected that the conversation may violate its usage policies.

Below is an analysis of what triggers this notice, what it actually affects, and how to respond.

Why a Chat May Be Flagged

Sensitive Input

The conversation may contain content that could be interpreted as harmful, such as:

Requests to generate malicious code or scripts.
Analysis or exploitation of network vulnerabilities.
Questions related to illegal activities.
Instructions for bypassing security restrictions.

False Positive

Even when the intent is legitimate code analysis or technical research, the system may still misread cybersecurity-related terminology as a potential attack attempt. AI moderation models tend to be sensitive to keywords, and the line between technical discussion and offensive behavior is not always precise.

Platform Review Mechanism

The system automatically scans conversation content for risk assessment. In newer versions, such as the April 2026 update, this kind of notice appears more often, suggesting that the platform may have introduced a stricter external review process.

What Happens After the Notice Appears

The current chat may be stopped: The platform may restrict or halt generation in the current conversation.
Risk records: Repeated risk-control triggers may be recorded, and accumulating too many of them could affect account status.
A trend toward higher sensitivity: Review mechanisms are becoming stricter, making technical discussions more likely to hit boundary cases.

How to Handle It

Start a New Chat

The most direct approach is to abandon the current conversation and click “New Chat” to start fresh. The previous context will no longer carry over, so the same moderation trigger usually will not repeat.

Adjust Your Prompt

Review what you entered earlier, remove terms that may be judged sensitive, and ask in a more neutral way. For example, change “how to bypass a certain restriction” to “what is the principle behind this restriction,” or change “how to write an attack script” to “what mechanisms do scripts of this type typically use.”

Do Not Try to Bypass It

Avoid using prompt injection or similar methods to force the AI to answer questions it has refused. This increases the risk of account penalties and often backfires.

Check the Nature of Your Activity

If you were not doing anything high-risk, such as analyzing phishing links or writing malware, the issue is most likely the AI misreading technical concepts. In that case, you can consider reporting it to the platform, though the short-term effect is usually limited.

Protect Privacy

Do not submit content containing sensitive personal information or trade secrets for AI analysis. Even if it does not trigger risk control, there is still a risk of data leakage.

Prevention Tips

Use neutral wording as much as possible when discussing technical topics.
Avoid concentrating a large number of sensitive topics in a single conversation.
Regularly clean up unnecessary chat history.
Avoid frequently testing moderation boundaries on important accounts.

Summary

“This chat was flagged for possible cybersecurity risk” is usually triggered by automated moderation and does not necessarily mean the account has violated rules. The priority is straightforward: start a new chat > adjust the wording > do not fight the system head-on. In daily use, paying attention to wording boundaries can prevent most triggers.

Why ChatGPT and Codex Ask for Phone Verification at Login

Wed, 06 May 2026 00:07:43 +0800

Recently, some users have run into a situation where their ChatGPT account has already been registered, but the system asks for phone verification again when logging into ChatGPT or Codex. This is especially confusing with Codex: the account was fine for signup, so why ask for a phone number when logging into the tool?

This is usually related to account risk controls, abuse of free quotas, network environment, and account security policies. Below is a summary of common causes and how to approach them.

Why phone verification is required

The most direct reason is tighter risk controls.

Once Codex opens up to users, its free quota attracts not only legitimate users but also mass registration and quota-farming. When registration bots create accounts in bulk and drain free quotas, platforms naturally tighten verification policies.

From the user’s side, the result looks like: an account that previously only needed email or third-party login is suddenly asked for a phone number when accessing ChatGPT or Codex.

This does not necessarily mean your account has a problem. It may simply be that the login environment looks risky. For example:

You are using a network exit shared by many users.
The current IP range has been heavily used for registrations or suspicious logins.
The account is brand new but immediately accesses a resource-intensive tool.
The device, region, or network changes frequently.
Free-tier usage patterns resemble those of bulk accounts.

If you recently experienced account anomalies, login restrictions, or false bans, your network environment may have been flagged along with others using the same exit. Shared nodes used by many people carry inherently higher risk.

Why Codex triggers it more often

Codex differs from normal chat—it is closer to a development tool, potentially involves heavier resource usage, and is more attractive for bulk accounts draining free quotas.

So it is not unusual for the same account to look fine on the regular ChatGPT page but hit phone verification in the Codex login flow. Think of it as different product entry points applying different risk judgments.

For normal users, this kind of verification is usually not targeting individuals—it is aimed at curbing mass registration and quota abuse. But if your network environment is not clean, you can get caught in the crossfire.

Approach 1: Upgrade to Plus

If you use ChatGPT or Codex long-term, the simplest fix is upgrading to ChatGPT Plus.

In practice, paid accounts are generally less likely to trigger quota-abuse risk controls than free accounts. A Plus account is also better suited for stable use of Codex, advanced ChatGPT models, and other high-frequency features.

That said, upgrading to Plus does not mean you will never see another verification prompt. If it still asks for a phone number after upgrading, the common cause is still the network environment.

At this point, check:

Whether you are on a shared network used by many people.
Whether your exit IP keeps changing.
Whether you have been using low-quality proxies or public nodes long-term.
Whether many OpenAI accounts are active on the same network.

If possible, switching to a more stable and cleaner network environment before logging in is usually more effective than repeated retries.

Approach 2: Check your network environment

Many login verification problems that look like account issues are fundamentally network issues.

If a particular exit IP is shared by many users, or has been used for bulk registration, suspicious logins, or automated requests, it is more likely to be flagged. When that happens, even a legitimate user may be asked for additional verification when logging into ChatGPT or Codex.

Check from these angles:

Switch to a more stable network environment.
Avoid public, cheap, high-user-count shared nodes.
Minimize frequent region switches over short periods.
Do not rapidly switch between multiple accounts in the same browser.
If using a proxy, prefer lines with more stable quality and less abuse history.

You can also use third-party network quality detection tools to check the risk profile of your current IP, but such results are only a reference and do not fully represent OpenAI’s internal assessment.

Approach 3: Complete the phone verification as required

If the system explicitly asks for phone verification, the safest approach is to complete it as requested.

It is advisable to use a phone number you can keep long-term. That way, if your account later needs security verification, recovery, or alerts, you can handle them.

Do not bind important accounts to numbers of unknown origin, shared numbers, or numbers you cannot keep. It may get you through the short term, but in the long run it creates risks for account recovery, security audits, and secondary verification.

If you are using a work account, team account, or a development account you rely on heavily, you should especially avoid temporary numbers you cannot control. Account security matters more than short-term convenience.

What to watch for when upgrading to Plus

If you plan to upgrade to Plus, confirm a few things first:

The account itself can log in normally.
The current network environment is stable and not frequently hopping regions.
The payment method is reliable—do not use third-party proxy payments of unknown origin.
After upgrading, keep the payment record and account email safe.
Do not share the account with multiple people.

Many account problems are not caused by Plus itself, but by the network, payment, and sharing habits around the upgrade. An account that is shared by many, logged into from different locations, and frequently environment-switched can trigger security verification even if it is paid.

If you are only trying it out occasionally, a free account works fine. But if you already use Codex as a daily development tool, Plus is better suited for long-term use.

Quota farming is not recommended

The free quota for tools like Codex is meant to let regular users try and experience the product. If large numbers of bulk accounts continuously drain that quota, the platform has no choice but to keep tightening risk controls.

The result is that normal users get affected too: more login friction, more verification steps, more false bans, and higher account usage costs.

For people genuinely using Codex for coding, modifying projects, and running engineering tasks, it is more worthwhile to clean up the account and network environment than to spend time dodging risk controls. In the long run, that is easier than constantly registering new accounts, switching nodes, and dealing with verification issues.

Summary

When ChatGPT or Codex asks for phone verification at login, it is usually tied to account risk controls, free-quota abuse, and network environment risk. It does not necessarily mean the account violated any rules, but it does indicate that the current login environment or account state triggered a higher verification level.

The order of action is straightforward:

First check the network environment; avoid shared high-risk exits.
If you are a long-term user, consider upgrading to Plus.
If the system requires phone verification, use a number you can control long-term.
Avoid bulk registration, account sharing, and frequent login-environment switching.

The core of stable AI tool usage is not about bypassing verification forever—it is about keeping the account, network, and usage patterns as normal as possible. That reduces login friction and lowers the chance of collateral damage later.

OpenAI Introduces Advanced Account Security: A Stronger Layer of Protection for ChatGPT and Codex Accounts

Fri, 01 May 2026 06:15:29 +0800

OpenAI introduced Advanced Account Security on April 30, 2026, as an optional high-security setting for ChatGPT accounts.

It is mainly designed for two groups of users. One includes journalists, elected officials, political dissidents, researchers, and others who are more likely to face targeted attacks. The other includes security-conscious users who want stronger protection for their ChatGPT and Codex accounts.

Once enabled, this feature protects not only ChatGPT, but also Codex when accessed through the same login account.

Why ChatGPT accounts need a higher level of security

Many people now use ChatGPT for increasingly private and high-stakes work.

A ChatGPT account may contain:

Personal questions and long-running conversations
Work documents and project context
Connected tools and workflows
Code and development tasks in Codex
Enterprise, research, or security-related materials

If an account is taken over, the loss is not limited to leaked chat history. An attacker may also access connected tools, view sensitive context, or interfere with work in progress.

So what OpenAI is introducing is not just another login option. It is a stricter set of account protection measures.

What Advanced Account Security includes

OpenAI places this capability in the Security settings of ChatGPT accounts on the web, where users can opt in.

After it is enabled, it strengthens account security in several ways.

First, sign-in becomes stronger.

Advanced Account Security requires passkeys or physical security keys and disables password-based login. The goal is to make phishing-resistant sign-in the default for people who need it most.

Second, account recovery becomes stricter.

Traditional account recovery often relies on email or SMS. If an attacker controls a user’s email account or phone number, they may use that access to reset the account. To reduce this risk, Advanced Account Security disables email and SMS recovery and uses stronger recovery methods instead, such as backup passkeys, security keys, and recovery keys.

There is an important tradeoff here: after enabling the feature, account recovery depends much more on the user keeping those recovery methods safe. OpenAI explicitly states that if users enrolled in this feature lose their recovery methods, OpenAI Support will not be able to help recover the account.

Third, sessions become shorter and easier to manage.

OpenAI shortens sign-in sessions to reduce the exposure window if a device or active session is compromised. Users also receive login alerts and can review and manage active sessions across their devices.

Fourth, training exclusion becomes automatic.

For people handling sensitive information, preventing conversations from being used for model training is an important privacy setting. When Advanced Account Security is enabled, that preference takes effect automatically: conversations from those accounts will not be used to train OpenAI models.

Working with Yubico to promote physical security keys

OpenAI also announced a partnership with Yubico to offer users a customized security key bundle.

It includes:

YubiKey C Nano: designed to stay plugged into a laptop, reducing daily sign-in friction
YubiKey C NFC: designed as a backup and for use across laptops and mobile devices

OpenAI says users can also use other FIDO-compliant physical security keys or software passkeys.

This means Advanced Account Security is not tied to one specific piece of hardware. It is designed around phishing-resistant authentication methods.

Trusted Access for Cyber users will be required to enable it

OpenAI also says that individual members of Trusted Access for Cyber who access its more capable and permissive cybersecurity models will be required to enable Advanced Account Security starting June 1, 2026.

Organizations can meet the requirement in another way: by attesting that their single sign-on workflow already uses phishing-resistant authentication.

This arrangement makes sense. The more powerful the model capability, the stronger the account protection needs to be. This is especially true for cybersecurity research, vulnerability analysis, and red-teaming scenarios, where the account itself becomes a high-value target.

Who should consider enabling it

This feature is not necessarily for everyone.

If you only use ChatGPT for ordinary conversations and do not want to deal with the complexity of stricter recovery, it may be reasonable to wait.

But the following users should seriously consider it:

People who often handle sensitive work materials in ChatGPT
People who use Codex with private code repositories
Journalists, public affairs professionals, researchers, executives, and other high-risk users
Cybersecurity professionals
People already comfortable with passkeys or physical security keys
People especially concerned about phishing, SIM swapping, or email account takeover

Before enabling it, it is best to prepare backup passkeys, security keys, and recovery keys, and make sure they are stored properly. Otherwise, security improves, but account recovery becomes much harder.

What this means for AI products

Advanced Account Security is not a model capability update, but it reflects the fact that AI products are entering higher-risk usage.

As ChatGPT and Codex begin to carry workflows, code, documents, enterprise connectors, and long-term context, the account is no longer just a way to “log in to a chat tool.” It becomes the key to an AI work environment.

The more these products resemble personal workspaces, the more important account security, recovery mechanisms, session management, and training-data controls become.

OpenAI’s decision to put passkeys, physical security keys, recovery restrictions, session management, and training exclusion into one setting is the right direction. It gives high-risk users a clear place to raise account protection to a level more suitable for sensitive work.

Conclusion

Advanced Account Security can be understood as a high-security mode for ChatGPT and Codex.

It reduces the risk of account takeover through stronger sign-in, stricter recovery, shorter sessions, login alerts, and automatic training exclusion. The tradeoff is that users must manage their own recovery methods more carefully, because traditional email and SMS recovery are no longer available after enabling it, and OpenAI Support cannot serve as a fallback.

If you already use ChatGPT or Codex for important work, especially involving private code, sensitive documents, or a high-risk identity, this feature is worth paying attention to.

Reference link:

Introducing Advanced Account Security - OpenAI

How to Split Tasks Between ChatGPT, Claude, and Gemini: Choosing for Daily Use, Coding, and Special Capabilities

Sat, 25 Apr 2026 10:51:19 +0800

Many people no longer rely on just one model. Instead, they switch back and forth between ChatGPT, Claude, and Gemini. That makes the question much more practical: which kinds of tasks should go to which model?

This feels confusing not because all three are weak, but because they are now strong in different ways. If you still choose based on a vague standard like “which one is smarter,” you can easily end up picking the wrong tool.

If we simplify the conclusion first, it roughly looks like this:

For daily conversations and general-purpose tasks, many people start with ChatGPT
For command-line coding, long-context collaboration, and sustained task execution, Claude often feels smoother
When you need Google ecosystem integration, search, multimodal entry points, or certain product-level capabilities, Gemini tends to stand out more

Let’s break that down into three parts.

1. Daily conversations: why many people still open `ChatGPT` first

For most everyday scenarios, ChatGPT still feels like the “default entry point.”

This is not about a single benchmark. It is about the overall experience:
when you want to ask a quick question, organize your thoughts, draft some copy, create a first version, or summarize a piece of material, ChatGPT usually feels fairly balanced.

Its strengths often show up in a few places:

Its response style is relatively stable
The learning curve is low for general users
Most broad tasks do not require much extra prompt tuning
The product feels polished and works well for frequent everyday use

So if your task is something like this:

Help me organize a topic
Turn an idea into structured content
Summarize a long article
Brainstorm several approaches
Rewrite something more clearly

Then ChatGPT is often a very natural place to start.

That does not mean it is always the strongest option for every professional task. It means that for broad, general-purpose use, it often feels more like the default workspace.

2. Command-line coding and long tasks: why many people lean toward `Claude`

Once a task shifts from “let’s chat” to “let’s keep working until this is done,” many people start preferring Claude.

This is especially true in scenarios like:

Command-line programming
Understanding the context of a large project
Coordinating edits across multiple files
Debugging long task chains
Reading code while steadily moving a task forward

In this kind of work, the key is usually not whether one reply is especially impressive. It is whether the model can stay stable across a longer chain of work.

The reason Claude is often favored is usually not that “it says one sentence better than the others,” but that:

It holds up better on long-context tasks
It feels steadier when reading files, logs, and rules continuously
It is better suited to gradually advancing complex coding work
In command-line and agent workflows, it is often treated as the primary working model

If you are doing vibe coding, fixing bugs in the terminal, understanding project structure, or changing features across multiple files, Claude’s strengths tend to show up more clearly.

Put simply, Claude feels more like a model you work with to get things done, not just one you ask a question and get an answer from.

3. `Gemini` often wins not by “competing head-on in everything”

When people talk about Gemini, they often frame the question like this: is it the strongest of the three?

But in real usage, the more useful question is usually not that. It is: in which scenarios is it especially worth pulling out and using on purpose?

Gemini’s value often shows up more clearly in these directions:

Integration with the Google ecosystem
Search and information gathering
Multimodal entry points
Certain product-side feature linkages

If your workflow is already close to Google’s toolchain, for example:

Search
Documents
Email
Browser-side usage
Mobile entry points

Then Gemini’s practical convenience may matter more than a simple model-score comparison.

In other words, Gemini is often useful because it plugs into your workflow more naturally, not just because it may or may not beat someone else in a single response.

4. The useful way to choose is not asking who is strongest, but asking what kind of task you have

When people compare all three models side by side, the easiest trap is trying to find one “single best” model.

But real tasks vary too much:

Some are one-off Q&A
Some are long-running conversations
Some are software projects
Some are information retrieval
Some are multimodal processing
Some are toolchain collaboration

So the more effective approach is usually to sort by task type:

If you want a broad, high-frequency assistant that works right away, start with ChatGPT
If you need long context, command-line work, coding collaboration, and steady progress on complex tasks, try Claude first
If you need help from the Google ecosystem, search, multimodal entry points, or certain product integrations, pay special attention to Gemini

That kind of division of labor is much closer to real-world use than forcing a single overall champion.

From a light user’s perspective, paying for all three can look redundant.
From a heavy user’s perspective, it is more like assigning different tools to different jobs.

The reason is simple:
if the strengths of the three models have already started to diverge clearly, then using them together is not really duplicated spending. It is a way to reduce switching costs and trial-and-error costs.

For example:

Use ChatGPT for daily organization and general Q&A
Use Claude for primary coding work
Use Gemini for certain search, multimodal, or Google-related workflows

The logic of this setup is not fundamentally different from designers installing multiple creative tools or developers using multiple IDEs.

6. When you should not switch models too often

Of course, having more models is not always better.

If you are still building a stable workflow, jumping too early and too often between three models can actually make things messier. Common issues include:

Re-explaining the same task three times
Getting different suggestions from different models and struggling more to judge them
Losing context and increasing collaboration costs
Getting stuck on tool choice before forming your own working boundaries

So a steadier way is usually this:

Give each model one primary scenario first
Use it continuously in that scenario for a while
Gradually build your own habits of division of labor

That makes it easier to gain reusable experience instead of staying forever in the “let me try this one today” stage.

7. A simple way to remember it

If you just want a practical version to remember, you can use this plain-language split:

ChatGPT: more like the default general-purpose assistant
Claude: more like the main option for long tasks and coding collaboration
Gemini: more like the tool with stronger advantages in search, multimodal work, and the Google ecosystem

This is not an absolute rule, and it does not mean the three cannot replace each other. It is simply a more realistic starting point.

What really matters is not choosing the “strongest model in the universe,” but figuring out as soon as possible:
for the kind of task in front of you, which model saves the most time, costs the least mental effort, and makes it easiest to get results?

OpenAI Releases GPT-5.5: Stronger Agentic Coding, Knowledge Work, and Research

Fri, 24 Apr 2026 08:39:56 +0800

OpenAI published Introducing GPT-5.5 on April 23, 2026. Judging from the official page, this release is not just about making the model “smarter”; it is more about whether the model can keep pushing complex tasks forward.

OpenAI positions GPT-5.5 as a model better suited for real work. It is expected not only to answer questions, but also to write code, debug, research online, analyze data, create documents and spreadsheets, operate software, and move across tools until the task is finished.

1. Where GPT-5.5 Is Strongest

The release page repeatedly highlights four areas:

Agentic coding
Computer use and tool use
Knowledge work
Early scientific research assistance

In other words, GPT-5.5 is aimed less at short Q&A and more at long-running tasks. For example, an engineering problem is not just “how should this code be changed”; the model needs to understand the project structure, locate the cause of failure, edit related files, add tests, verify results, and reduce repeated prompting from the user.

OpenAI also emphasizes that GPT-5.5 uses fewer tokens in Codex tasks. This matters in practice because coding agents can consume tokens quickly once they start reading files, running commands, and fixing bugs. If a model can complete the same task in fewer steps, both cost and waiting time go down.

2. Coding Is the Main Showcase

OpenAI calls GPT-5.5 its strongest agentic coding model to date.

The most notable public numbers include:

Terminal-Bench 2.0: GPT-5.5 reaches 82.7%
SWE-Bench Pro: GPT-5.5 reaches 58.6%
OpenAI’s internal Expert-SWE: GPT-5.5 also scores higher than GPT-5.4

These evaluations have one thing in common: they are closer to real engineering workflows than isolated algorithm questions. Terminal-Bench in particular involves command-line operations, planning, trial and error, tool coordination, and multi-step verification.

For everyday developers, the implication is direct: whether a model can take on larger tasks depends on whether it can hold context for a long time, check its own assumptions, know when to run tests, and understand what else a change may affect.

The value of GPT-5.5 in Codex also shows up mainly in these behaviors. It feels more like a collaborator that can take over part of an engineering task, rather than a tool that only completes code fragments.

3. Knowledge Work Becomes a Core Scenario

Beyond coding, OpenAI is placing GPT-5.5 into a broader office-work context.

The announcement says GPT-5.5 can generate documents, spreadsheets, and slide decks better in Codex, and is also better suited for operational research, spreadsheet modeling, and organizing business materials. Combined with computer use, its goal is not merely to offer suggestions, but to participate in the full workflow of finding information, understanding content, using tools, checking output, and turning raw material into a result.

The page also notes that OpenAI already uses Codex across many internal departments, including software engineering, finance, communications, marketing, data science, and product management. The interesting part is not any single example, but the direction: OpenAI is expanding Codex from a developer tool into a more general work tool.

In ChatGPT, GPT-5.5 Thinking is available to Plus, Pro, Business, and Enterprise users; GPT-5.5 Pro is aimed at harder questions and higher-accuracy work, and is available to Pro, Business, and Enterprise users.

4. Research Capability Is More Than Better Answers

GPT-5.5 also receives a strong research-focused presentation.

OpenAI says it has improved in genetics, quantitative biology, bioinformatics, mathematical proof, and related areas. The key is not whether the model can recall a fact, but whether it can handle more realistic research problems: reading data, spotting anomalies, proposing analyses, interpreting results, and continuing based on intermediate findings.

The release page mentions GeneBench and BixBench, both of which focus more on multi-stage scientific analysis. OpenAI also says an internal version of GPT-5.5, with a custom harness, helped discover a new proof related to Ramsey numbers and verified it with Lean.

These examples should not be simplified into “AI can now do research independently.” But they do suggest that models are moving from answer engines toward research collaborators. In scenarios where code, data, papers, experiment ideas, and notes are mixed together, GPT-5.5’s long-horizon reasoning and tool use become especially important.

5. Inference Efficiency: Stronger Without Getting Much Slower

One easily overlooked point is that OpenAI says GPT-5.5 matches GPT-5.4 in real-world per-token latency.

Normally, larger and more capable models bring higher latency. This time, OpenAI emphasizes that inference-system optimization helped GPT-5.5 become more capable while keeping speed stable. The release page also mentions that Codex analyzed production traffic patterns and wrote load-balancing heuristic algorithms, increasing token generation speed by more than 20%.

That detail is interesting: the model is not only served by infrastructure, but also helps improve the infrastructure that serves it.

6. Safety Gets Stricter, Especially Around Cybersecurity

Because GPT-5.5 has stronger cybersecurity capabilities, OpenAI is also tightening safety controls.

The announcement says GPT-5.5 improves over GPT-5.4 in cybersecurity capability, so OpenAI is deploying stricter classifiers, especially for high-risk activity, sensitive cybersecurity requests, and repeated misuse.

This means some users may see more refusals or friction when working on cybersecurity-related tasks. OpenAI also offers Trusted Access for Cyber, intended to reduce unnecessary barriers for verified defensive users.

For ordinary developers, the simple takeaway is: legitimate security hardening, vulnerability fixing, and code auditing should continue to be supported, while high-risk attack workflows will be more tightly controlled.

7. Availability and API Pricing

According to OpenAI’s release page, GPT-5.5 availability is as follows:

ChatGPT: GPT-5.5 Thinking for Plus, Pro, Business, and Enterprise users
ChatGPT: GPT-5.5 Pro for Pro, Business, and Enterprise users
Codex: GPT-5.5 for Plus, Pro, Business, Enterprise, Edu, and Go plans
Codex: 400K context window
Codex Fast mode: about 1.5x token generation speed at 2.5x the cost

For the API, OpenAI says gpt-5.5 and gpt-5.5-pro will be available soon.

The announced API prices are:

gpt-5.5: US$5 / 1M tokens input and US$30 / 1M tokens output
gpt-5.5-pro: US$30 / 1M tokens input and US$180 / 1M tokens output
gpt-5.5 API context window: 1M
Batch and Flex are half the standard API price
Priority processing is 2.5x the standard price

This is clearly more expensive than many everyday models, so it is better suited for high-value tasks: complex engineering changes, long-document analysis, office automation, research assistance, and important business workflows, rather than casual chat.

8. How to Read This Release

In one sentence, GPT-5.5 is about OpenAI pushing models further from “answering questions” toward “getting work done.”

The most important part is not just higher benchmark scores, but the convergence of several capabilities:

Better long-task persistence
More reliable tool use
Stronger engineering context understanding
Better fit for documents, spreadsheets, research, and business workflows
Longer context and higher token efficiency
Stricter controls around high-risk capabilities

For developers, the most interesting thing to test is complex engineering work in Codex. For enterprise users, the bigger question is whether it can turn some cross-tool, cross-document, cross-process work into deliverable output.

GPT-5.5 is not a small update aimed only at chat experience. It looks more like another step in OpenAI’s push toward AI as an execution layer for work.

Introducing GPT-5.5 - OpenAI

OpenAI Introduces ChatGPT Images 2.0: Image Generation Starts Moving Toward Deliverable Output

Wed, 22 Apr 2026 14:21:45 +0800

OpenAI published Introducing ChatGPT Images 2.0 on April 21, 2026. Judging from the announcement page, the main point is not simply that the images look better. The bigger message is that image generation is moving toward something more controllable, more layout-aware, and more directly usable.

If you look only at this launch page, it reads more like a dense capability showcase than a traditional technical announcement. There is very little about model architecture, training details, or benchmarks. Instead, OpenAI uses a large set of examples to answer a more practical question: can ChatGPT now handle more of the work that previously required repeated manual fixes for text, layout, and final polish?

01 The clearest signals in this release

The most prominent phrases on the page already summarize the focus:

Greater precision and control
Stronger across languages
Stylistic sophistication and realism

Taken together, those three ideas say a lot.

First, the emphasis is shifting away from imagination alone and toward control. The page includes many examples such as posters, magazine spreads, promo pages, infographics, character sheets, comic pages, and print-ready bookmark designs. What these examples share is not just visual appeal. They require text handling, hierarchy, whitespace, composition, stylistic consistency, and format control at the same time. That suggests OpenAI is intentionally pushing the product from “generate an image” toward “generate a visual asset people can actually use.”

Second, multilingual text rendering is being treated as a headline feature. The page includes multilingual posters, book covers, a Korean hospitality campaign, Japanese manga, and several typography-focused examples. That matters because one of the most persistent weak points in image models has been long text, complex layouts, and non-English scripts. OpenAI putting this front and center is itself a signal: text rendering and cross-language layout are now capabilities it believes are worth showcasing directly.

Third, the stylistic range is very broad. The examples span photorealistic images, retro collage posters, Bauhaus-inspired graphics, fashion editorials, black-and-white documentary styles, children’s-book illustrations, manga, educational infographics, product grids, and character reference sheets. The message is not only that the model can imitate many visual styles. It is that the system is trying to adapt to a wider set of real visual tasks.

02 Why this looks like a move toward deliverable output

From the announcement itself, ChatGPT Images 2.0 looks less like a stronger text-to-image model and more like an upgraded visual production tool.

Earlier models could produce impressive pictures, but the experience often broke down when the task changed into things like these:

creating a poster with a full headline, subtitle, and supporting copy
building a magazine or promo page with dense information
generating a comic page with continuity across characters and panels
producing marketing assets with fixed aspect ratios, clear layout constraints, and brand tone
creating polished visual content that includes multilingual text

This release seems designed to answer those older limitations directly.

The page includes educational infographics, design-trend posters, print-ready bookmark layouts, a cafe launch poster, tourism promo material, product-merch mockups, and a redesigned academic poster. These are not just images that look nice at a glance. They are much closer to semi-finished or even finished outputs from real creative workflows.

In that sense, the most important change here may not be a simple increase in image quality. It may be that the model is starting to look more like a system for content production, brand materials, education, and lightweight design work.

03 What this means for ChatGPT’s product direction

The structure of the announcement also hints at a broader product shift.

OpenAI does not present ChatGPT Images 2.0 as a niche tool only for artists or visual creators. Instead, it repeatedly frames the feature through research, reasoning, source transformation, layout organization, knowledge communication, and marketing output. The page even includes examples built around math proofs, design trends, historical notes, and academic papers.

That suggests image generation inside ChatGPT is no longer just about adding a picture to a chat or generating a single illustration. It is moving closer to being a general-purpose expression layer. The goal seems to be this: once a user has already researched, thought through, organized, and written something in ChatGPT, the system should also be able to handle the final visual output.

If that direction continues, competition in image generation will rely less on pure aesthetics or realism alone and more on capabilities like these:

whether the system can reliably handle complex text
whether it can preserve consistency across pages or panels
whether it can produce layouts closer to real working materials
whether it can connect naturally to research, writing, marketing, and teaching workflows

04 What the announcement does not say

At the same time, the format of the page also makes its limits clear.

As of the official page published on April 21, 2026, the announcement focuses much more on outputs than on methods. It does not go into detail about:

quantified improvements over the previous generation
explicit metrics for text accuracy or multilingual rendering
failure boundaries for complex layout tasks
API details, pricing, access modes, or enterprise integration specifics
concrete changes to safety policies or generation limits

So the page is best read as a product signal rather than a full technical specification.

05 Short conclusion

If I had to summarize ChatGPT Images 2.0 in one sentence, the key upgrade is not that it “draws better,” but that it is becoming better at producing finished work.

OpenAI clearly wants image generation to evolve from an inspiration tool into a production tool that is more executable, more layout-aware, more communicative, and more directly usable. Text control, multilingual output, layout structure, stylistic range, and long-form visual organization used to be places where image models often showed their weaknesses. In this release, those same areas are being presented as selling points.

That does not mean image generation has solved every design problem. But this announcement does suggest a shift in what matters. The next competitive edge may not come from who can generate the most striking single image. It may come from who can most reliably generate visual content that is actually ready to use.

Introducing ChatGPT Images 2.0 - OpenAI

codex-quota Practical Guide: Local, Web, and Docker Usage with Original CLI Commands

Thu, 16 Apr 2026 18:13:04 +0800

What This Project Does

codex-quota is a lightweight tool for checking ChatGPT Codex quota usage, with data fetched from https://chatgpt.com/backend-api/wham/usage.

Main features:

Supports both single-account and multi-account queries (account/*.auth.json).
Outputs five_hour%, weekly%, weekly_reset, and marks the source (network or cache).
Uses exponential backoff retries for temporary failures (408, 429, 5xx).
Includes local caching to reduce repeated requests when quota is already exhausted.
Provides a Web Dashboard, JSON API, and auth file management pages.

Advantages:

Lightweight: runs with simple scripts and minimal dependencies.
Practical: supports both CLI and Web entry points.
Deployable: works with Docker and Docker Compose.
Easy to operate: includes retry, cache, and scheduled refresh support.

Prepare Account Credentials First

Create credential files in account/<name>.auth.json, for example:

{
  "tokens": {
    "access_token": "eyJ...",
    "account_id": "user-xxxxxxxx"
  }
}

Explanation:

access_token and account_id are required by the usage API.
<name> in the filename is used as the account name in output.

Local CLI Usage (Keep Original Commands)

Install dependencies:

`1`	`pip install -r requirements.txt`

Explanation: installs project dependencies.

Query all accounts:

`1`	`python codex_quota.py`

Explanation: reads account/*.auth.json and outputs quota summary for all accounts.

Query one account:

`1`	`python codex_quota.py your_account_name`

Explanation: only queries account/your_account_name.auth.json.

Force refresh (skip cache):

`1`	`python codex_quota.py --refresh`

Explanation: ignores local cache and fetches fresh data directly.

CLI Options (Aligned with README)

account_name: optional account name (without .auth.json).
--account-dir: auth directory, default account.
--chatgpt-url: quota API endpoint.
--raw-json: print full JSON response body.
--raw-headers: print response headers.
--refresh: ignore cache.
--retries: retry count, default 3.
--retry-delay: base retry delay in seconds, default 2.0.

Web Dashboard Usage (Keep Original Command)

Start the service:

`1`	`python codex_quota_service.py --host 0.0.0.0 --port 8081`

Explanation: starts HTTP service listening on port 8081.

Access URL: http://localhost:8081

Service options:

--host: bind address, default 0.0.0.0.
--port: service port, default 8081.
--interval-seconds: scheduled refresh interval, default 3600.
--account-dir: auth directory, default account.
--state-file: state file path, default <account-dir>/codex_quota_web_results.json.
--account-name: optional single-account mode.
--chatgpt-url: quota API endpoint.
--retries: retry count.
--retry-delay: base retry delay.
--refresh: ignore CLI cache during scheduled runs.

HTTP Endpoints (For Automation)

GET /: dashboard page.
GET /api/results: latest results in JSON.
GET /refresh: trigger immediate refresh and redirect to /.
GET /auth: list auth files.
GET /auth/new: form to create auth file.
GET /auth/edit?name=<account>: form to edit auth file.
POST /auth/save: create/update auth file.
POST /auth/delete: delete auth file.

Docker Usage (Keep Original Commands)

Build image:

`1`	`docker build -t codex-quota .`

Explanation: builds the current project as image codex-quota.

Run container (map 8081):

`1`	`docker run --rm -p 8081:8081 -v ./account:/app/account codex-quota`

Explanation:

--rm: remove container automatically after exit.
-p 8081:8081: map host port to container port.
-v ./account:/app/account: mount local credentials into container.

Access URL: http://localhost:8081

Docker Compose Usage (Keep Original Command)

Start:

`1`	`docker compose up --build`

Explanation: build and start services based on docker-compose.yml.

Access URL: http://localhost:8081

Usage Tips

For multi-account scenarios, use Dashboard first for unified view and auth management.
For alerting or automation, prefer GET /api/results.
Do not commit real access_token values to public repositories.
If you see many temporary failures, increase --retries and --retry-delay.

How Codex Usage Limits Work: 5-Hour Limits, Weekly Limits, and Credits

Wed, 15 Apr 2026 22:50:00 +0800

When people first look at Codex usage limits, it is easy to assume that the 5-hour limit is a short-term balance, and that the weekly limit only starts decreasing after the 5-hour quota is used up.

That is not how it works. Codex is better understood as checking multiple limit windows at the same time: a short window prevents burst usage, while the weekly window controls total usage over the week. A Codex request usually counts against both.

So this situation is usually normal:

1
2

5-hour quota still has plenty left
but weekly quota has already decreased

01 The Short Version

You can understand Codex usage with three rules:

The 5-hour limit and the weekly limit apply at the same time.
If the weekly limit is exhausted, you usually cannot continue using the same subscription quota pool even if the 5-hour quota still has room.
Codex is not priced by simple message count. Usage depends on the model, tokens, task complexity, context size, and execution location.

In pseudocode:

can_use_codex =
    five_hour_remaining > 0
    && weekly_remaining > 0
    && no other product policy is triggered

When the 5-hour window resets, only the 5-hour quota is restored. It does not restore weekly quota. Weekly quota resets on its own schedule, or you may be able to buy extra credits on supported plans.

02 Why Both Windows Decrease

Think of Codex limits as two gates:

Window	Purpose
5-hour window	Prevents high-frequency burst usage
Weekly window	Controls total weekly usage

Each Codex task creates real usage. That usage is reflected in the relevant rate limit windows.

It is not:

1
2
3

Use 5-hour quota first
After the 5-hour quota runs out
Start using weekly quota

It is closer to:

1
2
3

One Codex request
=> counts toward the 5-hour window
=> also counts toward the weekly window

That is why weekly usage can drop even when the 5-hour quota is not exhausted.

03 Look at Token-Based Credits

OpenAI does not publish a formula that lets users fully reproduce the exact Codex charge. What is public is the rate card, the main factors, and per-model credit pricing.

As of 2026-04-15, the main Codex rate card model is token-based credits. Usage is estimated from input tokens, cached input tokens, and output tokens.

Example official rates:

Model	Input / 1M tokens	Cached input / 1M tokens	Output / 1M tokens
GPT-5.4	62.50 credits	6.250 credits	375 credits
GPT-5.4-Mini	18.75 credits	1.875 credits	113 credits
GPT-5.3-Codex	43.75 credits	4.375 credits	350 credits
GPT-5.2-Codex	43.75 credits	4.375 credits	350 credits
GPT-5.1-Codex-Max	31.25 credits	3.125 credits	250 credits
GPT-5.1-Codex-mini	6.25 credits	0.625 credits	50 credits

A rough estimate is:

usage
≈ input tokens / 1,000,000 × model input price
+ cached input tokens / 1,000,000 × model cached input price
+ output tokens / 1,000,000 × model output price

This is not an exact billing formula, but it explains the trend: output is expensive, long context is expensive, and stronger models cost more. The official rate card also says Fast mode uses 2x credits, and Code review uses GPT-5.3-Codex pricing.

04 Do Not Only Count Messages

Ten Codex messages can consume very different amounts.

Light tasks are usually cheaper:

Editing one small function
Explaining a short code snippet
Writing a short paragraph
Making a local change in a clearly specified file

Heavy tasks cost more:

Scanning a large codebase
Running a long agent session
Repeated read, edit, test, and fix loops
Generating lots of code or a long report
Using cloud tasks
Enabling fast mode

So message count is only a rough feeling. It does not tell you the real usage.

05 Local Tasks vs Cloud Tasks

Execution location can make a big difference.

A local task works in your local workspace: reading files, editing code, and running commands. A cloud task is delegated to a hosted cloud environment, which is better for longer and more automated workflows.

Cloud tasks are often more expensive because they involve:

A hosted execution environment
Longer tasks
More tool calls
Larger context
A more complete automation loop

For normal code edits, article cleanup, or small fixes, local tasks are usually cheaper. Use cloud tasks when the job truly needs hosted execution.

06 Why Weekly Usage Drops Fast

If your 5-hour quota barely moves but weekly usage drops a lot, common causes include:

You used cloud tasks.
You used a more expensive model.
You enabled fast mode.
The context was large, with many files or a long conversation.
The output was long, such as lots of code, a long report, or log analysis.
The task chain was long: search, edit, test, fix, test again.
Your quota script mislabeled the limit windows.

If you read fields from something like /backend-api/wham/usage, do not only trust processed labels such as five_hour% or weekly%. Check the raw JSON fields:

limit_window_seconds
percent_left
reset_at
bucket / feature name

Typical windows:

limit_window_seconds = 18000
=> about 5 hours

limit_window_seconds = 604800
=> about 7 days

If your script labels the windows backwards, the quota display will be misleading.

07 How to Save Quota

To make weekly quota last longer:

Split large jobs into smaller tasks.
Prefer local tasks when possible.
Tell Codex the relevant paths to reduce unnecessary scanning.
Avoid dumping huge logs, long files, or unrelated context.
Use cheaper mini models for light work.
Ask for a plan before starting a long task.
Ask for concise answers when you do not need a long report.

A useful mental model:

can continue using
= short window has quota
&& weekly window has quota

usage speed
= model price
× tokens
× output length
× task complexity
× execution location

This model is not exact billing math, but it explains most Codex usage-limit behavior.

Codex Usage and Quota Check

Sun, 12 Apr 2026 00:01:33 +0800

If you want to check the remaining quota for a Codex account, a small local script can call ChatGPT’s /backend-api/wham/usage endpoint directly.

The overall flow is simple:

Read tokens.access_token and tokens.account_id from auth.json
Send a request to https://chatgpt.com/backend-api/wham/usage
Include Authorization: Bearer ... and ChatGPT-Account-Id in the headers
Parse the five-hour and weekly quota windows from the response

What this is useful for

This approach is handy when you want to quickly confirm:

how much five-hour quota is left
how much weekly quota is left
when the quota resets

If you manage multiple accounts, the script can also scan account/*.auth.json and print a compact summary table. The auth.json file for your current signed-in ChatGPT account can usually be found under ~/.codex/.

The key inputs

In practice, the script mainly depends on two values:

access_token
account_id

Both are often available in a local auth.json. With them, the request headers usually look like this:

headers = {
    "Authorization": f"Bearer {auth_token}",
    "Accept": "application/json",
    "ChatGPT-Account-Id": auth_account_id,
    "Origin": "https://chatgpt.com",
    "Referer": "https://chatgpt.com/",
    "User-Agent": "Mozilla/5.0",
}

How to read the response

After the request succeeds, the most important entries are the two quota windows:

five_hour
weekly

A practical script usually normalizes them into:

remaining percentage
reset time
window length

It is also useful to handle alternate field names such as primary_window, secondary_window, five_hour_limit, and weekly_limit.

Common issues

A 401 response usually means the access_token is expired or invalid.

A 403 response usually means the account cannot access this endpoint, or the account is in an abnormal state.

If the response uses inconsistent field names, it is better to normalize them before printing the summary.

Reference

codex-auth-manager: https://github.com/RioArisk/codex-auth-manager

Code

import argparse
import base64
import json
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
from typing import Any

import requests


UTC = timezone.utc
CST = timezone(timedelta(hours=8), name="CST")
JSONDict = dict[str, Any]


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Query ChatGPT Codex usage from /backend-api/wham/usage."
    )
    parser.add_argument(
        "account_name",
        nargs="?",
        help="Account name used to load account/<account_name>.auth.json. If omitted, load all *.auth.json files in account/.",
    )
    parser.add_argument(
        "--account-dir",
        default="account",
        help="Directory containing <account_name>.auth.json files.",
    )
    parser.add_argument(
        "--chatgpt-url",
        default="https://chatgpt.com/backend-api/wham/usage",
        help="ChatGPT usage endpoint.",
    )
    parser.add_argument(
        "--raw-json",
        action="store_true",
        help="Print the full JSON response body.",
    )
    parser.add_argument(
        "--raw-headers",
        action="store_true",
        help="Print response headers.",
    )
    return parser.parse_args()


def print_json(data: Any) -> None:
    print(json.dumps(data, indent=2, ensure_ascii=False))


def load_auth_json(path_str: str | Path | None) -> JSONDict | None:
    if not path_str:
        return None
    path = Path(path_str).expanduser()
    if not path.is_file():
        return None
    try:
        return json.loads(path.read_text(encoding="utf-8"))
    except (OSError, json.JSONDecodeError):
        return None


def get_nested_string(data: JSONDict | None, *keys: str) -> str | None:
    current: Any = data
    for key in keys:
        if not isinstance(current, dict):
            return None
        current = current.get(key)
    return current if isinstance(current, str) and current else None


def format_dt(dt: datetime | None) -> str:
    if dt is None:
        return "-"
    return dt.astimezone(CST).strftime("%Y-%m-%d %H:%M:%S %Z")


def format_cst(dt: datetime | None) -> str:
    return format_dt(dt)


def epoch_ms_to_dt(value: Any) -> datetime | None:
    if value is None:
        return None
    try:
        raw = int(value)
    except (TypeError, ValueError):
        return None
    # Newer responses sometimes use epoch seconds, older ones use epoch milliseconds.
    timestamp = raw / 1000 if raw > 10**11 else raw
    return datetime.fromtimestamp(timestamp, tz=UTC)


def first_dict(data: Any, *keys: str) -> JSONDict | None:
    for key in keys:
        value = data.get(key) if isinstance(data, dict) else None
        if isinstance(value, dict):
            return value
    return None


def decode_jwt_exp(token: str) -> datetime | None:
    parts = token.split(".")
    if len(parts) != 3:
        return None
    try:
        payload = parts[1]
        payload += "=" * (-len(payload) % 4)
        data = json.loads(base64.urlsafe_b64decode(payload.encode("ascii")))
        exp = data.get("exp")
        if exp is None:
            return None
        return datetime.fromtimestamp(int(exp), tz=UTC)
    except (ValueError, TypeError, json.JSONDecodeError):
        return None


def get_percent_left(value: JSONDict) -> float | int | None:
    percent_left = value.get("percent_left")
    if percent_left is None:
        percent_left = value.get("remaining_percent")
    if percent_left is not None:
        return percent_left

    used_percent = value.get("used_percent")
    try:
        if used_percent is not None:
            return max(0, 100 - float(used_percent))
    except (TypeError, ValueError):
        return None
    return None


def resolve_limit_window(value: JSONDict) -> JSONDict:
    if (
        "reset_at" not in value
        and "reset_time_ms" not in value
        and isinstance(value.get("primary_window"), dict)
    ):
        return value["primary_window"]
    return value


def parse_limit_entry(name: str, value: Any) -> JSONDict | None:
    if not isinstance(value, dict):
        return None

    value = resolve_limit_window(value)

    percent_left = get_percent_left(value)
    reset_time_ms = value.get("reset_time_ms")
    if reset_time_ms is None:
        reset_time_ms = value.get("reset_at")

    window_seconds = value.get("limit_window_seconds")

    return {
        "name": name,
        "percent_left": percent_left,
        "reset_time_ms": reset_time_ms,
        "reset_at": epoch_ms_to_dt(reset_time_ms),
        "limit_window_seconds": window_seconds,
    }


def infer_limit_name(window_seconds: Any) -> str | None:
    if not isinstance(window_seconds, (int, float)):
        return None
    if window_seconds <= 6 * 3600:
        return "five_hour"
    if window_seconds >= 6 * 24 * 3600:
        return "weekly"
    return None


def relabel_rate_limits(primary: JSONDict | None, secondary: JSONDict | None) -> tuple[JSONDict | None, JSONDict | None]:
    for entry in (primary, secondary):
        if not entry:
            continue
        inferred_name = infer_limit_name(entry.get("limit_window_seconds"))
        if inferred_name:
            entry["name"] = inferred_name

    if primary and secondary and primary.get("name") == secondary.get("name"):
        if primary.get("name") == "weekly":
            primary["name"] = "five_hour"
        else:
            secondary["name"] = "weekly"

    if primary and primary.get("name") == "weekly" and secondary is None:
        return None, primary

    if secondary and secondary.get("name") == "five_hour" and primary is None:
        return secondary, None

    return primary, secondary


def parse_rate_limits(data: JSONDict) -> tuple[JSONDict | None, JSONDict | None]:
    primary = None
    secondary = None

    for primary_key in ("five_hour", "five_hour_limit", "five_hour_rate_limit", "primary"):
        if primary_key in data:
            primary = parse_limit_entry("five_hour", data.get(primary_key))
            if primary:
                break

    for secondary_key in ("weekly", "weekly_limit", "weekly_rate_limit", "secondary"):
        if secondary_key in data:
            secondary = parse_limit_entry("weekly", data.get(secondary_key))
            if secondary:
                break

    if primary is None:
        primary = parse_limit_entry("five_hour", data.get("primary_window"))
    if secondary is None:
        secondary = parse_limit_entry("weekly", data.get("secondary_window"))

    return relabel_rate_limits(primary, secondary)


def format_percent(value: Any) -> str:
    return f"{value:g}" if isinstance(value, (int, float)) else str(value if value is not None else "-")


def percent_sort_value(value: Any, descending: bool) -> tuple[int, float]:
    if isinstance(value, (int, float)):
        numeric_value = float(value)
        return (0, -numeric_value if descending else numeric_value)
    return (1, 0.0)


def get_auth_paths(account_dir: str, account_name: str | None) -> list[Path]:
    base_dir = Path(account_dir)
    if account_name:
        return [base_dir / f"{account_name}.auth.json"]
    return sorted(base_dir.glob("*.auth.json"))


def get_account_name_from_path(path: Path) -> str:
    suffix = ".auth.json"
    return path.name[: -len(suffix)] if path.name.endswith(suffix) else path.stem


def build_summary_row(account_name: str, five_hour: JSONDict | None, weekly: JSONDict | None) -> JSONDict:
    return {
        "account": account_name,
        "five_hour_percent": five_hour["percent_left"] if five_hour else None,
        "weekly_percent": weekly["percent_left"] if weekly else None,
        "weekly_reset_at": weekly["reset_at"] if weekly else None,
    }


def print_summary_rows(rows: list[JSONDict]) -> None:
    if not rows:
        return

    sorted_rows = sorted(
        rows,
        key=lambda row: (
            percent_sort_value(row.get("five_hour_percent"), descending=True),
            percent_sort_value(row.get("weekly_percent"), descending=True),
            format_cst(row.get("weekly_reset_at")),
            row["account"],
        ),
    )

    display_rows = []
    for row in sorted_rows:
        display_rows.append(
            {
                "account": str(row["account"]),
                "five_hour": format_percent(row.get("five_hour_percent")),
                "weekly": format_percent(row.get("weekly_percent")),
                "weekly_reset": format_cst(row.get("weekly_reset_at")),
            }
        )

    headers = {
        "account": "account",
        "five_hour": "five_hour%",
        "weekly": "weekly%",
        "weekly_reset": "weekly_reset",
    }
    widths = {
        key: max(len(headers[key]), max(len(item[key]) for item in display_rows))
        for key in headers
    }

    print(
        f"{headers['account']:<{widths['account']}}  "
        f"{headers['five_hour']:>{widths['five_hour']}}  "
        f"{headers['weekly']:>{widths['weekly']}}  "
        f"{headers['weekly_reset']:<{widths['weekly_reset']}}"
    )
    for item in display_rows:
        print(
            f"{item['account']:<{widths['account']}}  "
            f"{item['five_hour']:>{widths['five_hour']}}  "
            f"{item['weekly']:>{widths['weekly']}}  "
            f"{item['weekly_reset']:<{widths['weekly_reset']}}"
        )


def validate_token_inputs(
    token: str,
    account_id: str,
    auth_token: str | None,
    auth_account_id: str | None,
) -> int | None:
    if token.startswith("sess-"):
        print("status: invalid_token_type", file=sys.stderr)
        print(
            "message: --chatgpt-token looks like a session token (sess-...). Use the JWT access_token instead.",
            file=sys.stderr,
        )
        if auth_token:
            print(
                "hint: Found tokens.access_token in auth.json; omit --chatgpt-token or pass that value instead.",
                file=sys.stderr,
            )
        return 1

    token_exp = decode_jwt_exp(token)
    if token_exp is not None and token_exp <= datetime.now(UTC):
        print("status: expired", file=sys.stderr)
        print(f"message: access_token expired at {format_dt(token_exp)}", file=sys.stderr)
        if auth_token and auth_token != token:
            auth_token_exp = decode_jwt_exp(auth_token)
            hint = format_dt(auth_token_exp) if auth_token_exp else "unknown time"
            print(f"hint: auth.json contains a different access_token expiring at {hint}", file=sys.stderr)
        return 1

    if auth_account_id and account_id != auth_account_id:
        print("warning: supplied --account-id does not match auth.json tokens.account_id", file=sys.stderr)

    return None


def handle_error_response(response: requests.Response, data: Any, raw_json: bool) -> int | None:
    if response.status_code == 401:
        print("status: expired", file=sys.stderr)
        print("message: Token 宸茶繃鏈熸垨鏃犳晥", file=sys.stderr)
        if raw_json:
            print_json(data)
        return 3

    if response.status_code == 403:
        print("status: forbidden", file=sys.stderr)
        print("message: 璐﹀彿宸茶灏佺鎴栨棤鏉冭闂?, file=sys.stderr)
        if raw_json:
            print_json(data)
        return 3

    if response.status_code >= 400:
        print(f"HTTP {response.status_code}", file=sys.stderr)
        print_json(data)
        return 3

    return None


def fetch_chatgpt_usage(auth_path: Path, args: argparse.Namespace) -> tuple[int, JSONDict | None]:
    auth_data = load_auth_json(auth_path)
    account_name = get_account_name_from_path(auth_path)
    auth_token = get_nested_string(auth_data, "tokens", "access_token")
    auth_account_id = get_nested_string(auth_data, "tokens", "account_id")

    if not auth_data:
        print(f"{account_name}: auth file not found or invalid", file=sys.stderr)
        return 1, None

    if not auth_token:
        print(f"{account_name}: missing access_token", file=sys.stderr)
        return 1, None

    if not auth_account_id:
        print(f"{account_name}: missing account_id", file=sys.stderr)
        return 1, None

    validation_error = validate_token_inputs(
        auth_token,
        auth_account_id,
        auth_token,
        auth_account_id,
    )
    if validation_error is not None:
        return validation_error, None

    headers = {
        "Authorization": f"Bearer {auth_token}",
        "Accept": "application/json",
        "ChatGPT-Account-Id": auth_account_id,
        "Origin": "https://chatgpt.com",
        "Referer": "https://chatgpt.com/",
        "User-Agent": "Mozilla/5.0",
    }

    try:
        response = requests.get(args.chatgpt_url, headers=headers, timeout=60)
    except requests.RequestException as exc:
        print(f"Request failed: {exc}", file=sys.stderr)
        return 2, None

    if args.raw_headers:
        print("=== Headers ===")
        print_json(dict(response.headers))
        print()

    try:
        data = response.json()
    except ValueError:
        print(f"HTTP {response.status_code}", file=sys.stderr)
        print(response.text, file=sys.stderr)
        return 3, None

    error_response = handle_error_response(response, data, args.raw_json)
    if error_response is not None:
        return error_response, None

    if args.raw_json:
        print("=== Raw JSON ===")
        print_json(data)
        print()

    rate_limits = first_dict(data, "rate_limit", "rate_limits")

    if rate_limits is None:
        return 0, build_summary_row(account_name, None, None)

    five_hour, weekly = parse_rate_limits(rate_limits)
    return 0, build_summary_row(account_name, five_hour, weekly)


def main() -> None:
    args = parse_args()
    auth_paths = get_auth_paths(args.account_dir, args.account_name)
    if not auth_paths:
        print("No auth files found.", file=sys.stderr)
        sys.exit(1)

    exit_code = 0
    summary_rows: list[JSONDict] = []
    for auth_path in auth_paths:
        current_exit_code, summary_row = fetch_chatgpt_usage(auth_path, args)
        exit_code = max(exit_code, current_exit_code)
        if summary_row is not None and not args.raw_json:
            summary_rows.append(summary_row)

    if summary_rows:
        print_summary_rows(summary_rows)
    sys.exit(exit_code)


if __name__ == "__main__":
    main()

ChatGPT on KnightLi Blog

After Google I/O, Should You Subscribe to GPT or Gemini? A Comparison for Regular Users and Developers

The Short Answer

What Changed for Gemini After Google I/O

Who Is ChatGPT / GPT Best For Now?

Who Is Gemini / Google AI Best For Now?

How Regular Users Should Choose

How Developers Should Choose

How Content Creators Should Choose

How Enterprises and Teams Should Choose

When You Need Pro / Ultra

The Most Cost-Effective Subscription Strategy

Checklist Before Subscribing

Summary

How Did AI Agents Evolve? A Complete 2022-2026 Five-Generation Timeline

Overview: five generations of Agents

Late 2022: Generation 0, the ChatGPT chat-box era

Mid-2023: Generation 1, tool calling wakes up

Late 2023 to 2024: Generation 2, engineered workflows

2024 to 2025: Generation 3, Computer Use reaches real interfaces

2025 to 2026: Generation 4, MCP, Skills, and persistent digital workers

After 2026: Generation 5 preview, loops, internal memory, and world models

Six patterns behind the timeline

The real moat

Final note

Codex Mobile Remote Access: Use the ChatGPT App to Follow Coding Tasks on Your Mac

What it can do

Requirements

Limits of Codex mobile remote access

How to connect

What the phone is good for

Common issues

Best use cases

My take

References

What Is ChatGPT File Library? File Storage, Limits, and Privacy Boundaries

Latest availability

What it saves

Adding files to a new chat

Finding and managing files

Storage by plan

Per-file limits

Deleting and downloading

Temporary Chat does not save files

Data and training settings

Good and bad use cases

My take

References

OpenAI's New Realtime Voice Models: GPT-Realtime-2, Live Translation, and Streaming Transcription

GPT-Realtime-2: the main model for voice agents

Live translation for multilingual voice products

Streaming transcription: voice content enters workflows immediately

Pricing and availability

What this means for developers

Safety and disclosure still matter

Summary

What Is the Difference Between GPT-5.5, GPT-5.5 Instant, GPT-5.5 Thinking, and GPT-5.5 Pro?

Quick Comparison

What Is GPT-5.5

GPT-5.5 Instant: Default, Fast, Everyday Use

GPT-5.5 Thinking: The Main Mode for Complex Tasks

GPT-5.5 Pro: Research-Grade, Heavier, More Rigorous

Tool Support Differences

Context Window Differences

How to Choose

Everyday Q&A

Writing, Summarizing, Email Editing

Coding and Debugging

Research and Material Analysis

Tasks Requiring Image Generation, Canvas, or Memory

Short Conclusion

Related Links

How ChatGPT, Claude Code, and Gemini memory mechanisms differ

ChatGPT: long-term preferences around the person

Memory Sources: making personalization more visible

Claude Code: around codebases and engineering rules

Claude Code Auto Memory: accumulating project experience

Gemini: around Google ecosystem context

Core differences

How to choose

1. Daily conversations: why many people still open `ChatGPT` first

2. Command-line coding and long tasks: why many people lean toward `Claude`

3. `Gemini` often wins not by “competing head-on in everything”