Smart Engines: the platform

What you’ll get here

a map of the three tiers that make up Smart Engines — what each one is for, why they’re separated, and how they compose into a single multi-chain platform.

Most platforms are one big program. Smart Engines is deliberately three, because the three jobs it does have little in common: signing on blockchains is heavy and security-critical, serving application developers is light and fan-out, and routing traffic is edge-facing. Bolting all three into one binary would force every job to inherit the worst constraints of the others. So we split them.

This section is the tour of that split. Read it top to bottom and you’ll understand the whole platform shape before you touch a single API.

🧠 For Normies

Think of a restaurant. The kitchen (validator) does the skilled, dangerous work with the knives and fire. The waiters (host) take orders and bring food in a friendly way. The front door / signposts (gateway) get you to the right table. One building, three very different jobs, each staffed for what it actually needs.

---

The three tiers at a glance

Smart Validator · The brain

What it holds: key shares, the rules engine, on-chain identity.

Signs on chain? Yes — the only tier that holds key shares and signs.

Smart Host · The BaaS runtime

What it holds: per-app sign-in sessions, database, file storage, functions, messaging.

Signs on chain? No — asks the validator over HTTP.

Smart Gateway · The front door

What it holds: a routing table; no keys.

Signs on chain? No — routes traffic only.

The dependency arrow only ever points one way: gateway → host → validator → chains. The host and the gateway hold no chain keys and sign nothing. When the host needs something done on chain, it asks the validator over HTTP.

🧠 For Normies

Each layer only knows about the layer directly beneath it. The front door doesn’t know how to sign a blockchain transaction, and it doesn’t need to — it just forwards to the layer that does. Fewer things each layer can break, fewer secrets each layer can leak.

---

How they compose

%%{init: {'flowchart':{'htmlLabels':true,'curve':'basis'}}}%%
flowchart TD
    Client([Client / browser / SDK])
    subgraph Edge["Edge tier"]
      GW["Smart Gateway<br/>routing · rate limits · host checks"]
    end
    subgraph App["Application tier"]
      H["Smart Host (BaaS)<br/>sign-in · DB · storage · functions · messaging"]
    end
    subgraph Core["Core tier"]
      V["Smart Validator<br/>consensus · threshold signing · rules"]
    end
    Chains[("Blockchains<br/>Hedera · XRPL")]

    Client -->|HTTPS by hostname| GW
    GW -->|route to the app and its host| H
    H -->|sign / verify over HTTP| V
    V -->|threshold-signed txns| Chains

The same request can pass through all three: the gateway routes a request to the right app, the app uses the host for its backend, the host asks the validator to threshold-sign a chain operation, and the validator submits it to the chain. Each hop is a clean contract, and each tier scales on its own curve.

The chains the validator signs on today:

Chain	Status
Hedera (consensus, rule publication, governance and audit topics)	Live
XRPL	Live
Stellar, Polkadot, Solana, Bitcoin	Coming next
Ethereum, Polygon (EVM)	Postponed

---

Genesis: where the cluster comes from

Before any of this serves a request, the platform has to bootstrap. Genesis creates the network’s own accounts with distributed key generation across the genesis validators, so that after genesis no single validator can sign anything alone. On the testnet, the genesis bootstrap is three clusters run by HSuite. The three tiers are the permanent architecture; three clusters is only where the network starts. That story is its own page: Genesis & lifecycle.

🧠 For Normies

“Genesis” is the platform’s first boot — the moment the network agrees on who it is and creates the shared keys nobody holds alone. Everything else assumes genesis already happened.

---

Pages in this section

Smart ValidatorThe core tier: consensus, threshold signing, rules enforcement.

Smart HostThe BaaS runtime: sign-in, database, storage, functions, messaging, metering.

Smart GatewayThe routing tier: host discovery, routing, failover, rate limiting.

Genesis & lifecycleBootstrap → steady state → membership changes & resharing.

Harbor & content-addressed imagesImage digests, the signed image manifest, and the app registry.

---

Next steps

Start with the brain: Smart Validator

Smart HostOr, if you're a developer who just wants a backend.

GlossaryNew term? Check the Glossary.

Run a nodeHow node runners will join the network.