DEV Community: Soulman

OpenMed Is Now Deployable on Phala Cloud

Soulman — Sun, 21 Jun 2026 12:52:58 +0000

Note: This article is Adapted from the official Phala announcement.

Healthcare AI has a data problem that most people don’t talk about enough. Clinical notes are some of the most sensitive information that exists, and yet to get value out of them with AI, you have to run them through pipelines that process, store, and analyze that data somewhere. The question is always where, and who can see it. OpenMed solves the first part by taking unstructured clinical text and turning it into structured data that AI systems can actually use. Phala Cloud solves the second part by making sure all of that happens inside a confidential compute environment where the data stays protected the entire time it’s being processed.

What Running OpenMed on Phala Actually Means
When you deploy OpenMed using Phala’s template, your clinical notes, the NLP pipeline processing them, and your app credentials all run inside a Phala TEE CVM. That means even the infrastructure provider cannot access what’s happening inside. For developers building healthcare tools or institutions evaluating AI adoption, this removes one of the biggest blockers, which is proving that sensitive patient data never left a protected environment. You don’t have to take anyone’s word for it. The architecture makes it verifiable.

Why This Makes Phala Worth Paying Attention To
What makes Phala stand out is that they keep closing the gap between confidential computing as a concept and confidential computing as something you can actually ship. A ready to deploy OpenMed template is a practical example of that. Builders don’t need to figure out the security architecture from scratch. They pick the template, deploy it, and get a working confidential environment for healthcare AI out of the box.

You can deploy at https://cloud.phala.com/templates/openmed, review the template code on Phala’s GitHub at https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/openmed, and find the upstream OpenMed project at https://github.com/maziyarpanahi/openmed

Why Svelte and Phala Cloud Work Well Together if you deploy it on Phala Cloud

Soulman — Sun, 21 Jun 2026 12:44:34 +0000

Note: This article is Adapted from the official Phala announcement.

Svelte has become a go-to choice for developers who want to build fast, reactive frontends without the weight of a large framework. It compiles your UI down to small, efficient code that runs directly in the browser, which means your app loads quickly and feels responsive. For a lot of projects, that’s exactly what you need on the frontend side. But most real applications don’t stop at the UI. At some point your app needs to run server side logic, call external APIs, or handle user data, and that’s where things get more complicated.

Where Phala Cloud Fits Into the Picture
When you deploy your Svelte app on Phala Cloud, the server side parts of your application run inside a Trusted Execution Environment backed compute instance. This means your API credentials, backend logic, and user data are processed in an environment that is isolated and verifiable, not just sitting on a standard server where you’re hoping nothing goes wrong. For developers and teams building products that institutions or security focused users need to trust, that distinction matters. You’re not asking anyone to take your word for it. The environment itself provides the guarantee.

Getting Started Is Straightforward
Phala Cloud has a ready to use Svelte template that makes it easy to get a project running without starting from scratch. The template code is open and available on GitHub, so you can review exactly how it’s structured before you deploy anything.
If you’re a developer, builder, or team working on an application that needs a clean frontend and secure backend infrastructure, this is a practical starting point worth exploring.

You can deploy directly at https://cloud.phala.com/templates/svelte and find the template code at https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/svelte and the upstream Svelte project at https://github.com/sveltejs/svelte

How Developers and Institutions Can Run AI Models Without Exposing Their Data

Soulman — Sun, 21 Jun 2026 12:38:11 +0000

Note: This article is Adapted from the official Phala and Cluster announcement.

Most people don’t think about what happens to their data the moment it leaves their device and hits an AI model. It travels through servers, APIs, and infrastructure layers, and somewhere along that path, it’s visible. For developers and institutions working with anything sensitive, a privacy policy alone doesn’t fix it.
That’s the gap Cluster and Phala Network are closing together.

What TEE Hardware Actually Does

TEE stands for Trusted Execution Environment. Think of it as a sealed room inside the processor itself. When a model runs inside a TEE, the data is encrypted during processing, not just in transit or at rest. Nobody outside that enclave can see what’s happening inside, not the cloud provider, not Phala, not Cluster.
The models running inside this setup are ones developers already use like DeepSeek, Qwen, GLM, and MiniMax. So there’s no switching costs or rebuilding your stack. You keep your existing workflow, and the hardware handles the privacy layer underneath.

The Attestation Is the Proof

Here’s the part that matters most for anyone serious about verification. Every inference call returns a signed attestation. That’s a cryptographic receipt generated by the hardware itself, confirming that your prompt was processed inside the enclave and never exposed. You’re not taking anyone’s word for it. The hardware signs off on it directly.
For institutions handling financial data, health information, legal documents, or anything else that can’t be exposed, this moves the conversation from policy to proof. If you’re building applications where data handling needs to be demonstrable and not just promised, that’s worth paying close attention to. You can explore the full breakdown through Here: https://x.com/clusterprotocol/status/2066861913267667235

GLM-5.2 Is Now Live on Phala: What Builders Need to Know

Soulman — Sun, 21 Jun 2026 12:33:20 +0000

Note: This article is adapted from the official Phala blog post. Original article published June 16, 2026 at https://phala.com/posts/glm-5-2-open-source-sota-confidential-ai-phala

Phala Network just became a launch partner for GLM-5.2, the latest open-source model from Z.ai. If you build agents, run long-context workflows, or work with sensitive data in production, this one is worth a closer look. The partnership brings together a model that sits at the top of open-source coding benchmarks with infrastructure built specifically for private, verifiable AI inference.
GLM-5.2 comes with a 1 million token context window and strong performance across long-horizon coding tasks. On FrontierSWE it trails Claude Opus 4.8 by just 1% and edges out GPT-5.5 by the same margin. It also scored first on Design Arena’s code category with 1360 Elo, and shows a sharp improvement over GLM-5.1 on Terminal-Bench 2.1 and SWE-bench Pro. For an open-source model with open weights, those numbers put it in serious company.

Why Running It on Phala Changes the Equation
Model capability gets a lot of attention, but where and how a model runs matters just as much when the workloads are sensitive. Agents handling source code, customer records, legal documents, or internal business logic carry real privacy risk inside every prompt and tool trace. Phala addresses this by running inference inside hardware-isolated environments called TEEs, where execution is protected and the runtime properties can be independently verified. Redpill provides an OpenAI-compatible API layer on top, so developers can route into this stack without changing their existing integrations.

How It Performs in a Real Environment

Phala ran their own benchmark of GLM-5.2-FP8 on an 8xH200 setup using SGLang. At standard context lengths, it holds above 25 tokens per second per user through 64 concurrent users, with aggregate throughput continuing to scale. At longer input shapes it maintains that same threshold through 32 concurrent users before latency pressure increases at higher concurrency. These are practical serving numbers that reflect how the model actually behaves under load, not just isolated lab conditions.

Where to Access It
GLM-5.2 is live on both Phala and Redpill at $1.40 per million input tokens and $4.60 per million output tokens. Most infrastructure conversations treat privacy as something added after deployment. Phala’s approach builds it into the deployment layer from the start, and this launch is a clear signal of where that infrastructure is heading.

GLM-5.2 on Phala: https://phala.com/models/z-ai/glm-5.2 on Redpill: https://redpill.ai/models/z-ai/glm-5.2

Reach out to the Phala team directly at @PhalaNetwork on X or visit https://phala.com/ to explore enterprise access and deployment options.

For individual developers and teams, getting started is straightforward through either platform. For institutions, this is a more significant conversation. If your organization is evaluating AI infrastructure for workloads that involve regulated data, client information, or anything where data exposure is a compliance or legal risk, Phala confidential inference stack is one of the few production ready options that addresses that problem at the infrastructure level rather than asking you to manage it yourself. The combination of open source model strength, verifiable execution, and a familiar API surface makes this a practical starting point, not just a proof of concept.

PaddleOCR on Phala Cloud: Extract Documents Without Exposing What’s Inside

Soulman — Mon, 15 Jun 2026 17:57:20 +0000

Note: This article is Adapted from the official Phala announcement. Original post published on the Phala X handle. Find it here: https://x.com/phalanetwork/status/2065573625588261019

PaddleOCR is one of the more capable open-source OCR engines available, built by PaddlePaddle, and it handles everything from printed text to tables with solid accuracy. Phala Network has added it as a deployable template on Phala Cloud, and the reason that matters is where it runs. When you deploy this template, your OCR workload runs inside a TEE CVM, a hardware-level isolated environment where the document contents, pipeline logic, and extracted results all stay private. That includes from the node operators themselves.

What This Opens Up
The practical value is in documents that have always been awkward to process in the cloud. Financial statements, legal contracts, medical records, internal reports. Content sensitive enough that you don’t want raw data sitting in a general-purpose cloud environment during processing. With this setup, PaddleOCR runs inside the enclave, structured data comes out, and the source material never gets exposed.
For teams building pipelines in regulated industries or handling client data under strict privacy requirements, that changes what’s actually buildable.
The template is live at https://cloud.phala.com/templates/paddleocr and the full code is on GitHub under Phala here: https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/paddleocr. and on Upstream: https://github.com/PaddlePaddle/PaddleOCR

Why This Matters for Phala
Phala keeps shipping deployable templates that let builders plug real tools into a private compute environment without starting from scratch. PaddleOCR is one more example of that pattern, and for developers and institutions taking data privacy in AI pipelines seriously, that’s the kind of progress worth paying attention to.

Flue on Phala Cloud: TypeScript Agents With Privacy Built In

Soulman — Mon, 15 Jun 2026 17:45:57 +0000

Note: This article is Adapted from the official Phala announcement. Original post published on the X handle. Check it here: https://x.com/PhalaNetwork/status/2064931094139638104

If you’re building AI agents in TypeScript, there’s always a setup tax before you write any real logic. Sessions, tool calls, sandboxes, skill routing, Flue handles all of that in one harness so you can focus on what your agent actually does.
The template is live on Phala Cloud at https://cloud.phala.com/templates/flue, with code open on GitHub under the Phala here: https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/flue. The upstream framework is at withastro/flue.check it here: https://github.com/withastro/flue

What Phala Adds
Deploying on Phala Cloud means your agent runs inside a TEE confidential virtual machine. Your repo context, prompts, and tool calls stay inside a hardware-verified environment that nobody outside it can access, including the infrastructure provider. Most agent frameworks have no real answer for this. You usually end up trusting your cloud provider with everything running inside it. Phala closes that gap without changing how you write your agent.

Why It Matters
Combining TypeScript tooling with hardware level privacy in a one-click template is not something you see often. A lot of projects treat confidential compute as a roadmap item. Phala ships it as something you can deploy today.
For teams running agent logic they can’t afford to expose, that’s a real difference, and it’s why Phala stays worth watching as the agent space grows.

Headroom Runs Inside a Phala TEE, and That Changes How You Think About LLM Pipelines

Soulman — Mon, 15 Jun 2026 17:39:57 +0000

Note: This article is Adapted from the official Phala post.

If you’re building with large language models, you already know the context window problem. Every tool output, log entry, and document chunk you feed into your model costs tokens, and those costs add up fast. Headroom handles this automatically, sitting between your data sources and your LLM and compressing tool outputs, logs, files, and RAG chunks before they reach the model. That alone is useful. But where it runs is the more interesting part.

The Data Never Leaves the Encrypted Environment
Headroom deploys inside a Phala Confidential Virtual Machine, meaning your API keys, compression rules, logs, and payloads are processed inside an encrypted hardware environment that even the underlying cloud infrastructure cannot read. This is not a software-level privacy claim. The protection comes from the hardware itself, and that trust is verifiable, not just promised.
For anyone building pipelines that touch sensitive or regulated data, that distinction matters. You can deploy it directly from a template at https://cloud.phala.com/templates/headroom, and the full code is on GitHub under Phala here: https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/headroom, with the upstream from chopratejas/headroom if you want to dig in or adapt it.check it here: https://github.com/chopratejas/headroom

Why Phala Is Worth Watching
Headroom is a small but concrete example of what becomes possible when confidential compute is the base layer rather than an afterthought. Most infrastructure forces a trade-off between flexibility and privacy. Phala removes that trade-off for workloads running on top of it. The code is open, the deployment is live, and builders can verify the environment themselves.

For developers and institutions evaluating where to run sensitive AI workloads, that combination is what a serious shortlist looks like.

GitHub’s Copilot SDK Just Got a Privacy Upgrade

Soulman — Thu, 11 Jun 2026 22:50:07 +0000

Note: This article is adapted from the official phala.com announcement.

GitHub recently released the Copilot SDK, which lets developers embed Copilot Agent directly into their own apps and services. Until now, if you wanted Copilot’s capabilities, you worked inside GitHub’s interface. The SDK changes that by opening up the agent layer so builders can bring it into whatever they’re building, on their own terms.
That’s useful on its own. But it also opens up a question most developers haven’t had to think about yet: when your agent is running inside your infrastructure, what happens to the context it’s working with? Your repo contents, your prompts, the state the agent holds while it’s executing, where does all of that actually live, and who can see it?

What Phala Built on Top of It
Phala put together a deployment template that runs the Copilot Agent inside a TEE CVM. Without getting into the weeds, that means the agent executes inside a hardware-protected environment where the contents are sealed off, even from the infrastructure provider itself. Your repo context, prompts, and execution state stay inside that environment throughout the entire process. Nothing leaks out, and the execution can be verified rather than just trusted.
If you’re a developer ready to try it, You can be up and running with a private Copilot Agent deployment faster than you’d expect. If you’re part of a team or institution evaluating how to deploy AI agents without exposing sensitive data to third parties, this is a setup worth a serious look. The infrastructure is already there, and it works today.

The template is ready to deploy at https://cloud.phala.com/templates/copilot-sdk, and both the template code and the upstream Copilot SDK are open for anyone to inspect on GitHub.

Template code: https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/copilot-sdk
Upstream: https://github.com/github/copilot-sdk

Phala.com and LLMTUNE partner in Building AI Infrastructure That Actually Keeps Your Data Private

Soulman — Thu, 11 Jun 2026 22:44:12 +0000

Note: This article is adapted from the official Phala.com announcement.

Most conversations about private AI stop at encryption. Encrypt the data before it moves, encrypt it when it sits in storage, and call it done. But there is a gap that rarely gets talked about which is what happens to your data while it is actively being processed?
That is the moment it is most exposed, and it is the part most infrastructure providers quietly skip over. Phala Network has been focused on closing that gap for a while now, using TEE to create a hardware-level boundary around computation itself. The model runs, the inference happens, and none of it is visible outside that protected space, not even to the infrastructure provider running it. That is a fundamentally different level of guarantee than what most platforms offer, and it is why serious builders keep coming back to Phala when the question of trust actually matters.

What LLMTUNE Brings to the Table
LLMTUNE focuses on the parts of the AI workflow that happen before deployment like fine-tuning models, shaping their behavior, and getting them ready to run in production.
That is meaningful work because a base model out of the box rarely does exactly what a business or developer needs. You train it, adjust it, specialize it, and then you need somewhere trustworthy to run it. The problem has always been that fine-tuning and confidential deployment were handled by completely separate systems that were never designed to talk to each other.
This partnership changes that. By combining LLMTUNE’s model preparation capabilities with Phala’s confidential compute infrastructure, the two teams are building a path where private AI goes from concept to running system without the chain of trust breaking somewhere in the middle.

Why This Matters for Anyone Building With AI Today
Institutions, developers, and businesses that handle sensitive data are running out of reasons to delay moving AI workloads into production. Regulation is tightening, user expectations around data handling are rising, and the technical excuse that truly private AI is too complicated or too limited is getting harder to make.

What Phala and LLMTUNE are building together is exactly the kind of infrastructure that removes those blockers. You get model tuning, deployment, and hardware-verified confidential compute as a connected system rather than a patchwork of tools.

Phala has been one of the more consistent projects in this space when it comes to actually shipping infrastructure that developers can build on, and partnerships like this one reflect that. The teams say more is coming, and based on what each side already does independently, that is worth paying attention to.

Supermemory on Phala Cloud: Your AI App's Memory Layer, Done Right

Soulman — Thu, 11 Jun 2026 22:35:29 +0000

*Note: This article is adapted from the official Phala announcement. *

Most AI applications need memory in a practical sense: where does the app store user context, how does it retrieve the right information at the right time, and where do the credentials live that make retrieval work? Supermemory solves this by turning memory into an API layer, so instead of building retrieval logic from scratch, you connect to it and focus on your actual product.
The problem is that memory datasets and credentials often touch sensitive data, and most builders treat the security side as something to figure out later.

What Changes When You Deploy on Phala Cloud
Phala Cloud has a deployment template for Supermemory, and the difference comes down to how computation is handled. When you deploy inside a TEE CVM, your code runs in a hardware-enforced enclave. The data being processed is not visible to the host machine or cloud provider, and you can verify this through on-chain attestation rather than just taking someone’s word for it.
Most cloud infrastructure protects data at rest and in transit. Phala extends that to data during computation, which is the gap that matters most when memory datasets contain real user data or live credentials.

The Infrastructure Is Ready. Are You?
If you are a developer building AI agents that handle user data, this is the setup worth testing. If you are an institution evaluating AI pipelines where data governance is non-negotiable, Phala gives you something most providers cannot: verifiable proof that your computation ran the way it was supposed to, not just a policy document saying it did.
Phala keeps showing up when AI infrastructure touches real-world constraints, compliance, credential handling, verified execution, and it does it with working tooling, not whitepapers. The Supermemory template is the latest example.

Deploy from the template at https://cloud.phala.com/templates/supermemory, review the code at https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/supermemory, and find the upstream project at https://github.com/supermemoryai/supermemory The infrastructure is there. Start building on it.

AI Apps Have a Memory Problem, and This Fixes It

Soulman — Tue, 09 Jun 2026 13:48:57 +0000

Note: This article is adapted from the official Phala Network announcement.The Official Announcement: https://x.com/phalanetwork/status/2063649383074459672

Most AI applications today are stateless by default. Every session starts fresh, context gets lost, and developers end up building custom workarounds just to give their apps a basic sense of continuity. MemPalace is an open-source memory layer built specifically to solve that. It gives AI applications a structured way to store and retrieve memory across sessions, and it ships with benchmarks so developers can measure performance before making any architectural decisions. That last part matters more than it sounds. Most memory solutions ask you to trust the implementation. This one lets you verify it.
MemPalace is available as a deployment template on Phala Cloud, which means you can go from reading about it to having it running in a confidential environment without writing infrastructure from scratch. The template code lives in the Phala Network GitHub repo, and the upstream source is maintained directly by the team. Find the links at the end of this article.

Where the Memory Actually Lives
When you deploy this template on Phala Cloud, your memory datasets, application logic, and workflow credentials all run inside a Trusted Execution Environment, which is a confidential virtual machine secured at the hardware level. This is not encryption at rest or access control through a dashboard. The data is isolated and protected while it is actively running, meaning no one outside the environment, including the cloud provider itself, can see what is happening inside.

For developers building AI agents that handle user data, proprietary workflows, or anything sensitive, this changes the risk calculation significantly. You are not choosing between functionality and privacy. You get both, and the privacy guarantee is verifiable, not just a policy claim on a terms of service page.

Why Phala Keeps Showing Up in Conversations That Matter
Confidential compute is not a new concept, but most infrastructure projects treat it as an optional layer you add later. Phala builds from it as the default. Every application deployed on Phala Cloud inherits that foundation automatically. The MemPalace integration is a good example of how that plays out practically. A useful open-source tool becomes significantly more valuable when the environment it runs in can be trusted at the hardware level.
For institutions evaluating AI infrastructure, that combination is difficult to replicate elsewhere. The open-source nature of MemPalace means the memory logic can be audited. The TEE environment means the runtime can be attested. That is a meaningful stack for anyone building applications where data handling is not just a technical concern but a legal or compliance one as well.

The template is live at https://cloud.phala.com/templates/mempalace and both repositories are publicly accessible for anyone who wants to look at what is actually being deployed before running it.

Template code: https://github.com/Phala-Network/phala-cloud/tree/main/templates/prebuilt/mempalace
Upstream: https://github.com/MemPalace/mempalace

Your AI Agents Are Leaking. Deploy Agno on Phala Cloud and Fix That Today.

Soulman — Tue, 09 Jun 2026 13:04:57 +0000

Note: This article is adapted from the official Phala Network announcement. Original source: https://x.com/phalanetwork/status/2063107042102178178

Running AI agents in the cloud usually means accepting a certain level of exposure. Your agent’s memory, the credentials it uses to call external tools, the logic deciding which model handles which task, all of that lives on infrastructure you don’t fully control. For most applications that tradeoff is fine. For agentic systems handling sensitive workflows, it’s a real problem.
Agno is a framework built for multi-agent systems. It handles the coordination layer between agents, memory, tool access, model routing, in a way that’s clean and developer-friendly. What it didn’t have until now was a straightforward way to run those workloads inside an environment where the infrastructure itself couldn’t see what was happening.

What the Phala Integration Changes
Phala Cloud lets you deploy inside a Confidential Virtual Machine backed by TEE hardware. That hardware enforces a boundary around the running process so nothing outside it, not the cloud provider, not the host OS, can read what’s happening inside. When you run Agno on Phala Cloud, your agent’s credentials, memory state, and routing logic all stay inside that boundary. The confidentiality is enforced at the hardware level, not just by access controls someone could override.
The template is live at https://cloud.phala.com/templates/agno, the code is open, and it’s built directly on the upstream Agno framework. You can review the integration on Phala’s GitHub at https://github.com/Phala-Network and the upstream framework at https://github.com/agno-agi/agno. before you deploy anything.

Why Phala Is Worth Watching
A lot of projects working on confidential compute have solid theory and not much you can actually deploy. Phala has built a platform where you take a real framework, use a template, and have a confidential agent environment running without rewriting your stack. That gap between concept and usable infrastructure is where most efforts in this space have stalled. Phala has crossed it, and they keep extending it, which is what separates projects building something real from ones still explaining what they’re going to build.
Deploy Today
If you are a developer building multi-agent systems and you care about keeping your stack private, the template is ready and the setup is straightforward. Head to https://cloud.phala.com/templates/agno and get it running.
If you are part of an institution evaluating private AI infrastructure, this is a working deployment you can test today, not a roadmap item. The code is open, the environment is auditable, and the privacy guarantees come from the hardware itself. That is a bar worth holding other solutions to.