The AI Arbiter for Connected Couples
Open Agents 2026 · ETHGlobal
LoveClaw is a relationship trust app for two people who opt into mutual accountability. Each partner installs it on their device, pairs over a QR code or invite link, and from that point on their phones stay in sync peer-to-peer over the AXL mesh network. There is no central couples server. Every AI agent gets minted as an NFT on the 0G Galileo testnet, relationship events are stored permanently on-chain via 0G Memory, and both partners can lock real ETH stakes in a deployed smart contract on Ethereum mainnet. Together they also manage a mutual on-chain portfolio from the Today dashboard: shared ETH / USDC vault balances, live pricing, and co-approved token swaps (quotes and execution stay peer-negotiated over AXL until both sides agree).
Hackathon prototype. Not a financial or relationship advice.
Diary — auto-generated journal day (sticky + illustration)
Pact — Command Examples modal in chat (@loveclaw presets)
Phone captures · p1.jpg · p2.jpg · p3.jpg
LoveClaw is a mobile app built on an OpenClaw-style fork: each phone runs a local agent that collects consented signals (apps, rough location, notification categories—not message bodies, screen-on patterns, and similar). After pairing, those signals feed local checks against the pact you both agreed on, and the two devices share updates with each other—chat, diary, pact changes, heartbeats, and swap handshakes—peer-to-peer over AXL, with no central “couples server.”
Signals can also be batched through a small Python relay in prototype/relay/ for a stronger breach pass (model + fallback), an operator console stream, and typed episodes into 0G Memory (router → EverMemOS → search + durable storage, including zgs_kv on testnet). Roughly: signals in → “does this break our rules?” → memory and optional demo logging.
When something looks like a breach, the other person gets an alert over AXL, the moment can be remembered in 0G Memory, and if you turned on ETH stakes, LoveClawPact on Ethereum mainnet is where the serious on-chain breach / dissolve story runs (that contract is exercised with Foundry tests in evm/).
AXL is the private wire between the two phones: chat, diary sync, pact edits, heartbeats, and swap coordination (swap_confirm / swap_execute) all ride that mesh—direct partner-to-partner paths, not a shared backend for couple traffic.
0G shows up in three practical ways: mint an ERC-7857 Agentic ID on Galileo with ethers + MetaMask, push diary snapshots to 0G Storage with @0gfoundation/0g-ts-sdk, and optionally pick 0G Compute in settings like any other AI provider.
Uniswap (Trading API v1) powers quotes and swaps from the Today tab. Swaps mirror the two-party pact idea: one partner proposes in plain language, the app fetches a quote, the other phone must confirm over AXL, you re-quote at execute time (routes go stale fast), then call /swap and broadcast with the vault signer via ethers. Mutual money moves stay co-signed, not solo.
Each partner runs a local AI agent that reads consented device signals: app usage metadata, GPS location, notification categories (not message bodies), screen activity, and presence patterns. The couple agrees on a pact that defines what counts as a breach. If the agents detect a violation, a breach alert fires, the partner is notified over AXL, the event is written to 0G Memory, and if ETH was staked the on-chain penalty logic kicks in.
Phone A Phone B
Local Agent Local Agent
reads signals reads signals
| |
+------------- AXL P2P mesh ----------------+
|
Both agents evaluate signals
against agreed pact rules
|
Breach detected? ----No----> monitoring continues
|
Yes
|
+------------+------------+
| |
AXL breach alert 0G Memory
sent to partner breach episode
| stored on-chain
|
Smart contract
(ETH stake locked on Ethereum mainnet)
penalty applied if confirmed by both agents
Trust & accountability flow · hownew.png
What goes in the pact. At pairing you combine preset triggers (dating installs, location, diary, and similar) with custom rules in plain language—full sentences, quoted lines, in-jokes, or “house norms,” however you write them.
Permissive by design. Anything both of you explicitly agree to can live in the pact text. The only catch is being honest about what the app can see: if you both sign up for a rule, it should match what your devices and consent model actually expose.
What “automated enforcement” really means. Automated breach paths only fire when local agents can roughly infer a violation from signals you already consented to share. Those signals include things like:
- Installed apps / package names
- Coarse GPS and presence
- Notification categories (not message bodies)
- Screen-on patterns
- Shared diary and chat context
- Heartbeats and similar device metadata
When a rule is only a mutual promise. If a rule would need proof the stack cannot access—or surveillance outside those channels—it stays a mutual promise between you. Nothing silently trips a “hard” automated breach for that; the product does not pretend it can enforce what it cannot observe.
Drafting and changes. Use @loveclaw in the chat tab to draft or rephrase rules. If a change would alter what gets monitored, it still goes to your partner as pact_changes_propose over AXL and only applies after they accept.
The paired chat flow includes a “Command Examples, Be Creative! Ask for Anything!” sheet (#pact-inspire-modal in the chat UI). Each row injects an @loveclaw … starter into the composer—tap an example to load it into the agent — then edit before sending. Presets shipped in the UI:
- No dating apps — Monitors for Tinder, Bumble, Hinge, Grindr, Badoo and triggers a breach alert if any are detected on either device.
- Screen time limit — 2h social media/day — Tracks daily screen time on Instagram, TikTok and Twitter/X. Alerts both partners when either one exceeds 2 hours.
- DeFi only — no CEX apps — Detects custodian exchange apps (Coinbase, Binance, Kraken, Gemini). Only self-custody wallets like MetaMask, Rainbow or Uniswap are permitted.
- Zero gambling apps — Flags sports-betting, casino and lottery apps the moment they appear on either device. Breach alert fires immediately.
- Spending transparency — no hidden shopping — Triggers when high-value shopping apps (Farfetch, Net-a-Porter, StockX) are opened. Encourages shared spending decisions above the agreed threshold.
- Digital curfew — phones off by midnight — Monitors device activity after midnight on weeknights. Sends a gentle nudge to both partners when either is still on-screen past curfew.
Every message between partners travels over AXL with no server in the middle. This includes breach alerts, diary sync, location heartbeats, pact amendments, swap negotiations, and profile/avatar updates.
Each partner gets a 64-character hex AXL public key. The creator's key is embedded in the invite QR code. When the joiner scans it, their device sends an axl_handshake message over AXL to complete pairing. After that all communication is direct P2P.
AXL nodes run locally on :9002 (creator) and :9012 (joiner). In development the Vite proxy forwards /axl9002 and /axl9012. In production a Vercel serverless proxy handles the forwarding via DEMO_AX_9002_URL and DEMO_AX_9012_URL environment variables.
Message types sent over AXL: axl_handshake, breach, break_pact_propose, break_pact_grant, break_pact_deny, diary_note, diary_note_delete, diary_notes_sync, pact_changes_propose, pact_changes_accept, swap_confirm, swap_deny, swap_execute, profile_update, score updates, location heartbeats, and pings.
Full technical reference: README_AXL.md
0G powers three distinct layers of LoveClaw.
Agent NFT (ERC-7857 on 0G Galileo testnet)
Every partner mints a personal AI agent as an NFT on the 0G Galileo testnet using the ERC-7857 Agentic ID standard. The contract is deployed at 0x2700F6A3e505402C9daB154C5c6ab9cAEC98EF1F on chain ID 16602.
When you tap "Register Agent" in your profile:
- The app reads the mint fee from the contract and calls
iMintwith your agent's name, model (claude-sonnet-4-6), capabilities, and system prompt hashed as data fields. - A fresh Ethereum wallet is generated locally and linked to your NFT on-chain via
authorizeUsageanddelegateAccess. - The agent wallet private key is encrypted with AES-GCM (PBKDF2, 150k iterations) and kept on-device for signing; you never handle the raw key in the UI.
- Your profile now shows an "OG Agent Address NFT ID #X" badge with a link to the 0G Chainscan explorer. Your partner sees your NFT ID in their profile view of you.
- The agent wallet address is passed into the
LoveClawPactsmart contract as your authorised breach-filing address. Only that address can submit evidence on-chain.
The agent wallet also signs every 0G Storage upload and is embedded in each diary snapshot as metadata, permanently linking stored files to the on-chain agent identity.
0G Memory (EverMemOS)
A Python service (memory_router.py) runs at port 9091 as a thin HTTP wrapper around EverMemOS at port 1995. EverMemOS backs everything with MongoDB, Elasticsearch, Milvus for vector search, Redis, and zgs_kv which writes to the 0G testnet blockchain.
Episodes are written automatically:
- Breach detected (dating app found) writes a
breachepisode - Partner first connects writes an
axl_handshakeepisode - Diary entry generated writes a
diaryepisode - Both partners detected at the same location writes a
togetherepisode
Before generating a diary entry, the app queries 0G Memory with a semantic search to pull relevant past episodes and inject them as context into the AI prompt. This grounds every diary entry in real relationship history.
0G Storage
Partners can tap "Store on 0G" in the diary tab to upload a cover image and a full JSON diary snapshot to the 0G Galileo testnet using @0gfoundation/0g-ts-sdk. The upload uses Indexer and MemData from the SDK, signs with the agent wallet, and returns a rootHash and txHash with direct links to the Galileo storage and chain explorers.
Hackathon journal uploads (Galileo). All diary “Store on 0G” submissions from the Open Agents 2026 build are listed under one address on 0G StorageScan: 0xD319693b334FBAb00aA455a119C36763F00Ca3bB on Galileo testnet.
0G Compute
In Settings, 0G Compute is available as an AI provider option. When selected, diary generation and breach analysis route to 0G inference instead of a centralised API.
Project LoveClaw — The AI Arbiter for Connected Couples. Two people pair phones (QR or invite), stay in sync over AXL with no central couples server, and run local agents on consented device signals. They agree on a pact; breaches alert the partner, write to 0G Memory, and can tie to ETH locked in LoveClawPact on Ethereum mainnet. The Today tab adds a mutual portfolio: shared vault balances and Uniswap Trading API swaps that both partners must approve before anything is broadcast.
Contracts
| What | Network | Address |
|---|---|---|
| LoveClawPact (stakes, breaches, dissolve) | Ethereum mainnet (chain 1) |
0x597a01608952220f1d833c833111731E6762085c — verified source |
| ERC-7857 Agentic ID (per-partner AI agent NFT) | 0G Galileo testnet (chain 16602) |
0x2700F6A3e505402C9daB154C5c6ab9cAEC98EF1F — code: src/lib/agentic-id.js |
Repository and setup
- Repo: https://github.com/vm06007/loveclaw
- Setup: Clone, copy
.env.example→.env,bun install, then Running locally (bun run dev, optionalprototype/signal-relay.pyon9090, optionalmemory_router.pyon9091,bun run dev:alice/dev:borisfor two roles). Stack detail: README_0G.md, README_UNISWAP.md, README_AXL.md.
Live demo and demo video
- Live: https://loveclaw.app/ · pairing shell: https://web.loveclaw.app/
- Video (keep under 3 minutes): [Add YouTube or Loom URL before you submit.]
Protocols and SDKs
- 0G: ERC-7857 Agentic ID on Galileo; 0G Storage via
@0gfoundation/0g-ts-sdk(browser +prototype/relay/zg_upload.ts); 0G Memory via EverMemOS +memory_router.py/memory_client.py; optional 0G Compute in AI settings. - AXL: P2P mesh for couple messages (
src/axl/). - Ethereum:
LoveClawPactfor stakes and breach lifecycle (evm/). - Uniswap: Trading API v1
quote/swap(README_UNISWAP.md). - OpenClaw: Local consent-first agent model and lineage (see welcome copy on loveclaw.app).
Team
| Name | Telegram | X |
|---|---|---|
| Vitaliy Marinchenko | @EthVitCom | @EthVitally |
| Yiying Zhu | @EthVitCom | @EthVitally |
GitHub: @vm06007.
How agents communicate and coordinate (two-partner “swarm”)
Each phone runs a local LoveClaw agent (signals + pact evaluation). The two agents do not share a central coordinator: they exchange typed messages over the AXL mesh (handshake, breach alerts, diary sync, pact proposals and accepts, swap confirm/deny/execute, profile updates, heartbeats). Relay (prototype/signal-relay.py) and 0G Memory (memory_router.py → EverMemOS) sit beside that path for analysis and durable episodes; on-chain steps use the per-partner agent wallet tied to each ERC-7857 NFT. Message inventory: README_AXL.md (and the AXL subsection under Sponsors and integrations earlier in this README).
ERC-7857 on 0G explorer and embedded memory
- Contract on Galileo: chainscan — Agentic ID. After Register Agent, the profile links to the minted token on the same explorer (add a direct token URL here if the form asks for one specific mint).
- Intelligence / memory on-chain and in product: Episodes (breach, handshake, diary, together, etc.) flow through EverMemOS and
zgs_kv→ 0G testnet; the Diary pipeline semantic-searches 0G Memory before generating each day’s narrative; 0G Storage uploads are signed by the agent wallet and tied in diary metadata. Deep dive: README_0G.md — How the pieces fit together.
Example agent code
- On-chain agent:
src/lib/agentic-id.js—iMint,authorizeUsage,delegateAccess; agent wallet signs 0G Storage and is the address authorised on LoveClawPact for breach evidence. - In-app copilot:
src/app/lovclaw-ai.js—@loveclaw, structured JSON,pact_changes_proposeover AXL.
Architecture diagram
See Architecture overview and the diagram in this doc: local agent :18789, AXL, relay, memory router → EverMemOS → 0G testnet, Galileo for NFTs, Storage for diary snapshots, optional Compute, Ethereum for LoveClawPact.
Full technical reference: README_0G.md
LoveClaw includes a shared couple vault backed by the Uniswap Trading API v1.
Mutual portfolio. After pairing, the Today tab is the couple’s shared money view: one place to see mutual budget, combined ETH and USDC balances for the vault narrative, and ETH priced in USD from a live Uniswap quote—both partners read the same numbers. Swap flows are explicitly two-party: you propose in natural language, the app fetches a quote, and the other partner must confirm on their device over AXL (swap_confirm → swap_execute) before any signed transaction is broadcast. Neither side can move mutual funds alone.
Partners can type natural-language swap commands like "swap 0.1 ETH for USDC". The app parses the intent, fetches a quote from POST /uniswap/v1/quote, and then negotiates the swap peer-to-peer over AXL before broadcasting anything. Both partners must confirm before POST /uniswap/v1/swap is called and the signed transaction is broadcast via ethers.
The vault display shows live ETH and USDC balances and prices ETH in USD using a real-time Uniswap quote. The Uniswap API is proxied through Vite in development (/uniswap rewrites to trade-api.gateway.uniswap.org) and through Vercel in production.
Full technical reference: README_UNISWAP.md
Uniswap builder feedback (API, docs, DX): FEEDBACK.md
Deployed and verified on Ethereum mainnet.
| Field | Value |
|---|---|
| Address | 0x597a01608952220f1d833c833111731E6762085c |
| Network | Ethereum mainnet (chain 1) |
| Verified | Etherscan source |
| Source | evm/src/LoveClawPact.sol |
| Compiler | Solidity 0.8.30, optimizer 200 runs |
Both partners lock ETH when creating and joining a pact. Each partner assigns an AI agent address (derived from their 0G agent wallet). Only those agent addresses can file breach evidence on-chain. Neither partner can file against themselves.
The contract supports two breach modes. In instant breach, both agents must agree before any funds move. In delayed breach, one agent files evidence and the accused partner has a dispute window (default 24 hours, max 7 days) to challenge it. If unchallenged, the innocent partner claims the full stake.
screen-home
screen-create --> screen-code (QR + invite link, AXL key embedded)
screen-join --> (joiner enters name and invite code)
screen-paired --> screen-dashboard
tab: today (trust score, mutual portfolio / vault, co-approved swaps)
tab: signals (heartbeat map, activity)
tab: diary (AI-generated entries, Store on 0G button)
tab: pact (rules, trigger amendment flow)
screen-profile (agent NFT registration, AXL key, partner profile view)
A Python service in prototype/relay/ runs at port 9090. It ingests signal batches from the app, runs breach_ai.py (Claude-backed breach analysis with keyword fallback), broadcasts events to an operator SSE console at http://localhost:9090/, and writes typed episodes to 0G Memory via memory_client.py.
The Diary tab is your couple’s AI journal: each day it composes a narrative from a context bundle—recent signals, calendar notes, semantic hits from 0G Memory, and partner-visible history. The write-up is styled like a retro journal (sticky date + body copy); the day view can pair that text with a scene image—either a stock illustration from the shared prototype/diary/images/ pool or an AI-generated cover when you run diary image generation (OpenRouter image path). Both partners see the same entry; updates sync over AXL.
Type @loveclaw in the chat tab to use the pact architect: propose new rules, get help phrasing triggers, or ask questions about the pact. The AI responds with structured JSON (propose_rule, need_info, chat) and if a rule is proposed it gets sent to the partner as a pact_changes_propose message over AXL for their approval.
bun install
# Web app
bun run dev # http://localhost:1420
LOVECLAW_DEV_HTTPS=1 bun run dev # HTTPS for camera / geolocation on LAN
# Signal relay (port 9090)
python3 prototype/signal-relay.py
# 0G Memory router (port 9091, optional)
python3 memory_router.py serve
python3 memory_router.py docker-up # starts the full EverMemOS Docker stack
# Two device roles in separate terminals
bun run dev:alice
bun run dev:borisPrerequisites:
| Tool | Purpose |
|---|---|
| Bun | Install and run scripts |
| Python 3.10+ | Signal relay and memory router |
| Go 1.21+ | AXL node binary in examples/axl-demo/ |
| Docker | EverMemOS stack for 0G Memory (optional) |
| MetaMask | Agent NFT minting on 0G Galileo testnet |
Key environment variables (copy .env.example to .env):
| Variable | Purpose |
|---|---|
VITE_UNISWAP_API_KEY |
Uniswap Trading API key |
VITE_VAULT_ADDRESS |
Shared couple vault address |
VITE_VAULT_PRIVATE_KEY |
Vault signing key |
VITE_ZG_PRIVATE_KEY |
Wallet key for 0G Storage uploads |
MEMORY_ROUTER_URL |
0G Memory router URL (default http://localhost:9091) |
DEMO_AX_9002_URL |
AXL node URL for creator (Vercel deploy) |
DEMO_AX_9012_URL |
AXL node URL for joiner (Vercel deploy) |
Browser (Vite web client + src/) or Tauri desktop app
|
+-- LoveClaw agent :18789 reads device signals
+-- AXL mesh :9002 / :9012 P2P partner sync
+-- Signal relay :9090 breach analysis + SSE console
+-- Memory router :9091 0G Memory HTTP adapter
|
+-- EverMemOS :1995 (Docker)
+-- MongoDB :27017
+-- Elasticsearch :19200
+-- Milvus :19530
+-- Redis :6379
+-- zgs_kv ---------> 0G testnet blockchain
0G Galileo testnet (agent NFT minting via MetaMask)
Ethereum mainnet (LoveClawPact contract, ETH stakes)
Uniswap Trading API (quotes and swaps, proxied)
Trust. Transparency. Automation.