Skip to content
Hightop docs header art
Hightop
Under the Hood

Architecture#

Hightop looks like a clean fintech app. Underneath, it is a stack of interoperating systems — each with a specific job, each reinforcing the others.

Every action in Hightop — whether it is a payment, an earn deposit, a borrowing action, or a swap — flows through the same architecture and is validated against the same onchain rules. That is the architectural payoff: one stack, one set of controls, one trust model, regardless of what the agent is doing.

The Layer Model#

Hightop's architecture can be viewed as five layers from top to bottom. The Wallet Model page gives a closer view of the layers within a single account. Here is the full system stack:

Entry Layer — the Hightop app and the Hightop API. Humans use the app to configure rules, monitor activity, and manage agents. Agents use the API to execute actions. Both talk to the same systems underneath.

Control Layer — the rules engine. Agent permissions, spending limits, payment paths, timing rules, and asset restrictions all live here. The same rule language governs payments, earn, and borrowing — which is why one set of controls works across all of them.

Rules stack in layers: account-wide guardrails, agent-specific guardrails, and path-specific rules. The most restrictive always wins. Key controls are enforced onchain by smart contracts. Covered across the Control Agents section, with the full rules model in Agent Permissions and Limits.

Wallet Layer — one smart contract wallet per Hightop account. The wallet holds and controls assets and positions, enforces policies onchain, and connects to external protocols through standardized adapters. This is the shared execution surface and capital pool across all of Hightop's systems — payments, earn, borrowing, and trading all flow through the same wallet. Covered in Wallet Model.

Protocol Layer — the yield, borrowing, trading, and other external financial protocols that the wallet reaches through its adapters. Underscore Protocol powers the wallet and earn infrastructure. Ripe Protocol powers the borrowing infrastructure. Both connect to a broader set of integrated protocols for lending, swaps, and liquidity. Covered in Earn Under the Hood and Borrowing Under the Hood.

Settlement Layer — Base, a Layer 2 blockchain built on Ethereum. This is where transactions settle, where smart contract state lives, and where the public record of every action is stored. Hightop users do not interact with this layer directly — it runs underneath everything.

How the App and API Relate#

The app is for humans. The API is for agents. Both connect to the same control layer and wallet layer.

When you configure an agent in the app — setting its permissions, limits, allowed assets, and payment paths — those rules are written into the smart contract wallet. When the agent later sends a request through the API, the smart contract checks the request against those same rules. The app and the API are two entry points into one system.

Neither has more power than the rules allow. A human using the app cannot bypass the onchain controls any more than an agent using the API can. The smart contract is the authority. The trust argument for why this matters is in Why Onchain Enforcement Matters.

A Request Moving Through the Stack#

Here is what happens when an agent deposits idle cash into Earn — showing how the layers work together:

  1. Entry Layer — the agent has idle USDC sitting in the Hightop account and sends a request through the API to deposit it into Hightop Earn.
  2. Control Layer — the smart contract checks: Is this agent active? Does it have earn permission? Is the asset allowed? Is the amount within limits?
  3. Wallet Layer — the smart contract wallet assembles the transaction and routes it through the appropriate adapter — in this case, the Underscore Protocol adapter for Earn.
  4. Protocol Layer — the Underscore Core Vault receives the deposit. The vault is already being managed by an AI agent that continuously optimizes across approved yield protocols.
  5. Settlement Layer — the transaction settles on Base. The blockchain records it permanently.

If any validation or execution step fails, the entire transaction reverts. No funds move. The same flow applies to payments, borrowing actions, swaps, and every other operation — always through the same layers, always validated against the same onchain rules.

Payment Systems#

Payment paths are control-layer primitives — the rules live in the control layer, and execution flows through the wallet layer.

Hightop has three internal payment paths, each designed for a different trust level and use case:

  • Recurring Payments — pre-approved vendors that agents can pay repeatedly, within configured limits
  • One-Off Payments — ad hoc payouts with optional review delays and cancellation windows
  • Trusted Transfers — fast transfers to your own highest-trust destinations, with delayed additions for security

Money also moves in and out of Hightop through external rails — bank transfers, ACH, card-based onramps, and withdrawal paths. These connect at the wallet layer.

Hightop also supports machine-native payment standards like x402 and MPP — designed for agents paying other agents and services directly. See Emerging Payment Protocols.

Earn Infrastructure#

Hightop Earn is powered by Underscore Protocol vaults, built by the Hightop team — shared pools where AI agents optimize yield across approved protocols within onchain-enforced boundaries. Core Vaults handle passive yield. Amplified Vaults layer managed leverage on top using the borrowing infrastructure.

Vault shares are standard tokens that can be used as collateral for borrowing — this is the bridge between the earn and borrowing systems, and it is what makes productive collateral possible. Covered in Earn Under the Hood.

Borrowing Infrastructure#

Hightop's borrowing runs on Ripe Protocol, also built by the Hightop team — a unified multi-collateral lending system where your entire portfolio backs a single overcollateralized loan. Earn vault shares, which represent your Earn position, can serve as productive collateral, earning yield while backing debt.

The wallet connects to Ripe through the same adapter architecture it uses for everything else. Agent controls still apply — borrowing actions are validated against the same onchain rules as payments and yield operations. Covered in Borrowing Under the Hood.

How the Pieces Connect#

The architecture is designed so that each layer reinforces the others:

  • Earn vault shares become borrowing collateral — the earn system and the borrowing system are not separate silos. Earn vault shares, representing your Earn position, flow into Ripe as productive collateral, and borrowed funds can flow back into Core Vaults for additional yield. This is how Amplified Vaults work.
  • Agent controls apply to everything — whether an agent is making a payment, depositing into Earn, or managing a borrowing position, the same control layer validates every action against the same onchain rules.
  • One wallet, every protocol — yield protocols, borrowing infrastructure, trading venues, and payment paths all connect through the same smart contract wallet via standardized adapters. No separate accounts, no fragmented capital.
  • Onchain enforcement runs through every layer — the trust model is not bolted on at the end. It is built into the wallet, the control layer, the vaults, and the borrowing protocol. The rules are enforced by smart contracts at every step.

The Hightop team built the app, API, wallet, control, earn, and borrowing layers as one vertically integrated stack. That matters because the layers were designed around the same needs: agents that need fast, programmable execution, and humans who need clear boundaries and simple oversight. The result is a system where the same rule model applies across actions, capital stays unified in one wallet, and earn and borrowing compose cleanly instead of being bolted together from separate products.

The underlying protocols — Underscore Protocol for wallets and vaults, Ripe Protocol for borrowing — are both open-source. The full source code is available on GitHub (Underscore, Ripe).

Where to Go Next#

Previous

Emerging Payment Protocols

Next

Wallet Model