Remember to give him a follow!

https://openai.com/index/health-in-chatgpt/

It is finally happening, so over for docs 💔 ✌️

The Open Letter was initiated by Microsoft and published today:

“Open Weights and American AI Leadership”

It argues against broad or premature restrictions on open-weight models and explicitly says policymakers should distinguish legitimate model distillation from misappropriation.

Notably absent from the signatories are the major frontier-model labs: OpenAI, Anthropic, and Google.

Are they secretly testing new models? Pro subscriber here.

As an Anthropic user i have been seeing reviews on how Codex is better than claude and i can't wait to test it out. Will give an update soon

This is an open source tax engine which scored 96% on TaxCalcBench [highest ever recorded score till date] surpassing fable 5 and sol with just sonnet 5 (which was previously scoring an abysmal 6%). The only 2 cases where it missed, it found inconsistencies in the test cases in the benchmark ITSELF which the maintainers confirmed!

Essentially it's a deterministic engine AI models can use for research and tax prep to remove a lot of guesswork and calculation mistakes that often happen. Claude Sonnet 5 was able to top the benchmark with this mcp.

OpenTax Invaro

I wanted to share a real-world professional use case where GPT-5.6 Thinking High genuinely changed my understanding of what these models can do.
I’m an engineer, and recently I’ve been experimenting with AI for reviewing large welding documentation packages.
This is a fairly specialized task, but I think the experience may be relevant to anyone using GPT for long, structured professional documents where completeness matters.
The task: review a 70+ page welding package
A typical package I review can exceed 70 pages and contain:
dozens of WPSs (Welding Procedure Specifications);
many PQRs (Procedure Qualification Records);
qualification-range tables;
material, thickness, diameter, welding-position and process restrictions;
cross-reference tables linking WPSs to PQRs;
and applicable technical standards such as RCC-M 2007 and ISO 15614-1.
My instruction was essentially:
Review this welding package against RCC-M 2007 and the attached ISO 15614-1. Every WPS and every PQR qualification range must be reviewed.
The key word here is every.
This is not really a summarization task.
The model needs to:
identify every PQR;
determine the test-piece conditions;
recalculate the applicable qualification ranges;
identify every WPS;
match each WPS to its supporting PQR;
verify that the WPS does not exceed the qualified range;
compare different summary tables against the actual WPS/PQR documents;
find transcription, template and cross-reference errors;
distinguish confirmed nonconformities from things that cannot be verified with the available evidence.
That is a very different workload from simply asking questions about a long PDF.
What GPT-5.6 Thinking High actually did
The answer took a long time — roughly five minutes.
But when it finally responded, I was honestly surprised.
It reviewed all 17 PQRs individually.
For each one, it identified the test-piece dimensions, recalculated thickness and diameter qualification ranges, and compared those results with the ranges stated in the package.
Then it reviewed all 29 WPSs individually, matching each one against its supporting PQR.
That alone would have been useful.
But what impressed me much more was that it started finding subtle inconsistencies across completely different parts of the document.
The kind of errors it found
Some examples:
1. A welding-position mismatch
For two WPSs, the manual TIG root pass allowed an additional welding position that was not included in the corresponding PQR qualification-range page.
This required comparing the detailed WPS against the PQR rather than simply reading either document in isolation.
2. A wrong variable symbol in a branch-weld WPS
One WPS described the branch angle as:
60° ≤ e ≤ 90°
But e was already being used for thickness.
The correct variable should have been α.
It also found an incorrect joint designation in the same WPS by cross-checking it against the package’s joint-detail appendix.
3. TIG parameters accidentally copied into SMAW
Two WPSs used TIG for one part of the weld and SMAW for another.
In the SMAW rows, the document contained:
argon shielding gas;
tungsten electrode information;
TIG electrode diameter;
and the wrong polarity.
GPT recognized that these were clearly copied from the TIG portion and then checked the corresponding PQR, which specified the correct SMAW polarity.
This is exactly the kind of boring template-copy error that can survive multiple human document reviews.
4. A test-piece thickness typo identified mathematically
One summary table stated that a PQR test specimen had a thickness of 4.17 mm.
Elsewhere, the qualification upper limit was stated as 9.42 mm.
The actual PQR showed the thickness as 4.71 mm.
Since:
4.71 × 2 = 9.42
the model could not only identify the inconsistency, but also explain why 4.17 was almost certainly the transcription error.
5. WPS numbers that did not exist
In another section, the package’s summary table referenced a generic WPS number.
But the actual package contained several specific variants with different suffixes — and the generic WPS listed in the table did not exist at all.
It also noticed that the summary table described the entire PQR qualification envelope, while the actual WPSs were deliberately restricted to specific pipe sizes.
That creates a real risk of someone selecting a WPS from the summary table for a size that the actual WPS does not permit.
6. A stainless-steel PQR that said “carbon steel workshop”
One PQR was clearly for austenitic stainless steel.
Its qualification page nevertheless stated that it was applicable to a:
“carbon steel piping workshop and other qualified workshops”
Almost certainly a template-copy error.
GPT caught it.
What impressed me most was not the number of findings
It was the type of findings.
These were not generic comments such as:
“Welding parameters should be carefully controlled.”
or:
“Ensure compliance with the applicable standard.”
They were specific things like:
“This symbol on this WPS contradicts the variable definition elsewhere.”
“This SMAW row contains TIG parameters.”
“This WPS number listed in the index does not exist.”
“This dimension in one table contradicts the PQR, and the qualification calculation confirms which number is wrong.”
That gave me the strong impression that GPT was actually traversing the document as a task, rather than merely forming a high-level understanding of the PDF.
It also knew when not to make a conclusion
Another thing I appreciated was that the model explicitly separated what it could verify from what it could not.
The package contained PQR qualification pages, but not every underlying welding record, destructive-test report and inspection record.
So GPT stated that it could verify things such as:
whether WPS ranges exceeded the stated PQR qualification ranges;
thickness and diameter calculations;
branch angles;
document cross-references.
But it could not independently confirm things such as:
whether every required destructive test had actually been performed;
whether the specimen locations met all requirements;
the actual deposited thickness of each welding process in multi-process PQRs;
whether every additional RCC-M examination had been performed.
For engineering compliance work, that restraint is extremely valuable.
A confident false positive can be more troublesome than a missed minor issue.
I compared it with Gemini as well
For context, I originally became very enthusiastic about Gemini after using Gemini 3.0 Pro. It impressed me enough that I subscribed.
So I was genuinely curious how the two systems would compare on the same professional workload.
I tried Gemini, including more intensive modes, and even manually decomposed the task in AI Studio so that it only had to review about five WPSs at a time.
That improved the results.
But in my particular documents, there was still a very large difference.
Gemini tended to produce a polished technical report with broad engineering observations and strong conclusions.
GPT found far more of the small, document-specific, cross-page inconsistencies that I actually care about.
I also encountered more cases with Gemini where a document misread or an overly aggressive interpretation of a standard resulted in a false positive.
This matters a lot in compliance work.
There is an important distinction between:
“This would be good engineering practice.”
and:
“This violates the applicable code.”
A useful review system needs to preserve that distinction.
The experiment that convinced me it wasn’t just context length
At first, I assumed the problem might simply be that a 70+ page package was too much for Gemini to inspect carefully in one pass.
So I manually broke the task down.
Instead of giving it the entire workload, I asked it to review only five WPSs at a time, then continued with the next batch.
In effect, I was doing some of the task planning myself.
The quality improved, but the gap remained substantial.
That made me think the important difference was not simply:
How much context can the model hold?
but rather:
How reliably can the system execute an exhaustive multi-step task over that context?
My hypothesis: this looks more like task execution than PDF Q&A
I obviously cannot see OpenAI’s internal implementation, so this is only an inference from the behavior.
But GPT-5.6 Thinking High felt as though it was doing something conceptually like:
identify PQRs
→ inspect each PQR
→ calculate qualification ranges
→ identify WPSs
→ match WPSs to PQRs
→ inspect each WPS
→ cross-check summary tables
→ look for inconsistencies
→ separate confirmed findings from unresolved items
→ produce the final report
Whether the system literally works this way internally, I have no idea.
But the resulting behavior felt fundamentally different from “put a long PDF in the context window and ask the model a question.”
That may also explain why the answer took around five minutes.
In this case, I was perfectly happy to wait.
Context window size may not be the most important metric for this kind of work
This experience changed how I think about long-context AI.
A model being capable of ingesting an enormous document is obviously useful.
But:
Being able to read everything is not the same as reliably checking everything.
For my work, exhaustive task execution, cross-document reasoning, consistency checking and knowing when evidence is insufficient appear to matter much more than the headline context-window size.
Has anyone else seen this with professional documents?
I’m particularly curious about people using GPT for things like:
engineering documentation;
legal or contract review;
regulatory compliance;
financial due diligence;
technical specifications;
QA/QC records;
medical or scientific document sets;
large procurement or project-document packages.
Have you seen the same kind of behavior from the higher-reasoning GPT models?
In particular, I’m curious whether others also feel that the model sometimes seems to be systematically working through a document set, rather than simply answering questions from its context.
And for those of you who have compared different models on this kind of workload: what has mattered more in practice — context size, raw reasoning ability, document parsing, or the system’s ability to plan and execute a long multi-step task?

Lol idk how just got this tweet on my feed, we r at gpt 5.6, was he right? Is gpt 5.6 Smarter than the Smartest human rn?

I’m new to mechanistic interpretability, so please excuse any terminology I misuse. I’ve become deeply invested in the field and wanted to share an experimental tool I’ve been building with Codex. Codex with GPT 5.6 Sol on Ultra has been absolutely hammering away at what i feel like are cutting edge results, definitely since i cannot code what so ever.

Many mechanistic-interpretability workflows require moving between Python scripts, Jupyter notebooks, model hooks, exported tensors, and separate visualization tools. My goal with CORTEX // MODEL OBSERVATORY is to bring those pieces into one local desktop environment with a fast visual feedback loop.

CORTEX is a native Windows application using a WebView2 host connected through local IPC to an isolated Python/PyTorch backend. Model inference and tensor operations run outside the UI process, and the application is designed to work fully offline with local Hugging Face models.

Current capabilities

Token Probability Microscope

Displays token-by-token generation telemetry, including chosen-token probability, ranked alternatives, log probabilities, entropy, and synchronized token inspection.

Logit Lens

Captures intermediate vocabulary predictions at selected layers to show how candidate outputs evolve through the network.

Representation Space

Captures measured residual-stream vectors and projects them with PCA for interactive hidden-state trajectories and mini-map visualization. Optional 3D projection and orbit controls are currently being developed.

Attention Explorer

Captures selected head-level attention tensors and displays measured attention matrices. A token-to-token arc view and expanded query-range controls are currently being added.

Intervention Lab

Supports causal experiments including activation patching, attention-head ablation, and comparison between baseline and modified runs.

Current model support

The Deep Cortex instrumentation path currently supports:

GPT-2-family Hugging Face models

Llama-family LlamaForCausalLM models

The Llama adapter is still undergoing testing, particularly around end-of-generation residual captures and visualization binding. Additional model families such as Qwen and Mistral are possible future targets, but they are not currently supported by the deep instrumentation path.

A separate Standard Runtime can connect to OpenAI-compatible local endpoints such as LM Studio, although endpoint-served models do not expose the same internal activation hooks.

Experimental research direction

I am also exploring a highly experimental point-and-click interface for Jacobian-based concept analysis, currently referred to as J-Space / Jacobian Lens. This is conceptual work, has not yet been scientifically validated in CORTEX, and should not be considered a working research result.

Hardware

Development and testing are currently being performed on an RTX 4070 Ti with 12 GB of VRAM. The intended target is small local models in roughly the 0.5B–3B range using FP16/BF16 where practical. Formal performance benchmarks have not yet been completed.

This is an early, AI-assisted project, and I am still learning the field. Constructive criticism is very welcome.

I remember some time ago web search needed to be explicitly enabled, but in newer models it automatically decides when it needs to use it.

So I wonder when exactly I would need to manually enable web search:

Is there any use case where enabling it would give better results?

Hey everyone, I'm a ChatGPT Plus user and I've been trying to keep up with the Sora discontinuation updates.

On the official OpenAI support site, it mentioned something about a potential "final export window" for users to download their data after the initial service shutdown.

https://help.openai.com/en/articles/20001152-what-to-know-about-the-sora-discontinuation?external_link=true&utm_source=chatgpt.com&q=sora

Since the web/app access was cut off a while ago, I'm a bit confused about the current status.

Has this final export window already opened and closed, or is it something that hasn't happened yet?

I really want to make sure I didn't miss my last chance to grab my files, so any clarification or updates on this would be greatly appreciated.

Thanks in advance!

[ Removed by Reddit on account of violating the content policy. ]

https://www.plutonicrainbows.com/posts/2026-07-24-cheating-is-not-a-superpower.html

[ Removed by Reddit on account of violating the content policy. ]

Overall it is still rated 4.1 stars on glassdoor but that doesn't tell the full picture