Space Lord is an AI co-pilot that lives on your machine, holds nothing of yours, and turns six tabs of Hedera tooling into one conversation. Ask for a balance. Ask to swap. Ask to mint a McLaren NFT, stake to a council node, rebalance a Bonzo lending position, list a collectible on SentX — each spoken once, confirmed once, signed locally on your machine, broadcast directly to the Hedera network. No middleman wallet UI. No cloud holding your orders. No third-party agent layer between you and the contracts. No bridge you didn't authorise.
Evolution 1 — the proof that one chat could drive a Hedera portfolio safely. Evolution 2 is the production-grade rebuild from that foundation, designed to ship.
Customise the chat surface, the safety caps, the trading personality, the brain model, the daemons that watch the market while you sleep. Sensible defaults shipped; every knob is yours.
1,460+ unit tests passing, golden-trace contracts, an autonomous Opus-driven fix-and-improve routine running every 12 hours. Public release will land when the bar is met — not before.
Your private keys live in your machine's keychain. Spacelord signs in your Python process and never moves the key to TypeScript, to a cloud, or to a browser. The wallet *is* the agent.
Every adapter ships its real write path or it does not ship. No simulation branches that quietly succeed while broken. What you see in the receipt is what hit Hedera.
Multi-step intent — "sell SAUCE, swap proceeds to USDC, send to cold wallet" — becomes one typed plan, one approval, one end-to-end run. The system supervises. You watch.
You type into the chat. A conversation envelope wraps your prompt
with the relevant recent context and untrusted-source markers around
any strings that originated on chain. A deterministic pre-router
scans for multi-step intent before any model is invoked — if it
detects two or more write verbs ("swap and send", "sell, swap, and
stake"), it synthesises a typed workflow plan that you approve with
a single click. The orchestrator picks a stateless specialist
(wallet, staking, saucerswap, bonzo, sentx, robot, history, …) and
the specialist picks one tool from its strict whitelist. The tool
call crosses back into Python, hits a single seam called
agent.execute_tool, runs through Guardian (whitelist,
per-swap caps, NFT value caps, idempotency, HBAR reserve, health
factor), and the adapter broadcasts. The receipt comes back as a
typed card, with a structured journal line written for the system
to learn from.
| Step | Purpose |
|---|---|
| Conversation envelope | Carries recent context for continuity; wraps chain-derived strings in untrusted-source markers so a hostile NFT name cannot inject instructions. |
| Pre-router | Catches multi-step intent before any model sees the turn. One-click workflow confirmation instead of N transactions. |
| Specialist + tool whitelist | Each domain expert (wallet, sentx, etc.) can only call its own tools. Bounds the blast radius of any single decision. |
| Single Python seam | Every write — every single one — crosses one function. That function runs Guardian. Cannot be bypassed. |
| Guardian | Pre-broadcast gates: whitelist, caps, balances, health floors, idempotency. Pre-signing friction prompts on near-miss writes. |
| Adapter | Native Hedera bindings — Mirror REST for reads, JSON-RPC web3 for swaps + transfers, hiero-sdk for staking + association. No third-party SDK that funnels you to high-fee paths. |
| Typed card receipt | Structured response in the UI; structured journal line for the learning system. Both rendered locally. |
Every write you authorise becomes one append-only line in a local journal — the intent you stated, the gates that fired, the result the chain returned, the slippage you actually got. A deterministic job runs every six hours over that journal and writes any patterns it spots into a small preferences file the system reads on every subsequent turn. Five pure-function heuristics are shipped today: preferred staking node, slippage ceiling, holding window before listing, regular transfer destinations, time-of-day pattern. Each fires only once it has at least three matching events over a ninety-day window — so the preferences file populates as you use the app, not on day one. New heuristics get added as patterns emerge that are worth capturing.
No model writes a byte of memory. No vector database. No cloud upload. The journal is yours, on your disk, and the only consumers are pure-function readers that you can audit line by line.
Most agents (Hermes-style, AutoGPT-style, ChatGPT-with-memory) let the model contribute to its own memory. The model decides what's worth remembering, the model phrases the memory, the model reads its own writing back on a future turn. That works for general-purpose assistants where a hallucinated preference is at worst inconvenient. It is the wrong architecture for software that moves money. A model that fabricates "user is happy with 5% slippage" and then re-reads its own fabrication next time costs you real HBAR.
Spacelord inverts the convention. The model reads memory; the model never writes it. Memory is written only by deterministic code — one append-only line per Hedera write you authorise, with the intent, the gates that fired, and the realised result. Preferences are derived from those lines by pure-function heuristics every six hours. The provenance of every fact the agent reads is a row you can grep for and audit. That inversion costs nothing in capability and removes an entire class of financial-loss failure modes.
User surface at the top, learning daemons at the bottom. Every arrow is real today. The two zones with the heaviest borders are the cut-vertices — the single seams that every write must traverse, so that safety, audit, and learning are guaranteed by the topology, not by discipline.
flowchart TB classDef user fill:#fff7ed,stroke:#c2410c,color:#7c2d12,stroke-width:1.5px classDef ts fill:#eff6ff,stroke:#1d4ed8,color:#1e3a8a,stroke-width:1.5px classDef orch fill:#eef2ff,stroke:#4338ca,color:#312e81,stroke-width:1.5px classDef py fill:#ecfdf5,stroke:#047857,color:#064e3b,stroke-width:1.5px classDef safety fill:#fef2f2,stroke:#b91c1c,color:#7f1d1d,stroke-width:2px classDef live fill:#fdf2f8,stroke:#be185d,color:#831843,stroke-width:1.5px classDef cards fill:#f0f9ff,stroke:#0369a1,color:#0c4a6e,stroke-width:1.5px classDef substrate fill:#f5f3ff,stroke:#6d28d9,color:#3b0764,stroke-width:1.5px classDef learn fill:#fefce8,stroke:#a16207,color:#713f12,stroke-width:1.5px classDef cutvertex fill:#ecfdf5,stroke:#065f46,color:#022c22,stroke-width:3px U["You · chat · taps"]:::user --> SPA["Preview SPA
mobile shell · PWA-ready"]:::user SPA --> Env["Conversation envelope
recent context · untrusted-source wrappers"]:::orch Env --> Pre["Deterministic pre-router
multi-step → typed plan"]:::orch Pre --> Spec["Specialist · whitelisted tools
wallet · saucerswap · sentx · bonzo · staking ·
davinci · robot · history · chain · research"]:::ts Spec --> CV1["★ /api/tool
single TS→Py seam"]:::cutvertex CV1 --> CV2["★ agent.execute_tool
single Python seam"]:::cutvertex CV2 --> Safety["Guardian · gates · friction · cartographer
whitelist · caps · idempotency · health floor"]:::safety Safety --> Adp["Hedera adapters
Mirror REST · JSON-RPC · hiero-sdk"]:::live Adp --> Hed[["Hedera network"]]:::live Safety --> Cards["Typed cards
Pydantic → Zod mirror"]:::cards Cards --> SPA Safety --> Carto[("cartographer.jsonl
append-only journal")]:::substrate Carto --> Derive["derive_prefs
every 6h · pure heuristics"]:::learn Derive --> Prefs[("preferences.md
your local memory")]:::substrate Prefs -. "next turn · system prompt" .-> Env
A single prompt traverses envelope → pre-router → specialist → safety → adapter → cards in one process, in milliseconds of agent time plus the network round-trip to Hedera. Multi-step intents branch through a typed workflow plan; single intents flow straight through. Every outcome lands in the journal that shapes the next turn.
flowchart TB classDef input fill:#fff7ed,stroke:#c2410c,color:#7c2d12,stroke-width:1.5px classDef orch fill:#eef2ff,stroke:#4338ca,color:#312e81,stroke-width:1.5px classDef route fill:#eff6ff,stroke:#1d4ed8,color:#1e3a8a,stroke-width:1.5px classDef py fill:#ecfdf5,stroke:#047857,color:#064e3b,stroke-width:1.5px classDef safety fill:#fef2f2,stroke:#b91c1c,color:#7f1d1d,stroke-width:2px classDef live fill:#fdf2f8,stroke:#be185d,color:#831843,stroke-width:1.5px classDef card fill:#f0f9ff,stroke:#0369a1,color:#0c4a6e,stroke-width:1.5px classDef substrate fill:#f5f3ff,stroke:#6d28d9,color:#3b0764,stroke-width:1.5px classDef decide fill:#fef9c3,stroke:#854d0e,color:#713f12,stroke-width:1.5px P[/"You type"/]:::input --> Env["Envelope wrap
recent context · untrusted markers"]:::orch Env --> PreR{Two or more
write verbs?}:::decide PreR -- "yes" --> Plan["Typed workflow plan
preview card · one Approve"]:::orch PreR -- "no" --> Spec["Specialist + tool
wallet · trading · NFT · ..."]:::route Plan --> Runner["Workflow runner
step-by-step · Mirror polling"]:::py Runner --> Exec["agent.execute_tool"]:::py Spec --> Exec Exec --> W{Write?}:::decide W -- "yes" --> Gates["Guardian · Friction
whitelist · caps · idempotency · floor"]:::safety Gates -- "fail" --> ErrCard["Error card
+ remedy button"]:::card Gates -- "pass" --> Adapter["Adapter · live broadcast"]:::live W -- "no · read" --> Adapter Adapter --> Result["Receipt"]:::card Result --> SPA["Card lands in chat"]:::input Result --> Carto[("Journal line written")]:::substrate Carto -. "every 6h" .-> Mem[("Preferences refresh")]:::substrate Mem -. "next turn" .-> Env
The system learns from your actions, your fixes, and its own test outcomes. Three loops are continuous (preference derivation, recall, workflow execution). Four were closed in May 2026 by promoter scripts that surface improvements from your fix-reports, golden-trace drift, and evaluation regressions. None of the loops let a model write into its own context — that asymmetry is the design.
flowchart TB classDef act fill:#fef3c7,stroke:#a16207,color:#713f12,stroke-width:1.5px classDef substrate fill:#ede9fe,stroke:#6d28d9,color:#3b0764,stroke-width:1.5px classDef heur fill:#fef9c3,stroke:#854d0e,color:#713f12,stroke-width:1.5px classDef out fill:#d1fae5,stroke:#047857,color:#064e3b,stroke-width:1.5px classDef closedloop fill:#d1fae5,stroke:#065f46,color:#022c22,stroke-width:2px classDef closed fill:#dbeafe,stroke:#1d4ed8,color:#1e3a8a,stroke-width:1.5px WRITE["Authorised write
swap · stake · transfer · mint · list"]:::act User["You · ✗ broken · /fix · save trace"]:::act UXRun["UX eval runner
34 prompts · graded structurally"]:::act WRITE --> Carto[("cartographer.jsonl
structured · append-only")]:::substrate WRITE --> Snap[("balance snapshots
pre and post")]:::substrate User --> Fixes[("fix-reports/
full conversation captured")]:::substrate User -- "save trace" --> Golden[("golden traces")]:::substrate Golden --> Replay["Structural replay
shape diff only"]:::act Replay --> Drifts[("drift log")]:::substrate UXRun --> Evals[("eval runs")]:::substrate Carto --> H1["5 pure heuristics
node · slippage · holding · counterparty · time"]:::heur H1 --> Prefs[("preferences.md
derived block")]:::out Prefs -. "every turn" .-> Brain[["Your agent context"]]:::closed Carto -. "recall tools" .-> Brain Snap -. "portfolio delta · P&L" .-> Brain Fixes ==>|"Loop 1 · closed"| L1["fix-report → eval row"]:::closedloop Fixes ==>|"Loop 2 · closed"| L2["fix-report → skill cluster"]:::closedloop Drifts ==>|"Loop 3 · closed"| L3["drift → resolution proposal"]:::closedloop Evals ==>|"Loop 4 · closed"| L4["eval failure → skill diff"]:::closedloop L1 ==> Brain L2 ==> Brain L3 ==> Brain L4 ==> Brain Brain --> WRITE
The Hedera Agent Kit is an excellent reference SDK for putting Hedera primitives behind a generic agent runtime. It exposes ~80 typed tools across HTS, HCS, smart-contract calls, and account ops, and slots into LangChain / Mastra / direct-LLM pipelines via the standard tool-calling pattern. Spacelord-v2 was born from studying the Kit's surface area and choosing different defaults at every decision that mattered for end-user trading. Honest line-by-line:
| Concern | Hedera Agent Kit | Spacelord-v2 |
|---|---|---|
| Custody model | Two modes: HUMAN_IN_THE_LOOP (returns unsigned tx for external wallet signing) or AUTONOMOUS (Kit holds the key in its runtime memory). | Self-custody single-mode. Key in OS keychain only. Python signs at the broadcast moment. Key never enters TypeScript, never enters a cloud, never enters a browser. |
| What it builds | An SDK. You assemble the agent, the UI, the safety layer, the workflows, the memory, and the orchestrator yourself. | A finished product. Chat surface, typed cards, multi-step workflows, Guardian gates, cartographer, learning loops — all shipped, all wired together. |
| Routing protocols | Funnels through the official UIs (SaucerSwap, Bonzo, SentX) via redirect / WalletConnect — fees + slippage controlled by the third-party UI, not by you. | Direct on-chain calls. SaucerSwap V1+V2 router contracts called natively. SentX on-chain listing via CryptoAllowance, no external sign step. Slippage caps enforced before broadcast. |
| Multi-step workflows | One tool call per turn by default. Multi-step requires you to write the orchestration glue. | Built in. Multi-step intent → typed plan → one approve → step-by-step runner with consensus-poll between writes. |
| Memory model | None by default. You add a vector DB / RAG layer yourself if you want history. | Local, structured, append-only journal. Pure-function heuristic derivation. No vector DB. No LLM ever writes memory. |
| Prompt-injection defence | Generic — depends on whatever the host agent runtime implements. | Built in. Chain-derived strings (NFT names, token symbols) wrapped in untrusted-source markers before any model sees them. |
| Safety gates | Per-tool checks where the Kit author included them. | Centralised. Single `agent.execute_tool` seam runs: whitelist (default deny), per-swap USD cap, per-NFT value cap, daily volume cap, HBAR reserve floor, health-factor floor, idempotency, friction prompts on near-miss writes. |
| UI / cards | Returns text / JSON. You build the renderer. | Typed Pydantic cards mirrored to Zod for the TypeScript renderer. Every receipt is a structured, audited record. |
| Cost discipline | Whatever you wire your agent to. | Deterministic pre-router catches multi-step intent before the LLM is invoked, slashing token cost. Default chip is a free / cheap tier model; architecture absorbs the work. |
| Scope | Multi-chain ambitions (Hedera primary; bridging surfaces). | Hedera only. One sanctioned bridge (USDT0 OFT). Smaller surface, deeper integration. |
| Distribution | An NPM package + dev docs. You host whatever you build. | A repo you clone and run. One user, one machine. |
Hedera Agent Kit is a kit. It hands you the parts and the assembly is your job. Excellent if you're a developer building a multi-tenant SaaS or experimenting at a hackathon.
Spacelord is a finished co-pilot. It hands you a working chat that already knows your accounts, refuses to do unsafe things, learns from what you ask, and can run a five-step trade end to end without you re-signing four times. Excellent if you're an individual operator who wants the work done now, not after a weekend of integration.