星禾-66

When researching the Newton Privacy Envelope, there was one detail I kept confirming multiple times: decrypting data isn’t something that can be done just by coordinating with telecom operators—it also requires both the user’s signature and the application’s signature. If either one is missing, decryption cannot proceed.

Specifically: the ciphertext is bound to a particular policy client, chain, and intent, which prevents the ciphertext from being replayed across contexts. Decryption requires a double signature—users sign with Ed25519 to bind their identity to the specific data reference and intent; the application also signs with Ed25519 to prove that the user has given consent. Only when both signatures are present can the telecom operator trigger the threshold decryption process.

The practical implication is this: even if someone obtains enough decryption shares from multiple telecom operators, without the user adding the application + user dual signatures, those shares are useless. Telecom operators cannot unilaterally decrypt any user data; they must have proactive participation from both the user and the application.

At first, I thought this was merely an access control mechanism. Later, I realized it changes the ownership logic of data across this entire system—the right to decrypt data doesn’t reside with Newton or the operators; it resides in the combination of the user and the application.

What I still haven’t fully worked out is: if the application itself is compromised or its private key is leaked, how much does this protection partially fail? Ultimately, the security of the application signature depends on the application’s own key management quality—Newton can’t control that layer.

@NewtonProtocol $NEWT #Newt
#newt
Do you think the design of “user + application dual signatures required for decryption” is reasonable for real-world integration?

To automate strategy execution with latency sensitivity, I used to focus mainly on the on-chain execution part. After studying Newton’s process, I realized that the latency design of the authorization decision stage itself has a detail I hadn’t noticed before.

Multiple operators independently fetch external data, and the values each one receives may differ slightly. If everyone is required to synchronize and confirm the data before signing, then you have to wait for the slowest node—meaning the entire latency is determined by the worst performer.

Newton splits the process into two phases. In the first phase, each operator fetches its own data and signs proof of what it has received; the Gateway then uses median consensus to produce a unified dataset. The second phase is when everyone runs strategy evaluation against the same dataset. Once the BLS signature aggregation fills the required staking-weight threshold, it exits without waiting for the final node to be ready.

At first, I thought the two phases were only to solve the data consistency problem. Later, I noticed that they also change the determining factors for latency: the total time depends on the faster batch of operators, not the slowest one. These two issues are handled together with the same design.

What I haven’t fully verified yet is robustness under extreme conditions. If network conditions are poor or the operators’ geographic distribution is highly uneven, how good will the quality of median consensus be? I don’t yet have enough real-world data over a long enough period to judge.

@NewtonProtocol $NEWT #Newt
#newt $NEWT
When you evaluate chain-based automation tools, what’s roughly the maximum tolerance you have for authorization latency?

I’ve always felt that the feature “An AI Agent helps you manage your treasury yield” sounds far bigger than what it can realistically do—until I reviewed the integration logic between Newton Protocol and Vaults.fyi, and realized this actually can be implemented.

Let me explain what it specifically does. Vaults.fyi is a data platform that tracks on-chain vault APYs in real time, with broad coverage and support for 7-day and 30-day period granularity.

Newton plugs this data source into the Agent execution layer as a WASM sandbox plugin. After integration, the functionality is: before the AI trading agent allocates user funds into which vault, it must first query Newton for that vault’s 30-day annualized yield. Only if the yield meets a preset threshold will the transfer operation be allowed by the on-chain contract; otherwise, it is outright rejected.

The value of this guardrail isn’t “smartness”—it’s “enforcement.”

Many earlier yield aggregation tools claimed to have a similar logic, but that logic lived in the Agent’s code. If there’s a bug in the code, or the data interface goes down, or the operator changes things intentionally, then that “yield threshold condition” becomes meaningless. Newton’s constraint is defined at the zkPermissions layer: authorization is bound into on-chain execution via a zk proof. If a valid proof that satisfies the conditions isn’t provided, the contract rejects it at the protocol level.

Another detail is data trustworthiness. If external APY data could be manipulated, then the guardrail would be fake. Newton’s data integration uses WASM sandbox execution plus ECDSA-signed output. Each operator node independently pulls the numbers; the results come with cryptographic signatures, so tampering can be detected. This effectively adds verifiability to the data itself—not just trusting that the data platform wouldn’t do anything shady.

From a real on-chain operations perspective, this solves a long-standing headache for me: when the market is volatile, many yield aggregation strategies can misallocate funds into vaults whose yield has already collapsed due to sensing/latency delays. The losses are very real. With a real-time on-chain yield guardrail, at least this risk-control line becomes quantifiable and verifiable—it’s not based on guesswork.

The mainnet Beta is already running; this isn’t a planned feature.
$NEWT @NewtonProtocol #Newt #newt
Have you used any on-chain yield aggregation tools, and then found that the actual APY is very different from what was advertised?

Everyone who has done on-chain strategy knows that Sybil attacks are one of the hardest problems to defend against in DeFi. You can set a cap on rewards and you can set staking thresholds, but if an attacker can create addresses in bulk, these parameters are basically useless—costs are so low they’re negligible, and收益 scales linearly with the number of addresses. This arbitrage space is structural.

Newton Protocol integrates Human Passport for human-machine verification. I’m interested in this integration point because its defense logic is different. The core mechanism of Human Passport is to aggregate users’ on-chain behavior data across platforms and produce a comprehensive trustworthiness score, rather than relying on a single identity document. In the context of agent automation scenarios, this means the strategy engine can include the condition that “the operator is a real, independent human” in its authorization checks. If the condition isn’t met, the strategy will simply not execute for those addresses.

What I care about more is the combined effect of this mechanism and staking economics. With only human-machine verification, attackers can keep farming accounts over the long term to bypass it. With only staking thresholds, in high-reward scenarios the cost of bulk attacks can still be covered. Only when both are combined does the cost of forging actually rise—and it rises non-linearly.

The value of this kind of defensive layer is easy to overlook in a bull market because everyone focuses on returns. By the time a Sybil attack breaks through a protocol’s incentive mechanism, people come back to think about it.

@NewtonProtocol #Newt
#newt $NEWT
When you participate in on-chain activities, do you prioritize a protocol’s Sybil-defense mechanisms?

When I manage my own vault yield strategy, the most annoying part isn’t the strategy itself—it’s the data lag. Many AI trading agents shout about “automatically finding the optimal yield,” but in reality they rely on snapshot data from a few hours ago—or even earlier. By the time your funds actually enter the position, the annualized return has already changed. This kind of “automation” is essentially a delay trap.

By integrating Newton Protocol with Vaults.fyi’s real-time vault yield data, the delay issue feels like it’s been pushed back by a step. Before an agent allocates funds, it can use near real-time annualized yield data for its decision-making. Rules like “only deploy funds in vaults where the 30-day annualized yield is above a certain threshold” are no longer just placeholders—they become conditions that can genuinely be verified at the moment of execution.

I’ve tested similar logic scenarios myself: when traditional robots encounter yield fluctuations, they often have to wait for the next polling cycle before adjusting positions. That window in between is where losses happen—or where you miss out on returns. After making the data source into a real-time guardrail, this window can theoretically be compressed. It’s not some groundbreaking innovation, but for people who focus on execution, these details are what truly determine whether the yield curve looks good.

In this whole workflow, NEWT handles the on-chain actions related to payment permission execution. It hasn’t been packaged up as some kind of mining incentive—and I think that’s pretty pragmatic.

@NewtonProtocol $NEWT #Newt
#newt
How long is the data delay generally in the yield strategy tools you’re using?

Yesterday I stared at the Model Hub for @OpenGradient for a long time and counted the model version numbers one by one.

I noticed something I’d never paid attention to before: the versioning rule is “major version. minor version.” Each version generates its own Blob ID independently, meaning old versions won’t be overwritten and will remain on Walrus permanently.

My first reaction was: that’s quite storage-hungry. If a model iterates twenty times, you end up with twenty complete records.

Then I looked at it from another angle: this isn’t waste—it’s preserving something: the model’s record of mistakes.

In typical AI development, model iteration is one-way. v1 gets replaced by v2, and the traces of v1 basically disappear. No one would go back to check what mistakes v1 made and why it was replaced.

OpenGradient’s versioning mechanism turns this into something traceable.

If a DeFi protocol is using the risk model’s v3 version and something goes wrong, in theory it can go back and check the historical performance of v1 and v2—whether the issue had already existed, but simply hadn’t been discovered.

For developers, this might not have immediate value—everyone’s thinking about using the latest version.
But for post-incident accountability and model quality audits, this design is meaningful: it makes the question of “what mistakes the model has made before” the first time it becomes something you can actually look up, rather than disappearing along with version updates.

What I’m curious about now is whether there are real-world scenarios that would truly use this capability—whether someone would specifically dig through a model’s historical versions to study its mistake trajectory.

$OPG probably isn’t being used much right now, but I think it’s the kind of design that’s “not needed until something goes wrong—then you find out it’s valuable.”

@OpenGradient
#opg $OPG
Have you ever encountered a tool feature that you never had use for in everyday life—until the day something happened and you realized its value?

Today I calculated a number that made me feel a bit uncomfortable.
The total supply of @OpenGradient is 10 billion $OPG , with a fixed cap of 10 billion.

The Foundation controls 15%, i.e., 150 million tokens. Of these, about 50 million tokens are available at launch, and the remaining 100 million tokens are released linearly over 48 months—roughly 2.08 million per month.

Just looking at this figure, releasing 2.08 million per month doesn’t seem like much.

But I put it on the demand side and compared.
Assume that in the first year of the mainnet, 10 DeFi protocols integrate AlphaSense. Each protocol calls the volatility model 1,000 times per day, and each call has a $OPG equivalent value of $0.01.

Total yearly consumption: 10 × 1,000 × 365 × 0.01 = 36,500 USD-equivalent in $OPG .

If $OPG is worth $1, that would be 36,500 tokens consumed per year.

Compared to the Foundation’s release of 2.08 million tokens per month, the yearly consumption is only 0.17% of the supply pressure.

That ratio made me stop and think for a long time.
It’s not that the project is bad—it’s that before demand truly kicks off, supply pressure will keep weighing on the price.

In the first year of the mainnet, for consumption to cover supply pressure, one of the following conditions must hold: the number of protocol integrations isn’t 10 but 1,000, or the cost per call isn’t $0.01 but $1— or both happen at the same time.

Neither of these conditions is impossible, but both require time.

That number—$OPG —made me separate my “direction judgment” from my “position sizing.”

Getting the direction right doesn’t mean it’s the optimal time to enter now.

@OpenGradient #opg
Before the supply-demand balance becomes clear, will you take a heavy position, or wait for confirmation of the signal?

Today I looked at something. It took me about two hours, and in the end I wrote down a conclusion that makes me feel a bit uneasy.

I was reviewing the verification spectrum of @OpenGradient : basic signatures, TEE, and ZKML—three verification methods, with costs ranging from 0 to 10,000x.

Then I worked out a question: if a DeFi protocol really wanted to put high-risk decision-making onto ZKML verification, how much would it actually pay?

I made an estimate.
An AMM risk model where each transaction triggers an AI judgment—100,000 transactions per day—each judgment requiring ZKML verification.

The cost of ZKML is 1,000 to 10,000 times that of ordinary inference. Assuming ordinary inference costs $0.001 per run in $OPG consumption, ZKML would be $1 to $10 per run.

100,000 runs multiplied by $1 means $100,000 per day.
That’s $36.5 million per year.
That number made me stop.
For a DeFi protocol, what does $36.5 million a year in verification cost amount to?

It amounts to a substantial operating expense that needs to be covered from protocol revenue.
This means only top protocols with a large enough TVL and high enough fee income can afford ZKML verification.
Small protocols can’t. Mid-sized protocols might use TEE instead of ZKML.
So the real market for ZKML is much narrower than I originally imagined.

This doesn’t mean ZKML has no value—it means its value is concentrated in a much smaller user base.

$OPG changed how I estimate the overall market size for “verifiable AI.” It’s not that the direction is wrong; it’s that the scale may be overestimated.
@OpenGradient #opg $OPG
Have you ever calculated the real cost of ZKML verification? Has this number changed your view of $OPG ?

There’s a question about $OPG that I’ve asked myself three times, and the answers are different every time.

On this network, what is the real economic unit?

The first time I answered: it’s the $OPG token.

But a token isn’t an economic unit; it’s a settlement instrument. The thing that gets settled using the token is the economic unit.

The second time I answered: it’s the number of inference calls.

But inference calls are a flow metric, not a value metric. One million free test inferences and ten thousand paid production inferences are worth completely different things.

The third time I answered: it’s the number of verifiably executed inferences—and specifically the kind that people keep paying to have repeated.

That answer made me reorder my entire valuation framework for @OpenGradient .

On the testnet, the amount of inference: irrelevant.

After mainnet launch, the amount of paid inference: has some reference value, but it still isn’t enough.

After incentives ebb, the amount of spontaneous paid inference—this is the true economic unit.

I previously saw an analysis that made a similar kind of judgment: when certainty is purchased repeatedly, the story becomes interesting. I think that sentence is right.

The problem is: when will spontaneous paid inference after the incentives ebb actually show up?

This isn’t a question with a formula. It’s a question that can only be answered when that moment arrives.

What I’m doing with $OPG is trying, as much as possible, to think through all the other variables before that time comes.

@OpenGradient #opg
Before or after the incentives ebb, will you make your final decision about whether to hold $OPG ?

When the system is running normally, nobody looks at the verification layer.

That’s an interesting structure.

What @OpenGradient is doing is attaching cryptographic proofs to every AI inference. Choose the level: TEE hardware proofs, ZKML zero-knowledge proofs. Submit the proofs to the chain, where they can be checked forever.

While thinking about this, I’ve had one question stuck in my mind that I couldn’t resolve:

This proof—who is it really for?

Not asking about the answer; I’m asking about actual behavior. In practice, once the AI produces a result, the user uses it. The protocol gets executed. No one goes digging through the proof. As long as the output looks reasonable, nobody questions the process.

Then one day, a protocol has a problem. The money is gone, or less than expected, or went somewhere it shouldn’t. At that point, the on-chain inference proof suddenly becomes very important.

So, to some extent, this infrastructure is preparing for an accident that hasn’t happened yet.

There’s nothing wrong with that. Insurance works on the same logic.

What feels frictionful is this: infrastructure prepared for an accident needs to be widely adopted before the accident happens for its value to be fully realized. But widespread adoption usually happens only after the pain point has already occurred.

It’s the classic chicken-and-egg problem.

The testnet $OPG has already run over 1,000,000 inferences, with more than 2,000 models hosted. Those numbers show the protocol is functioning.

But the variable I care about most isn’t the size of the numbers—it’s how many of those inferences come from the need for verifiability choosing this network, rather than developers just testing it “to see how it goes.”

These two kinds of inference throughput look the same on the data level. But they’re not the same thing.

Have you ever actively chosen a piece of infrastructure because it has a verification layer?
@OpenGradient
#opg $OPG

I’ve seen folks analyze the lock-up structure of $OPG , and they broke down the numbers pretty clearly.

But there’s one thing that analysis didn’t cover: how exactly will the tokens controlled by the foundation be used?

Ecosystem incentives, research grants, governance, network usage—these four uses have completely different impacts on the price of $OPG .

Ecosystem incentives usually mean tokens are distributed to developers and users, ultimately hitting the market, creating real sell pressure.

Research grants go to the team, with a longer holding period, leading to relatively smaller sell pressure.

Governance tokens might be locked for voting participation long-term, generating basically no sell pressure.

If network usage incentives are directly distributed to node operators, the leftover after covering costs will flow into the market.
These four uses, if each takes up 25%, create a certain release pressure structure each month.

If ecosystem incentives take up 60%, it’s a completely different scenario.
I haven’t found any public breakdown of the foundation's token usage ratios for @OpenGradient .

Just because there’s no info doesn’t mean there’s a problem. Early projects adjust their fund uses based on actual needs; locking it down can be a hassle.

But as someone holding $OPG , I think this is a more crucial issue than the lock-up period itself.

The use of the funds has a more direct impact on token price than the schedule does.

The schedule tells you when tokens will hit the market. The usage tells you whether they’ll flood into the market afterward.
@OpenGradient #opg
Have you ever researched the specific uses of the tokens you hold, particularly the foundation's portion?

After crunching the node costs, I sat there and thought for a bit.

It's not whether to run a node, but a more fundamental question.

@OpenGradient The network, in the early days of the mainnet, needs node operators to take a hit and support it.

This isn't new; all early networks have been like this. Early Ethereum miners were also betting on the future, and the electricity costs for the Bitcoin genesis block miners were way higher than the value they mined.
But there’s one key difference.

Bitcoin and Ethereum miners were betting on the token price going up. That bet is pretty straightforward, the logic is clear.

What are the node operators of $OPG betting on?
On the surface, it’s also the token price, but digging deeper, for the token price to rise, real demand needs to emerge.

Real demand needs integration from developers. For developers to integrate, the network needs to have a stable enough node support.

This is a three-tiered dependency chain.

Each layer needs the previous one to be established first.
The node operators are betting on more than just price; they're betting that the entire dependency chain can fall into place in order.

This bet is way more complex than the bet of Bitcoin miners.
I'm not saying this bet isn't worth taking. Just that before you figure out what you’re betting on, you shouldn’t only look at electricity costs and ROI.

$OPG Have you seriously thought about what you're really betting on when holding an early infrastructure token?

@OpenGradient
#opg $OPG

I realized I missed a variable before.

I've been calculating the demand side for AlphaSense—how many protocol integrations, how many calls, how much $OPG consumption.

But I didn't seriously consider the other side of the supply: the quality distribution of inference nodes.

This is something I've started to think is important recently.

OpenGradient's inference nodes are stateless GPU work nodes that anyone can deploy. The network allocates tasks and rewards based on contributions.

The question is: in the early days of the mainnet, when inference demand is still unstable, who will come to run nodes?

I made a simple classification:

Those willing to run nodes early on fall into roughly two categories. One group consists of believers who are bullish on the network long-term, accepting short-term losses while seriously maintaining node quality. The other group is purely gambling on the OPG price, hoping to cover their costs with price appreciation.

The behaviors of these two groups regarding node quality are completely different.

The second group will immediately leave if the $OPG price drops. If a large number of nodes leave simultaneously, the network's inference capacity will sharply shrink, posing a service interruption risk for protocols integrated with AlphaSense.

Protocols will assess this risk before integrating AlphaSense.

So now I have an additional observation metric: after the mainnet launch, how much did the number of nodes change when the $OPG price dropped by 20-30%?

This number tells me the true quality of the node network and is more valuable than just "total node count."

What do you think the ratio of believers to speculators among early node operators is?
@OpenGradient
#opg

I've recently recalculated the supply and demand structure for $OPG .

It's not about the price; it's about a question I've always wanted to clarify: what is the magnitude of the supply pressure from OPG before the demand side really kicks in?

Total supply is 1 billion tokens, with a fixed cap.
In the token distribution structure, ecosystem incentives, team, and investors all have unlocking plans. Following the typical early project distribution, the team and investors probably account for about 20-30%, with lock-up periods and linear release.

Assuming 1% of the total supply is unlocked each month for the first 12 months, that would mean approximately 10 million $OPG tokens entering circulation each month.

The demand side is currently in the testnet phase, with actual $OPG consumption being virtually zero, primarily driven by speculative holding in the market.

This equation will change once the mainnet goes live, but the speed of that change depends on the growth rate of inference calls.

I've done a conservative estimate: if in the first year of the mainnet, there are 10 protocols integrating AlphaSense, with each protocol making 1000 calls per day at an equivalent of $0.01 worth of OPG per call, the total consumption for the year would be around $36.5 million worth of OPG.

If the price of OPG is at $1, that translates to an annual consumption of 36.5 million tokens.

Comparing this to the potential monthly unlock of 10 million tokens, this demand side consumption in the first year of the mainnet won’t be enough to cover the supply pressure.

For the demand side to surpass the supply pressure, we need the number of protocol integrations to exceed my expectations, or the price of $OPG to be low enough to allow for sufficient consumption in terms of volume.

This isn’t bearish; it’s about calculating how fast the mainnet
@OpenGradient needs to expand its ecosystem to maintain token economic balance.

Do you think that in the first year of the mainnet, the inference consumption can cover the unlocking supply pressure?

@OpenGradient
#opg

I did a rough estimate.
If an AMM protocol wants to use @OpenGradient 's volatility AlphaSense to dynamically adjust fees, with calls happening once a minute, that’s 1440 calls a day.

Each call consumes OPG. Let’s assume each call is worth $0.01 in OPG. That means $0.01 in OPG per call, totaling $14.4 a day, which adds up to $5256 a year.
This number isn’t huge.

But if there are 100 protocols doing this, we’re looking at $525,600 in consumption for $OPG over a year. For 1000 protocols, that’s $5.256 million.

And that’s just for the volatility module.
If price prediction AlphaSense is also adopted, the call frequency may be even higher. Sybil detection will spike during the airdrop season.

The issue isn’t whether this model can generate enough consumption.
The real question is: how long will it take to get to 100 protocols after the mainnet launch?

Right now, my judgment is that getting to 10 in the first year would be exceeding expectations.

It’s not that the product is bad. The decision chain for protocol integration is too long—technical assessments, governance proposals, audits, development timelines; conservatively, each protocol takes six months to a year from contact to launch.

So my current assessment of the demand side for $OPG is: the logic holds, but the timeline is longer than the market expects.
This judgment affects my trading rhythm but not my directional outlook.

After the mainnet launch, I’ll start counting the number of protocol integrations, which is the only metric I’m tracking.
How many protocols do you think AlphaSense can integrate in the first year of the mainnet?
@OpenGradient
#opg $OPG

After buying $OPG , the first thing I did was try to find a reason to sell it.

I searched for three days.
What ultimately made me pause wasn't the technical risks.
It was a simple question: why is this network supposed to be better than OpenAI's API?

Not that verifiability isn't important. It's crucial in certain scenarios.
But "important" doesn't equal "developers will choose it".
I did a rough comparison.

Using the x402 protocol with @OpenGradient to call GPT-4.1: first, you need to do the Permit2 authorization, then send the request, get the 402 response, sign the $OPG payment, resubmit, wait for the TEE node to execute, and then the result comes back, proving asynchronous settlement.

Directly using the OpenAI API: write three lines of code, fill in the API Key, call it, and get the result back.

Functionally, OpenGradient wins; it has proof. But in terms of friction, OpenAI wins; it's just way simpler.

This friction gap is something I continuously care about.

Not that friction can't be accepted. In some scenarios, that friction is completely worth it—DeFi agents need auditable reasoning chains, and medical AI requires immutable records.

But those scenarios are niche, at least for now.
Most developers aren't there.

So my current holding logic is: $OPG is a bet that "the scale of high-trust-demand scenarios will expand," rather than betting that "all developers will migrate."

These two market scales are vastly different.
What type of developers do you think will be the core user base for verifiable AI?
@OpenGradient
#opg $OPG