kubilavax Integrated (🦍⚡️)

gRialo friends, in the usual blockchain model, security comes from validators redoing the same computation across the network. A transaction comes in, a result is produced, and then the network checks that result by running the same computation again. That model is strong, but it is also expensive. And once the computation gets heavy or the inputs involve private data, it starts to feel pretty inefficient. The model @RialoHQ is pushing looks at the problem differently. Here, the computation is not repeated by everyone. It happens once, a cryptographic proof is generated to show it was done correctly, and the chain verifies that proof instead of rerunning the whole thing. If the proof is valid, the application can use that verified result and settle the state update onchain. So the difference is basically this: In the classic model, the network keeps repeating the same work. In this model, the computation happens once, and correctness is checked through a proof. That matters because some things are just not a good fit for repeated onchain execution. The computation might be too heavy, the data might be too large, or the inputs might be private. Think about something like calculating an index price. The raw data could be huge or proprietary. Instead of having everyone onchain recalculate it over and over, you can compute it offchain and bring the result onchain with a proof. The same applies to eligibility checks. Maybe you want to verify whether a user qualifies for a reward, a loan, or some rule-based access. With the right proof system, you can prove that the condition was satisfied without exposing all of the user’s private data. That is also how Rialo is positioning itself here. Not as the place where everything has to execute onchain, but more like the layer that verifies proofs of offchain computation and lets applications settle those verified results onchain. One of the most important distinctions in the article is this: A proof can show: “Given these inputs, this computation was executed correctly.” But it does not automatically show: “These inputs were true in the real world.” So a proof can prove the computation was done correctly, but input validity is still something the application has to handle carefully. That is honestly one of the most useful parts of the article, because it makes the limits clear instead of pretending proof solves everything. I also put together a simple visual below comparing the classic model with the approach Rialo is describing. It makes the difference easier to see at a glance. At the end of the day, the classic blockchain model says, “everyone should recompute.” The model Rialo is describing says, “compute once, verify the proof onchain, and let the application settle the verified result.” If heavier computation, privacy, and more complex financial apps are going to live onchain, it is not hard to see why this approach is getting attention. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gRialo fam, the numbers @RialoHQ shared are genuinely impressive. Builder’s Hub started with 120 attendees in January and has now grown to 475. Shark Tank reaching 685 attendees is no small thing either. Looking at it from a community participation angle makes it even more meaningful. Because this is not just about bigger numbers. It also shows that the community is consistently paying attention to these spaces. Seeing participation keep climbing in builder focused events month after month is a strong signal. For anyone who is not familiar with Builder’s Hub and Shark Tank, here is the simple version. Builder’s Hub feels like the place where builders in the community show what they are working on, get feedback, and become more visible. Shark Tank feels like the more intense version of that. Builders get up, pitch their project, answer questions, and show what they have actually built. That is why these should not be read as just regular community meetups. One makes the building process more visible, and the other puts that work more directly in the spotlight. That is the most valuable part of Rialo’s tweet to me. Not just that they are running events, but that the community is showing up to them more and more over time. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gRialo friends, If you want to build a strong onchain finance product, the data layer has to be strong too. Because if the data you use for pricing, valuation, and risk calculations is weak, the product built on top of it will hit a ceiling sooner or later. In financial apps especially, data quality directly shapes product quality. That is exactly what @RialoHQ's latest post is pointing to. Alongside Subzero Labs being featured in @CBOE’s Innovation Spotlight, the bigger story is that Cboe’s EDGX market data is being integrated into the Rialo ecosystem. What makes that important is that Cboe is not some random data source. It is a major exchange network that institutions already rely on. So the message here is pretty clear: Rialo wants institutional grade market data to feel like a built in part of the infrastructure. And that matters. Because the goal is not to make developers build data pipelines from scratch every time. The idea is that high quality market data should already be there, so teams can spend less time cleaning and stitching data together, and more time actually building products. That is especially important for trading, fintech, and more serious financial applications. Because this is not just about putting a price on a screen. Pricing engines, valuation models, and decision systems all need reliable data underneath them. Another interesting part is how they are framing the EDGX feed. Not as some outside add-on you plug in later, but as a native layer inside the network that developers can access while building. So this is not just a “new partner” announcement. The bigger point is that Rialo wants to make real world market data more accessible for onchain applications at the infrastructure level. And if stronger financial apps are actually going to be built onchain, this is one of the layers that really matters. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gLiquid friends, big update from @liquidtrading. The team just announced a new $18M raise, which brings total funding to over $25M. But the real thing that stands out here isn’t just the amount. It’s the vision behind it. Liquid isn’t trying to be just another crypto trading app. The goal is to build a mobile first trading experience that gives people access to equities, preIPO exposure, prediction markets, commodities, FX, and crypto in a more unified way. So this is bigger than just “come trade something.” The bigger play is bringing different markets into one product experience. Based on the numbers they shared, Liquid reached 40k traders, 120+ countries, and $3B+ in volume in just 7 months after launch. That shows it’s not just an idea on paper anymore. People are actually using it. On the investor side, Neo and Left Lane Capital stand out in this round. And seeing names like Paradigm and General Catalyst still in the picture also says a lot about the confidence behind the project. That’s the part that matters most here. Liquid isn’t trying to stay stuck in one lane. It’s trying to bring together the different markets traders already move through during the day. Instead of crypto in one place, prediction markets somewhere else, commodities somewhere else, and stocks in another app, the goal is to make that experience feel more connected. Note: this is not a paid partnership or an ad. I only turned on the paid partnership label because I tagged @liquidtradingfor the event.

gRialo friends, with AI agents, the issue is not just intelligence anymore. Trust matters just as much. Because you can already give an agent a task. You can make it pay for things. You can make it pull data. You can even let it use other tools. But the real question is this: What exactly is this agent allowed to do, and what is off limits? Think of a simple example. A sales agent can pull lead data for you. Cool. But can that same agent also spend money from your wallet? Can it cancel a subscription? Can it send a payment to someone? And if it can, does it hit a limit? That is where the real issue starts. That is also what the a16z piece is getting at. What the agent economy is missing is not just better models. Identity, permissions, payments, verification, and trust infrastructure matter just as much. For an agent, things like this need to be clear: - who it represents - what boundaries it operates within - how much it is allowed to spend - where responsibility sits if it makes a mistake - why another system should trust it in the first place And this is exactly where @RialoHQ is putting the spotlight, especially on permissions and guardrails. The simplest way to read their point is this: You cannot just hand an agent the keys and hope for the best. You also need to code the limits around what it can do. So an agent might: - use only certain tools - never spend more than $100 - ask for extra approval on sensitive actions - interact only with specific addresses That is basically where their idea of programmable authority is going. So the question is not just “does the agent work?” The real question is: how controlled is the agent while it works? That is why the conversation is slowly moving away from model quality alone and toward infrastructure. A smarter agent can be useful. But an agent with no clear limits is risky. So the bigger takeaway is this: The AI agent era probably will not be unlocked by intelligence alone. The real shift will come from infrastructure that makes identity, permissions, and trust much more solid.

gRialo friends, think about a shared wallet for a second. Money can move out of it, or an important setting can be changed, but only if several people approve it. Normally, the system looks at one simple thing. Did enough people approve? But sometimes that is not the real issue. The real issue is whether the approved action is actually safe. Because a transaction can look fine on paper and still be risky. It can be unusually large, weird, or something that clearly needs extra checks. That is where @RialoHQ’s “Guarded Multisig” idea comes in. The goal is not just to have a shared wallet that counts signatures. The goal is to have one that can also look at the risk of what is being approved. They break it down into four layers. Real time alerts when a critical proposal or transfer shows up, extra verification for large actions, checking the actual dollar value of a transaction instead of just the token amount, and adding a delay before major governance changes go live. The core point is pretty simple: An approved action is not always a safe action. They explain it through the Drift example. The attacker got the approvals they needed, so from the multisig’s point of view the action looked valid. But from a security point of view, the situation was very different. Rialo’s answer is to stop treating these security checks like something you patch on later with bots or outside tools. The idea is to push them as close as possible into the wallet’s own execution flow. And they did not leave it as just a write up. There is a demo too, so I went and tried it. First I created an account here: playground.rialo.io/account You create the account, get a testnet wallet, then request some devnet $RIALO so the demo can run. After that, you move over here: guarded-vault.playground.ria… I set up my own vault there. That part was actually useful, because it stops being just a theory piece. You can click around and get a more concrete feel for how the logic is supposed to work. Of course, this is still a demo. But it does show the main idea pretty clearly: Crypto may need more than just multisig. It may need smarter shared wallet systems that can raise alerts, ask for extra confirmation, understand transaction size, and slow down critical changes when needed. Dropping the links below for anyone who wants to try it. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gLiquid fam, with @liquidtrading’s new role system, the first mission is live too. It looks simple, but it actually matters. You go to the App Store or Google Play, leave an honest review about the Liquid app, then drop a screenshot of it in the mission 1 channel: (discord.com/channels/1436216…) I left my review based on my own experience. I mentioned what I like, and I also pointed out what I think is still missing. That’s the good part here. They’re not asking people to just write “great app” and move on. They want feedback from people who actually use it. They also made it clear that AI reviews, fake reviews, or someone else’s screenshot can cost you your role. I added my review screenshots below. So the mission is basically this: leave a review, take a screenshot, send it to the mission 1 channel. Deadline is April 27, 2026. Note: this is not a paid partnership or an ad. I only turned on the paid partnership label because I tagged @liquidtrading for the event.

gRialo friends, at first glance, bringing private credit onchain sounds like a pretty clean idea. You tokenize the credit, write the terms into a smart contract, and let repayments and collateral logic run automatically. From the outside, it feels like the problem is solved. But the real problem is somewhere else. What makes private credit hard is not writing the rules into code. What makes it hard is knowing when those rules should actually kick in. Because what we are talking about here is not just a debt record. There is a real company behind it, real cash flow, a real balance sheet, and real risk. Has the company’s income dropped? Can it still cover its interest payments? Has it breached a covenant? The answer to those questions does not live onchain. It lives in bank records, ERP systems, accounting data, and sometimes only in the company’s own reporting. That is where the problem really starts. If a smart contract gets clean and reliable data, it can enforce rules very clearly. But if the data is wrong, incomplete, or delayed, that clarity does not save you. In some cases, it just makes the problem more obvious. A system running on bad data is basically automating the mistake. That is what the article calls the truth problem. The issue is not writing the rule. The issue is figuring out what is actually true. And I think that is the strongest distinction in the whole piece. Putting something onchain is one thing. Being able to verify it is something else. You can move a private loan onchain. But if you cannot independently verify the financial reality behind it, then what you see onchain is just a digital representation. Not the thing itself. That is why private credit is different from the DeFi lending most people are used to. In a lot of DeFi lending models, the collateral is onchain, the price data is onchain, and the liquidation logic is built around that. The system knows what it is looking at. In private credit, the real signal sits outside the chain. The thing the chain needs in order to act is outside its own field of view. That is why the article talks about a verification gap. The rules might live onchain, but if the reality that triggers those rules stays offchain, there is a serious disconnect. And it is not only a technical issue. It is also an incentives issue. The people reporting or interpreting that data may not always want to present the full picture as clearly as they should. This is where Rialo’s main argument comes in. If you want to bring private credit onchain in a meaningful way, tokenization alone is not enough. You need another layer in between. The article calls that layer the determination layer. Its job is to pull in outside data as directly as possible from the source, evaluate it in a way that is both reliable and verifiable, and then turn it into something a smart contract can actually use. So the point is not just moving data onto a chain. The point is giving the chain a stronger basis for why it should trust that data in the first place. To me, that is the most valuable part of the article. It is saying the real bottleneck in private credit is not automation. Automation comes after the data problem is solved. The real bottleneck is being able to determine the truth in a reliable way. So in the end, the hard part of bringing private credit onchain is not writing the rules. It is verifying the reality that those rules depend on. And honestly, I think that is exactly where the real conversation should be. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gLiquid friends, a new update just dropped, and it directly affects everyone making content around @liquidtrading This one changes the direction of the content and role system. The first big change is this. Content roles are getting simplified. In the new system, there will be no more than 4 content roles. They also said current roles will be converted into the new system on an equal basis. So the current structure is not staying the same. They’re moving to a more compact model. The second important point is that roles will no longer be split into branches or sub-categories. That means setups like Educators and Trendmakers could either disappear completely or turn into something very different. The third, and probably most important, change is the new content format. Liquid made that part very clear. The new format will carry more value when it comes to earning and keeping roles. The current format is not completely dead, so the kind of content people are making right now may still count. But the new system will clearly have more weight. The message is simple. They want something that is harder than just taking docs and turning them into AI-reworded tweets, but also more useful. They even mentioned the chance to earn fees if content in the new format goes viral. Another big change is that parliament is gone. The structure that used to matter for decisions and reviews will no longer exist. What replaces it is still not clear yet. So one of the most important parts of the system is still waiting to be explained. The purge system is staying, but they say it will be more precise. So yes, there will still be cleanups, but the idea is to make them more targeted. They’re also bringing in a raid system. No real detail yet, only that a selected few will be part of it and the meaning will be explained soon. So this is the picture right now. Liquid wants a content system that is simpler, more performance-driven, and easier to measure. But there are still some big questions that haven’t been answered yet. What exactly will the 4 new roles be. How will current roles be converted. What does the new content format actually want. Who makes the decisions after parliament is gone. How does the fee model work. Until those details are clear, the full picture still isn’t there. So in simple terms. Content roles are being reduced. Parliament is being removed. A new content format is coming. The old format is not fully gone, but the new one will matter more. And the whole system is moving more toward output, impact, and performance. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @liquidtrading

gRialo friends, one of the hardest parts of designing a regulated stablecoin is not just moving money. It is deciding which transfers should actually be allowed to go through. Right now, that check usually happens offchain. An issuer, an exchange, or some outside service looks at the transaction and decides whether it should pass or get blocked. The problem is that this setup is fragmented, delayed, and way too dependent on external actors. The demo @RialoHQ shared is showing a different approach. The question is pretty simple: What changes if compliance is not an external filter, but something enforced right at execution time? The logic in the demo is straightforward. A rule is defined for the stablecoin. For example, if the sender or receiver is on a denylist, the transfer should not go through. Then the chain checks that rule while the transaction is executing. If it passes, the transfer goes through. If it fails, the transaction is stopped and the chain state does not change. So this is not a let the transfer happen first, then check it later model. It is real time rule enforcement at execution. The demo shows this in both one time transfers and recurring payments. For one time transfers, the idea is simple: if the rule is satisfied, the transfer goes through. If not, it never completes. But the more interesting part is the recurring payment flow. Because here, the chain is not just approving the workflow once and forgetting about it. The rule gets checked again every single time it runs. That matters a lot. A payment flow can start out compliant and later become non compliant. Say the recipient gets added to a denylist after the workflow has already started. On the next execution, the system checks the rule again and automatically stops the flow. That is the part that stands out to me. Compliance is not something checked once at setup. It stays part of the execution flow the whole way through. The infrastructure side of the article backs that up too. Rialo is combining three building blocks here: a private execution environment, native Web2 connectivity, and protocol level automation. Put simply, the chain can pull policy data from outside systems, evaluate it during execution, and run recurring flows without waiting for outside bots or keepers. Of course, there is an important limit here. This is still a demo. It is not saying a compliant stablecoin product is already live. It is showing the building blocks that could make something like that possible. And one more thing matters here: the policy source can still live offchain. The denylist or compliance data may still come from an external system. Rialo is not claiming to remove that. The claim is that enforcement itself can move into the chain’s execution layer. So this is not just about “compliant stablecoins.” It is really about turning compliance from a manual offchain process into something that becomes part of how the chain runs. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gRialo friends, DKG (Distributed Key Generation) is basically a way for a group to create shared cryptographic control without handing that power to one single person. Why does that matter? Because the point is not just splitting a key into pieces. If that key is created by one party from the start, then the system still begins with a central point of risk. DKG takes a different route. Each participant creates their own private contribution, hides it inside a polynomial, and privately sends only the relevant share to the others. No one ever sees the full secret. Then each participant adds up the intermediate shares they receive and computes their own final share of the group secret. So there is shared authority in the system, but the full secret never sits in one person’s hands. That’s where it gets interesting. Once enough shares come together, the system can either reconstruct the secret or, in many practical setups, produce a valid signature on its behalf without ever exposing the secret itself. From the outside, that signature looks just like a normal signature verified against a public key. But under the hood, the authority is distributed rather than sitting with one operator. That’s the real strength of DKG. It’s not just about splitting a key after the fact. It’s about making sure the key is born collectively in the first place. @RialoHQ frames this around things like validator quorums, cross chain workflows, and other sensitive actions that need shared signing. So instead of relying on one signer, you rely on a threshold of participants combining their shares. There is an important caveat though. For this to be secure, the system also needs a way to check whether participants are sending valid and consistent shares. That’s why DKG alone is not the full story. You also need verification layers like VSS. So in short, the real difference with threshold cryptography is not just splitting authority. It’s making sure that authority never starts in one hand to begin with. And that’s exactly the problem DKG is trying to solve. Also, Rialo Learn has a step-by-step DKG simulation if you want to see the flow in practice instead of just reading about it: learn.rialo.io/tutorials/dkg… Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR.

gRialo friends, @RialoHQ is pointing to the $1.7T+ unsecured consumer credit market in the US. In this market, credit scores have long been one of the main tools used to make lending decisions. How much credit someone gets, and at what rate, has often been shaped around that score. But a credit score does not always show the full picture. Two people with similar scores can still look very different when you look at income flow, work history, cash flow, or platform level behavior. The score may look similar, but the risk may not be. That is where Rialo’s point starts to matter. Credit assessment no longer has to rely on a single number alone. Education, employment history, cash flow, and behavioral data can also shape the decision. But this is not just about making better lending decisions. The bigger idea is moving key parts of the lending stack onchain. Rialo is trying to bring three layers together here: richer credit assessment, more efficient loan servicing, and more transparent loan packaging. So the question is not only who gets the loan. It is also how repayments are tracked, how operations are managed, and how similar loans can be grouped into clearer risk pools. Put simply, a lender does not just want to issue loans. They also want to track performance, monitor repayments, group similar loans together, and manage the whole process inside a more integrated system. That is the bigger picture Rialo is pushing: bringing assessment, servicing, and packaging into one infrastructure layer. Of course, the key issue here is data. Real world data only helps if it is reliable, permissioned, and usable. Still, the core message is clear: this is not just about making better loans. It is about building a credit system that assesses better, runs more efficiently, and becomes more transparent over time. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ @RialoTR

gLiquid fam, your trading data from the @liquidtrading app now syncs automatically with your community portfolio. So you don’t have to mess around with screenshots or manual PnL entries anymore. The trades you already made now count on their own. The flow in the image is pretty clear. First, you go to the Liquid App tab on the dashboard. Then you pick the EVM wallet you want to use. Once the wallet is connected, the system starts pulling your data. When it’s done, you’ll see your volume, active days, PnL, and other trading stats automatically on the Liquid App Analytics screen. This update makes things way cleaner, especially if you’re going for trader roles. Instead of collecting extra proof just to show you’ve been trading, the data shows up directly on the dashboard. Less manual work, more real records. I showed the steps one by one in the image below. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @liquidtrading

gRialo friends, blockchain systems are not only hard to build. They are also hard to upgrade cleanly over time. Validator sets change, rules change, and sometimes the consensus itself changes too. That’s exactly what @RialoHQ is trying to address with Gauss. At the simplest level, Gauss is saying this: you should not have to stop the system just to upgrade it. The core idea is to separate consensus and execution more clearly. Gauss does that with two logs: The inner log keeps everything ordered by consensus. The outer log keeps only the transactions that execution actually needs to see. That split matters. Because the consensus side does not only contain user transactions. It also includes validator changes, transition messages, and other coordination entries. Gauss is basically saying execution does not need to see all of that. So the system’s internal coordination and the transaction flow seen by users are kept separate. In practice, that means consensus can manage the transition in the background, while execution keeps following a clean transaction flow. The easiest way to picture it is this: the train keeps moving while the locomotive is being replaced. That’s where Gauss stands out. Validators can change, quorum rules can change, and even the consensus design can change. But the execution layer does not have to be directly disrupted every time that happens. So Rialo is not really talking about a new “speed” story here. It is talking about a cleaner and less disruptive way to handle upgrades. Note: This is not a paid partnership or an ad. I only enabled the label because I tagged @RialoHQ.

gLiquid fam, my News Feed guide for the teach a liquid feature event just got me the drip role. I’ve been making content around @liquidtrading for about 1.5 months now. One thing I really like here is that the role system doesn’t just reward being active, it tries to reward real contribution too. If your content is actually useful, you can feel that a lot faster. There are 3 main roles in the system: drip, frame, and orator. Got the first one. Now I’m going after the rest. Big thanks to everyone who supported me. If you still haven’t joined, here’s the Discord: discord.gg/qfW6Umau *This content was created for a Liquid community event. It is not an advertisement.

gRialo friends, MPC, FHE, and TEEs are different technologies, but they’re all trying to solve a similar problem: how to compute on sensitive data without exposing it. MPC lets multiple parties compute together without fully revealing the data to each other. FHE is about computing directly on encrypted data without decrypting it first. TEE runs computation inside a protected environment. But having these tools is only one part of the story. The hard part is coordinating the whole flow in a way that stays secure, controlled, and verifiable from start to finish. So the question is not just “can we do confidential compute?” It’s also about which program is running, whether the data is going to the right place, whether the user actually gave consent, and how anyone can verify that the result was produced correctly. That’s the layer @RialoHQ is pointing to with REX. At the simplest level, REX is not the thing doing the confidential compute itself. It’s the system that makes that process usable, controlled, and provable. The goal is to verify the program, route encrypted inputs to the right place, enforce permission checks, run the compute inside a protected environment, and then prove that the output was generated correctly. That’s the part that stands out here. Rialo is not just saying “we support privacy.” It’s saying we orchestrate the full privacy flow at the protocol level. And that matters because in the real world, privacy alone is not enough. You also need control, consent, and verification. So in short, REX is Rialo’s coordination layer for confidential compute. @RialoTR @RialoHQ

gRialo friends, Not all credit flows through banks. At the simplest level, private credit is when companies borrow from private funds instead of banks. At first, bringing that onchain sounds like a strong idea. You tokenize the loan, write the rules into a smart contract, and the system looks more transparent and more automated. But the hard part starts right there. A smart contract can enforce the rules, sure. But first, it needs to know whether the borrower is actually following the agreement or not. And that’s where things get messy. In private credit, the most important data does not live onchain. Financial statements, bank activity, ERP records, payment data... all of that sits offchain. So the real issue is not just writing the rules. The real issue is knowing, in a reliable way, when those rules should actually apply. That’s where what @RialoHQ calls the verification gap shows up. Tokenizing a loan may be possible. But proving that the real financial condition behind that loan is being reflected correctly is much harder. And the problem is not only that the data lives offchain. In traditional private credit, the people handling that data can also have conflicts of interest. If you move the same flow onto blockchain without changing that part, you’re basically rebuilding the old problem with a new wrapper. That’s why private credit is different from more standard RWA cases. Some assets are easier to bring onchain. But in private credit, borrower data, covenant logic, and loan terms are much more complex. What Rialo is pointing to is this: what’s missing here is not just tokenization, but a determination layer that can turn real world data into a verifiable result that a smart contract can safely act on. So the challenge is not only putting credit onchain. The real challenge is being able to verify the truth behind that credit in a reliable way. For anyone who wants to go deeper, I’m also dropping the blog link: rialo.io/posts/bringing-priv… The post explains the verification gap and determination layer side in much more detail. @RialoTR @RialoHQ