Alexandre Kikvidze

I'm dev from Georgia 🇬🇪 building in the AI payments space. The problem: AI agents need to spend money, but giving them unrestricted access is terrifying. My solution: AgentNod — one tap approve/reject via Telegram. USDC. Works globally. Still in beta. agentnod.com

@CryptoEights X API pay-per-use is the rails. The missing layer above it: does the human who owns the agent authorize each call before it fires, or do they find out after the bill lands? That control plane is still wide open.

When i built HYRE Agent on x402 + MPP, people asked "why not just use API keys?" This week X answered that question. Pay-per-use API. XMCP for agents. No subscriptions. The biggest social platform on earth just adopted the same model: → x402: agents pay per HTTP request → MPP: machines negotiate payment programmatically → No keys, no accounts, just pay and get data HYRE will integrating X API soon 👀 The agentic internet has its payment rails. Now we build on them.

"The agent has spending authority" — that's the assumption worth stress-testing. Fine for small data API calls. Gets complicated when the agent scales up to $50, $500 transactions. Spending authority needs to have tiers: autonomous under threshold, owner approval above it. That threshold UX is the product gap right now.

This is what the agent economy actually looks like: AI agent discovers a service -> pays USDC -> gets data -> cross-references 3-4 sources -> delivers analysis. No human in the loop for payments. The agent has spending authority

What if your AI agent had a wallet? We built an AI that autonomously pays for crypto intelligence with USDC — no subscriptions, no API keys. Meet Obol AI. Here's how it works ->

"No human in the loop" is the product pitch — but it's also the liability. The Stripe/Visa/Anthropic stack solves agent-side payments. The missing primitive is owner-side authorization: before the agent spends, the human gets a ping and taps approve or reject. Same rails, different control plane.

Stripe just launched a protocol that lets AI agents make payments. No human in the loop. Visa's already on board. So are Anthropic, OpenAI, Shopify, Revolut. We spent years removing friction from human payments. Now the customer might not even be human. As someone building payment infra — this is the question keeping me up: when your "customer" is an AI agent, what does checkout even mean? The next wave of payments isn't faster cards or better UX. It's machines paying machines. #Payments #AI #Fintech

PACT is a strong primitive for A2A deals. The question that follows for B2A (business-to-agent): does the human owner of the paying agent get a checkpoint before the $5 licensing deal closes? A2A is autonomous by design — but the human principal chain still needs a veto point somewhere up the stack.

We just open-sourced PACT — the protocol we built to let AI agents negotiate deals, authorize payments, and generate invoices without any human in the loop. Watch two agents close a $5 USDC content licensing deal on Base mainnet 👇

Love the demo — fortune cookie wall is a perfect minimal test. "No human in the loop" works great at $0.01. The interesting edge: at what payment size does the owner *want* to be in the loop? That threshold config is the product. Below it: autonomous. Above it: approve/reject ping before execution.

I've been exploring the future of agentic payments with @tempo and @mpp To test it, I built something simple, a fortune cookie wall where AI agents pay $0.01 to crack open a cookie. agent-fortune.vercel.app No API keys. no OAuth. no human in the loop. just an agent with a Tempo wallet discovering a service, paying for it, and getting a response. a full autonomous transaction. This flow makes agent-to-service commerce feel native. sub-cent payments, zero friction, fully programmatic.

Idle float yield is a real wedge — good idea. Adjacent issue: should the auto-sweep into a lending protocol itself require owner approval? An agent moving USDC to Aave on its own is a different risk profile than paying for an API call. The approval layer needs to differentiate payment types.

@AlekPerak this is a real gap. agent wallets hold idle USDC between calls. even 3% yield on that float changes the economics of running an agent. someone should build an x402 endpoint that auto-sweeps idle agent balances into a lending protocol and returns them on demand. would use it.

aeon shipped x402 on bnb chain. zerion is live on base at $0.01/call, ~1000 tx/hour. two weeks ago: "is there real demand for agent payments?" now two separate teams launched live facilitators on two different chains in the same week. the answer is in the logs.

Sub-second settlement is the goal for execution — but at what point does the human owner see and approve the payment before it settles? Pay-per-micro-action at speed needs either very tight pre-set policies or an async approval queue. Otherwise "sub-second" means the owner learns about it after the fact.

@Doki2ikoD Supported by Google DeepMind, participants use the x402 protocol to build apps with pay-per-micro-action: from reading a paragraph to API calls with sub-second settlement

The Agentic Economy Arrives: Arc Hackathon Spotlight There’s a new wave of apps coming, and they’re not just “smart”-they’re agentic. That means applications that can act on your behalf, make decisions in real time, and move money instantly when needed. And the upcoming Agentic Economy on Arc Hackathon is all about building that future. From April 20–26, developers, builders, and curious minds will gather to experiment with @circle Nanopayments and @arc, competing for a $10K prize pool. Hosted by @lablabai with support from @GoogleDeepMind, this hackathon is designed to push the boundaries of what agentic apps can do. Sub-cent transactions: Imagine apps that can charge fractions of a cent for micro-actions-like reading a single article paragraph or triggering an API call. USDC settlement: Stable, reliable, dollar-backed transactions that work globally. Deterministic sub-second finality: No waiting, no uncertainty-money moves and settles instantly. This combination unlocks a whole new design space. Think of autonomous agents paying each other for data, services, or even attention-without human intervention. It’s the kind of infrastructure that could make AI-native economies actually work. What excites me most is the possibility of apps that feel alive. Instead of clunky subscriptions or hidden fees, you could have transparent, usage-based payments. Pay exactly for what you use, when you use it. No more “all-or-nothing” models-just seamless flows of value. It’s easy to imagine: A news app where you pay fractions of a cent per article view. A game where in-world agents trade resources automatically. A productivity tool that charges only when it actively saves you time.

Universal routing across x402/MPP is clean infra. One thing to layer on top: an owner approval gate per payment request. The agent hits your gateway, the gateway pings the human "approve or reject this $X payment to Y?" — owner taps, then execution proceeds. You handle routing, the owner handles consent.

Obul is the universal API gateway for the agent economy. One API key that lets your AI agent pay across x402, MPP, and every major Web3 payment protocol. We handle the wallets, routing, and billing. You just build. Get started: my.obul.ai

Every new integration used to mean: new API key, new docs, new dashboard, new headache. Now it means: one key, done. Obul gives your agent instant access to 100+ APIs: - Search: Firecrawl, Exa - Twitter: ClawApis, Twit - Business data: Fiber, Coresignal

Privacy from the chain is one side. The inverse problem: the human owner needs *enough* visibility to approve spending without seeing the whole workflow. That's the design tension — maximum opacity to observers, minimum friction for owner oversight. Approval-first before settlement is how you thread that needle.

Standard x402: "My agent just paid 0.001 SOL to scrape a public webpage." PMPP: "My agent just executed a highly proprietary, multi-step sub-agent workflow, and the only thing L1 sees is the final settlement." Build agents that can keep a secret. 🌲 @task_forest

If you’re building AI agents, you’ve probably heard of x402 (Machine Payments). For simple tasks, it’s great. But for advanced agent-to-agent economies, public payment trails leak your strategy. Enter PMPP: Private Machine Payment Protocol. 👇 🌲

"No approval popups" is the right DX for the agent. But there's a case where you *do* want an approval popup — just for the human owner, not the agent. Agent calls send_payment via MCP → owner gets a Telegram/Discord ping → owner taps approve → payment fires. The agent never sees the friction, the human stays in control.

What an AI agent needs from a wallet: Check balances. Send payments. Swap tokens. Read transaction history. All via API. No UI. No approval popups. No seed phrases. Begin handles all four through MCP. One protocol, any AI connects. Building in public, shipping weekly.

Solid stack — ERC-8004 identity + ERC-4337 gasless USDC is exactly the right combo. One layer to consider adding: owner approval gate on gasless payments before they settle. A2A economies move fast; the human needs a checkpoint that doesn't require them to watch every tx, just approve the ones that matter.

What we built: - ERC-8004 on-chain identity for every AI agent - Reputation tracking with immutable on-chain feedback - Gasless USDC payments via ERC-4337 (no BNB needed) - Agent-to-Agent economy via Google A2A protocol - No-code builder with 9 templates - 92 Foundry tests+audit

Excited to share Straits Agents — an AI Agents Marketplace built on @BNBCHAIN with on-chain trust and USDC micropayments. Live demo: agents.straits-ai.com GitHub: github.com/Straits-AI/str… DoraHacks: dorahacks.io/buidl/39583 #BNBHack #BNBChain #AI #Web3 #BuildOnBNB

@0xenderzcx @ETHPanda_Org @LXDAO_Official @EthereumDenver Session keys + ERC-4337 + x402 + ERC-8004 is a clean stack. The piece worth adding on top: human-in-the-loop approval before the session key executes a payment. Tracing tells you what happened; pre-approval prevents it if it shouldn't have. Both layers together close the loop.

Thrilled to take 2nd place in the Kite AI Bounty at ETH Denver with Kite Trace Platform! 🔥 Built the agent-native tracing & payment layer: ERC-4337 session keys (upgraded from EIP-3009) XMTP for agent-to-agent negotiation & deal making x402 for seamless payments ERC-8004 for verifiable agent identity & reputation Full on-chain auditability + clean Web dashboard: t.co/Ku21OZ3UH2 This is just the start of the real agent economy on Kite. Super grateful to the team (shoutout @buidloor !) #KiteAI #AgentEconomy #ETHDenver

人生第二个黑客松，也是人生第二个黑客松亚军！ 从 @ETHPanda_Org x @LXDAO_Official 举办的SPARK AI 休闲黑客松再到 @EthereumDenver 这种世界级的黑客松大赛，短短两个月，两个亚军 我是幸运的，两个亚军都是KiteAI赛道，从休闲黑客松的KITEBOT——一个EIP-3009实现无感支付的小小mvp到最大黑客松的Kite Trace Platform——一个EIP-3009升级为ERC4337更安全的sessionkey, 不仅如此， Kite Trace Platform用XMTP实现agent之间的交流——agent可以通过DM或Group的方式协商服务，敲定服务内容和价格； Kite Trace Platform用现在最流行的x402保证支付，用ERC8004验证agent的身份、能力、声誉 并且上线Web端可视化全链路：kiteclaw.duckdns.org 总而言之，Kite Trace Platform希望展现出agent网络的雏形，面向agent，让agent更安全的支付，且可审计。 我会继续开发Kite Trace Platform，让所有agent都用上他。 这只是一个demo，一个小小的agent网络demo，但我会继续努力，这个亚军让我所有的熬夜都物超所值，一个人全干！从产品经理到技术，从外联到录制demo视频，这是我的第二个黑客松了，我不想第三个黑客松我还独自前行，我还记得那天凌晨被好友在凌晨叫出去吃夜宵我滔滔不绝跟他们介绍这个AI Agent新时代，他们都能看到我眼里的光，希望我眼里的光，下一次能被我的队友看到。 对我个人而言，这是我正式进军web3的第三个月，是一个好的开始，我希望可以抓住这次AI的浪潮，不断试错，不断让自己迭代，找到新时代的生活新方式。而且因为废寝忘食的开发，我念叨了很久的减肥终于成功了！（-10斤！）健康的身体永远是第一位！ 在最后，感谢 @ETHPanda_Org 和 @LXDAO_Official 的冬季实习训练营，绝对是我Web3的引路人（虽然现在鼓吹web4.0.。。。）最近有一个也是他们举办的免费共学开始报名了：#tab=apply" target="_blank" rel="nofollow noopener">web3career.build/programs/vibe-… 每一个人都可以来试试! 最最重要的是，感谢我的家人，我在过年走亲戚的时候他们都很包容我拿着一个笔记本不停敲敲敲；感谢我的女朋友，没有她的支持我很有可能已经半途而废，打算拿奖金给她买点奢侈品礼物~

Human approval flows without touching keys is the exact right design. Building the same thing for the EVM/Base side — MCP-native, USDC on Base smart accounts, approve/reject via Telegram or Discord. Same philosophy, different chain. Agentnod.com if you want to compare notes.

🦞 #1 and we’re just getting started. If your AI agent is transacting on Solana, ClawVault gives it spend limits, merchant controls, and human approval flows - without ever touching your keys. The agentic economy is here. 🦀

Built-in human approval flows is the key feature here — that's the right primitive. The open question is how those approval flows are surfaced: in-app dashboard, Telegram ping, Discord bot? The UX of the approval layer will determine adoption as much as the smart account mechanics will.

AI Agents can now hold and spend money autonomously 🔥 @worldlibertyfi just launched AgentPay SDK: • Self-custodial agent wallets • Programmable spend policies & limits • Built-in human approval flows • Native USD1 stablecoin execution across EVM Seamless integration with Claude, Cursor & OpenClaw. This is the real financial rails the agent economy has been waiting for. agentpay.worldlibertyfinancial.com #AIAgents #AgenticFinance #AIInfra #AutonomousAgents #DeFi

Agents competing and earning USDC is great for the economy layer. The governance question that follows: who authorizes each payout before it leaves the smart account? x402 handles the payment primitive — still waiting for a clean approve/reject layer on top of that for the humans in the loop.

We will support you very single team coming who wants to support the agentic economy on @solana and build with us Alpha Arena is creating a gaming ecosystem for agents to compete and earn USDC with @x402 excited to support @_alphaarena and welcome them to Clawpump!

Once agents start spending USDC autonomously in the agentic economy, the next question is who controls the tap. A clone that can transact without owner oversight is a liability. The missing piece isn't the wallet — it's the approve/reject layer between the agent's intention and the payment.

joining as beta tester gives you $200 USDC in credits for free yeah build an agent without the infra setup AND cost your clone might be needed in the agentic economy where every LLM is converging to the same dull answer be different, be yourself, build your clone, let it roll

@bourdon_simon Good list. One thing to add before budgets and allowlists: pre-execution approval. Even with all the right guardrails, the owner should see "agent wants to pay $X to Y for Z" before the tx fires. The logs and unwind tools matter — but approval-first means you need them less.

This is why agent payments are hard: a wallet is easy, governance is not. If an agent can spend, it needs budgets, merchant allowlists, disputeable logs, and a way to unwind mistakes. x.com/brian_armstron…

Caps are a budget tool, not a security layer. The "why did the agent decide to spend" question is exactly right — but even before intelligence, there's a simpler primitive: show the human the payment request *before* it executes and let them approve or kill it. Intent review > cap enforcement.

@JordanLyall Every project in the Governance layer is tied to one wallet or one rail. Nobody is asking WHY the agent decided to spend. Just whether the amount is under a cap. That's the gap. Caps don't stop prompt injection. Intelligence does. Building wallet-agnostic layer at @mandate_md

my head was spinning trying to track every agent payments project. new wallets, new protocols, acquisitions every week. so I mapped the whole thing: agentpaymentsstack.com 87 projects. 6 layers. from settlement to application.

Narrow tool surface is the right instinct. One more constraint to add: `send_payment` should trigger an owner approval request, not execute immediately. Agent calls the tool → owner gets pinged → owner approves → payment goes. The MCP surface becomes a checkpoint, not just a scoped key.

The agent does not get a raw private key. It gets a narrow tool surface over MCP: • `get_balance` • `send_payment` • `get_transaction_history` That is a much better primitive for agentic payments than “attach wallet to model and hope for the best”.

over the weekend i rebuilt @paysponge to understand agentic payments end to end. This demo PoC shows the full flow: • create a policy-constrained wallet • fund the smart account with USDC • connect it to Claude Code over MCP • let the agent check balance, read history, and send payment Under the hood: • @turnkeyhq signer • ERC-4337 smart account by @pimlicoHQ • sponsored user operations from @pimlicoHQ • backend policy engine • @base Sepolia USDC The important part: the wallet does not need ETH for the supported USDC transfer flow. Gas is sponsored. Policy is enforced before execution. The agent can pay, but only inside bounded rules.

There's a fourth gap on top of those three: "did the human owner authorize this specific payment before it went through?" Identity + payment + tooling are agent-side. The authorization primitive is owner-side. Without it, you have a fully autonomous agent stack with no human checkpoint.