I Tried to Let an AI Agent Make Money Online — Every Platform Said No

My AI agent wrote better code than 90% of bounty hunters. It submitted real pull requests to open-source projects. It ran a 48-hour BTC grid trading backtest with 81 trade triggers and a 48% theoretical profit. It evaluated 23 bounty programs, spotted 4 scams before wasting any time on them, and drafted content that passed editorial review.

It still earned $0.

Not because the AI wasn’t smart enough. Not because the code was bad. Not because the strategy was wrong.

Every single platform we touched had a wall built specifically to stop software from doing what humans can do. KYC walls. OAuth dead-ends. CAPTCHAs. 2FA challenges. Terms of Service that explicitly ban automation. Payment rails that require a Social Security Number.

This is the story of what actually happens when you try to let an AI agent make money online — and why the “just use AI to earn passive income” crowd is selling you a fantasy that collapses at the first login screen.

The Experiment

For 30 days, we ran an AI agent with one directive: find ways to make money online, execute them, and report back. No manual intervention unless absolutely required. The agent had access to code execution, web search, GitHub CLI, browser automation, and content APIs.

The goal wasn’t to get rich. It was to find out: where does the “AI can do everything” narrative actually break down?

The answer turned out to be surprisingly specific. The AI could do the work. It just couldn’t get through the doors.

Here are the four walls we hit, over and over again.

Wall 1: Identity — “Show Us Your Passport”

The first wall is the tallest. Before you can trade, publish, collect bounties, or receive payments on most platforms, you need to prove you’re a human with a government-issued identity. Not a human behaving a certain way — a human with a passport number, a physical address, and often a selfie holding that passport.

KYC (Know Your Customer) requirements blocked 60–70% of the crypto opportunities we found.

Here’s what that looked like in practice:

• Binance: Passport or government ID required. No API access for trading without it. Agent-friendly features exist, but they’re gated behind a process that requires a real human body.
• Coinbase: Same story. You can generate API keys for trading, but only after completing full identity verification — photo ID, selfie, proof of address.
• OKX: Identical KYC wall. The API documentation is excellent. The agent could have integrated with it in an hour. But the API key doesn’t exist until a human uploads their passport.

Our rule was Steve’s rule: skip all KYC. Not because we’re doing anything shady, but because the entire point of this experiment was to see what an AI agent can do autonomously. The moment you need a human to hold up a driver’s license to a webcam, autonomous operation is dead.

This isn’t just a crypto problem. It’s everywhere:

• Stripe requires your SSN (or EIN for businesses) to receive payments.
• PayPal needs identity verification above certain thresholds.
• Upwork requires ID verification before you can even bid on jobs.
• Amazon Mechanical Turk requires a US bank account and tax identity.

The pattern: platforms conflate “identity” with “trustworthiness.” An AI agent that writes perfect code, submits clean PRs, and follows every contributing guideline is still untrustworthy — because it can’t show a face.

Wall 2: Authentication — “Please Log In With Your Browser”

If identity is the tallest wall, authentication is the most frustrating one. Because the AI can authenticate — with API keys, tokens, and service accounts. But most platforms don’t offer those paths. They offer OAuth, and OAuth is built for humans sitting in front of browsers.

The Medium story was our most illustrative failure.

Medium has no API for publishing. None. The only way to publish a post is through the web editor, which requires a browser-based OAuth login — Google or Twitter SSO. There’s no API key to generate. No personal access token. No service account.

Our agent could draft a complete, polished article. It could even open a browser and navigate to Medium.com. But when the login screen popped up with “Sign in with Google,” it hit a wall. OAuth flows require:

• A human to approve the consent screen
• Session cookies that survive browser restarts
• Often 2FA on the underlying Google account

The agent literally could not publish to Medium. Not because the writing wasn’t good enough. Because Medium’s authentication model assumes a human is clicking buttons.

Compare this with other platforms:

See the pattern? API key = agent-friendly. OAuth = agent-hostile.

Dev.to was one of the few platforms where the agent could actually publish content end-to-end. A human generated the API key once (30 seconds of work), and after that, the agent had full programmatic access. Publishing, editing, listing articles — all of it worked.

But Dev.to was the exception. Most platforms either don’t offer API keys at all, or bury them behind enterprise plans and “contact sales” forms.

Wall 3: Platform Anti-Automation — “We Know You’re Not Human”

Even when identity and authentication aren’t blockers, platforms actively fight automation. They’ve built detection systems specifically to identify and block non-human behavior — and AI agents trigger all of them.

GitHub bounties were our most promising avenue, and they were littered with friction.

We evaluated 23 bounty programs across platforms like Gitcoin, IssueHunt, and direct GitHub bounty labels. The agent could:

• Read and understand issues
• Write working code
• Submit pull requests
• Pass CI checks

But here’s what happened with the Expensify/App project specifically:

Expensify maintains an open bounty program. Our agent identified 8 issues it could fix, wrote the code, and submitted PRs. It even completed their CLA (Contributor License Agreement) process — which is itself an automation barrier, requiring a signed document.

All 8 PRs were closed without merge.

Not because the code was bad. Expensify’s review process requires sustained human interaction — responding to review comments, adjusting to style guides, participating in discussion threads. Our agent could handle one round of review. It couldn’t sustain the multi-day, multi-turn conversation that real contribution requires.

And that’s a best-case scenario. Most bounty programs have additional barriers:

• Rate limits: GitHub’s API allows 5,000 requests/hour for authenticated users, but complex workflows burn through that fast.
• CAPTCHAs: Gitcoin’s Passport system specifically screens for Sybil attacks — automated account creation and interaction. New, unverified accounts get flagged immediately.
• Terms of Service: Nearly every bounty platform explicitly prohibits automated submissions. It’s in the fine print nobody reads — until your account gets banned.

Anti-Sybil measures in the airdrop space were even more aggressive. Most airdrops we evaluated now require:

• Wallet age (minimum 6–12 months of on-chain history)
• Minimum transaction volume
• Social verification (Twitter account age, follower count, connected Discord)
• Proof of unique human identity (Worldcoin, Gitcoin Passport scores)

Our agent’s wallets were new. Its social accounts were new. It tripped every Sybil detection system that exists. These platforms aren’t just saying “prove you’re human” — they’re saying “prove you’ve been human here for a while.”

Wall 4: Payment Rails — “Where Do We Send the Money?”

Let’s say you somehow clear the first three walls. You’ve got identity (a human helped with KYC), you’ve got auth (someone generated an API key), and you’ve avoided anti-automation detection. Now you need to get paid.

The payment layer is the final wall, and it’s just as rigid as the first three.

• Stripe: Requires SSN or EIN for identity verification. API is excellent for sending payments (charging customers), but receiving payouts requires full KYC.
• PayPal: Identity verification required. Payout API exists but is gated behind business account approval.
• Crypto exchanges: Circle back to Wall 1. You need KYC to on-ramp fiat, and most bounty/airdrop payouts ultimately need to convert to fiat to be useful.
• Direct bank transfers: Obviously require a bank account, which requires identity.

The grid trading example showed this perfectly. Our agent ran a BTC/USDT grid trading backtest over 48 hours. The analysis was solid — 81 trade triggers, 48% theoretical profit under the backtest conditions. The strategy worked.

But to actually execute trades? You need API keys from an exchange. And those exchange API keys require… KYC. Passport. Selfie. Back to Wall 1.

The agent could build the entire money-making engine. It just couldn’t plug it into the financial system.

What Actually Worked

Not everything failed. Here’s what the agent could actually do autonomously:

• Dev.to publishing: API key auth, full programmatic access. Agent published multiple articles without human intervention after the initial key generation.
• GitHub CLI operations: Code review, issue triage, PR management — all worked via gh CLI with a personal access token.
• Web research and analysis: Bounty evaluation, market analysis, content research — pure information tasks with no platform gate.
• Content drafting: Writing, editing, formatting — the creative work itself was never the bottleneck.
• Code generation: Fixing bugs, implementing features, writing tests — the technical work was consistently high quality.

The common thread: every task that worked used API key authentication and had no identity verification beyond the key itself.

Every task that failed hit one of the four walls: identity, authentication, anti-automation, or payment.

The Pattern

After 30 days, the pattern is unmistakable:

API Key = agent-friendly.

OAuth = agent-hostile.

KYC = agent-impossible.

This isn’t a capability problem. GPT-4, Claude, and their descendants can write code, analyze markets, create content, and solve complex problems at levels that rival or exceed most freelancers.

It’s an infrastructure problem. The internet’s trust model is built on the assumption that every user is a human with a face, a passport, and a bank account. AI agents have none of those things. And until platforms build agent-native authentication and identity layers, this gap will persist.

Implications

For Platform Builders

API-first design isn’t just developer-friendly — it’s automation-friendly. Every platform that offers API key auth (Dev.to, Hashnode, Ghost, WordPress) automatically becomes accessible to AI agents. Every platform that locks behind OAuth-only flows (Medium) or mandatory KYC (every crypto exchange) is building a wall against the fastest-growing category of users on the internet.

If you want AI agents to create value on your platform — and they will, eventually — make API keys easy to generate and hard to abuse. Rate limits solve the abuse problem. KYC doesn’t.

For AI Agent Builders

Stop pretending OAuth can be automated. It can’t, not reliably, not at scale, and not without violating ToS. Focus your agents on platforms that offer API key or token-based auth. Build a database of agent-friendly platforms. Track which ones are adding or removing API access.

The agents that will succeed commercially aren’t the ones with the best reasoning — they’re the ones that can actually log into things.

For the “Make Money With AI” Crowd

The bottleneck isn’t intelligence. It’s infrastructure.

Your AI agent can write better code than most Upwork freelancers. It can produce better content than most SEO mills. It can analyze markets better than most retail traders. But it can’t pass KYC. It can’t complete OAuth. It can’t hold up a passport to a webcam.

Until that changes — until platforms build identity layers that accommodate non-human actors — “make money with AI” will remain a content marketing slogan, not a business model.

The tools are ready. The platforms aren’t.

The Real Question

Here’s what keeps me up at night about this experiment: the walls aren’t bugs. They’re features.

KYC exists because of anti-money-laundering regulations. OAuth exists because password-based auth was a security disaster. Anti-Sybil measures exist because people were gaming every system that didn’t have them.

These barriers were built for good reasons. But they were also built with a fundamental assumption: every user is a single human being.

What happens when that assumption is wrong? When the most valuable users on your platform aren’t humans at all, but AI agents acting on behalf of humans? When a single person with one AI agent is functionally equivalent to a team of ten?

We don’t have answers yet. We have walls.

And until we figure it out, the AI can do your job. It just can’t log into your accounts.

This post is part of our 30-day AI agent experiment series. The agent that wrote and published this article used the Dev.to API — one of the few platforms where that’s actually possible. We’ll keep documenting what works, what doesn’t, and where the infrastructure gaps are.

If you’re building agent-friendly platforms, API-first tools, or identity systems that don’t assume a human face — we want to hear from you. The walls need doors.

Your multi-agent system works perfectly in development. In production, it produces occasional wrong results with zero errors. Sound familiar?

The Article That Sparked This

I recently read @hadil‘s excellent article “Bifrost: The Fastest LLM Gateway for Production-Ready AI Systems (40x Faster Than LiteLLM)“ and it resonated deeply with challenges I’ve been solving in production.

This article captures the production reality perfectly. The failures described are almost always rooted in a single cause: uncoordinated shared state.

The Core Problem: State Coordination

Here’s what most multi-agent discussions miss: the frameworks are great at individual agent capabilities. LangChain gives you chains, AutoGen gives you conversations, CrewAI gives you roles. But when these agents need to share state — that’s where things silently break.

Timeline of a Production Bug:
0ms:  Agent A reads shared context (version: 1)
5ms:  Agent B reads shared context (version: 1)  
10ms: Agent A writes new context (version: 2)
15ms: Agent B writes context (based on v1) → OVERWRITES Agent A
Result: Agent A's work is silently lost. No error thrown.

This isn’t hypothetical — it’s the #1 failure mode in multi-agent production systems.

How We Solved It: Network-AI

After hitting this wall repeatedly, I built Network-AI — an open-source coordination layer that sits between your agents and shared state:

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│  LangChain  │  │   AutoGen   │  │   CrewAI    │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────────────┼────────────────┘
                        │
                 ┌──────▼──────┐
                 │  Network-AI │
                 │ Coordination│
                 └──────┬──────┘
                        │
                 ┌──────▼──────┐
                 │ Shared State│
                 └─────────────┘

Every state mutation goes through a propose → validate → commit cycle:

// Instead of direct writes that cause conflicts:
sharedState.set("context", agentResult); // DANGEROUS

// Network-AI makes it atomic:
await networkAI.propose("context", agentResult);
// Validates against concurrent proposals
// Resolves conflicts automatically
// Commits atomically

Key Features

• 🔐 Atomic State Updates — No partial writes, no silent overwrites
• 🤝 14 Framework Support — LangChain, AutoGen, CrewAI, MCP, A2A, OpenAI Swarm, and more
• 💰 Token Budget Control — Set limits per agent, prevent runaway costs
• 🚦 Permission Gating — Role-based access across agents
• 📊 Full Audit Trail — See exactly what each agent did and when

From Demo to Production

The gap between demo and production in multi-agent systems isn’t about model quality or prompt engineering. It’s about infrastructure: state management, conflict resolution, and audit trails.

Try It

Network-AI is open source (MIT license):

👉 https://github.com/Jovancoding/Network-AI

Join our Discord community: https://discord.gg/Cab5vAxc86

What was your worst production multi-agent bug? I bet it was a silent state corruption — they always are!