The internet’s final form is not a faster silo; it’s a global coordination layer where code, value, and identity move as one atomic unit. Sui is that layer.
Fair warning: 11-minute read. Grab a coffee!
BTW: Here’s the link to my Substack to stay posted:
The Internet Is Broken
The internet wasn’t built to handle what we’re asking of it today.
It was supposed to be this universal substrate: open, democratic, composable by default. The kind of thing where innovation could compound because everything was meant to click together.
That was the dream. What we got instead is something very different.
Today’s internet feels fast on the surface, but under the hood, it’s fragmented, opaque, and deeply brittle.
Behind every slick app is a tangled mess of custom connectors, one-off integrations, and hand-written glue.
Every time you move data from one system to another, you’re hoping nothing breaks.
Every new app is a reinvention. Every user experience is stitched together by brute force. We've layered more abstraction on top of a broken foundation, but we’ve never really gone back to fix the foundation itself.
We’ve ended up with a web that doesn’t compose.
One where every service is a silo. One where coordination between apps, systems, and agents isn't native to the infrastructure, but duct-taped on after the fact.
We’ve built an internet where value moves slowly, logic can’t travel, and even the most basic interactions require trust in half a dozen middlemen.
And you can feel it every time you try to do something even slightly outside the box. The deeper you look, the more obvious it becomes.
A World of Friction
The more we build on top of this foundation, the worse it gets.
Every new app adds another layer of complexity. Another set of endpoints, another schema, another silent agreement between systems that no one remembers until it breaks.
The problem isn’t that we can’t connect things. It’s that we can’t coordinate them.
Developers spend weeks wiring up services that should’ve clicked together in minutes.
You want your app to trigger a payment, update a database, send a notification, and store a file?
Congratulations! You’re now juggling five different APIs, three sets of auth keys, and two different timeouts, just to make something basic happen.
There’s no shared context, no native way to coordinate, no way to build truly composable experiences across services.
We’ve accepted this friction as the cost of doing business on the internet. We normalize the patchwork. We design entire careers around managing the mess.
But what happens when that cost starts swallowing entire product roadmaps?
When whole teams are hired just to “make the integrations work”?
When companies are forced to build from scratch what already exists, simply because nothing composes?
That's the world we're living in right now.
There’s a whole economy of SDKs, dev tools, and glue code built just to paper over the fact that nothing truly composes.
Every time we think we’ve abstracted our way out, we end up building a new abstraction on top of the same old cracks. And when things inevitably break, we don’t question the foundation, we just patch the symptoms and move on.
But the cost of that friction doesn’t disappear. It builds. It compounds. And eventually, it shows up everywhere.
The Cost of Staying Fragmented
The cost of staying fragmented isn’t just technical debt, it’s innovation we never ship.
Developers spend close to 40% of their time wrangling code that has nothing to do with the product itself. Not designing, not building core features, not pushing what’s possible—just fighting the friction.
And it adds up fast.
Across industries, we’re talking about billions of dollars burned every year just to connect systems that were never designed to speak to each other.
That’s not just some abstract inefficiency. That’s developer salaries, product timelines, and market opportunities all getting eaten alive.
And when teams finally ship, they’ve often ended up duplicating work that already exists because reuse is too hard. APIs are inconsistent, auth flows are messy, and business logic isn’t built to be reused in modular ways.
So teams rebuild the same things, over and over, in slightly different wrappers, because there’s no composable foundation underneath them.
Integration delays stretch delivery cycles from weeks to quarters.
Product managers kill features to protect deadlines. Startups miss windows. Enterprises stall launches. And in the end, it’s not the competition that kills momentum, it’s the drag from inside.
This is the real consequence of fragmentation.
A generation of ideas dies in backlog limbo because coordination is too costly to justify. And yet somehow, this has become normal. We don’t even question it anymore..
But if you zoom out far enough, the picture becomes clear.
The problem isn’t just time or cost, it’s architecture. Something foundational is broken. And it’s been broken from the start.
What Broke the Web?
It’s easy to blame the symptoms. The glue code, the downtime, the dev time that disappears into integration work.
But none of that started with bad teams or poor planning, it started with the internet’s DNA.
The original sin is architectural. The original protocols weren’t designed for what we’re asking of them today.
They were built for documents, not programs. For publishing, not coordination. For sending information, not composing logic.
The entire stack was engineered around a read-only model of the world, where you loaded a page, clicked a link, maybe sent a form, and then moved on (early Web 1.0).
But that’s not how the modern internet works.
Today, everything is interactive. Apps talk to other apps. Services call downstream services. And none of it is native to the infrastructure.
HTTP was never built to support stateful coordination across services. APIs are just remote calls with no memory.
No guarantees. No determinism. No way to compose actions across domains and know they’ll either all succeed or all fail together.
There’s no shared execution layer. Just endpoints floating in the void, hoping someone wires them together correctly.
And so we build workarounds. We stuff logic into middleware.
We write microservices to glue microservices to other microservices. We rely on retries and polling and webhooks and cron jobs to give the illusion of coordination.
But it's just that, an illusion.
Underneath it all is a system that never evolved past its document-sharing roots. A system where services don't compose, where logic can’t travel, and where trust has to be outsourced to third parties who don’t care about your app’s uptime.
This is the architecture we’re still building on. And we’ve pushed it far beyond its original purpose.
If we want to go further, if we want to build an internet where agents can act, services can coordinate, and value can move with logic, we need to rethink what this foundation actually needs to be.
What the Future Demands
So the next question is:
What kind of foundation would actually let modern apps and the AI agents coming right behind them coordinate natively instead of fighting gravity every time they move?
Let’s start with the obvious!
Modern software isn’t a set of pages anymore; it’s a swarm of continuously running processes: APIs, microservices, data streams.
All of it needs to coordinate the moment it comes online, not after a week of plumbing and a mile of middleware.
Actions across services can’t be best‑effort handshakes; they need the same atomic certainty you expect from a function call inside your own codebase.
And it means any participant must be able to verify, instantly and cryptographically, that what they asked for actually happened.
That sets a new checklist.
First, composability: any service should snap into any other the way Lego bricks snap together.
Second, verifiability: when one service calls another, both sides should know precisely what happened, when, and under which rules.
Third, cryptographic guarantees at runtime: the substrate itself enforces the contract, with no more patchwork of retries, webhooks, and cron jobs.
Those are the minimum specs for an internet ready to graduate from brittle endpoints to living, breathing systems of logic.
We need a shared execution environment that treats the entire network like one programmable surface.
An LLM that can draft an email is cute, but an agent that books travel, swaps currencies, and files expenses in a single round trip? That will require deterministic, composable coordination at machine speed.
Anything less and the agent economy will stall out before it really begins.
Coordination has to be an intrinsic property of the substrate itself.
The real question: If this is the spec sheet for the internet’s next layer, who’s already shipping it?
The Coordination Layer We’ve Been Missing
Think of Sui as the internet’s missing coordination layer.
It’s the piece that finally lets services interact like they were always meant to: seamlessly, predictably, and without glue code holding them together.
What makes Sui different isn’t that it’s fast or cheap or parallelized, although it’s all those things. What makes it different is how it thinks about what an application is. Most platforms still treat services as isolated silos.
Sui treats the network like a programmable surface.
It’s built from the ground up to let one piece of logic talk to another, to let value, identity, and action move together as one unit. Not bolted on after the fact. Not piped through ten different middle layers.
Native. Composable. Deterministic.
You don’t have to scaffold entire architectures just to pass a token from point A to B. You don’t need a separate queue system just to ensure two services agree on what happened.
With Sui, coordination becomes a feature of the environment, not an integration task you assign to a junior engineer in sprint planning.
In other words, this isn’t just an upgrade to infrastructure. It’s a reset. A new foundation for how services coordinate, how logic moves, and how systems compose.
But the real unlock happens when you look at the primitives that make this possible.
Because under the hood, Sui introduces something far more powerful than a faster chain. It gives the internet its first native unit of composition.
The Internet’s New Building Block
Here’s the magic trick Sui pulls: it turns every public function on the network into what you can think of as an Atomic API.
A callable, composable unit you can snap into any workflow without asking permission.
Underneath, those functions operate on objects, not arbitrary key‑value blobs. an object the system can track, own, and mutate with absolute clarity.
Because everything is object‑centric, the runtime always knows who owns what, which fields changed, and whether two transactions touch the same state.
That knowledge is what lets Sui run transactions in parallel without sacrificing determinism, but more importantly it’s what lets developers reason about composition as simply as importing a library.
Now layer on Programmable Transaction Blocks (PTBs).
Think of a PTB as an orchestration script you fire at the network: Call this function, feed its output into that function, create a new object, then transfer ownership, as one seamless operation.
You package the whole intent into a single block, sign it, and the network guarantees it either all happens or none of it does.
Suddenly, stitching together services feels less like writing brittle integration code and more like composing pure functions in your editor.
And here’s where it gets interesting. Because a PTB can call any Atomic API, you can chain logic across modules written by completely different teams.
A flight-booking service can reserve your seat, a rail operator can lock in your train, and a hotel system can confirm your room. Three separate domains, one execution context, zero glue code.
The orchestration lives inside the block, not in a cron job or a message queue you have to nurse at 2 a.m.
That means fewer moving parts, fewer edge cases, and, crucially, an execution flow machines can inspect and verify without human hand-holding.
For developers, the upshot is obvious: less time wiring things together, more time shipping features.
For AI agents, the implications are even bigger. An agent can scan the network, discover Atomic APIs, and compose them on the fly with PTBs, confident the result will be deterministic and auditable.
Coordination stops being a brittle afterthought and becomes a first‑class capability they can rely on at machine speed.
That’s the new building block: an object‑centric world of Atomic APIs, orchestrated by PTBs, delivering workflows that are programmable, verifiable, and extensible by default.
Now the question shifts from “Can this really work in practice?” to “What happens when every app can be snapped together like Lego?”
Build Once, Compose Everywhere (Prove it works)
The moment you have Atomic APIs and PTBs, something fundamental shifts: you stop building applications as monoliths, and you start building them as systems of composable parts.
Not integrations. Not dependencies. But modules you can snap together, reuse, swap out, and remix without rewriting your backend or duct-taping a new API to the side of your architecture.
It’s the difference between hand-coding every joint and being handed a language where composition is the default, not the exception.
This is where Sui quietly flips the model of application development on its head.
Instead of every app needing to reinvent a payment flow, a permissions layer, a notification system, or a user registry, those features become addressable, callable units.
If it exists once, it can be reused. If it works in one context, it can be composed in others.
You don’t have to go build from scratch what someone else has already implemented. You just call their Atomic API, wrap it into your logic using a PTB, and you’re done.
That alone compresses development cycles from quarters to days. But more importantly, it opens up entirely new types of workflows, things that were previously too complex, too brittle, or too expensive to coordinate.
This isn’t just about blockchain. It’s about a new model for building software.
Because the moment you can trust the execution environment, you don’t have to own the entire stack. You just need to compose the parts that matter.
Which brings us to the next leap:
What happens when those systems no longer require human operators at the center?
When software starts coordinating with software, not just statically, but dynamically, contextually, and in real time?
The Next Evolution of Internet: Seamless, Modular, Agent-First
Zoom out far enough, and you start to realize something strange about the AI era we keep talking about.
Everyone’s building models. Everyone’s talking about agents. But none of it really works yet, not in the way we intuitively expect it to.
We’ve got LLMs that can summarize PDFs, generate poems, draft emails. We’ve got copilots that can autocomplete your code or help you write a contract.
But ask an AI agent to do something useful in the real world, book a flight, pay a vendor, submit a form, execute a business process, and it stumbles almost immediately.
Not because it’s not smart enough. But because the underlying internet doesn’t let it do anything.
There’s nowhere for that AI-Agent to go.
Because even the best AI agent still runs into the same old walls: endpoints that don’t compose, APIs that don’t speak the same language, services that weren’t built to be called by other machines.
So we build wrappers. Plugins. Agent frameworks. More scaffolding. And still, nothing flows. It’s like teaching a robot to run when the floor beneath it is made of sand.
But with a coordination layer like Sui, that floor becomes concrete.
Agents no longer have to simulate workflows by hacking together HTTP requests. They can actually coordinate, discover a service, compose with it, and execute real logic, all in one deterministic, auditable round trip.
The internet becomes addressable not just by humans, but by agents. Every function becomes a callable, composable capability.
And the role of software shifts from being a closed loop of interface and backend, to an open network of logic, stitched together at runtime by systems that can think.
This is what changes everything.
Once agents can coordinate without friction, the entire software stack starts to look different.
We move from applications that need backends, schedulers, and custom integrations to a world where most of what we used to call “infrastructure” just lives on the network, natively. Built-in.
Available for anyone or anything to use.
And in that world, the developer becomes more like a conductor than a builder. You’re not recreating the orchestra every time. You’re just composing new arrangements.
And that brings us full circle to the real transformation here!
Rebooting the Internet’s DNA With The Coordination Layer
We’ve come full circle. Thirty years ago the web linked documents; today we’re finally ready to link logic.
Everything we’ve walked through, Atomic APIs, PTBs, object-centric data, agent-level composability, adds up to a single realization: Sui isn’t just another tool in the developer toolbox.
It’s a rewrite of the internet’s DNA.
It replaces a world of endpoints and best‑effort calls with a fabric where code, value, and identity travel together, as one atomically verifiable unit.
That means the next killer app isn’t an app at all. It’s a composition, a living braid of capabilities drawn from a global pool of reusable services.
So where does that leave us?
At the edge of an internet that looks less like a patchwork of endpoints and more like a living operating system for global computation.
If you’re a builder, that means the fastest route to shipping something new is no longer reinventing the stack. It’s releasing a capability into the network and letting others snap it into their flows.
If you’re a capital allocator or a strategist, it means the surface area for innovation just exploded, because the cost of coordination just fell to near zero.
And if you’re simply someone who cares about where technology is headed, it means we finally have a path toward an internet that is open by default, intelligent by design, and composable at every layer.
That’s the endgame: not faster silos, but a global coordination layer where everything, data, value, identity, travels together, friction free.
The foundation is poured. Now it’s up to us to build the skyline.