NEAR AI disclosed on 9 November that an attacker had exploited a remote code execution flaw in SGLang, the open-source inference engine, and reached one of its servers the day before.

The company's own description of what that means is the clearest statement of the problem anyone has written this year. A trusted execution environment, NEAR AI said, does not protect against a vulnerability in the software running inside the environment.

Which is exactly right, and exactly the thing the entire confidential-computing pitch tends to blur.

What a TEE actually promises

A trusted execution environment protects your workload from the machine it runs on. The cloud provider cannot read the memory. A compromised hypervisor cannot read the memory. An administrator with physical access cannot read the memory. That is a real and valuable guarantee and the hardware delivers it.

What it does not do is make the code inside the enclave correct.

If the software you put in the enclave has a remote code execution flaw, an attacker who exploits it is now inside the protected boundary, running with the enclave's privileges, looking at the enclave's plaintext. The hardware is working perfectly. It is faithfully protecting the attacker's code from the cloud provider.

So the guarantee inverts. The same wall that stops the host from looking in also means the attacker inside is harder for anyone outside to observe. NEAR AI says the attacker could have seen requests being processed on that server that day, including requests sent in confidential mode — the mode whose entire purpose is that nobody can see them.

The rest of the incident

Beyond the enclave itself, the attacker reached eighteen AI agents running on an older deployment that was not inside the TEE, taking chat history, settings and logs.

For around 100 users of Private Chat, email addresses and names were taken, and for some accounts plan and balance information. NEAR AI says it found no indication that stored Private Chat conversations or uploaded files were accessed.

Two customers' API keys were exposed in logs and have been revoked. Which is its own small lesson: the keys were not stolen from a vault, they were sitting in log output, which is where keys usually end up.

The part that should not be allowed to pass

NEAR AI reported the flaw to the SGLang project. It has not identified it by CVE number. It has not named the affected versions. It has not said whether a fix has been released.

SGLang is open-source infrastructure used by a great many organisations to serve models. Every one of those operators read this disclosure, and not one of them can determine whether they are exposed, because the three facts required to answer that question are all missing.

This is the gap that turns one company's incident into everybody's problem. NEAR AI handled its own users reasonably: prompt disclosure, a clear statement of what was and was not accessed, keys revoked, an honest sentence about the TEE that most companies would have avoided. All of that is better than average.

And then the one piece of information with value beyond its own customer base was withheld, or at least not published. If the flaw is unfixed, saying so is how other operators know to take mitigations. If it is fixed, saying which version is how they know to upgrade. Either way the information helps and its absence helps nobody except an attacker working through the other deployments.

The wider point about this layer

We wrote earlier this week that half of all AI-related vulnerabilities sit in orchestration and serving infrastructure, and that exactly five such flaws appear in CISA's exploited-vulnerabilities catalogue, three of them in a single proxy product.

This is what the sixth looks like before it gets catalogued. An inference engine, holding plaintext requests, reachable over the network, written fast in a fast-moving field, deployed by people who reasonably assumed that putting it in an enclave was the hard part of the security work.

The enclave was the easy part. The software inside it is the attack surface, and it always was.

What is not established

  • We did not retrieve NEAR AI's own incident report. The quotations and figures here come through reporting of it and should be checked at source.
  • Which SGLang flaw was used. NEAR AI has not said. There are publicly known SGLang remote code execution issues, and coverage notes there is no basis for connecting any of them to this incident.
  • Whether the flaw is fixed, and in which versions.
  • What was actually observed as against what could have been observed. NEAR AI's language is about capability, not confirmed access, and that distinction is doing real work in the disclosure.
  • Whether any third-party service running on NEAR AI's infrastructure was affected. One assistant product is reported to have used a NEAR AI enclave, and NEAR AI has not said whether the compromised server handled any of its traffic.
  • Whether the older non-TEE deployment should have been retired, and why it was still serving eighteen agents.