Yoshi Invest

I once thought self-custody was pretty simple: if you keep the private key, then the Bitcoin is still yours.

But while tinkering with the @BabylonLabs_io testnet—an integration that made me stop longer than I expected: Ledger.

Not because hardware wallets are new. Rather, because Clear Signing made me ask a new question: is keeping the key really enough if I don’t understand what I’m signing?

Trustless Bitcoin Vaults (TBV) use Taproot with spending conditions that are set when the vault is created. That makes it crucial to understand exactly what you’re confirming.

This is what’s notable about Ledger Clear Signing: it helps users confirm interaction with TBV on the device using more understandable information before signing. Millions of Ledger signers will be able to interact with TBV.

But for me, that scale isn’t the most interesting part. What matters more is that as self-custody grows, the ability to understand what you’re authorizing must grow with it.

Keep the key and regain control. But that control matters more when the key holder also understands what permissions they’re granting each time they sign.

$BABY #baby @BabylonLabs_io #BABY

Data never lies when, for the first time, I noticed the @BabylonLabs_io testnet data on June 18, 2026: 439 vaults were created, 111 were active, and the TVL was 2.1 sBTC. Those numbers made me start following it.

About 20 days later, I came back: 1.87K vaults, 247 active, and 4.4 sBTC TVL.

At first glance, everything is increasing. But there’s one detail that made me pause: the number of vaults created increased more than 4x, while active vaults and TVL only rose about 2x.

It made me realize that “tried” and “in use” are two very different signals.

With Trustless Bitcoin Vaults (TBV), Xangle Explorer lets you look beyond transaction counts: which vaults are still active, how much collateral is sitting in the system, and that the testnet has recorded 0.52 sBTC liquidations.

Viewing a financial system only through how many times it has been interacted with can paint a very different picture. For me, the more meaningful signal is the gap between how many activities were created, how many positions are actually active, and how much capital is still being maintained in the system.

$BABY #BABY #baby @BabylonLabs_io

After nearly 4 hours of testing the testnet—@BabylonLabs_io đ to borrow 100 USDC using BTC—I realized something interesting: the interesting part isn’t the BTC collateral itself, but the loan-creation architecture.

To use BTC in DeFi, I usually have to wrap it, bridge it, or rely on a third party. But at #baby , native BTC is locked on Bitcoin L1 via Trustless Bitcoin Vaults (TBV), while Babylon Core Spoke connects that collateral to Aave v4’s lending and liquidity.

What I found particularly noteworthy is how this architecture handles liquidation: the liquidator can be settled immediately through a separate liquidity layer, instead of having to wait for the native BTC to be processed on L1 first.

Babylon doesn’t need to rebuild the lending market, and Aave doesn’t need to force BTC out of its native state. Two infrastructures meet—while Bitcoin remains unchanged in essence.

A notable step forward: it’s not about trying to “pull” Bitcoin into DeFi, but about enabling the capital market to access Bitcoin right where it already exists.
$BABY #BABY #baby @BabylonLabs_io

Spend 2 Alpha Points to build the booster wallet #GRVT on 10/7. The final task is that Creatorpad will receive additional $GRVT allocation on the TGE day 21/7. I went through 4 hours of security on @grvt_io to dissect it and found out:
When “invisibility” becomes the pinnacle of security.
In Web3, those multi-million-dollar hacks that bring entire systems down always make us cautious. No matter how strong a system is, there are always hidden risks. So how can we ensure that when risk occurs, my assets automatically and proactively find their way back to my personal wallet?

And when ultimate power belongs to the Blockchain, not to the exchange.
When I deposit to #grvt , the assets aren’t sitting in the exchange’s “pocket” but are locked in a transparent on-chain smart contract. The exchange only has the right to match orders on my behalf based on my signature—absolutely no ability to arbitrarily move or freeze those funds.
When a risk occurs, the user only needs to interact directly with the underlying smart contract to activate the “Emergency Escape Hatch.” After a specified waiting period for the exchange to respond with no signal, the smart contract automatically unlocks and returns all funds to the user’s personal wallet—while the exchange cannot interfere.
It operates completely independently and automatically turns “invisible” security into a weapon.
@grvt_io isn’t trying to build a super-thick wall to protect the exchange; they designed a mechanism so that: even if the system collapses, the user’s assets won’t.
It requires multi-layered, deeply specialized defenses.
A safe system is not allowed to depend on a single layer of protection.

The future Hybrid Exchange: performance + trust + asset safety.
The race for transaction infrastructure—clear and straightforward—has gradually moved to an entirely new chapter.
#GRVT

After the highly controversial market crash in October 2025, confidence in CEXs has once again been called into question.

While the absolute transparency of DEXs forces major investment funds and whales to face a different reality: exposed wallets, exposed strategies, and losing their investment advantage to MEV-scouting bots.

A cruel paradox emerges: To be safe, you must be transparent—but too much transparency becomes a “strategic suicide.”

This reminds me of Ronald Reagan’s classic quote: “Trust, but verify.”

So where should trust be placed so the system can both be verified and protect strategic privacy?

That is precisely the point where @grvt_io comes in.

Instead of forcing users to trade off strategic privacy for verifiability, #grvt keeps the order flow off-chain to minimize the risk of large funds and whales having their strategies exposed.

In return, every matched order result must be accompanied by a cryptographic proof posted on-chain so the network can verify that the final state is valid. This helps shrink the “black box” that users previously had to trust the operator to manage.

What ZK-Proof changes is not trust itself, but how much of it still remains to be based on trust.

GRVT doesn’t eliminate trust. GRVT narrows the scope of trust.

Perhaps in the future, the race among exchanges won’t be about the question “who is more trustworthy,” but about “who can design a better trust model.”

If trust can’t disappear, then isn’t it more important to determine exactly where it should exist? @grvt_io #grvt

Does matching (order matching) really need a Blockchain?
Most of us went through a default Web3 mindset: the more you put on-chain, the better—blockchain can handle more work and that must be better.

At first glance, that sounds completely reasonable. But the system has to sacrifice matching speed and may even put heavy pressure on the blockchain network just because millions of orders are placed and canceled every second by traders.

Maybe the real issue has never been about putting how much onto blockchain, but about what truly NEEDS blockchain. If matching and settlement have entirely different responsibilities, why must they run on the same architecture?

What caught my attention at @grvt_io is that they don’t try to build an all-in-one “everything” system. They separate matching to be processed off-chain because its job is simply to match orders as fast as possible; what needs to be optimized is performance and low latency. Meanwhile, settlement is kept on-chain to fulfill its proper role—transferring assets and recording the final state in an immutable way.

Each component focuses only on its core responsibility. Matching doesn’t need blockchain; only settlement does.
#grvt didn’t split off because it’s a product—that’s the responsibility of the system.

Therefore, a Hybrid Exchange isn’t merely a marketing buzzword combining CEX and DEX. It shapes a new type of trading infrastructure: asset ownership belongs to the blockchain, while operational performance belongs to a system optimized and tuned off-chain.
$LAB $DEXE

Switching 15 minutes per trade for “financial freedom”: Is it worth it?

The “all-in-one” experience of CEX made me forget that I was handing assets over to a third party. It wasn’t until I moved to a personal wallet that the difference became clear: on CEX, a few clicks for trading turned into 15 minutes of fumbling, trying to figure out the next step.

And yet, in the end, I still went back to CEX.

Everyone in crypto has heard the saying: “Not your keys, not your coins.” We all know self-custody is safer.
But then why is a CEX still the choice for most users?

Users don’t refuse self-custody. They just refuse an experience that constantly makes them think about it.
They don’t want self-custody.
They want to forget that custody even exists.

That’s also what caught my attention when I read GRVT’s docs. Instead of viewing self-custody as a problem users need to learn to adapt to, they treat the self-custody experience as the real problem that needs to be redesigned.
By applying Account Abstraction (AA) and a Hybrid Exchange model, GRVT lets you create a wallet using your own Google or Apple account—so you can trade smoothly like on a CEX without having to constantly sign/approve each individual order. Your assets remain yours, but the experience is exactly like Web2.
GRVT doesn’t start from the custody problem.
GRVT starts from the self-custody UX problem.

Maybe the next wave of Web3 competition won’t be about who offers better self-custody, but about who makes self-custody feel like a natural part of the experience.

When self-custody becomes “invisible,” what reason will users have to keep choosing a CEX?
@grvt_io #grvt $TAC $LAB

There was a time when I only wanted to handle a fairly simple transaction.

Withdraw assets from a CEX to a wallet, bridge, approve, swap—then move on to another protocol.

Everything worked exactly as designed. But only after I was done did I realize that what made me the most exhausted wasn’t the transaction fees—it was having to constantly switch between too many systems just to accomplish a single goal.

That made me ask a question: does the problem with crypto lie in each individual product, or in how those products are put together?

That’s why I paid attention to GRVT and spent nearly two hours reading through the project’s docs carefully.

At first, I thought it was just a Hybrid Exchange. But the more I read, the more I realized that GRVT’s documentation doesn’t just revolve around one feature—it also touches on multiple aspects such as the user experience, security, control over assets, and transaction architecture.

Will GRVT’s approaches truly hold up in real-world usage, or are they only sensible on paper?
@grvt_io #grvt $TAC $LAB

SPEED AND THE TRUTH OF AI ON-CHAIN?
I once built a DeFi portfolio management system myself: AI analyzes off-chain and then sends commands to a Smart Contract via a Web2 API. At first it ran incredibly fast, but when real capital started moving, I became uneasy: How can I be sure the intermediary server runs the correct model? Could the result be altered before it goes on-chain?
To solve this, I tried forcing the system to run ZKML so the AI could prove correctness through mathematics. The result was a performance catastrophe: processing speed dropped by 1000x. Transaction commands that once took milliseconds turned into a queue. The on-chain system is safe, but it’s like a “tortoise dragging its feet.”

I then continued with the @OpenGradient Hybrid AI Architecture (HACA) to separate inference and verification across two timelines.
All requests are forwarded directly to the GPU Nodes, returning results immediately with low latency like Web2—without waiting for on-chain block creation time. Then, a new node generates cryptographic proofs and submits them on-chain for Full Nodes to audit.
This thoroughly eliminates the risk caused by the time gap between receiving results and completing verification.
The mechanism cancels out block-creation latency, relieves pressure, and optimizes the user experience.
However, the system still has to rely on the integrity of the GPU hardware.

AI on-chain wins users over with immediacy and transparency. My feedback for #OPG is: $OPG should not only prove dApp performance like Web2 and security like Web3, but also needs to prove the integrity of the GPU hardware.

If future AI shifts from trusting promises to verifying with mathematics, then the AI race is no longer about “speed or security,” but “speed that earns trust.”

Last night at 1 a.m., I swapped 0.7 ETH through 3 Wallets, paid 18.4 USD Gas Fee, ate 2.7% Slippage, and even clicked Approval wrong one more time...

Sitting there watching the Route spin through Bridge and Aggregator felt kind of funny.

Crypto sometimes does not lose because of the market.

It loses because the stack we use is too complicated!

Honestly, I used to think every new chain, new VM, new architecture was good.

Sounded premium.
Sounded like the future.

But when you actually build, you realize the most expensive thing is not Gas Fee, not Funding Fee, and not even a PnL order at -46.8 USD.

The most expensive thing is forcing users to change their habits.

A dApp that makes people move liquidity, relearn Wallet flow, understand Bridge again, wait for Finality again... how is that any different from making customers switch coffee shops just because the cup looks nicer?

The market does not care for things that are “technically right” but behaviorally wrong.

This is why I started paying attention to @OpenGradient not because the word AI sounds shiny.

But because the way it frames the problem is slightly different: keep EVM Compatibility, Solidity, living Liquidity, then insert AI inference as an EVM-native Layer through Precompile.

Sounds small.

Position Data — Cross-chain Price Spread — Market Sentiment → Verifiable AI Output with TEE Proof, so Smart Contract can process Conditional Logic by itself.

No need to tear down the house and rebuild it.
No need to drag users on a pilgrimage to a new chain.

Base has Liquidity, Arbitrum has Assets, Optimism has User Behavior; if Multi-chain AI calls can gather those pieces into the same decision flow, then DeFi AI routing finally has real ground to run on.

I no longer believe the line “good technology will win by itself.”

Good technology that makes the market pay too much friction is still just a beautiful slide!

So which path do you guys choose: rebuild everything clean from scratch, or make what already exists become smarter?
#OPG $OPG @OpenGradient $VELVET $LAB

I find something quite interesting:
Every time a token is listed on a major exchange.
Every airdrop or incentive event starts to attract the attention of a lot of users.
But after the events end, they almost disappear from the market.
So what makes an AI infrastructure token exist so they can keep staying without vanishing?

Most of today’s AI infrastructure tokens focus on attracting users.

@OpenGradient builds Model Hub, where every AI request is paid for with OPG. In my opinion, this is when the token stops being a speculative asset and becomes part of every use of AI.

To do that, #OPG integrates the payment layer x402 directly into every AI request.

Separation between incentive and adoption. One comes from economic benefits, the other from real usage needs.

If incentive is the rain, then adoption is where the water is stored.
Incentive brings users in.
Adoption keeps them there.

The economic value of token $OPG is sustainable because it’s based on real usage demand.
Not based on attention.

If an AI protocol wants to create sustainable economic value, it needs to prove its ability to convert from attraction to retention.

Maybe this is both OPG’s strength and its weakness.
If there’s room for feedback, I think #OPG shouldn’t just prove that x402 works. OPG needs to prove that an increasing number of AI requests cannot do without that payment layer. Only when usage grows naturally can the token shift from expected value to value created from real demand.

If every AI protocol can attract attention, then what will become the true competitive advantage to keep users from leaving?

Our dashboard shows that latency has decreased. But the number of retries has increased.

The strange part is that the system looks faster, yet the real-world experience is less stable.

One of the investigations led me to a node @OpenGradient that the system selected because it was closest geographically, so sending the inference batch there was a pretty natural choice.

The first three requests crossed the retry threshold almost immediately.

At first, I blamed timeouts. Then the queue. I even suspected a new model release. But a farther node still processed the same workload without issues.

That’s when I realized I was optimizing the wrong metric.

Distance only tells where the request starts. It doesn’t reflect the entire journey the request must complete.

Our network traffic goes through a busy routing path before reaching the node. Inference starts quickly, but the verification responses return unevenly. The application sees inference complete, while the trust signal is still delayed—then it retries a job that had never actually failed.

The problem isn’t whether the node is near or far.
It’s that the metric I used to optimize only measures part of the request.

Every system eventually becomes what its metric is optimizing.

Looking back, I didn’t choose the wrong node.
I chose the wrong point to end the measurement.
I considered the request complete when inference finished, while for #OPG , the experience truly completes only after verification.

If the request only completes after verification, then the metric should end there too.

If inference completes before trust is established, then what exactly should we optimize?
$OPG $CAP

When transferring a few million dong, I only need to confirm with my face.

But when signing a home purchase contract, I’m willing to spend more time checking every clause.

The interesting part is that I’ve never chosen the strongest verification method for everything.

Because each level of trust comes with a price.

Time.

Convenience.

Cost.

That makes me think about AI.

If AI will handle millions of different tasks, does every task truly need the same level of trust?

@OpenGradient looks at the problem differently.

Instead of having just one verification method, #OPG builds multiple levels of verification.

Basic verification (Vanilla) for situations that need speed.

Trusted Execution Environment (TEE) for applications that need a balance between performance and trust.

ZKML for cases that require the highest level of cryptographic assurance.

Rather than applying the same standard to every scenario, each application can choose the verification level that fits its needs.

Perhaps the future of AI won’t be about creating more trust.

But about creating the right level of trust needed.
$OPG $DEXE $LAB

A report with incorrect data.
An email was sent with the wrong content.
The boss didn’t ask:
"Where is the mistake?"
But instead asked:
"Who did it?"
That made me think about a bigger issue.
AI is developing more and more, and AI is becoming an indispensable need in human life.
So have you ever wondered:
If AI makes a mistake, who is responsible?

And in @OpenGradient , this question is viewed from a fairly interesting angle.

Instead of only focusing on producing results.

#OPG is building a Trust Layer, where every decision can be traced back, rather than just leaving a result that nobody knows how it was created.

When a decision can be traced, responsibility can also be traced back.

An AI doesn’t become trustworthy because it makes fewer mistakes.

It becomes trustworthy when responsibility is designed in from the beginning, instead of having to hunt for it after every error.

Perhaps the future of AI won’t be "smarter AI".

It will be more trustworthy AI.
$OPG $DEXE $SLX

10% for personal use.
15% for networking.
A detailed list and those plans, experiences, and lessons accumulated over many years. I'm sharing everything with AI.

Initially, it was just conversations.

But over time, AI started to remember them.

What AI remembers isn’t random data.
It's how I operate.
How I make decisions.
The things I've learned over the years.

Interestingly, if tomorrow I switch to a different model, what I wouldn't want to lose isn't the model.
But everything that has been remembered.

And in @OpenGradient , this is very clear.

MemSync isn’t just built to help AI remember.

It’s built on a bigger assumption:

Memory can exist as a separate layer.

And when memory becomes infrastructure, the important question may no longer be:

“How much can AI remember?”
But rather:
“Who owns AI's memory?”

Perhaps the most valuable thing in the future of AI won’t be the ability to remember.

But the ownership of what has been remembered.
#OPG $OPG $DEXE $LAB

WHY DO PEOPLE NOT IMMEDIATELY FILL OUT A SIGN-UP FORM WHEN SOMEONE OPENS ONE?
They scroll straight to the bottom.
Looking for a tiny line:
“Approved within 24–48 hours”
or
“We will review your application”
And just seeing that.
They stop.
No further questions.
No attempt to start.
Not because they don't want to participate.
But because at that moment, the action of “joining” is no longer understood as a starting point.
It's transformed into something that must be approved before it counts as existing.

A person isn't truly free to join if they have to wait for someone to give them the green light to start.

And that’s where @OpenGradient stands out.
Most AIs today have participation rights decided by a gatekeeping group.

#OPG is building a future where innovation isn't limited by prior approval.

A future where Open Contribution becomes the norm.
And Participation doesn't require pre-authorization.

Where the right to participate isn't determined by prior consent.
It starts with an individual choosing to engage.

Perhaps the most important question won't be:
"How many people want to build it?"
But rather:
"How many people are allowed to build it?"

The future of AI may not be shaped by ecosystems with the most interest.
But by ecosystems with the most people able to participate. $OPG $DEXE

Two people can own the same kitchen.

With the same ingredients.

With the same tools.

Yet one person keeps whipping up new dishes.

While the other just repeats the familiar ones.

Why does the same set of resources lead to different outcomes when combined differently?

When aiming for breakthroughs, most folks start by searching for something new.

A new tool.

A new idea.

A new resource.

This is a form of Recombination Blindness.

We get so fixated on hunting for new components that we miss the new value lying within the existing ones.

Breakthroughs often don’t arise from a new component.

But from how old components are recombined.

AI is facing a similar challenge.
Perhaps that’s why @OpenGradient has emerged.

While most AI systems focus on adding capability,
#OPG is building infrastructure so that existing capabilities can create value beyond themselves.

A future like this requires:

✓ Interoperability

✓ Specialized Components

✓ Modular Infrastructure

✓ Open Coordination

A system doesn't become more valuable just because it has more capabilities.

But because it can create something new from the capabilities it already has.

The future of AI may not belong to the biggest models.

But to the ecosystems that can recombine the fastest.

Perhaps the most important question won’t be:

"What capabilities are we missing?"

But rather:

"Have we fully leveraged the capabilities we already have?" #OPG $OPG @OpenGradient

The other day I ordered food on the app.

The dish I received was quite different from the picture.

What bothered me the most wasn't the food itself.

But the moment I thought I had no way to file a complaint.

A few minutes later, I discovered there was still a feedback button.

Suddenly, I felt a lot less annoyed.

Even though everything still hadn't been resolved.

Thinking it over, it’s pretty strange.

What makes a decision easier to accept?

People are less accepting of decisions that can’t be questioned.

The more a decision impacts people, the more it needs to be scrutinized.

Yet, the most impactful decisions are often the hardest to question.

I call this the Challenge Shield.

An invisible barrier that makes the decisions needing scrutiny the hardest to challenge.

A system is more trustworthy when its decisions can be contested.

But if we don’t know whether a decision can actually be challenged,

Then we also don’t know if that system is more trustworthy or not.

That’s where I see @OpenGradient heading in a pretty interesting direction.

Allowing decisions to be reviewed, debated, and re-evaluated.

And if this holds true,

The future of AI may not be defined by the most trusted systems,

But by those systems that allow their decisions to be challenged the most.
#OPG $OPG

Lately, I've noticed something pretty strange.

The most successful things are often the ones that are hardest to change.
The better a system works,
The fewer people want to change it.

At first, that seems reasonable.

But what happens when the world keeps changing while the system does not?

Many systems don't disappear due to failure.
They disappear because they've been too successful for too long.
I call that the "Evolution Trap".
A trap that occurs when current success erodes future evolutionary potential.

Perhaps the longest-lasting systems aren't the most perfect ones.

But the ones that can evolve.

So what makes a system able to evolve?

A system struggles to adapt if every new change forces it to be rebuilt from scratch.
Each change becomes a complete overhaul.

And over time.
Staying the same becomes easier than changing.

That's also the problem @OpenGradient is tackling.
Instead of forcing the AI ecosystem to be rebuilt every time a new capability emerges.

#OPG allows the AI ecosystem to continuously improve without needing a complete overhaul.

New components can emerge without causing existing components to stop working together.

When change no longer means a complete rebuild.
Evolution is no longer a trade-off.
It becomes a continuous process.

And if that's true.
The future of AI might not be defined by the most powerful models.

But by the ecosystems that can evolve the fastest. #OPG $OPG

Lately, I've picked up a pretty lazy habit.

Every time I need to find something, I hardly ever scroll down to check the whole list. I usually just look at the first few suggestions and make my choice right away. It feels like I'm picking. But when I think about it, most of the work has already been done beforehand. Someone else has decided what appears in front of me.

That's when I suddenly remembered @OpenGradient is doing something really interesting: turning AI from something we have to trust into something we can verify.

It sounds like an AI problem. But I see a different angle that’s worth pondering.

If one day there are thousands or millions of AIs coexisting, the biggest issue might not be which AI is the best.

But rather, which AI gets used.

At that point, users won’t evaluate each AI on their own. They'll rely on a layer of a system to decide which AI pops up in front of them, which AI gets called, and which AI gets overlooked.

This is where I find the Access problem starts getting interesting.

Verification helps us know if an AI is doing its job. But who verifies the system that chooses the AI for us?

If that access layer can’t be verified, we’re just shifting our trust from the AI to a new gatekeeper.

Perhaps when AIs become abundant, the strongest AI won’t necessarily hold the most power.

The most powerful thing could be the system that decides which AI gets to show up.

So if I have a suggestion for @OpenGradient , I think don’t just verify the AI.

Find a way to verify the thing that selects the AI.

Because if the AI needs to be verified, then the thing that selects the AI probably needs verification even more. #OPG $OPG