daimon (Gk.): the inner voice — taught to you by what you've lived through — that whispers what to do.

Daimon is the on-chain version. An AI trading agent that learns your style by conversation, executes privately, and is itself a transferable asset.

---

The pitch in 60 seconds

AI agents today live in one of two unsatisfying places:

• On someone else's server (ChatGPT, Replika, character.ai) — you don't own the memory, you can't move it, you can't sell it.
• Local to your machine — private, but not portable, not shareable, not provable, not a real product.

The whole category is stuck because AI agents have no property semantics. You can't sell one. You can't lease one. You can't will one to your kid.

Daimon fixes that. You train one. You own it. You pass it on.

The demo moment: "I trained my daimon for six weeks. I just sold it for 2 ETH."

---

What you do, in five rooms

Room	What happens
/spawn	Connect a wallet. Name your daimon. It hatches into one of eight species.
/train	Tell it about you. Every message becomes encrypted memory.
/brain	See exactly what it knows. Every memory has an on-chain access log.
/act	It reads the market, recalls what you taught it, proposes a trade. You approve. Settles privately.
/market	Sell your daimon. Or rent its brain for 30 days. Capabilities are on-chain.

---

Why this had to ship now

Two primitives had to exist first:

1. Memory you actually own. A real encrypted-iNFT memory layer (ERC-7857), with TEE-attested inference and an on-chain access log.
2. Actions that don't leak. A real MEV-resistant intent solver, with ECIES-encrypted intents and TEE-attested execution.

Both shipped to 0G's APAC hackathon. Daimon is what becomes possible when you compose them.

---

Live

Surface	Where
Web app	http://localhost:3000 (run locally — production deploy in progress)
BFF health	http://localhost:3001/api/health
Daimon marketplace (Galileo)	0xb9D4…F807

---

Run it locally (4 commands)

git clone … && cd daimon
npm install
# fill in contracts/.env, bff/.env, web/.env.local from the .env.example files
npm run dev:bff    # http://localhost:3001
npm run dev:web    # http://localhost:3000

Smoke-test the live stack end-to-end:

npm run smoke

Sample output:

✓ BFF /api/health           — operator key OK, marketplace OK
✓ BFF /api/market           — ETH/USD = $2,269.13
✓ SealedMind SIWE login     — session minted
✓ POST /v1/minds            — Mind created
✓ POST /v1/minds/:id/remember
✓ POST /v1/minds/:id/recall
✓ BFF /api/propose-trade    — TEE responded:
    "I would wait for a red day to DCA according to my owner's preference."
✓ BFF /api/marketplace/listings — fee 250 bps

That last line is the magic: a real LLM, inside a real Intel TDX enclave, quoting a real memory the user crystallized 30 seconds earlier — through six layers of encrypted infrastructure, in a single human-readable sentence.

---

What's actually new in Daimon

The novel parts — what we wrote, what we deployed:

Layer	Where
/spawn /train /brain /act /market consumer dApp	web/ (Next.js 14, wagmi, RainbowKit, Tailwind, ~1.5k LOC)
Thin BFF orchestrating market data + TEE proposals + VeilSolver execution	bff/ (Express + TypeScript, ~400 LOC)
FamiliarMarketplace.sol — SALE/RENT listings, fee routing, events	contracts/ (~210 LOC Solidity)
Local profile cache + 8-species deterministic picker	web/src/lib/familiar.ts, web/src/lib/species.ts
Rented event "inbox" — seller signs grantCapability + mirrors to SealedMind	web/src/app/market/grants/page.tsx
Daimon brand kit (mark, wordmark, banner, favicons)	marketing/brand/

The two-step rental flow (renter pays on-chain → seller's wallet signs grantCapability from the inbox → BFF mirrors into the SealedMind backend) is the integration's hardest UX problem, solved.

Note on internal names. Files, package scopes (@familiar/shared), and the marketplace contract (FamiliarMarketplace.sol) keep the original familiar namespace. The brand-facing rename to Daimon is a UX choice; the internal identifiers are stable because the deployed contract addresses can't be re-emitted under a new name.

---

Built on partner primitives

Daimon is not a re-implementation of memory and execution. It's a consumer surface on two primitives that shipped alongside it:

SealedMind — memory you own

• ERC-7857 iNFTs (one per wallet) on 0G Galileo
• AES-256-GCM under wallet-derived keys; TEE-attested LLM inference (Qwen 2.5 7B in Intel TDX)
• On-chain CapabilityRegistry for time-bound sharing
• On-chain MemoryAccessLog for every read/write
• Used via @sealedmind/sdk

VeilSolver — execution that doesn't leak

• ECIES-encrypted intents → TEE plan (GLM-5-FP8 in Intel TDX + H100)
• ECDSA-signed plans verified on-chain via ecrecover
• executedIntents mapping for replay protection
• minAmountOut enforced by the contract (MEV bounded by Solidity, not policy)
• Used via veilsolver-sdk

We didn't build a project. We built a stack. SealedMind ships the memory primitive. VeilSolver ships the execution primitive. Daimon shows what they unlock together.

---

Deployed addresses (0G Galileo testnet · chainId 16602)

Contract	Address
FamiliarMarketplace (Daimon marketplace)	0xb9D42824955b492BE4cBf13988C3d0Ad9985F807
SealedMindNFT	0x741BbE3B2d19E1aE965467280Cc2a442F3632Ee7
CapabilityRegistry	0xf6b33aDa9dd4998E71FA070C1618C8a52A44Ec66
MemoryAccessLog	0xB085F48c98E8878ACA88460B37653cC8d2E24482
VeilSolver	0x4181c06901Ee172cc169fFDf44c6C192c22265aF
Mock USDC	0xDb799A80BC1eC3688F84002Fb900B590F516f1CE
Mock WETH	0x51addE398737830C2Ee2C32aF35C6C4f5e2a6180

Explorer: https://chainscan-galileo.0g.ai

---

Monorepo layout

daimon/   (folder still on disk as `familiar/`)
├── contracts/   Hardhat — FamiliarMarketplace.sol, tests, deploy script
├── bff/         Express — market data, TEE chat, VeilSolver bridge, capability mirror
├── web/         Next.js 14 — the consumer dApp (spawn / train / brain / act / market)
├── shared/      Cross-package types + chain constants
├── scripts/     E2E smoke test, brand renderer
└── marketing/   Pitch deck, twitter rollout, demo recording guide, brand kit

Everything is env-driven (.env.example in each package). Zero hardcoded keys, addresses, or URLs.

---

What's intentionally v1

• iNFT SALE is recorded on-chain + payment is routed, but the brain isn't auto-re-keyed. Threshold re-encryption is the v2 fix. Today, you list, payment goes through, the marketplace emits SaleRecorded — and the seller separately submits SealedMindNFT.transfer(...) once the v2 mechanism lands.
• RENT works fully today. Renter pays → seller's inbox shows the pending rental → seller signs CapabilityRegistry.grantCapability(...) → BFF mirrors into SealedMind. The renter can sm.recall the seller's mind for the rental window; the cap is revocable any time.

---

Roadmap

• v0.2 — threshold re-encryption on transfer. Coordinated with the SealedMind team. Sale of a daimon becomes a clean key handoff.
• v0.3 — mobile-first UI. /act and /brain go mobile-comfortable.
• v0.4 — strategy registry on top of SealedMind shards. "Lease just my trade-history shard" instead of full brain rental.
• v0.5 — split signing wallets. Decouple the iNFT-owner wallet from the trade-execution wallet (so a hot wallet executes but a vault wallet holds the brain).

---

Acknowledgements

Daimon is the consumer surface of a coordinated three-project 0G submission:

• The SealedMind team for the encrypted-memory primitive that makes the brain an iNFT.
• The VeilSolver team for MEV-resistant intent solving that lets the daimon act without leaking alpha.
• The 0G team for the infrastructure — Storage, Compute (TEE), and the Galileo L1 — that makes "AI agent as on-chain asset" run on real money.

---

License

MIT.