Scaling trust beyond Ethereum: Cartesi’s bold approach to verifiable rollups
Cartesi isn’t just scaling Ethereum. It’s redefining what’s possible.
In episode 278 of Web3 with Sam Kamani, Bruno Maia, Head of Growth at Cartesi, shares how they’re building infrastructure for developers who want more than just speed or lower gas fees — they want trust, verifiability, and real-world computation on-chain.
Bruno’s journey is a story of transitions — from telecom at Qualcomm, through the ICO boom, to becoming a full-time Web3 builder in 2018. He eventually joined Cartesi, co-founded by a long-time friend, and hasn’t looked back since.
From verifiable AI marketplace to general-purpose rollups
Cartesi’s origin story is refreshingly pragmatic. What started as a platform for verifiable AI quickly ran into Ethereum’s limits. The team needed compute, determinism, and dev flexibility that Solidity couldn’t provide. So they built their own: a RISC-V-based Linux VM, designed to run app-specific optimistic rollups, all while inheriting Ethereum’s base layer security.
This approach unlocks something radical — not just scalability, but a new programming paradigm. You can write decentralized apps in any language, use mature Linux tools, and deploy software that’s both verifiable and deterministic.
It’s not “Layer 2.” It’s Stage 2 — a term Cartesi uses to emphasize full trust minimization, including robust dispute resolution and on-chain verifiability.
Why Cartesi’s model matters
Ethereum wasn’t designed to run complex computation natively. Cartesi extends Ethereum’s design space, not just horizontally (faster or cheaper) but vertically — into real-world use cases that require complex logic and reproducibility.
Some emerging applications include:
- Verifiable AI: Custom machine learning models that run on-chain and can be audited
- Advanced DeFi: Deterministic lending and risk assessment logic
- Carbon credits & RWAs: Real-world asset tracking with verifiable proofs
- On-chain games: PlayRise.io is just one example of what’s now possible
All of this runs in a Linux-based environment, which means developers don’t need to relearn everything — they just need to plug into a new execution layer.
Bringing Web2 devs into Web3
One of Bruno’s biggest missions at Cartesi is lowering the barrier for Web2 developers. And it’s not just about DX (developer experience). It’s about:
- Trust: Ensuring that computation is deterministic and disputes resolvable
- Tools: Offering rich environments with full Linux compatibility
- Incentives: Using funding, hackathons, and validator marketplaces to support the ecosystem
Rather than chasing vanity metrics, Cartesi focuses on meaningful KPIs — like external capital raised for Cartesi-powered projects and long-term sustainability through its validator marketplace and token-based incentive systems.
The validator marketplace and attention economy
Cartesi isn’t falling into the trap of “open-source equals free.” Their model includes:
- A validator marketplace, where infrastructure is rewarded for securing apps
- A growing token utility, tied to participation and governance
- An “attention economy,” where impactful dApps are rewarded for traction and user adoption
This approach aligns incentives — not just for devs, but for infrastructure participants and users.
Web3 biz dev ≠ Web2 sales
One of the most interesting takeaways from this episode is Bruno’s view on BD in Web3. He compares it to early-stage startup building — where it’s less about closing deals and more about finding product-market-fit alongside the community.
This also reflects in how Cartesi approaches go-to-market: choosing the right devs for the right product maturity, and building slowly with deliberate traction, not hype.
The road ahead: RWAs and native on-chain flows
Looking forward, Bruno and Sam discuss what’s needed to bridge real-world value into Web3. It’s not just about tokenizing real estate or invoices. It’s about native cash flows on-chain — things like rent, subscriptions, or yield that can be paid, tracked, and verified directly through smart contracts.
Cartesi’s infrastructure — with modularity, DA layers, rollups, ZK integrations, and privacy tools — is positioned to enable this next wave.
Final thoughts: come hack the Honeypot
Bruno ends with a challenge: developers, white-hat hackers, and infrastructure nerds — test Cartesi’s limits.
Check out their Honeypot Challenge. If you can break it, you keep the funds. And you help secure the future of trust-minimized computation.
Listen to the full episode:
