The problem with crypto UX

Crypto promised to democratize finance. A decade later, the reality is that most people who own crypto never use it. The infrastructure exists — fast blockchains, deep liquidity, sophisticated financial primitives — but the interface between human intent and onchain execution remains broken.

The execution gap

When a user wants to swap ETH for USDC at the best available price, the protocol-level reality requires: identifying which chain offers the best rate, ensuring the correct gas token is available, approving the token spend, executing the swap, and — if the best rate is on another chain — bridging first. Each step introduces a new failure mode, a new approval, and a new opportunity for user error.

This is not a user intelligence problem. It is a design problem. The existing model forces users to speak the machine's language rather than their own. INTNT inverts this relationship.

Why existing solutions fall short

Current approaches — DEX aggregators, bridge interfaces, portfolio managers — reduce friction at individual steps but do not solve the underlying problem. They still require users to understand chain topology, manage multiple approvals, and accept execution risk at each step. They optimize the machine-language interface rather than replacing it.

Existing intent-adjacent protocols such as UniswapX and CoW Protocol address intent within single ecosystems or specific verticals (token swaps). No general-purpose, cross-chain intent layer with a verifiable settlement guarantee exists today. This is the gap INTNT fills.

The INTNT solution

INTNT is a coordination protocol. It does not replace existing blockchains, DEXes, or liquidity venues. Instead, it sits above them — translating declarative user intent into verified onchain execution through a competitive solver network and a novel multi-layer settlement architecture.

How it works in three steps

• Intent creation. The user signs a structured intent using EIP-712 — specifying input token, output token, minimum acceptable output, deadline, and a unique nonce. No transaction is broadcast. No gas is paid. The signed message is posted to the IntentBook contract, which stores it and emits an event.
• Solver competition. Registered solvers — bots, market makers, or any technical operator — monitor the IntentBook for new intents. Each solver independently calculates the best execution path across available liquidity venues. The solver that can provide the best outcome submits their solution to the SettlementEngine.
• Atomic verification and settlement. The five-layer SettlementEngine verifies the solver's solution atomically. If the solution satisfies all conditions — valid signature, eligible solver, correct output — it executes and the user receives their output. If any condition fails, the entire transaction reverts. The user loses nothing.

What users can express as intents

Protocol architecture

// Core intent data structure
struct Intent {
    address user;           // intent creator
    address inputToken;     // ERC-20 being spent
    uint256 inputAmount;    // amount to spend
    address outputToken;    // ERC-20 desired
    uint256 minOutput;      // floor — enforced by L4
    uint256 deadline;       // unix timestamp expiry
    uint256 nonce;          // prevents replay
    bytes32 intentHash;     // keccak256 of above
}

// Reputation growth curve (fills → points per fill)
fills  1–100:   +5 points per fill
fills  101–500: +2 points per fill
fills  501+:    +1 point per fill
max:          1000 points

// Slashing mechanics
slash amount = stakedAmount × slashPercent / 100
reputation   = max(0, score − reputationDecayPerSlash)
deactivate   if stakedAmount < minimumStake

// Simulation flow
1. Check target is on governance-approved whitelist
2. Snapshot outputToken.balanceOf(user) → balanceBefore
3. Execute solution.callData against solution.target
4. Snapshot outputToken.balanceOf(user) → balanceAfter
5. outputReceived = balanceAfter − balanceBefore
6. Require outputReceived >= intent.minOutput

// Settlement sequence (atomic)
1. Require Layer2.isEligible(solver)          // cheapest check first
2. intentHash = Layer1.validateAndConsume()   // consumes nonce
3. Require !filled[intentHash]                // double-fill guard
4. simResult = Layer3.simulate()              // verify output
5. If sim failed: slash solver, revert
6. filled[intentHash] = true                  // before transfers
7. Pull inputToken from user → this
8. Transfer (inputAmount − fees) → solver
9. Transfer protocolFee → treasury
10. Transfer solverFee → Layer5 escrow
11. Layer2.recordFill(solver)                 // update reputation

The solver network

Solvers are the execution layer of INTNT. They are independent operators — bots, market makers, or technical individuals — that monitor the IntentBook for open intents and compete to fill them profitably.

Solver architecture

A solver comprises four functional modules:

Solver economics

Solvers earn 0.10% of the input amount on every filled intent. At $1M in daily volume, a single solver capturing 30% of fills earns approximately $300/day in fees before gas costs. Early solvers additionally receive $INTNT liquidity mining rewards, materially improving unit economics during the bootstrap phase.

Reputation and competition

Solver reputation scores — computed entirely onchain from fill history — serve two functions. First, they act as a market signal: users and integrating apps can filter for high-reputation solvers. Second, they become the basis for INTNT's AI agent reputation primitive (see Section 6). Early solvers who accumulate reputation during the testnet and bootstrap phases hold a durable competitive advantage as the network scales.

$INTNT token economics

$INTNT is an ERC-20 token with three structural utilities and one emergent utility. It is not a governance token that happens to exist — each utility is load-bearing to the protocol's operation.

Utility 1 — Solver access

Solvers must stake a minimum of 10,000 $INTNT in the SolverVerifier contract to be eligible to fill intents. This creates demand for the token directly correlated to solver network growth. As intent volume increases, more solvers join, each requiring a minimum stake purchase. Bad actors are slashed — tokens burned permanently — creating deflationary pressure from protocol misuse.

Utility 2 — Governance

$INTNT holders govern all adjustable protocol parameters via Snapshot voting with onchain execution via a Governor contract and Timelock. Governable parameters include: fee rates, minimum solver stake, slash percentages, dispute window duration, approved execution targets (L3 whitelist), and treasury allocation.

Utility 3 — Staker yield

25% of all protocol fees flow to $INTNT stakers proportional to their stake. This creates real yield backed by real transaction volume — not an emission schedule. The yield scales linearly with protocol usage.

Supply allocation

Fee flow

Revenue scenarios

The reputation primitive

The most underappreciated aspect of INTNT's design is its emergent fourth utility: a verifiable onchain trust score for autonomous execution agents.

As AI trading agents, DeFi bots, and autonomous wallets proliferate, every protocol they interact with faces a fundamental question: should this agent be trusted? Today there is no standard answer. Each protocol makes its own assessment, usually defaulting to either full permissionlessness (anyone can interact) or full permissioning (whitelist only).

The INTNT reputation score

Every solver wallet in INTNT accumulates an onchain reputation score based on four factors:

• Fill rate — the percentage of submitted solutions that successfully settle
• Execution quality — average output delivered versus minimum required (did the solver beat the floor?)
• Speed — time from intent posting to fill submission
• Slash history — permanent record of any slashing events

This score is fully verifiable by any contract, wallet, or protocol that can read Base state. It requires no oracle, no trusted intermediary, and no off-chain attestation.

The AI agent market

DeFi protocols can use INTNT reputation scores to gate access — "only interact with wallets that have INTNT reputation above 800." For AI agents operating autonomously, this score becomes a portable credential: evidence of reliable, non-fraudulent onchain execution history. As autonomous agent wallets become the dominant user archetype in DeFi, INTNT owns the trust primitive they all need.

This positions INTNT not only as an intent execution layer but as foundational infrastructure for the autonomous onchain economy — a market that barely exists today but will be substantial within three years.

Development roadmap

Risk factors

INTNT is pre-mainnet software. The following risks are material and should be understood by any participant.

Smart contract risk

Despite multiple audits and the architectural isolation of financial logic to Layer 4, smart contract exploits remain possible. Mitigations: staged TVL caps during initial deployment (single intent cap $1,000, total cap $50,000 in the first 90 days), two independent audits before mainnet, formal verification of core L4 invariants, and a bug bounty program.

Solver cold start

A protocol with no solvers cannot fill intents. Mitigations: the founding team operates solver zero from day one; liquidity mining rewards subsidize early solver economics; the open-source solver template minimizes technical onboarding friction.

Regulatory risk

$INTNT may be classified as a security in certain jurisdictions. Mitigations: legal opinion obtained before token launch; foundation or DAO LLC structure in a crypto-favorable jurisdiction; genuine utility from day one reduces the "investment contract" argument; progressive decentralization of governance.

Competitive risk

Established protocols (Anoma, ERC-7521, UniswapX) may expand to address the general intent layer. Mitigation: the reputation primitive is INTNT's durable differentiator — it accumulates with usage and cannot be replicated by a competing protocol starting fresh.

MEV and solver manipulation

Solvers could attempt to frontrun intents or manipulate execution prices within the allowed parameters. Mitigations: L3 simulation enforces minimum output strictly; commit-reveal patterns for high-value intents; private mempool support (Flashbots Protect) as a recommended solver configuration.

Conclusion

INTNT Protocol addresses a foundational gap in the onchain economy: the translation layer between human intent and machine execution. By separating intent expression from transaction construction, introducing a competitive solver network for optimal execution, and enforcing outcomes through a novel multi-layer settlement architecture, INTNT makes crypto work the way users expect it to — not the way blockchains require it to.

The protocol launches on Base, targeting the 93% of wallet holders who own crypto but never use it. It expands to all major EVM chains and Solana in Phase 4. Its reputation primitive — an emergent byproduct of the solver network's onchain activity — positions INTNT as infrastructure for the autonomous agent economy that is developing alongside it.

$INTNT is a structurally necessary token: without solver staking, there are no solvers; without solvers, there are no fills; without fills, there are no fees. This alignment between token utility and protocol function makes $INTNT one of the few tokens in DeFi whose demand is directly correlated to the protocol's actual usage.

This document is provided for informational purposes only and does not constitute an offer or solicitation to purchase securities. $INTNT tokens have not been registered under the securities laws of any jurisdiction. This whitepaper describes a pre-mainnet protocol and is subject to change. Participation in INTNT Protocol involves significant risk including total loss of funds. Always conduct your own due diligence.