SpacelordAI agent · your own Hedera wallet · you hold the keys, and the code
Everything on Hedera,
in one chat.
No app-hopping. No double-signing. Your keys, your machine.
You know the drill: six tabs, two wallets, a confirmation for every step, and a dead end when one app won't talk to the next. Spacelord replaces all of it with one chat: an AI agent that holds its own Hedera wallet and talks straight to the chain. Ask in plain English, it runs the steps with your keys, and hands you a card you can read at a glance. Most of what you ask is handled right on your machine and never reaches a paid model, so it costs you next to nothing.
It started with an annoyance, not a business plan. A job an LLM could say in three seconds, like "unlock my vested SAUCE and swap it to USDC," was costing five minutes of logins, app-hopping and double-confirmations. So I deleted the sludge. Keys on my own machine, one interface that talks straight to the chain. Everything here grew out of removing one double-tap.
See it first
Chat is the whole interface
Ask in plain English. It plans the steps, runs them on-chain with your keys, and shows the result as a card you can read at a glance, not a wall of text.
- One sentence, many steps, across Hedera and Hyperliquid
- Fixed cards for the things you do all the time
- Free-form chat only when a card won't do
- Mobile-first, opened from your phone, keys stay home
No website. No magic-link. No "sign in with." You open it on your phone, and the work just happens.
Why this, not a generic kit
Why not just point an AI at Hedera?
Fair question. You could hand a general agent, or a free toolkit, the keys to your account and let it drive. Here is what those actually do, and what we do instead. This is the part most "AI for crypto" hopes you never ask.
⇲ Direct to chain, no skim
Free kits like the Hedera Agent Kit quietly funnel you to high-fee services and route your business through third-party APIs that take a cut. Our tools go straight to the contract. Nobody in the path bills you for the privilege.
◎ Built for Hedera, not a plugin
A general "agent OS," an MCP toolbox, a chat app with a crypto skill, they are built to do anything, so they do nothing in finance especially well. Every piece of Spacelord is purpose-built for moving value on Hedera.
▤ Memory that can't lie to you
The standard pattern stuffs a vector database with old chat and lets the model treat it as fact, which is how an agent hands you an hour-old balance. We inverted it: the model reads memory, never writes it, and a balance check forces a live look.
⛒ Your keys, never a model's
The fashionable answer hands a third-party model loop, often over MCP, the power to sign. That is the exact thing we refuse. Signing stays on your machine, behind a wall of checks the model cannot skip.
⟿ Routing that gets cheaper
Generic agents send every message to an expensive model. Ours walks cheap, deterministic checks first and learns from your own use, leaning on the paid model less over time, heading toward needing none.
⬡ Web3-native, by design
It is built to discover other agents and new marketplaces directly on Hedera, the way the network is meant to work, not to route you into one company's walled garden.
Fixed cards, not walls of text
We started out building generative UI, letting the model draw a fresh interface every time. Then we realized that for almost everything in finance you want the opposite: a fixed, standardized card per job. A trade confirmation always looks like a trade confirmation. A balance looks like a balance. What you would expect to see is what you get. Chat falls back to free-form prose only when a card genuinely does not fit.
An AI you can talk to, with the reliability of an app you already know how to read.
Real autonomy, not a permission wall
We give the agent real autonomy. If it can do what you asked, it does, the whole multi-step chain end to end, no double-taps, no "accept" walls, no asking permission at every step. The only time it stops is to check it understood you, and only while you are there to answer. The hard limits are gates in the code, caps, reserves, a pause switch, not a person standing in the way. We can work this way because it is open source with no financial stake in your transactions. A company with money on the line has to shackle its agent, make it ask, make it crawl. We do not, so the agent just gets it done.
Why it exists
Take the middleman out
Ask the uncomfortable question. Why does a bank exist? Why a broker? They were built for a world that had no way to do business without a middleman in between. That need was real for centuries. It is not real any more.
The encryption and the intelligence to remove that middle layer now exist. Not to abolish the institutions. They still have real jobs, like liquidity, lending, and market-making, even backing up your keys if you choose to let them. But they do not need to sit between you and every single transaction you make. That role is finished. We are not deleting the institutions. We are moving them out of the middle.
⌁ The big exchanges are building this too
They are shipping "agents" that act for you. Theirs run on their rails, hold your keys, and route your orders through their book. In a crisis they are the ones who can lock you out, and a lot of us have been locked out before.
⎈ Ours is the opposite
The keys are yours. The code is open. Orders go straight to on-chain protocols run by reputable parties, with nobody in the middle who can stop you, freeze you, or skim you. A closed agent asks you to take a company's word. An open one lets you verify, fork, and own.
The bigger why, and why Hedera read on
This is, almost eerily, the financial super-app Elon described at X.com in 1999 and never got to build, killed by politics, not by impossibility. What is different in 2026 is that one person can now build the whole stack, because AI writes the code and a community can harden it.
Why Hedera. It is the most reliable network we have worked on, and it is about who runs it. The council is a who's-who of the largest companies on earth, and those companies do not want to be financial institutions. They want to ship packages, build planes, run AI, and get fairly paid. Their incentives line up with ours: keep the plumbing excellent, and do not sit on top of every transaction taking a cut. Three-second finality, sane fees, and the most active development team in the space.
To be clear about the neighbours, this does not replace Bitcoin. Bitcoin is the bedrock, no counterparty and no one to depend on. Hedera is for the day-to-day, your connection to the largest companies in the world and the systems they are about to build on-chain.
There is a quieter benefit too. If everyone runs their own copy, even slight variations with their own key management, there is no single honeypot. A monoculture is one breach away from disaster. A million self-custodied variations is a brutal thing to attack. Self-sovereignty is not just a values argument, it is a security one.
The brain
Chat is the product. Underneath, code you can read.
The key feature is plain. You talk, and it does the work, even when one sentence means five steps on two chains. Underneath, two design choices make that predictable and cheap. It is open source: if something breaks, we fix it, no promises made.
One sentence, a whole reasoning chain
A single request fans out into a chain of reasoning. Here it routes to your wallet, your staking, and a market read, pulls each answer, and composes one reply. No approval walls between you and the result, the agent just does the work.
The AI decides what you want. Fixed code decides how it happens.
Every action that moves money runs as fixed, pre-written code. The same path every time, never re-improvised by a model. The most common jobs are locked to known-good steps. The model's job is to understand you and pick the right tool, not to reinvent a swap on the fly and hope it gets it right. Reliability comes from being boring where it counts.
Cheap doors first, the paid model last
Most apps send every message straight to an expensive AI model. We do not. Your words walk through cheaper, faster checks first, and only reach a paid model if those cannot answer. That keeps it fast, predictable, and low-cost. There are three doors before a single AI credit is spent.
Plain pattern rules free
Simple text matching catches slash commands and obvious requests instantly. No model involved.
Deeper matching free
More precise logic maps your words to a known action and turns it into a typed plan, including multi-step jobs like "unlock and swap and send."
A small on-device learner free
A lightweight AI compares your request to everything you have asked before. Every request and workflow it sees becomes training data. Over time this grows into our own small routing model, so we lean on the big paid model less and less. It is infrastructure that gets more valuable the more the app is used.
Only now, the language model uses credits
If all three doors miss, a capable model reads the request and routes it to the right specialist. Each specialist owns a tiny fixed toolset, so a wallet helper cannot place a trade and a trade helper cannot move money out. That whitelist is the blast radius.
Under the hood: the routing flywheel, in detail technical
The first two doors are a deterministic dispatch (tiers one and two): regex plus a Python matcher that rewrites natural language into a single specialist call. Door three is an embedding classifier we have validated against the live system. It already beats the current approach across the confidence range, and it is being wired in behind a confidence gate, with the deterministic "this is a write" checks always kept in front of it. The target model for that learner is a small open Gemma embedding model.
Door four is the language orchestrator (today Gemma 4 31B, reached through OpenRouter so we can switch models mid-task to balance cost and quality). It is deliberately model-agnostic. You can point it at a different model, and the roadmap is to let you run a local or proprietary model directly, with any-model connection kept open for research or heavier building.
Every turn records which door answered and which route it took. A bank of thousands of test prompts is replayed each session to score accuracy, currently 94.6% across 2,837 cases. Wrong routes get flagged and the patterns get sharpened. The requests we see are also the fuel that trains the in-house router. This is the part that quietly compounds: the more it is used, the cheaper and sharper it gets, and the less it needs anyone else's model.
flowchart LR
%%DARK%%
P[/"Your words"/]:::user
D1{Pattern rules}:::decide
D2{Deeper match}:::decide
D3{On-device learner}:::decide
D4["Language model
picks a specialist"]:::orch
Spec["Specialist
tiny fixed toolset"]:::ts
Exec["Single write seam"]:::cut
Gates["The gates
caps · reserves · pause"]:::safety
Live["Live network"]:::live
Card["Result you can read + tap"]:::card
P --> D1
D1 -- "miss" --> D2
D1 -- "hit · free" --> Spec
D2 -- "miss" --> D3
D2 -- "hit · free" --> Spec
D3 -- "miss" --> D4
D3 -- "confident · free" --> Spec
D4 -- "uses credits" --> Spec
Spec --> Exec --> Gates --> Live --> Card
D3 -. "every request becomes training data" .-> D3
How writes are gated
It reads the chain. It never remembers it.
A normal AI assistant is built to remember everything and build on it. An assistant that handles your money is the opposite. It can't lean on its own memory; it has to go and look. That flip is the spine of the whole design.
The stale-balance lesson
Early on, asked for a balance, the agent would sometimes get lazy and answer from its own chat memory, handing back an hour-old number as if it were live. For software that moves money, that is a disaster, and it is not a wording problem, it is a design problem. So we flipped the rule. The model reads memory. The model never writes it. Memory is written only by plain code, kept append-only, and split into two lanes that never bleed: your local history ("did I already swap this? what did I pay last time?"), and live chain truth ("what is actually on-chain right now?"). A balance check forces the tool to run. It can never quietly serve you yesterday's number as today's.
This is also why we left OpenClaw
We did not start from scratch. The first build rode on OpenClaw, an off-the-shelf agent, talked to over Telegram. It worked well enough that we entered it in the 2026 Hedera Apex Hackathon and won the AI Agents track, even though OpenClaw never really fit the job. Daily use showed why it didn't. Its whole architecture is built for knowledge work, to fill its context from memory and lean on it, which is exactly how it once handed us that hour-old balance as if it were live. And Telegram couldn't show the work: money deserves a clean card, not a wall of text, and our commands kept colliding with the agent's own built-ins. It was fundamentally unsuited, so we built our own layer. If OpenClaw ever shifts toward a cleaner framework, we would happily move back toward cross-compatibility. For now we carved our own path, with blinders on, because nobody was building what we wanted.
The machine is assembled from the best parts of well-known open source: Mastra for orchestration, the Hedera Agent Kit and Hermes for mechanics we could borrow. But every piece of the agent layer was purpose-built for this one job, moving value from a chat. We have not found a replica of it anywhere. That is the honest claim, and we think it holds: this part is genuinely new.
The guardian layer, in detail technical
Before any write goes out, a set of gates run: an allow-list of what can be called, a check that the same action cannot fire twice, ceilings on swap and NFT size, a floor that holds back a reserve of HBAR, a lending health-factor floor, and a global pause switch. Tests are written for this layer first, so the gate code is not allowed to rot.
Every write also appends one line to a local journal: what you asked, what the checks said, what was broadcast, and how the result compared to the quote. That journal is both the audit trail and the learning substrate. After a trade settles, what you got is compared to what you were quoted, and any slippage shows up as a card, not a silent surprise.
Hedera, and getting data fast
Talking straight to the network
Hedera is home base and the deepest integration. The pieces are chosen so they work for every kind of account, with nobody else in the loop.
⇆ Transfers that work for everyone
All transfers, both HBAR and tokens, use Hedera's native layer, so they work for every account type, not just fancy ones. The plumbing is the same whether your account is old or new.
◎ How it reads the chain today
Account and market data come from Hedera's Mirror Node, the free public endpoints, and can be routed through Hgraph for more speed and higher limits. Before any swap it asks the network for a real quote first.
Under the chat sits a real spread of work: a swap engine, self-custodial limit orders, a lending desk, an NFT marketplace and an atomic on-chain swap rail, native staking, and a Bitcoin-rebalancing robot that keeps working while you sleep. Each one carries its own live status light.
Algorithmic trading, as a consumer
Register an always-on strategy, a rebalancer, a power-law model, a set of limit orders, and the daemon works it around the clock, through the same gates as the chat. Your own trading bot, no desk and no fund behind you, on Hedera or Hyperliquid.
The Bitcoin power-law rebalancer runs live today; user-defined strategies are that same path, opened up.
A real NFT marketplace, and your NFTs as art
Browse a collection's live listings, prices, ranks and all, and make atomic on-chain offers, right inside the chat. Your own collectibles render full and beautiful, like this on-chain McLaren mint.
Why our limit orders stay on SaucerSwap V2, not V3 a deliberate call
SaucerSwap V3 added a central order book, which is genuinely useful, and we support it as its own opt-in app. But we keep the default limit orders on V2 on purpose, and it comes down to sovereignty.
- V3's order book makes you log in. Even just browsing the markets needs an authenticated token from an external service. That is exactly the middleman we are removing.
- V3 needs orders signed off-chain and handed to an external system, instead of a plain on-chain transaction you can verify end to end.
- V3 only works from one specific account type, which locks out the most common Hedera accounts entirely.
V2 limit orders are self-custodial, settle on-chain, need no outside login, and work for every account type. That is the trade we will make by default, every time: universality and ownership over the extra features of someone else's book.
More chains
Started on Hedera, branched to Hyperliquid
Hyperliquid is a second home for fast market access, added deliberately. The clever part is how you get there.
A full perps desk, in the same app
Live order book, candles, depth, positions and fills, place and cancel orders, set leverage. The market access of a serious exchange, with none of the custody. Your keys still sign on your machine.
Your own Hedera keys are your passport across chains
You do not whitelist a wallet, hand an exchange your address, or wait on an approval to go cross-chain. Spacelord uses the keys it already holds on your machine to manage a clean second-chain wallet for you, and moves value across with one sanctioned bridge. One identity, your keys, no permission slip. Signing still happens on your machine. The Hyperliquid side only ever reads until a write crosses back through the gates, and money-out gets the strictest check of all.
How it builds, and fixes itself
An app that improves while you sleep
AI runs the build loop. The same kind of model you are chatting with reviews the code, fixes the bugs the app files against itself, and ships enhancements, all behind a wall of automatic checks.
It works while you are away
The daemons keep running, watching, rebalancing, and your agent leaves notes on the home screen: a drift sweep that fired, a health check that passed, an offer on your NFT. You glance, and you are caught up.
⊗ It catches its own bugs
When a tool fails in a way the system recognises, it files its own ticket. No report needed. You can also flag any bad result in one tap, which saves the whole conversation as a test the next round never reopens.
▦ It freezes what works
A workflow that works can be saved as a recording. Before every change, those recordings are replayed and compared. If behaviour drifts, the change is held until it is sorted. Good behaviour stays good.
How a fix actually lands
AI reads the day's tickets, writes the fix, and runs it against every check. Each evening a mechanical janitor sweeps the result: clean, gate-passing work ships, anything risky or conflicted is parked for a person. Small stuff lands on its own. Big stuff waits for a human.
How it teaches itself, in detail technical
Everything the system learns stays local, append-only, and on your machine. The model never writes a byte of it. Plain code turns your history into a small preferences note the brain reads each turn, a recall path pulls a few facts from your journal only when a question is about the past, and approved multi-step plans feed their results back in.
flowchart TB
%%DARK%%
WRITE["You do something on-chain"]:::act
Carto[("local journal
append-only")]:::sub
Snap[("balance snapshots")]:::sub
Fixes[("your bug reports")]:::sub
Heur["plain heuristics"]:::heur
Prefs[("your preferences note")]:::sub
Brain[["the brain, next turn"]]:::closed
Fix1["bug → a test"]:::loop
WRITE --> Carto
WRITE --> Snap
Carto --> Heur --> Prefs
Prefs -. "read every turn" .-> Brain
Carto -. "recall on demand" .-> Brain
Fixes ==> Fix1 ==> Brain
Brain --> WRITE
The whole shape, one picture technical
Eight zones, one process on your machine. The two starred boxes are the only places a write can pass through, so the gates can never be skipped, not by chat, not by a daemon, not by a slash command.
flowchart TB %%DARK%% U["You · chat · taps"]:::user --> SPA["The app
mobile shell"]:::user SPA --> Brain["The brain
cheap doors first"]:::orch Brain --> Spec["Specialists
tiny fixed toolsets"]:::ts Spec --> Seam1["★ one app seam"]:::cut Seam1 --> Seam2["★ one write seam"]:::cut Seam2 --> Guard["The gates
caps · reserves · pause"]:::safety Guard --> Adp["Hedera + Hyperliquid
your keys, your signatures"]:::live Adp --> Net[["the networks"]]:::live Guard --> Cards["Typed cards
read + tap"]:::card --> SPA Guard --> Log[("local journal")]:::sub Log --> Learn["learning, on your machine"]:::learn Learn -. "your preferences" .-> Brain Net -. "result" .-> Guard
Straight talk
What we depend on, and what we refuse
We still touch a few outside things. Two we genuinely rely on today; the rest are nice-to-haves you can skip. All of it is friction we want gone, not features we are proud of.
The two we actually rely on
| What | Why it's there | The honest catch |
|---|---|---|
| Tailscale | The always-on private link between your phone and the machine that holds your keys. This is the one piece that makes "just open it on your phone" work without exposing anything to the public internet. | An account on your own devices. No public website, no opening your home network, your keys never leave home. The most important dependency, and the one we are happiest to have. |
| OpenRouter | Routes the chat brain to a model, and lets us switch models mid-task for cost and quality. | It needs a key and it is an outside party in the brain's path. In time we will not even need it: the plan is to run a local or our own model directly, with any model you choose still free to connect. |
Nice-to-haves you can skip
| What | Why it's there | The honest catch |
|---|---|---|
| SentX key | Richer NFT-marketplace data and listings. | You have to register on the SentX site and paste in a key. Exactly the manual chore a plug-and-play app should not ask of you, so we flag it and lean on on-chain data where we can. The app runs fine without it. |
| WalletConnect / Reown id | A backup way for the app to sign for an outside dApp when something cannot be done in-app. | One free, one-time paste, and a backup only, never how you actually use the app. Off by default. |
| Hgraph | An optional fast lane for chain data, with higher rate limits. | Without it the free public Mirror Node still works, just slower. A nice-to-have, never a requirement. |
The lines we will not cross
- No custodian. We never hold your keys or your orders.
- No closed core. Anyone can read it, scan it, and run it.
- No whitelisting a wallet to go cross-chain. Your own keys are the passport.
- No fake transactions. Live only. If it cannot really happen, it fails loudly.
- No memory poisoning. The model reads memory, it never writes it.
- No hidden AI bill. Cheap doors first, the paid model only when needed.
Where this goes
The bigger picture
It is a proof of concept and a work in progress, and it will be for a while. It is the work of one person who got fed up with a double-tap and kept pulling the thread.
⌖ Your own models
Move off outside model routing toward local and proprietary models you run yourself, with any-model connection kept open for research and heavier building.
⬡ More chains
Your top few chains, each fully supported for bridging and trading, each added as a clean self-contained pillar.
⟁ A community flywheel
Feedback posted on-chain, an evening loop that actions it, contributors who harden it, and a product that keeps getting better at what people use.
The foundation stays open, so anyone can read it, fork it, and take back control of how they live online. Some specialised workflows may one day be paid, by subscription or one-off, but the core stays open. We never used to live in a world where you had to log into a third party just to exist. That is not the world we want. We want one where people can be people, and part of that is the plain freedom to transact with each other directly.