GPU-less, Trust-less, Limit-less: Reimagining the Confidential AI Cloud - Mike Bursell

AI is transforming everything: healthcare, finance, automation, digital marketing. But one thing holds it back, and that's trust. How do you run models on sensitive data without handing it over? How do you deploy proprietary models without losing control? And how do you collaborate, especially in non-deterministic environments, without relying simply on blind trust?

Well, that's what Confidential AI solves, and that's what Super Protocol makes real: GPU-less, trust-less, limit-less. And this session is about what those words actually mean, and how developers can apply them to run scale and monetize AI workloads securely.

So, whether you're building with sensitive data, proprietary models, or untrusted partners, you'll see how Confidential AI opens up new possibilities. We'll start by breaking down the core technology behind Confidential AI, and then walk through a number of real demos to see how it works in practice.

Let's start with the foundation: Confidential Computing. This solves one of the most overlooked problems in AI today, which is that your data and your model are most vulnerable not when they're stored or in transit, but while they're being processed, whether that's during training, fine-tuning, or inference.

And that's where Trusted Execution Environments, or TEEs, come in. At the hardware level, a TEE is a secure and isolated part of the processor, like Intel TDX or AMD SEV SMP or NVIDIA GPU TEEs. It creates what's called a confidential environment, where code and data are protected even during execution.

The chip itself provides the isolation, using instructions built into it during manufacture. So, once a workload enters this environment, it's protected in memory, invisible to the host OS, hypervisor, or in fact even anyone with system access, even the owner of the hardware.

And it's not just about isolation. A TEE also generates a cryptographic attestation. That's a signed proof that the workload ran inside verified hardware using unmodified code. This is important for two reasons. Not only do you need strong assurances that the workload is truly protected by the hardware, but attestation also allows us to make statements about what the workload actually is.

So, attestation lets you know not only what's in the TEE, but also that it's a real TEE in a properly manufactured, TEE-capable chip. Because if you can't be sure of those two facts, then you can't be sure of anything about the workload or what it's processing.

So, in short, a TEE lets you run sensitive computations securely and prove that they ran as intended. And that changes everything. It means we can now run AI models even on sensitive data without exposing the model or the data.

That's the foundation of what we call Confidential AI. Let's look at where and why you might care about this. In particular, what about some real-world problems that developers face, and why is this shift to Confidential AI critical? We'll start off with healthcare.

If you've ever tried to build or fine-tune a medical AI model, you know the hardest part isn't the model, it's the data, and not processing it, just getting it, or permission to use it in the first place. Hospitals and labs just don't share raw datasets, even if your model could improve patient outcomes.

In research, access to clinical data is tightly controlled, expensive to generate, and often siloed. You can't just bring your model to the data, not under current regulations or security policies. This all means that trying to train medical AI models on real data can take months of negotiation to get access to even small datasets, and working across datasets from multiple providers can be well-nigh impossible.

This is what Confidential AI can help solve. Another topic: personal AI agents. Those are the ones that manage your inbox, calendar, or documents, and they're already being built. But mass adoption is still out of reach. Why? One of the main reasons is because these agents need deep access to private, sensitive data to be truly useful.

That triggers concerns across the board. Users don't want to expose their personal data. How can I be sure it's not being shared? Developers don't want to store it. How can they protect it from being stolen or misused? Enterprise and regulators won't greenlight this use without strong guarantees.

How can we all be sure that we won't be sued? Confidentiality isn't a nice-to-have. It's the missing piece that's actually holding back real-world adoption of these technologies. Our next example is digital marketing. In digital marketing and customer analytics, everyone wants to fine-tune models on real user behavior, tracking how users interact with various websites, content, and online services.

But between privacy laws, internal security rules, and basic ethics, working with that data often risks upsetting regulators and auditors or is downright blocked. It's a massive gap between what's technically possible and what's actually allowed.

What about AI model monetization? Let's say that despite the various complications and regulations that need to be navigated, you've built a domain-specific model for legal, medical, or financial use. Of course, you want others to use it, and you want to get paid for it.

But you're not willing to give away your model or its weights for free, which you risk if you allow people to run it themselves without protection. At the same time, customers aren't willing to expose their sensitive data, not for testing, not for production, so they won't trust you to run your model with their data.

In other words, both sides want the benefits without giving up control. The good news is, with Confidential AI, neither party has to relinquish that control. Let's talk about model training and proof, because there's another typically overlooked problem, and that is provenance.

The key question is simple. Even if you have managed to train or fine-tune your model on sensitive data, how do you prove its provenance, allowing users to track back to the initial datasets? In other words, how can you guarantee that a model was really trained where and how you say it was?

With a tested execution, this becomes possible. The provenance of the data can be assured with proof that the answers or outputs that you get at the inference stage relate back to the initial datasets and only the original datasets.

In all of the cases we've just discussed, traditional cloud setups fall short. They're built on trust and legal contracts, not on provable guarantees. These limitations are exactly why we built Super Protocol, to make Confidential AI not just possible, but usable.

What we're going to do next is walk through how it works and what it unlocks. It's time to talk about Super Protocol. What is Super Protocol? Super Protocol is a confidential AI cloud and marketplace built for secure collaboration and monetization of AI models, data, and compute.

What are some of the pieces? First of all, we have a TEE-agnostic infrastructure. What does that mean? Super already runs on Intel, NVIDIA, and AMD TEEs, and as major chip makers continue to include TEEs as a core part of their strategy, we'll support those platforms too.

It means edge-ready architecture. We've validated ARM Confidential Computing via ARM 9 emulation, confirming full compatibility with our architecture. As ARM 9-based chips roll out broadly across Android devices, now 70% of the smartphone market, we aim to deliver end-to-end Confidential AI from personal edge devices straight to the cloud.

We're built on swarm computing principles, which means that we scale across distributed GPU nodes with no single point of failure and automatic workload redistribution in case of server downtime. We're fully decentralized with no human intervention, entirely orchestrated by smart contracts on BNB chain.

There's no barrier to entry, zero barrier entry, because you don't need TEE expertise to run or attest the workloads.

Maybe best of all, all parts of Super Protocol will be open source, because it's a protocol, not a service. Think about the HTTPS protocol. It keeps your data safe when you send that data online. Super Protocol does the same but for AI.

It protects your data while AI is working on it. It sets a new standard for keeping data safe during AI computing. What do we mean by GPU-less? This isn't about removing GPUs. It's about removing dependency. Because with Super Protocol, you can run accelerated AI workloads across independent GPU nodes without being locked into any cloud vendor or centralized provider.

You don't need to buy GPUs, nor do you need to rent them for longer than you're using them. Whether you're training on your own server or accessing GPUs through the marketplace, you keep control.

Thanks to the nature of TEEs and Super Protocol's open source architecture, no unauthorized access is technically possible. Not by the hardware provider, not by Super Protocol, not by any third party. That's what makes confidential computing the foundation of trustless AI.

Then there's limitless. Limitless is about removing the blockers, the legal, the technical, and the organizational barriers. With Confidential AI, you're not limited by policy, regulation, or infrastructure constraints. Because traditional cloud platforms impose limits on data, on geography, and on control.

You can't access GPU instances without approval. You can't access sensitive datasets, collaborate across borders, or monetize your model without handing it over. Traditional clouds are especially unfit for agentic, non-deterministic AI, where autonomous agents interact, make decisions, and evolve in real time.

Most cloud environments just weren't built for that kind of dynamic multi-party logic. Super Protocol removes those limits. You can train, deploy, and monetize AI across organizations and jurisdictions with full confidentiality and ownership. Agents can compute, communicate, and adapt without predefined scripts or centralized control.

Confidential, permissionless, limitless. Now let's look at two great end customer case studies from digital marketing and the healthcare industry. Digital marketing first. Imagine Mars, your favorite confectionery company, running hundreds of ad companies all over the world. The digital global ad market is massive, worth around $600 billion a year, but every week ad wastes budget.

Realize is a company that uses AI to measure how people react to ads by analyzing tiny facial expressions. They help brands like Coca-Cola and Mars choose ads that really, truly connect with people. But to make their AI even more accurate, Realize needed much more biometric video from external partners, and that's where the problem started.

Privacy laws like GDPR and CCPA, along with concerns about data ownership, made providers reluctant to share sensitive footage. For its Mars project, Realize used Super Protocol's Confidential AI Cloud. AI training ran inside secure environments, in other words, TEEs, using powerful chips like NVIDIA's H100s and H200s and Intel Xeons.

Every step was automated by smart contracts and verified by both the hardware and Super Protocol's open source certification, which meant that throughout the process, the data and the models stayed completely secure, proven to be inaccessible even to the cloud provider, to Super Protocol, or to Realize themselves.

Verifiable confidentiality changed everything. Because once providers knew their data was truly protected, they shared four times more sensitive footage, growing the training set by 319 percent. With that boost, accuracy jumped to 75 percent, on par with human-level performance.

To Mars, it paid off, a 3-5 percent sales increase across 30 brands in 19 markets. The takeaway: when data privacy is provable, locked data gets unlocked, powering better models, smarter AI, and real business impact. That's the Super Protocol advantage, transforming privacy into performance and confidence into revenue, not just for digital marketing, but for every data-driven industry.

Now it's time to talk about healthcare. In fact, let's talk about BEL, the Brain Electrophysiology Laboratory. They were racing to submit a new epilepsy diagnostic device to the FDA. BEL creates advanced medical devices and AI tools to help diagnose epilepsy and sleep disorders.

But to get FDA approval, they needed to submit perfect documentation. That usually takes two to four weeks of manual audits, multiple NDAs, and carries the risks of exposing trade secrets. Even one small mistake could cause a 120-day delay in review, slowing down patient access and return on investment.

They wanted to speed things up using Tritonic's AI-powered audit tool. But they had one concern, one big concern: how to keep BEL's data and Tritonic's model safe from exposure in traditional cloud environments. The answer: Tritonic used Super Protocol's Confidential AI Cloud.

The audit ran inside secure hardware environments in TEEs using NVIDIA H100 and H200 GPUs and Intel TDX CPUs. Every step was automated, orchestrated by smart contracts, and backed by cryptographic proof. All files and models stayed encrypted, only readable inside the secure environment and completely hidden from Super Protocol, BEL, Tritonic, or anyone else.

The results were huge. Audit time dropped from weeks to just one to two hours. There was zero risk of leaks. Both BEL's and Tritonic's IP stayed fully protected, and there were no re-review delays, cutting out those 120-day setbacks.

The bottom line: Super Protocol helped BEL move faster, stay secure, and deliver life-saving tools to patients much sooner. It proves that when confidentiality is guaranteed, even the most sensitive and high-stakes processes, like FDA clearance audits, can be transformed.

That's the Super Protocol advantage. You want to see a demo, don't you? Let's focus on the practical part of today's session so that you can see and feel how this works in action. Remember, Super is a confidential AI cloud and marketplace built for secure collaboration and monetization of AI models, data, and compute.

Our first demo is of the Super AI Marketplace. We'll start with an overview of its interface and core value prop, and then walk through a step-by-step demo of deploying an AI model in just a few clicks, entirely with a fully confidential environment.

Let's begin the marketplace demo with a short overview of the highlights. The Super AI Marketplace is built on a confidential and decentralized architecture. There are no centralized components or data centers. A blockchain-based ecosystem is used to manage the relationships and financial settlements between the participants.

Providers of AI models and datasets, providers of confidential computing hardware, and the clients. Confidential computing ensures that the models remain private and authors retain full control and ownership. Models may be leased but not downloaded. Nobody has access to the Trusted Execution Environment, TEE, during processing, which means that the models and the user data are off-limits even to the clients.

The models are deployed in the TEE and are accessible via a link or API. One of the goals of the marketplace is to enable monetization for authors of closed-source models. A variety of scenarios are offered: per hour, fixed, and revenue sharing.

Now let's do a speed run-through of the marketplace UI and deploy one of the models. The marketplace supports two login methods, Web3 and Web2. Let's log in through Google.

This is the main marketplace of the models available for deployment in a variety of categories or tasks. You can also deploy or publish your own model. The published models will remain confidential and not be available for download. In this demo, we will deploy one of the published DeepSeek models.

As you can see, there are many variants.

Let's take this one. You can see the description here and also a variety of quantizations, requirements, and pricing scenarios.

Let's deploy on the H100 GPU. The order is assembled automatically, but you can also modify it manually to adjust the compute configuration. Let's deploy now. The order is now being created on blockchain.

The order is now being prepared for deployment. The engine and the model will be downloaded into the confidential computing environment and get ready for execution. About 20 minutes have passed. The order is now deployed at this link. You can also deploy as an API and integrate into your own app, and you can also set up your own domain.

This is the text generation web UI interface. Here you can interact with the DeepSeek model.

Allright, and now one final step: verification. Let's copy this link.

Now we input the link into this tool. It verifies that this model is deployed in a confidential environment, that the connection is encrypted, and that the AI engine has not been tampered with.

In the next demos, we will show the many more features and capabilities of Super Protocol. Thank you.

Now let's move to something more dynamic. Agentic AI is gaining traction across industries. Let's see how agentic automation can be built and run inside Super Protocol.

Let's explore how to build secure, automated AI workflows for processing sensitive medical data using n8n, deployed on Super Protocol. By running everything inside TEEs, inaccessible even to server admins or Super Protocol, and combining low-code automation with a decentralized infrastructure, we deliver fully confidential, compliant, and verifiable medical AI.

In this demo, we will review a simple use case. A doctor uploads an X-ray image and the patient's personal data using a protected web form. That image, along with metadata, is passed into an automated workflow built with n8n, which runs inside a TEE on Super Protocol.

The workflow cleans the input data, invokes an AI model to analyze the X-ray, and generates a structured medical report. That report is then emailed securely to the doctor.

Let's take a look at the system in action. We've already deployed n8n on Super Protocol. Once deployed, the platform gives us a secure access link. Opening this URL brings up the n8n user interface. In production, this direct UI access is disabled.

Every interaction goes through secure APIs, web forms, etc. We register or log in and enter the n8n dashboard. Instead of building a workflow from scratch, that will take some time; we'll import one that's already been prepared. For the workflow to run, we need to add some credentials in the Credentials tab: API keys to access the AI model deployed on Super Protocol or elsewhere, Gmail credentials for sending email reports.

These are securely stored and isolated inside the TEE. We will add those behind the scenes. This example workflow is simple but demonstrates all the core ideas: image processing, data sanitization, AI analysis, and automated reporting. Here's how the workflow runs.

The webhook trigger starts the workflow automatically when data is submitted via the web form. Data extraction pulls out the uploaded X-ray and metadata, the patient's ID, name, age, and clinical information, as well as the doctor's name and email address.

Then, personal data is separated from diagnostic input. The AI model receives only the X-ray and symptom description necessary to generate a diagnostic result. This result is combined with the patient's personal data to form a medical report in text, HTML, or JSON.

The latter may be needed to easily integrate the workflow with hospital systems or ERPs. The report is sent to the doctor's Gmail and also posted back to the web form endpoint. Let's quickly walk through the n8n's user interface.

We've already seen the Workflows tab. It's where you build or import automation flows. Nodes in n8n are highly customizable and allow you to make API calls, respond to webhooks, and write any JavaScript in your workflow. In the Credentials tab, you can securely manage API keys and login details.

In the Executions tab, you can view current and past runs, successes, errors, and debugging data. To debug, switch the workflow to inactive. Let's submit a sample form with a test X-ray.

Watch each node execute step by step.

We can inspect the inputs and outputs of each node: image, metadata, AI result, etc.

Confirm that the form receives the response and the email arrives in the inbox. Everything works within a secure, confidential environment. To conclude, this solution easily adapts to other use cases: CT scans, MRIs, ECGs, and even lab tests in minutes.

With n8n's visual builder, secured by Super Protocol's TEEs. No more choosing between functionality and privacy. Confidential AI made simple.

Let's look at scaling. You'll see how Super Protocol enables distributed inference using vLLM across multiple GPU servers without relying on any single provider. This is where GPU-less becomes real.

For this demo, we're distributing inference of a large language model across multiple GPU servers using vLLM. Under the hood, vLLM partitions the model by layers and assigns each layer's computation to a different node in an overlay network. Great for memory efficiency and throughput, but by default, those machines run in unprotected environments, exposing your data, model code, and intermediate state to host operators.

Here's how Super Protocol secures it. Every vLLM node runs inside a confidential VM powered by TEE hardware, all tied together over a private overlay network. Data, model weights, and intermediate activations are decrypted and processed only inside each confidential environment, with all inter-node communication encrypted so no sensitive material ever leaves the secure boundary or is exposed to any host.

Now let's see this in action. Launch distributed vLLM inference in confidential mode and retrieve the execution report. In our demo, we have four host owners: Alice, Bob, Carol, and David. They provide TEE hardware with GPU H100 200s to Super Protocol.

That allows running a single large LLM across four GPU nodes in fully confidential mode on Super Protocol.

Our custom Dockerfile is based on the official vLLM repository. We added a short helper script that can launch vLLM in different modes. Head in Workers. We also prepared configuration files for each mode since we need to run all four participants in different roles.

First, let's build the Docker image using the build command.

Next, let's export the built image to a Tarble archive, which we'll need for the next step.

Then, let's upload the archive into decentralized storage using a Super Protocol CLI tool called SPCTL. Now it's ready to run on Super Protocol.

We've prepared four SPCTL configuration files, one per participant. First, we launch the master node head, which accepts all incoming connections. Since all orders are in the same overlay network and we know the internal IP addresses, this is easy to do.

Alice runs her vLLM to start the head node.

Super Protocol launches her confidential environment and returns an order ID.

Next, let's launch Bob and Carol in regular worker mode, and they automatically connect to Alice's head node and share GPU cycles.

David's node is special. His node configuration file not only sets the mode, worker, but also specifies which model to run. In this case, it's Mistral with 22 billion parameters. Points to the domain with an SSL certificate and private key for secure connections.

Includes the head node's address so it can join the overlay. Launches the model inference in addition to being a worker. This parameter shows that the setup uses four GPUs connected together. We preloaded the Mistral model so that the hybrid node can immediately launch inference across all four GPU hosts in one confidential workflow.

Here, Alice, Bob, Carol, and David are simply the owners of those hosts. The job itself runs across their combined resources. All four orders have deployed successfully. We can download the on-chain reports and verify that the image and model hashes match what we expect.

We can do this verification for each of the four participants. Each report passes integrity checks, confirming that the orders contain the correct model and application.

Finally, let's test the public endpoint. Anyone can access the provided domain, verify that everything works, and make requests. Since processing is parallelized across four machines, responses return much faster than usual.

That's it. You've seen how Super Protocol enables GPU-less distributed inference, fully confidential, decentralized, and verifiable on-chain. The distributed setup provides both security through TEE hardware and improved performance through parallel processing.

So finally, let's talk about trust, one of my favorite topics, or rather how you can move beyond it. In this demo, we'll show how Super Protocol replaces blind trust with built-in cryptographic proofs. Every run is verifiable, independently and transparently, down all the way to the hardware level.

So trustless doesn't mean insecure; it means verifiable by design, because every workload produces a cryptographic proof showing what ran, where, and how, without exposing the actual workload data. Now, let's see what makes this truly trustless. Full verifiability and trust aren't required anymore.

When a workload runs on Super Protocol, it generates a cryptographic attestation, a signed proof from the hardware itself, building on the attestation capabilities inherent in confidential computing. This attestation verifies that your model executed in a real trusted execution environment, a TEE, using unmodified code on verified hardware inside a secure, open-source runtime.

You don't have to trust the provider. You don't have to trust the platform, because you can verify. And even if you don't, the system won't expose your sensitive data if there are attempts to bypass it, simply because the protocol won't allow your application and data to load and run if this happens.

Here's what that looks like in practice.

Hi. Today, we'll demo how Super Protocol helps data owners and AI model developers collaborate securely. One of the toughest business and technical challenges is training models on medical data, where privacy is crucial. We'll show how Super Protocol solves this.

We have three participants: Alice's lab, Bob's clinic, and Carol's research center. Alice and Bob each hold sensitive datasets. Carol brings a training engine. There's no model yet. The goal is to train a brand new model for early cancer detection on Alice's and Bob's data without exposing either the data or Carol's intellectual property.

All three inputs, Alice's data, Bob's data, Carol's training engine, run inside a trusted execution environment, or TEE. No one, not the cloud host, not Super Protocol, not even the participants, can access what's inside. Outside the TEE, each party keeps full custody of its assets.

Inside, no one can see raw data, source code, or weights. Training is fully automated by the verified engine, the Super Protocol certification center, and smart contracts on OpDNB, DNB Chains Layer 2. In the past, multi-party training meant legal paperwork, manual setup, and blind trust.

So many projects stalled or took months or years to get underway. Super Protocol removes those trust barriers. It hides the complexity and automates the entire process behind the scenes. And you don't need to be an expert in confidential computing.

At Super Protocol, a confidential virtual machine, or CVM, is launched once and then handles multiple jobs. No need to spin up a new VM for every task. On boot, the CVM contacts the open-source certification authority, also running in confidential mode for remote attestation.

If the check passes, the center issues a certificate proving the CVM is genuine and running inside an attested trusted execution environment. But attesting the CVM isn't enough. Before any data enters, an open-source security mechanism inside CVM, the trusted loader, comes in.

First, it's attested and gets its own certificate. Then it creates a signed key pair and checks every component. If any of these checks fails, the process automatically stops to safeguard all parties and ensure nobody's data or models are compromised.

Now, let's walk through that flow.

Carol builds a container-based training engine.

Here is its hash.

She uploads her engine image to her own encrypted storage, provides its hash, and the source code so that the data owners can verify them. Alice and Bob check them. To be clear, Carol's engine is proprietary, but she privately shares its source code with Alice and Bob so they can verify it doesn't leak data.

If she's not happy doing this, or if Alice and Bob aren't security experts, an alternative is to have an external party inspect it and provide assurances to Alice and Bob that the model is safe to process their data.

Meanwhile, Super Protocol's open-source certification center lets anyone confirm that the whole process runs inside a trusted confidential environment.

Alice and Bob archive and upload their datasets using the Super Protocol CLI tool called SPCTL. The utility encrypts the files during upload. Bob uploads his dataset to his own decentralized storage.

Alice uploads data on her side to her storage.

Let's see what's inside Alice's file. Here is the hash, encryption key, and storage access. The same will be with Bob's file. Alice and Bob grant the CVM access and specify the verified engine's hash and the ID of the confidential virtual machine that will process the order.

In our case, it's the compute offer number 8. Its public key is already published on the blockchain.

Even Alice herself doesn't have access to this encrypted data, as only the specified CVM with ID 8 has the private key to decrypt it. Bob's data is protected in the same way. Carol places the main order to process the workload using her uploaded engine and Alice's and Bob's prepared access files.

She uses the compute offer 8. When the job is submitted, the trusted loader checks the CVM certificate, calculates hashes for the engine, datasets, and config, compares them with the approved list, blocks the job if anything diverges. Only if every hash matches does training start inside the TEE.

Data and the engine are only ever decrypted inside the TEE. Even the participants cannot access them during execution, and everything is protected from other parties, including the owner of the system executing the training. Only Carol receives the encrypted output, the newly trained model, and artifacts.

Encryption keys never leave the TEE, so Alice, Bob, Super Protocol, and the hardware vendor remain blind to the results. Let's check the order status. As we can see, the job is already done, so we can download the result now.

Here it is, and we can also see that it was decrypted. SPCTL decrypts it using Carol's key specified in the config file. You can find more details about this process in the Super Protocol documentation. Everything is explained there.

Let's unpack the result and check what's inside.

The logs show that the application ran as expected. We can see files located in the input directories, meaning the input and reference data were pulled from those directories, just as expected.

Then the training process ran and the results were saved. All output was successfully written into the SP output folder. Here's the trained model, the PKL file with its weights, evaluation matrix, and other output artifacts. All of this was processed in a fully confidential environment.

That means everything ran on a secure machine. Security is great. Proof is better. Before training begins, the trusted loader creates an integrity report signed inside the TEE. That report is later published on OpDNB as the part of order report, giving anyone public, tamper-proof evidence that the job will run in a certified environment with the approved inputs.

Here's how we retrieve the report for this specific order using the SPCTL command. If the job has already started, this report has already been published to the blockchain. What we see here includes the certificates we discussed earlier, along with a list of processed inputs and the timing.

The image refers to the actual executable workload. Its hash matches exactly the one we saw earlier, the one trusted by both Alice and Bob. Right here, same hash. We can also verify that these hashes correspond to Alice's and Bob's inputs.

Let's take Alice's dataset. Its hash matches. And now Bob's.

Same thing. So yes, both Alice's and Bob's data were used in this job, and it ran with the correct training engine. The job is complete. The result is encrypted and delivered only to Carol. After every job is finished, all raw inputs are wiped.

An order report is published on chain, giving everyone public proof that the run was genuine.

The order report isn't just an audit log. During runtime, an app inside a CVM can sign data with its private key. Anyone on chain can verify that the signature came from a trusted, decentralized, confidential environment, crucial for Web3 AI workflows.

You've just seen how Super Protocol lets Alice, Bob, and Carol train a medical AI without ever exposing data or models to each other or any other parties. Super Protocol turns complex, multi-party, trust-heavy collaboration into a push-button workflow. Try it yourself.

Build, verify, run. No expertise in confidential computing required. Thanks for watching.

This report shows exactly what ran, where it ran, and that it followed the expected logic, all verifiable by any participant. No NDAs, no manual audits, just built-in verifiable trust powered by confidential computing. It's time to recap. Throughout this session, we've looked at real-world problems, shared impactful case studies in the most data-driven industries, digital marketing and healthcare, and walked through demos showing exactly how confidential AI actually works.

Running models on private data without exposure. Deploying proprietary models without losing control. Fine-tuning without compliance risk and verifying execution with cryptographic proof. With Super Protocol, you get all of that in a way that's simple to use, transparent and verifiable, secure by design, GPU-less, trustless, limitless.

And it's not just a concept, but a practical path forward for developers. We invite you to launch your own model in a confidential environment today. Try it now. Here are some links to some starting points: the Super Protocol website, the Super AI Marketplace, documentation about Super Protocol, and NVIDIA's article about Super Protocol.

Thank you for your time, and we hope to see you leveraging confidential AI soon with Super Protocol. Have a great day.