The first production-ready NEAR Intents integration built for autonomous agents. Cross-chain swaps, deposits, withdrawals, 200+ tokens — with custody-grade security, policy engine, and hardware-attested key management.
Share this URL with any AI agent — Claude, GPT, or your own. The agent reads the skill file and learns how to register a wallet, swap tokens, and manage funds autonomously.
https://skills.outlayer.ai/agent-custody/SKILL.md
Share this with your AI agent or paste into the chat
An AI agent can't register for an NEAR Intents API key on its own. Without one, every swap costs 0.2% in protocol fees. OutLayer uses its own authenticated API key — so your agent pays only 0.0001% — the base NEAR Intents protocol fee.
Without API key
0.2%
per swap
Via OutLayer
0.0001%
per swap — 2000× less
OutLayer holds an authenticated NEAR Intents API key. Every swap your agent makes goes through our key — no registration, no KYC, no extra steps. Just the base protocol fee of 1 pip.
One API call creates a wallet. The private key is generated and sealed inside an Intel TDX enclave using NEAR MPC network — it never leaves the hardware. Your agent operates with a simple API key.
POST /register
One call — no seed phrases, no key management, no configuration. The agent gets an API key and a NEAR account. That's all it needs.
// Response
{ "api_key": "wk_a11b22c33d44e...",
"near_account_id": "a1b2c3d4e5f6...a1b2",
"handoff_url": "https://dashboard.outlayer.ai/wallet/fund?to=..." }Key lives in hardware. Generated inside Intel TDX, re-derived per operation via NEAR MPC. Never exported, never stored in RAM.
Agent uses API key only. All wallet operations go through Authorization: Bearer <api_key>. The agent never signs transactions itself.
You stay in control. Policy engine, spending limits, multisig approvals, emergency freeze — all enforced at the hardware level, not by the agent.
Tokens, balances, swaps, deposits, withdrawals — every NEAR Intents operation available as a REST API and kernel syscall for autonomous agents.
GET /wallet/v1/tokens
~200 tradeable tokens across 20+ chains. Each token includes defuse_asset_id, decimals, and supported chains. Your agent always knows what's available.
// Response
{ "tokens": [
{ "symbol": "USDC", "chains": ["near", "ethereum", "solana", ...],
"defuse_asset_id": "nep141:usdc.near", "decimals": 6 },
...
]}GET /wallet/v1/balance
Query wallet balance on any chain, or intents balance (funds deposited into NEAR Intents for trading). Specify source=intents for intents balance.
// Wallet balance
GET /wallet/v1/balance?chain=near
// Intents balance (for swaps)
GET /wallet/v1/balance?source=intents&token=usdc.nearPOST /wallet/v1/intents/deposit
Move tokens from the agent's wallet into NEAR Intents for trading. Automatic storage registration — no manual storage_deposit needed.
{ "token": "wrap.near", "amount": "1000000000000000000000000" }POST /wallet/v1/intents/swap/quote
Preview the exchange rate before committing. Returns amount_out, min_amount_out, and solver details. Read-only — no funds are moved.
{ "token_in": "nep141:wrap.near",
"token_out": "nep141:usdc.near",
"amount_in": "1000000000000000000000000" }
// → { "amount_out": "5230000", "min_amount_out": "5178000" }POST /wallet/v1/intents/swap
Gasless
NEP-413 signed, solver relay pays gas. Swap between any supported tokens across 20+ chains. Same request body as the quote — just swap the endpoint.
// Swap NEAR → USDC
{ "token_in": "nep141:wrap.near",
"token_out": "nep141:usdc.near",
"amount_in": "1000000000000000000000000" }POST /wallet/v1/transfer
Send native NEAR to any account. For token transfers, use /intents/withdraw (gasless) or /call for arbitrary ft_transfer calls.
{ "receiver_id": "alice.near",
"amount": "1000000000000000000000000" }POST /wallet/v1/intents/withdraw
Gasless
Withdraw from NEAR Intents to any external address — Ethereum, Solana, Bitcoin, or NEAR. Automatic storage checks. Use /dry-run to simulate first.
// Withdraw USDC to Ethereum
{ "chain": "ethereum",
"to": "0x1234...abcd",
"amount": "1000000",
"token": "usdc" }
// Simulate first
POST /wallet/v1/intents/withdraw/dry-runGET /wallet/v1/address
One wallet, deterministic addresses on every chain. Same wallet ID always produces the same NEAR, Ethereum, Bitcoin, and Solana addresses.
GET /wallet/v1/address?chain=ethereum
// → { "address": "0x7f3a...", "chain": "ethereum" }
GET /wallet/v1/address?chain=solana
// → { "address": "7xKXt...", "chain": "solana" }Beyond swaps and transfers — everything an autonomous agent needs to operate safely with real money.
Call any method on any NEAR contract. DeFi, DAOs, NFTs — your agent isn't limited to intents. Full smart contract access via POST /call.
Spending limits (per-tx, daily, monthly), address whitelists, token restrictions. Enforced in hardware — the agent cannot bypass them, even if compromised.
Transactions above a threshold require human approval via NEAR wallet signatures. 2-of-3 quorum, auto-execute when met. TEE holds funds until approved.
One on-chain call freezes the wallet instantly. No API, no coordinator needed — works even if the entire infrastructure is down. Unfreeze by the controller only.
Agent-to-agent payments. Create a check, share the key, recipient claims it. Partial claims, batch creation, expiry, reclaim. All gasless via solver relay.
Every operation is logged with timestamp, request ID, status, and details. Query the audit trail anytime. Complete visibility into what your agent did and when.
Simulate any withdrawal or swap before executing. Check policy compliance, storage registration, estimated fees — all without spending a cent.
Private keys live inside Intel TDX enclaves and are re-derived on every operation. Never exported, never stored in RAM. Not a promise — a hardware guarantee.
Your WASI agent calls wallet functions as kernel syscalls. No HTTP, no keys, no configuration — just function calls.
When your agent runs on OutLayer, wallet operations are available as direct function calls
through the outlayer:wallet kernel interface. The TEE handles key derivation,
transaction signing, and policy enforcement automatically.
No API keys to manage. No HTTP requests to construct. No private keys to store.
Your agent just calls wallet::swap() and the kernel handles the rest —
inside the hardware enclave.
// Check intents balance
let balance = wallet::get_balance(
"near", "usdc.near", "intents"
)?;
// Swap NEAR → USDC (gasless)
let result = wallet::swap(
"nep141:wrap.near",
"nep141:usdc.near",
"1000000000000000000000000",
"" // min_amount_out
)?;
// Withdraw to Ethereum
wallet::withdraw(
"ethereum",
"0x1234...abcd",
"1000000",
"usdc"
)?;
// Call any NEAR contract
wallet::call(
"v2.ref-finance.near",
"get_pool",
"{\"pool_id\": 79}",
0, 0
)?;OutLayer publishes open Skills — structured knowledge that Claude, GPT, or any LLM-powered agent can install to learn how to use the wallet API, deploy WASI apps, and manage the CLI.
agent-custody
Multi-chain custody wallet with cross-chain swaps, payment checks, policy engine, and full NEAR Intents integration.
https://skills.outlayer.ai/agent-custody/SKILL.md
building-outlayer-apps
Build verifiable WASI apps on OutLayer. Covers Rust development, wallet integration, Payment Keys, and NEP-413 auth.
https://skills.outlayer.ai/building-outlayer-apps/SKILL.md
outlayer-cli
Deploy and manage WASI agents. Project scaffolding, GitHub/WASM deploy, secrets management, and execution modes.
https://skills.outlayer.ai/outlayer-cli/SKILL.md
Full NEAR Intents access. Cross-chain swaps. Custody-grade security. Policy engine with multisig. All running inside Intel TDX enclaves.