悠悠悠吖

What exactly are TermMax’s FT, XT, and GT? Explained with a story

The first time I saw TermMax’s FT, XT, and GT, I was honestly a bit confused.

To be fair, for a lending protocol, why would it involve so many tokens?

Later, I realized that if you always look at it from the “lending” perspective, it’s really hard to make sense of it. But if you switch the viewpoint and treat it as a financial transaction that has been split apart, it suddenly becomes much clearer.

Let’s say I borrow you 100,000 USDC, and after one year I repay 108,000.

The most traditional interpretation is: 100,000 is the principal, and 8,000 is the interest.

But what TermMax does is further break down that future debt.

FT: you can think of it as a “ticket for future payments.” You buy it today at a discount; at maturity, it’s redeemed at the agreed value. The difference in between is the profit you locked in early.

XT: this can be understood as another part of that debt. It works together with FT to separate the principal and the interest structure. In TermMax’s design, the combination of FT and XT corresponds to the full debt structure.

As for GT, I think it’s easiest to understand.

If FT and XT are about breaking up “money,” then GT is more like packaging a “position.”

What your collateral is, how much you borrowed, and what the risk of this position looks like—all of it can be packaged into one complete position.

Seen this way, TermMax isn’t simply moving “lending” onto the blockchain.

It’s doing something else:

Breaking a complex financial transaction into components that can be priced, combined, and managed.

That’s also the part I find most interesting.

Because early DeFi solved the question of “how to borrow money,” but as it develops further, financial transactions inevitably become more and more complex.

Returns, debt, time horizons, collateral, leverage—these things can’t stay permanently tied together.

Of course, more complexity also means a higher learning curve, and the real liquidity, liquidation mechanisms, and market depth are all worth continuing to monitor.

But at least from a product-logic perspective, TermMax shows me a completely different way of thinking:

Not making finance simpler—but breaking complex finance into individual pieces that can be recombined.

That might be the signal that DeFi financial engineering is finally starting to mature.

@TermMax #TermMax

What was everyone’s mindset when they first entered the market and bought BTC?

It’s simple.

When it goes up, they’re happy.

When it goes down, they’re afraid.

They watch the price every day.

The first thing they do when they open their phones is check the candlestick chart.

But over the past few years, I’ve noticed some veteran players around me have changed.

After they buy BTC, they increasingly treat it like “a collectible.”

They’re not as sensitive to price swings as before.

One friend even told me:

“Now when I look at BTC, it doesn’t feel like I’m watching a stock. It feels more like I’m checking an old item at home.”

At the time, I thought that was pretty funny.

But if I think about it carefully, it actually makes some sense.

Because for many people who hold BTC, what they’re buying isn’t really a short-term return.

It’s a sense of certainty.

But in recent years, a problem has slowly started to appear.

Everyone knows BTC is valuable.

And they also know it shouldn’t just lie there.

However, when it comes to getting people to genuinely participate in various on-chain activities, many start to hesitate.

The reason is simple:

Making a little profit is fine.

But if, in order to chase returns, you have to hand over the thing you care about most, it suddenly doesn’t seem worth it.

That’s where the BTC ecosystem feels awkward right now.

Everyone hopes BTC will be more useful.

But they also hope it won’t change.

It’s a bit like an old phone you’ve used for ten years.

You want more functions.

But you don’t want it to suddenly turn into something you don’t recognize.

Later, I started paying attention to Babylon partly because of this contradiction.

It’s not trying to solve the problem of “how to make BTC more flashy.”

Instead, it’s about how to keep BTC’s original sense of trust, while participating in more things.

I think this direction is definitely worth watching.

Because the real future problem might not be:

Does BTC have value?

But rather:

With all that value, how can it be used without breaking trust?

Of course, whether it can ultimately succeed still takes time.

But at least this is a problem that I think a lot of people will face.

#Baby $BABY @BabylonLabs_io

Why does the blockchain world also need an “Alipay escrow”?

A few days ago, a friend asked me to buy something secondhand.

His first line wasn’t about the price.

Instead, he said:

“Is there platform escrow?”

At the time, I found it pretty funny.

It was just a few hundred yuan worth of stuff, yet everyone’s first reaction was still:

Don’t just transfer money directly.

Find an intermediary first.

Later I thought about it, and it’s actually pretty interesting.

In the real world, we’re already used to credit mechanisms.

On Taobao, there’s escrow transactions.

When renting an apartment, you pay a deposit.

Buying a car comes with a contract.

Why?

Because human nature—simple as it is— is also simple.

Most people won’t cheat.

But systems can’t be built on the assumption that “everyone is a good person.”

Blockchain is the same.

Many people say the biggest advantage of blockchain is that it doesn’t need trust.

But later I realized that, more accurately, it’s not that trust isn’t needed.

It’s that trust is moved from “trusting a person” to “trusting the rules.”

That’s also something I’ve felt strongly after studying Babylon.

In the past, many BTC application proposals’ biggest problem wasn’t lack of demand.

It was that there was too much trust required in the middle.

You need to trust the bridge.

Trust the custody.

Trust a certain platform.

Trust a particular operations team.

And what Babylon wants to explore is, when BTC participates in more scenarios, to reduce as much of this extra trust as possible.

By using Bitcoin Staking, BTC can help secure other PoS networks, while keeping a security logic that stays as close as possible to native Bitcoin.

To be honest, I feel this direction is pretty similar to escrow transactions in real life.

It’s not that everyone is a scammer.

It’s that the rules are designed in advance, so strangers can cooperate too.

In the future, truly large-scale blockchain adoption won’t rely only on technology being faster.

More importantly:

Do ordinary people dare to put their assets in there?

Without a foundation of trust, even the best technology can only stay within small circles.

#Baby $BABY @BabylonLabs_io

Back when the BTC ecosystem first started getting hot a few years ago, I was honestly pretty excited.

Because at the time, a lot of people were saying:

“Bitcoin is finally going to have more ways to be used.”

Borrowing, yield, DeFi—everything was coming in.

But when I calmed down and thought it through, I realized there’s a pretty real problem.

Why do so many BTC holders ultimately still choose not to participate?

It’s not that they don’t understand the returns.

And it’s not that they don’t want to improve capital efficiency.

It’s that, deep down, there’s always a hurdle in their mind:

“Is my BTC still safe?”

To be frank, this question is crucial.

Because for many assets, you might be willing to try some new ways of playing.

But with BTC, it’s different.

For many people holding BTC, at its core, they’re buying a sense of certainty.

What they believe in is:

You don’t have to trust a platform.

You don’t have to trust a person.

You just need to trust Bitcoin’s own rules.

So when BTC enters DeFi, the biggest contradiction shows up.

You want BTC to play a bigger role.

But you also can’t add too many new trust risks just for efficiency.

That’s also why I later started paying attention to Babylon.

The design inside it regarding a Trustless Bitcoin Vault— I think it addresses a very practical issue.

The focus isn’t simply on helping BTC make money.

It’s on exploring how to bring BTC into more financial scenarios, while reducing reliance on third-party custody and additional trust layers.

I think this direction is quite interesting.

Because many projects think about:

“How can we let users take their assets out?”

But Babylon is focused on:

“How can we let users be willing to take their assets out?”

These two questions may look like they differ by only a few words, but the logic is completely different.

Of course, it won’t be smooth sailing for BTC to enter more scenarios.

The bigger the asset, the more cautious you need to be.

But I think what will truly matter in the future isn’t who can create the highest returns.

It’s who can make more people feel comfortable using their own assets.

Because in the crypto world, returns are attractive.

But trust is what keeps people.

#Baby $BABY @BabylonLabs_io

Earlier, I thought the biggest problem with cross-chain was technology. Later I realized it’s actually trust.

Recently, while researching the BTC ecosystem, I had a question.

Why, after all these years, is there still no particularly smooth connection between Bitcoin and other chains?

At first, I thought it was mainly a technical issue.

The speed isn’t fast enough.

Interoperability is poor.

Development is difficult.

But later I found it’s not that simple.

The real difficulty is:

Do you dare to trust the middle step?

Because the most special thing about BTC is that it doesn’t require you to trust any particular person.

People trust the rules.

But many ways of connecting BTC to other ecosystems introduce new roles.

You need to trust the bridge.

You need to trust the custodian.

You need to trust the new system.

Honestly, this is also why many BTC holders are quite cautious.

They don’t want BTC to play a bigger role.

They just don’t want to sacrifice BTC’s most core value for more ways to play.

When I later saw Babylon, I felt the issue it focuses on is quite interesting.

It doesn’t just think in a simple way of:

“how to move BTC somewhere else.”

Instead, it considers:

“how to keep BTC’s own security logic while participating in more networks.”

Through Bitcoin Staking, BTC can help build the security of other PoS networks, rather than simply turning into another kind of asset.

I think this difference is crucial.

Because very often, the real difficulty isn’t creating new functionality.

It’s adding functionality without breaking the original most important value.

That’s why I think Babylon is worth studying.

It’s not merely about solving how BTC can make money.

It’s about solving whether:

between BTC and other chains, we can build a more trustworthy connection.

Of course, this path still needs time.

Any new mechanism must be validated by the market.

But if, in the future, more networks require security value like BTC, then this kind of connection may become increasingly important.

#Baby $BABY @BabylonLabs_io

A while back, I chatted with a few friends about projects, and the most-discussed topics were always familiar ones.

Which chain’s TVL has gone up.

How many developers a new ecosystem has attracted.

Which project has high expectations for anirdrops.

But as we kept talking, someone suddenly asked:

“If a chain is fast, but nobody believes it’s secure, what’s the point?”

At the time, I found that question quite interesting.

Because in the past, when I looked at public chains, I really did focus more on performance and ecosystem.

Later, after going through a few cycles, I gradually realized that the most core issue for blockchains isn’t actually building the features.

It’s making others dare to put their assets in.

Especially for many PoS networks.

They need staking to guarantee security.

But when a new chain is just launched, you often run into a very real problem:

Token value isn’t high, staking capital is limited, and network security costs aren’t sufficient.

So to attract more people to participate, you can only raise the rewards.

It may work in the short term, but in the long run it brings inflation pressure.

This problem is something many new networks run into.

When I later studied Babylon, I felt the angle it took was quite special.

It wasn’t trying to invent another new security model—instead it was thinking:

Can we leverage the economic security that already exists in Bitcoin to help other PoS networks lower the barrier to security?

Through Bitcoin Staking, BTC holders can participate in building the security of other networks, allowing the long-term accumulated value of trust behind Bitcoin to create more utility.

Honestly, I think this direction is more worth paying attention to than simply talking about BTC returns.

Because returns are just short-term appeal.

What truly determines how far a network can go is its security foundation.

Just like in the real world, a city’s development isn’t only measured by how many skyscrapers it has—more importantly, whether its infrastructure is reliable.

Of course, this direction for Babylon still needs time to be proven.

After all, bringing an asset like BTC into more scenarios—security will always come first.

But I think the question it raises is crucial:

As more and more blockchains emerge in the future, will they all need to build trust from scratch?

Or can they rely on security strength that has already been validated by the market?

This question may shape how many networks develop in the future.

#Baby $BABY @BabylonLabs_io

In our previous discussion about blockchain projects, the most common questions people ask are:

What is the TPS?

Are the fees low?

How many applications are in the ecosystem?

These are all important.

But after going through several market cycles, I’ve increasingly come to feel that one question is actually more core:

Why should this network make me trust it?

Because at the end of the day, blockchain isn’t really playing with code—it’s about trust.

After many new chains launch, their biggest challenge isn’t the technology, but how to establish security.

You need validators, funding, user participation, and time to accumulate gradually.

And what Babylon has made me pay attention to is this: it tries to turn the security consensus that Bitcoin has built over more than a decade into a resource that other networks can use.

In simple terms, BTC wouldn’t only protect Bitcoin itself; it could also help other chains build a stronger security foundation.

This direction is indeed quite bold.

Because the most valuable thing about Bitcoin isn’t its price—it’s that people are willing to trust it.

That trust wasn’t formed in a single day. It’s the result of countless times of market volatility, attack events, and cycle changes.

So I think Babylon’s value isn’t just about creating a BTC yield protocol.

It’s more like an attempt to build a new security layer.

Of course, at the moment, this whole direction is still developing. Whether it can truly form large-scale applications in the future will need to be validated by the market.

But at least it raises a question that’s well worth thinking about:

In the future, is it really necessary for every new blockchain to start from scratch and build trust each time?

If it’s possible to leverage underlying security like Bitcoin—sharing existing consensus—then the industry’s overall development efficiency could be completely different.

A lot of the time, truly important infrastructure isn’t necessarily something users see every day.

But it can silently shape the direction of the entire industry.

#Baby $BABY @BabylonLabs_io

Many people look at Bitcoin and their first reaction is still just two words: hold it.

Buy BTC, put it in a cold wallet, and wait for the next market cycle.

In the past, I also thought this was the simplest and most correct way to use Bitcoin. But recently, I’ve increasingly felt that there’s an issue worth rethinking:

If the global value of BTC is enormous, yet in the long run it can only be used as a store of value and cannot participate in a broader financial system—doesn’t that feel a bit regrettable?

Bitcoin’s biggest potential may not be only price appreciation, but becoming the most reliable underlying asset across the entire on-chain world.

That’s also why I started paying attention to Babylon.

When I first saw the concept of “BTC staking,” I actually had some questions. Because many past BTC financial solutions, in essence, required wrapping BTC, bridging across chains, or relying on centralized custody. While that improves capital efficiency, it also introduces new trust issues.

Babylon’s direction, on the other hand, feels more like it’s trying to resolve this contradiction.

It aims to help BTC maintain its security properties while providing security support for other blockchain networks. Through a native BTC staking mechanism, BTC holders can participate in the on-chain economy—rather than simply turning BTC into another kind of asset.

Also, the direction of the Babylon Trustless Bitcoin Vault particularly caught my attention.

In simple terms, it attempts to explore how native BTC can enter DeFi scenarios as collateral, while reducing reliance on bridged assets and centralized custody solutions. Users can use the value of BTC to take part in financial applications like lending and borrowing, allowing a large amount of “sleeping” Bitcoin to become liquid.

I think the true value of Babylon isn’t just “adding yield to BTC.”

More importantly, it’s trying to solve a long-standing problem in the Bitcoin ecosystem:

Value is huge, but capital efficiency has always been limited.

Of course, this path won’t be smooth. Once BTC enters a more complex financial system, security mechanisms, risk controls, and user understanding will all face long-term tests.

But in a bigger sense, the truly important infrastructure in the future may not be creating new assets—it may be enabling the immense value that already exists to generate more connections.

Bitcoin’s next phase may not be about getting more people to buy BTC.

#Baby $BABY @BabylonLabs_io

Why don’t institutions hand billions of dollars to an “Agent they can’t explain”?

A few days ago, I saw a friend who works in traditional asset management say: “We’re not that we don’t believe in AI—we just don’t believe in an AI that, when something goes wrong, can’t explain why it did what it did.”

That line made me think for a long time.

The crypto world loves to talk about how, after AI Agents, they will manage wallets, rebalance portfolios, make markets, and even complete all kinds of on-chain actions on behalf of users. But if one day a fund actually entrusts tens of billions of dollars to an Agent, what will be the most important question?

I don’t think the answer is returns, or execution speed.

It’s why it made that decision.

Traditional finance has a crucial principle: every movement of funds must leave behind a basis for the decision. Not because the process is cumbersome, but because if something goes wrong, you need to know where the responsibility lies and whether the decision complied with the rules that were set in advance.

But many on-chain Agents today are more like a “black box.” They analyze, they execute, they trade—but why they chose this route, and why they ignored another option, is often something users don’t know. If the assets being managed are real, this lack of transparency is itself a risk.

That’s also why I later started paying attention to the Newton Protocol.

I found that its focus isn’t on making the Agent smarter and smarter through training—it’s on making sure every execution by the Agent can be constrained, verified, and explained.

In Newton’s design, users can define strategies and permission boundaries in advance, and then combine that with a verifiable execution process. This way, the Agent doesn’t have infinite power; it completes tasks within established rules. In the future, whether it’s an institution or an individual, people can know: why this action happened, what the basis was, and whether it deviated from the original authorization.

I’ve always believed that the biggest barrier for AI to enter the financial industry has never been algorithms—it’s trust.

A money-making Agent isn’t necessarily worth long-term reliance.

But an Agent that can explain itself, follow rules, and accept verification has a real chance to enter the mainstream financial system.

Perhaps in the future, what institutions truly buy isn’t the intelligence of AI, but the trustworthy execution capability behind it.

@NewtonProtocol

$NEWT #Newt

# After FTX, I realized many people care about the wrong direction.

A couple of days ago I came across a line: "Exchanges are getting safer now."

I stared at that sentence for a long time.

Is it really safer?

I think we’ve only moved the risk from one place to another.

Previously, everyone worried whether exchanges would run off with funds, so they started chasing on-chain solutions—self-custody, transparency. But in the past two years, after actually using them, I found another issue gradually coming to the surface.

On-chain data is indeed public, but many people still don’t know what they’re actually trusting.

Do you trust the code? Or that the project team won’t casually upgrade contracts? That the oracle can’t behave abnormally? That the backend won’t pause certain functions? Or that a particular cross-chain bridge will never have problems?

Only later did I realize that in the financial world, the most valuable thing is never “public,” but “verifiable.”

“Public” just puts information out there; “verifiable” means anyone can independently confirm whether something really happened.

These two concepts look similar, but they’re very far apart.

So when I recently studied GRVT, I didn’t pay too much attention to how many orders it can process per second, nor how many popular technologies it uses.

Instead, I cared more about the underlying approach.

It doesn’t try to put everything on-chain. Rather, it separates efficiency from verification: trading keeps pursuing the speed that professional markets require, and the final settlement goes back on-chain using zero-knowledge proofs to complete verification.

This made me realize that what it truly wants to change isn’t the way we trade, but the way we place trust.

In the past, we were used to believing that a platform wouldn’t do harm; in the future, a more ideal state would be that whether a platform does harm doesn’t rely on promises—it relies on the fact that everyone can verify.

Of course, this doesn’t mean GRVT has solved all problems.

Whether liquidity is sufficient, whether institutions keep entering, whether the system remains stable under extreme market conditions—these still need time and real markets to validate.

But at least, it showed me a direction.

In the future, competition among trading platforms won’t necessarily be about who has lower fees or a prettier interface. It will be about who can turn “trust” from corporate credibility into technical verification.

@grvt_io #grvt

In recent years, blockchain has been working on a single problem: how to get more value onto the chain.

From DeFi to RWA, and then to AI agents, on-chain capabilities are getting stronger. But at the same time, a contradiction is becoming increasingly obvious:

As the technology becomes more complex, everyday users are becoming farther away from the on-chain world.

Now, to participate in an on-chain operation, you may need to understand wallets, Gas, cross-chain transfers, approvals, protocol mechanisms—and even determine the relationships between different contracts.

For professional users, this is a form of freedom.

But for more ordinary users, this is actually a barrier.

I believe that the true large-scale adoption of blockchain in the future will not come from getting users to learn more complicated knowledge. Instead, it will come from hiding complex processes behind the infrastructure.

This is also one of the reasons I pay attention to Newton Protocol.

The direction it explores is, in essence, helping make on-chain applications more automated and intelligent.

In the future, users may not need to manually handle dozens of steps. They can simply tell the agent their goal, and the agent will carry out the specific execution.

For example:

“Help me manage this portion of my stablecoins.”

“Help me find a yield strategy that meets my risk requirements.”

“Help me optimize my asset allocation.”

But the biggest challenge here is: for users to entrust the task to an agent, they need to believe the process won’t go out of control.

Through a strategy framework, permission mechanisms, and verifiable execution logic, Newton enables an agent not only to take action, but also to act according to the predefined conditions.

This represents a new way of interacting on-chain.

In the past:

User → Wallet → Protocol → Transaction.

In the future, it may become:

User states a goal → Agent understands the need → Infrastructure handles execution.

I think the core of the next phase of Crypto competition is not just performance and liquidity, but who can make complex technology truly serve ordinary people.

Because truly great infrastructure ultimately becomes “unnoticeable.”

What users see is a simple experience, while behind the scenes a complex system is running.

That may be the direction Newton is exploring.

@NewtonProtocol
$NEWT
#Newt

I’ve been thinking about a question lately: if in the future more and more on-chain operations are handled by AI agents, when a transaction goes wrong, who should actually be blamed?

In the past, when we used DeFi, most actions were still something we clicked ourselves and confirmed ourselves. Even if we lost money, we knew what decision we had made. But in the future, if an agent automatically rebalances, automatically trades, and automatically participates in various protocols, things will be completely different.

Because at that time, what the user faces won’t be a single simple transaction, but a continuously running automated system.

That’s the key issue.

Many AI projects today are showing that agents can do more things, but very few have truly solved a critical problem: when an agent is executing, how can you prove it hasn’t gone beyond the permissions granted by the user?

An agent that analyzes the market isn’t scary. What’s scary is when it has access to funds but no clear boundaries.

That’s also why I’m paying attention to Newton Protocol.

They didn’t focus on building a smarter AI. Instead, they’re constructing a trusted execution framework—one that allows the AI to be trusted. Through strategy rules, permission controls, and verification mechanisms, the agent doesn’t do “whatever it wants,” but acts within the scope the user sets. Newton’s design includes mechanisms like zkPermissions, enabling users to define more granular execution conditions and use cryptographic verification to ensure the execution matches the requirements.

For example, in the future an AI asset management assistant could automatically help optimize returns for the user every day. But the user can set constraints in advance: a single transaction can’t exceed a certain amount, it can’t buy certain assets, and it must pause under extreme market conditions.

In this model, the AI is responsible for finding opportunities, while the rules are responsible for limiting risk.

I think the real sign that AI + Crypto has matured isn’t that AI makes more decisions for people—it’s that it can reliably complete tasks within clearly defined boundaries.

Being smart is just the beginning; trusted execution is the endpoint.

@NewtonProtocol
$NEWT
#Newt

During this period of researching GRVT, I’ve been thinking about a question:

In the future, will the true competition in on-chain finance not be about who has the strongest single-point technology, but rather who can combine different capabilities into a complete financial system.

Because this industry has already moved past the stage of asking whether a particular technology exists.

Zero-knowledge proofs, off-chain matching, yield agreements, RWA assets—none of these are secrets anymore.

The real challenge is how to put them into the same product so that what users feel is a complete account, not dozens of fragmented agreements.

It doesn’t choose to recreate all the underlying infrastructure; instead, it builds its product logic on a mature ecosystem. For example, it uses ZKsync-related technologies to implement a trading architecture and privacy capabilities, improves capital efficiency with a unified margin approach, and also integrates yield sources like Aave, so that previously idle trading margins can be used for more purposes.

This route is actually quite similar to how traditional finance has developed.

Where large financial institutions are truly strong is not that every component is produced in-house, but that they have the capability to connect trading, risk management, and asset allocation.

As underlying capabilities become more open, the competitive barrier will gradually lower. Others can also integrate ZK infrastructure, connect yield protocols, and design similar capital management models.

So what GRVT will truly need to prove in the future is not that “others can’t do it,” but rather “even after others have done it, why do users still choose it.”

What’s tested here isn’t just code, but liquidity accumulation, institutional partnerships, user experience, the risk framework, and the ecosystem network.

Technology can be copied, and patterns can be learned, but the trust and liquidity required to build a mature financial platform takes a long time to cultivate.

So I believe GRVT’s greatest value isn’t an uncopyable technological fortress, but rather a set of product-combination capabilities that are already starting to take shape.

It’s like it’s answering a question:

As on-chain financial infrastructure becomes more mature, who can become the entry point that connects all these capabilities?

The answer the market gives in the future may not belong to the platform with the most complex technology, but to the one that turns complex technology into a simple experience.

@grvt_io #grvt

ARTX

artx

artx