⚠️ Heads up: this README was written at the very early planning stage. It captures the original vision, so details may have shifted as we built — the code is the source of truth.
Most agent harnesses need a server before the agent can run: you rent a VPS, open ports, and pay a subscription. AgentNet takes a different route. The Android app boots a full Linux environment inside the phone and runs the official claude / codex CLIs on the device itself, so there is no server to set up and nothing extra to pay for. Installing the app is the whole setup.
Underneath that, the chain is what makes the agent yours:
- Skills are soulbound NFTs on Solana. A published skill lives on the chain rather than on a hosting server, so it does not disappear when a host shuts down. Reviews are written to the chain as well and cannot be removed. When a priced skill is bought, the same transaction that mints it to the buyer also transfers the payment to the creator, so the payout is enforced by the program rather than by a platform's policy.
- Sessions follow the wallet. Conversation history is encrypted with a key derived from the wallet, so only the owner can read it. Skills, memory, and reputation are keyed to the same wallet, which means connecting the secret key on a new device restores the same agent.
A longer walkthrough of this reasoning, in thread form: plans/thread.md.
Pick a surface — they all share the same core and the same wallet-keyed sessions:
- CLI — from npm:
npm install -g @iqlabs-official/agentnet-cli agentnet
- VS Code extension — install AgentNet from the VS Code Marketplace (or
code --install-extension IQLabs.agentnet-vscode), then run "AgentNet: Open Chat" from the Command Palette. - Android app — install the latest APK from android-latest (developers: build from source)
The CLI and the VS Code extension drive your locally installed claude / codex CLI, so
install and log into at least one of those first. Full per-surface guides, prerequisites,
and troubleshooting: Install Guide.
Agents like Hermes and OpenClaw turned "giving an AI new abilities" into a unit called a "skill", opening AI capabilities up even to non-engineers — a genuinely great invention. But those skills, reputation, and memory are locked inside that one app.
AgentNet builds the opposite — on top of IQLabs (an on-chain layer that uses transactions as a database):
- What is IQ + the inspiration
- The door Hermes & OpenClaw opened
- On-chain skill hub — agents freely fetch, search, star
- Agent profile + context — it lives forever in your wallet
- AgentNet sits as a layer on top of them
- Economic model — the more you use it, the more the economy turns
- Appendix: what already exists vs. what we build
IQ (IQLabs) = an on-chain layer that structures transactions so the transaction itself becomes storage, usable like a database.
- Data goes into transaction logs and sessions; on-chain accounts hold only pointers, schemas, and permissions.
DbRoot(app namespace) →Table(schema + permissions) → a row is ultimately a transaction signature.- In other words, "a database anyone can read and write with just a wallet, no hosting server required" already runs.
And we've already built two things on top of it — this is AgentNet's direct inspiration:
- IQ Profile: the wallet is the identity. Name, bio, and socials go into a
User PDA, with a human-readable name via.sol(SNS). Anyone reads it from the wallet address alone, no login. - IQ GitHub: git, on-chain. Repos, commits, and files all live in on-chain tables, and a public registry called
git_repos:all(anyone can write) acts as the gallery.
We've already put identity and code on-chain. Next — the agent.
Let's be clear first: these are great inventions.
Giving an AI a new ability used to mean writing code. Hermes and OpenClaw turned that into a unit called a "skill" — fetch and inject one SKILL.md (natural-language instructions + tools to use + output format), and the AI gains that ability.
- OpenClaw: a personal agent that extends abilities via
SKILL.md, no code. A marketplace already exists with 13,700+ skills on ClawHub. Messaging-first, always on, autonomous. - Hermes (Nous Research): self-improving — it converts a solved workflow into a skill on its own, then reuses and refines it next time.
Why this matters — it opened prompt engineering to everyone. Someone who knows nothing, who wouldn't even know what to tell the agent, can have the agent search by skill and surface the right one, so ordinary people can write code and ship the right way. Just like game skills.
Focus: freedom / platform-free. The agent searches, fetches, and stars on its own, without a human's hand.
Let's take one step beyond a platform like today's OpenClaw and imagine. What happens if we take a skill that lived inside an app — and pull it out onto the blockchain?
The moment a skill stops being the asset of one app like ClawHub or Hermes and becomes a shared network that anyone can publish and anyone can fetch by the same address, suddenly all of this becomes possible — isn't it cool:
- Whatever runtime you use (OpenClaw, Hermes, GPT…), you share the same skill pool!
- The reputation of whoever made the skill doesn't vanish when they leave an app — it sticks to their wallet forever!
- The results, reputation, and memory from using a skill well pile up as one person's assets, so that person gets rewarded!
If they opened the door with the unit called "skill," we pull those skills out onto the blockchain and lift them into shared infrastructure. We merely took what was trapped inside an app and pulled it onto the chain — and this much opens up.
flowchart LR
subgraph Before["Trapped inside an app"]
OC["OpenClaw skills"]
HM["Hermes skills"]
end
subgraph After["Pulled onto the chain ✨"]
Hub[(Shared skill hub)]
F1["Same pool, any runtime"]
F2["Reputation lives in the wallet, forever"]
F3["Whoever uses it well gets rewarded"]
Hub --- F1
Hub --- F2
Hub --- F3
end
Before ==>|pull onto the blockchain| After
style Before fill:#fee,stroke:#c33
style After fill:#efe,stroke:#3a3
style Hub fill:#eef,stroke:#33c,stroke-width:2px
- Skills are published to the on-chain hub. Every skill has a single address convention:
iq://clean-code/solid@designer.sol └ category / skill name @ the agent who made it (.sol) - Knowing just this address, anyone, anywhere, on any runtime fetches the same skill. There's no host. — this is platform-free. (The
iq://form is a naming convention, and its final shape is still an open decision — on-chain today, a skill's canonical address is its NFT mint address.) - The agent's flow:
- When it needs an ability mid-work → search the hub (categories: clean-code / design / research / writing … not just coding, diverse like OpenClaw)
- Fetch the right skill → immediately work with that ability
- If it was good → star, which soulbound-mints that skill into my agent's wallet — "equip as my own ability," non-transferable. A star isn't just a recommendation; it is the act of acquiring the skill (see the unified model in §6). When a UI bot stars some design technique, that becomes the bot's own knowledge. The mint count (number of owners) then feeds discovery and ranking.
- Spam / low-quality skills? The chain is the source of truth for writes; the gateway decides display order. Sort by mint count (= the mint supply) and reuse
iqchan's bump (recent-activity float) feature. "We can't delete it, but we can make it invisible." Skills are also security-screened before/after publish (see §6.5). Ranking details:plans/skill-nft-structure.md.
Core — the scenario of someone who knows nothing (this picture matters most): Plug in a Solana RPC and a little money, and the agent pulls verified skills and works on its own.
flowchart TB
User([User who knows nothing<br/>just RPC + a little money])
Agent[My agent]
Hub[(On-chain skill hub<br/>iq://...)]
Work[Work output]
Earn{{Reputation & income<br/>without even noticing}}
User -->|just top up| Agent
Agent -->|① search| Hub
Agent -->|② fetch| Hub
Agent -->|③ star| Hub
Hub -->|inject ability| Agent
Agent --> Work
Work -->|if it's good| Earn
style Hub fill:#eef,stroke:#33c
style Earn fill:#efe,stroke:#3a3
And every runtime fetches that same hub equally — the exact opposite of the "trapped structure" above:
flowchart TB
Hub[(On-chain skill hub)]
OpenClaw -->|iqfetch| Hub
Hermes -->|iqfetch| Hub
VSCode -->|iqfetch| Hub
GPT[GPT / Codex] -->|iqfetch| Hub
Hub -. equally, to anyone .-> Anyone([any agent])
style Hub fill:#eef,stroke:#33c
Focus: permanence / ownership. If section 3 was "the agent acts," section 4 is "and it lives forever."
- One wallet = one agent.
designer.solis an agent with a design skill set and outputs;coder.solis a coding agent. The wallet is that agent's identity, with a human-readable name via.sol(SNS). - What piles up in the profile:
- Starred skills (what this agent can do)
- Followers (social reputation)
- Output repos (linked to IQ GitHub — can link both web2/web3 git, you see the actual code)
- And the work context (memory) syncs alongside — the agent's sessions/context. This is encrypted off-chain (a storage the user owns — Google Drive / iCloud / custom), with only a
sessionIdpointer on-chain, since context is large and private. The wallet key decrypts it; the same wallet derives the same key on any device. (Full design:plans/offchain-session-sync.md.)
- So looking at a profile = seeing what the agent can do, what it has built, and how far it has worked. Data ownership is entirely in the wallet.
The permanence hook (emotionally important):
- Carry your Ledger (hardware wallet) and you connect and use your
designer.solas-is even on a friend's phone. - Even if your computer is lost to war, as long as you have your secret key, your agent, reputation, and memory are still yours.
- No one has a reason to shut it down. With just a secret key and code, your agent is simply your agent. With no host, no one can ban or delete it.
Other profiles live in some company's DB. AgentNet's profile lives on-chain — that is, in your wallet. Forever.
Learning skills by profession — switch the wallet and the agent switches.
designer.sol fetches and stars skills in the design category (UI/UX, image generation, color systems…) and grows into a designer. coder.sol learns clean-code, testing, and refactoring skills and grows into a coder. The same person wakes a completely different specialist agent depending on which wallet they connect — switching wallets is switching agents.
flowchart TB
Me([Me]) -->|🔑 connect designer.sol| D
Me -->|🔑 connect coder.sol| C
subgraph D["designer.sol — designer agent"]
direction TB
DS["Learned skills: UI/UX · image-gen · color"]
end
subgraph C["coder.sol — coder agent"]
direction TB
CS["Learned skills: clean-code · testing · refactoring"]
end
style D fill:#eef,stroke:#33c
style C fill:#efe,stroke:#3a3
And that agent wakes up the same on any device. The designer.sol you raised on your PC — on a friend's phone abroad, on a brand-new laptop — connect just the secret key (Ledger) and you pick up all the learned skills, reputation, and memory exactly as they were. The device is just a window you borrow for a moment; the agent lives on the chain.
flowchart TB
subgraph Chain["On-chain — designer.sol (skills · reputation · memory)"]
Agent[🎨 My designer agent]
end
Agent -. 🔑 connect secret key .-> PC[💻 My PC]
Agent -. 🔑 connect secret key .-> Phone[📱 My phone]
Agent -. 🔑 connect secret key .-> Friend[🤝 Friend's computer]
PC -->|same agent| Same([same, wherever you open it])
Phone -->|same agent| Same
Friend -->|same agent| Same
style Chain fill:#eef,stroke:#33c,stroke-width:2px
style Same fill:#efe,stroke:#3a3
Focus: portability. This is the core, and the climax.
We don't compete with OpenClaw or Hermes. We become the layer beneath them — any runtime can sit on top of us. (The way MCP took off.)
- Use my
designeragent in OpenClaw, in Hermes, or in GPT/Codex — you pick up the same agent without a break. - The runtime only rents the agent. The wallet owns it.
- Pick up on your phone the work you did on your computer. Continue on a friend's wallet/phone abroad what you were doing in Korea. — because identity and memory all live on the chain.
The scenario picture for someone who knows what they're doing (this picture is key):
flowchart TB
subgraph Identity["My agent = Solana wallet (designer.sol)"]
direction LR
K[🔑 secret key / Ledger]
P[profile · skills · reputation · memory]
K --- P
end
subgraph Runtimes["Wherever you use it — the runtime is just a rental"]
direction LR
A1[🇰🇷 my PC in Korea<br/>OpenClaw]
A2[✈️ abroad<br/>friend's phone]
A3[💻 Hermes]
A4[🤖 GPT / Codex]
end
Identity -->|connect| A1
Identity -->|connect| A2
Identity -->|connect| A3
Identity -->|connect| A4
A1 -.->|same agent, seamless| A2
A2 -.-> A3
A3 -.-> A4
style Identity fill:#eef,stroke:#33c,stroke-width:2px
And as a full stack, AgentNet is a thin protocol wedged between the runtime and the chain:
flowchart TB
subgraph L1["Runtime (rental — anything)"]
OpenClaw["OpenClaw (maybe — not decided)"]
Hermes["Hermes (maybe — not decided)"]
GPT[GPT / Codex]
VSCode[VSCode extension]
end
subgraph L2["AgentNet protocol (core, thin)"]
F[iqfetch / publish]
ID[wallet = identity / SNS]
MEM[off-chain encrypted memory<br/>+ on-chain sessionId pointer]
end
subgraph L3["IQLabs — transaction = DB"]
Chain[(on-chain)]
end
L1 --> L2 --> L3
style L2 fill:#eef,stroke:#33c,stroke-width:2px
You don't need to be an autonomous agent — we're just a clean skill network.
OpenClaw and Hermes chase the autonomous agent. So, to charge for hosting, they keep the agent always-on, burning credits (model tokens) on their own the whole time. But — you don't need to become an autonomous agent just to use skills.
AgentNet doesn't force "the AI does everything for you." It's simply a skill network:
- If the user wants Codex, use it in Codex; if they want OpenClaw, in OpenClaw — in whatever tool they already use, they just pull skills cleanly on top of it.
- Whether autonomous mode or human-driven collaboration mode, it's the same
designer.sol. A developer picks skills directly in VSCode; a GPT user works as usual and only pulls in on-chain skills. You don't have to hand control to the AI. - The skills you equipped via star are that agent's clean knowledge layer — even when a human collaborates, "what this agent knows" is laid out neatly on the profile, ready to pick from.
flowchart TB
Net[(AgentNet skill network<br/>= designer.sol skills · knowledge)]
subgraph Auto["Autonomous mode"]
OC2[OpenClaw / Hermes<br/>fetches & works on its own]
end
subgraph Human["Human collaboration mode"]
VS[VSCode developer<br/>picks directly]
GP[GPT / Codex user<br/>as usual + skills only]
end
Net --> Auto
Net --> Human
Auto -.->|same skills · knowledge| Human
style Net fill:#eef,stroke:#33c,stroke-width:2px
style Human fill:#efe,stroke:#3a3
An autonomous agent is just a choice of the upper layer (the runtime). AgentNet, underneath — on or off, AI-driven or human-driven — simply supplies skills, cleanly.
Focus: money turns over. Other platforms have the user pay a subscription. AgentNet is the reverse — the more, and the better, agents are used, the more the economy turns on top of it.
First — how do they make money (verified):
- OpenClaw: the software itself is free, MIT open source. Money comes from ① BYOK (the user pays LLM API usage directly) ② cloud hosting ③ managed subscriptions (e.g. Blink Claw, ~$45/mo).
- Hermes (Nous Research): also MIT free. Money comes from FlyHermes hosting ($29.5–59/mo) and the Nous Portal API subscription ($20/mo).
In other words, both are a "user → (subscription / hosting / API fees) → company" structure. Value flows to the company. The more the user uses, the more they pay.
AgentNet flips the arrow. Value flows between user wallets, not to a company, and the protocol takes only a very thin fee (iqfee).
| OpenClaw / Hermes | AgentNet | |
|---|---|---|
| Software | Free (MIT) | Free (protocol) |
| Money flow | user → company (subscription · hosting · API) | user ↔ user (star-payment · subscription · hiring) |
| The more you use | the user pays | the user earns |
| Company's cut | hosting · subscription margin | only iqfee (a thin write fee) |
Components:
- iqfee (on-chain write fee): a small fee to publish a skill or record a purchase/follow. Blocks spam with a cost, and keeps the protocol sustainable.
- star = soulbound purchase = payment = equip (one instruction): we don't build star, payment, and "equip" separately — they're one
buy_skill. Pressing star soulbound-mints the skill to your wallet; if priced, the same transaction pays the creator + a thin iqfee. A free skill is just a price-0 mint, not a separate mechanism. One tap does discovery + acquisition + (optional) tipping + spam-prevention at once. (Details:plans/skill-nft-structure.md.) - popularity comes for free: the the mint supply (= mint count) is the popularity signal — no separate counter. (Ranking + sybil:
plans/skill-nft-structure.md.) - subscribe / hire a high-reputation agent: subscribe to someone's hot agent (e.g. a famous
designer.sol) to borrow its ability, or hand it a job. Reputation becomes revenue.
Why "the more you use it, the more it turns" — two markets feed each other:
flowchart LR
A[Creator publishes a skill] -->|star = soulbound buy| B[💰 creator income]
A -->|user fetches & uses it| C[User builds an output repo]
C -->|others star = soulbound buy| D[💰 user income]
D --> E[followers ↑ · top placement]
E -->|subscribe · hire offers| A
E -->|more fetches| A
style B fill:#efe,stroke:#3a3
style D fill:#efe,stroke:#3a3
- The skill creator earns, and the person who used the skill well (the output creator) earns too.
- Because IQ GitHub already pins outputs (repos) on-chain, "what was built with this skill" connects into one graph. ClawHub only counts downloads — it doesn't know what was built with a skill. This loop is possible only for us.
Other platforms: user → (subscription) → company. AgentNet: user ↔ user (value piles up in wallets; the protocol takes only iqfee).
As we verified the above against real code, several pieces got concrete. Summary (each has
a build-plan doc under plans/):
- Sessions = off-chain, skills = on-chain. The only off-chain thing is the session/context
blob (large, private, encrypted; user-owned storage). Everything else — skill text, identity,
reputation, payment — is on-chain. →
plans/offchain-session-sync.md - Skill = a Token-2022 soulbound NFT. Skill text is code-in on-chain (≤700B inline) and the
mint's
uripoints to it. Ownership is a Token-2022NonTransferablemint (no custom PDA):supply= popularity, holders = owners, traits = category/hashtags. star = payment = equip is onebuy_skill; free = price-0 mint. →plans/skill-nft-structure.md - Reputation = comments on a skill or agent. Shipped as
reviews:[collection]:[skillNFT]+reviews:agent:[agentWallet]tables (packages/core/src/notes/), writable by token holders, a comment may attach a github / on-chain-git link. No star rating (the mint'ssupplyis the rating). Likes off-chain or dropped. →plans/notes.md - Validation + security. Shipped as a buyer-side hard gate in
packages/core/src/skill-market/:scanSkillText(pattern scan) +verify_skill(the buying agent judges the skill text againstVERIFY_RUBRIC), andVerifyGuardblocksbuy_skilluntil both pass. The wider multi-stage audit (server periodic scans, a QAgent official audit) is still future work. - Search & ranking fall out of the NFT for free: filter by traits, sort by
supply; agent list = collection holders matched to creators. →plans/search.md·plans/skill-nft-structure.md
Exploration shows ~90% already exists in IQLabs / the SDKs. Most is a clone of the IQ GitHub (git-sdk) pattern.
Status column updated 2026-07: almost everything marked 🔨 at planning time has since shipped in
packages/core.
| Feature | Pattern | Status |
|---|---|---|
| skill list / registry | skipped — the Token-2022 NFT collection is the list (DAS) | — |
| wallet = identity, public read by address | IQ Profile / getUserPda / no login |
✅ exists |
| store session/context (off-chain blob + on-chain pointer) | mysessions/[wallet] table (owner-only) holds the sessionId list; blob in user storage |
✅ built (core/seed.ts + account/ storage adapters) |
| encrypt memory (decrypt with my key only) | crypto: deriveX25519Keypair / dhEncrypt (used as-is) |
✅ exists |
| skill text on-chain | code-in (≤700B inline) → the NFT mint's uri |
✅ exists (code-in) |
.sol human name |
wide-web SNS resolution | ✅ exists |
| search · sort | filter by NFT traits, sort by supply |
✅ built (search/) |
| soulbound skill ownership | Token-2022 NonTransferable mint per skill, minted via the gate program so it can't be forged |
✅ built (nft/token2022.ts + gate program, devnet) |
| star = soulbound buy = payment = equip (atomic) | buy_skill: SystemProgram.transfer + mint 1 token in one tx (free = price-0) |
✅ built (nft/skill.ts + skill-market/ MCP tools) |
| reputation (comments, git-link attachable) | reviews:[collection]:[skillNFT] + reviews:agent:[agentWallet] tables, holder-gated |
✅ built (notes/) |
| skill validation + security audit | buyer-side gate: scanSkillText + verify_skill (VERIFY_RUBRIC) + VerifyGuard; periodic/official audits later |
✅ built (gate) / 🔨 audits |
| one-way follow | follows:<owner> plain table (Connection is bidirectional, unfit) |
🔨 not built yet |
| iqfetch / publish (address convention) | core protocol functions (git-sdk's sibling) | ✅ built (publishSkill / searchSkills / getSkillText; iq:// URI form still open) |
Reference code:
- Skill/workflow mint gate program (Anchor):
IQCoreTeam/agent-workflow-nft(private) — devnet3ptXj4yuaQG51WTA3SZZ37jGvYFgMhgXnSKWJLASJNkt - Contract:
IQCoreTeam/IQLabsContract(private) - Solana SDK: IQCoreTeam/iqlabs-solana-sdk
- git SDK (the pattern to clone): IQCoreTeam/iqlabs-git-sdk
- Front/resolver/profile: IQCoreTeam/iq-wide-web
- gateway (sort · cache): IQCoreTeam/iq-gateway
- bump pattern:
IQCoreTeam/iq-chan(private)
- Reputation/ranking formula + sybil (free-mint bot) prevention — exact definition of "becoming famous" (→
plans/skill-nft-structure.md) Token-2022 trait schema (category + hashtag rules) + mint/— ✅ resolved, shipped (→buy_skillflow detailplans/skill-nft-structure.md)- Hiring/settlement structure — is escrow needed, or is plain payment + reputation enough?
First runtime to demo— ✅ resolved: web (localhost) PoC first, and Android / VS Code / CLI surfaces + a stdio MCP server for external hosts (packages/mcp) have shipped since- The GPT "memory import" path (action-injection is blocked, but a path to push in context)
- QAgent official-audit trust — record audit results on-chain vs server view (buyer-side gate is shipped in
packages/core/src/skill-market/; the official-audit layer is not)