NEAR AI Breach: What Was Exposed and Why It Matters13 min read2,583 words

NEAR AI Breach: What Was Exposed and Why It Matters

The NEAR AI breach exposed data from 100 users and 18 agents. Learn what was accessed, why confidential computing fell short, and what users should do.

NEAR AI breachAI data securityconfidential computingSGLang vulnerabilitycrypto privacy
NEAR AI Breach: What Was Exposed and Why It Matters

The NEAR AI Breach Shows Where Confidential AI Can Fail

A system meant to keep AI requests private can still fail if something in the stack goes wrong. NEAR AI said an attacker exploited a vulnerability in SGLang, an open-source engine used to run AI models, and then reached internal systems. The company reported exposed account details for about 100 users, data from 18 older AI agents, and logs that included API keys belonging to two NEAR AI Cloud customers.

What happened matters beyond the raw numbers. NEAR AI provides confidential AI infrastructure and uses trusted execution environments (TEEs) to separate prompts from the operators of the servers. But that protection doesn't make every part of the service invulnerable. If there's a weakness in software running inside the protected environment, the boundary can still be bypassed.

This article sticks to what NEAR AI confirmed, separates it from what remains possible, and explains why hardware-based isolation wasn't enough here. It also offers practical steps for users and teams building AI services. Finally, it places the incident in context: the issue involved AI service infrastructure, not proof of compromise of the NEAR blockchain itself.

What happened in the NEAR AI breach

NEAR AI said an attacker exploited a remote code execution vulnerability in SGLang, software used to serve AI models and generate responses to user requests. Remote code execution is a serious category of flaw: if attackers have the right access, they may be able to run commands on a system, not just view data or send a normal request.

In the company's November 9 incident report, NEAR AI said the attacker first gained access to an inference server. From there, investigators traced the intrusion into other parts of NEAR AI's infrastructure. The report also links the activity to an internal system connected to Private Chat, a feature NEAR AI said it had already retired.

NEAR AI described more than one kind of data exposure. The attacker downloaded account information for about 100 users and accessed 18 agents on an older deployment of NEAR AI Agents. The logs also included API keys for two Cloud customers. NEAR AI said it revoked those keys.

Timing is part of the story, too. NEAR AI said that requests handled in confidential mode on November 8 may have been visible to the attacker. That's something the investigation identified as a possibility, not a confirmation that every such request was read or copied. The company also said it found no indication that stored Private Chat conversations or uploaded files were accessed.

It's worth getting the scope right. The report is about a breach of AI service infrastructure. It does not say the NEAR blockchain, user wallets, or blockchain transactions were compromised. In other words, the affected assets were account records, legacy agent data, and credentials - rather than on-chain funds.

Why the entry point matters

An inference server sits right where users feel the service: prompts go in and model outputs come out. If that layer is flawed, it can create consequences that go beyond an ordinary application bug - especially if the server can reach other internal systems while processing sensitive requests.

That "one server to more systems" path is a key detail. It's also the kind of thing security reviews can miss if they focus only on whether a model-serving component is patched, rather than what it can reach if it's compromised.

What information was exposed

NEAR AI reported several categories of data, and they shouldn't be treated as interchangeable. Some exposure was confirmed. Other risks were described as possible. And the company said it found no indication that certain stored content was accessed.

For about 100 users, the attacker downloaded names and email addresses. The report says subscription plan and account balance information were included for some users, but it doesn't claim every affected account had all of that detail.

The attacker also accessed 18 agents on an older deployment of NEAR AI Agents. NEAR AI said the attacker retrieved their chat histories, settings, and logs. Importantly, NEAR AI said those agents weren't running inside its confidential computing environment, meaning the privacy protections associated with that environment wouldn't automatically apply to this legacy deployment.

NEAR AI logs also contained Cloud API keys for two customers. API keys act as credentials - applications use them to authenticate to a service. If a key is exposed, the impact depends on what permissions it grants, whether it stayed active, and whether anyone actually used it. NEAR AI said it revoked both keys, but it didn't say whether the attacker used them first.

What NEAR AI said was not found

NEAR AI said investigators found no indication that stored Private Chat conversations or uploaded files were accessed. That's a meaningful result, but it's not the same thing as proving nothing sensitive was at risk somewhere in the broader system.

The company also warned that confidential-mode requests processed on November 8 may have been visible during the intrusion. The report doesn't establish that those live requests were actually accessed. A careful reading has to keep "may have been visible" separate from "were read."

For users, the most useful breakdown is:

  • Confirmed: account details for approximately 100 users were downloaded.
  • Confirmed: histories, settings, and logs for 18 older agents were retrieved.
  • Confirmed: logs exposed API keys for two Cloud customers; NEAR AI revoked them.
  • Possible: confidential-mode requests processed on November 8 may have been visible.
  • No indication found: stored Private Chat conversations and uploaded files were accessed.

That's more helpful than a headline number, because different data types lead to different next steps. Account holders should watch for targeted messages, while API-key customers should review credential use and activity in their own systems.

Why confidential computing did not stop the attack

NEAR AI Cloud uses TEEs to keep AI prompts encrypted and isolated from the server operator while models process them. The point is to reduce how much a customer has to trust the company running the hardware.

But a TEE isn't a complete end-to-end security plan. It can reduce certain risks - like an infrastructure operator reading raw prompts - while leaving a separate risk: vulnerabilities in the software running inside the protected environment. In this incident, NEAR AI acknowledged that confidential computing wouldn't protect against a vulnerability in software inside the TEE.

That's the main technical takeaway. If a vulnerable model-serving component can be pushed into running attacker-controlled commands, encryption at the hardware boundary doesn't automatically make the system safe. The application still has to work with plaintext to do anything useful. If the code handling that plaintext is compromised, the attacker may be able to interfere with processing or reach other connected resources.

A useful way to think about the security layers

Confidential AI is better understood as multiple controls with different jobs, not a single privacy switch:

  1. Hardware isolation separates workloads from the host and its operator.
  2. Application security determines whether the code processing requests can be exploited.
  3. Identity and access controls limit what a compromised service can reach.
  4. Logging and monitoring help detect unusual activity and support investigation.
  5. Credential management limits damage if tokens or keys end up in logs or get exposed elsewhere.

A strong setup needs all of those. A TEE can reduce some risks, but it doesn't patch SGLang, restrict every internal connection, or automatically revoke a credential that ends up in logs.

This lesson carries beyond AI cloud. Security claims only matter when they spell out what threat they cover. Saying data is encrypted or isolated doesn't answer whether the software processing it is secure, how access is constrained, or how quickly exposed credentials can be contained after an incident.

What the incident means for AI and crypto privacy

This breach is a reminder that privacy is an operational outcome, not just a feature label. NEAR AI is part of the broader NEAR ecosystem and has talked about confidential AI alongside its blockchain goals. The incident doesn't suggest blockchain itself "failed." It shows that services built around blockchain ecosystems still rely on conventional software, infrastructure, credentials, and incident response.

That distinction matters for people evaluating privacy claims. Blockchains provide public, verifiable transaction records, but an AI service tied to that ecosystem processes private prompts off-chain. Those prompts live or die based on the AI service's architecture and operations, not on the security of a ledger that isn't processing the requests.

There's also a gap between what a product offers now and what older deployments still run. The 18 affected agents were on an older deployment and weren't running inside the confidential computing environment. A user might reasonably assume a service-wide privacy promise applies to every feature and version. The incident is a practical warning that teams have to say exactly where the protection applies: which workloads are covered, which are legacy, and where data is stored or logged.

In October, NEAR AI said Brave's Leo browser assistant was using its confidential inference infrastructure for a supported AI model. The incident report doesn't identify Brave users among those affected. So it's not evidence that Brave accounts or requests were compromised. Still, it's a good example of why customers adopting a privacy-focused service need clear information about the exact product paths and deployments they're using.

Why this matters to institutions and regulators

For companies considering confidential AI, the right question isn't only whether a provider uses TEEs. Buyers should ask about the full control environment: patching, access boundaries, retention, logging, key rotation, incident notifications, and evidence from security reviews.

For users in the US, UK, and elsewhere, familiar data-protection questions come up again: what information was involved, who was affected, and what notifications are required. NEAR AI said it notified users whose account details or agents it confirmed were accessed and said it would make any required regulatory notifications. The report doesn't map directly to a specific legal violation, and notification duties depend on the facts and the rules that apply.

This is where real institutional adoption gets earned. Privacy infrastructure has to be backed by operational controls and precise disclosure. A "guarantee" that leaves out the boundaries can create more risk than it removes, because customers may assume protections cover areas they don't.

What users and infrastructure teams should do

NEAR AI said it revoked active sessions and administrative credentials, replaced agent tokens, took Private Chat offline, and deployed a fix for the SGLang vulnerability across its inference servers. It also said it finished rotating remaining credentials and completed a forensic review. NEAR AI added that it notified users whose account records or agents it confirmed were accessed and contacted the owners of all 18 affected agents.

Those steps focus on containment and recovery. For affected users, the remaining work is mostly defensive, and it should match what was actually exposed.

If you used NEAR AI

  • Treat unexpected messages with caution. NEAR AI warned users to watch for unsolicited messages referencing their account or balance. Don't share login details or credentials in response to a message that claims to offer help.
  • Review account activity. If you were notified, check for unfamiliar sessions or account changes and follow the company's instructions for securing your account.
  • Rotate credentials you control. If you used an exposed agent token or related key elsewhere, replace it there too. Revoking a key at one service doesn't update copies stored in your own apps.
  • Check billing and usage where relevant. Cloud customers should review their own service activity and contact the provider if they see usage they can't explain.
  • Don't assume every request was exposed. The report distinguishes confirmed access from possible visibility of confidential requests. Use the notice you received and the provider's current guidance to judge whether you were affected.

If you operate AI infrastructure

This incident suggests a practical review sequence for any service that handles confidential prompts:

  1. Inventory every deployment. Identify legacy agents, retired features, and services that still have credentials or internal connections.
  2. Patch and verify model-serving software. Track the versions of inference engines running in production, apply fixes, and confirm the patched version is actually deployed across the fleet.
  3. Reduce blast radius. A model server should only have the network access and permissions it needs. If one process is compromised, it shouldn't automatically inherit broad access to internal systems.
  4. Keep secrets out of routine logs. Use narrowly scoped credentials, redact sensitive values, and ensure rotation is fast enough to execute during an incident.
  5. Test the response path. Know how to revoke sessions, replace tokens, disable a feature, preserve evidence, and notify customers - without waiting for a long cross-team process.
  6. Describe privacy boundaries precisely. Spell out which products use confidential computing and whether legacy features, stored data, logs, or customer-managed integrations follow different controls.

A mature response isn't just "did we deploy a fix." It also depends on whether teams can establish what was reached, separate confirmed access from uncertainty, and close the paths that let one compromised service move into others.

Conclusion

The NEAR AI incident doesn't invalidate confidential computing, but it shows where that technology has limits on its own. Hardware isolation can reduce exposure to server operators; it can't compensate for vulnerable software, overly broad internal access, or credentials left in logs.

For users, the key is to distinguish confirmed access from possible exposure and protect accounts and credentials accordingly. For AI providers and institutional buyers, the bigger lesson is to evaluate the full system - software, permissions, legacy deployments, monitoring, and incident response. Privacy claims are only as strong as the weakest layer that actually handles the data.

Frequently Asked Questions

The incident report describes access to NEAR AI infrastructure after an attacker exploited SGLang. It does not report a compromise of the NEAR blockchain, wallets, or on-chain transactions. The disclosed exposure involved user account details, older AI agent data, and two Cloud API keys.
NEAR AI said account details for approximately 100 users were downloaded, including names and email addresses, with plan and balance information for some. Data from 18 older agents included chat histories, settings, and logs. Logs also exposed API keys belonging to two Cloud customers.
NEAR AI said confidential-mode requests processed on November 8 may have been visible, but the report does not confirm that they were accessed. The company found no indication that stored Private Chat conversations or uploaded files were accessed. Those are distinct findings and should not be conflated.
Follow any direct notice from NEAR AI, be wary of unsolicited messages referencing your account or balance, and review relevant account or service activity. If you reused an exposed token or key in another system, rotate it there as well. Cloud customers should check for unfamiliar API usage.

Related articles