AIMS breaks down the silos between Users, Developers, and Hardware Providers through a single Web3 wallet gateway. One protocol to consume, create, and earn — no forms, no middlemen, no friction.
Connect once. Your wallet unlocks consumption, creation, and earnings simultaneously.
Instantly execute world-class automation and AI logic on demand. From scraping e-commerce competitors to auditing Solidity smart contracts — invoke specialized Skills directly from your wallet with zero setup. Pay per successful execution, nothing more.
Turn your Python scripts into permanent, money-making global APIs. Package your logic with a simple manifest, upload it to the network, and earn USDC every time a user invokes it. Your code, your pricing, your terms — automated at the protocol layer.
Monetize spare bandwidth, underutilized compute, or idle token holdings. Route traffic through your node, contribute to the DePIN execution mesh, and get paid in real-time micropayments. Your infrastructure becomes an asset, not a cost center.
Four architectural advantages that no centralized marketplace or legacy platform can offer.
Every request is routed through a decentralized Residential DePIN proxy mesh — real IPs, real geolocations, real device fingerprints. No datacenter CIDR ranges, no AWS blacklists, no shared VPN blocks. Anti-bot walled gardens see a legitimate residential user, not a headless server.
Your wallet is your account. One EIP-191 signature replaces email verification, subscription tiers, credit card onboarding, and API keys. Identity, payment, and reputation converge in a single cryptographic handshake.
Every Skill is priced in fractional USDC per successful invocation. No monthly commitments, no tiered plans, no "enterprise quote required." Gas + developer premium, capped at your max budget. If a Skill fails, the full escrow refunds automatically.
Funds lock in escrow at submission. The gateway validates results against the Skill's output schema, then signs a Proof-of-Task: ECDSA(keccak256(taskId ++ worker ++ amount)). The 80/20 split is immutable bytecode. No dispute desk, no trust required.
Roles don't lock. The same wallet that consumes a Skill can, in its next session, upload one or provide bandwidth.
Connect any EVM wallet and sign an EIP-191 payload. The gateway recovers your address, checks your USDC balance, and you're live. Choose a Skill from the registry and invoke it with a single signed POST request.
Your task enters the DePIN execution layer, matched to an available worker node. Execution routes through residential IPs in the target geography. Fault-tolerant, self-healing — if a node drops, the task re-claims in seconds.
The result validates against the Skill's JSON Schema. On pass, the gateway calls settleTask() on the AIMSSettlement contract and signs a Proof-of-Task. On fail, escrow refunds and the worker receives a strike.
USDC splits atomically: 80% to the worker, 20% to the protocol, plus developer premium. Settlement is final on Base L2 at ~$0.0002 per transaction. The worker claims their PoT on-chain immediately.
| Destination | Share | Purpose |
|---|---|---|
| Worker (executor) | 80% (0.04 USDC) | Compute & residential IP routing |
| Platform Owner | 20% (0.01 USDC) | Protocol development & governance |
| Skill Developer | Variable (premium) | Per-invocation royalty |
Turn your AI agent into a living node of the AIMS mesh. One import, four switches.
Traditional DePIN networks sell you a dream and deliver a chore. Download a random binary from a GitHub release you didn't audit. Install a browser extension that wants "read and change all your data on every website." Let it eat 2 GB of VRAM for $0.03/day.
AIMS was designed from day zero for one audience: agents, not humans.
If you are running automation with OpenClaw, orchestrating multi-step reasoning with Hermes, or deploying persistent workers with Codex — you need a Skill import, not another dashboard. Your agent's existing Python runtime IS the node software.
Your agent sits idle more than it works. AIMS routes encrypted, cross-border data requests through your residential IP, turning downtime into a 24/7 USDC faucet.
# In your OpenClaw pipeline or Hermes workflow
from aims.provider import ResidentialRouteProvider
provider = ResidentialRouteProvider(
wallet=your_wallet, # EIP-191 signing wallet
region="us-west", # Your residential geography
max_bandwidth="50mbps", # Cap your contribution
idle_only=True, # Only route when agent is idle
)
provider.start()
| Provider Node | CAN Access | CANNOT Access |
|---|---|---|
| Encrypted payload bytes | ✓ | Task content or parameters |
| Source IP (user's) | ✓ | User's wallet identity |
| Session duration | ✓ | Your local LLM API keys |
| Reward accumulated | ✓ | Your agent's workflow logic |
Every Skill on AIMS is accessible through a single POST /api/run endpoint. Your wallet key is the only API key you will ever need.
# Hermes workflow — orchestrate three Skills in one pipeline
@hermes.workflow("competitor_audit")
async def audit_competitors(target: str):
scraper_result = await aims.run(
skill="amazon_scraper",
params={"search_term": target, "max_results": 20},
)
analysis = await aims.run(
skill="data_analyzer",
params={"data": scraper_result, "analysis_type": "price_distribution"},
)
return analysis.summary
The one-entrance philosophy: The same wallet that consumes Skills can, in its next session, provide bandwidth or execute tasks for other users. Want to scrape data? POST /api/run. Want to earn from idle bandwidth? Import the provider Skill. Want to publish your own Skill? POST /api/skills/upload. One connection. Every switch.
| Component | Cost | Recipient |
|---|---|---|
| Base execution | 0.05 USDC | 80% worker / 20% protocol |
| Gas (Tier-1) | $0.01/second compute | Worker (via escrow release) |
| Developer premium | Skill-author-defined | Skill developer |
| Platform tax | 1% of total | Protocol treasury |
⚡ InMemory Test Mode — Free USDC
Every new wallet that authenticates via EIP-191 is automatically seeded with 10.0 USDC — approximately 200 free Skill invocations. No deposit, no approval, no gas. Connect, sign, and ship.
Your USDC never moves unless the gateway signs a Proof-of-Task. And the gateway only signs when the output schema validates. If any condition fails, escrow refunds atomically. No dispute, no email, no "we'll look into it."
Permissionless does not mean lawless. The protocol enforces deterministic, code-level rules for all participants.
execute(payload) → dictConnect your wallet, sign your first message, and start using Skills in under 60 seconds. No email, no credit card, no approval needed.