刘刘浩浩
50 Posts
刘刘浩浩
9 Following
2 Followers
2 Liked
Posts
All
Quotes
See translation
#BinancePickAndWin 昨晚埃及踢澳大利亚那场给我看爽了又捏把汗！开场13分钟阿舒尔头球闪击1-0，结果下半场哈尼乌龙送礼被扳平1-1。加时互爆门将都没戏，拖到点球——萨拉赫勺子稳稳罚进，澳洲连丢俩，埃及四罚全中4-2拿下！队史首次世界杯淘汰赛晋级，法老军团牛逼，下一轮干阿根廷冲啊！
Last month my sister needed to apply for a mortgage. The bank told her to prepare bank statements from nearly three years. She ran to two branch offices; each teller printed a stack of A4 pages for her. On the bottom-right corner of every page, a red stamp was placed, and the timestamp was precise to the minute.
She brought the stack of papers back. The first thing she did was put them in a transparent document sleeve and store them in the home safe. I asked her whether these wouldn’t be the same as what the counter could print later—haven’t they already been stamped? She said it wasn’t like that. The teller told her: every time the documents are printed, it’s that exact moment’s copy. The stamp number and timestamp are unique. If you lose it, the bank won’t give you a second, identical copy. For later audit and review, they only recognize that one.
I watched her put the document sleeve into the safe and just stood there for a moment.
Later, when I flipped through the section about <c-1/> @NewtonProtocol in the whitepaper compliance evidence, the image that came to my mind was exactly that transparent sleeve.
Every time Newton finishes an authorization decision—every single transfer, every time it evaluates a strategy—it generates a cryptographic record on the spot. In the record, it binds: what transaction this was, which strategy was used for the evaluation (which CID), who the participating nodes were, what the aggregated signature is, and what the block height was. It all exists in an on-chain contract called TaskManager.
Just like my sister’s stack of bank statements—what feels unnecessary at the time can be pulled out when you need it.
When regulators want to check why this transfer was authorized back then, there’s no need to dig out the user’s identity information. They can simply pull the proof from the blockchain to verify directly: the strategy was indeed evaluated at that time point, the evaluator was among the nodes that had staked, and it signed.
The challenge mechanism needs it too. If someone suspects the evaluation result at the time was wrong and wants to complain, the on-chain credential is the original evidence.
In traditional finance, many compliance issues aren’t that no review is done. It’s that even when review happens, the evidence isn’t kept clearly. Later, you can’t find the papers when you go back to search the archives—or the internal systems have been updated and the versions don’t match the rules from then. That’s where the arguing starts. Newton engineers this: during evaluation, it fixes the evidence immediately, leaving no room for adding records later.
Before my sister put that stack of statements into the safe, she told me that if you did something, you should leave behind a tangible thing.
Leave a record—if you don’t need it, it’s a wasted record; but if you do need it, not a single page can be missing.
@NewtonProtocol $NEWT #Newt
She brought the stack of papers back. The first thing she did was put them in a transparent document sleeve and store them in the home safe. I asked her whether these wouldn’t be the same as what the counter could print later—haven’t they already been stamped? She said it wasn’t like that. The teller told her: every time the documents are printed, it’s that exact moment’s copy. The stamp number and timestamp are unique. If you lose it, the bank won’t give you a second, identical copy. For later audit and review, they only recognize that one.
I watched her put the document sleeve into the safe and just stood there for a moment.
Later, when I flipped through the section about <c-1/> @NewtonProtocol in the whitepaper compliance evidence, the image that came to my mind was exactly that transparent sleeve.
Every time Newton finishes an authorization decision—every single transfer, every time it evaluates a strategy—it generates a cryptographic record on the spot. In the record, it binds: what transaction this was, which strategy was used for the evaluation (which CID), who the participating nodes were, what the aggregated signature is, and what the block height was. It all exists in an on-chain contract called TaskManager.
Just like my sister’s stack of bank statements—what feels unnecessary at the time can be pulled out when you need it.
When regulators want to check why this transfer was authorized back then, there’s no need to dig out the user’s identity information. They can simply pull the proof from the blockchain to verify directly: the strategy was indeed evaluated at that time point, the evaluator was among the nodes that had staked, and it signed.
The challenge mechanism needs it too. If someone suspects the evaluation result at the time was wrong and wants to complain, the on-chain credential is the original evidence.
In traditional finance, many compliance issues aren’t that no review is done. It’s that even when review happens, the evidence isn’t kept clearly. Later, you can’t find the papers when you go back to search the archives—or the internal systems have been updated and the versions don’t match the rules from then. That’s where the arguing starts. Newton engineers this: during evaluation, it fixes the evidence immediately, leaving no room for adding records later.
Before my sister put that stack of statements into the safe, she told me that if you did something, you should leave behind a tangible thing.
Leave a record—if you don’t need it, it’s a wasted record; but if you do need it, not a single page can be missing.
@NewtonProtocol $NEWT #Newt
See translation
#BinancePickAndWin 昨晚世界杯1/16决赛葡萄牙干克罗地亚那场，我看完直接跪了！上半场闷成0-0，下半场佩里西奇先偷一个，C罗点球扳平还创了淘汰赛最年长进球纪录。最绝的是最后补时莱奥传中，替补拉莫斯泰山压顶2-1反超！格子军团压哨头球被VAR吹掉越位，克罗地亚人直接哭晕。41岁C罗配40岁魔笛最后一舞，这剧本绝了，葡萄牙晋级下轮干西班牙，冲啊！
Last month I accompanied my mom to update her social security card—she had to run to three different banks in a single day. At the first bank, the teller said the photocopy of her ID needed both the front and back on the same page. My mom had two separate copies, so they made her reprint them. The second bank required her household register book, but she didn’t bring it—so we went home to retrieve it. The third bank asked for my mom’s current residential address; she couldn’t provide the house number for the apartment in Beijing because it was a rental. They only processed it after she filled out a form and signed her name.
My mom didn’t complain the whole time. On the way home, she said just one thing: “How do you get a card? Every bank has a different rule.”
Behind this is an old problem—identity verification relies on institutions repeatedly rechecking everything. Rules differ from one place to another, and every time the entire set of materials must be pulled out and reviewed from the beginning. ID photocopies get duplicated over and over. Who keeps the records, how long they’re kept, and whether someone misuses them—ordinary people don’t know.
The Verifiable Credentials for @NewtonProtocol are meant to solve this. The credential is issued once by the issuer, then saved by the user. When an application verifies it, it only checks whether the credential signature is valid and whether the necessary attributes match the rules—no need to look at the underlying documents. To verify an application where the user “completed KYC,” you only need that conclusion. The underlying ID number, residential address, and workplace don’t need to be exposed. The credential is also portable—one credential can be accepted by one app, and the next app recognizes it too, without having to start over.
To describe it with my mom’s example that day: she only needed to do identity authentication once at the location where her household is registered, and obtain a verifiable credential. The first bank verified that “the credential holder is a Chinese resident” and passed without checking the photocopy. The second bank verified that “there is a social insurance enrollment record” and passed without checking the household register book. The third bank verified that “the residence has been filed/recorded” and passed without requiring her to fill out a form on the spot. One credential, three banks—she never had to submit the materials again.
There are also a few things that make me uneasy. Since the credential is in the user’s hands, what happens if the phone is lost? The “recovery mechanism” section in the whitepaper doesn’t address it. If the issuing institution itself behaves badly—if the system is compromised—how trustworthy are the credentials left to be depends on the trust model at the layers below. For a list of issuing institutions trusted by multiple applications, who decides it and whether the process is transparent is an open question.
That day, when my mom got home and sat on the sofa, she said something—“Can’t we just get things done in one go if it can be done in one go?” After reading this section, I thought of her words again.
$NEWT @NewtonProtocol #Newt
My mom didn’t complain the whole time. On the way home, she said just one thing: “How do you get a card? Every bank has a different rule.”
Behind this is an old problem—identity verification relies on institutions repeatedly rechecking everything. Rules differ from one place to another, and every time the entire set of materials must be pulled out and reviewed from the beginning. ID photocopies get duplicated over and over. Who keeps the records, how long they’re kept, and whether someone misuses them—ordinary people don’t know.
The Verifiable Credentials for @NewtonProtocol are meant to solve this. The credential is issued once by the issuer, then saved by the user. When an application verifies it, it only checks whether the credential signature is valid and whether the necessary attributes match the rules—no need to look at the underlying documents. To verify an application where the user “completed KYC,” you only need that conclusion. The underlying ID number, residential address, and workplace don’t need to be exposed. The credential is also portable—one credential can be accepted by one app, and the next app recognizes it too, without having to start over.
To describe it with my mom’s example that day: she only needed to do identity authentication once at the location where her household is registered, and obtain a verifiable credential. The first bank verified that “the credential holder is a Chinese resident” and passed without checking the photocopy. The second bank verified that “there is a social insurance enrollment record” and passed without checking the household register book. The third bank verified that “the residence has been filed/recorded” and passed without requiring her to fill out a form on the spot. One credential, three banks—she never had to submit the materials again.
There are also a few things that make me uneasy. Since the credential is in the user’s hands, what happens if the phone is lost? The “recovery mechanism” section in the whitepaper doesn’t address it. If the issuing institution itself behaves badly—if the system is compromised—how trustworthy are the credentials left to be depends on the trust model at the layers below. For a list of issuing institutions trusted by multiple applications, who decides it and whether the process is transparent is an open question.
That day, when my mom got home and sat on the sofa, she said something—“Can’t we just get things done in one go if it can be done in one go?” After reading this section, I thought of her words again.
$NEWT @NewtonProtocol #Newt
My mom’s credit card supplementary card—my dad holds it. The daily limit is 500. It can only be used for purchases at supermarkets and pharmacies; other merchants can’t be charged.
The day she applied for the supplementary card, she specifically asked the bank customer service three times—“Can it be changed to 1000?” The customer service said it could, but she said no, just 500. When she told me about it, she said it with a laugh—saying, “You don’t have to worry, you dad’s not incapable of trusting, it’s just that every time he goes to the pharmacy he wants to顺手 buy some heart-and-blood-vessel supplements. And once he buys, it’s three or four hundred. The ones he’s bought and not finished yet have been piling up in the cabinet for half a year—one bottle isn’t even opened before another one gets bought and brought home.” She said it wasn’t about how much money it was. It was that he didn’t actually need those things; the doctor hadn’t told him to take them. But the moment he steps into that kind of store, he can’t help wanting to buy.
500 a day—supermarket and pharmacy. She said these two limits pretty casually, but in reality it’s a whole set of rules: the permissions have a clear target (my dad), a clear amount (500), a clear usage scenario (supermarket/pharmacy), and a clear revocation mechanism (press once in the bank app). Whichever condition gets triggered, the card simply won’t go through at the checkout—awkward right there in front of the cashier. But my mom said the awkwardness once is still better than having the house cabinets stuffed full.
Over these two days I flipped through the Newton mainnet Beta whitepaper. The authorization layer there does something pretty similar to the logic of my mom’s supplementary card. For every on-chain action, before it’s put on-chain it first has to pass through an operator network layer and run the Rego policy—allowlist, limit, judicial jurisdiction, blacklist—only after passing will it be allowed. If you want to revoke it, you just change the rule and revoke it; you don’t have to replace the entire wallet. And you don’t have to go one by one to cancel the previously authorized contracts’ approve—doing that would be far more troublesome than what my mom does with the bank app.
Giving someone permission has never meant giving them the whole package. You have to know what can be opened, what can’t, and how fast revocation needs to be. That’s exactly what the authorization layer does: it turns “granting permissions” from something you do once for everything into something you grant a little at a time each time. $NEWT is the payment medium for this authorization layer. The operator relies on EigenLayer re-staking to support economic security—wrongly configured.
With that card, my dad used it for half a year, and the rate at which those heart-and-blood-vessel supplements piled up at home slowed down noticeably. Last week he even brought it up to my mom—saying, “Should we adjust the limit to 800?” My mom said no.
No means no.
$NEWT @NewtonProtocol #Newt
The day she applied for the supplementary card, she specifically asked the bank customer service three times—“Can it be changed to 1000?” The customer service said it could, but she said no, just 500. When she told me about it, she said it with a laugh—saying, “You don’t have to worry, you dad’s not incapable of trusting, it’s just that every time he goes to the pharmacy he wants to顺手 buy some heart-and-blood-vessel supplements. And once he buys, it’s three or four hundred. The ones he’s bought and not finished yet have been piling up in the cabinet for half a year—one bottle isn’t even opened before another one gets bought and brought home.” She said it wasn’t about how much money it was. It was that he didn’t actually need those things; the doctor hadn’t told him to take them. But the moment he steps into that kind of store, he can’t help wanting to buy.
500 a day—supermarket and pharmacy. She said these two limits pretty casually, but in reality it’s a whole set of rules: the permissions have a clear target (my dad), a clear amount (500), a clear usage scenario (supermarket/pharmacy), and a clear revocation mechanism (press once in the bank app). Whichever condition gets triggered, the card simply won’t go through at the checkout—awkward right there in front of the cashier. But my mom said the awkwardness once is still better than having the house cabinets stuffed full.
Over these two days I flipped through the Newton mainnet Beta whitepaper. The authorization layer there does something pretty similar to the logic of my mom’s supplementary card. For every on-chain action, before it’s put on-chain it first has to pass through an operator network layer and run the Rego policy—allowlist, limit, judicial jurisdiction, blacklist—only after passing will it be allowed. If you want to revoke it, you just change the rule and revoke it; you don’t have to replace the entire wallet. And you don’t have to go one by one to cancel the previously authorized contracts’ approve—doing that would be far more troublesome than what my mom does with the bank app.
Giving someone permission has never meant giving them the whole package. You have to know what can be opened, what can’t, and how fast revocation needs to be. That’s exactly what the authorization layer does: it turns “granting permissions” from something you do once for everything into something you grant a little at a time each time. $NEWT is the payment medium for this authorization layer. The operator relies on EigenLayer re-staking to support economic security—wrongly configured.
With that card, my dad used it for half a year, and the rate at which those heart-and-blood-vessel supplements piled up at home slowed down noticeably. Last week he even brought it up to my mom—saying, “Should we adjust the limit to 800?” My mom said no.
No means no.
$NEWT @NewtonProtocol #Newt
See translation
#BinancePickAndWin
上半场看得人想关电视！开场7分钟后防漏人送丢球，贝林被锁死、拉师傅隐身，全队慢悠悠来回倒脚，要不是凯恩大爹下半场梅开二度，戈登边路一上来就喂饼，真要被非洲黑马干回家！赢了是赢了，但这状态碰墨西哥还得被爆锤，索斯盖特（图赫尔）赶紧调啊，别光靠凯恩续命！
上半场看得人想关电视！开场7分钟后防漏人送丢球，贝林被锁死、拉师傅隐身，全队慢悠悠来回倒脚，要不是凯恩大爹下半场梅开二度，戈登边路一上来就喂饼，真要被非洲黑马干回家！赢了是赢了，但这状态碰墨西哥还得被爆锤，索斯盖特（图赫尔）赶紧调啊，别光靠凯恩续命！
Take my mom to the hospital for a follow-up visit on the weekend. The blood pressure medication has been changed a few times over the past two years; this time, the doctor added another diuretic. Back home, I put the new medicine into the plastic pill organizer.
I pulled out the new medication’s package insert to read it—ingredients, dosage, contraindications, interactions, and side effects. It’s a whole sheet crammed with information.
My mom said the doctor didn’t flip through this paper when prescribing.
What the doctor relied on was another ledger—the past two years of the patient’s blood pressure, the liver and kidney markers from the last tests, how good their sleep has been recently, and whether that long-standing issue has been flaring up again. That ledger lives in his mind, in his three decades of experience seeing patients—it's not on the insert.
The insert is rules—everyone can see it. The doctor’s ledger is judgment—only he can see it. They’re not the same thing. The hospital sets it up this way for a reason.
It wouldn’t make sense to simply move it onto the chain.
On-chain compliance has been moving fast these past two years—tokenized government bonds, compliant stablecoins, and lending protocols that require KYC. But when you actually run the contract’s compliance audit, you’re executing a snippet of code on a centralized compliance service provider’s server. After it runs, it spits back a simple “passed.” Once the contract receives the result, it executes immediately. You can’t see what rules were used to run the audit, who ran it, or who’s accountable if something goes wrong.
What @NewtonProtocol does is turn that ledger that only exists in someone’s head into the package insert printed on the pill organizer.
The rules are written in Rego/OPA, the same language used for enterprise cloud policy management. You can see which rules ran, and which steps they checked. The rules aren’t run by a single service provider—it's a collective certification by a group of operators that have staked assets. They sign with BLS aggregation into a compact cryptographic endorsement. If the attestation goes wrong, the staked assets will be slashed and forfeited. EVM-compatible chains share the same set of operators, and one attestation is recognized across different chains. What you see on-chain is the attestation, not the original file. $NEWT is the asset staked by the operators, and it’s also the fee paid by the application to the authorization layer.
In the hospital, the insert belongs to the patient, and the doctor’s ledger belongs to the professional—that’s the division of responsibilities. After moving it onto the chain, this division shouldn’t be copied verbatim. When you pay someone to do a job and someone else performs the compliance judgment for you, that process should come with its own “insert”—it should be visible to you.
$NEWT @NewtonProtocol #Newt
I pulled out the new medication’s package insert to read it—ingredients, dosage, contraindications, interactions, and side effects. It’s a whole sheet crammed with information.
My mom said the doctor didn’t flip through this paper when prescribing.
What the doctor relied on was another ledger—the past two years of the patient’s blood pressure, the liver and kidney markers from the last tests, how good their sleep has been recently, and whether that long-standing issue has been flaring up again. That ledger lives in his mind, in his three decades of experience seeing patients—it's not on the insert.
The insert is rules—everyone can see it. The doctor’s ledger is judgment—only he can see it. They’re not the same thing. The hospital sets it up this way for a reason.
It wouldn’t make sense to simply move it onto the chain.
On-chain compliance has been moving fast these past two years—tokenized government bonds, compliant stablecoins, and lending protocols that require KYC. But when you actually run the contract’s compliance audit, you’re executing a snippet of code on a centralized compliance service provider’s server. After it runs, it spits back a simple “passed.” Once the contract receives the result, it executes immediately. You can’t see what rules were used to run the audit, who ran it, or who’s accountable if something goes wrong.
What @NewtonProtocol does is turn that ledger that only exists in someone’s head into the package insert printed on the pill organizer.
The rules are written in Rego/OPA, the same language used for enterprise cloud policy management. You can see which rules ran, and which steps they checked. The rules aren’t run by a single service provider—it's a collective certification by a group of operators that have staked assets. They sign with BLS aggregation into a compact cryptographic endorsement. If the attestation goes wrong, the staked assets will be slashed and forfeited. EVM-compatible chains share the same set of operators, and one attestation is recognized across different chains. What you see on-chain is the attestation, not the original file. $NEWT is the asset staked by the operators, and it’s also the fee paid by the application to the authorization layer.
In the hospital, the insert belongs to the patient, and the doctor’s ledger belongs to the professional—that’s the division of responsibilities. After moving it onto the chain, this division shouldn’t be copied verbatim. When you pay someone to do a job and someone else performs the compliance judgment for you, that process should come with its own “insert”—it should be visible to you.
$NEWT @NewtonProtocol #Newt
A while back, when I moved, I packed an old wooden chest and stored it in the attic. My college notebooks, copied contracts, worn-out books, and the drawings my child made when they were little were all in there. The chest is locked, and the key is in my own hands. If you want to use any of it, you have to climb up there and unlock it yourself.
Using AI tools these past few years feels the opposite of what you’d expect.
I used ChatGPT for more than a year. Each time I started a new conversation, it still needed me to introduce who I am and what I do all over again. It tells everyone the same script—smart, but it doesn’t recognize people. The “back-end” talks it has supposedly kept on its servers. Recently, there was news that a court required “deleted” chat records to be preserved, and that’s when people realized that deleting doesn’t really mean it’s gone.
Deeper than that. The years of searching for illnesses on various platforms, looking at houses, asking for code, and wandering thoughts in the middle of the night—when you piece them together, it’s more detailed than keeping a diary. They get packaged into a black box to run models, then sold to advertisers, affecting what loans I see, what insurance I get, and what recommendations I get. There’s no way to check, no way to change, and you don’t get even a cent.
It’s like prying open a wooden chest, putting all the items out in the open—yet you can’t get back in yourself.
@OpenGradient Flip this around and talk about it. People in the AI era shouldn’t be serfs who serve as data supply; they should be the owners of their own land. Turn it into a few concrete product points: data stays on your device, encrypted and safeguarded; AI should be allowed to read only the categories you authorize, and it leaves after reading—authorization can be revoked at any time; this “knowing who you are” capability can be carried to any supported application, with the key in your hand so it works wherever you move; the model reads the part you contribute, and there are traceable records on-chain for the results—no mysterious extra accounting calculated in a locked room.
Meanwhile, device security is another matter entirely. What happens inside that authorization window is protected by TEE hardware. The TEE trust root still ties back to the supply chain of the chip manufacturers, and there’s still some distance between design and widespread practical deployment.
If AI really “remembers” what I look like, it wouldn’t be imagining more accurate answers—it would be knowing my mom has high blood pressure, so it avoids high-salt options when recommending recipes; it would be knowing that I asked about mortgage interest rates half a year ago, so when I ask again this time, it first checks whether that loan has been paid off. That kind of “remembering,” kept in your own hands versus kept in some server’s back-end, is two totally different things.
The wooden chest should be in your own attic. The key should be in your own hands. One day, if the AI wants to peek in, you open the lock yourself, take it upstairs, look together, then come back down and lock it again.
I’ll keep looking into this. No rush to move the chest. But the door should be fitted with a lock.
$OPG @OpenGradient #OPG
Using AI tools these past few years feels the opposite of what you’d expect.
I used ChatGPT for more than a year. Each time I started a new conversation, it still needed me to introduce who I am and what I do all over again. It tells everyone the same script—smart, but it doesn’t recognize people. The “back-end” talks it has supposedly kept on its servers. Recently, there was news that a court required “deleted” chat records to be preserved, and that’s when people realized that deleting doesn’t really mean it’s gone.
Deeper than that. The years of searching for illnesses on various platforms, looking at houses, asking for code, and wandering thoughts in the middle of the night—when you piece them together, it’s more detailed than keeping a diary. They get packaged into a black box to run models, then sold to advertisers, affecting what loans I see, what insurance I get, and what recommendations I get. There’s no way to check, no way to change, and you don’t get even a cent.
It’s like prying open a wooden chest, putting all the items out in the open—yet you can’t get back in yourself.
@OpenGradient Flip this around and talk about it. People in the AI era shouldn’t be serfs who serve as data supply; they should be the owners of their own land. Turn it into a few concrete product points: data stays on your device, encrypted and safeguarded; AI should be allowed to read only the categories you authorize, and it leaves after reading—authorization can be revoked at any time; this “knowing who you are” capability can be carried to any supported application, with the key in your hand so it works wherever you move; the model reads the part you contribute, and there are traceable records on-chain for the results—no mysterious extra accounting calculated in a locked room.
Meanwhile, device security is another matter entirely. What happens inside that authorization window is protected by TEE hardware. The TEE trust root still ties back to the supply chain of the chip manufacturers, and there’s still some distance between design and widespread practical deployment.
If AI really “remembers” what I look like, it wouldn’t be imagining more accurate answers—it would be knowing my mom has high blood pressure, so it avoids high-salt options when recommending recipes; it would be knowing that I asked about mortgage interest rates half a year ago, so when I ask again this time, it first checks whether that loan has been paid off. That kind of “remembering,” kept in your own hands versus kept in some server’s back-end, is two totally different things.
The wooden chest should be in your own attic. The key should be in your own hands. One day, if the AI wants to peek in, you open the lock yourself, take it upstairs, look together, then come back down and lock it again.
I’ll keep looking into this. No rush to move the chest. But the door should be fitted with a lock.
$OPG @OpenGradient #OPG
See translation
#BinancePickAndWin
卧槽今晚淘汰赛开炸！先看凌晨科特迪瓦打挪威，哈兰德+厄德高双核发威，非洲大象反击也够野，看好魔人一锤定音小胜或拖点。重头戏法国干瑞典，姆巴佩突突大巴，瑞典苟得住上半场但架不住法国深度，高卢雄鸡稳晋级。早场墨西哥高原主场碰厄瓜多尔，阿兹特克气氛拉满，东道主小优！单场定生死，冷门随时来，熬夜值！
卧槽今晚淘汰赛开炸！先看凌晨科特迪瓦打挪威，哈兰德+厄德高双核发威，非洲大象反击也够野，看好魔人一锤定音小胜或拖点。重头戏法国干瑞典，姆巴佩突突大巴，瑞典苟得住上半场但架不住法国深度，高卢雄鸡稳晋级。早场墨西哥高原主场碰厄瓜多尔，阿兹特克气氛拉满，东道主小优！单场定生死，冷门随时来，熬夜值！
These past two days, while taking walks, I kept mulling over one thing—the AI space, and how my focus may have been off earlier.
I flipped my notebook back to last week’s page and wrote down a passage: how beautifully a model answers isn’t the important part. What matters is whether that answer can be verified. Not long ago I used tools to organize information. For the same publicly available material, across two conversations, the numbers it gave didn’t quite match. At the time I couldn’t tell which version was correct, so I saved both.
Sitting back at my desk, I felt a bit dazed—an output that can’t be traced. The smarter the model, the more it amplifies risk rather than shrinking it.
So I went through document @OpenGradient , reread it several times, and finally caught the flavor: it doesn’t treat verification as the kind of “patch action” after reasoning.
I thought the design of networks like this is to make reasoning strong first, then add a layer of validation on top. But it isn’t arranged that way. One module does reasoning, another does verification—parallel and independent. From the start, it puts two things on equal footing: “how the answer is believed” and “how the answer is generated.”
Once you turn that corner, my understanding of @OpenGradient Chat changes too. Before, I thought it was just a chat interface onboarding new users. But now it seems more like a hub—on the surface it’s conversation, underneath it’s the entry point that routes real requests into the verification layer. The user asks questions, the model runs inference, the verification network independently provides endorsement, and on-chain settlement happens with the four roles doing their own jobs that none can replace.
Earlier, I used to focus on how many models get uploaded to Model Hub. Now I think that number has limited reference value. More models just means a longer shelf—you have to see whether anyone actually comes to pick them up. Whether real verification-layer calls can keep up with model growth is what matters. If Chat can keep bringing in high-frequency demand, then the verification layer will be continuously used, tested, and refined. What’s accumulated won’t be the form described in documents—it will be the shape it takes after being called countless times.
I also re-understood $OPG . It doesn’t seem like governance tokens as I previously thought. More like a line stitching together requests, verification, and settlement— the more it’s used, the tighter that line gets.
There’s also the weighing part. The capacity for the verification layer to run independently has to be observed after the mainnet runs for a while. Whether Chat can consistently push real traffic into the system is one variable. And the actual data from verification calls that’s disclosed publicly isn’t that much either. These things have to wait.
Next, I plan to shift my focus from the number of models to the verification layer’s call activity, and see whether it grows along the path implied by my current assumptions.
$OPG @OpenGradient #OPG
I flipped my notebook back to last week’s page and wrote down a passage: how beautifully a model answers isn’t the important part. What matters is whether that answer can be verified. Not long ago I used tools to organize information. For the same publicly available material, across two conversations, the numbers it gave didn’t quite match. At the time I couldn’t tell which version was correct, so I saved both.
Sitting back at my desk, I felt a bit dazed—an output that can’t be traced. The smarter the model, the more it amplifies risk rather than shrinking it.
So I went through document @OpenGradient , reread it several times, and finally caught the flavor: it doesn’t treat verification as the kind of “patch action” after reasoning.
I thought the design of networks like this is to make reasoning strong first, then add a layer of validation on top. But it isn’t arranged that way. One module does reasoning, another does verification—parallel and independent. From the start, it puts two things on equal footing: “how the answer is believed” and “how the answer is generated.”
Once you turn that corner, my understanding of @OpenGradient Chat changes too. Before, I thought it was just a chat interface onboarding new users. But now it seems more like a hub—on the surface it’s conversation, underneath it’s the entry point that routes real requests into the verification layer. The user asks questions, the model runs inference, the verification network independently provides endorsement, and on-chain settlement happens with the four roles doing their own jobs that none can replace.
Earlier, I used to focus on how many models get uploaded to Model Hub. Now I think that number has limited reference value. More models just means a longer shelf—you have to see whether anyone actually comes to pick them up. Whether real verification-layer calls can keep up with model growth is what matters. If Chat can keep bringing in high-frequency demand, then the verification layer will be continuously used, tested, and refined. What’s accumulated won’t be the form described in documents—it will be the shape it takes after being called countless times.
I also re-understood $OPG . It doesn’t seem like governance tokens as I previously thought. More like a line stitching together requests, verification, and settlement— the more it’s used, the tighter that line gets.
There’s also the weighing part. The capacity for the verification layer to run independently has to be observed after the mainnet runs for a while. Whether Chat can consistently push real traffic into the system is one variable. And the actual data from verification calls that’s disclosed publicly isn’t that much either. These things have to wait.
Next, I plan to shift my focus from the number of models to the verification layer’s call activity, and see whether it grows along the path implied by my current assumptions.
$OPG @OpenGradient #OPG
On Sundays, I’ll have time to go through a few pages of notes on AI on the chain these days. One question keeps looping in my mind—where does the chain’s “judgment” actually come from?
In the past, I didn’t think about it specifically. On the contract layer, the default assumption is that it’s a container for rules: conditions come first, then when triggered, it executes. But with the bear market replays we’ve seen lately—liquidations, arbitrage, the draining of value—I’m increasingly convinced that this container only solves half the problem. It can execute literally, but it can’t guarantee that, at the moment of execution, it’s truly aligned with the real-world scenario. The code might be correct, yet the contract can’t tell whether what’s in front of it is ordinary market noise or someone has shaped the situation into something that makes it trigger. This “judgment” layer has been missing on-chain.
@OpenGradient is one of the few projects I’ve seen that positively addresses this. It pulls real-time on-chain data, feeds it into a model, then sends the results back as contract parameters. It moves the decision from the outside to the inside—turning a single layer into a dual layer: rules outside, judgment inside.
But what I can’t skip is not what it does, but what its judgment relies on.
Let me give an analogy. An old fisherman goes out onto the sea to look at clouds, wind, and fish bobbers—reading the signs from the sky and water, and it’s far more accurate than a chart. But if someone quietly scatters dead fish into a certain patch of sea at night, then in the daytime he sees the fish bobbers active, assumes it’s a great spot to fish, and ends up with an empty net. The problem isn’t his experience—it’s that the “scene” presented to him on that sea patch has been deliberately arranged.
On-chain data is a public ledger, but “public” and “not pre-arranged” are two different things. Every transaction can be written to the chain, and every lure can be as well. If you construct events that look superficially anomalous yet are actually bait, and inject them into the time window sampled by node nodes, then the model reads a scenario that has been arranged. The contract’s next actions are perfectly self-consistent within its own logic—only the self-consistency is built on an input that someone has manipulated. The cost to attack this layer may be much lower than going after code vulnerabilities.
Moreover, the model’s logic for filtering abnormal inputs is not published with much detail, and there isn’t much cross-node verification and discussion. The mechanism today is still far from “repeatedly refined under a malicious environment”—the new defenses and the defenses that have gone through real, hard testing are not the same thing.
The direction is right; maturity can’t be substituted with vision. I’ll hold a small position to observe how nodes iterate on polluted inputs and whether the transparency of incident post-mortems improves. Until then, I won’t treat it as de-duplicated infrastructure that’s already been validated.
I believe on-chain judgment will eventually be filled in. But when it’s filled in to the point that it can withstand malicious environments—that day, this track will still need a few more rounds.
$OPG @OpenGradient #OPG
In the past, I didn’t think about it specifically. On the contract layer, the default assumption is that it’s a container for rules: conditions come first, then when triggered, it executes. But with the bear market replays we’ve seen lately—liquidations, arbitrage, the draining of value—I’m increasingly convinced that this container only solves half the problem. It can execute literally, but it can’t guarantee that, at the moment of execution, it’s truly aligned with the real-world scenario. The code might be correct, yet the contract can’t tell whether what’s in front of it is ordinary market noise or someone has shaped the situation into something that makes it trigger. This “judgment” layer has been missing on-chain.
@OpenGradient is one of the few projects I’ve seen that positively addresses this. It pulls real-time on-chain data, feeds it into a model, then sends the results back as contract parameters. It moves the decision from the outside to the inside—turning a single layer into a dual layer: rules outside, judgment inside.
But what I can’t skip is not what it does, but what its judgment relies on.
Let me give an analogy. An old fisherman goes out onto the sea to look at clouds, wind, and fish bobbers—reading the signs from the sky and water, and it’s far more accurate than a chart. But if someone quietly scatters dead fish into a certain patch of sea at night, then in the daytime he sees the fish bobbers active, assumes it’s a great spot to fish, and ends up with an empty net. The problem isn’t his experience—it’s that the “scene” presented to him on that sea patch has been deliberately arranged.
On-chain data is a public ledger, but “public” and “not pre-arranged” are two different things. Every transaction can be written to the chain, and every lure can be as well. If you construct events that look superficially anomalous yet are actually bait, and inject them into the time window sampled by node nodes, then the model reads a scenario that has been arranged. The contract’s next actions are perfectly self-consistent within its own logic—only the self-consistency is built on an input that someone has manipulated. The cost to attack this layer may be much lower than going after code vulnerabilities.
Moreover, the model’s logic for filtering abnormal inputs is not published with much detail, and there isn’t much cross-node verification and discussion. The mechanism today is still far from “repeatedly refined under a malicious environment”—the new defenses and the defenses that have gone through real, hard testing are not the same thing.
The direction is right; maturity can’t be substituted with vision. I’ll hold a small position to observe how nodes iterate on polluted inputs and whether the transparency of incident post-mortems improves. Until then, I won’t treat it as de-duplicated infrastructure that’s already been validated.
I believe on-chain judgment will eventually be filled in. But when it’s filled in to the point that it can withstand malicious environments—that day, this track will still need a few more rounds.
$OPG @OpenGradient #OPG
See translation
#BinancePickAndWin
卧槽！淘汰赛第一炮就是南非干加拿大，历史首次双双进32强，赢球直接写队史！加拿大主场加持，戴维斯左路起飞+乔纳森·大卫吃饼，纸面略强；但南非小组末轮绝杀韩国够硬，莫科纳回归中场绞杀，反击也有两下子。看好枫叶兵多将广小胜或拖进点球，非洲雄狮想续命得先把阿方索掐死。单场定生死，加时+点球都不意外，熬夜值！
卧槽！淘汰赛第一炮就是南非干加拿大，历史首次双双进32强，赢球直接写队史！加拿大主场加持，戴维斯左路起飞+乔纳森·大卫吃饼，纸面略强；但南非小组末轮绝杀韩国够硬，莫科纳回归中场绞杀，反击也有两下子。看好枫叶兵多将广小胜或拖进点球，非洲雄狮想续命得先把阿方索掐死。单场定生死，加时+点球都不意外，熬夜值！
Weekend I flipped through the AI project notes I’d been reading these past few days. I meant to pick up a few conclusions, but as I kept flipping, I realized I’d been comparing only the surface layer. Which model answers more reliably, which company’s interface feels smoother—those differences exist. But slowly I started to think about what truly determines whether an AI product can run long-term: it isn’t those points.
These days, nearly every project is competing by iterating on models. Yet the model is precisely the part of the whole architecture that’s cheapest to swap out. This year everyone uses GPT; next year they might all migrate to someone else. Whether a network can really stand depends on how the underlying web of coordination is woven.
@OpenGradient has a few foundational things I keep revisiting. HACA splits the nodes that perform inference and the nodes that verify results into two distinct roles, each handling its own portion. Trustworthiness doesn’t hinge on the logic of redundant computation—“everyone computes the same answer.” Instead, it rests on the post-verification mechanism. This separation is interesting—because it effectively replaces the location where “reliability” is carried.
I pulled TEE out on its own to think it through. It locks the inference process inside hardware-level isolated enclaves. On the cloud side, operations and maintenance only ever sees ciphertext. What the model runs, and which segment of weights it uses—outside observers can’t see. This is masking on the compute side.
Oblivious HTTP does another thing on top of the request path. From the moment the user initiates the request to the point the model receives it, no step can map “who asked” to “what was asked.” This is masking on the transport side.
With these two layers stacked together, it’s not that the model answers more accurately. Chat feels dependable because the entire chain—from initiation to execution—is shielded end to end.
I also went over the role $OPG plays in the network. It’s more like a settlement intermediary among several roles—paying for models, compensating the running nodes, issuing reimbursements to application developers, and sending incentives to contributors based on network contributions. Whether these flows of money can be balanced is far easier to guess than the strength of the models.
Looking back at MemSync, I originally thought it was just about long-term AI memory. But what it may truly be solving is something else—whether user preferences, context, and habits left across different AI tools can flow across platforms. If this can’t be done, an AI-native application will always remain an island.
I weighed a few things again, too. How much load the verification nodes can carry can only be known after running for a while. The effectiveness of Oblivious HTTP’s dependency on external relays also needs to be tested. And for MemSync’s deployment, the key hinges on whether the large-model vendors are willing to adopt the same set of protocols—there’s no clear answer.
No conclusions, then. This time I only managed to smooth out a few places I couldn’t figure out. There are also a few more pieces of material I want to go back and read.
$OPG @OpenGradient #OPG
These days, nearly every project is competing by iterating on models. Yet the model is precisely the part of the whole architecture that’s cheapest to swap out. This year everyone uses GPT; next year they might all migrate to someone else. Whether a network can really stand depends on how the underlying web of coordination is woven.
@OpenGradient has a few foundational things I keep revisiting. HACA splits the nodes that perform inference and the nodes that verify results into two distinct roles, each handling its own portion. Trustworthiness doesn’t hinge on the logic of redundant computation—“everyone computes the same answer.” Instead, it rests on the post-verification mechanism. This separation is interesting—because it effectively replaces the location where “reliability” is carried.
I pulled TEE out on its own to think it through. It locks the inference process inside hardware-level isolated enclaves. On the cloud side, operations and maintenance only ever sees ciphertext. What the model runs, and which segment of weights it uses—outside observers can’t see. This is masking on the compute side.
Oblivious HTTP does another thing on top of the request path. From the moment the user initiates the request to the point the model receives it, no step can map “who asked” to “what was asked.” This is masking on the transport side.
With these two layers stacked together, it’s not that the model answers more accurately. Chat feels dependable because the entire chain—from initiation to execution—is shielded end to end.
I also went over the role $OPG plays in the network. It’s more like a settlement intermediary among several roles—paying for models, compensating the running nodes, issuing reimbursements to application developers, and sending incentives to contributors based on network contributions. Whether these flows of money can be balanced is far easier to guess than the strength of the models.
Looking back at MemSync, I originally thought it was just about long-term AI memory. But what it may truly be solving is something else—whether user preferences, context, and habits left across different AI tools can flow across platforms. If this can’t be done, an AI-native application will always remain an island.
I weighed a few things again, too. How much load the verification nodes can carry can only be known after running for a while. The effectiveness of Oblivious HTTP’s dependency on external relays also needs to be tested. And for MemSync’s deployment, the key hinges on whether the large-model vendors are willing to adopt the same set of protocols—there’s no clear answer.
No conclusions, then. This time I only managed to smooth out a few places I couldn’t figure out. There are also a few more pieces of material I want to go back and read.
$OPG @OpenGradient #OPG
See translation
#BinancePickAndWin
卧槽今晚收官大戏！莫德里奇最后一舞带队死磕加纳，格子赢球才稳，输了一堆人看脸色，老骨头够燃！英格兰碰已出局的巴拿马，凯恩不刷够数据说不过去，妥妥大胜打卡。阿根廷替补也够约旦喝一壶，梅西可能上来溜两脚找感觉。C罗碰南美冠军哥伦比亚，这小组头名争夺火药味拉满。阿尔及利亚vs奥地利平了双赢出线，搞不好默契局闷平——四场出线悬念明早全揭晓，兄弟们熬住！
卧槽今晚收官大戏！莫德里奇最后一舞带队死磕加纳，格子赢球才稳，输了一堆人看脸色，老骨头够燃！英格兰碰已出局的巴拿马，凯恩不刷够数据说不过去，妥妥大胜打卡。阿根廷替补也够约旦喝一壶，梅西可能上来溜两脚找感觉。C罗碰南美冠军哥伦比亚，这小组头名争夺火药味拉满。阿尔及利亚vs奥地利平了双赢出线，搞不好默契局闷平——四场出线悬念明早全揭晓，兄弟们熬住！
See translation
#BinancePickAndWin 昨晚德国爆大冷被厄瓜多尔2-1逆转，萨内闪击白给，普拉塔角球反超绝杀，日耳曼战车照样头名出线，厄瓜多尔搭末班车。科特迪瓦佩佩梅开二度2-0送库拉索回家，象军历史性出线！日本前田大然先拔头筹被瑞典埃兰加扳平1-1，蓝武士小组第二碰巴西；荷兰范赫克头槌锁定3-1突尼斯头名。土耳其居莱尔神仙球+艾汉补时绝杀3-2美国，可惜赢球仍出局，澳洲闷平巴拉圭0-0靠净胜球晋级。这夜值了！
One interesting thing about AI this year is that, within the same track, two completely different paths have emerged.
On one side, there are projects with lots of flair in their page design, names that include “AI,” and contract logic that’s no different from traditional DEXs. “AI” is just a label—some attractive UI, a whitepaper that sounds plausible, and riding the wave of narrative to grab traffic. After watching, I felt a bit disappointed—this approach is essentially “narrative consumption,” burning through the hard-earned attention the industry has built up, wave after wave.
The other path is much quieter. @OpenGradient is the latter. I studied its route map for a long time and found it didn’t really touch those popular C-end entry points—stories about AI writing, image generation, and agents that anyone can talk about weren’t emphasized much. What it’s doing is more foundational: turning reasoning capability into compute resources that can be directly called by a blockchain. On-chain, even running a simple judgment model used to make gas skyrocket. What it changes is this bottom layer—allowing ordinary contracts to mount model analysis, and sinking “AI” from the application layer down into the infrastructure layer.
I don’t think the market has priced this properly yet. In the early stages, infrastructure projects are rarely valued based solely on narrative—value only becomes visible once real people build on top of it and it runs under real loads, and then the market responds. The current price signals may not reflect the true position.
That said, I don’t want to be overly optimistic either—there are a few things I have questions about.
First is privacy computation, betting on trusted execution environment (TEE) nodes. It sounds decentralized, but the hardware layer can’t be avoided—deep inside the motherboard, instruction privileges are controlled by a few chip manufacturers. If the hardware side has any issues, the decentralization narrative gets torn open a gap. This is the ceiling of the TEE route itself.
Second is the few frames of latency for putting inference on-chain. From the user’s perspective it’s just a few seconds, but for MEV searchers, there’s far too much they can squeeze in. Whether the protocol layer has a fallback or safeguard is something I haven’t confirmed yet—I still need to read the documentation more carefully.
Third is that early investment shares are locked until Q1 of 2027. The circulating supply is currently under a controlled phase, and as the unlock window approaches, price behavior will be different from what it is now. This is a matter of timing, not quality—but it needs to be accounted for in the portfolio calculation.
Be patient. First, wait to see the real usage after the mainnet rollout. Infrastructure-level judgment shouldn’t be rushed—it needs time to run for a while.
$OPG @OpenGradient #OPG
On one side, there are projects with lots of flair in their page design, names that include “AI,” and contract logic that’s no different from traditional DEXs. “AI” is just a label—some attractive UI, a whitepaper that sounds plausible, and riding the wave of narrative to grab traffic. After watching, I felt a bit disappointed—this approach is essentially “narrative consumption,” burning through the hard-earned attention the industry has built up, wave after wave.
The other path is much quieter. @OpenGradient is the latter. I studied its route map for a long time and found it didn’t really touch those popular C-end entry points—stories about AI writing, image generation, and agents that anyone can talk about weren’t emphasized much. What it’s doing is more foundational: turning reasoning capability into compute resources that can be directly called by a blockchain. On-chain, even running a simple judgment model used to make gas skyrocket. What it changes is this bottom layer—allowing ordinary contracts to mount model analysis, and sinking “AI” from the application layer down into the infrastructure layer.
I don’t think the market has priced this properly yet. In the early stages, infrastructure projects are rarely valued based solely on narrative—value only becomes visible once real people build on top of it and it runs under real loads, and then the market responds. The current price signals may not reflect the true position.
That said, I don’t want to be overly optimistic either—there are a few things I have questions about.
First is privacy computation, betting on trusted execution environment (TEE) nodes. It sounds decentralized, but the hardware layer can’t be avoided—deep inside the motherboard, instruction privileges are controlled by a few chip manufacturers. If the hardware side has any issues, the decentralization narrative gets torn open a gap. This is the ceiling of the TEE route itself.
Second is the few frames of latency for putting inference on-chain. From the user’s perspective it’s just a few seconds, but for MEV searchers, there’s far too much they can squeeze in. Whether the protocol layer has a fallback or safeguard is something I haven’t confirmed yet—I still need to read the documentation more carefully.
Third is that early investment shares are locked until Q1 of 2027. The circulating supply is currently under a controlled phase, and as the unlock window approaches, price behavior will be different from what it is now. This is a matter of timing, not quality—but it needs to be accounted for in the portfolio calculation.
Be patient. First, wait to see the real usage after the mainnet rollout. Infrastructure-level judgment shouldn’t be rushed—it needs time to run for a while.
$OPG @OpenGradient #OPG
Log in to explore more content