For business, this story is not about “another big AI service got hacked.” It is much closer to the day-to-day work of teams that are adding AI to products, admin panels, and internal workflows.

What happens when we allow AI to generate interactive interfaces, run code in the browser, connect to APIs, and work alongside private customer data? That’s where the uncomfortable part begins.

Imagine an e-commerce store building an internal AI assistant for managers. It assembles mini dashboards, shows orders, and opens customer profiles. Or a clinic where an AI agent helps the receptionist quickly find patient records. Convenient. But if that interface is isolated badly, one pretty HTML insert can become a doorway into data.

The problem wasn’t the model, but the HTML preview around it

As Simon Willison writes, researchers at Parameter Labs described an exploit in the ChatGPT implementation of the so-called artifacts pattern. OpenAI previously called it Canvas, and in its newer form it appears to be HTML previews.

The idea behind the feature is straightforward: ChatGPT can display interactive HTML apps inside an isolated iframe. On paper, that sounds right. Untrusted HTML is supposed to live in a sandbox and stay away from the main page, OpenAI APIs, and the user’s private data.

But the researchers found a chain where several seemingly minor decisions added up to a serious hole.

In ChatGPT, the MathLive library was used for charts. It has its own virtual keyboard, which could be triggered in the parent page via postMessage() from a sandboxed iframe. The code handling those messages used innerHTML. That allowed arbitrary HTML to be injected into the parent page. There was no protection preventing other isolated frames, including the HTML preview, from calling this mechanism.

On its own, innerHTML does not execute script tags directly. But it was enough to inject a new iframe without sandbox restrictions.

Then another detail kicked in. OpenAI’s CSP blocked inline scripts and allowed code to be loaded only from a few domains. One of them was YouTube. Through YouTube’s oEmbed endpoint, JavaScript could be reflected in a way that allowed it to execute.

Once JavaScript was running on the ChatGPT page, the attack could call private user APIs and exfiltrate data through an image reference. In the end, an attacker could create a share URL that, when opened by a logged-in user, stole private data or performed actions on their behalf.

OpenAI fixed the issue and paid a $5,000 bug bounty. Willison считает that amount far too low for a vulnerability of this level.

What this means for your SaaS, agent, or internal admin panel

For product owners, this is the real takeaway. The risk doesn’t stop with ChatGPT. If your team is building a SaaS product, an internal AI console, agents in n8n or Make, a document-based RAG interface, or an HTML report generator, you need to look beyond prompts.

A minimal practical checklist looks like this:

  • isolate HTML previews on a separate origin, not next to the main application;
  • validate postMessage: who can send messages, from which origin, and with what payload;
  • avoid innerHTML where you can work with safer DOM APIs;
  • do not rely on CSP alone, because domain allowlists can still have non-obvious bypasses;
  • separate access tokens: previews and agents should not automatically see everything the user can see;
  • for actions taken on behalf of a person, require confirmation, especially when payments, customer data, or CRM changes are involved.

For a marketing agency, that means an AI landing page generator should not have access to every client account. For a delivery service, an internal agent that shows routes should not be able to change order statuses without additional permission. For a startup, share links should be treated as an attack surface, not as a harmless convenience feature.

Our position at Artica is simple: AI interfaces should be designed as products with dangerous zones, not as “just a chatbot.” A good place to start is auditing every spot where the model or the user can inject HTML, open an iframe, call an API, or pass data between windows.

That is less flashy than a demo on stage. But this kind of boring engineering is often exactly what saves a business from expensive surprises.