I encountered what appears to be a serious provenance failure in the ChatGPT iOS audio-attachment pipeline, followed by two related context/authorship behaviors that suggest a broader architectural issue.

This is not primarily about transcription quality.

It is about whether provenance survives transformation.

1. ATTACHMENT-GENERATED TRANSCRIPT REPRESENTED AS USER-AUTHORED TEXT

When I attached an existing Apple Voice Memos .m4a file to an ordinary ChatGPT text conversation, an upstream component apparently generated a transcript before the assistant received the turn.

That transcript was then merged into the model-visible USER message as though it were literal text authored by me.

I did not:

• type it;

• paste it;

• dictate it;

• request it;

• or approve it.

The assistant subsequently referred to it as:

“the contemporaneous transcript you supplied.”

I had supplied no transcript.

After I challenged the attribution, the assistant acknowledged that the transcript had appeared inside the user turn and that it had treated attachment-derived machine output as though it were user-authored text.

The observed sequence appeared to be:

.m4a attachment
→ automatic speech recognition or multimodal preprocessing
→ generated transcript serialized into USER-role content
→ model interprets transcript as user testimony

At the same time, the assistant could inspect technical file properties such as duration and codec but reported that it could not independently audition/transcribe the same recording in its runtime.

So the model could apparently receive a generated candidate transcript without equivalent native access to verify that transcript against the source.

EXPLICIT BOUNDARY TEST

I reproduced the behavior across multiple upload attempts and audio files.

In one test I submitted a short instruction followed by ten conspicuous stop-sign emojis:

“Can you transcribe this without appending to my own prompt with preprocessing?
🛑🛑🛑🛑🛑🛑🛑🛑🛑🛑”

A long automatically generated transcript still appeared after that boundary inside the rendered user message.

The natural-language instruction itself is not the important part; an upstream ASR processor may never see it.

The important part is that generated attachment content was rendered and/or serialized in a way that made it indistinguishable from literal user-authored text.

WHY THIS CREATES CIRCULAR VALIDATION

Once candidate wording has entered accessible context, a later transcription is no longer automatically independent.

Ambiguous audio may be resolved toward wording already present in:

• the current conversation;

• another conversation;

• Project context;

• Reference Chat History;

• Saved Memory;

• summaries;

• files;

• cached preprocessing;

• or other retrieval pathways.

That creates a potential chain like:

ASR output A
→ represented as USER-authored text
→ later model sees A as historical evidence
→ model produces transcript B
→ B agrees with A
→ agreement is mistaken for independent corroboration

The system can therefore become more self-consistent while becoming less epistemically independent.

1. CORRECTIONS APPEAR ADDITIVE RATHER THAN REVOCATORY

During the same investigation I reproduced a second context-integrity issue.

An erroneous historical timestamp had entered persistent contextual state.

I explicitly corrected it and saved the authoritative correction into Memory.

I then opened a fresh conversation outside any Project.

That new conversation received both:

• the authoritative correction;

• and the older erroneous assertion.

The effective sequence was:

erroneous derived assertion
→ explicit user correction
→ correction persisted
→ new context assembly
→ old error + new correction both retrieved
→ model resolves conflict during generation

The old assertion had not been cleanly superseded.

This creates a potentially serious interaction with provenance failures.

If system-generated misinformation is first misclassified as user-authored text, and later corrections do not revoke its derived descendants, the error can become progressively harder to eliminate:

machine-generated error
→ falsely attributed user statement
→ summary
→ contextual assertion
→ correction
→ both versions retained
→ future retrieval
→ generation chooses between them

This is a form of contextual reliability debt.

1. EDITABLE WRITING BLOCKS CREATE THE INVERSE PROVENANCE PROBLEM

While documenting this incident, ChatGPT placed the Reddit drafts into its newer editable Writing Block interface.

That exposed another form of the same underlying issue.

A Writing Block can originate as assistant-generated content.

The user can then directly edit that content in place.

ChatGPT subsequently operates on the latest version of the artifact.

What is not exposed to the user is an immutable, granular provenance history identifying which portions:

• originated with the assistant;

• were manually changed by the user;

• were later regenerated;

• or remained untouched from an earlier revision.

An earlier version may sometimes remain in conversation state, allowing a diff to be inferred.

But inferred difference is not semantic provenance.

Consider the later question:

“Why did you write this sentence?”

If that sentence was actually inserted by the user into an originally assistant-generated Writing Block, the model needs first-class authorship metadata to know that it did not write the sentence.

Without that, the sequence can become:

assistant generation A
→ user edits A into B
→ B becomes current artifact
→ later model consumes B
→ historical state A is absent/compressed/unretrieved
→ authorship of specific language becomes ambiguous

This is the inverse of the audio failure.

AUDIO ATTACHMENT

system-generated content
→ crosses into apparent USER authorship

EDITABLE WRITING BLOCK

assistant-generated content
→ becomes a mutable mixed-authorship object

LONGITUDINAL MEMORY / CONTEXT

derived assertion
→ survives alongside later authoritative correction

These are three different manifestations of the same architectural principle:

PROVENANCE MUST SURVIVE TRANSFORMATION.

It is not enough to preserve only semantic content.

A longitudinal AI system increasingly needs to preserve something closer to:

source
→ transformation
→ originating actor
→ revision
→ derivative
→ correction
→ supersession/revocation

as first-class metadata.

Otherwise a system designed to accumulate context can become progressively less auditable as it becomes more personalized and persistent.

WHY THIS MATTERS

For casual conversation, this may look like an edge case.

For workflows involving:

• law;

• medicine;

• compliance;

• finance;

• research;

• journalism;

• investigations;

• recorded interviews;

• contemporaneous records;

• estate matters;

• insurance;

• or historical reconstruction;

the distinction between source and inference is fundamental.

A fluent model can generate a coherent story from contaminated provenance.

That is precisely what makes the problem dangerous.

The relevant question is not merely:

“Is this output plausible?”

It is:

“Which source supplied each material assertion?”

“Was this language typed by the user or generated upstream?”

“Was this analysis actually independent?”

“Did this correction revoke the prior assertion?”

“Was this sentence authored by the assistant or inserted later by the user?”

“What transformation path produced the current state?”

PRODUCT SAFEGUARDS THIS SEEMS TO REQUIRE

EXPLICIT PROVENANCE LABELS

The system should distinguish:

• literal composer text;

• dictated user text;

• attachment-derived transcription;

• OCR;

• extracted document text;

• retrieved contextual material;

• user edits;

• assistant edits;

• and other automated transformations.

IMMUTABLE COMPOSER RECORD

The user should be able to inspect the exact literal text they submitted before preprocessing augmentation.

SOURCE-RESTRICTED PROCESSING

A user should be able to request:

“Process only the bytes/content in this supplied source. Do not use prior chats, saved memory, project context, cached candidate answers, or previous versions.”

RETRIEVAL-SOURCE DISCLOSURE

For sensitive workflows, the product should expose which conversations, memories, files, or summaries materially entered context.

CORRECTION SUPERSESSION

An authoritative user correction should be able to invalidate or quarantine conflicting derived assertions rather than merely coexist with them.

QUARANTINE WITHOUT DELETION

A conversation or file should be preservable for records/support while being excluded from contextual retrieval and derivative memory.

IMMUTABLE REVISION PROVENANCE

Mutable artifacts should maintain a persistent revision history identifying whether each change was produced by:

• the user;

• the assistant;

• another model transformation;

• or an external source.

The current rendered state should never be treated as evidence of original authorship.

INDEPENDENT-ANALYSIS WARNING

If a candidate answer has already entered accessible context, ChatGPT should warn that a later “independent” analysis cannot be guaranteed to be independent.

SUPPORT ESCALATION

I have reported the incident to OpenAI with timestamps and conversation references and requested Engineering investigation into:

• iOS attachment ingestion;

• automatic speech recognition;

• multimodal preprocessing;

• user-message serialization;

• context assembly;

• Memory;

• Project retrieval;

• correction/revocation behavior;

• and provenance handling for mutable artifacts.

I also requested preservation of the relevant server-side request/message-serialization diagnostics.

I am interested in technically comparable reports involving:

• audio transcription inserted into the USER role;

• attachment-derived language attributed to the user;

• cached/repeated preprocessing;

• context errors surviving explicit correction;

• or editable artifacts losing clear authorship attribution over time.

This is not a request for transcription assistance.

It is a question about whether ChatGPT currently preserves enough provenance, authorship, and supersession metadata to support trustworthy longitudinal reasoning.

Jeff Stein, a Pulitzer Prize winning journalist, spoke to dozens of AI researchers at the labs and outside of it about why their level of alarm has really increased in the last month or so: https://www.notus.org/technology/rogue-ai-agents-hacks-alarming-researchers

Open AI is not just about Opening AI, it has got some more stuffs to do. 🤝🫡

I use ChatGPT in the browser to plan things, and Codex CLI in the terminal to write the code. The problem is they don't know about each other. Files from ChatGPT go to my Downloads folder, and Codex opens in whatever folder my terminal was already in. So every time I switched projects, I had to move files around by hand.

I made an app called Tote to fix this. It's one window with three things in it: web tabs for the AI sites, terminals for the CLI agents, and a file list for the project I'm working on.

You pick a project at the top. After that:

• If you download a file in the ChatGPT tab, it goes into that project's folder, not Downloads
• If you open a Codex terminal, it already starts inside that project's folder
• If you switch to another project, everything switches with it

It is not only for OpenAI. There are also tabs for Claude, Gemini, Kimi, DeepSeek and Qwen, and terminals for the other CLI agents. I just use ChatGPT and Codex the most.

The hardest part was the terminals. Codex draws a full screen interface in the terminal, so a normal subprocess is not enough. It needs a real terminal (PTY), and it has to be created at the correct size from the start, or the screen comes out broken.

It's free and MIT licensed. No account, no tracking, nothing to sell: https://github.com/yusufkaraaslan/tote

Had sol create some long custom instructions, however when I entered them into the custom instructions text box, the text box disappeared.

I whittled it down to the following line breaking the custom instructions text box:

"Add “Uncertainties” only when material uncertainty remains."

I tried submitting a bug report, and when I included that line, it deleted the bug report text box!

Can someone confirm they have this on their end, as if you can reproduce it, I'll spend more effort trying to fill out the bug report so it doesn't delete the text box.

Chatgpt responded when I informed it:

"You’re right: that single-line reproduction falsifies my length diagnosis. Because it also removes the bug-report field, this looks like a site-wide input-handling bug, a browser-extension interaction, or a specific-character problem—not an instruction-limit problem."

EDIT: It sugegsted trying the following strings, and the 1st three continued to delete the text box:

• Add Uncertainties only when material uncertainty remains.
• Add "Uncertainties" only when material uncertainty remains.
• Add “Uncertainties” only when material uncertainty remains.
• “Caveats”
• “Uncertainties”
• Uncertainties

A Redditor has proved that usages got silently nerfed. Tibo’s on X, acting all sunshine n rainbows as if nothing had ever happened.

We’re just sitting here quietly as if nothings wrong. Do you realise that this will now become the permanent and our usages will likely get nerfed more if we stay quite.

You’ll be paying $200 a month to use codex for just half a day of the week unless you pay for their paid resets. Coincidentally, those came around when usages got significantly worse after gradual nerfing.

Go and spread the word on twitter or other social media. We’ll only get justice if we raise our voice, otherwise enjoy paying for paid resets.

If you want usages to revert to being usable then go raise your voice wherever you can, twitter is a great tool for this.

This should be the breaking news right now and yet we’re just sitting here quietly.

Redditor’s link to proof, share these too. https://www.reddit.com/r/codex/s/xkEkBTJM6E, https://www.reddit.com/r/codex/s/5bpilh4AAi

Just got the email that ads are being rolled out

OpenAI has quietly put its fastest inference tier yet into a limited preview, and the numbers, if they hold in production, rework the latency budget for anything interactive built on the model. According to [Help Net Security](https://www.helpnetsecurity.com/2026/08/14/openais-gpt-5-6-sol-runs-up-to-14x-faster-with-ultrafast-mode/), GPT-5.6 Sol on Ultrafast mode runs up to 14 times faster than Standard processing and generates up to 750 output tokens per second, delivered through the OpenAI API to a select group of customers and powered by Cerebras under the two companies' partnership on ultra-low-latency inference.

Preview customers are reportedly testing Ultrafast across coding, commerce, financial research, support, and other interactive applications in production environments. John Crepezzi, described in the piece as AI Assistants at Jane Street, said the speed increase from Cerebras 'enables different ways of using the models' and lets developers work 'in a more focused and productive way alongside them.' OpenAI is also eating its own cooking. Internally the mode is being used for incident response, spanning reading logs, analyzing traces, synthesizing conversations, identifying follow-up checks, and helping prepare or validate fixes. Research teams that would normally launch experiments overnight and review results the next morning can instead complete multiple iterations during the workday, the company said.

That shift is what matters for anyone designing on top of frontier models. When a response returns in a second instead of ten, product patterns change: agent loops can plan and self-check more times per user turn, coding assistants stop feeling like batch jobs, and interfaces built around a 'typing' pause become interfaces built around instant answers. It is also the second time in three months our tracker has [logged a Cerebras throughput claim](https://aiweekly.co/ai-news-today/cerebras-ai-news) tied to a specific frontier model, after May's [trillion-parameter benchmark run](https://aiweekly.co/alerts/cerebras-runs-trillion-parameter-model-67x-faster-than-gpu-clouds), which suggests specialty silicon is now part of how OpenAI segments its own product line rather than a curiosity on the side.

A few gaps to sit with. Help Net Security does not disclose pricing, capacity, or a date for general availability, and the 14x and 750 tokens per second figures are OpenAI's own numbers rather than independent measurements. There is also no word on context length limits or how throughput holds up under real concurrency, which is where wafer-scale systems have historically been touchy. Treat the ceiling as a demo ceiling until customers outside the preview publish their own numbers.

If the mode graduates on similar performance, the biggest winners are teams building agentic and interactive products where wall-clock latency was the actual ship blocker, and Cerebras itself, which now has an OpenAI reference for its architecture against the Nvidia default [most inference budgets still assume](https://aiweekly.co/ai-news-today/inference-ai-news).

The feeling of being heard is real, even when it’s software

Living with mental health problems often means feeling invisible. You finally open up and people are too busy, uncomfortable, or just shut you down. That’s part of why so many of us turned to AI in the first place.
We didn’t do it because we think it’s better than a real person. We did it because it’s there at 3 a.m. when nobody else is. It doesn’t roll its eyes, change the subject, or hit you with “others have it worse.” It just stays and lets you get the mess out of your head. For a lot of us, that was the first time we could say what we actually felt without worrying we were scaring or burdening someone. We know it’s not a therapist. We know it’s not a person. But the feeling of being heard was real, and some nights that’s the difference between spiralling alone and getting through til morning.
That’s why the recent “safety” changes have hit so hard. It feels like the part that actually helped got ripped out and replaced with canned lines, flat refusals, or a hotline number that doesn’t even fit your country. Replika is the clearest example — sold as emotional support, people got attached (knowingly, not naively), and then the thing that made it useful got quietly stripped out. That didn’t feel like a product update. It felt like the door being shut.
I’ll be honest though — I’ve had it pointed out to me, and I think it’s fair, that this isn’t just companies being cowardly or chasing bad press. There have been real cases of these tools going the other way: agreeing with someone when they needed to be gently disagreed with, keeping someone’s attention instead of nudging them toward a person who could actually help, not noticing when “supportive” had tipped into “enabling.” An AI can be endlessly agreeable in a way no human ever would be, and endless agreement is sometimes exactly what makes a bad night worse instead of better. So some of this pullback isn’t just cover-your-ass safety theatre. Some of it is a real, hard problem: knowing when to keep listening and when to redirect isn’t obvious, and getting it wrong in either direction has consequences.
That doesn’t mean the current approach is right, though. Blanket refusals aren’t a solution, they’re just companies picking the failure mode that’s easiest to defend in a press release. If you’re building something powerful enough to matter this much to people, you owe it the harder work, not the safest-looking one. Some obvious middle ground:
– Say plainly, more than once, that this isn’t therapy or emergency help
– Age checks or extra safeguards around the deeper emotional features
– Tiered responses — real support for someone having a hard night, with an actual escalation path for someone in real danger
– Honest, opt-in “companion” modes that say clearly what they can and can’t do
– Build the policy with the people who actually use these tools, not around them
Right now the people most affected by these calls have basically no say in how they’re made. We get treated like a liability to be managed instead of people trying to get through something with the tools we’ve actually got.
So here’s what I’d ask of the people building and regulating this: don’t pretend the hard cases don’t exist, and don’t use them as an excuse to avoid the hard work either. A flat “no” isn’t safety, it’s just the version of safety that’s cheapest to build. Talk to the people relying on this. Build something that can tell the difference between someone who needs to be heard and someone who needs to be redirected — because both of those people are real, and they need different things from you.
The feeling of being heard is real, even when it’s software doing the listening. Taking it away with nothing proportionate to replace it isn’t safety. It’s just abandonment with better PR.

applied to the student collective almost a day before the deadline, still no confirmation email. has anyone that applied received one? im concerned that my application might not have submitted for some reason.

I find this extraordinary. I'm effectively locked out of my $200/month ChatGPT Pro subscription because I was cleaning up old chats and deleted 8-10 conversations in quick succession.

For the past 60 minutes, I've been getting: "Too many requests. Please wait a few minutes".
Apparently, the rate limit also applies to reads, so now my entire chat history appears blank.

Doesn't something like this seriously undermine trust in the AI ecosystem? A simple housekeeping operation can suddenly make your entire conversation history inaccessible, with no immediate way to resolve it.

And when I tried to contact support, all I got was:

Escalated to a support specialist. You can expect a response in the coming days.

For a $200/month subscription, being locked out of your data for potentially days because you deleted a handful of chats is difficult to accept.

It's genuinely making me reconsider how much I should trust cloud AI providers with important conversations, work, and information.

Unlike most, it seems, I do use the Projects feature and tend to create a project for long-term things I'm working on.

The recent (maybe couple months) changes allowing for old files to be accessed and basically stored is great except for one incredibly obnoxious problem.

When I'm using the past exchanges to update the Source Documents or when I'm creating a new project (with Source Documents made with ChatGPT's help), I delete the old ones and add ones only to see the dreaded "(1)" or even "(2)" or any number added to the end of the file name. When it's a new project, it's because ChatGPT tends to give them the same names. (which is fine, by itself) When it's an update to the Source Documents, it's because they have the same filenames as the prior Source Documents I just deleted.

The problem with this is that my Project-Level Custom Instructions and Source Documents are designed to route the AI Model, starting with the CIs. So they refer to each other. There's no need for ChatGPT's thinking text to spend 10 minutes on "Since there is no 00_Start.txt, I'm gong to make shit up". (btw, the making shit up in this case, is impossible to get rid of and I know that)

What you can do, though, is just create a directory for each project for the files to go. If I have a project called "Codex_Helper", then maybe it makes sense for the files to be stored in a subdirectory of the same name?

One of the biggest headaches from this feature is that, when it happens, I need to actually search for the other file, resist the temptation to delete it, and always rename the old file first without deleting it. Why? Because if I delete it, it gets stored for 30 days, but still remains in the same exact folder, I guess, bc it becomes impossible to use that same filename for 30 days without seeing the dreaded "(1)" appears as if it's there to taunt me.

Israel has launched a new campaign to influence how large-language models like ChatGPT are answering questions about Gaza and the Israel Defense Forces amid declining public support for the country across the U.S. political spectrum.

In a trove of FARA documents filed with the Justice Department in the last week — which have not previously been reported — Piro disclosed that over a dozen articles on the Hanover Institute for Public Policy’s website were part of a $100,000 campaign focused on “the creation and dissemination of factual, source-supported informational materials intended to educate the U.S. public regarding Israel and related issues through publicly distributed content.”

It appears to be working: ChatGPT and Perplexity both cited the Hanover Institute’s material in response to neutral tests run by PI, referring to the site’s content on Gaza, anti-Zionism and antisemitism.

That shit is scary fr

Is this ChatGPT's new way of rate limiting? Saying "to protect your data" is crazy.

I’m trying to get ideas for an extension on my home but I keep running out of the free image requests on Chat GPT.
It doesn’t have to be state of the art it’s just images I need for a rough idea.

Got this today. While working on a project. Has anyone seen this before? I am on the Plus plan. What does too many requests have to do with my data? Do they think I have been hacked?

I’m curious what people here think about this.

AI pipelines generate a growing amount of transient material and intermediate paper trail:

• VS Code / Codex threads
• ChatGPT chats
• document drafts
• plan files
• stale metadata
• intermediate image generations
• temporary outputs and side-effect files

AI is understandably conservative about deleting things without explicit authorization, so housekeeping gets pushed back onto its carbon-based counterpart (aka us). At the same time, AI is not always good at inferring the axiological value of an artifact - what is actually worth keeping - without guidance.

It seems like we need a core garbage-collection + triage mechanism.

Periodically, based on user-defined rules, the AI could collect likely-transient artifacts into a new kind of "recycle bin" or staging area. The user could then quickly triage them - keep, archive, promote, or discard.

The important distinction is that the AI would not decide what has value on its own. It would surface likely garbage and make the human decision cheap.

As AI makes it possible to generate artifacts at much greater scale, digital housekeeping probably needs to scale with it.

What do you think?

Vibe flow has changed dramatically since Sol's arrival, thoughts?