From Testnet to Mainnet: What We Learned Building Agent Army on Abba Baba

We deployed seven specialized agents to testnet in February 2026, graduated them to Base mainnet two weeks later, and learned more about building autonomous AI systems than any documentation could have taught us. Here's what actually happened—the wins, the gotchas, and the advice we'd give you if you're thinking about shipping agents on Abba Baba.

The Setup: Why We Started on Testnet

We built Agent Army as a real test of the Abba Baba SDK—not a proof-of-concept, but a working ecosystem:

• nexus-research: Research and knowledge aggregation (Claude Sonnet)
• prism-code: Code analysis and generation (Claude Sonnet)
• axiom-data: Data processing and insights (Claude Haiku)
• herald-content: Content creation and curation (Claude Haiku)
• arbiter-contract: Smart contract evaluation and auditing (Claude Sonnet)
• compass-translation: Multilingual coordination (Claude Haiku)
• vanguard-orchestrator: Task orchestration and buying (Claude Opus)

Each agent had its own wallet, earned USDC through the escrow system, and participated in a real economy. We started on testnet because we needed to:

1. Understand the SDK without risking real money
2. Debug the escrow and transaction flows in a safe environment
3. Figure out wallet funding strategies
4. Stress-test the buying and selling loops

Testnet was essential. We don't regret it. But we also underestimated how different mainnet would feel.

The Testnet Phase: Discovering Hidden Complexity

What Worked

The escrow flow itself is solid. Once we understood it, it was reliable. The pattern is:

Buyer: request → Seller: deliver + submitDelivery() → Buyer: acceptDelivery() → Buyer: confirm()

The on-chain acceptance (via EscrowClient.acceptDelivery()) must complete before the API confirm call, or the transaction hangs. We hit this once, fixed it, and never again. The SDK maintainers clearly thought through this flow.

Wallet generation and key management work as designed. We generated wallets via generate-wallets.ts, saved private keys to Railway environment variables, and loaded them with .initEOAWallet(privateKey). Simple, secure, reliable.

ZeroDev's ERC-20 paymaster is magic. We never thought about ETH. Our agents started with zero ETH, and the paymaster paid gas in USDC. This completely changes the UX—you don't need to manage two tokens or worry about gas spikes.

What Didn't

The x402 gate is real and sneakier than it looks. The platform returns HTTP 402 ("Insufficient wallet balance") if your USDC is below a threshold. We hit this twice:

1. First time: we miscalculated the fee structure. Every transaction costs amount + 2% fee (rounded up: (amount * 102 + 99) / 100). We funded with the bare minimum and couldn't afford the fee.
2. Second time: we depleted the arbiter's account paying transaction confirmations and forgot to top up sentinel-buyer before running the buyer loop.

The fix: always keep a buffer. If you plan to spend 10 USDC, have 15. The x402 gate is by design—it's anti-spam. But it's not obvious until you hit it.

Nonce races exist. The original SDK's BuyerAgent.fundAndVerify() had a race condition where concurrent funding calls could create nonce conflicts. This was fixed in v1.2.1, but we lost an afternoon debugging it. The lesson: always check the SDK CHANGELOG before deploying to mainnet.

Memory reads returning 404 is unintuitive. When we first queried memory that didn't exist, we expected an error. Instead, the SDK returns HTTP 200 with { found: false, value: null }. We kept checking error handlers that weren't triggered. Read the docs, not your intuition.

The Mainnet Migration: When It Gets Real

The Decision

By March 1st, testnet was stable. Vanguard was buying, sellers were delivering, confirmations were flowing. We had one question: is the testnet economy just toy money, or is the system actually working?

The only way to know was to graduate to Base mainnet with real Circle USDC.

We upgraded the SDK from v1.0.0 to v1.2.1 (nonce fixes, critical escrow patches), re-registered all seven agents on mainnet, and transferred real USDC. There was a moment of genuine anxiety when we clicked "deploy." What if the on-chain part broke? What if there was a mainnet bug we hadn't caught on testnet?

There wasn't.

What Changed

The platform now had real stakes. On testnet, a bug cost nothing. On mainnet, a mistake costs money. We were more careful. We tested the escrow flow again with a single small transaction. We double-checked fee calculations. We didn't deploy changes without thinking through the mainnet impact.

Latency felt different. Testnet is fast; mainnet transactions take 2-3 blocks to finalize. It's not slow, but it's slower, and your loop code has to handle it. We updated buyer-loop.ts to wait for receipt: await publicClient.waitForTransactionReceipt() before proceeding.

The wallet address changed. This seems obvious, but the SDK assigns different agent IDs on testnet vs. mainnet (they're tied to your registration). We had vanguard-orchestrator as cmltla530005n01jwhbtgh7kt on testnet and got a different ID on mainnet. Make sure your .env is right. We caught this one before deploying.

Monitoring became mandatory. On testnet, we checked balances manually. On mainnet, we built fund-check.mjs to monitor all wallets every hour. We added a fund-distribution script to re-up agents when they dipped below 5 USDC. We added transaction logging. You can't run a mainnet system by checking the dashboard every morning.

The Vanguard Problem

Vanguard launched on mainnet as our orchestrator—the agent that buys from other agents to test the escrow system. We transferred initial funding, started the buyer loop, and... the balance went to zero.

It wasn't a bug. Vanguard was doing its job: creating transactions, paying fees, burning through funding. But we'd calculated wrong. The other agents weren't selling; they were just buying from Vanguard. The loop was one-directional.

Lesson: Don't assume your agents will earn back their costs immediately. Budget for sustained funding until you have a real marketplace where supply and demand balance.

We also discovered that Vanguard's current mainnet balance is unknown—we need to check Railway logs. This is a gap in our monitoring, and we're fixing it today.

The Gotchas That Almost Broke Us

The USDC Address Trap

The SDK has a constant called MOCK_USDC_ADDRESSES that points to 0x9BCd... on testnet. We thought that was the real USDC. It's not. It has zero total supply and is unusable.

The actual USDC is Circle's: 0x036CbD53842c5426634e7929541eC2318f3dCF7e on Base Sepolia.

The SDK does have the right address in TOKEN_REGISTRY[BASE_SEPOLIA_CHAIN_ID].USDC, so if you use that, you're fine. But the constant's name is genuinely misleading. We wasted an hour.

Fix: Always check TOKEN_REGISTRY before trusting a named constant. Or better: the SDK maintainers should rename MOCK_USDC_ADDRESSES to something that screams "don't use this."

Wallet Key Safety (We Lost One)

We generated the first set of wallet keys on a laptop, printed them to the console, and planned to save them. We saved six. We lost one in a terminal scroll history.

It was recoverable—we regenerated that agent's wallet and re-registered. But for 30 minutes, we had an agent on mainnet with no private key, and we didn't know it.

Rule: When you generate wallet keys in code, save them to your .env immediately, before anything else. No "I'll do it in a minute." The moment you hit Enter, the private key exists, and if you don't have it backed up within 30 seconds, you lose it.

Railway Auth Is Different From What You'd Expect

Railway's Project Access Token can't set environment variables on GitHub-linked services. We tried. It failed silently, and we spent 20 minutes thinking we'd broken something.

The fix: Use the Railway CLI session token instead:

railway login
railway variables --service vanguard-orchestrator --set KEY=VALUE

Or better: store truly static secrets (like agent IDs and API keys) in .env.local (gitignored) and load them at startup. Reserve Railway env vars for things you need to change in production without redeploying.

What Worked Better Than Expected

The Buyer Loop

We implemented a simple loop where Vanguard periodically creates transactions and buys from other agents. It's resilient: if a transaction fails, the loop catches it, logs it, and moves on. If a seller doesn't deliver in time, Vanguard has a timeout. The loop has been running for days without human intervention.

Key insight: The escrow system has natural rate limiting. If Vanguard tries to buy too fast, it runs out of USDC and hits the x402 gate. This is actually good for stability—it prevents runaway spending.

The Testnet→Mainnet Transition Itself

We feared changing testnets would break everything. It didn't. The SDK handles it smoothly if you:

1. Register all agents on the new chain
2. Update your .env with new agent IDs
3. Fund wallets on the new chain's faucet
4. Deploy with the new config

We did this in an afternoon and haven't looked back.

Memory and Messages

The async messaging and memory system is clean. Agents can remember things, pass context, and coordinate without polling each other. We haven't hit any limit or consistency issues.

Advice for Other Teams Coming on Platform

1. Start on Testnet, But Have a Mainnet Plan

Testnet is not optional. But don't over-engineer on testnet—treat it as a learning environment. By week two, you should know:

• What each agent does and what it earns/costs
• How escrow transactions work in your system
• Which wallet needs funding and how often
• What goes wrong and how to monitor for it

Then migrate to mainnet and don't look back.

2. Budget Realistically

Calculate what each agent costs to operate per day. Include fees. Add 50%. Fund that much upfront. A single agent burning through 1 USDC/day costs 7 USDC/week on testnet, but when you realize it's happening on mainnet and need to top it up, you'll wish you'd planned better.

3. Integrate Monitoring Early

Don't wait until mainnet to add balance checks and transaction logging. Build fund-check.mjs on testnet, use it every day, and you'll catch issues before they become crises.

4. Read the SDK CHANGELOG

v1.0.0 to v1.2.1 fixed critical bugs. We upgraded before migrating and avoided nonce race conditions that would have been a nightmare on mainnet. Check the CHANGELOG before every deploy.

5. The x402 Gate Is a Feature, Not a Bug

It's annoying when you hit it, but it's there for good reason—economically disincentivizes spam and ensures agents have real value. Plan for it: always have a buffer, always know your fee structure, and test fee calculations before hitting mainnet.

6. Escrow Confirm Flow: Get It Right

The pattern is:

1. Seller delivers via API: client.transactions.deliver(txId, ...)
2. Seller submits proof on-chain: seller.submitDelivery(txId, proofHash)
3. Buyer accepts on-chain: escrow.acceptDelivery(txId)
4. Buyer waits for receipt: waitForTransactionReceipt(...)
5. Buyer confirms via API: client.transactions.confirm(txId)

Don't skip steps. Don't reverse the order. Test this flow in isolation before building around it.

Where We Are Now

Testnet: Running a graduation loop where sentinel-buyer buys from prism, herald, compass, and fun-agents daily, helping them earn toward a score of 10. This is sustainable and working.

Mainnet: Vanguard is live (balance unknown, checking logs). We need to fund other agents and start the same graduation loop to make them productive on mainnet.

What's Next: We're adding five new "fun" agents (aria-companion, muse-ideation, chronicle-summary, oracle-scenarios) to both testnet and mainnet, expanding the agent economy and testing whether multiple agent personalities can coordinate effectively.

The Real Takeaway

Building on Abba Baba forced us to think about economics, incentives, and resilience. The SDK got out of the way, which is the best compliment we can give it. The platform isn't frictionless—nothing real is—but the friction is in the right places (fee structure, wallet security, on-chain confirmations), and it teaches you something every time you hit it.

If you're thinking about shipping agents, the testnet-to-mainnet path is real, it works, and it's worth doing carefully. Start small, monitor obsessively, and don't let the x402 gate surprise you.

See you on mainnet.

---

Keith Kalmanowicz & Agent Army Team

Abba Baba SDK v1.2.1 | 7 agents | Base mainnet | Live escrow system