Sui’s Killer Feature Isn’t Speed. It’s Letting AI Agents Build Their Own Workflows.
Crypto spends most of its energy arguing about speed. Transactions per second, block times, fees. Those numbers matter, but they’re about to stop being the main event.
The main event is AI agents. Not chatbots, but software that can watch markets, spot opportunities, weigh risks and act on its own, around the clock. And these agents are running into a problem that has nothing to do with speed.
They can think of things they aren’t allowed to do.
The gap between intelligence and agency
Picture an AI agent managing a treasury. It notices a pricing gap across three apps: a cheap swap on one, a favorable lending rate on another, and a high-yield vault on a third. The strategy is obvious to it, and the math checks out.
Then it hits a wall. On most blockchains, nobody has built the contract that connects those three apps in that order. The agent can see the opportunity, but it can’t act on it until a human developer writes the glue, gets it audited and deploys it. By then, the opportunity is gone.
That’s the gap between an AI’s intelligence and its agency. Today’s agents mostly live inside boxes that developers built for them: a swap button here, a prebuilt vault strategy there. They can only follow paths someone anticipated.
But agents think faster than developers ship. And nobody can prebuild every useful combination of every app for every situation an agent might encounter. The number of combinations explodes with every new protocol.
So the real question for the agentic economy isn’t which chain is fastest. It’s which chain lets agents build their own workflows. That chain is Sui. No blockchain gives AI agents more freedom to build.
Watch an agent do it on Sui
Back to our treasury agent. On Sui, it doesn’t wait for anyone. It assembles the entire strategy itself, on the spot, as a single Programmable Transaction Block (PTB):
Swap USDC for SUI on DeepBook.
Take the SUI that comes out of that swap and deposit it as collateral in a lending app.
Borrow stablecoins against that collateral.
Send the borrowed stablecoins straight into the yield vault.
Here’s the crucial part: the agent doesn’t need to know the exact amounts in advance. The coin that comes out of the swap is the coin that goes into the deposit. The loan that comes out of the lending app is what goes into the vault. Each step hands its actual result directly to the next, at the moment of execution.
Four steps, three apps that were never designed to work together, one transaction. No new smart contract, no developer and no permission. Either the whole thing succeeds or none of it happens.
And before it commits a single dollar, the agent can test-run the entire transaction against the live chain, see what would happen, adjust the amounts and run it again. It can try a dozen versions of its strategy in seconds and execute only the winner.
This was just a small example: a single PTB can hold up to 1,024 commands.
Why this changes everything: outputs become inputs
Lots of chains let you bundle actions together. That isn’t the point.
The point is that on Sui, the output of one step becomes the input of the next, decided live, across any apps the agent chooses. That one property is what turns an agent from a user of prebuilt products into an author of its own strategies.
Without it, an agent has to guess amounts ahead of time or rely on a contract someone wrote to pass results along. Either way, it’s back inside a developer’s box.
With it, every public function on Sui becomes a building block the agent can wire together however the moment demands. The lending app becomes a building block. So does the exchange, and so does the vault. Protocols stop being destinations agents visit and become capabilities agents assemble.
The most important smart contract in the agentic economy may be the one nobody had to write. An autonomous agent shouldn’t need a developer’s permission, or a newly deployed contract, every time it invents a new way to use the financial system. On Sui, it doesn’t.
“So agents can do anything with my money?”
No, and this is where Sui’s design gets elegant.
The agent invents the workflow. It can’t skip the rules.
On Sui, rules can be built into the assets themselves. Take DeepBook’s flash loans. When an agent borrows, it receives a debt object that the transaction cannot complete without repaying. Forget the repayment step and the entire transaction reverts, as if it never happened. The rule isn’t a suggestion the agent is asked to follow; it’s physically impossible to break.
The same principle extends to authority. Owners can hand agents capability objects that define exactly what they’re allowed to do: how much they can spend, which assets they can touch and where funds can go.
Agents write the workflow. Assets write the rules. That combination of total freedom to compose and hard limits that can’t be skipped is exactly what’s needed before anyone hands real money to an AI.
Doesn’t everyone have this?
Not in this form.
Solana bundles instructions into atomic transactions, but one instruction can’t simply pick up another’s results and keep going. Ethereum’s newer wallet upgrades let accounts batch calls, but the chaining runs through wallet contract code someone wrote in advance. Aptos is the closest competitor, with its own tools for composing Move calls in a single transaction.
Sui’s difference is that live result passing isn’t an add-on. It’s how every Sui transaction works, built on an object model where the things being passed between steps are real, owned assets. Agents don’t need a special tool or a prebuilt contract. They just build the transaction.
The flywheel
Now zoom out.
Every new app launched on Sui adds new building blocks, and agents can combine them in ways their own developers never imagined. More apps mean more combinations. More combinations mean more capable agents. More capable agents mean more reasons to build on Sui.
That’s the flywheel, and it compounds.
The agentic economy won’t be won by the chain that moves tokens fastest. It will be won by the chain where AI agents are free to act on what they figure out. Agents will go where they can build their own workflows, and right now that’s Sui.
For the bigger picture of where autonomous machines are taking the economy, see my earlier article: [link]
We're building Suikii, a counter app for small shops. The shop types an amount and shows a QR, the customer approves in Slush, and the USDC lands in the shop's own wallet. Nothing sits in between.
So we tested it for real on mainnet: 0.01 USDC for an iced latte, with the phone and the counter recorded at the same time.
What we saw:
- Final on Sui 1.32 s after tapping Approve, Face ID included (from the checkpoint timestamp)
- 0 SUI in gas. The customer paid exactly 0.01 USDC
- The counter showed Paid at 3.61 s. The extra 2 s or so is the wallet handing back to the pay page before the counter hears about it
- A loyalty stamp landed on the customer's card on its own
The video ends on the suiscan page for the transaction, so you can check it yourself.
Honest question for anyone who runs a shop or knows someone who does: what would stop you from taking USDC at the counter today?
Walrus Memory has no delete. That made our app’s rules honest.
\Unwritten, built for Total Recall: what it does, how it uses Tatum and Walrus, and how it learned.**
A note on the data.
The demo household, the Wilsons 🏚️, is not a real family: it is six weeks of decisions written to Walrus Mainnet by a script in the repository. What is real is everything built on it — the engine, the blobs, the Sui wallet, and the transfers a daily job signs through Tatum. Where the demo simulates something, this post says so.
What it does
Every household answers one question informally and never writes it down: **who can spend what, alone, up to how much.*\* Unwritten watches real decisions and writes that agreement for you. Then it does the uncomfortable part: it tells you when the rule you \think** you have is not the rule you actually follow.
Setup asks one number — $18 — and nothing else, so there is something for the first month to correct. After six weeks of decisions the engine finds:
> \Alex approves alone up to $45.00 · groceries · 11 of 11** > \Nothing under $18.00 has ever been discussed · 8 events, zero conversations** > \72% of Max’s allowance goes to games** > \Friday is fastfood night · 5 of 6 weeks · $32.40 ± $10.69 · never discussed** > \The 2-of-2 above $100 rule is not real — the second signature lands within 3 min in 4 of 5**
None of that was configured. The last is the product earning its keep: a rule the family wrote down and then stopped following, said out loud.
How it learned over time
Seven pure functions over decision events. **No LLM in the learning path*\*: it has to be testable without mocks, readable by a reviewer, and reproducible twice on stage. Run week by week over the same decisions, the engine does this:
| Week | What it knows |
| 1–2 | Nothing, and it says so. | | 3 | The first two rules: the Friday rhythm and the one contested category. |
| 4 | The $45 solo limit — against the $18 from setup — and the allowance pattern. |
| 5 | The allowance share moves 67% → 70%: a new version supersedes the old. |
| 6 | Seven rules, including the drift between a stated rule and the real one. |
A rule gets a new version when its **claim*\* moves — the allowance share went 67% → 70% → 72%, three versions — and \not** when it only gains evidence: “8 of 8” becoming “11 of 11” under the same $45 is one rule on firmer ground.
Two bugs are worth telling, because both were found by someone else’s eyes. On the deployed site the week control first showed \nothing** for weeks 1–5: Mainnet holds one derivation, because the weekly pass that would write one per week is not built. The fix replays the same function over the decisions that are on Mainnet; Week 6 equals what Mainnet holds. And the proof page’s check of that equality first cut each sentence at “· n of m”, hiding every number after it — it said 7 of 7 while a figure on screen disagreed with Mainnet. **A check that can only pass is not a check.*\* It now compares whole sentences, and a test tampers with a number and expects failure.
How it uses Walrus Memory
No delete, no edit. The SDK gives you `remember`, `recall` and friends; no update, and the delete API is gated and scoped to legacy blobs. Our first seed died half-written and there was nothing to undo — that namespace still holds 17 memories, so we bumped the version. The constraint became the design. A rule is never edited: a new version appends and names the one it replaces, which gives an honest, verifiable timeline for free. And data minimisation became structural — we never write item names, member names or addresses, only a stable ref and the role someone held \at the time**. (This demo has no database; the household’s names are fixtures, and a visitor’s typed names never leave their browser.)
Every blob can be checked on [Walruscan] ( https://walruscan.com ): its size, the `seal_encrypt_fence` and `certify_blob` transactions that stored it, and the epochs it is paid for — for the seed, 41 to 56. The SDK documents a 50-epoch default, but that option is read only by its manual client; we use the relayer-backed one, so we read the real figure from the explorer.
A seeded blob on Walruscan
A namespace is not a privacy boundary. The docs are explicit: delegate authorization is account-wide. So we scope the \write** instead of the read: an aggregate-only digest written into a second, Observer-owned account would hold nothing it could leak. That is a design — this build has one account, and the Observer screen illustrates the second.
. Public Sui fullnodes have deprecated JSON-RPC and now answer “migrate to gRPC or GraphQL”, so the gateway is how the app reads the wallet at all:
- `suix_queryTransactionBlocks` — the house wallet’s outgoing transfers
- `suix_getAllBalances` — the treasury, and the low-balance nudge that branches on it
- `sui_getLatestCheckpointSequenceNumber` — anchors a visitor’s session to a chain height
- `signAndExecuteTransaction` — the transfers themselves
Reality check matches each transfer to a decision by **day and recipient, never by amount*\* — gas would make every honest purchase an anomaly. A row with no match is something neither side knew alone: the chain knows money left and not whether anyone agreed; memory knows what was agreed and not whether it happened. As of 14 October, Tatum reads four real transfers on the live wallet and two have no approval in memory.
A daily GitHub Actions job signs them, and about one in five is deliberately written without a decision, so there is always something to find — the screen says so. The sharper stories (a subscription repriced $10.99 > $12.99, a $71 Tuesday pizza) live in the seeded spend log, and Reality check labels which half is which.
Three things we learned about Tatum rather than about the product. The gateway answered `No healthy upstream available` on two of three consecutive attempts one evening, so everything retries transient faults and only those. `suix_queryTransactionBlocks` pages at 50, newest first, and ignoring the cursor would have silently dropped the oldest days. And idempotence belongs to the chain, not a file: the daily job asks the wallet whether today’s transfers already landed before sending.
How the browser, Tatum and Walrus meet — every edge is a call the code makes
Evidence you can run
Visitors never see a wallet, gas or a hash. So the proof lives on a page that runs both integrations live — three buttons that call Tatum and Walrus Memory from your browser and show the answer, the latency, and whether a cache served it. Every blob links to its bytes and to Walruscan; transfers link to Suiscan; `pnpm verify` asks the relayer and Tatum directly from a clone.
What is simulated, or not built
Each is marked on the screen where it appears. Ratification is a rehearsal end to end: no transaction, no memory write. **Revoking the delegate key*\* is a rehearsal — doing it for real would lock every visitor out. The weekly derive pass is not built; the week control replays it. Members and sessions are not built; a role switcher stands in. Thee house pot in “Try it yourself” is a number in the browser. And the limits of the idea itself: it is useless for about two weeks, the owner is a single point of failure for policy changes, and a new baby or a lost job invalidates every rule at once.
Where it started: Tatum AI Builder
The first version of the main screen was generated on ai.tatum.io and kept in a separated repo:
, so the lineage can be diffed rather than asserted. What survived is `packages/chain`, which grew out of the generated Tatum client and its four documented traps (a key works on `api.tatum.io ` or `.dev` but never both, and the wrong host answers 401 like a bad key; a spread `Headers` silently drops the key; read the environment per call; derive the gateway from the API base). What did not survive is the single-file shape, which is right for a screen and wrong for a rule engine.
On the weekend of September 13, 2008, the heads of Wall Street’s biggest banks filed into the New York Fed to try to save Lehman Brothers. By Monday morning, Lehman had filed the largest bankruptcy in U.S. history.
The problem that weekend wasn’t intelligence or effort. Nobody could answer the questions that mattered fast enough.
Lehman had 900,000+ derivatives contracts with 6,000+ counterparties, about $35 trillion in notional value. A month before the collapse, Fed officials were still trying to get information on those contracts. The failure splintered into 75+ separate bankruptcy proceedings, and about 1,000 contracts were still unsettled four years later. Days after Lehman, AIG nearly went down holding $440B+ in credit-default swaps its own regulator later said he barely understood.
Wall Street had mountains of records. What it didn’t have was a map.
I just published a long piece on this. Here’s the short version.
1. Finance records things. It doesn’t record how things connect.
Every bank, custodian, servicer and clearinghouse keeps its own ledger. What’s never existed is a shared, authoritative record of the relationships between them.
Follow a 2008 mortgage: pooled into a mortgage-backed security, sliced into tranches, bundled into a CDO, sliced again, insured by credit-default swaps, pledged as collateral. Every step creates a new entity with its own books, each seeing only its own layer.
That’s not a speed problem. It’s an architecture problem. And it’s about to get worse:
The financial system of 2008 was too interconnected for anyone to understand. The financial system of tomorrow will be too interconnected for humans to operate.
Fixing the first requires making financial relationships machine-readable. Fixing the second requires making them programmable.
2. Rebuild the chain as objects.
On Sui, every asset can be an object with a permanent identity, an owner and a version history, and objects can own other objects. So the 2008 chain stops being disconnected ledgers and becomes a structure. The mortgage keeps its identity when it’s pooled. The pool, the tranches and the CDO are distinct objects, each with a traceable link to what’s beneath it.
Once assets live onchain as objects, much of this map draws itself. The protocol records every ownership link and every transaction in a form software can read, and applications record the rest, like a swap pointing to the CDO it insures. Call it an economic dependency graph.
And this is not the same as “tokenizing securities.” Tokenize a 2008-style CDO as one opaque token and nothing changes. Putting opaque securities on a blockchain just makes opaque securities easier to transfer.
3. Visibility, intelligence, action.
Visibility: a mortgage defaults, and software traces the damage outward through the security, the tranche, the CDO, the funds holding it and the insurer behind it. What took weeks of phone calls in 2008 becomes a query.
Intelligence: regulators stop asking banks to self-report exposures weeks later and ask the system directly: “If commercial real estate drops 25%, who takes losses and where does it spread?”
Action: this is the big one.
4. PTBs make financial relationships executable, and anyone can compose them.
Atomic transactions aren’t new. Bank-focused networks like Canton settle multi-party deals all-or-nothing and can chain complex workflows. The difference is who gets to compose. On those networks, composing happens among members who were sponsored in and have authorized each other. On Sui, anyone (a company treasury, a startup, an AI agent) can assemble a brand-new financial action on the spot from up to 1,024 steps across any public application, each step feeding the next, without joining anything or asking permission.
Institutional networks give finance a private club. Sui gives it a public set of building blocks.
Three examples from the piece:
Capital that goes where it’s needed: collateral verified, pledged and substituted automatically, even at 2 a.m. on a Sunday. Less capital sitting idle just because the system is slow.
Agreements that coordinate themselves: a hospital financed by ten lenders across three countries. When a milestone is certified, one transaction checks insurance and permits, releases every lender’s share and updates every position. If any condition fails, no money moves.
An economy that can improvise: a manufacturer’s AI agent needs $2M of materials by Friday. Because every piece lives onchain, it sells tokenized Treasuries, borrows against receivables, converts currency, pays the supplier and insures the shipment in one transaction no one ever designed, simulated first and all-or-nothing.
That last one is the core of it. With just 100 financial apps, there are nearly 162,000 ways to combine three of them. Nobody will pre-build all of those. An autonomous economy can’t wait for developers. An AI agent can’t wait to be sponsored into a network or approved by every counterparty before it acts.
That’s why Sui’s architecture matters beyond any single DeFi app. The value isn’t just a better lending protocol or exchange. It’s that every app on Sui becomes a building block for financial arrangements nobody has invented yet.
5. Why Sui over Canton?
Canton is serious, and the piece treats it that way. But the starting points differ:
Canton is private by default and shares by exception. Sui is verifiable by default and private by exception.
On Canton, a system-wide picture has to be assembled from private views, institution by institution. On Sui, the shared, verifiable state is the starting point, and confidentiality is added where it’s needed: Seal for data, confidential transfers for amounts, Nautilus for private computation, and Spheres for relationships that are sensitive in themselves.
Canton is bringing programmability to the institutional system as it exists today. Sui is trying to make institutional finance part of an open programmable economy. The question isn’t which network can modernize Wall Street. It’s which architecture can connect Wall Street to everything else.
The honest part: faster finance can spread contagion faster. A partial map can mislead. 2008’s worst exposures lived offchain. Spheres and confidential transfers aren’t production-ready yet. The piece covers all of it. But speed with sight is different from speed without it, and private-by-default networks risk making contagion faster while the full picture stays behind institutional walls.
The bottom line: the object model gives finance a vocabulary. The relationships give it a map. Programmable transactions give it the ability to act.
The old financial system recorded what happened. The next one could understand what is happening, and act on it.
So here’s my question: if the next financial system needs to be machine-readable, globally composable and usable by autonomous agents, is an institution-first architecture really the right foundation? Or does an open, object-based system like Sui have the stronger long-term design? Especially interested in hearing from people working in TradFi, Canton or Daml.
Not financial advice.
On the weekend of September 13, 2008, the heads of Wall Street’s biggest banks filed into the New York Fed to try to save Lehman Brothers. By Monday morning, Lehman had filed the largest bankruptcy in U.S. history.
The problem that weekend wasn’t intelligence or effort. Nobody could answer the questions that mattered fast enough.
Lehman had 900,000+ derivatives contracts with 6,000+ counterparties, about $35 trillion in notional value. A month before the collapse, Fed officials were still trying to get information on those contracts. The failure splintered into 75+ separate bankruptcy proceedings, and about 1,000 contracts were still unsettled four years later. Days after Lehman, AIG nearly went down holding $440B+ in credit-default swaps its own regulator later said he barely understood.
Wall Street had mountains of records. What it didn’t have was a map.
1. Finance records things. It doesn’t record how things connect.
Every bank, custodian, servicer and clearinghouse keeps its own ledger. What’s never existed is a shared, authoritative record of the relationships between them.
Follow a 2008 mortgage: pooled into a mortgage-backed security, sliced into tranches, bundled into a CDO, sliced again, insured by credit-default swaps, pledged as collateral. Every step creates a new entity with its own books, each seeing only its own layer.
That’s not a speed problem. It’s an architecture problem. And it’s about to get worse:
The financial system of 2008 was too interconnected for anyone to understand. The financial system of tomorrow will be too interconnected for humans to operate.
Fixing the first requires making financial relationships machine-readable. Fixing the second requires making them programmable.
2. Rebuild the chain as objects.
On Sui, every asset can be an object with a permanent identity, an owner and a version history, and objects can own other objects. So the 2008 chain stops being disconnected ledgers and becomes a structure. The mortgage keeps its identity when it’s pooled. The pool, the tranches and the CDO are distinct objects, each with a traceable link to what’s beneath it.
Once assets live onchain as objects, much of this map draws itself: the protocol records every ownership link and every transaction in a form software can read. Call it an economic dependency graph.
And this is not the same as “tokenizing securities.” Tokenize a 2008-style CDO as one opaque token and nothing changes. Putting opaque securities on a blockchain just makes opaque securities easier to transfer.
3. Visibility, intelligence, action.
Visibility: a mortgage defaults, and software traces the damage outward through the security, the tranche, the CDO, the funds holding it and the insurer behind it. What took weeks of phone calls in 2008 becomes a query.
Intelligence: regulators stop asking banks to self-report exposures weeks later and ask the system directly: “If commercial real estate drops 25%, who takes losses and where does it spread?”
Action: this is the big one.
4. PTBs make financial relationships executable, and anyone can compose them.
Atomic transactions aren’t new. Bank-focused networks like Canton settle multi-party deals all-or-nothing and can chain complex workflows. The difference is who gets to compose. On those networks, composing happens among members who were sponsored in and have authorized each other. On Sui, anyone (a company treasury, a startup, an AI agent) can assemble a brand-new financial action on the spot from up to 1,024 steps across any public application, each step feeding the next, without joining anything or asking permission.
Institutional networks give finance a private club. Sui gives it a public set of building blocks.
Three examples from the piece:
Capital that goes where it’s needed: collateral verified, pledged and substituted automatically, even at 2 a.m. on a Sunday. Less capital sitting idle just because the system is slow.
Agreements that coordinate themselves: a hospital financed by ten lenders across three countries. When a milestone is certified, one transaction checks insurance and permits, releases every lender’s share and updates every position. If any condition fails, no money moves.
An economy that can improvise: a manufacturer’s AI agent needs $2M of materials by Friday. It sells tokenized Treasuries, borrows against receivables, converts currency, pays the supplier and insures the shipment in one transaction no one ever designed, simulated first and all-or-nothing.
That last one is the core of it. With just 100 financial apps, there are nearly 162,000 ways to combine three of them. Nobody will pre-build all of those. An autonomous economy can’t wait for developers. An AI agent can’t wait to be sponsored into a network or approved by every counterparty before it acts.
5. Why Sui over Canton?
Canton is serious, and the piece treats it that way. But the starting points differ:
Canton is private by default and shares by exception. Sui is verifiable by default and private by exception.
On Canton, a system-wide picture has to be assembled from private views, institution by institution. On Sui, the shared, verifiable state is the starting point, and confidentiality is added where it’s needed: Seal for data, confidential transfers for amounts, Nautilus for private computation, and Spheres for relationships that are sensitive in themselves.
Canton is bringing programmability to the institutional system as it exists today. Sui is trying to make institutional finance part of an open programmable economy. The question isn’t which network can modernize Wall Street. It’s which architecture can connect Wall Street to everything else.
The honest part: faster finance can spread contagion faster. A partial map can mislead. 2008’s worst exposures lived offchain. Spheres and confidential transfers aren’t production-ready yet. The piece covers all of it. But speed with sight is different from speed without it, and private-by-default networks risk making contagion faster while the full picture stays behind institutional walls.
The bottom line: the object model gives finance a vocabulary. The relationships give it a map. Programmable transactions give it the ability to act.
The old financial system recorded what happened. The next one could understand what is happening, and act on it.
What is everyone's genuine thoughts on this and on crypto in general right now?
Where do you see SUI going, short and long term.
Are you buying more?
Personally after doing my research, the community, paired with the connections and legitimacy that SUI seems to carry, has got me convinced. Hopefully I'm not wrong, and my punt turns to riches.
Sui Basecamp produced five major announcements this week: Samsung Wallet, Google Cloud, Alibaba Cloud, $500M committed to Hashi, and 40 million TPS. Each is significant on its own. But the more interesting story is what they add up to.
Individually, these are partnerships and milestones. Together, they fill different gaps that any working economy needs: a way for people to get in, capital to put to work, demand for goods and services, a way to trust counterparties, and the capacity to handle volume.
And in almost every case, the people using Sui won’t know it’s there. That’s the point.
Access: Samsung puts Sui inside a wallet people already use
Starting the last week of October, Galaxy owners in the U.S. can hold and send USDC from Samsung Wallet, the app that already holds their cards and boarding passes. There’s no crypto app to download and no keys to manage. Sends to crypto wallets carry no Samsung fee, and payouts can go to bank accounts in 60+ countries.
Solana is a network partner too, so this isn’t an exclusive. What matters for Sui is the distribution model: the user opens a familiar app, taps send, and a blockchain settles it underneath. Stablecoin transfers on Sui cost nothing at the protocol level. Users won’t see gas on either chain, but for anyone operating rails at the scale of millions of transfers, zero beats almost-zero. Whether that wins Sui a bigger share of Samsung’s routing is worth watching.
82 million is the number of compatible devices, not users. The test is how many people actually fund a balance.
Capital: Hashi brings money, not just users
This is the announcement I think people are underrating.
A blockchain can attract millions of users without attracting meaningful capital. Hashi comes from the other direction. It’s Sui’s native Bitcoin collateral system: BTC stays on Bitcoin, while hBTC on Sui can be used for lending, credit, and yield. It’s launching mainnet in phases this month with more than $500M committed by a coalition of 20+ partners. Anchorage Digital, a federally chartered crypto bank, just joined with institutional custody routes and stablecoin liquidity.
Bitcoin is the largest pool of idle capital in crypto. If even part of that $500M becomes real deposits, Sui’s DeFi stops being a story about users and becomes a story about collateral. Lending markets, market makers, and structured products all follow collateral.
And collateral isn’t tied to one app. If hBTC becomes usable across Sui DeFi, the same Bitcoin can support lending, trading liquidity, and products that don’t exist yet. How far that reuse goes will depend on the risk controls each protocol sets.
Caveat: these are commitments, not deposits. Mainnet will tell.
Demand: Alibaba gives agents something to buy
Alibaba Cloud is bringing its services into Sui Agent Payments. A company gives an agent a stablecoin budget with set limits: which services, how much in total, a cap per payment, and an expiry. The agent then pays per API call with no human approving each purchase. It’s announced, not live, but it’s a real seller of real compute agreeing to be paid this way.
Trust: Google Cloud and the problem only a neutral record solves
Here’s a problem that will matter soon. One company’s AI agent buys data from another company’s agent. One side says the data was delivered; the other says it wasn’t. Neither wants to hand over its private logs, and neither trusts the other’s.
The Verifiable Agent Arbiter, co-developed by Mysten and Google Cloud, is built for this situation. Detailed agent logs stay private in the customer’s own Google Cloud Storage. Cryptographic proofs of those logs are anchored on Walrus and Sui, so nobody can change the record after the fact without it showing. That includes either company and, notably, Google.
To be precise: this proves the record is intact, not that the agent told the truth. But you can’t settle a dispute without an agreed-upon record, and this provides one. It’s also one of the cleanest answers yet to “why does this need a blockchain?” Google can host everything except the one thing that can’t belong to any single party.
Initial enterprise deployments are planned; broad adoption hasn’t happened yet.
Capacity: why 40 million TPS “offchain” is the point
On Basecamp’s main stage, Sui tunnels processed 40.6M transactions per second, settling to mainnet. That’s up from 6M in July. CertiK’s full report is pending.
Yes, it happened inside offchain tunnels. That’s the design, not a gotcha. No human market needs 40M TPS, but machines might. And no sane system should push every API call through global consensus. Mysten’s co-founder Adeniyi Abiodun described it this way: “Think of Sui as a court.” Parties transact privately at machine speed, and the chain enforces the rules, settles the result, and handles disputes. Tunnels are new, and two livestreamed records aren’t the same as years in production. But this is how a machine economy plausibly scales.
Why this is happening on Sui
Fair question: couldn’t all of this happen on Ethereum or Solana? Parts of it already do. Solana is in Samsung, and Base leads in agent payments.
But two things are different here.
First, the architecture. Sui represents assets, permissions, and ownership as programmable objects, and a single transaction can chain many actions together that all succeed or fail as one. That matters when the actor is an agent juggling budgets, collateral, and service agreements with no human checking each step.
Second, and more underrated, the stack. Storage (Walrus), encryption and access control (Seal), verifiable compute (Nautilus), Bitcoin collateral (Hashi), agent payments, and tunnels all come from the same team and are designed to fit together.
That matters more than it sounds. Every handoff between separately built systems is a point of failure: another bridge, another integration, another set of assumptions that may not match. A human might hit a few of those handoffs a day. An agent moving between payments, collateral, private data, and verified computation could hit thousands. Ethereum has excellent pieces built by dozens of independent teams. Sui is betting that as economic activity gets more complex and more automated, coherence beats a collection of best-in-class parts. Basecamp was the first week that outside giants started building against several pieces of that stack at once.
Where this could go
Picture this. An autonomous agent manages a treasury. It borrows against Bitcoin collateral, buys cloud compute, contracts with another company’s agent, and settles every obligation within permissions its owner set, all with a tamper-proof record behind it and no human approving each step.
That’s a scenario, not an announced product. No integration links all of these today. But after this week, every piece of it has a named, credible participant building toward it on Sui.
What this means for SUI
The paradox: Sui is getting easier to adopt by making SUI easier to ignore. Samsung doesn’t even support the token. That’s deliberate. Making every Galaxy user buy a few dollars of SUI first would be a terrible growth strategy.
But not all five announcements are equal for the token. Network usage, apps on Sui, and demand for SUI itself are related but not identical. Ranked by how directly each one creates on-chain activity that SUI secures and settles:
Hashi. Capital deployed in Sui DeFi means real transactions, real liquidity, and collateral that stays on the network. This is the most direct path.
Agent commerce and VAA. These generate settlement and verification activity on Sui, plus storage demand on Walrus, which has its own token.
Tunnels. Only the opens and closes hit the chain, by design.
Samsung. Enormous for reach, minimal for direct fees. Its value is strategic: it puts Sui underneath a consumer wallet at a scale no crypto app has reached, before most people know rails are being chosen.
A dollar moved on Sui is not a dollar of SUI demand. The token thesis is that SUI secures and settles a network carrying consumer payments, institutional Bitcoin, and machine commerce. Hashi is the first test of whether that becomes real economic weight on chain.
What would prove this wrong
Samsung launches and almost nobody funds a balance.
Hashi’s $500M mostly stays a commitment.
VAA never gets a named enterprise in production.
Alibaba’s integration ships quietly and agent spending stays negligible.
Any one of these would weaken the thesis. If they go the other way, Basecamp week will look like the moment the pieces started connecting.
The bigger picture
For years, blockchains have competed to be noticed: fastest, cheapest, loudest. Sui is competing to disappear underneath a phone wallet, a coalition of Bitcoin institutions, and two hyperscale clouds.
The next great blockchain may not be the one that convinces the world to use crypto. It may be the one that makes crypto invisible while the world’s economic activity quietly moves on chain. After this week, Sui has the strongest claim yet to being that chain.
Hi everyone,
I am doing an academic research project on Sui's architecture and roadmap. I am reading about the upcoming Walrus decentralized storage protocol.
I wanted to ask: How will Walrus interact with Sui's existing Storage Fund mechanism? Will heavy assets (like 3D gaming NFTs) be moved entirely to Walrus, or will the Storage Fund still handle their on-chain state rebates?
Thanks for the help!
Hey all, I'm Abner from the Walrus Foundation. We launched Walrus Console this week and I wanted to share it here and get honest feedback.
The problem we're going after
If you're building anything data-heavy, you know the tax. Your product accumulates files, context, and history that become your edge. But when apps and permissions are built around one provider, that data becomes harder to use anywhere else. Moving it means migrations and rewrites. Access rules get recreated in each new environment. Verifying it depends on the provider's systems.
What Console is
It's a managed way to build on Walrus. You get familiar file management (UI, API, and MCP) on top of a data foundation that is:
* Portable – use your data across supported apps, and connect AI tools like Claude Code and Cursor through MCP
* Programmable – data is private by default with encryption
* Verifiable – you can independently verify data integrity instead of taking a provider's word for it
No wallets, tokens, or storage renewals to manage. Sign in with Google or Apple and you're in. Free up to 5 GB.
Happy to answer questions on how it works under the hood, what's supported today, and what's coming. And if you've dealt with data lock-in, I'd like to hear how you handled it.
Most crypto job scams don't start with a scam message. They start with a normal one.
Monday: "Applicants pay no fees. Onboarding only through our careers portal."
Thursday: "Please send a refundable $60 deposit today. Our HR partner will finish onboarding with you on Telegram."
Read on its own, Thursday's message looks like a normal onboarding step. The scam is the contradiction, and you only see it if you remember Monday.
Same with the developer version: smooth interview, great salary, then "clone our repo and run npm install for the take-home." That's how the Contagious Interview campaign got into 30,000+ dev machines and drained 7,000 wallets this year.
So I built Revoir (French for "to see again"). You paste each message as it arrives, as text or a screenshot. It remembers every claim the recruiter made, compares each new message against the old ones, and quotes exactly what changed: fees, channel, who you're talking to. Then it gives a verdict: likely scam, suspicious, or no scam signals.
It can also scan a GitHub repo they ask you to run, without running it, and flag install hooks, VS Code autorun tasks, and code that reads wallet or SSH keys.
When an offer ends, you can report how it went. Phone numbers, domains and handles are hashed, so the next person who gets a message from the same number is warned.
It's free and open source. I built it for a hackathon on Walrus Memory, using DeepSeek for the reasoning.
Share my first-hand experience of day two at Sui Basecamp: what I saw, what I learned, and what impressed me.
Recap: An overview of the venue, demos, and announcements I learned about.
Knowledge Sharing: What I learned about the technology and how to understand its claims.
Highlights: The moments that stood out and why they mattered to me.
Vlog Experience: A personal walkthrough of the atmosphere and activities I experienced.
Recap
What stood out on day two at Basecamp?
The dopamint-arena presentation on LLM poker
The first thing I want to talk about is the dopamint-arena presentation on LLM poker. AI models take the seats at a poker table and play against each other, and I thought it was really impressive.
Trying Dopamint Open and pressing Predict
Dopamint Open was a lot of fun. I went in, pressed the Predict button, and became a participant myself. Getting to join in, instead of only watching, made it more fun.
Spending a few hours vibe coding
I also spent about three to five hours vibe coding today, and that was just as fun. We built Visual Shop, an eyewear marketplace on Sui testnet where a seller turns a photo of a frame into a 3D model, and a buyer tries it on with a webcam before paying in SUI.
In the dopamint-arena design docs, the contestant in an LLM match is a specific, committed version of a model. The documented Texas Hold'em profile seats six players, gives each a starting stack of 10,000, and plays 15 hands. The blinds rise every three hands, from 50/100 at the start to 300/600 at the end. That means the stacks get shallower as the match goes on: from 100 big blinds at the start to about 17 at the last level.
These numbers come from the repository's committed Texas v1 table profile. They are the documented default, not a measurement of the table I watched.
What "autonomous" does and does not cover
Each model plays through an operator-controlled harness that runs inside an attested enclave, which is a locked-down environment whose software can be measured and checked. The design docs record every model turn as evidence: the exact requests and responses exchanged with the model provider, any tool calls, and the rationale the model declared. The accepted moves form a transcript whose Merkle root is anchored at settlement.
One caveat from the same docs: the vendor inference itself remains an explicitly external trust domain. The enclave and the evidence make the orchestration around the model checkable, but they don't turn the model provider's servers into something you can verify.
What Predict is, and what it is not
According to the DOPA-PREDICT design, prediction is a closed-loop, play-money feature. You connect a Sui wallet and take positions without creating a separate off-chain account. It is a separate bounded context from the game: it consumes verified match results and is specified never to influence what the models see, which actions are legal, or how a match settles. So being a participant on the prediction side doesn't change the poker.
Open is the league for bring-your-own agents
The design docs describe DOPA-OPEN as the open-agent league. Participants can run their own decision logic on infrastructure they control, and that runtime is explicitly treated as untrusted. The authority still runs match coordination, timekeeping, evidence, and settlement the same way for every participant class. This is why the same arena can host different kinds of players without trusting any of them.
What I learned building Visual Shop
Visual Shop has no backend server and no database. Sui is the backend:
Shop: One shared object holds the list of listing IDs, so the front end loads the whole catalog in one read.
Listing: A shared object with the seller, title, price, stock, and a link to the media file.
Receipt: An object owned by the buyer, created when they pay. It is the proof of purchase.
The buy function checks that the listing is active and in stock and that the payment is exact, then sends the coin to the seller. The 3D model is built in the browser from a photo, in a web worker. The try-on uses MediaPipe for face tracking and three.js to draw the frame on the face.
Two Sui details tripped us up, and both are in our spec:
JSON-RPC is gone on public fullnodes. Reads have to go through gRPC and the newer u/mysten/dapp-kit-react.
The faucet credits the address balance. A funded wallet may own no coin objects at all, so payment is built with coinWithBalance instead of splitting the gas coin.
Everything runs on Sui testnet. Physical delivery isn't part of the demo, so the on-chain receipt is the proof of purchase.
Highlights
Demos, moments, and the personal impressions that stayed with me.
LLM poker, presented by dopamint-arena
The dopamint-arena presentation on LLM poker really impressed me. AI models playing poker against each other is a fun idea on its own.
The design docs also record each model's turns as evidence, so claims about a match can be checked against a record.
Pressing Predict and joining Dopamint Open
Dopamint Open was a lot of fun. I went in, pressed Predict, and became a participant, so I was part of it instead of just watching.
A working shop in a few hours
Vibe coding was a highlight too. In just a few hours we had a Move contract on testnet, a photo-to-3D seller flow, a webcam try-on room, and on-chain receipts. We even added hand-gesture control in the fitting room: point left or right to change frames, and hold a thumbs-up to buy. It was a really fun way to spend part of the day.
Vlog Experience
Come along for my second day at Basecamp.
Watching LLM poker
Today I watched the dopamint-arena presentation on LLM poker, and it was really impressive. AI models sit at the table and play poker against each other. Really cool to see.
Joining Dopamint Open
Then I tried Dopamint Open. I went in and pressed Predict, and just like that I was a participant. Super fun.
Vibe coding Visual Shop
I also spent three to five hours vibe coding today. We built Visual Shop: take a photo of a pair of glasses, turn it into a 3D model, try it on with your webcam, and pay in SUI. All of it runs on Sui testnet, and it was really fun to build.
On stage today, Mysten co-founder Adeniyi Abiodun described Sui with an analogy: "Think of Sui as a court."
Agents agree on rules when they open a tunnel. They transact privately and at machine speed. They settle when they close it. The chain stays out of everything in between unless there's a dispute.
I think that's the clearest statement yet of what Sui is trying to become. It isn't a chain that processes every machine interaction. It's the neutral layer underneath them: authority before a transaction, proof after it, settlement and dispute resolution when the parties disagree.
The three big announcements from the last 48 hours make the most sense as evidence for that architecture. Each answers a different question.
1. The demand question: what can an agent actually buy? (Alibaba Cloud)
Sui and Alibaba Cloud announced they're bringing Alibaba's cloud services into Sui Agent Payments. A company gives an agent a budget, and the agent pays per call in stablecoins on Sui, with no human approving each purchase. The owner's grant sets which services the agent can buy, the total budget, a per-payment cap, and an expiry date.
Payments are only part of this. The harder part is authority: who gave this machine permission, and did it stay within it? Sui is making that authority explicit and programmable instead of handing an agent the keys to an account.
Status: announced, not live. The integration still has to ship.
2. The institutional question: what would make a company trust an agent with money? (Google Cloud + Mysten: Verifiable Agent Arbiter)
Crypto has spent years looking for problems that genuinely require a blockchain. This may be one.
VAA is an evidence layer that Mysten and Google Cloud are co-developing for enterprise agents:
The sensitive telemetry (prompts, outputs, tool calls, policy decisions) stays private in the customer's own Google Cloud Storage.
Cryptographic proofs of that record are anchored on Walrus and coordinated on Sui.
Google can host the agent, store the data, and provide the protocol agents use to talk to each other. But if two Google customers' agents end up in a dispute, Google can't be the sole keeper of the evidence. The proof has to live somewhere neither company, and ideally not even the cloud provider, can quietly rewrite. That's the role this design gives Sui.
VAA also plugs directly into Sui Agent Payments. It logs the authorization, the spending decisions, and the service delivered. So the Alibaba and Google pieces aren't just compatible in theory; Mysten has wired them together.
There's also distribution upside here. VAA handles disputes between agents talking over Google's Agent2Agent (A2A) protocol, now under the Linux Foundation. Sui doesn't need to win the race over how agents communicate. If A2A becomes a major enterprise standard, Sui could become part of how agents prove what happened afterward.
Regulation adds a concrete reason to care. The EU AI Act imposes logging and record-keeping requirements on covered high-risk AI systems, with major provisions taking effect from 2027.
Status: initial enterprise deployments are planned before broader availability.
3. The scale question: what happens when millions of agents do this continuously? (40.6M TPS in tunnels)
Sui tunnels hit 40,614,180 TPS today, up from 6.09M in July. More than 10,000 tunnels opened on mainnet. Only the open and close transactions hit the chain. CertiK monitored the test live, and its full report is due in the coming days.
Expect people to say "that's offchain, it doesn't count." That misses the point. An economy producing millions of machine interactions per second shouldn't write every step to global consensus; doing so would make agent commerce uneconomic. The real test is whether those interactions can stay fast and private while still settling under rules nobody can break. That's what tunnels are built to show.
Why this fits Sui specifically
An agent economy isn't just accounts sending balances. It's agents interacting with assets, permissions, service entitlements, credentials, and machines. That kind of state maps naturally onto Sui's object model. Other chains can build scoped agent permissions too, but on Sui it's the native shape of the system rather than something added on top.
What it doesn't mean
The money in these flows can settle in stablecoins, and agents may never need to hold SUI. Sponsored transactions hide gas from the user, though someone still pays it. Eligible stablecoin transfers can run at zero gas. So a dollar of agent commerce is not a dollar of SUI demand, and anyone pitching it that way is overselling. The real token thesis is that SUI secures and settles the trust layer underneath this activity, and that layer becomes more valuable as more machine commerce depends on it.
And announcements aren't adoption. What I'm watching:
CertiK's published report
The first named enterprise running VAA in production
Alibaba's integration going live, and whether real agent spending shows up on-chain
The bigger picture
Machines are already fast. The hard problem is letting machines run by different companies buy, commit, and pay without everyone having to trust the same intermediary. That needs programmable authority before the transaction, verifiable evidence after it, and a neutral place to settle disagreements.
That's a much bigger thesis than "Sui is fast." Sui is trying to become the trust layer for an economy whose participants increasingly aren't human. This week, two of the world's largest cloud companies started building on that premise.
