文哥web3社区

An Architecture Overview of @grvt_io in the dead of night— the more I look, the more it seems like this project has something going for it, but the more I look, the less I feel confident.

First, the publicly visible parts. The official documentation is very clear: “matches and stores data off chain and provides smart contract level guarantees of their execution on chain”. Order matching happens off-chain, and the settlement results are guaranteed on-chain via smart contracts. This ZK Stack Validium architecture combined with a centralized limit order book can handle 600,000 orders per second—its speed is indeed close to that of CEX. Spearbit conducted a comprehensive security audit for 28 days in December 2024, and the team is doing real engineering work. That point has to be acknowledged.

But once I break down the technical details, I can’t help raising some doubts.

In the official “Architecture Overview,” there’s a line: “users requests are routed through our Backend infrastructure - the only permissioned entity allowed to execute transactions against our smart contracts”. All requests must go through the GRVT backend, which is the only permitted entity allowed to submit transactions to the L2 contracts. In plain terms: GRVT runs a private chain. If the backend gets compromised, the whole system is exposed. In the Validium mode documentation, the official text also admits that “operator keeps block data confidential”—meaning the data is controlled by the operator. Four-layer contracts plus a private backend entry point means every interface is a potential vulnerability. Audits can cover the code logic, but they can’t cover combination vulnerabilities across layers. Is this multi-layer defense truly blocking vulnerabilities—or just stacking more attack surface? I can’t say.

Now, let’s talk about the tokens. Total supply: 1 billion. Investors: 19.9%, team: 19%, community/airdrop: 28%, and future reserves: 33.1%. Investors plus team plus future reserves add up to 72%—a majority held by investors and insiders. The TGE was pushed from Q1 to the end of June. On the first day after launch, only 18% corresponding to Season 2 and early airdrops were opened. Meanwhile, for the large allocations held by investors and the team, the whitepaper says nothing about the specific unlock schedule.

After raising $33.3 million, backed by ZKsync and Delphi Ventures, the cumulative trading volume reached $177 billion in 2025. But the centralized architecture risks and the transparency issues in the token model are still right there. I’ll only be able to judge the value for ordinary players once the institutions’ unlock rules are completely transparent.

What do you think of this kind of hybrid architecture? Is it good enough, or are you also skeptical? #grvt

After years of on-chain analysis, there was one contradiction I couldn’t figure out: smart contracts are supposed to be tamper-proof, but regulatory rules change all the time, sanctions lists get updated every few days, and you try to connect an immutable thing to a changing world—this mismatch had never been addressed head-on. Only after dismantling the Newton mainnet Beta did I finally see the answer. @NewtonProtocol

Newton separates strategy from code. Rules are written in Rego and decoupled from the contract. Updates to the sanctions list and adjustments to risk thresholds are made by changing configuration—no need to touch code or redeploy. Traditional upgrades either drag on for weeks due to multisig processes, or they require migrating assets by switching contracts; on-chain and off-chain always end up a step out of sync. Newton compresses that gap to almost zero.

There’s also a technical choice that’s been underestimated: strategy verification uses zero-knowledge proofs. Institutions can prove compliance without disclosing their positions and trading counterparties. For institutions, this is a hard requirement—nobody wants to publish their entire order book just to prove they’re clean.

Taken together, these two points mean Newton solves a triangular contradiction: on-chain things must be verifiable; institutions need privacy; regulators need to keep up with changing requirements. The three demands used to clash with each other, but this architecture now covers all of them at once.

Still, governance makes me uneasy. Protocol upgrades are split into two layers: economic parameters can be adjusted by voting, while core logic requires a hard fork. That sounds reasonable, but I couldn’t find the exact thresholds—51% or 66%? Based on staked votes or token holdings? Since the mainnet Beta went live, there hasn’t been any formal proposal. All parameters have been changed via announcements from the foundation. If only foundation nodes need to agree to a hard fork, what’s the difference from just upgrading directly?

$NEWT is currently around $0.04, down quite a bit from the highs. Some in the community call for a rebound; others call it “a PPT in the compliance space.” I understand that divide. Early token circulation supply can be released in ways that easily get battered by sentiment, with little to do with the protocol’s value. From the technical route, making verification a prerequisite and turning it into infrastructure is a self-consistent logic I rarely see in the compliance track. Can this zero-knowledge proof system plus strategy separation really hold up under pressure from large capital?
#newt

Tonight at 3:00 a.m., this semi-final between France and Spain: world No. 2 vs No. 3. In six matches, Mbappé scored eight goals—against Spain, who conceded just 1 goal in six matches. Spear vs shield—who wrote this script?

Let me point out a few details for you to savor.

France’s attack is indeed fierce. In six games, Mbappé hammered in 8; Olise in six matches provided 6 assists. The whole team scored 16. But France has a fatal weakness—at the 2024 Euro semi-final and the 2025 Nations League semi-final, they were sent home by Spain two times in a row. Facing Yamal, Mbappé has won only 2 of their last 10 meetings. Those numbers alone already make you hold your breath for Mbappé.

On Spain’s side, it’s even more ruthless. Unai Simón kept a clean sheet for a stretch of 649 minutes at one point; in six matches, he recorded shutouts in all of them—setting a World Cup record. The 19-year-old Yamal is basically Mbappé’s nemesis; he’s been locking him down. Coming off the bench, Merino delivered match-winning goals as a substitute in two straight games—this bench depth is really scary.

Even more heartbreaking: the semi-final is on France’s National Day. Macron said he’d personally attend if they reached the final. If France loses, that National Day turns into a national mourning.

Here are my random personal predictions—just chatting, don’t take it too seriously.

This match probably won’t be pretty. Spain will definitely control the ball slowly, wearing France down. France will probably sit back and hit on the counter. For the first 60 minutes, it’ll likely be 0-0. Whoever scores first wins. Mbappé’s pace sprinting at the Spanish veteran’s flank is the only chance—but Spain’s back line is too solid. It’s likely to drag into extra time, even penalties.

My feeling is Spain has a slightly bigger chance—63/37. After all, the psychological edge is there: they’ve knocked out France in consecutive major-tournament semi-finals. This team knows exactly how to play France. But for a player like Mbappé—one person can completely change a game. Honestly, it’s really hard to say.

Set the alarm for 3:00 a.m., have the beer ready—who makes the final, we’ll see in the comments section.

#BinancePickAndWin

#BinanceTurns9 #币安9周年
Nine years of shared adversity—thank you, Binance, for guiding us as we explore the world of crypto and unlock limitless possibilities! From 0 to 9, from trading to the Web3 ecosystem, we’ve witnessed countless miracles together. Wishing Binance a happy 9th anniversary 🎂—let’s Build the future together!

Originally, I only wanted to understand what the point of splitting Intent and Policy in @NewtonProtocol is. I flipped through the developer documentation several times before I realized my previous understanding was too shallow.

When I used to write contracts, I was used to stuffing the decision logic directly into the business flow—authorization, conditions, and execution all tightly bundled together. If the code ran, that was considered good enough. Newton’s design is completely the opposite: Intent describes “what I want to do,” Policy decides “whether it can be done,” and the execution layer only has to run the validation results. At first I thought it was just another layer of abstraction. The more I looked, the more I felt that what it really wants to separate is the responsibility boundaries that developers normally mix together by default.

But this architecture also makes it impossible for me to be fully confident. Following the technology stack down: TEE depends on Intel SGX. Vulnerabilities like Foreshadow and Plundervolt—each round of side-channel attacks is a slap in the face to the word “trusted.” The computational overhead of generating proofs with ZKP is several times higher than that of ordinary transactions. The cross-chain bridge of Newton’s own Rollup is itself an additional attack surface. HTX’s report says the mainnet launch is scheduled for Q3 2025, developer tools in Q4, and global multi-chain coverage by 2026. With four layers—TEE + ZK + Rollup + AI—stacked together, each layer by itself is already a tough nut to crack, so the development iteration difficulty rises exponentially.

What concerns me even more is Newton’s dependence on EigenLayer. Policy execution relies on EigenLayer’s restaking nodes to perform consensus validation—this is a shortcut and avoids building validator verification from scratch. But if the underlying restaking contracts have vulnerabilities, or if a large-scale operator gets slashed, the impact will propagate along the dependency chain to Newton. $NEWT has a total supply of 1 billion tokens, with only about 287 million currently circulating, and 94% has not been released yet. The TGE has only been around for a little over a year, and most of the complicated functionality that supports the valuation is still in the roadmap.

Of course, I won’t dismiss it entirely because of this. If the community project really starts reusing the same set of Policy instead of writing critical decisions back into its own business logic, I would be more supportive of what NewtonProtocol wants to change—the underlying mindset for developing on-chain applications.
#newt

I翻到了@grvt_io 的官方文档，翻到“Hybrid Architecture”那节时我停下。FAQ里写得很清楚：“GRVT has a hybrid architecture that is made up of both on-chain and off-chain systems for scalability, security, and privacy.”链下撮合、链上结算。再看数据：600,000笔/秒、亚毫秒级延迟。CEX级速度再加ZK自托管——这组合拳确实漂亮。

但我翻到另一段时愣住了。文档说：“A subset of the off chain actions are pushed to the GRVT chain. These actions are then published as zero-knowledge proofs to verify off-chain transactions on Ethereum.”链下撮合后打包成ZK证明并提交到以太坊。听起来顺，可L2BEAT的风险评估专门点了一句：“Each update to the system state must be accompanied by a ZK proof”。问题就出在这个“must（必须）”上。

ZK证明的生成依赖Boojum虚拟机的特定版本。底层迭代、版本升级，兼容性漏洞也就跟着来了。一旦批量证明验证失效，所有用户的提现、结算都得被堵死。L2BEAT的ZK Catalog还专门追踪各项目的verifier合约，流程是“regenerating Solidity files directly from source code to confirm deployed contracts are legitimate”。他们为什么这么做？因为验证密钥的生成依赖trusted setup，而“SNARKs require a trusted setup”——这就是信任假设。

我算了一笔账。GRVT自研了衍生品撮合、统一保证金、清算专用的ZK电路。把这些逻辑塞进ZK电路里，复杂度远超普通支付类ZK项目。约束过紧导致证明失败；约束不足又可能被人恶意构造出“看似合法”的证明。功能越复杂，潜在漏洞可能就越深。白皮书里把证明速度写得很漂亮，但验证失效时的应对方案却只字未提。

再说TGE。官方确认总供应10亿枚，社区与空投占比28%。一旦解锁6%的空投增量（从22%提到28%），大概率会形成真实的抛压。前几周的宽幅震荡几乎是跑不掉的。

所以我现在的想法是：与其押方向，不如等TGE后真实流动性形成再入场。

你怎么看GRVT这套混合架构？欢迎在评论区分享你的技术分析。
#grvt

If Binance is “the player” wearing the No. 9 jersey, then I’m willing to be that “teammate” who has always stood by your side.

Come to think of it, I’m also something of an “old teammate.” Over the years, we’ve gone through so much together—charging forward in bull markets, holding strong during periods of volatility, and never even thinking about walking away in the lows. Watching Binance grow from that youthful “rookie” into the “superstar” it is today, with more than 300 million users worldwide, there’s really no way to put into words how I feel. In these nine years, Binance has turned community voices into tangible product updates, with 198 improvements and 2,354 pieces of user feedback.

What moves me most is the “customer service Xiao He” who always keeps users in mind. For a co-founder to personally reply to users’ DMs and help everyone recover mistakenly transferred assets year after year—this kind of warmth as a teammate is something no candlestick chart can ever capture.

It’s our ninth anniversary, and the new season has already begun. As a teammate, I want to say: thank you for the companionship and trust over these nine years. For the next nine years, no matter how the market changes, we’ll keep standing shoulder to shoulder and together earn our ranks!

#币安九周年

When I was reading the mainnet announcements on @NewtonProtocol , I noticed that the first batch of data partners were RedStone and Credora—one provides oracles and the other provides credit ratings. At first I found it strange. With an on-chain authorization agreement, why weren’t the partners security audit firms?

After thinking it through, I understood. Newton’s Policy Engine is essentially a judge. No matter how strict you write the rules, whether the judgment is correct ultimately depends on the data fed into it. For example, if the price drops below a threshold, liquidation is triggered. If the data source is manipulated or delayed, the rules being written perfectly won’t help. Its credibility is actually two layers stacked together: the operator network on EigenLayer together with zero-knowledge proofs ensures the computation process isn’t tampered with; but whether the data used as the basis for the judgment is correct is a separate, independent issue.

What concerns me even more is TEE. Newton runs its agent on Phala Cloud, with Intel SGX providing hardware isolation, and remote attestation can verify that the agent executed in a trusted environment. But TEE verifies that the environment is trusted—not that the code is free of flaws. If the agent’s code contains malicious logic, TEE will obediently execute it, and remote attestation will still pass. In that sense, TEE may actually stamp a layer of “trusted” approval on malicious code.

There’s also a practical issue. Newton’s core contracts reserve admin upgrade privileges, controlled by the foundation’s multisig wallet. If any multisig member leaks information or colludes, theoretically they can directly change the contract rules. As for the third-party audit status of the contract, it is currently still “none.”

I agree with Newton’s direction of embedding compliance and risk control into the execution process rather than relying on a post-incident pursuit model. But with these three layers of risk stacked together—dependence on external data providers, TEE not auditing code intent, and the core contract retaining admin privileges—I will wait until third-party audits are in place and the agent reputation scoring goes live before considering entrusting it with my assets.
#newt $NEWT

A friend of mine who’s into quant trading complained to me the other day: running strategies on a DEX is just too hard—speed can’t keep up, and the slippage hurts badly. He sent me a link and said, “Take a look at GRVT. They claim they’re solving this.”

I went through the official documentation for @grvt_io . GRVT uses a hybrid architecture: “off-chain matching with on-chain stored data, and providing contract-level guarantees for on-chain execution.” The matching runs off-chain to maximize speed; settlement and verification are sent back on-chain for security via ZKsync’s Validium technology. The official numbers are very persuasive: peak throughput of 600,000 transactions per second, with sub-millisecond latency.

But then issues show up. Since GRVT uses a Validium approach, data availability is maintained off-chain by a DAC committee. Unlike a standard rollup that publishes full batches to the Ethereum mainnet, transaction data isn’t put on a public ledger. That does indeed prevent front-running and sandwich attacks. But what’s the trade-off? The underlying granularity of the order book is limited for retail users—quant teams want to capture real-time order flow? They’re out of luck.

Now, the account system is another story. GRVT splits accounts into “funding accounts” and “trading accounts.” The funding account handles deposits and withdrawals with extremely strict permissions; the trading account is what you use to trade. The API only lets you access the trading account—private keys aren’t stored. Security is maximized, but for retail users it’s also too heavy: registering requires binding an email, setting up SecureKey, and if you accidentally clear cached data, you might be locked out.

Even the regulatory angle is interesting. GRVT claims it’s the “first licensed DEX globally.” By end of 2024, it obtained a Bermuda M-class license. But the M-class license is essentially a “modified” license with sandbox-style constraints—its audit transparency and depth aren’t on the same level as the EU’s MiCA or the U.S. CFTC.

My take: GRVT’s technical compromises are genuinely smart, and the front-end experience does feel more like CEX. However, the Validium data transparency issues and the controversy over the real value of the license are hurdles you can’t bypass. I plan to wait and observe the actual liquidity depth after TGE before deciding whether to get in. In DeFi, it’s better to trust the code than the slides. #grvt

I’ve been working on on-chain automation for almost two years, and I’m increasingly convinced that this space is stuck in a deadlock: if you let an AI Agent manage your money, you have to give it permissions; but once you hand over permissions, it’s basically handing over the keys to someone else. Market solutions either turn the bot into a centralized system, with security relying on nothing more than “good conscience,” or they move computation onto the chain—where the Gas fees are so high that ordinary users can’t afford it.

What impressed me about Newton Protocol is that it breaks the “trust problem” into an executable technical design. Its three core principles—Scoped Autonomy (limited autonomy), Verifiable Integrity (verifiable integrity), and Earned Reputation (reputation accumulation)—connect pre-constraints, in-process verification, and post-penalties into a closed loop. The AI computation runs inside a TEE; ZKPs are used to generate verifiable proofs; then EigenLayer’s AVS network samples and rechecks. Operators must stake NEWT tokens—if they act maliciously, they’re directly slashed and their assets are forfeited. This mechanism doesn’t depend on “team goodwill,” but instead hardens the game rules through adversarial constraints. I think the direction is right.@NewtonProtocol

But after going through the docs, I also found some issues. ZK verification Gas costs around 230k, which is more than ten times that of a normal transfer. The cost of complex strategies doubles as well, and ordinary users simply can’t use it. What worries me even more is the permission expiration problem: session keys have an expiration time, but the documentation doesn’t mention any “automatic revocation on expiry.” An attacker can capture a ZK proof near expiration and submit it repeatedly, enabling unlimited calls to the user’s authorization. Once a ZK proof is generated, it’s verifiable; the system doesn’t check whether the proof has been used.

Also, although the mainnet Beta has launched, there are still very few advanced models that can generate large amounts of native Gas consumption on-chain. The ecosystem hasn’t truly taken off yet, so it’s still an unknown how much real business activity could burn circulating supply to offset token release pressure.$NEWT With total supply of 1 billion tokens and initial circulating supply of 215 million, there is objectively a long-term selling/pressure effect.

I won’t blindly go all-in just because I like the direction. Verifiable automation is the inevitable path for the industry, but ZK costs, permission risks, and ecosystem deployment data—all of these need continuous tracking. Let’s wait until real usage volume comes in.#newt

I stumbled upon project @grvt_io by chance. It claims it wants to build “the top financial institution on the blockchain,” and even obtained a Bermuda license. Honestly, my first reaction was disbelief. But when I looked through its official documentation, the more I read, the more interesting it seemed.

What attracts me most is its hybrid architecture. The official help docs put it clearly: “GRVT has a hybrid architecture that is made up of both on-chain and off-chain systems for scalability, security, and privacy.” Off-chain matching and on-chain settlement, with a claimed order-matching speed of 600,000 TPS and sub-millisecond latency. The official blog further explains that this architecture is “built as a ZK Stack validium,” using zero-knowledge proofs to protect transaction privacy, with Ethereum handling final settlement. Some people in the community say the experience is “almost CEX-level”—I agree with that assessment, but the real performance on the mainnet still remains to be seen.

Let’s talk about the 2026 roadmap. The official goal is “unifying the entire capital lifecycle around a single programmable balance,” where one balance serves as both margin, yield, and trading. It plans four major layers: earnings, investment, trading, and payments, and also intends to integrate L1 liquidity such as Aave through ZKsync Atlas. The blueprint sounds sexy, but the implementation difficulty is certainly not small.

GRVT’s compliance path is definitely a plus. It secured a Bermuda Class M license by the end of 2024, and already obtained a VASP authorization in Lithuania in 2023. The founders come from top-tier investment banking, and the team’s background is solid.

But I also have some reservations. TVL currently is only around $7–8 million, and some analysis suggests that “the lack of trading activity and on-chain data is not short-term noise, but a structural issue.” Although the tokenomics model has been published—total supply of 1 billion tokens and a 28% community airdrop—its specific distribution mechanism hasn’t been fully implemented yet. Adjustments to the airdrop rules have also sparked some community discussion.

The direction is right—the road ahead is long. The hybrid architecture sounds great: the coordination between off-chain matching and on-chain settlement, the performance overhead of zero-knowledge proofs, and the balance between regulation and decentralization are all tough challenges. Once the mainnet is truly running and the data is out, then we can judge whether it’s a real transformation or just a good story—not too late. #grvt

I’ve been researching derivatives trading on-chain recently, and I found project @grvt_io quite interesting. To be honest, the Perp DEX space is already crowded—old players are firmly entrenched, so what kind of “new magic” could a fresh project actually bring? But after digging through the documentation for a few days, my view changed.

What really impressed me about GRVT is its hybrid architecture. The official technical docs explain it clearly: “GRVT adopts an architecture that matches and stores data off chain and provides smart contract level guarantees of their execution on chain.” In other words, order matching runs off-chain, with speed comparable to centralized exchanges, while settlement and verification happen on-chain, with smart contracts acting as a backstop. The official claims it can reach 600,000 TPS with sub-millisecond latency. I think this approach is genuinely pragmatic—more reliable than pure AMMs, which can be big slippage culprits.

But technology alone isn’t enough. GRVT also introduces a “single balance” design, aiming to let the same pot of funds both earn yield and serve as margin. The official blog puts it this way: “The same deposit can simultaneously earn yield, back a margin position, and even stay exposed to spot price appreciation.” That sounds great and addresses the problem of fragmented capital. Still, I’m a bit uneasy—if this complex mechanism runs in practice, can risk management and liquidation really keep up? Hard to say.

GRVT reportedly holds a Class M license from the Bermuda Monetary Authority, claiming to be the first DEX to obtain a license. Compliance is a double-edged sword: institutional capital may be willing to enter, but KYC blocks anonymous users— and in places like Hong Kong, it’s even inaccessible directly.

I also skimmed through the roadmap. In 2026, it plans to integrate Aave and other L1 liquidity via ZKsync Atlas, and it also wants to launch perpetual contracts for stocks and forex. The ambition is big, but the TGE has been pushed from late June to July, and some people in the community are already questioning delivery capability.

Overall, I think GRVT is worth keeping an eye on. The technical foundation looks solid, and the compliance path is fairly clear. But don’t rush in—after the TGE, let real data and community feedback speak for themselves. A whitepaper can be beautiful, but only the real-world rollout counts. #grvt

I’ve looked at quite a few on-chain automation projects, but it always feels like something is missing. While reading the technical documentation for @NewtonProtocol , I found that someone is solving a problem I’ve been thinking about: how to let an AI agent have freedom without going too far.

Newton’s core is “bounded autonomy”: users use zkPermissions to set an AI agent’s funding limits, operational scope, and trading conditions. These permissions are encoded into zero-knowledge circuits, so the agent can only act within the defined boundaries. Tasks execute inside a TEE; for every step, the system generates a ZKP proof that is verified on-chain. This “compute off-chain, verify on-chain” architecture keeps gas costs manageable, while preserving cryptographic-level verifiability.

But when I read about the cost of ZK verification, I hesitated. On-chain verification gas for Groth16 proofs is about 230,000—more than ten times a standard Ethereum transfer. Complex strategies require multiple proofs, which makes costs double. Ordinary users simply can’t afford it. What also makes me uneasy is that Newton integrates two different ZK-VM frameworks—Succinct and Risc Zero. The underlying cryptographic library logic isn’t uniform; what if cross-framework verification introduces a logical conflict? The documentation doesn’t go into detail.

There’s also a blind spot with session keys: “session keys bound to user-defined policies.” Permissions have an expiry time. But what happens after they expire? I searched the documentation and couldn’t find any explanation of an automatic revocation mechanism. An attacker could capture ZK proofs near expiry and repeatedly submit them within the valid window, enabling unlimited calls to those permissions. The ZK proofs are verifiable, but the system doesn’t check whether the proof has been used before. That’s a classic replay risk.

Of course, the direction is right: on-chain automation needs verifiability, moving from “trust the person” to “trust the rules.” But ZK is too expensive, the revocation mechanism is missing, and the user-experience barrier is still high—these are very real engineering shortcomings. I’ll keep tracking mainnet data and the scale of B2B integrations, and I won’t go all-in just because the narrative sounds grand. How far this architecture can go depends on whether Newton can turn the ideals in its documentation into a reality that stands up to scrutiny.
#newt $NEWT

Last night I pored over the whitepaper for @NewtonProtocol until 3 a.m., and the more I read, the more alert I became. The project wants to build a “verifiable automation layer,” so AI agents can execute on-chain actions for you, with evidence for every step showing nothing was done in a sloppy or unauthorized way. The idea is pretty wild, but when you break it down, there are quite a few issues.

Newton’s core logic is three layers: a model registry that manages the agent identity, a Keystore Rollup that holds users’ permissions, and an automation intent layer that governs execution conditions. Out of all of it, the Keystore is what worries me most. The whitepaper describes it as “a specialized rollup responsible for storing and updating user permissions.” Whether any agent can move your assets depends entirely on it. And this thing runs on delegated PoS—validators stake NEWT to secure it. The logic chain looks flawless: TEE provides the execution environment → ZKP produces proof → Keystore stores authorization → on-chain verification.

But the “wall” of the TEE is thinner than I imagined. I read Binance Research’s report and the exact wording is: “currently utilizes Phala's cloud environment.” Right now, they run TEE using Phala’s cloud. Private keys, session keys, and transaction authorizations all live inside a third-party enclave. In the 2025 TEE.Fail attack, researchers extracted critical keys from Intel TDX and AMD SEV for under $1,000. Phala has also admitted that enclaves might be cloned. A tampered agent can still generate a “everything is normal” Quote, and the on-chain contracts will dutifully sign off.

What makes me even more uneasy is that in the early network, the foundation’s own TEE servers were the dominant force, not a distributed network—it was the foundation calling the shots.

I’m not writing off the direction—if anything, I’m more cautious precisely because I see potential. TEE didn’t eliminate trust; it just shifted trust from the project team to Intel and AMD. My strategy is simple: stay focused and keep my main position unchanged. We’ll talk again once Newton runs successfully with a方案 that doesn’t rely on third-party TEEs. #newt $NEWT