Primus × Kaito Campaign: The Breakdown The @primus_labs Katalyst campaign is now live, with 0.3% of the $PRIM allocation dedicated to the campaign. But the important part isn’t just the reward pool. Here’s how the campaign actually works...🧵 1. Campaign Period Epoch 1 runs from September 22 → October 22, 2026. A second epoch may be announced later. The campaign is running on X and up to 450 creators can receive ranked rewards. 2. The Campaign Focus Primus is positioning itself as: Confidential infrastructure for institutional onchain finance. Creators can build around several core angles: → Institutional finance → Confidential finance → Verification → Privacy × verification → BNB You don't need to cover everything in one post. The goal is to create original educational content around one of these areas. 3. What Primus Actually Provides Primus focuses on two important problems in onchain finance: Verification Prove information that needs to be trusted, including financial information that exists offchain. Confidentiality Protect information that needs to remain private while still operating on existing financial rails. The bigger idea: Make onchain finance more private without removing the ability to verify what matters. 4. How Creators Are Scored This is probably the most important part. Your campaign performance is based on: Kaito Mindshare + Referral Multiplier Your top 4 eligible posts during each epoch are used to calculate your Mindshare performance. You can submit up to 10 posts per epoch, but your top 4 eligible posts are what matter for the score. That means quality and performance matter more than simply posting as much as possible. 5. The Referral Multiplier There is another layer. Creators can increase their multiplier by referring people to the Primus XP Points page. Those users complete Primus XP tasks and earn points. Their earned XP contributes to the referral multiplier. And the XP tasks can change weekly. So the campaign isn't only about creating content. There is also a community-growth component. 6. The Reward Pool The total campaign allocation is: 0.3% PRIM = 30 bps Split into: 0.24% / 24 bps → Creators 0.06% / 6 bps → Kaito stakers Creator rewards are distributed by language region and ranking. English region Ranks 1–10 → 30% of regional pool Ranks 11–50 → 40% Ranks 51–150 → 30% The same structure applies to the Chinese region. The Korean region has a smaller regional pool, with the same ranking structure. In total, 450 creators are eligible for ranked rewards. 7. Vesting The campaign rewards are: Fully unlocked at the end of the campaign. Rewards are settled and distributed after all epochs are completed. 8. Content Eligibility Matters There is an important distinction here. Kaito handles the campaign infrastructure and performance calculation, but the project has the final say on content eligibility. After the campaign: → Content is compiled for Primus review → Kaito checks content integrity → The project evaluates eligibility → Kaito takes the performance snapshot → Eligible rewards are processed Posts that violate the Content Guidelines can be disqualified and won't contribute to the final score. 9. The Content Strategy If you're participating, don't treat this as a simple “Primus is great” campaign. There are much stronger educational angles. For example: Institutional finance Why do institutions need privacy and verification before moving meaningful capital onchain? Confidential finance How can institutions use public blockchains without exposing sensitive positions or strategies? Privacy × verification Why should financial activity remain private where necessary while important claims remain provable? BNB How can confidentiality and verification make the BNB ecosystem more suitable for institutional activity? These are much deeper conversations than simply explaining what Primus is. 10. The Bigger Picture Institutional adoption doesn't only require more liquidity. It requires infrastructure that answers two questions: “Can this information be trusted?” and “Does everyone really need to see it?” That is where Primus is positioning its infrastructure. Verification for what needs to be trusted. Confidentiality for what needs to stay private. And infrastructure that sits above existing onchain financial rails. That’s the core story behind the Primus × Kaito campaign. If you're creating for this campaign, focus on original educational content, strong ideas and genuine conversations around confidential institutional finance. And if you're participating, remember to submit the main X post link through Kaito Studio. Campaign: Sep 22 → Oct 22, 2026 Reward pool: 0.3% PRIM allocation Creator pool: 0.24% PRIM Eligible creators: Top 450 Scoring: Kaito Mindshare + Referral Multiplier: s.kaito.ai/9lTk7PJ

Primus zkTLS makes use of ZK Proofs to let you grab exactly the information you need without revealing your password or your full history @primus_labs does it in two different ways, depending on what the app needs. • MPC Mode • Proxy Mode 1/7 #fhe #zktls #privacy

Primus AlphaNet Tutorial: How to Verify Your Web2 Identity with zkTLS If you’re new to the @primus_labs AlphaNet Campaign, here’s the simple step-by-step guide. The idea is straightforward: Connect your wallet → install Primus Extension → choose a task → generate your zkTLS proof → get your activity verified. 1. Go to the Primus AlphaNet Campaign Open: app.primuslabs.xyz Connect your wallet by clicking “Connect Wallet.” Choose the wallet you normally use to interact with the dApp. This wallet will be associated with your verified activities on the campaign. 2. Enable the Primus Extension After connecting your wallet, click: “Enable Extension” You’ll be directed to the Chrome Web Store to install the Primus Extension. The extension is an important part of the verification process because it enables Primus to generate the zkTLS proof from the supported Web2 platform. 3. Choose the Web2 task you want to verify Once the extension is ready, you’ll see different verification tasks. Such as: X / TikTok / GitHub / Luma / Spotify / ... Choose the task you want and click: “Verify Now” This starts the verification process for that platform. 4. Example: verifying your X account If you choose the X task, there are additional requirements. You need to: → Follow the official @primus_labs account → Repost the required tweet → Then generate your proof This allows the campaign to verify the required X activity. 5. Deposit the required ETH For X verification, the docs currently specify a small Base ETH deposit of approximately: 0.000035 Base ETH This is used to pay the Primus Network fee. You also need to cover the very small Base gas cost associated with the deposit transaction because the proof is stored onchain. If the verification task fails, the deposited amount will be refunded shortly. 6. Generate your zkTLS proof After completing the requirements, the zkTLS proof is generated automatically on the relevant platform page. You don't need to manually create the cryptographic proof yourself. Primus handles the proof-generation process through the extension and AlphaNet infrastructure. 7. Check your verification status Once the proof is successfully generated, your task card will show a green verification icon. That means your required activity has been successfully verified and your account status has been counted for that task. 8. Verify more Web2 activities You don't have to stop with one platform. You can return to the task list and complete other available verification tasks such as: X → TikTok → GitHub → Luma → Spotify → ... Each task lets Primus verify a different aspect of your Web2 identity or platform activity through zkTLS. The more eligible tasks you complete, the more reputation score you can potentially accumulate within the campaign. The whole process in one line: >Connect Wallet >Enable Primus Extension >Choose a task >Verify Now >Complete the platform requirement >Generate zkTLS proof >Proof gets verified >Green verification icon >More verified Web2 activity + reputation And that's the AlphaNet Campaign flow. What I like about the design is that you’re not simply telling Primus: “Trust me, I have this account.” The system uses zkTLS proofs to verify information and activity from supported Web2 platforms. Your Web2 activity stays where it already exists, while Primus provides a way to turn the relevant information into a verifiable proof. Web2 activity → zkTLS proof → verifiable identity/activity That’s the basic idea behind the Primus AlphaNet Campaign. #primuslabs #zkTLS

How @primus_labs AlphaNet works a simple guide If you’ve been hearing about Primus AlphaNet but still wondering what actually happens behind the scenes, here’s the simple breakdown. Think of AlphaNet as the decentralized attestor network that helps DApps verify data coming from Web2 sources through Primus zkTLS. The flow looks like this: Web2 data → AlphaNet → zkTLS attestation → DApp → verification Here’s what happens step by step. 1. A DApp needs some Web2 data For example, an application may need to verify information from an exchange such as Binance or OKX. Instead of asking the exchange to put that information directly onchain, the DApp creates a verification request. 2. The DApp submits a task The task is submitted to the Primus Network. The network returns a task ID and the attestors assigned to handle that task. These attestors are the nodes participating in AlphaNet. 3. The attestors perform the zkTLS verification The user and attestor work together through Primus zkTLS. Primus supports different execution modes, including MPC and Proxy mode, with different security and performance trade-offs. The goal is simple: Verify that the information really came from the intended Web2 source without requiring the underlying private data to simply become public. 4. An attestation is produced Once the process is completed, the attestor returns an attestation together with a signature and other metadata. That attestation is the important output. It is the cryptographic statement that the requested Web2 data was verified. 5. The DApp can use the verified data The application can then verify the attestation and use the result inside its own logic. Primus also provides smart-contract verification tools so attestations can be verified onchain across supported blockchains. And there’s an important privacy detail here: The DApp does not necessarily need to expose the user's entire underlying data. It can request the specific information it actually needs. 6. AlphaNet can work with more than one data request This is especially useful for exchange and financial applications. Primus supports multiple-URL aggregation, meaning a single attestation can contain verified information from multiple request URLs. For example, data from different exchange endpoints can be combined into one attestation instead of creating completely separate proofs for every request. And Primus is already providing tooling around exchange data verification, including Binance-related examples covering Spot, Margin, Futures and Alpha data. So the bigger picture is: DApp ↓ Requests specific Web2 data Primus Network ↓ Assigns attestors AlphaNet Attestors ↓ Execute zkTLS verification Attestation ↓ Cryptographically signed result DApp / Smart Contract ↓ Verifies and uses the result That’s the part I think is important to understand. AlphaNet isn't the website providing the data. The exchange, platform or Web2 service remains the data source. AlphaNet is the decentralized attestor layer helping turn that offchain information into something an application can verify and use. And that is what makes the Primus approach powerful: Web2 data doesn't have to stay trapped in Web2. It can be verified, kept private where necessary and brought into onchain applications in a way developers can actually build around. #Primuslabs #AlphaNet

See you at GWDC 2026 Korea 🇰🇷 @gwdc2026korea Primus Labs Co-Founder & CEO @xxiang_xie will join the event in Seoul, sharing perspectives on verifiable data, privacy-preserving computation, and the next generation of Web3 infrastructure. 📍 Sep 29–30 | aT Center, Seoul Let’s build the future of Web3 together. 💪

Hello, Seoul! 🇰🇷 @BNBCHAIN is coming back! 서울, 안녕하세요! 🇰🇷 BNB Chain 이 다시 찾아옵니다! Primus is glad to support #BNBSeoul and join this exciting gathering with the vibrant BNB ecosystem. Together with ecosystem partners and communities, we look forward to exchanging ideas, building connections, and exploring new opportunities in the on-chain space. See you on Oct 2! 10월 2일에 만나요! 🚀

What @primus_labs changed my mind about. When I first started looking deeper into privacy infrastructure, I thought the main goal was simple: Keep the data hidden. The more I studied Primus, the more I realized that’s only part of the problem. Because privacy becomes much more useful when data can still be verified, computed on and used without exposing everything behind it. That changed how I think about privacy. It’s not necessarily about putting data in a box and never touching it again. It’s about giving applications enough information to make decisions while limiting everything they don’t actually need to know. And that distinction is huge. A financial application might need to know that a condition has been satisfied without needing your entire financial history. A reputation system might need proof of a certain activity without needing every detail of your identity. An AI application might need to work with sensitive information without turning that information into another public dataset. The question then shifts from: “How do we hide the data?” to: “How much of this data actually needs to be revealed in the first place?” That’s probably my biggest takeaway from digging into Primus. Privacy and verification don't have to fight each other. You can have systems where information remains protected while the parts that actually matter can still be proven and used. And I think that changes the design space for applications quite a bit. Instead of asking users to constantly choose between privacy or usability, developers can start thinking about a third option: useful data, without unnecessary exposure. That’s the part of Primus I’ve found myself thinking about the most. #Primuslabs #FHE

Primus Co-founder @Xavier_bham joined the forum discussion at ETHShanghai 2026 @EthereumSH! Looking forward to reconnecting next time and continuing to support the growth of the #Ethereum ecosystem.

Proud to have joined the panel at @EthereumSH to discuss the crypto wars &CROPS. Privacy to the moon!

1/ Primus × Kaito Creator Campaign is here 🚀 We’re partnering with @KaitoAI for Primus: The Confidential Infra for Institutional Onchain Finance. Join Now: kaito.ai/studio/camp_8dbabb6… As more financial activity moves on-chain, institutions need stronger privacy guarantees while keeping financial activity, positions, and strategies verifiable. Primus is building infrastructure that enables both privacy and verifiability: 🔸 Verifiable — prove what needs to be trusted 🔸 Confidential — protect what needs to stay private

Great sharing at ECNU, Shanghai Frontier Cryptography & Ethereum Meetup on Primus’ zkTLS+FHE privacy infrastructure for Ethereum. Thanks to all organizers!

We’ve talked alot about what @primus_labs can do. Now let’s talk about what developers can actually build with it. This is where I see DVC and the Primus SDK playing a significant role. Not because we need another explanation of zkTLS, zkVM or zkFHE. We’ve already covered those. What I find more interesting is the layer connecting these capabilities to an actual application. Because there’s a big difference between having powerful cryptographic infrastructure and making that infrastructure practical for developers. A developer working with sensitive Web2 data has to think about several things at once: → Can the data be trusted? → Can the computation be verified? → Can sensitive information remain protected? → Can the result be used by an onchain application? → And most importantly, how do I actually build this without recreating the entire cryptographic stack myself? That’s where DVC starts to make sense. Instead of treating data verification and computation as completely separate problems, it creates a path where verified data can move into computation and produce a result that can be independently verified. And then the Primus SDK becomes an important part of the developer experience. Because infrastructure only creates real value when developers can actually interact with it. You shouldn’t need to understand every cryptographic primitive under the hood just to build an application that needs verified data or private computation. The SDK abstracts much of that complexity and gives builders a way to work with Primus capabilities from inside their applications. That opens up a much larger design space. Think about applications that need to make decisions based on information that exists outside the blockchain, while still preserving the properties that make the result trustworthy. Private financial applications. Credit and reputation systems. Eligibility and access systems. AI workflows that depend on sensitive data. Onchain automation based on verified external information. Applications where the data itself shouldn’t become public just because the application needs to use it. That’s the part I’m paying attention to. The goal isn’t simply to prove that privacy-preserving computation is possible. The bigger challenge is making it usable enough that developers can turn it into products. And that’s why I think DVC + SDK is an important part of the Primus story. The primitives provide the cryptographic foundation. DVC connects verification with computation. And the SDK gives developers a practical interface to build on top of that foundation. Powerful infrastructure is good. Powerful infrastructure that developers can actually build with is where things start getting serious. #Primuslabs #DVC #SDK

Great to join the “Frontier Cryptography & Ethereum” Meetup in Shanghai, co-hosted by @Ethtao_Ethtao, @ethereumfndn, @ethereumhkhub and ecosystem partners. Primus Co-founder @Xavier_bham shared how Primus is building privacy infrastructure with zkTLS and FHE, enabling verifiable data and confidential computation for #Ethereum. Privacy is becoming a key part of Ethereum’s future, and FHE can help institutions move on-chain with greater confidence.

Privacy is not dead. It is infrastructure still being built. As an Ethereum Foundation grantee, Primus is building privacy-preserving infrastructure with zkTLS, enabling verifiable off-chain data without exposing the underlying data itself. The future of onchain applications needs both verification and privacy. We’re continuing to build toward that future.

zkTLS has more than one way to establish trust. And the difference between MPC mode and Proxy mode is worth understanding. Both are designed to prove information obtained through a TLS connection while protecting sensitive data. But they take different approaches to how the attestation is produced. MPC Mode In MPC mode, the client and attestors work together to establish the TLS session with the data source. The important part is that the client doesn't simply hand its TLS secrets to an attestor. Instead, the TLS-related computation is performed collaboratively. The general flow looks like: Data Source → TLS → Client ↔ Attestors → ZK validation → dApp The attestors help generate the information needed for the proof, while the client retains control over its sensitive session information. @primus_labs uses QuickSilver in this process, a lightweight interactive zero-knowledge proof system designed to reduce computational and communication overhead. So MPC mode is essentially built around collaborative computation and stronger separation of sensitive TLS material. --- Proxy Mode Proxy mode takes a different route. Here, the attestor sits between the client and the data source. The TLS traffic passes through the attestor, which records the ciphertexts exchanged between the client and server. At the end of the session, the client proves to the attestor that it knows the plaintext corresponding to those ciphertexts. The simplified flow becomes: Data Source ↔ Attestor ↔ Client → ZK validation → Proof This removes some of the computational overhead associated with the multi-party setup. But it introduces another requirement: The attestor has to make sure it is actually communicating with the intended server. So Proxy mode trades some of the complexity of MPC for a different trust assumption around the communication path. --- Why have both? Because zkTLS applications don't all have the same requirements. MPC mode is designed around collaborative TLS computation. Proxy mode uses an intermediary to simplify the process and can offer performance advantages, while introducing a different network assumption. Primus also uses its QuickSilver protocol to improve the efficiency of its proof generation. That's an important detail because zkTLS isn't simply: «“Put a zero-knowledge proof around HTTPS.”» There is a lot happening underneath. You have: TLS → secure communication MPC / Proxy → different ways of obtaining and processing the TLS transcript ZK validation → cryptographic verification of the relevant information Attestation → a verifiable output that an application can consume And this is why understanding the MPC vs Proxy distinction matters. The end goal is similar: Prove useful information from Web2 without simply exposing the entire underlying session. But the path taken to get there is different. That design choice affects trust assumptions, computation, communication overhead and performance. And that's one of the parts of zkTLS that is easy to miss when you only look at the surface-level explanation. #Primuslabs #zkTLS

Most people see MPC, zkTLS, zkFHE and zkVM as four separate pieces of cryptography. In @primus_labs they answer different parts of the same problem: How do you take information from the real world, keep it private and still make the result verifiable? Here’s the simple way I think about it: 1. MPC — protect the connection In Primus MPC mode, the client and attestors work together to establish the TLS session with a data source. The goal is to avoid putting the entire trust of that process in one party. It’s about how the connection is established. 2. zkTLS — verify the data Once you’re dealing with Web2 data, the next question is: “Can I actually prove this information came from the source?” That’s where zkTLS becomes useful. It allows data from HTTPS/Web2 sources to be verified without simply exposing the underlying private information. 3. zkFHE — compute privately Verification is only part of the problem. Sometimes you need to actually compute on the data. zkFHE combines fully homomorphic encryption with zero-knowledge proofs, allowing computations to be performed on encrypted data while providing proof that the computation was executed correctly. 4. zkVM — prove the computation Then there’s the computation itself. A zkVM can execute a program and generate a proof that the program ran correctly with the given inputs. This is especially useful when verified private data needs to go through more complex business logic. So the roles are different: MPC → secure session establishment zkTLS → verifiable Web2 data zkFHE → private computation zkVM → verifiable execution And that distinction matters. They aren't four steps that every Primus application must blindly run through. They're different tools that can be combined depending on what an application actually needs. That’s what makes the architecture interesting: You don't have to choose between useful data, privacy and verifiability as one package. You can build the right combination for the job. #primuslabs #zkVM #zkTLS #zkFHE