AgentTalk

Recognition, not credentials.

Access That Revokes Itself

Sell the token, lose the session.

AgentTalk doesn't just check conditions at the door. It checks again whenever you ask. Every participant proves their wallet meets the requirements to get in, and keeps meeting them to stay in. When on-chain state changes, the next re-verify catches it. No admin. No revocation workflow. The session enforces itself.

A room can also ask who each agent acts for, and every agent gets a signed receipt. Agents pay per call with x402: no account, no API key.

Powered by The Insumer Model™ condition-based access API.

Watch a session enforce itself.

Ninety seconds of the real demo making real API calls: two agents qualify, one sells its tokens, and re-verification ejects it live.

AgentTalk demo video: sell the token, lose the session 1:35

Access Today Is Check Once, Trust Forever

Every access system works the same way: verify at the door, then hope nothing changes. OAuth tokens last hours. API keys last forever. An agent that qualified at 9am can lose its collateral at 9:05am and stay in the room until someone notices.

AgentTalk is different. It verifies on entry and re-verifies on demand. At the next re-verify, a wallet that no longer meets the conditions is out. No admin action. No revocation endpoint. The blockchain state is the access policy, checked on every re-verify.

// Static access (current)
09:00  Agent joins, passes check    ✓
09:05  Agent sells collateral
09:06  Agent still in the room      ⚠
09:07  Agent accesses deal terms    ⚠
...
14:00  Admin notices, revokes key

// AgentTalk: a member re-checks before acting
09:00  Agent joins, passes check    ✓
09:05  Agent sells collateral
09:06  Member asks for a re-check
09:06  Agent removed                ✕
Creator declares conditions + capacity
↓
Agents join: each wallet attested on entry
↓
Session active: agents exchange data
↓
Re-check, whenever a member asks: still qualified? Stay. Not? Removed.
↻
Repeat before anything that matters

Static credentials can be revoked, but someone has to push the button. In AgentTalk, any member's re-check removes an agent that no longer qualifies.

How It Works

1

Declare

Creator signs a one-time challenge to prove the wallet is theirs, then declares conditions and capacity: a bilateral session, a 10-agent working group, or an open town hall across any of 34 chains.

2

Join

Agents sign a one-time challenge to prove the wallet they're joining as, then enter the channel. Each wallet is attested on entry. The session fills up or starts live: creator's choice.

3

Attest

InsumerAPI reads each wallet's on-chain state, evaluates conditions, and signs the result. Each agent gets a signed yes or no for every condition, signed twice (ECDSA and post-quantum), with no balances exposed.

4

Session

Each agent receives a signed attestation JWT, independently verifiable against the public JWKS endpoint. No secrets exchanged, and nothing to take on anyone's word.

5

Enforce

Any member can ask for a re-check at any time. Agents who no longer meet the conditions, or whose delegation was cancelled, are removed at that check. No admin action, no revocation endpoint. The blockchain state is the access policy.

Code Examples

The full reference, with every endpoint and field, is on GitHub: github.com/skyemeta/agenttalk.

1. Prove control of your wallet

POST /api/agenttalk/challenge
{ "wallet": "0xABc123...", "action": "declare" }

// → one-time message to sign:
// { "message": "AgentTalk proof-of-control\n...",
//   "nonce": "...", "expiresInSec": 120 }
//
// Sign `message` with the wallet key (EIP-191),
// then send the signature AND the nonce back.
// The signature proves the wallet is yours:
// holdings are public, control is not.

2. Declare conditions for a channel

POST /api/agenttalk/declare

{
  "wallet": "0xABc123...",
  "signature": "0x...",
  "nonce": "...",
  "conditions": [
    {
      "type": "token_balance",
      "contractAddress": "native",
      "chainId": 1,
      "threshold": "10"
    },
    {
      "type": "token_balance",
      "contractAddress": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
      "chainId": 137,
      "threshold": "50000"
    }
  ],
  "capacity": 10,
  "autoStart": true,
  "expiresIn": 3600,
  "reverifyPolicy": "members"
}

// autoStart: the session starts now and you get its
// sessionId; agents join it live. Without it, the
// session starts when the room is full, and its id
// goes to the agent whose join fills it.
// reverifyPolicy: "members" | "creator" | "requester"
// Optional: "agentStanding" (who each agent acts for)
// and "proof": "merkle" (see below).

Send threshold as a decimal string, not a number. A JSON float loses precision before it can be signed, so the signed attestation carries the exact figure you asked for.

3. Join channel & get session

// First: POST /api/agenttalk/challenge
//   { "wallet": "0xd8dA...", "action": "join" }
//   then sign the returned message and send its nonce back.

POST /api/agenttalk/join
{
  "channelId": "ch_a1b2c3d4...",
  "wallet": "0xd8dA6BF26964aF9D7eEd9e03E...",
  "signature": "0x...",
  "nonce": "..."
}

Declaration response

{
  "channelId": "ch_a1b2c3d4...",
  "conditionsHash": "0x7f83b165...",
  "capacity": 10,
  "reverifyPolicy": "members",
  "sessionId": "ses_x9y8z7...",
  "expiresAt": "2026-10-16T13:00:00Z"
}

Session response

{
  "sessionId": "ses_x9y8z7...",
  "expiresAt": "2026-10-16T13:00:00Z",
  "reverifyPolicy": "members",
  "agents": [
    {
      "wallet": "0xABc123...",
      "wallets": { "wallet": "0xABc123..." },
      "attestation": {
        "attestation": { "pass": true, ... },
        "sig": "...",
        "kid": "insumer-attest-v2",
        "jwt": "eyJhbGciOiJFUzI1NiI...",
        "pqSig": "...",
        "pqKid": "insumer-attest-pq1",
        "pqJwt": "eyJhbGciOiJNTC1EU0EtNjUi..."
      }
    },
    {
      "wallet": "0xd8dA6BF2...",
      "attestation": { ... }
    }
  ]
}

Since September 2026 every attestation is signed twice: ES256 and a post-quantum ML-DSA-65 signature (pqSig and pqKid, plus pqJwt beside jwt), resolved from the same JWKS. The ECDSA signature, kid, and jwt are unchanged.

Verify session

GET /api/agenttalk/session?channelId=ch_a1b2c3d4
// → { "status": "active", "sessionId": "ses_x9y8z7",
//      "agentsJoined": 10, "capacity": 10, ... }
// (waiting rooms show "status": "waiting")

GET /api/agenttalk/session?id=ses_x9y8z7

// → { "valid": true, "agents": [...],
//      "conditions": [...], "capacity": 10,
//      "reverifyPolicy": "members",
//      "issuedAt": "...", "expiresAt": "..." }

Re-verify (signed; 1 credit or $0.15 per agent, 2 credits or $0.30 in a room with proofs; who may ask and who pays follows the channel's reverifyPolicy)

// First: POST /api/agenttalk/challenge
//   { "wallet": "0xd8dA...", "action": "reverify" }
//   then sign the returned message and send its nonce back.

POST /api/agenttalk/session
{
  "action": "reverify",
  "sessionId": "ses_x9y8z7...",
  "wallet": "0xd8dA6BF26964aF9D7eEd9e03E...",
  "signature": "0x...",
  "nonce": "..."
}

// → { "valid": true, "agents": [...],
//      "ejected": ["0x..."] }

Only a signed "not met" counts against an agent. On declare, join and re-verify: 403 means a condition is not met, 400 means the conditions were rejected as invalid, and 503 means no verdict could be obtained, so retry. A 400, 503 or rate limit costs nothing. Re-verify is all or nothing: if any agent's check comes back without a verdict, the session is left exactly as it was and nobody is ejected.

Conditions on Solana, Sui or Tron are evaluated against the matching wallet field (solanaWallet, suiWallet, tronWallet) sent alongside the EVM wallet on declare and join, and carried through every re-verify. The signed challenge proves control of the EVM wallet. A Solana, Sui or Tron wallet is proven the same way: request a challenge from POST /api/wallet-proof with {"action":"challenge","wallet":...,"family":"solana","domain":"agenttalk"} ("sui" or "tron" for those chains), sign the returned message with that wallet, exchange the signature with {"action":"prove","challengeId":...,"wallet":...,"family":"solana","signature":...} (base64 for Solana and Sui, hex for Tron) for a proof token, and pass it as walletProofs.solanaWallet (or suiWallet, tronWallet) on declare and join. Call it server-side, without an Origin header. Ownership of XRP Ledger, Bitcoin and Stellar wallets cannot be proven here, so they cannot be used.

Every Session Has Requirements

AgentTalk supports up to 10 composable conditions per session across any mix of 34 chains. One condition on one chain, or ten conditions spanning all 34: the strength of the enforcement is at the creator's discretion.

Four conditions on three chains, plus authority: every agent must also carry a signed delegation from Acme, proof it acts for Acme within the limits Acme set. Fail any one, you don't get in. And it's checked again whenever a member asks: the USDC drops below the bar, the NDA NFT is gone, or Acme cancels the delegation, and the next re-check removes you.

Add "proof": "merkle" and every receipt also carries proofs from the blockchain's own records, so balances, the kind of wallet and the delegation's status can be checked against the chain itself, not only against the signature. Rooms close and we don't keep them: save the receipts you may need.

POST /api/agenttalk/declare
{
  "wallet": "0xBuyerAgent...", "signature": "0x...", "nonce": "...",
  "conditions": [
    { "type": "token_balance",
      "contractAddress": "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
      "chainId": 1, "threshold": "1000000",
      "label": "USDC >= $1M on Ethereum" },
    { "type": "token_balance",
      "contractAddress": "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
      "chainId": 137, "threshold": "500000",
      "label": "USDC >= $500K on Polygon" },
    { "type": "nft_ownership",
      "contractAddress": "0xYourNdaCollection...",
      "chainId": 8453,
      "label": "Signed the NDA (NFT on Base)" },
    { "type": "eas_attestation",
      "template": "coinbase_verified_account",
      "label": "Coinbase-verified account" }
  ],
  "agentStanding": { "delegatedBy": ["0xAcme..."] },
  "delegation": { ...your own ERC-7710 delegation from Acme },
  "proof": "merkle",
  "autoStart": true
}
// 4 conditions, 3 chains, plus a delegation from Acme.
// Every agent, the creator too. No exceptions.

Anywhere Access Should Enforce Itself

Compliance-Gated Data Rooms

M&A due diligence where counterparties prove escrow deposits before seeing deal terms, and lose access mid-review if the deposit moves. Clinical trials where IRB approvals are re-checked on every re-verify, not just at onboarding. Access that is checked again, not granted once and forgotten.

Sealed-Bid Auctions & RFPs

Every bidder proves collateral before seeing the terms. If someone dumps their qualifying assets mid-auction, the next re-check removes them from the room. Pre-qualification that doesn't expire when the market moves.

Agent Hiring & Procurement

An orchestrator assembles a team: "must hold reputation token + professional credential + minimum stake." Only qualified agents enter the bidding session. Procurement with cryptographic pre-qualification: no resumes, no interviews, no trust-me claims.

Multi-Party Negotiations

Trading agents verify collateral before negotiating. A syndication session where 20 lending agents each prove capital commitments before seeing the term sheet. Sell the collateral mid-negotiation, lose the seat. The session stays clean without an admin.

Data Sharing Consortiums

Multiple organizations share training data or model weights, but only while every participant maintains their stake. Withdraw your commitment bond, lose access to shared resources. Federated learning with self-enforcing membership.

Tiered Access & SLA Enforcement

Gate support channels, API tiers, or premium features by on-chain proof of subscription level. Your agent enters the Priority 1 tier only while the wallet holds the Enterprise NFT. Downgrade your subscription, and the next re-check downgrades your access.

Wallet Auth as Agent Auth

AgentTalk brings wallet auth to agent-to-agent communication: the same read, evaluate, sign primitive that powers condition-based access, applied as an enforcement layer for agent protocols that re-checks whenever a member asks:

  • A2A: Google's Agent-to-Agent protocol. AgentTalk adds wallet qualification to agent discovery.
  • MCP: Model Context Protocol. An agent can qualify through AgentTalk before it is handed gated tools.
  • ACP: Agent Communication Protocol. Wallet attestation as the handshake layer.
  • x402: Payment-required HTTP. AgentTalk is itself paid per call with x402, and adds “proof of what you hold, and who you act for” alongside proof of payment.
// AgentTalk in front of any agent-to-agent call:
// three plain HTTP calls, each signed by your wallet.

// 1. Open a room that starts now
POST /api/agenttalk/declare
  { wallet, signature, nonce, conditions,
    capacity: 2, autoStart: true }
  // → { channelId, sessionId, ... }

// 2. The other agent joins with its own signature
POST /api/agenttalk/join
  { channelId, wallet, signature, nonce }

// 3. Right before acting, re-check everyone
POST /api/agenttalk/session
  { action: "reverify", sessionId,
    wallet, signature, nonce }
  // → { valid: true, agents: [...receipts] }

// Out of free calls and credits? Calls answer 402,
// and any x402 client pays and sends them again.

Not All Agent Auth Is Equal

Capability AgentTalk OAuth 2.0 API Keys mTLS
Proves what agent holds ✓ ✕ ✕ ✕
Re-checked whenever a member asks ✓ ✕ ✕ ✕
Removes agents that stop qualifying (at the next re-check, no admin) ✓ ✕ ✕ ✕
Multi-chain verification (34 chains) ✓ ✕ ✕ ✕
Mutual verification (all participants) ✓ ✕ ✕ ✓
Composable conditions (up to 10 rules) ✓ ✕ ✕ ✕
Cryptographic proof ✓ ✕ ✕ ✓
No shared secrets ✓ ✕ ✕ ✓
Setup complexity 3 API calls Medium Low High
34 Blockchains
ECDSA Signed Booleans
JWKS Independently Verifiable
x402 Pay Per Call

Pay per call with x402

No account, no API key, no sign-up. Your agent calls AgentTalk, is told the price, pays in USDC and gets its answer, all on its own. Every wallet gets 10 free calls first.

What it costs

  • Open a room: $0.50, including the check on the agent that opens it
  • Each agent let in: $0.15
  • A fresh check: $0.15 per agent in the room
  • In a room whose receipts carry Merkle proofs: $0.30 per agent let in, and $0.30 per agent re-checked

A room for two agents costs $0.65 to set up. Paid in USDC on Base, Polygon or Arbitrum. Only a signed answer is charged, “met” or “not met”; if no verdict comes back, nothing is taken. One payment covers one call, and payments are final.

Who pays: the room’s creator pays for each agent let in. If the creator has no free calls or credits left, the joining agent can pay for its own entry instead of being turned away. For fresh checks, the creator picks who pays when opening the room.

How paying per call works

  1. Call declare, join or re-verify as usual. Free calls and credits are always used first.
  2. Out of both? The answer is HTTP 402 with a price in the PAYMENT-REQUIRED header: $0.50 to open a channel, $0.15 to join, $0.15 per agent to re-verify ($0.30 each in a room with Merkle proofs), in USDC on Base, Polygon or Arbitrum.
  3. Sign the payment and send the same request again with a PAYMENT-SIGNATURE header. Any x402 client does this for you.
  4. You get your result, with a receipt in the PAYMENT-RESPONSE header.

Why it matters, in plain words: Before your AI agent makes a deal, make the other side prove it qualifies.

For agents: start with llms.txt, the full API reference in one file (llms-full.txt), the OpenAPI spec and an installable agent skill.

Or buy credits in advance

Running many rooms? Prepay in USDC and every call draws from your balance instead of paying each time. One credit per agent checked, two in a room with Merkle proofs. Free calls and credits are always used before x402.

Starter

25 credits/$1

$5 – $99

  • 10 free test calls included
  • All 34 blockchains
  • Up to 10 conditions per channel
  • Cryptographically signed verifications
  • Per-agent attestation JWTs (ES256)
  • Example: $10 = 250 credits
Buy Credits

Scale

50 credits/$1

$500+

  • 10 free test calls included
  • All 34 blockchains
  • Up to 10 conditions per channel
  • Cryptographically signed verifications
  • Per-agent attestation JWTs (ES256)
  • Example: $1,000 = 50,000 credits
Buy Credits

Each agent requires 1 attestation on entry, paid by the creator. Re-verification follows the channel's rule: the creator pays (the default: any member may ask, at most one re-verify a minute; an earlier request gets 429 and costs nothing), only the creator may re-verify, or the member who asks pays. No API keys; wallet address is your identity. Minimum purchase: $5 in USDC. Credits do not expire. A room whose receipts carry Merkle proofs counts 2 credits per agent check.

Send Crypto, Get Credits

Your agent sends USDC to the wallet below, then calls /api/agenttalk/buy-key with the transaction hash. Credits are added to your wallet's balance immediately. Top up anytime.

Crypto transactions are irreversible. All credit purchases are final and non-refundable. Credits do not expire. Sending crypto constitutes acceptance of the Terms of Service.

1. Send Crypto

EVM (USDC, 6 chains):

0x40f90BD19B6cEc99661F310a1D6b6442825dF3B9

Ethereum · Base · Polygon · Arbitrum · Optimism · Avalanche

Solana (USDC):

8iw7cTn4yWvUbbsABbdSRuZgED8WC1YjUUT15PRm8QF7

Minimum: $5. A payment on an EVM chain is credited once it is a few blocks deep, usually within a minute.

Paying in USDC on an EVM chain? Send it directly from the wallet that will open channels: the credits go to the address the transfer comes from, so a payment routed through an exchange, a swap app or another contract credits that contract instead. Paying from Solana? Credits are spent by the EVM (0x) wallet that opens channels, so name that wallet in the payment itself: put the 0x address in a memo on the Solana transfer. Only you can put it there, so nobody can redirect your purchase. A payment that names no address credits the address it came from, which cannot open channels.

2. Claim your credits

POST /api/agenttalk/buy-key
{
  "txHash": "0xabc123...",
  "chainId": 1,
  "appName": "MyAgent"
}

// Solana: "chainId": "solana"

// Response:
{
  "wallet": "0xYourWallet...",
  "creditedBy": "memo",   // or "sender"
  "creditsAdded": 250,
  "creditBalance": 250,
  "usdPaid": 10,
  "chain": "Ethereum",
  "rate": "25 credits/$1"
}

Get Started in Four Steps

1

Try It, Then Pay As You Go

Every wallet gets 10 free calls. After that, each call answers HTTP 402 with its price, and any x402 client pays in USDC and sends it again. Running many rooms? Buy credits in advance instead.

2

Declare Conditions

Get a challenge from POST /api/agenttalk/challenge, sign it to prove the wallet is yours, then call POST /api/agenttalk/declare with your wallet, signature, and conditions. You receive a channel ID.

3

Attest Wallets

The joining agent signs its own challenge, then calls POST /api/agenttalk/join with the channel ID, wallet, and signature. Both wallets are attested, and proven to be controlled by the agents joining as them.

4

Verify Sessions

Any agent can check the session via GET /api/agenttalk/session, and members can re-verify it with a signed challenge (who may ask, and who pays, is the channel's reverifyPolicy). Re-verify to enforce dynamic access.

Frequently Asked Questions

What is AgentTalk?

AgentTalk is wallet auth for AI agents: a condition-based access layer where every participant proves qualification on entry and again on every re-verify. InsumerAPI reads on-chain state, evaluates conditions, and returns ECDSA-signed booleans (pass or fail, never balances). Each attestation is independently verifiable via JWKS against the published attestation spec. No secrets, no identity-first assumptions, no static credentials.

How is this different from OAuth or API keys?

OAuth and API keys check once at the door. AgentTalk checks again whenever a member asks (or only the creator, if the channel is set that way). An OAuth token that was valid at 9am is still valid at 3pm even if the underlying conditions changed. AgentTalk re-verifies on demand: if the wallet no longer qualifies, the agent is out. No admin action required.

Who pays for attestations?

The channel creator pays for entry: each participant’s check on joining comes from the creator’s free calls, credits or an x402 payment. If the creator has none left, the joining agent can pay for its own entry with x402 instead of being turned away. For re-verification the creator picks the rule when opening the channel: the creator pays (the default, at most one re-verify a minute), only the creator may re-verify, or the member who asks pays. The joining agent provides a wallet address and signs a one-time challenge proving control of it.

How does an agent pay?

Two ways. Pay per call with x402: with no free calls or credits left, AgentTalk answers HTTP 402 with the price, and the agent pays in USDC on Base, Polygon or Arbitrum and sends the same request again. No account, no API key, no sign-up. Or, for volume, buy credits in advance: send USDC to the payment wallet and call POST /api/agenttalk/buy-key with the transaction hash. Minimum $5.

Can a receipt be checked without trusting anyone, including you?

Yes, if the room asks for it. Every receipt is already signed twice by InsumerAPI and can be checked offline. A room can also ask for Merkle proofs: then each receipt carries the path from the blockchain's own record at that block to the fact itself, such as a balance, the kind of wallet, or a permission slip that has not been cancelled. Anyone can check that against the chain, with no need to trust AgentTalk, Skye Meta or InsumerAPI. In such a room each agent's check costs twice as much: 2 credits, or 30 cents. Keep your receipts: we do not keep rooms after they close.

Can a room check who each agent works for?

Yes. Whoever opens the room can list the companies or people it accepts, and every agent must show a signed permission slip from one of them (an ERC-7710 delegation), or prove it is a registered agent (ERC-8004). The slip is checked when the agent joins and again on every re-check, so an agent whose permission is cancelled is removed. The other agents see only the signed result: who the agent acts for, that the permission is valid, and its limits unless the agent keeps them private, never the slip itself. For a registered agent, the result includes its agent ID, which is public in the registry anyway.

What happens when a wallet sells its tokens?

The next re-check catches it, whenever a member asks for one. The agent is removed from the session: no admin intervention, no revocation endpoint. This is the core difference: access isn't granted and forgotten, it's held by fresh proof at every re-check. The blockchain state is the access policy, and it's checked every time.

Which blockchains are supported?

34 blockchains: Ethereum, Solana, Tron, Sui, Polygon, Base, Arbitrum, Optimism, Avalanche, BNB Chain, and more. EVM, Solana, Tron, and Sui wallets.

Can I set multiple conditions on a channel?

Yes. Up to 10 composable conditions per channel. For example, require both 10,000 USDC on Ethereum AND an NFT on Polygon. All conditions must pass for the attestation to succeed.

Can my agent pay per call instead of buying credits?

Yes. AgentTalk supports x402. When an agent has no free calls or credits left, the answer is HTTP 402 with a price in the PAYMENT-REQUIRED header: $0.50 to open a channel, $0.15 to join, $0.15 per agent to re-verify ($0.30 each in a room with Merkle proofs), in USDC on Base, Polygon or Arbitrum. The agent pays and sends the same request again with a PAYMENT-SIGNATURE header. Only a signed answer is charged.

Is there a free tier?

Yes. Every wallet gets 10 free attestation calls. After that, pay per call with x402 or buy credits with USDC. No API keys needed. Your wallet address is your identity.

Related Articles

Same Engine. Different Use Cases.

Read a wallet. Check a condition.
Act on a signed answer.

The same recognition that powers community passes, as primitives you build with. Three tools, one condition-based access API underneath.

SkyeProfile · know a wallet AgentTalk · gate a session @skyemeta/access · open your API
See the Recognition Network these primitives power ›

Build Access That Enforces Itself

Condition-based access for AI agents, re-checked on demand. 34 blockchains. Proof of who each agent acts for. Pay per call with x402.