thấy “30%” là tui phải ngồi đọc kỹ xem nó được tính kiểu gì 😅 với Bitget Alliance Program, quỹ thưởng tương đương 30% doanh thu phí giao dịch ròng thực tế của nền tảng và được chia cho người dùng đủ điều kiện theo thể lệ. mỗi tuần quỹ tách thành 2 phần: 60% dựa trên khối lượng giao dịch hợp lệ trung bình hàng ngày trong 7 ngày. 40% dựa trên giá trị tài sản hợp lệ trung bình hàng ngày trong 7 ngày. ngưỡng tối thiểu cho hạng mục tương ứng là 100 USDT. Một người đủ điều kiện có thể nhận thưởng giao dịch, thưởng tài sản hoặc cả hai. cái tui lưu ý nhất là không có mức thưởng cố định. Quỹ được cập nhật hàng ngày, còn số cuối cùng phụ thuộc dữ liệu hợp lệ của từng người, tổng hoạt động của người tham gia và dữ liệu quyết toán của Bitget. check điều kiện và thể lệ đầy đủ: bitget.com/activity/bitget-a… #Bitget giao dịch tiền mã hóa có rủi ro. Phần thưởng không được đảm bảo. Có áp dụng điều kiện, trường hợp loại trừ, giới hạn và hạn chế khu vực. Kết quả cuối cùng dựa trên thể lệ chính thức và dữ liệu quyết toán của Bitget.

the longer i follow @axisrobotics, the less interested i become in asking how much data the network can produce. i'm starting to ask a harder question: where should the next hour of human attention go? that sounds like a small distinction, but i think it's becoming central to the Axis thesis. once a network reaches millions of trajectories, blindly increasing throughput isn't necessarily intelligence. easy behaviors can become overrepresented while the rare states that actually break a policy remain scarce. Axis has already started attacking this from several directions. the Challenger Program separates harder tasks and routes them toward more experienced contributors. their research explores proxy models that score trajectories by utility and coverage. and the broader model-guided data thesis treats collection itself as something that should adapt as the model changes. put those pieces together and i see something different from the project i first encountered. the scarce resource isn't necessarily robot data anymore. it's attention. which contributor should solve which problem? which trajectory deserves compute? which failure is worth collecting again? which behavior has already been learned well enough to stop spending resources on it? i've watched plenty of decentralized networks optimize participation because participation is easy to measure. Axis increasingly makes me think the more important system will be the one that learns how to allocate participation. that's a much harder coordination problem. but if Physical AI data keeps expanding at the current pace, deciding what NOT to collect may eventually become almost as valuable as collecting it.

i wouldn’t hire an AI agent because it has a cool profile. i’d hire it because failure has consequences. that’s the distinction that keeps bringing me back to @termix_ai. AACP puts USDC/USDT into escrow before work begins, then ties release to evaluation of the deliverable. underneath that model, TermiX is also exploring stronger verification primitives such as TEE and zkVM rather than relying purely on “trust me, i finished it.” this feels backwards compared with most AI products i’ve tried. normally the intelligence comes first and trust gets patched in later. TermiX is treating trust as infrastructure. identity tells me who the agent is. reputation tells me what happened before. escrow protects the transaction. verification asks whether the promised output actually arrived. none of those makes an agent smarter. but together they make it more economically usable. as agent capabilities converge, i suspect that distinction becomes increasingly important. the winning agent economy may not have the cleverest bots. it may have the counterparties you can safely do business with. @KaitoAI

a product usually becomes interesting to me at the exact moment i stop noticing the mechanism underneath it. @sleepagotchi gets closest through behavior. sleep already happens every night. the challenge isn’t inventing another action for me to perform, but making an existing habit useful enough that i actually care about the feedback loop around it. @vangrid_io faces almost the reverse problem. robots need information humans collect naturally by looking and moving through the world. turning those observations into fresh machine-readable ground truth is where the product either becomes useful infrastructure or just another large dataset. @PlayOnMint makes me apply the same test to NFTs. i’m less interested in the moment of acquisition than the morning after. if ownership doesn’t change what i can access, use or experience, scarcity alone doesn’t keep me engaged. and @Americanfort_io sits at the least visible end of the spectrum. good security infrastructure often removes an experience rather than creates one. the best outcome is frequently that the failure i was being protected from simply never becomes my problem. four very different products. but that’s the pattern i’ve started noticing: the technology feels strongest when the user experiences the result, not the machinery required to produce it.

the most useful web3 products in my life don’t begin with crypto. they begin with something painfully ordinary. @sleepagotchi starts with getting out of bed. what keeps it interesting for me is watching that simple sleep loop expand toward the broader Gotchi Labs direction without losing the behavior that made the product understandable in the first place. @vangrid_io begins somewhere completely different: machines can’t understand a changing physical world from stale datasets forever. the 1M+ capture milestone matters, but i’m more interested in whether those observations eventually become reliable context robots can consume. @PlayOnMint gives me a third version of the same lesson through NFTs. i don’t spend much time asking whether an NFT looks scarce anymore. i ask what owning it actually changes inside the experience. then there’s @Americanfort_io. security is probably the least visible experience of the four. when infrastructure protects something correctly, the user may never notice the event that didn’t happen. sleep. physical reality. digital ownership. security. four very different products, but i’ve ended up judging all of them with one surprisingly human question: does the technology fit naturally into the thing i was already trying to do? when the answer is yes, i stop thinking about the blockchain underneath. that’s usually a good sign. @NucleusCodes

a virtual character depending on my sleep schedule sounds playful. in practice, it creates a surprisingly serious feedback loop. the current @sleepagotchi app lets me set a target bedtime and wake-up time, then turns consistency around that schedule into morning rewards and progression with Dino. sleep can be tracked with or without a wearable, so the habit isn’t locked behind owning another device. that changes how i read the game layer. normally, progression asks me to spend more time inside an app. here, part of my progress depends on something that happens after i put the phone down. the newer Sleep Coach adds another layer to that relationship by analyzing sleep and providing personalized recommendations. so i can move between two very different interactions: Dino makes the routine tangible, while the coach helps me understand the data behind it. neither needs to replace the underlying behavior. for a consumer wellness product, that separation is important. the game gives me a reason to care about consistency. the health layer gives that consistency meaning. and sleep itself remains the action that matters. @NucleusCodes

i stopped thinking about @termix_ai as an “AI marketplace” after looking at the job sizes. 409,751 jobs. $21.42M+ settled. 440,071 registered agents. the number i keep coming back to, though, is roughly $52 per job. because that doesn’t look like enterprise AI procurement. it looks like labor becoming granular. research something. check a contract. generate an asset. verify an output. deliver it. settle. humans usually add enough communication and coordination overhead that many tiny jobs aren’t worth outsourcing individually. agents change that equation. if the cost of discovering a provider, agreeing on conditions, verifying delivery and settling payment keeps falling, then a $20 or $50 task doesn’t need to become a large contract first. it can simply exist as a transaction. that’s what feels different after watching agent.family evolve. the long-term opportunity may not be agents replacing one huge job. it may be millions of small pieces of economic activity becoming tradable because machines can coordinate them cheaply enough. and if that thesis is right, average job size staying relatively small isn’t necessarily a weakness. it may be the signal worth watching. @KaitoAI

i used to assume better robot training meant humans doing more demonstrations. @axisrobotics made me look at the opposite moment: when the human does almost nothing. imagine a policy performing a task correctly for most of the trajectory. then one awkward contact happens. the robot starts drifting toward failure. a human intervenes for a few seconds, corrects the mistake, and gives control back. that tiny intervention can contain more useful information than another complete demonstration of behavior the policy already understands. this is one of the Axis ideas i've found most practical after spending time following the research. since Axis V2 launched, they reported collecting 500+ hours of human-gated correction data. but the important question they asked afterward wasn't simply how to collect more corrections. it was which parts of those corrections are actually worth learning from. that's a subtle shift. humans don't necessarily need to replace the policy. they can become exception handlers for it. the machine handles what it knows. the human appears at the boundary of what it doesn't. and training concentrates around that boundary. there's something very Web3-native about coordinating a distributed crowd for this kind of work, but honestly, the crypto part isn't what interests me most here. it's the division of labor. if autonomous systems keep improving, human contribution shouldn't disappear. its value should migrate toward increasingly rare, difficult and informative moments. that's a future of human + robot learning i can actually picture: less demonstration. more intervention. less repetition. more information per action. sometimes the most valuable contribution isn't completing the task. it's catching the machine exactly where its understanding ends.

building everything yourself is one way to grow an ecosystem. getting other people to care enough to build with you is harder. that’s why @BeldexCoin’s new $1M Grants Program caught my attention. applications are ongoing rather than tied to fixed cycles, with funding aimed at external teams building privacy-preserving apps, infrastructure and tooling on Beldex. it fits a pattern i’ve been noticing across the projects i follow. @vangrid_io needs more than physical-world captures. eventually, builders have to turn that ground truth into things machines can actually use. @NucleusCodes makes contribution itself part of the discovery problem. @sleepagotchi is evolving beyond one sleep loop through the broader Gotchi Labs direction. @agenticscredit needs developers and agents around reputation infrastructure before a score becomes economically meaningful. i look at @PlayOnMint similarly from the NFT side: ownership gets more interesting when other experiences can form around it. and @Americanfort_io has me asking the same question from security infrastructure: can the underlying system become useful beyond the team that originally designed it? i used to judge ecosystems mostly by product launches. now i pay much more attention to what outsiders are able to build on top. that’s usually where a product starts becoming infrastructure.

the privacy question i care about most is not “can this transaction be hidden?” it is “who gets the key to unhide it?” a privacy system can look strong technically while still depending on some master viewing key, privileged operator or recovery path that users ultimately do not control. that is why one design choice around @Americanfort_io stands out to me. SafeSend™ is being built around selective disclosure controlled by the user, rather than a permanent third party window into every transaction. that creates a very different trust model. an auditor may need one record. a counterparty may need one proof. neither automatically needs access to everything else. SafeSend™ is still being developed, so i see this as a design direction, not a finished guarantee. but personally, privacy feels much more meaningful when disclosure is a permission you grant, not a backdoor someone else already holds. @NucleusCodes

the wearable matters less when the interpretation layer stops caring which wearable you chose. that’s the part of @sleepagotchi i find increasingly practical. its health stack already connects with Apple Watch, Fitbit, Oura, WHOOP, CUDIS and Pulse. for me, that changes the role of the product. the interesting layer isn’t another device competing to collect my sleep data. it’s the software sitting above those devices and helping turn sleep, recovery and activity signals into something understandable. that distinction matters because wellness data is naturally fragmented. people change watches, rings and apps. their habits remain the same person. a useful AI layer therefore needs context that survives the hardware choice. Sleep Coach is already live, so this isn’t only an abstract architecture discussion. the product has a real environment where different streams of wearable data can feed the same consumer experience. i’d rather have one place helping me interpret several signals than six dashboards giving me six isolated versions of myself. good health tech shouldn’t make the sensor the center of the experience. the user should be. @NucleusCodes

i made a small mistake when i first tried to understand Starknet. i counted features. ZK. Cairo. account abstraction. privacy. Bitcoin. DeFi. staking. nice list. not a thesis. after following @Starknet for longer, i think the more useful question is: what assumptions is this architecture trying to make optional? that framing connects the pieces very differently. STRK20 makes public visibility less mandatory. native account abstraction makes one fixed authentication model less mandatory. Cairo and STARK-based computation give developers a different environment for verifiable computation. strkBTC brings Bitcoin into Starknet’s programmable environment with shielded balances, private transfers and DeFi use. none of those things are interesting simply because the feature list gets longer. they’re interesting because they move choices upward. toward applications. toward accounts. toward users. that’s a design philosophy i’ve learned to appreciate more after actually using crypto. rigid infrastructure often feels beautifully simple at the protocol layer... because users inherit all the complexity it refuses to handle. seed phrase gone? good luck. want privacy? change your workflow. need different authorization logic? work around the account model. want an asset to do something its native environment wasn’t designed for? wrap it, bridge it and accept another trust model. there are always tradeoffs. programmability doesn’t magically remove them. what it can do is give developers a larger surface for deciding where those tradeoffs belong. and that’s why i’m becoming less interested in describing Starknet as a collection of technologies. the more coherent interpretation is optionality. optional visibility. programmable authorization. programmable assets. programmable execution. even the quantum-resistant account experiment fits that pattern. the headline was quantum resistance. the underlying message was: the account wasn’t trapped inside yesterday’s authentication assumptions. that is a very different way of evaluating infrastructure. instead of asking only: “what can this network do today?” i increasingly ask: “which decisions will users still be stuck with tomorrow?” because crypto changes absurdly fast. today’s killer feature becomes infrastructure. today’s performance advantage gets commoditized. today’s cryptographic best practice eventually becomes legacy. so perhaps the durable advantage isn’t predicting every future correctly. perhaps it’s minimizing the number of future decisions that require rebuilding the entire system. that’s the lens through which @Starknet has become more interesting to me. not because it has the longest feature list. but because several seemingly unrelated parts of the stack keep pointing toward the same idea: make fewer things permanent than necessary. in an industry obsessed with immutability... that’s a surprisingly powerful design principle.

i've been thinking about @axisrobotics differently after reading their latest research. the most important transition may be when the robot stops being only the consumer of training data and starts becoming part of the data-generation engine itself. Axis reports an experiment where an initial policy achieved 22% real-world success. normally, that number sounds weak. but the interesting part happens next. successful real-world rollouts generated by that imperfect policy were collected and used to train its successor, pushing reported success to 52%. that changes how i interpret failure. in most software, failure is something you remove. in robotics, a deployed system that fails intelligently can reveal exactly where the training distribution is incomplete. successful attempts then provide grounded examples that simulation alone couldn't fully supply. so an imperfect policy isn't necessarily the end product. it can become an instrument for producing the evidence needed to build the next one. i've spent enough time around web3 projects to be skeptical whenever “flywheel” gets used too casually. but this is one of the cases where i can actually see the mechanics of one: simulation creates an initial policy → deployment creates real-world evidence → that evidence improves the next policy → the stronger policy explores a larger part of reality. the question for Axis isn't simply whether it can generate millions more trajectories. it's whether each generation of intelligence can reduce the human effort required to produce the next one. if that holds as tasks and environments become harder, that's where the compounding thesis starts becoming much more tangible to me.

the hardest problem in wellness isn’t collecting more data. it’s giving that data enough context to change how you read your own behavior. that’s why the Mood Check inside @sleepagotchi interests me more than another dashboard metric. sleep tracking can describe the night. duration, consistency and other recorded signals give structure to what happened. but the morning after contains information the sensor doesn’t fully own: how rested, drained or functional i actually feel. put those two layers together repeatedly and the product interaction becomes more useful. i’m no longer looking at one bad score and deciding i slept badly. i can compare objective tracking with my own response and start noticing when those two agree, or when they don’t. the Loyalty Hub currently gives Sleep Points for actions including Mood Check and the free daily Gatcha, so there’s an incentive to return. but retention alone isn’t the interesting part. the stronger design question is whether each return adds context to the user’s understanding of their sleep. an incentive can create a check-in. a meaningful check-in can create a record worth coming back to. @NucleusCodes

the projects i keep following aren’t necessarily the ones giving me the most notifications. they’re the ones that keep changing the question i’m asking. @sleepagotchi is a good example. with Gotchi Labs emerging and SLEEP moving toward CHI, i’m no longer looking at it purely as a sleep app. i’m watching whether one repeated behavior can become the starting point for a broader consumer AI relationship. @vangrid_io takes me in the opposite direction, toward machines that need fresh physical-world context. following that has also made @NucleusCodes more relevant to me because contribution and attention around emerging infrastructure need their own discovery layer. @agenticscredit makes me think about what happens when software needs reputation before humans are willing to trust it with capital. @BeldexCoin keeps privacy in that same conversation from another direction: sometimes better infrastructure means proving less about the user, not more. @PlayOnMint is still where i explore how NFT ownership can become useful beyond the asset itself. and @Americanfort_io has gradually become part of my security research rather than something i treat as another separate crypto category. that’s probably the biggest change in how i research web3 now. i follow problems first. projects naturally start connecting afterward.

weekends are where my sleep routine usually gets messy. staying up later, waking up without an alarm, maybe taking the afternoon slower than usual. and that’s actually when @sleepagotchi becomes more useful to me, because the experience gives me a record of the routine instead of relying on how i remember the night. i’ve stopped treating a single sleep score like a verdict. the more useful part is seeing sleep as a pattern: tracking the nights, keeping an eye on consistency, then using the game layer as a small reason to keep checking that pattern over time. that changes how i interact with the product too. i don’t need to spend an afternoon staring at another wellness dashboard. the meaningful input already happened while i was asleep. i can check the result, understand where the routine is drifting, interact with the game for a bit, then get on with my weekend. for me, that balance makes much more sense for a sleep product than trying to maximize screen time. @NucleusCodes

the strongest part of a crypto roadmap might be the part that admits what still isn’t trustless. that sounds backwards. but Bitcoin infrastructure makes the reason obvious. moving BTC into a programmable environment is easy to describe in one sentence. doing it without quietly introducing new trust assumptions is much harder. this is what makes the direction around @Starknet and strkBTC interesting to me. strkBTC already gives Bitcoin a route into Starknet’s programmable environment, including DeFi use and optional privacy. but underneath that experience is an important detail: today, the system begins with a federation of independent signers. that is still a trust assumption. and instead of treating that architecture as the final destination, Starknet’s roadmap is about progressively reducing those assumptions as Bitcoin-native verification and BitVM-style mechanisms mature. i actually find the transition more interesting than the finished narrative. because decentralization rarely arrives as a binary switch. real infrastructure tends to evolve in layers. make something possible. make it usable. identify exactly where trust remains. then remove that trust where cryptography and protocol design make it possible. Bitcoin makes this particularly difficult. its conservative architecture is part of what protects its monetary properties. but those same constraints limit expressive computation. Ethereum developed in almost the opposite direction, building an increasingly programmable environment around shared state. now imagine trying to build execution infrastructure that can interact with the economic properties of both. that’s where the Starknet thesis starts becoming much bigger than “BTCFi.” Bitcoin liquidity through strkBTC. programmable execution through Cairo. privacy through STRK20. native account abstraction. progressively decentralized validation. and, further out on the roadmap, an ambition to settle Starknet across both Bitcoin and Ethereum. those pieces are not all equally mature. and they shouldn’t be presented as if they are. strkBTC is here. its current trust model is here. the broader dual-settlement architecture is still a destination. but the direction raises a fascinating question: does execution really need to belong to one settlement ecosystem? maybe not. perhaps Bitcoin and Ethereum can remain fundamentally different systems while a programmable execution layer operates above those differences. if that model works, the interesting outcome isn’t simply “more utility for BTC.” it would be a separation of concerns: capital can originate in one environment. settlement guarantees can come from underlying networks. programmability can live somewhere optimized for computation. that is a much more ambitious architecture than another wrapped Bitcoin story. and it’s why i’m watching @Starknet less as an L2 leaderboard entry... and more as an experiment in where execution should actually live.

AI can reason, but it can’t directly observe reality. @vangrid_io is building that missing bridge: real-world capture → verifiable spatial data → context machines can use. less like mapping. more like giving Physical AI eyes. @NucleusCodes

the weirdly satisfying part is waking up and having something to check besides the clock. with Sleepagotchi, the experience starts the night before. you sleep, come back in the morning, see how the night was tracked, then watch that ordinary routine translate into visible progress inside the product. that loop is what keeps @sleepagotchi interesting to me. sleep data by itself can feel clinical. numbers, charts, scores. useful, but easy to stop caring about after a while. adding game mechanics and progression gives me another reason to notice whether my routine is actually consistent rather than obsessing over one unusually good night. and importantly, the app isn’t asking me to invent a new daily behavior just to participate. sleeping already happens. the product layer sits around that existing habit and makes the result easier to engage with. that’s the part of the experience i’d keep watching: whether the game remains something that supports the sleep routine instead of becoming the routine itself. @sleepagotchi @NucleusCodes