Mantua.AI isn’t a chatbot gimmick or another “AI overlay” on DeFi dashboards. It’s a step toward a natural language layer for the blockchain, where users can type (or eventually speak) commands like:

“Swap 0.5 ETH for USDC using a dynamic fee hook.”
“Add liquidity to the ETH/USDC pool with MEV protection.”
“What’s the TVL of ETH/cbBTC pair?”

and see those requests parsed, reasoned through, and executed onchain — safely and transparently.

🔗 Test it now on Base Sepolia → testnetmantuaai.com

From Hooks to Intelligence

Mantua began as an experiment in programmable liquidity: using Uniswap v4 Hooks to make markets more adaptive. Over time, the project evolved into something broader — a DeFi operating system powered by AI reasoning.

The new version, Mantua.AI, builds on that foundation. It’s designed to understand intent, reason about DeFi logic, and act with precision. Under the hood, it integrates:

• Uniswap v4 Hooks for customizable swap and liquidity logic

• Metamask for wallet creation and blockchain access

• Base Sepolia as the primary test environment

This combination turns Mantua into more than an app — it’s a prototype for what intelligent interfaces onchain can look like.

What’s Live Right Now

The current soft launch focuses on the frontend layer: a working, intelligent interface where users can test core DeFi actions through conversational input.

Here’s what’s available:

• ✅ Wallet Connection

• ✅ Natural-Language Command Parsing

• ✅ Hook Integration

• ✅ Liquidity Creation Flow

• ✅ Real-time Token Pricing

• ✅ Execution Feedback

All logic runs through a chat-based interface, so every action — from adding liquidity to swapping — happens in a familiar conversational flow. It’s the same simplicity people expect from AI assistants, applied to onchain operations.

🔗 Test it now on Base Sepolia → testnetmantuaai.com

Why Base Sepolia

Building on Base Sepolia provides Mantua.AI with a stable, developer-friendly environment to test real interactions before mainnet deployment. Base’s alignment with Coinbase’s broader ecosystem — and its growing developer community — makes it the ideal testbed for intelligent onchain applications.

Mantua’s architecture is designed for compatibility with Base Mainnet, Ethereum, and Unichain, ensuring that when the full launch arrives, it will scale seamlessly across EVM-compatible chains.

The Vision Ahead

This soft launch isn’t the end — it’s the foundation layer for Mantua’s broader roadmap. Upcoming phases will focus on:

• Autonomous DeFi Agents: AI agents that monitor and execute user strategies within approved parameters

• Hook Library: Pre-built and community-contributed Uniswap v4 Hooks, ranked by performance and reliability

• Mantua Intel: A custom AI-powered Hook, built by Mantua.AI

• Voice and Multimodal Interfaces: Future versions will enable speech commands and contextual analysis of onchain activity

Step by step, Mantua.AI is transforming from a prototype into a programmable intelligence layer for decentralized finance — one that merges natural language, blockchain logic, and execution safety.

Try It, Watch It Grow

Mantua.AI is now live on Base Sepolia for early testers. The next steps include expanding the test group through Telegram and continuing to refine the chat experience, hook integrations, and transaction reliability before the public beta.

If you’ve been following Mantua’s journey — from programmable liquidity to intelligent interfaces — this soft launch marks the clearest proof yet that the vision is real and working.

Welcome to Mantua.AI — where DeFi meets intelligence, built on Base.

Try it live: https://testnetmantuaai.com

Startups may appear glamorous from the outside — but the truth is, most of it is just about hard conversations, misaligned expectations, and moments where things fall apart.

This past month, I had to face some of those moments head-on.

The Design Gap

brought on a designer early to help shape Mantua’s UX. We had some good moments — refining the liquidity pool flow, debating how to consolidate steps, and building a foundation together.

But cracks showed up. Missed meetings, late arrivals, and design changes made without communication. Initially, I attempted to maintain a collaborative approach, advocating for consolidation and a smoother user experience. But when unapproved edits started happening directly in the design file, I had to step back and ask: is this the level of professionalism I want in my founding team?

The answer was no. And I had to make the hard call to part ways.

The Developer Reality

Around the same time, I was in conversations with a potential dev lead. A talented builder with real potential. But here’s the reality: Mantua is still in the bootstrapping stage. Every founder on this project is working on sweat equity until we hit traction or funding.

That structure didn’t fit his reality — he needed income immediately, with a family to support. We had to walk away. And I don’t fault him for that.

The Lesson

Both experiences came down to the same thing: clarity is everything.

• Clarity on values (professionalism, accountability, urgency).

• Clarity on structure (equity-first until funding).

• Clarity on timing (not everyone can wait for the upside).

When things don’t work out, it’s not always failure. Sometimes it’s reality saving you time by revealing who’s really aligned.

The Pivot

These conversations also pushed me to make a bigger decision: we’re no longer Mantua Protocol. We are Mantua.AI.

Mantua.AI isn’t just another DeFi protocol. We’re building at the intersection of artificial intelligence, hooks, and autonomous agents — giving users natural language control over liquidity, swaps, and contracts.

The vision is sharper. The name is clearer. The mission is stronger.

When things don’t work out, it clears the space for what will. And for Mantua.AI, that means building a leading edge where AI connects liquidity, hooks, and agents into something the space hasn’t seen before.

Mantua Protocol started, like most things do, with vibes.

During the first hackathon, I hacked together the MVP in Replit. It looked good enough to demo, but under the hood it was clunky. Only two-thirds of the app worked. The swap flow worked. The add liquidity flow worked. But the most important part of the vision — the ability to chat with the large language model — didn’t.

That’s the reality of “vibe coding”: it gets you to something, but rarely all the way to working.

Phase 1 → The Limits of Vibe Coding

Vibe coding was a double-edged sword. It gave speed, but it also created cracks:

• The LLM chat interface, which was the heart of Mantua, didn’t function.

• Smart contracts can’t be vibe-coded — they require precision.

• Data must be accurate; hallucinations aren’t acceptable in DeFi.

We had enough to submit. Enough to demo. But not enough to believe this was a product that could scale.

Phase 2 → Structured Prototyping in Replit

The second version pushed things further. This time, the chat interface did work as designed. The swap and liquidity flows were tighter. The UI was lighter. For the first time, Mantua felt like a DeFi product instead of a demo.

But the challenges of building a DeFi product didn’t go away:

• Vibe coding can’t ship reliable smart contracts.

• LLMs need structured prompts and accurate datasets.

• Every small detail in UX matters when real value is moving.

So while the product looked better, building it was still a grind.

Phase 3 → UX Foundation with Onchain Design Sprint

The breakthrough came when Mantua was selected for FBI Africa’s Onchain Design Sprint — only 26 projects chosen out of 100+ applicants. We worked with a dedicated design team to audit and redesign Mantua’s UX from the ground up.

This was where Mantua grew up.

• We got an audited UX that removed the friction points, pushing users away.

• A design system that was clean, scalable, and professional.

• A product experience that matched the ambition: making programmable liquidity conversational.

Why It Matters

The leap from vibe coding → structured prototyping → design sprint foundation wasn’t just cosmetic. It was existential.

Great tech doesn’t matter if users can’t use it. Adoption lives in the UX.

Now, Mantua has that UX foundation. Not vibes. Not clunky half-working demos. A real design system we can build on top of — one that guides, simplifies, and converts.

Mantua’s journey so far has been about evolving from spark → prototype → foundation. The next phase is building on top of that foundation and bringing programmable liquidity fully on-chain.

👉 Subscribe https://landingmantuaprotocol.com/ to follow along as we turn Mantua’s design system into a live product

Back at the start of July—July 1st to be exact—I launched the very first edition of the Mantua Protocol newsletter.

It wasn’t flashy. No big announcement. Just me, hitting “send” on an idea that had been looping in my head for almost a year: what if liquidity itself could be intelligent?

That first “send” felt heavier than I expected. Not because I doubted the vision—I’ve been obsessed with DeFi and programmable liquidity for a while—but because I knew what I had really signed up for: the founder’s struggle.

The Founder’s Struggle

People often glamorize being a founder in crypto.
But here’s what it’s actually looked like for me these past two months:

1. Distribution challenges

I’ve poured hours into writing threads, breaking down DeFi mechanics, and trying to make hooks + AI accessible. And then? The algorithm buries it.
Engagement is flat. Visibility is throttled. And you sit there asking: is my content even good enough? Or am I just shouting into the void?

2. Community discovery gone wrong

When you’re building in public, you’re supposed to “go where your users are.” For me, that meant Discord communities like Uniswap. But during one round of discovery, I shared a signup link for feedback.
Minutes later, I was kicked out.
That stung—not because I didn’t understand the rules, but because I realized how fragile early customer discovery can be in crypto. One misstep and the door closes.

3. Vibecoding mistakes

I “vibe coded” the first two iterations of Mantua—moving fast, shipping quick.
But here’s the truth: that’s not the move in Web3. Especially not in DeFi. Precision, credibility, and trust are non-negotiable. Vibecoding works for a hackathon demo. It doesn’t work when you’re trying to manage real liquidity onchain.
I had to throw out work and start again with intention. Painful lesson.

4. The everyday grind

And then there’s the hardest part: waking up every day to build something that doesn’t exist yet—and convincing others it should exist.
The grind isn’t glamorous. It’s lonely. And it forces you to answer the same question over and over: why am I still here?

Some days, it feels impossible.
But I’m still here. Still showing up.

And here’s why ⬇

Why Mantua?

Every DeFi cycle repeats the same broken patterns:

• Liquidity providers carry most of the risk.

• Users are locked out by complexity.

• “Passive” strategies are anything but.

I’ve spent years analyzing DAOs, writing research reports, and building dashboards to highlight these problems.
But research wasn’t enough. At some point, I had to try to fix them.

That’s what Mantua is about:

• AI + Hooks → liquidity that can adapt in real time.

• Agents → strategy automation for everyone, not just whales.

• Conversational UI → making DeFi feel human, not alien.

This isn’t just a product. It’s a response to years of frustration I’ve seen (and felt) as both a researcher and a user.

The Bigger Picture

DeFi isn’t broken. But it’s brittle.

Liquidity is the lifeblood of every protocol—and yet, it’s still stuck in outdated, manual, one-size-fits-all systems. Liquidity providers take on blind risk. Traders eat slippage. Protocols bleed efficiency.

Hooks change this. AI supercharges it. Together, they unlock a future where liquidity is programmable, adaptive, and even autonomous.

Mantua is my attempt to bring that future forward.

What’s Next

I don’t have all the answers. I don’t even have a polished product yet.
What I do have is a vision, a prototype, and a commitment to keep showing up.

Here’s how you can help shape what comes next:

• Read + share this newsletter. It’s my main channel to think in public.

• Give me feedback. What makes sense? What doesn’t? Hit reply and tell me.

• Sign up as an early tester. Soon I’ll open Mantua’s doors to a small group of people who want to experiment with programmable liquidity before anyone else.

Closing

When I published that first newsletter on July 1st, I thought I was just sharing ideas.
Now, I realize it was the beginning of something bigger.

Mantua isn’t just a protocol. It’s a journey—my journey, and hopefully yours too.

The founder’s struggle is real.
But so is the vision of programmable liquidity.

👉 Subscribe to the Mantua Newsletter to follow along and help shape the future.

What is a liquidity pool?

Before diving into PLAMMs it is worth recapping liquidity pools. A liquidity pool is a crowd‑sourced collection of tokens governed by a smart contract. In a decentralized exchange (DEX) the pool serves as a digital repository of tokens that traders swap against. Liquidity providers (LPs) deposit token pairs into a pool and earn a share of the trading fees; their tokens remain available to buyers and sellers. AMMs automate pricing by adjusting token ratios based on a formula, but distributing liquidity evenly across all prices leads to slippage and low capital efficiency.

Understanding PLAMMs

PLAMM is a term used here to describe AMM protocols that combine concentrated liquidity with programmable automation. Like CLMMs, a PLAMM allows an LP to select a price range for their tokens rather than spreading liquidity across an infinite spectrum. However, PLAMMs go further by enabling smart‑contract logic to adjust ranges, rebalance positions or execute strategies automatically. The concept draws inspiration from existing programmable liquidity protocols:

• Balancer: An AMM that lets users create programmable liquidity. Balancer pools can hold more than two assets at arbitrary weights and use a constant mean formula instead of the usual constant product formula. Because pool parameters (weights and fees) are controlled by smart contracts, other protocols can build on top of Balancer and treat it as a programmable liquidity layer.

• iZUMi Finance’s LiquidBox: This multi‑chain protocol provides liquidity as a service (LaaS). LiquidBox offers programmable liquidity mining tools on Uniswap v3 LP NFTs, enabling projects to distribute incentives precisely within certain price ranges and to optimize liquidity distribution. Its design demonstrates how smart contracts can manage incentive programmes while LPs concentrate their capital.

• Cetus Protocol: A DEX on the Sui blockchain that uses a CLMM model for higher fee earnings. Cetus offers a Super Aggregator that routes trades across liquidity sources, permissionless pool creation, and developer SDKs. LPs can automate strategies using the Cetus Vault, which manages and rebalances positions—an example of programmable liquidity built on top of a CLMM.

These examples highlight that programmable liquidity is not a single protocol but a design pattern: concentrated liquidity plus smart‑contract logic for automation and customization.

How PLAMMs work

In a PLAMM, LPs still select a price range for their tokens just as in CLMMs. Within that range, the smart contract uses ticks—discrete price intervals—to calculate liquidity distribution. When prices move outside the range the LP’s tokens stop earning fees and can even incur impermanent loss. What makes a PLAMM unique is that the range and fee parameters can be programmatically adjusted. For example:

• A liquidity provider could schedule their range to follow a moving average or rebalance based on volatility.

• Incentive programmes could automatically redirect rewards to LPs in specific price bands. iZUMi’s LiquidBox distributes incentives within selected ranges and uses auto‑rebased modules to attract more liquidity while controlling token emission rates.

• Dynamic fees can react to market conditions. In Balancer smart pools, the fee is part of the pool’s parameters and can be changed by the controlling contract, allowing adaptive fee structures that respond to volatility.
  

Benefits of PLAMMs

PLAMMs inherit the advantages of CLMMs and add new capabilities:

• Better capital efficiency – Concentrating liquidity into a chosen price band increases the probability that an LP’s capital is used. Programmable logic can further optimize deployment by widening ranges during high volatility and narrowing them when prices are stable.

• Mitigation of impermanent loss (IL) – Selecting and adjusting ranges enables LPs to manage risk more actively. Automation reduces the need to constantly monitor markets and can react faster when prices leave the chosen band.

• Custom fee and incentive structures – Smart contracts can allocate fees and incentives precisely. LiquidBox, for instance, allows protocols to distribute mining rewards within defined price ranges.

• Programmable strategies and vaults – Automated rebalancing and hedging strategies make concentrated liquidity less time‑intensive. Cetus Vaults manages and rebalances LP positions so users can automate their strategies.

• Composability – By exposing programmable parameters, PLAMMs become building blocks for DeFi. Balancer’s programmable liquidity lets other protocols plug into its pools and build custom trading or yield products.

Difference between PLAMMs, CLMMs, and traditional AMMs

CLMMs differ from constant product AMMs because they let LPs concentrate their liquidity into a selected price range rather than spreading it across the full price spectrum. PLAMMs extend CLMMs by adding programmable functionality. In a standard CLMM, adjusting ranges or fees requires manual action; in a PLAMM, those parameters can be updated automatically by smart contracts. Thus, PLAMMs can implement dynamic liquidity strategies, algorithmic rebalancing, or incentive distribution at the protocol level.

Examples of PLAMM Platforms

The following five examples show how different DeFi protocols employ programmable liquidity and concentrated liquidity. They illustrate how the PLAMM concept manifests in practice.

PLAMM Positioning: Stablecoins vs Volatile Assets

Concentrated and programmable liquidity behave differently for stable and volatile tokens. In a stablecoin pair, price movements are smaller and ticks within a chosen range are closer together. This makes it easier for LPs to supply liquidity precisely and manage risk. For volatile assets, price ticks are spaced farther apart, and fees are higher to compensate for risk. Programmable logic can, for example, widen the range automatically when volatility increases or implement stop‑loss actions when prices leave a band.

Factors to Consider When Using PLAMMs

• Multiple positions – PLAMMs, like CLMMs, let LPs open multiple positions at different price ranges. Programmable strategies can manage these positions concurrently.

• Active management vs automation – Concentrated liquidity requires monitoring because prices move out of the range. PLAMMs can automate rebalancing, but users should still understand the underlying mechanics and risks. iZUMi Finance notes that active participation reduces impermanent loss.

• Cost of execution – On chains like Solana, execution fees are lower, and scalability issues are minimal. Programmable strategies may require frequent adjustments, so fee costs should be considered.

• Risk of impermanent loss – Concentrated liquidity is not a “set and forget” strategy; studies found that liquidity providers on Uniswap v3 sometimes lost more money than if they had simply held their assets. Another study shows that active users can generate more revenue using concentrated liquidity than by holding. Automation can help mitigate IL but cannot eliminate it entirely.

PLAMM vs HODLing

HODLing means holding tokens regardless of price fluctuations. CLMM data showed that many liquidity providers earned less than if they had simply held their tokens. However, active management and optimized strategies can outperform a passive approach. PLAMMs enable such strategies to be automated, making it more feasible for retail users to engage in active liquidity provision without continuously watching markets. Even so, providing liquidity introduces additional risks—prices leaving the range, smart‑contract risk, and unforeseen market events—so users should carefully weigh the benefits against the simplicity of hodling.

Conclusion

DeFi innovation continues to march forward. Programmable Liquidity Autonomous Market Makers (PLAMMs) extend the concentrated liquidity ideas of Uniswap v3 and other CLMMs by adding smart‑contract automation. They allow liquidity providers to tailor, automate, and even delegate their strategies. Protocols like Balancer, iZUMi Finance, Cetus, Uniswap, and Orca Whirlpools illustrate how programmable liquidity can improve capital efficiency, customize fee and incentive structures, and open new possibilities for composable finance. At the same time, they demand an understanding of active liquidity management, risk, and network fees. As DeFi matures, programmable liquidity is likely to become an essential tool for both traders and protocols striving to build more efficient and autonomous financial systems.

We're building the conversational interface for decentralized finance.

Mantua Protocol's mission is to make DeFi accessible, intelligent, and autonomous by turning natural language into onchain action. No more complex dashboards. No more manual contract interactions. Just say what you need - swaps, liquidity provisions, hook deployments - and watch it happen.

Since our last updates, we've progressed from vision to execution. Today, we're revealing:

• The complete technical architecture (PRD)

• Our aggressive 6-week build timeline (PM Guide)

• How we're training our AI on real DeFi operations

• How you can get early access

The Architecture: PRD Deep Dive

Core Components:

1. AI Layer (Natural Language Understanding)

• Fine-tuned OpenAI GPT-4 model specializing in:

  • DeFi intent recognition (swaps, pools, hooks)

  • Multi-step transaction decomposition

  • Risk parameter extraction (slippage, deadlines)

• Training data includes:

  • 50k+ verified contract ABIs

  • 12k decoded transaction logs

  • Hook documentation and use cases

2. Execution Engine (Onchain Operations)

• Session-key managed wallets with:

  • Automatic revocation

  • Transaction simulation via Tenderly forks

  • Gas optimization (EIP-1559)

• Full Uniswap v4 SDK integration

• Base RPC for real-time data

3. User Interface (Conversational DeFi)

• Chat interface with:

  • Dynamic slippage adjustment

  • One-click hook configuration

  • Transaction previews

• Support for both supervised (user signs) and autonomous modes

Example User Flow:

1. User says: "Create a 1% fee pool for DEGEN/WETH with a TWAMM hook"

2. AI extracts: Tokens, fee tier, hook type

3. System simulates: Pool creation and estimates gas

4. User approves: After reviewing simulation

5. Execution: Transaction submitted with session key

The Build Plan: 6 Weeks to Launch

Week 1-2: Data Collection & Model Training

• Scrape and clean:

  • 10k+ verified contracts

  • 8k transaction logs

• First fine-tuning run: 50M tokens

Week 3: Local Testing Environment

• Docker containers for API and UI

• Local encrypted database

• Initial test prompts (100+ scenarios)

Week 4-5: Blockchain Integration

• Base RPC connection

• Uniswap v4 SDK implementation

• Agent wallet setup

Week 6: Security & Launch

• Smart contract audits

• Penetration testing

• Documentation completion

Join the Movement

We're looking for:

• Early testers (Sign up here)

• Developer feedback

• Community input

Next Edition Preview:
We'll share:

• First fine-tuning results

• Demo video of the chat interface

• Early access program details

Final Note:
This isn't just another AI wrapper. Mantua represents a fundamental shift in how humans interact with blockchain protocols - through conversation rather than complex interfaces. The future of DeFi isn't more buttons; it's fewer barriers.

Follow our progress on X/Twitter | Join our waitlist

Hi everyone — Delleon here 👋

In our first edition, I shared my journey through crypto, culminating in building Mantua Protocol. Today, I’m thrilled to reveal the blueprint behind Mantua — our mission, architecture, and how we’re turning programmable liquidity into a reality you can use today. Our whitepaper lays it all out, but I’m breaking it down here so you don’t miss a thing.

🛠 Why Mantua Exists

Decentralized finance has come a long way. We’ve moved from manual order books to automated market makers, opening opportunities for anyone to become a liquidity provider. But even today, providing liquidity feels like navigating a maze:

• You must set narrow price ranges to avoid impermanent loss.

• You have to constantly monitor market moves.

• You rely on dashboards and complex tools just to keep up.

Meanwhile, Uniswap v4 introduced Hooks — smart contracts that allow liquidity pools to behave dynamically, from adjusting fees to implementing MEV protections. These are game-changing. Yet Hooks remain out of reach for most people because they require developer knowledge to deploy and manage.

Mantua Protocol was born to bridge that gap: by combining Uniswap v4 Hooks, natural language, and autonomous agents, we make programmable liquidity accessible to everyone, no coding required.

🎯 Mission & Purpose

Our mission is simple but powerful:
Make DeFi accessible, intelligent, and autonomous by turning natural language into onchain action.

Mantua’s purpose is to unify the fragmented DeFi landscape into a single intelligent layer, enabling traders, liquidity providers, and developers to automate onchain activity through an intuitive conversational interface. We’re building a platform where your words become your strategy — executed seamlessly onchain.

🏗 Mantua’s Architecture: How It Works

The Mantua Protocol architecture is built on three core layers working together to make your liquidity smarter:

1⃣ Natural Language Interface – This is the AI-powered front-end where you type or say commands like:

“Create a pool with 1% fees and a dynamic fee Hook.”

Our AI parses your intent and sends the instruction to the backend.

2⃣ Hooks & Pool Infrastructure – This deep integration with Uniswap v4 allows you to deploy liquidity pools with programmable behaviors. Our library of prebuilt Hooks lets you implement strategies like dynamic fees or MEV-resistant swaps without writing a line of code.

3⃣ Agent Layer – These are autonomous bots that execute strategies on your behalf. Agents can rebalance your positions, optimize fee tiers, or track token flows. You can deploy them instantly from templates or customize them step by step.

In practice, here’s what happens: you instruct an action → our AI understands and structures it → our backend executes it through smart contracts and Hooks → your agent monitors or adapts the position as needed.

🔥 Uniswap v4 & Programmable Liquidity

Uniswap v4 Hooks are the heart of Mantua’s programmable liquidity system. Hooks let you inject custom logic into a pool’s behavior — something we’ve never seen before in AMMs. But Mantua takes this a step further:

• No-code deployment: We provide a user-friendly interface so you can deploy pools with Hooks like dynamic fees or limit orders instantly.

• Hook library: A growing collection of prebuilt Hooks, including dynamic fee adjustments based on market volatility, time-based LP rewards, or MEV-resistant liquidity strategies.

• AI-guided recommendations: Our chatbot understands what you’re trying to achieve and suggests the best Hooks for your goals.

Hooks unlock programmable liquidity; Mantua unlocks Hooks for everyone.

🤖 AI Interface & Autonomous Agents

One of the most exciting aspects of Mantua is our AI-driven agent system. Instead of manually micromanaging your liquidity, you can deploy persistent agents that act as your onchain team:

• LP Manager Agent – Adjusts your liquidity ranges, optimizes fee tiers, and claims rewards on your behalf.

• Swap Optimizer Agent – Monitors the market to find the best execution prices.

• Research Agent – Tracks token flows, monitors whales, and alerts you to unusual liquidity behaviors.

These agents can be launched in seconds through natural commands like:

“Deploy a rebalance Agent on my ETH/USDC position.”

Agents take Mantua beyond a tool — they make it your onchain command center.

🔎 Use Cases for Everyone

Mantua is designed for all DeFi users:

• Liquidity Providers: Simplify deploying and managing liquidity; use advanced Hooks without technical expertise.

• Developers: Test and deploy new Hook strategies directly through Mantua’s interface.

• Analysts & Researchers: Query live onchain data in plain English to analyze pool behavior, token flows, or Hook performance.

We’re building for the people who power DeFi — and we’re giving them tools to operate smarter than ever.

💰 Monetization & Ecosystem Growth

Mantua will sustain itself and incentivize growth through a multi-layered model:

• Hook usage fees on Mantua-deployed contracts.

• Small routing fees on swaps or liquidity actions processed through Mantua.

• Agent Template Marketplace: earn by building & selling agent strategies (like high-yield vault bots) to other users.

🚦 Roadmap: From MVP to Mainnet and Beyond

Our MVP has been a major milestone. We’ve already:

• Launched the Mantua whitepaper.

• Deployed the MVP on Base Sepolia testnet.

• Completed essential flows: swapping tokens, creating pools, adding and removing liquidity.

This MVP isn’t a proof of concept — it’s a fully operational platform where you can test programmable liquidity today. We prioritized features that show the power of Hooks + AI + Agents:

• Users can create pools with custom hooks or MEV protection directly from chat commands.

• Liquidity management flows like adding/removing positions are fully integrated.

• Early AI integrations let the system parse commands and recommend strategies.

Next, our plan includes:

• Launching on Base Mainnet with the same powerful features.

• Releasing the full Hook library and advanced agent templates.

• Expanding AI reasoning capabilities for more sophisticated natural language commands.

Long-term, we’ll add LP dashboards, enable community governance, and introduce protocol token discussions to ensure Mantua grows with its users.

🌱 Community, Growth, and Building in Public

We’re committed to building Mantua transparently and with our community at the center. Our strategy includes:

• Weekly updates and live demos to show real progress.

• Targeted incentives for early Hook builders and LPs, including rewards and feature prioritization.

• Educational content across newsletters, social posts, threads, and videos.

We want Mantua’s success to be our community’s success.

🛡 Security & Scaling: Trust Through Design

Programmable liquidity can’t exist without safety. Mantua’s security approach includes:

• Modular Hook architecture: each Hook runs isolated to minimize systemic risk.

• Audit-first deployments: every Hook, Agent, and contract will undergo rigorous audits before mainnet launch.

• Permissioned agent workflows: nothing happens without your explicit approval.

For scaling, Mantua combines Base’s low-cost, high-throughput infrastructure with an intent-centric execution model and asynchronous agent design, ensuring we can handle thousands of users without bottlenecks.

🏛 Progressive Decentralization & Community Ownership

We’re building Mantua to progressively decentralize. Initially, a founder-led model enables us to iterate quickly. Over time, governance of Hook listings, protocol fees, and major features will transition to token holders and the community. Developers will eventually publish Hooks and agents through a permissionless registry governed by Mantua stakeholders.

Our philosophy is simple: decentralize what matters, automate what can be automated, and empower users instead of gatekeepers.

🌐 Conclusion: The Future of Liquidity

We believe liquidity shouldn’t be dumb capital. Liquidity should adapt, evolve, and work for you. Mantua’s blend of Uniswap v4 Hooks, conversational AI, and autonomous agents makes programmable liquidity a reality today — not just a vision for tomorrow.

The future of DeFi is programmable, intelligent, and user-driven. By giving everyone the power to control their liquidity through natural language, Mantua unlocks a new era of accessible, powerful, and flexible financial infrastructure.

👉 Want to dive deeper? Read the full whitepaper here: Mantua Protocol Whitepaper

Thank you for being part of our journey.

— Delleon 🛠
Founder, Mantua Protocol

Hi, I’m Delleon, the founder of Mantua Protocol. My crypto journey started with a deep curiosity about decentralized systems and a drive to explore how blockchain could democratize financial tools. I spent the past five years honing my skills in crypto GTM, research, and analysis, working with DAOs like Raid Guild, Potion DAO, & Global Coin Research, and startups like Tally to break down complex topics for everyday users.

The Base Buildathon was a pivotal moment—not just for me, but for the entire ecosystem. With over 5,000 builders across 2,800 teams from 500 cities in 100+ countries, the event showcased global enthusiasm for onchain innovation. Out of more than 900 projects submitted, only 77 teams were invited to the IncuBase accelerator, and I’m proud that Mantua Protocol was one of them. Seeing this massive builder movement firsthand inspired me to double down on Mantua’s mission to make programmable liquidity accessible.

My builder journey took a major leap during the Base Buildathon, where I created the initial version of Mantua Protocol and won first place in the DeFi & AI category. That experience gave me invaluable insight into what it takes to ship real products on Base, and showed me how powerful programmable liquidity could be for transforming DeFi.

After the Buildathon, I joined the IncuBase accelerator, where I’ve been refining Mantua’s vision with guidance from mentors and fellow founders. The accelerator has taught me the importance of staying laser-focused on user problems, iterating quickly, and aligning product decisions with both market demand and core values.

Along the way, I’ve learned that success in crypto isn’t about hype—it’s about relentless execution, real utility, and building in public with your community.

🛠 What I’m Working On: Mantua Protocol Updates

Mantua Protocol’s mission is to make DeFi accessible, intelligent, and autonomous by turning natural language into action. Here’s what we’re focused on right now:
✅ Current Roadmap Highlights
We’ve also rewritten and established our whitepaper, clearly outlining Mantua Protocol’s architecture, technical framework, economic model, and roadmap. This foundational document sets a shared vision for users, LPs, developers, and partners as we build programmable liquidity together.

We’re building the operating system (OS) for programmable liquidity—a chat-driven platform where users can create and manage Uniswap v4 liquidity pools with hooks, automate strategies, and interact with onchain assets using natural language. Think: “I want a pool with dynamic fees”—and Mantua does the rest, onchain.

🔜 What’s Next

• Sharing the whitepaper with the community to align on Mantua Protocol’s vision, architecture, and roadmap.

• Launching a private beta of the MVP and core features, inviting early users to test programmable liquidity flows, hooks, and AI-driven interactions.

• Continued discovery with the community, gathering feedback, refining the product, and ensuring Mantua solves real problems for liquidity providers and traders.

  

🔥 My Hot Takes

💥 On DeFi
Liquidity shouldn’t be static or dumb capital—users deserve programmable tools that adapt in real time. DeFi protocols must move beyond passive LP positions to give people more control, intelligence, and automation.

🤖 On AI in Crypto
AI won’t just make crypto easier to use—it will transform how users interact with onchain assets. Natural language agents that understand your intent and execute onchain actions are the missing piece to bring DeFi to millions of new users.

🪝 On Uniswap v4 Hooks
Hooks are the biggest unlock for liquidity innovation since the introduction of AMMs. But they risk remaining a niche developer feature unless we build accessible interfaces—like Mantua’s —that let anyone use powerful hooks like MEV protection or dynamic fees without needing to write a single line of code.