Deep dive
Your AI conversations should belong to you.
Sticks for next time.
NODE NEO
nodeneo.ai
The 30-second version
Most AI today runs through a small handful of large companies. You sign up with your email or phone, they tie your conversations to your account, they store everything on their servers, and — depending on the policy of the moment — some of what you said becomes training material for the next model. Their account, their rules, their copy of your conversation.
Node Neo is a different shape. There's no account. There's no central server holding a copy of your prompts. The AI runs on a public network of independent providers. Instead of buying a monthly subscription, you hold a small amount of a crypto token called MOR — you lock a tiny piece of it to start each chat session, and that piece is returned to your wallet when the session ends. The same MOR funds session after session, indefinitely. Your conversation history lives, encrypted, on your own device.
No account
You don't sign up. There's no email, no phone number, no profile. Your wallet (created on first launch) is your only identity, and it lives in your phone's secure enclave. Nothing for us to suspend, ban, or hand over.
Nothing in the middle
When you send a prompt, it goes from the app, through the Morpheus protocol, to a provider that bid for your session. We don't operate a server in that path. We can't read your conversation; the protocol can't either.
Stake, don't subscribe
"Stake" means lock, not loan and not spend. To start a session you lock a small amount of MOR — a "right-to-use" token. When the session ends, that lock releases and the MOR returns to your wallet, available for the next session. The same MOR funds chat after chat, indefinitely. A typical session locks just cents. Think of it as a library card on the Morpheus network — in your wallet forever, lets you check out as many sessions as you want.
Your history is local
Conversations are stored on the device, encrypted with a key derived from your wallet. Nobody — including us — can read your chat history without that wallet. Backup is a single file you export when you want.
Switch providers any time
If a provider misbehaves, gets slow, or you just don't trust them, close the session and open a new one with someone else. There is no single throat to choke — which is also the whole point. Sensitive prompt? Filter to MAX Privacy (TEE) mode and your prompt only routes to providers running their model inside hardware that can't read what you sent.
Read this before you do anything else: your wallet is yours alone.
- Lose the private key → funds gone, forever. No "forgot password," no support team, no recovery. Not us, not Apple, not Vitalik himself.
- Back it up on day one. Settings → Wallet → Export. Save to paper and an encrypted password manager (1Password, Bitwarden).
- Treat it like a bank password, stricter. Don't screenshot to your camera roll. Don't email it. Don't paste it into ChatGPT.
Why is there no recovery?
The trade-off — nobody can suspend your account, freeze your funds, or read your prompts — only works because nobody, including us, holds your key for you. That's the deal: total control, total responsibility.
First time? Try this model.
Node Neo will show you a long list of models when you start a chat — names like
GLM-4.6, Qwen3-Coder, Llama-3.3,
DeepSeek-V3. Some are tuned for code, some for reasoning, some for chat.
We're working on plain-language labels in the app to make this less intimidating.
For your first session, just pick GLM-4.6. It's a balanced general-purpose model from Z.ai that handles most everyday questions well — a good "kick the tires" choice. Once you're comfortable, browse the others and switch any time. Each new session can use a different model; nothing is locked in.
The Signal moment, again
In 2014, almost nobody had Signal. iMessage was “encrypted enough.” SMS was just what you used. Then Snowden, then the Apple-vs-FBI fight, then a cascade of breaches that made everyone realize their entire texting history was a few subpoenas away from being printed in a courtroom. Today Signal has hundreds of millions of users. Not because it's prettier than iMessage — it isn't — but because once you understood what was at stake, you couldn't go back.
We think the same shift is starting with AI. The first wave of users won't care that their ChatGPT history is sitting on OpenAI servers. The second wave will, and they'll want somewhere else to go. Node Neo is somewhere else to go.
If you wouldn't email it to your boss, you probably shouldn't be sending it to a centralized AI either.
The architecture, in one paragraph
Node Neo is a Flutter UI on top of an embedded Go module — specifically the
proxy-router/mobile
SDK from the upstream Morpheus consumer-node project. The SDK is compiled as a c-shared
library and called via dart:ffi on the same process. There is no
separate proxy-router daemon, no HTTP hop, and no Node Neo-operated server in the
consumer hot path. Wallet, chain RPC, model browsing, session open/close, and
prompt streaming all run inside the user's app, talking to two things: a Base RPC node
and the provider that bid for the session.
- Chain: Base mainnet, chain ID
8453. Multi-endpoint round-robin across public RPCs (Base public, publicnode, drpc.org, blockpi, plus an optional build-time premium RPC). - Wallet: a single hex private key. Generated locally on first launch, stored in the platform secure enclave (iOS Keychain / Android Keystore / macOS Keychain). No mnemonic UI — the legacy mnemonic vault auto-migrates to PK on cold start, then is wiped.
- Local store: SQLite per-wallet (database path is
nodeneo_{fp}.dbwherefpis a fingerprint of the wallet). All message content is AES-256-GCM encrypted with a key derived asSHA-256(privateKey). Backups are signed encrypted.nnbakarchives. - Source: Node Neo is MIT, on github.com/absgrafx/nodeneo. The Morpheus consumer node and contracts live under github.com/MorpheusAIs.
How a session works on-chain
The whole protocol turns on a Diamond contract on Base
(0x6aBE…030a).
Two facets do the heavy lifting:
SessionRouter
and
ProviderRegistry.
The token is plain ERC-20 MOR
(0x7431…b8e3).
The numbers below are read from the contracts.
Open: a stake, not a fee
openSession(amount, …) calls safeTransferFrom(user, diamond, amount)
— your MOR is moved into escrow inside the Diamond, not paid to the provider. The
amount is collateral that buys a stipend via:
stipend = (amount × computeBalance) / (totalMORSupply × 100)
The stipend then pays the provider at pricePerSecond (set by the provider's
bid) for as long as the math holds, up to a network-wide max session duration. Minimum
session length is 5 minutes
(MIN_SESSION_DURATION).
The pre-session confirmation modal in Node Neo shows you the exact MOR stake required
before you confirm; nothing happens silently.
Close at expiry: the entire stake comes back, in one transaction
The contract checks one boolean on close: isClosingLate = closedAt >= endsAt.
If close happens at or after the planned end of the session, that flag is true and
_rewardUserAfterClose takes the simple path:
- No on-hold entry pushed.
userStakeToLock_ = 0. - The entire stake is transferred back to the user immediately
via
IERC20.safeTransfer(user, stake). - The provider is paid
(endsAt - openedAt) × pricePerSecondfrom the centralfundingAccount(in the default indirect-payment mode).
This is true whether you actively close the session at the moment it expires, you let it sit expired-but-unclosed for a week and close it then, or you simply leave Node Neo running. Same result every time: full stake back in one transaction, zero cooldown.
Node Neo doesn't actually require you to remember any of this.
The embedded SDK runs a session-maintenance loop on a 15-minute ticker
(DefaultMaintenanceInterval = 15 * time.Minute in
proxy-router/mobile/sdk_maintenance.go)
that paginates through your unclosed sessions on-chain, finds any whose
endsAt has passed, and submits closeSession for each
of them automatically. The home screen still surfaces
expiredUnclosedCount as a backstop in case the app hasn't been
launched for a while, but for any user who opens the app at least once a quarter,
expired sessions effectively close themselves and the stake reappears in the
wallet without a second thought.
Close early: a proportional slice is held for up to 24 hours
If you close before the planned endsAt — you opened a
10-minute session and bailed at minute 5 because you were done —
isClosingLate is false and the contract takes a different branch:
- It computes
userInitialLock = (closedAt - openedAt) × pricePerSecond— the MOR-stipend value of the time you actually used during the closing day. - It converts that back to a stake amount via
stipendToStake(userInitialLock). - That stake amount is pushed onto
userStakesOnHoldwith an unlock timestamp ofstartOfTheDay(closedAt) + 1 day. - The remainder (
stake − locked) is transferred back to your wallet immediately, in the same transaction.
For a normal same-day chat session, the math collapses to a simple proportion: the locked fraction equals the fraction of planned time you actually used. Concrete example, indirect payment mode:
- You stake 1 MOR for a planned 10-minute session.
- You close it at minute 5 (early close, 50% used).
- ~0.5 MOR is returned to your wallet immediately in the
closeSessiontransaction. - ~0.5 MOR is locked until
startOfTheDay(closedAt) + 1 dayand shows up under on-hold in Node Neo's home screen and the "Where's My MOR?" scan. - Once unlocked, you call
withdrawUserStakes(address, 1)(selector0xa98a7c6b) to pull it into your wallet.
The cooldown clock is 0–24 hours, not 24–48. Because the unlock timestamp is anchored to the start of the day you closed in, closing at 11:55pm UTC unlocks ~5 minutes later, while closing at 12:05am UTC unlocks ~23h 55m later. The maximum you ever wait is one full day from the close time.
Why the early-close lock exists
The stipend that funds the provider is sliced from a daily emission window. Without the lock, a user could open and immediately close a session, harvesting the day's stipend slice without doing the corresponding work. The 1-day-from-day-start lock makes that economically pointless without penalising users who simply let their session run out and close honestly.
That's why the Node Neo home screen splits MOR into three buckets: wallet balance (spendable now), active stake (locked in currently-open sessions, returns on close), on-hold (locked from an early close, claimable after the day rolls over). For users who only ever close at expiry, the on-hold bucket stays at zero indefinitely.
Provider side: stake = earning cap
A provider registers via ProviderRegistry with a MOR stake. From
ProviderStorage.sol:
PROVIDER_REWARD_LIMITER_PERIOD = 365 days. On every payout the contract
enforces:
providerClaimLimit = provider.stake − provider.limitPeriodEarned
In plain English: a provider can earn at most their stake amount in MOR per
rolling year. Stake 100 MOR → headroom to earn up to 100 MOR before the
limiter resets at limitPeriodEnd. Want to earn more? Stake more. The
limiter is enforced before the transfer regardless of whether the session is funded
from the central pool (the default) or directly from the user's stake (the rare
isDirectPaymentFromUser branch) — both paths go through
_claimForProvider which subtracts from the same providerClaimLimit_.
Token supply, emission curve, and the L1 distribution contract that funds the
computeBalance term are out of scope for this page — for the
canonical numbers see mor.org.
TEE attestation, in plain technical language
"MAX Privacy" mode in Node Neo restricts the bid set to providers whose model is
running inside a Trusted Execution Environment — an Intel TDX
or AMD SEV-SNP enclave on the provider's hardware. The provider's chip generates a
cryptographic attestation that the running image matches a known good build, and the
attestation is verified through Sigstore
against the Morpheus secure-build pipeline. (The Sigstore TUF cache is configured to
live in the app's writable data dir — see
attestation_config.go
for the iOS-sandbox-friendly path.)
What this gives you: the model operator cannot read your prompt — the chip prevents it by hardware design. Your conversation runs entirely inside the enclave; not even the machine's own root user can pull it out.
What this doesn't give you: a guarantee that the model you asked for is the model you got. TEE attestation proves the running image is the published image; it doesn't, by itself, prove that a malicious provider didn't substitute a different attested image. For the threat model, the trust assumptions, and the chip-level details, see tech.mor.org/tee.html.
Verify it yourself
Diamond
The protocol entry point. Holds
SessionRouter and ProviderRegistry facets.
MOR token
ERC-20 on Base. Approve the Diamond, open sessions, withdraw on-hold — standard token surface.
SessionRouter
The facet implementing
openSession, closeSession, the stipend math,
and the user / provider on-hold mechanics quoted above.
SessionRouter.sol
ProviderRegistry
Provider stake, bids, the 365-day reward limiter constant.
ProviderRegistry.sol ·
ProviderStorage.sol
proxy-router SDK
The Go module Node Neo embeds.
sdk_chat.go, sdk_sessions.go,
sdk_wallet.go, redact.go, attestation_config.go.
proxy-router/mobile
Node Neo
App source (Flutter UI + Go FFI bridge + gateway + MCP server). MIT, builds reproducible from CI.
github.com/absgrafx/nodeneo
Marketplace API
A hosted REST mirror of the same protocol — useful for ops tooling and parity checks. Not in Node Neo's hot path.
api.mor.org ·
apidocs.mor.org
Tech docs
Compute-provider setup, TEE deep dive, network parameters.
tech.mor.org ·
tee.html
Network
The Morpheus front door — tokenomics, governance, ecosystem.
mor.org ·
app.mor.org
What's the catch?
Four honest ones. We'd rather you read these here than discover them yourself and feel sold to.
1. The biggest centralized models are still bigger.
GPT-5, Claude Opus, Gemini Ultra — these are at the frontier of what's possible. Models on the Morpheus network are usually a generation or two behind on raw benchmark scores. If you're chasing the absolute best leaderboard performance regardless of what you're paying with, those are the right tools. We use them too, sometimes; we just don't use them for everything anymore.
2. You have to handle a wallet.
If you've never touched crypto, the first ten minutes feel weird. You'll create a wallet, save a private key, buy a few dollars of ETH on Base, swap some for MOR. We wrote a calm, plain-language walkthrough for first-time users — New to crypto? Start here. — that defangs the fear and gets you from zero to funded in about 25 minutes. An in-app fiat-to-MOR onramp and a starter coupon are on the roadmap to remove this entirely — but the wallet itself isn't going away. That's by design. Nobody can suspend an account that doesn't exist.
3. Non-TEE providers run their model on regular hardware.
On a normal session, the provider serving your model can technically log your prompt on their own server. The protocol doesn't prevent it. What the protocol does prevent is anyone between you and the provider seeing it — no Morpheus-operated relay, no Node Neo server, no central inbox. For prompts where that's not enough, flip on MAX Privacy (TEE) and the bid set is restricted to providers running inside hardware that can't read your prompt by chip design.
4. Pseudonymous, not anonymous.
Your wallet address is a pseudonym; it isn't tied to an email or phone number. But
it is tied to every session you open: the fact that wallet
0x… opened a session with this provider, on this model,
for this much MOR, for this duration, is on Base mainnet and public.
Prompt content is never on-chain. But analysis of the metadata can,
in principle, link a wallet to a person if that wallet is also used in identifiable
ways elsewhere. Standard wallet-hygiene rules apply — use a fresh wallet for
Node Neo if that matters to you.
Side-by-side: centralized AI vs Node Neo + Morpheus
Ten honest rows. Some of these matter to you, some don't. Read for the ones that do.
| Centralized AI | Node Neo + Morpheus | |
|---|---|---|
| Identity | Email, phone, sometimes a credit card. The account is the unit of access and enforcement. | A wallet generated locally on first launch. No signup, no email, nothing for us to suspend. |
| Conversation logs | Stored, indexed, and retained on the vendor's servers, indexed against your account. | Encrypted on your device with a wallet-derived key. Nothing centrally retained. |
| Model choice | One vendor decides which models you get to use, and for how long. | Browse every model active on the network. Switch any time. New models register on-chain. |
| Cost model | $20/mo (or much more), whether you use it or not. Tier upgrades for "more usage." | One-time MOR acquisition. Each session locks a tiny piece as right-to-use stake and releases it on close — the same MOR funds chat after chat, indefinitely. No subscription. (do the math.) |
| Training-data policy | "We don't train on your data" — trust us. Policy can change at any time. | No central operator that could train on your data. With MAX Privacy, the provider can't read your prompt either. |
| Refusal / censorship | Centrally tuned refusal policy. Legitimate questions sometimes get blocked. | Per-model. Pick a provider whose model behavior you like; switch when you don't. |
| Account suspension | Suspended, region-blocked, or rate-limited at any time. Recourse is a help-desk ticket. | There is no account. Wallet-based access; nothing to suspend. |
| Jurisdiction / breach surface | One company's data jurisdiction. Subpoena-able. Breachable. Employee-browsable. | No central operator. Your history is encrypted on-device with a key only your wallet derives. |
| Verification | Closed weights, closed inference, closed pipeline. You trust the brand. | Open-source SDK and contracts; on-chain session metadata anyone can audit; optional hardware-attested execution. |
| Open source | Closed app, closed weights for the flagship models, closed server. | Node Neo: MIT. Protocol: MorpheusAIs. Contracts: on Base, verifiable. |
Who this is for
Node Neo isn't trying to be everyone's AI. It's for people who've decided that who owns the conversation matters more than who has the highest leaderboard score. That includes:
- People who use AI for medical, legal, financial, or relationship questions and would rather not have a permanent record on a corporate server.
- Builders who don't want their proprietary prompts and unreleased code being “not used for training” on a trust-us basis.
- Anyone who's read a privacy policy and didn't love what they saw.
- Crypto-native folks who want a real product, not another DeFi-shaped UX.
- People who, on principle, believe their AI should work for them — not for the company.
If that's you, you'll get it. If it's not you yet, that's fine — bookmark this page and come back the next time a privacy story makes you flinch.