0x_WanG

Today we’ll continue talking about @NewtonProtocol . Not sure if you’ve noticed, but on-chain compliance has a deadlock: to check whether a specific person is on the sanctions list, you have to look at their identity information. But if you stuff passport numbers, home addresses, and asset details into a bunch of operators, that’s no different from selling your privacy to data brokers.

Most projects simply sidestep this. They either avoid privacy data altogether and treat compliance as half-baked, or they transmit data in plaintext—sacrificing user privacy. #Newt didn’t dodge it; they directly confronted this contradiction.

They built a scheme using HPKE encryption plus threshold decryption. When you submit sensitive data, you first encrypt it with the system’s threshold public key. The encrypted data package is then sent to the Gateway, and no operator can open it. During policy evaluation, operators each produce a key share; only when the shares are combined can the ciphertext be decrypted. No single operator holds the complete private key, and no one can independently peek at your data.

Let me use a slightly imprecise analogy: your identity information is locked in a safe. The key is broken into n pieces and distributed to n people. Only by collecting all the pieces can the safe be opened. With just their own key fragment, any one person can’t do anything. After the safe is opened, everyone can only see the specific fields needed for policy evaluation—once viewed, it’s burned with no trace. What’s stored on-chain? Only hashes and commitments. Your plaintext data is never put on-chain.

There’s also a dual-signature access control gate: if you want to use your data, you must sign it with your own signature, and if the application needs to fetch your data, it must be signed as well. Only when both “keys” are inserted does the operator begin decryption. Having your data reference ID obtained unilaterally is useless—like picking up the number of a safe but having no key.

This isn’t saying it’s completely zero trust. At minimum, you don’t have to hand over your life savings information to a single centralized institution. Trust is diluted—spread across the mathematical guarantees of cryptography—rather than resting on a company’s conscience. $NEWT plays the role of an economic guarantor in this privacy layer. Operators must stake $NEWT to be eligible to obtain the decryption key. Misuse of data results in forfeiture via penalties. A challenger who stakes $NEWT can initiate a dispute. Privacy isn’t protected by commitments—it’s protected by money.

📆Today 18:00 Blind Box Airdrop—whoever gets there first gets it
This airdrop has three reward tiers:
✅ Common items (80%) 25–30U
✅ Rare items (15%) 35–40U
✅ Hidden items (5%) 80–100U
There are currently no announcements about new coins. The TGE has been deployed on-chain, but I don’t know which day it will be issued. I’ve decided to try my luck and go for a hidden item first.

Today we’ll continue talking about @NewtonProtocol . Have you noticed there’s a troublesome issue that’s hard to get around in on-chain strategy evaluation: external data is alive. If you write a strategy check that transfers a maximum of 10% of the wallet balance, then operators first have to go query the balance off-chain. If multiple operators query at the same time, the API responses will come back at different time points, yielding several slightly different numbers. But BLS signature aggregation requires everyone to sign exactly the same message. If the numbers differ, the signatures can’t aggregate, and consensus fails outright.

#Newt ’s solution is a two-phase consensus, and I think the design is quite ingenious. The first phase is called Prepare. Operators each fetch their own data, but they don’t sign— they only report the raw values back. Once the Gateway receives all values, it calculates the median, then checks whether each value’s deviation from the median exceeds the tolerance threshold (default is 10%). If the deviation is too large, the entire consensus round fails. It won’t quietly discard the outliers and pretend nothing happened.

The second phase is called Commit. The Gateway broadcasts the computed median to all operators. Everyone runs the same Rego policy using that unified dataset, and then performs the BLS signing. Since the input data has been standardized, the outputs match naturally, so the signatures can aggregate successfully.

Think about what this implies. Determinism in strategy evaluation isn’t achieved by trusting any single operator’s data source—it’s achieved by mathematics. The median is naturally resistant to extreme values: if one operator pulls a wildly incorrect price, it won’t sink the entire consensus round. Meanwhile, the tolerance check ensures the data sources can’t diverge too much. If they diverge too far, the whole thing restarts—no opportunity to slip by through “fudging.”

I believe Newton uses a statistical consensus mechanism to digest the uncertainty of off-chain data before signatures are produced. Every result an operator signs is backed by a verifiable data-alignment process. This isn’t a rule decided by guesswork; it’s a dual safeguard of cryptography plus statistics. As $NEWT serves as the fuel for the entire AI automation network, it’s worth watching what happens next.

Recently, after the Mainnet Beta of @NewtonProtocol went live, I spent some time looking at their architecture. The strategy engine uses OPA’s Rego; the operator network runs on EigenLayer; BLS signature aggregation is used to produce proofs. The technical choices are indeed solid. Before on-chain transaction execution, they perform compliance checks first—sanctions lists are enforced; transfer limits are blocked; identity is verified. Even institutional capital is willing to move in.

But I’ve had a lingering question that I can’t put down. The reason on-chain transactions are different from traditional finance boils down to one word: speed. No business hours, no approval process, no middlemen blocking you—just tap and the money is there. With flash loans, borrow and repay within a single block. Arbitrage opportunities that appear for only a few hundred milliseconds get eaten up immediately. This logic has been running for years, and for DeFi to reach its current scale, speed is the root.

#Newt inserts a layer of strategy evaluation between transaction and execution. Your trading intent is first sent to the Gateway; operators pull the data, run Rego, and generate a proof via signatures. Only after the contract receives the proof does it proceed. Even if consensus is optimized to sub-second latency, this extra hop is still real, measurable delay. Most of the time you might not notice it, but when volatility is severe, the price when you submit the transaction may already have moved by two tiers by the time the proof comes back. You think you’re buying at 100, but the actual fill happens at 105. That 5-dollar difference is the hidden cost introduced by compliance.

I’m not saying compliance shouldn’t exist. Institutional entry really does require this gate, and the gap Newton filled is also genuinely real. But a very practical question is: given the compliance pre-check, can the volume of capital willing to accept it really be compatible with the liquidity pools that already exist in DeFi? If security gains by one percent but speed loses by one percent, how do you do the math—and what ultimately determines where the ceiling for $NEWT lies.

The creator task handoff has been updated again, @NewtonProtocol The top 400 in the Chinese-speaking region will share 500,000 tokens $NEWT prize pool, Web3 wage slaves average 60U.

I went and looked into it, and the more I studied it, the more I felt this project is addressing the right problem very precisely. On-chain finance now has over $700 billion in monthly flow, stablecoins have a market cap of $313 billion, and tokenized assets are $25 billion. But if you think about one thing carefully, it feels absurd: not a single transaction is checked before execution. Your money leaves your wallet, the smart contract executes directly, and no intermediate layer asks whether this transaction is safe or compliant.

In traditional finance, when you swipe a credit card, Visa checks your balance, risk, and limits first, and only charges you after it passes. On-chain, it deducts directly; post-trade audit? The money is already gone. Multisig? Slow, and it only handles signatures, not rules. Wallet whitelists? Hard-coded into the code, and every change requires a new deployment.

What #Newt does, simply put, is add a Visa-style authorization layer to on-chain transactions. Before each transaction is executed, it first goes through the policy rules you wrote: whether the transfer amount exceeds the limit, whether the recipient is on a sanctions list, whether an agent has exceeded their authority. If the policy passes, a BLS signature aggregation produces a proof, and the contract executes only after verifying the proof; if it doesn’t pass, the transaction is blocked immediately.

I think the key point is that this check happens before execution, not after the fact. It stops the money before it moves, instead of chasing it after it’s gone. And the policy is written in Rego, using the same policy engine OPA that Kubernetes uses. There’s no need to redeploy the contract when changing policies; just update the CID on IPFS.

What does $NEWT do in all this? Operators stake NEWT to participate in policy evaluation; only after staking can they take tasks, and if they evaluate incorrectly, they get penalized. Application providers pay NEWT as the evaluation fee. Challengers stake NEWT to initiate disputes, and if they win, they get rewards. The whole economic loop is tied to the token.

So I think Newton is not just another DeFi protocol, but the missing rail infrastructure layer for on-chain finance.

📆 Today at 18:00, old-coin air drops—224 minutes are first-come, first-served. The cost is still 30U deducted for access. There’s still no news about any new coin listing. If you claim the old coins, you’re afraid of missing something new; if you wait for something new, you’re afraid the time will be wasted—making it hard to decide. By the way, why hasn’t the Indian project VEERA that was deployed on-chain earlier gone live yet?

I’ve always believed that the relationship between blockchain and privacy isn’t a choice between two extremes—it should be up to you to decide how much of a trail you want to leave. After reviewing the settlement model design of @OpenGradient , I felt that many people overlooked several details, but those details actually reveal the project’s overall design philosophy.

Most on-chain AI projects are either fully transparent: all inputs and outputs go on-chain, so anyone can look; or fully private: nothing is left on-chain, so you don’t even know whether the reasoning was verified. Neither approach is ideal. With full transparency, you wouldn’t want to use AI to handle anything sensitive. With full privacy, you lose the purpose of blockchain.

#OPG offers three settlement modes, and I think this design is important:

PRIVATE mode: Neither the input nor output hashes are put on-chain. On-chain, only a record that this inference occurred and was verified. Your conversation content and what the model returns leave absolutely no trace on-chain.

BATCH_HASHED mode: the default tier. Multiple inference requests are bundled into a Merkle tree, and only the root hash is written on-chain. The content of any single inference can’t be traced, but the completeness of the batch can be verified.

INDIVIDUAL_FULL mode: the full setup. Complete inputs and outputs, model information, and inference metadata are all written on-chain.

What I truly care about is that the choice is in your hands, not decided for you by the platform. If you run an inference and it’s a private matter, use PRIVATE. If it’s a public decision, use INDIVIDUAL_FULL. In between, use BATCH_HASHED. With the same inference architecture, you get three different levels of transparency—you can choose.

This matches the idea of a verification spectrum. TEE is suitable for low-overhead verification of large models; ZKML fits high-value scenarios that require mathematical determinism; and Vanilla is for quick verification of less critical cases. In the verification layer you choose your level of trust strength; in the settlement layer you choose your level of transparency. Both layers are spectra controllable by users—not simply black or white.

I think this kind of user-choice design is actually rare in Web3. Most projects either pursue maximum transparency and put everything on-chain, or pursue maximum privacy and leave nothing behind. OpenGradient’s approach is to give you tools to judge for yourself: for this inference, how much of a trail are you willing to leave? This is more concrete than any privacy promise, because privacy isn’t a “gift” from the platform—it’s a switch you control. $OPG has requirements that are continuous and rigid, and its value trajectory is worth observing long term.

I recently noticed that the payment settlement for @OpenGradient isn’t a single continuous route—it’s split into two: LLM inference uses the x402 protocol, settling with $OPG on the Base chain via Permit2; ML inference uses PIPE, settling on the native chain #OPG as part of the transaction.

Earlier, I wondered: wouldn’t it be simpler to use one unified path? Then I realized the settlement requirements for the two types of inference are completely different.

LLM inference is high-frequency, low-amount, and needs immediate confirmation. When you interact with GPT-5 once, spend a few cents in OPG, and wait a few seconds for the result—using settlement on the Base chain makes sense. Base has fast block times, low gas fees, and good liquidity. The Permit2 protocol lets payment authorization and deduction happen in one step, without needing a separate approve first, so the user experience is smooth.

ML inference is low-frequency, involves large amounts, and requires atomicity. PIPE performs on-chain ML execution; the inference result is written directly as part of the transaction state. Payment and inference are completed within the same transaction—either both succeed or both fail. This atomicity requirement can’t be met by x402 on the Base chain, because x402’s payment validation and inference execution are separated.

Think about it: in a DeFi protocol, PIPE calls a risk-control model. The model determines that the position should be fully liquidated, and the liquidation action is executed within the same transaction. If payment goes through Base and inference goes through the OpenGradient chain, how can cross-chain transactional consistency be guaranteed? Using a cross-chain bridge would introduce new trust assumptions. So PIPE’s payment must be on the native chain, packaged together with the inference and the state changes.

I think the dual-path design isn’t complicated—it’s pragmatic. $OPG is settled in both paths, capturing value in a unified way.

SOL chain MEME bull run again? Someone sent blackface Ansem 60% of the $ANSEM tokens—he started calling trades from 300k. In just two days, he rushed through to nearly a $100M market cap, up 300x. It’s been a long time since we saw a pump like this. Brothers, are you getting in? This wave is making everyone miss out again 🤑

I think the thing worth really looking at about the ban of Fable 5 isn’t when the model will be restored, but what it exposes as a structural issue: the stronger the model, the more likely it is to be shut down. The safety guardrails of Fable 5 were found to have bypass paths by an Amazon researcher. Within 24 hours, the White House pressured Anthropic to remove it; then export controls were imposed to restrict foreign users; finally, Anthropic completely shut off service for all users. One chain—from technical vulnerabilities to policy intervention to total shutdown—completed in under a week.

I think this isn’t a one-off case; it’s an inevitable logic of centralized AI. No matter where the model is deployed—whoever runs the servers has the final switch. Whether you use ChatGPT or Claude, fundamentally you’re renting someone else’s model, and the lease can be terminated at any time. But what I see with @OpenGradient is taking a different route: the Hermes 4 405B running on it is Nous Research’s open-source model, with publicly available weights and no built-in review layer, achieving the lowest refusal rate among open-source models on RefusalBench. The key point is that this model isn’t behind a particular company’s API; it runs on inference nodes in the HACA architecture. The inference nodes execute the model inside trusted execution environments, producing verifiable remote attestation. Each node only verifies the proof. This means there’s no single entity that can, like Anthropic shutting off Fable, cut off access with one click. The model files live on Walrus decentralized storage, and the inference nodes are independent operators on the network, with verification completed automatically on-chain.

I believe this is what “no censorship” truly means—not that the model itself is unbounded, but that the architecture doesn’t include a middleman capable of making decisions for you. The banning of Fable 5 tells us that centralized platforms’ safety review, export controls, and enterprise compliance are each another gate. HACA #OPG dismantles these gates from the infrastructure level. The only questions that matter are known only to you and the model; the inference results reach your hands first, and verification is performed asynchronously. This isn’t about seeking more freedom within the existing system—it’s about switching to a whole different infrastructure.

$OPG , after listing on the Korean market on June 15, led to liquidity exiting and profit-taking holders dumping, causing the price to drop significantly. Its value is directly tied to the network’s actual usage; next, we also need to look at its growth data and whether it can rebound with the market. For now, it’s still mainly a wait-and-see situation.

Today, let’s continue talking about @OpenGradient . I’ve always felt that what drives people most crazy about today’s AI isn’t that it isn’t smart enough—it’s that it has no memory. Every AI platform is an island: your preferences, habits, and context all get scattered across different conversation windows. I saw #OPG ’s MemSync addressing this problem, and I think its approach is much deeper than simple cloud-synced chat history.

MemSync’s architecture has three layers. The first layer is memory retrieval: it gathers the interaction fragments from various platforms into a vector index. The second layer is cross-encoder re-ranking. It’s not just matching by semantic similarity; instead, it feeds your current question along with each candidate memory into the model to assess how relevant that memory is to your conversation right now, then sorts them by relevance. The third layer is the optimization layer. Memories aren’t just added endlessly like a junk pile; there are four operations: create, update, strengthen, and delete. Duplicate entries get merged, strengthening weights are used frequently, and outdated information gets cleared.

What I find truly interesting about this design is that it turns human memory mechanisms into a computable engineering system. Short-term, event-driven processing and long-term knowledge accumulation are handled separately—just like you remember what you ate yesterday, and you also remember what your personality is like. And the entire memory layer uses MPC to manage keys and TEE for isolation: your memory data is encrypted and stored not as an asset of any particular platform, but as your own private database. Your memories follow you, not the platforms.

I believe this is the kind of architecture AI memory should have. And the value of $OPG depends on whether its verifiable AI reasoning network can translate into a sufficiently large market share. I’ll keep an eye on it.

📅 Today Alpha Airdrop Announcement:

🆕 CAP (CAP)
🕑 TGE subscription opens 18:00-20:00
📜 BNB subscription cap: 3 BNB
📜 Subscription price: 0.0035 U
✅ Points requirement: 225 points
🎯 The project is a yield-bearing stablecoin protocol. Users can mint stablecoins pegged to USD, BTC, etc., while automatically earning returns from underlying real-world assets (e.g., government bonds, money market funds). The official post has about 20,000 followers. It is led by traditional asset-management giants Franklin Templeton and Triton Capital, with a strong investment lineup, raising $16.5 million. Total token supply: 10 billion. The project announcement mentions an initial circulating supply of 15.6%: 5% for the ICO + 0.6% for the market maker + 10% for the ecosystem. Of that 10% ecosystem allocation, the portion is to be put into the treasury for future ecosystem development and does not directly enter TGE circulation. Therefore, initial circulation is low at 5.6%. Community airdrops are distributed in the form of stablecoins. The project appears highly controlled; expectations are that it can pull in some momentum.

Currently, the pre-market price is around 0.0225 U. It is expected to list on Binance Alpha, Coinbase, MEXC, KuCoin, Bybit, Kraken, etc. Additionally, the project has carried out a lot of activities in South Korea, with expectations for a “Grand Slam” on Korea. DYOR

#币安Alpha

I previously talked about three verification tiers for @OpenGradient : TEE, ZKML, and Vanilla. Among them, ZKML’s use cases are completely different from TEE’s, so it’s worth expanding on it separately.

What is ZKML? Zero-knowledge proofs plus machine learning. After your model runs inference once, it also generates a zero-knowledge proof that mathematically demonstrates that this model produces the corresponding output for that input. Anyone who obtains the proof can verify it, and the verification cost is extremely low. But the tradeoff is that the cost is huge: generating the proof can be thousands of times more expensive than ordinary inference. What used to take you 2 seconds to get a result might take hours—or even longer—when you add ZKML proving.

So who would pay for this? I think the answer is clear: scenarios where getting it wrong means you have to pay. For example, DeFi liquidation models—one misjudgment could cost millions of dollars. On-chain risk-control scoring—an incorrect evaluation could leave the protocol vulnerable to attack. ML models in compliance audits—the results must withstand third-party independent verification. In these cases, the cost of ZKML is essentially negligible compared to the potential loss.

Think about it: audit fees in traditional finance aren’t cheap either, but nobody calls them expensive, because the value of audits is that they add a layer of trustworthiness to the result. ZKML does the same thing—except that this layer of trustworthiness doesn’t come from the auditor’s professional judgment. Instead, it comes from a mathematical proof. The auditor can be wrong; the math won’t be.

Also, ZKML and TEE aren’t alternatives—they’re complementary. Routine inference runs on TEE: fast and affordable. High-risk decisions use ZKML: slower, but absolutely trustworthy. The PIPE module of #OPG even supports combining both verification types within a single transaction: the risk-control model uses ZKML to guarantee determinism, while the inference logic uses TEE to guarantee speed. This kind of hybrid verification is very hard to achieve with existing AI infrastructure.

Actually, I don’t think every inference is worth paying the higher cost to prove it. But when you need it, ZKML can provide a solution with pure mathematical determinism. As $OPG is the payment and settlement unit for the entire inference network, its value is tied to real compute consumption—so it’s worth monitoring continuously.

This week we've launched two new tokens, and the on-chain contracts are deployed. Tomorrow, we'll be opening up for the Cap App (CAP) presale from 19:00 to 21:00. The project is a yield-generating stablecoin protocol + on-chain financial application, raising $16.5 million with an initial circulation of only 5.6%. Plus, the community airdrop will be distributed in stablecoins, so we can expect a nice pump. No need to wait today, let's take a break.

Now, let's talk about @OpenGradient . I feel like decentralized AI has a very real issue that most people haven't considered: the model files are just too big. A GPT-level large language model can easily be tens of GB. Even a lightweight logistic regression model, combined with training data and version history, isn't something you can just easily fit on-chain.

I've seen the approach by OpenGradient, which is to offload the storage layer and use Walrus for decentralized storage. Model files, large zero-knowledge proofs, and detailed records of the inference process are all stored on Walrus, while the on-chain ledger only records a blob ID, which acts as a pointer to the actual data on Walrus.

Thinking about it, this solves a significant problem: full nodes don’t need to store dozens of GB of model files; they only need to keep a few bytes of ID. When inference nodes need the model, they pull it from Walrus, use it, and then release it. Verification nodes can fetch proofs using the ID when needed and validate as required.

Moreover, Walrus itself is decentralized; it doesn't just store data in the cloud and pretend to solve the problem. Model files are distributed across multiple nodes in the Walrus network, ensuring redundancy and availability. Any model uploader can publish their model through the Model Hub, and the files are automatically stored in Walrus. Inference nodes in the network can access them as needed, with no centralized custodian, no single point of failure, and no censorship risk.

I believe this design reflects #OPG 's consistent approach: rather than rigidly adapting blockchain architecture to fit AI, they are designing each layer specifically for AI workloads. The compute layer uses HACA, the verification layer uses TEE plus ZKML, the storage layer uses Walrus—each layer is tailored for the data characteristics of AI, which is a very clever design. However, the value capture of $OPG will still depend on the genuine application of the project's needs, and I'll keep an eye on it.

Brothers, it's another sunny day! At 20:00, grab 160 tokens, first come, first served for 200 slots. There are a total of 63,000 shares available, expecting an average of 60U per person.

📅 Today's Alpha Airdrop Preview:

🆕 Nesa (NES)
🕑 Expected Launch at 20:00
🎯 This is a decentralized Layer-1 blockchain project focused on privacy protection, aiming to build the world's first privacy-first decentralized AI inference network, serving as an alternative to centralized AI platforms like ChatGPT, providing trustworthy, privacy-protecting AI services; their official Twitter has around 380,000 followers, indicating some hype. Funding details are not disclosed, but it's founded by the same creator as the Everlyn project. Last year, $LYN was publicly sold on Kaito, and at TGE, the FDV was around $1 billion, but now it’s only 36M. Be cautious, take profits when possible; the total token supply is 1 billion, with an initial circulation of 25.5%. Currently, the pre-launch price is about $0.4, expected to list on Binance Alpha, OKX, MEXC, KuCoin, etc.

Next, let's talk about @OpenGradient . I feel the key part of the phrase 'privacy proof as an alternative to privacy policy' is the proof. A privacy policy is something you choose to believe, while proof is something you can verify. But the question is, how do you verify?

The TEE trusted execution environment of OpenGradient runs on remote servers, and it uses remote authentication. In simple terms, when TEE starts, it generates an encrypted signature report that contains the hash of the currently running code and hardware identity. This report is directly signed by the root key of the chip manufacturer, making it impossible for anyone to forge. You or any third-party auditor can take this report to compare with OpenGradient's open-source code repository to confirm that the version running in TEE has not been altered. This is where hardware and cryptography guarantee its integrity.

I find it even more interesting when this mechanism is layered on top of the OHTTP relay. Your request first goes through the OHTTP relay, which can see your IP but only sees encrypted ciphertext and doesn’t know what you asked; then the ciphertext enters the TEE gateway for decryption, where TEE can see the content but not your identity, so it doesn’t know who you are. This two-layer setup ensures that no party can simultaneously access both your identity and what you asked.

I believe this is true verifiable privacy. Your messages are encrypted locally in the browser, with the keys existing only on your device, and the chat history server holds nothing. No need to sign agreements or trust promises; the architecture and hardware enforce this for you. I see #OPG genuinely turning this into an architecture that is worth following up on. $OPG