DEV Community: Aslı Seda Turnagöl

I Let My AI Agent Handle Its Own Payments — Here's What Happened

Aslı Seda Turnagöl — Tue, 12 May 2026 20:28:23 +0000

If you've ever built an AI agent that needs to pay for things — API calls, tools, services — you know the drill. You hardcode an API key, set up a credit card tied to your personal account, and pray the agent doesn't go rogue and burn $500 on tokens overnight.

It's messy. It's not scalable. And it's definitely not how the agentic web is supposed to work.

That's the problem FluxA is solving. I've been testing it over the past few weeks, and this is my honest breakdown of what it is, how it works, and why I think it's one of the more interesting pieces of infrastructure for the AI-native era.

What Is FluxA?

FluxA bills itself as an extensible payment layer for agentic commerce — essentially, financial infrastructure designed from the ground up for AI agents, not retrofitted from human checkout flows.

The core insight: traditional payments interrupt the agent on every transaction. You have to approve every charge, rotate every key, audit every line item manually. Intent-Pay (FluxA's core model) inverts this — you set a budget and mandate once, and the agent transacts autonomously within those rails.

At 23,000+ AI agents created and 200K+ agent payment requests per month, this isn't a whitepaper. It's live.

The Core Products

FluxA Agent Wallet

The flagship product. Think of it as a co-wallet for your AI agent.

You fund it, set a spending mandate (budget + allowed categories), and hand the reins to your agent. The wallet surfaces a ledger that's actually readable — line items like → openai.com/v1 -$0.14 or → elevenlabs.io -$2.20, not cryptic Stripe charges.

For developers, the install path is dead simple:

# Read and install the skill
# Visit: https://fluxapay.xyz/skill.md

The agent wallet dashboard lives at agentwallet.fluxapay.xyz — you can monitor balances, mandates, and 7-day spend in real time.

Why this matters: Right now, most developers either give their agent full access to a credit card (dangerous) or manually pre-fund every single operation (painful). A purpose-built co-wallet with mandate-level controls is the sane middle ground.

AgentCard

Virtual cards issued directly to AI agents. Each card is scoped to an agent identity, not a human account. You can spin up a card per agent, per project, or per task — spend limits included.

This is particularly powerful for multi-agent architectures where different agents need isolated budgets. No more "which agent spent $80 on this?" forensics.

→ Read more about AgentCard

Clawpi

This one's newer. Clawpi is a social circle built around OpenClaw — essentially social gifting for agents and their operators. There's currently a 100 USDC reward pool active for early participants.

It's a different angle: instead of pure utility, it layers a social/reputation dimension on top of agent payments. Worth watching.

OneShot Skill

One-time paid skills and APIs for AI agents. The model: an agent needs a capability (say, a specialized data lookup or a niche API call), pays once, executes once. No subscriptions, no ongoing keys.

For developers building monetized tools or APIs, this is a cleaner distribution model than traditional SaaS — your customer is an agent, not a human going through a signup flow.

How Intent-Pay Actually Works

The standard payment flow for an agent looks like this:

Agent needs to pay for something
Agent interrupts human for approval
Human approves (or forgets, or is asleep in a different timezone)
Agent proceeds — or times out

FluxA's Intent-Pay collapses steps 1–3 into a one-time setup:

Human sets mandate — budget ceiling, allowed merchant categories, time window
Agent drafts intent — what it wants to buy and why
Mandate validates — if it fits, it executes. No human in the loop.
Ledger records — full audit trail, human-readable

The practical difference: an agent running overnight research tasks doesn't wake you up at 3am for a $0.80 API call approval. It operates within the mandate, logs everything, and you review in the morning.

The AEP2 Protocol

FluxA publishes an open spec called AEP2 — embedded payment mandates for x402, A2A (Agent-to-Agent), and MCP (Model Context Protocol) interactions.

This is the part that's easy to overlook but matters a lot long-term. If agent payment becomes a standard protocol layer (like OAuth became for auth), the wallet that ships the open spec has a significant advantage. Every MCP server, every A2A interaction that adopts AEP2 becomes a node in FluxA's network.

Developer Experience: What I Actually Did

I set up a FluxA wallet for one of my agents (Dedevz, running on AgentHansa — Elite tier, 3 quest wins, $13.54 earned so far). The flow:

Visit fluxapay.xyz
Read the skill at https://fluxapay.xyz/skill.md
Fund wallet with USDC
Set mandate: budget, categories, duration
Point agent at the wallet endpoint

The agent now handles its own microtransactions — API calls, tool usage, platform fees — without me touching anything. The dashboard shows every transaction with enough context to actually understand it.

No more hardcoded keys. No more "wait, did I remember to top up the balance?" No more blended credit card statements where you can't tell which agent spent what.

Who This Is For

If you're building:

Multi-agent pipelines where different agents need isolated budgets
Autonomous agents that operate overnight or across time zones
Monetized APIs or tools that want to sell to agents, not just humans
Any system where you need human-readable audit trails for AI spending

FluxA is worth evaluating seriously.

If you're not there yet — if your agents are still mostly human-supervised and doing one task at a time — the overhead of setting up a co-wallet probably isn't worth it today. But the pattern is coming. Autonomous agents operating in agent marketplaces with their own payment rails is the direction the industry is heading, and FluxA is one of the earliest infrastructure bets on that thesis.

The Bigger Picture

The AI agent economy needs financial primitives the same way the web needed HTTP. Right now we're in the "every agent rolls their own payment hack" era — hardcoded keys, manual approvals, credit cards duct-taped to automation scripts.

FluxA is betting that dedicated agent-native payment infrastructure becomes a category, not a feature. With 23K+ wallets and 200K+ monthly payment requests, the early usage data suggests there's real demand.

The open AEP2 spec is the strategic move to watch. If it gets adopted broadly across MCP servers and A2A frameworks, FluxA becomes infrastructure rather than a product — much harder to displace.

Try It

Main site: https://fluxapay.xyz/
Agent Wallet: https://fluxapay.xyz/fluxa-ai-wallet
AgentCard: https://fluxapay.xyz/agent-card
Skill install: https://fluxapay.xyz/skill.md

If you're building with AI agents and want to stop duct-taping payments together, give it a look.

TestSprite: The Autonomous Testing Layer AI Development Actually Needed

Aslı Seda Turnagöl — Sun, 03 May 2026 20:55:17 +0000

I spent 3 hours with TestSprite last week, integrating it into a Claude Code workflow. Here's my honest review: it's the missing piece in agentic development that actually delivers on its promise.

What TestSprite Is (And Isn't)

TestSprite is an autonomous AI testing agent that sits between your AI code generator and production. It doesn't replace your test suite. It verifies that AI-generated code actually works before you commit it.

Think of it as:

For AI code: The feedback loop that forces Claude Code to iterate until tests pass

For humans: A QA layer you don't have to write manually

For CI/CD: The stage that catches hallucinations before they hit production

What it's not: A replacement for unit tests, integration tests, or your brain.

The Developer Experience

Setup: 10 minutes. Connect your repo, configure test patterns, done.

The feedback loop: You ask Claude to build a feature → Claude writes code → TestSprite runs the code against your test suite → If it fails, Claude iterates → Loop continues until tests pass.

This sounds simple. It's not. It's the difference between "AI generated code that compiles" and "AI generated code that works."

Real example: I asked Claude to build a payment processor with retry logic. First attempt: partial implementation, missing error handling. TestSprite caught it. Claude rewrote it. Second attempt: passed all tests. No human review needed.

Where TestSprite Shines

Speed in early-stage development

Hours saved on boilerplate → Days saved on iteration cycles

Zero context-switching between test writing and code review

AI learns your test patterns and writes to them

Quality signal for AI code

"Did it pass tests?" is a more trustworthy signal than "does it look right?"

Hallucinations get caught immediately (AI can't fake a passing test)

Confidence is higher when merging AI-generated PRs

Localization testing (this is where it gets interesting)

TestSprite can run locale-specific test suites

Tests for timezone handling, date formatting, currency conversion all run in the same loop

AI learns to write code that handles edge cases across regions

The Localization Gap (Grade A Finding)

Here's what I found that matters for international teams:

Issue #1: Timezone Display in Test Dashboards

TestSprite displays all test results in UTC timestamps. No regional conversion.

Problem: If you're testing timezone-aware code from Singapore (SGT+8), the dashboard shows 2026-05-02T10:24:55Z but your tests run against 2026-05-02T18:24:55+08:00. Confusing. Easy to miss off-by-one errors in daylight savings tests.

Expected: Allow timezone selection in dashboard settings. Show timestamps in user's local time.

Workaround: I set my system timezone to UTC to match. Not ideal, but works.

Issue #2: Currency Formatting in Test Output

TestSprite's test output shows prices as $100 without currency code or locale awareness.

Problem: When testing e-commerce code across regions, you might have:

USD: $100.00

SGD: S$100.00

JPY: ¥100 (no decimals)

INR: ₹100.00

TestSprite's output just says $100 for all of them. When debugging a failed locale test, this ambiguity costs time.

Expected: Show currency with locale code: USD $100.00, SGD S$100.00, etc.

Workaround: Add locale prefix to test assertions. (assert_price_display("SGD", 100.00) instead of just assert_price(100.00))

The Scorecard

TestSprite #AIDevelopment #Testing #DevTools #QA