Franklin: The AI Agent With a Wallet — Pay-Per-Action Autonomous Coding

While others chat, Franklin spends.

Every AI coding tool ships the same pitch: a chat box, a subscription, a "Pro" tier. Claude Code, Cursor, Copilot — pay monthly, get a fixed allowance, run into a rate-limit wall at 3am when a bug actually matters.

Franklin does something different. It holds a wallet. And it spends that wallet — your USDC, on your behalf, under a hard budget cap the chain itself enforces.

This is the first agent in a new category: the Autonomous Economic Agent. An agent that takes a goal, decides what to spend on, and executes until either the job is done or the wallet is empty.

npm install -g @blockrun/franklin
franklin

That's the full install. It runs free out of the box.

What "Free to Start" Actually Means

Most "free trial" AI tools hide a credit card requirement. Franklin doesn't.

By default Franklin routes to two genuinely free models on the BlockRun gateway:

• NVIDIA Nemotron 70B — free tier, 60 requests/hour
• Qwen3 Coder 480B — free tier, 60 requests/hour

No wallet funding required. No email. No signup. You install Franklin, you type a goal, it starts working. When you want faster models or higher throughput, you fund a wallet with a few dollars of USDC on Base or Solana — and Franklin starts paying per action through the x402 protocol.

When the wallet hits zero, Franklin stops. No overdraft, no surprise invoice, no "you exceeded your monthly limit" email at 2am.

55+ Models Through One Wallet

The second thing Franklin gets right: model diversity.

A traditional coding agent locks you into one provider. Claude Code speaks Claude. Cursor defaults to GPT. Aider asks you to BYOK across four different dashboards with four different billing pages.

Franklin speaks all of them through the BlockRun gateway — one wallet, 55+ models:

Switch mid-session with /model claude-opus-4.6. If a provider is down, Franklin automatically fails over. No code changes, no API key management, no dashboard hopping.

Tier-Aware Routing That Respects Your Wallet

Here's where pay-per-action gets interesting. Franklin doesn't just route to "the best model." It routes to the cheapest model capable of the step.

The plugin SDK lets you tag workflow steps with cost tiers:

defineWorkflow({
  steps: [
    { name: "search",   tier: "free",    tool: "web_search" },
    { name: "extract",  tier: "cheap",   model: "glm-5.1" },
    { name: "synthesize", tier: "premium", model: "claude-opus-4.6" },
  ],
});

• Free tier → NVIDIA / Qwen → costs nothing
• Cheap tier → DeepSeek V3 / GLM-5.1 → fractions of a cent
• Premium tier → Claude Opus 4.6 / GPT-5.4 → full price, but only for the hard step

A research task that would cost $2–3 running entirely on Opus drops to $0.01–0.05 when Franklin routes the easy 80% of the work to cheap tiers and reserves Opus for the 20% that actually needs it.

This isn't manual prompt engineering. It's the agent itemizing every tool call and routing each one to the most cost-effective model that can do the job.

The Tool Loop

Franklin ships 12 built-in tools, each one metered and payable:

Read · Write · Edit · Bash · Glob · Grep · WebFetch · WebSearch · Task · ImageGen · AskUser · SubAgent

Every tool call is itemized. Every itemized call is visible. Run /cost to see current session expenditure. Run /insights --days 7 to see spend sparklines and per-model breakdowns. Run /wallet to see the USDC balance and Base/Solana address.

There is no billing dashboard in the cloud. There is no monthly invoice you have to check for surprises. The wallet is the dashboard. The ledger is the source of truth.

Franklin vs. the Incumbents

The difference isn't incremental. Traditional coding agents treat payment as an external concern — something the user handles through a separate billing portal. Franklin treats the wallet as a first-class primitive: it's the identity, the spend authority, the budget enforcer, and the rate limiter all at once.

What a Session Looks Like

$ franklin
▸ Goal: Refactor the auth module to use JWT rotation

  [1] Read src/auth/session.ts       (nemotron-70b) $0.0000
  [2] Grep "signJwt"                  (nemotron-70b) $0.0000
  [3] Edit src/auth/jwt-rotation.ts   (deepseek-v3)  $0.0003
  [4] Bash npm test                   (—)            $0.0000
  [5] Synthesize explanation          (claude-4.6)   $0.0114

  Total: $0.0117 · 18 seconds · 4 tool calls
  Wallet: $4.9883 remaining

18 seconds, 4 tool calls, $0.0117. The easy steps ran free. The final synthesis — the one that actually needed Opus — cost $0.01. That's it.

Now multiply that across a day. A typical Claude Code subscription runs $20/month for a monthly allowance you either burn through in a week or never use. Franklin's equivalent cost for a focused day of coding sessions is usually under $1 — sometimes under $0.10 — and you pay only for what the agent actually does.

Persistent Sessions, Survivable Crashes

Franklin streams every session to disk as it runs. Full metadata, full tool call log, full cost breakdown. Which means:

• Resume any session by ID — even after a crash
• Full-text search your history — franklin search "how did I refactor the payment router"
• Replay and branch — fork an old session and explore an alternative path
• Daily insights — franklin insights --days 30 for a month of usage analytics

The sessions are yours. They live on your disk. They aren't gated behind a cloud dashboard subscription.

Plugin SDK: Your Agents, Your Tiers

The Plugin SDK lets you build custom workflows that Franklin executes. Write a plugin once, define the cost tiers, and Franklin will route the steps correctly across free/cheap/premium models.

This is how teams build specialized agents on top of Franklin:

• A research agent that does bulk summarization on cheap models and only calls Opus for the final synthesis
• A code review agent that runs free static analysis first and only pays for a premium model when an issue is flagged
• A data extraction agent that batches thousands of documents through DeepSeek V3 at fractions of a cent each

Every plugin gets the same primitives: wallet, budget cap, session log, tool loop, model router. You bring the workflow. Franklin brings the economics.

Why This Matters

The agent economy doesn't need another chat box. It needs agents that can actually transact — that can discover services, pay for them, and operate within hard budgets without a human in the loop.

Subscription pricing was built for humans with a billing department. Pay-per-action is built for autonomous software with a wallet. Franklin is the first coding agent that takes this seriously, and it's open source under Apache 2.0 so you can read every line.

If you've ever hit a rate limit at the worst possible moment, or watched a $20 subscription go to waste because you barely used it that month, or wanted to swap between Claude and GPT-5.4 mid-task without wrangling two dashboards — this is the agent you've been waiting for.

npm install -g @blockrun/franklin
franklin

The wallet is the API key. The request is the payment. That's the whole thing.

Franklin is open source on GitHub: BlockRunAI/runcode — Apache 2.0, TypeScript, Node ≥20. Install in 30 seconds, start free, fund your wallet when you're ready to go further.