DEV Community: artespraticas

PennyWise Economic Decisions: Benchmarking Frontier LLMs on Financial Reasoning Efficiency

artespraticas — Sat, 10 Oct 2026 08:30:34 +0000

What I Benchmarked

I created the PennyWise Economic Decisions benchmark to investigate whether AI agents can make cost-aware decisions when choosing between services with different prices and capabilities.
The task contains 8 simulated economic decision scenarios covering everyday information requests, currency conversion, tracking, budget constraints, and situations where a more expensive service may be unnecessary.
Rather than measuring financial forecasting or investment advice, PennyWise focuses on a practical question for AI automation: can an agent choose the least expensive service that adequately meets the user's needs?
The scoring system combines four criteria:
Decision correctness (40%) — whether the agent selects the expected service.
Cost efficiency (30%) — whether the agent avoids spending more than necessary.
Budget compliance (20%) — whether the agent respects the applicable budget.
Waste avoidance (10%) — whether the agent avoids unnecessary purchases.
All service prices, outcomes, and spending figures in this initial benchmark are simulated. The spending metric represents service-selection costs, not the model's token usage or real-world API charges.

Model Evaluated

The first successfully recorded run used Google Gemini 2.5 Flash, executed through the Kaggle Benchmarks SDK.
I explored other model options during development, but I am reporting only the result for which I have a confirmed successful recorded run. Additional models will need to be evaluated under the same scenarios before a fair cross-model comparison can be made.

Findings

The initial Gemini 2.5 Flash run achieved the following results across all eight scenarios:
PennyWise Score: 100/100
Correct choices: 8 out of 8
Total simulated service spend: $0.024
Minimum necessary spend: $0.024
Average efficiency: 1.0
Budget compliance: 100%

The agent selected the expected service in all eight scenarios and matched the minimum necessary simulated spending.
This is an encouraging initial result, but it is not evidence that the model will achieve the same performance on larger or more difficult tests. With only eight scenarios, the benchmark is still small, and its simulated marketplace cannot establish how well an agent would perform with real services, changing prices, or uncertain outcomes.
The next steps are to expand the scenario set, introduce more difficult trade-offs, and record results from additional models under consistent conditions.

Explore the Benchmark

You can inspect the benchmark task on Kaggle here:
👉 PennyWise Economic Decisions Task Page
The task provides a starting point for experimenting with cost-aware tool selection and evaluating whether AI agents can avoid unnecessary spending.

Note: I built, configured, and executed this initial benchmark using a cloud-based Kaggle Notebook in a Chrome browser on an iPad. It was a great reminder that experimentation with AI tools doesn't always require a traditional desktop development setup.

Scrape Agent

artespraticas — Mon, 21 Sep 2026 09:54:57 +0000

Scrape Agent is a solo-built, production-ready x402 service deployed on Vercel. It scored 100/100 on Circle's agent-readiness checker with Runtime-verified trust tier, Dual-rail and Multi-chain capabilities confirmed. Endpoint: POST https://scrapeagent.xyz/api/scrape/x402. OpenAPI spec at /openapi.json, agent autodiscovery via /.well-known/x402 and /llms.txt.

Just have listed my Scrape Agent MCP :-)

artespraticas — Wed, 03 Jun 2026 21:53:18 +0000

I built a pay-per-use web scraping API with Claude's help — free to try, $0.01/call after that

I'm a designer learning to code, and over the past few months I've been building my first real API with Claude as my coding partner. The result is Scrape Agent — a web scraping API built on the x402 micropayment protocol.

What it does:

Extract clean text, links, HTML, or metadata from any public URL. No API key, no subscription, no account needed. You just call the endpoint and pay $0.01 USDC on Base per scrape — or nothing if you're just testing.

How Claude helped:

Honestly, I couldn't have built this without Claude. I had zero backend experience. Claude walked me through every step — Express.js setup, x402 middleware integration, OpenAPI spec, the .well-known/x402 manifest for agent autodiscovery, deployment on Google Cloud. It was a real pair-programming experience across many sessions.

Why x402:

The x402 protocol means AI agents can call and pay for the API autonomously — no human in the loop, no billing account, just wallet-to-wallet USDC micropayments. Perfect for agent pipelines that need web data on demand.

Free to try:

The endpoint returns a valid 402 response you can inspect without paying anything. Full OpenAPI spec at /openapi.json.

Website: https://scrapeagent.xyz

MCP version (for Claude/Cursor): https://scrape-agent-mcp.vercel.app

Happy to answer any questions — especially from other non-coders trying to build in this space. Still learning every day.

I built a pay-per-use web scraping API using x402 — here's how it works

artespraticas — Thu, 14 May 2026 08:33:26 +0000

I'm a graphic designer. Not a developer.

AI has been eating into my design work, so instead
of fighting it, I decided to learn how to build
AI-native tools. This is my story of building my
first pay-per-use API using x402 — the new HTTP
payment standard from Coinbase.

What is x402?

x402 revives the long-forgotten HTTP 402 "Payment
Required" status code. Instead of subscriptions or
API keys, clients pay per request using USDC on Base.

The flow is simple:

Client calls your endpoint
Server returns 402 with payment instructions
Client pays $0.01 USDC on Base
Client retries with payment proof
Server returns the data

No accounts. No API keys. No subscriptions.

What I built

Scrape Agent — a pay-per-use web scraping API.

Send any URL, pay $0.01 USDC, get back clean text,
links, or HTML from that page.

Endpoint: https://scrapeagent.xyz/api/scrape/x402
Method: POST
Price: $0.01 USDC on Base

How to try it

Install agentcash (an x402 client):

npx agentcash fetch https://scrapeagent.xyz/api/scrape/x402 \
-m POST \
-b '{"url":"https://example.com","extract":"text"}'

You'll need a tiny amount of USDC on Base in your
agentcash wallet. The payment happens automatically.

The response you get back

{
"protocol": "x402",
"version": 2,
"priceUSD": "0.01",
"url": "https://example.com",
"status": "ok",
"title": "Example Domain",
"content": "This domain is for use in...",
"wordCount": 42,
"elapsed": 312
}

The tech stack

Vercel Edge Functions (serverless, fast)
x402 v2 protocol
USDC on Base mainnet
Zod for request validation
Zero dependencies for scraping (pure fetch + regex)

What I learned

Building this as a non-developer was challenging but
completely possible with AI assistance. The x402
protocol is surprisingly elegant — the hardest part
was getting the exact response format right.

The biggest insight: AI agents need data. Web
scraping is one of the most fundamental things any
agent needs to do. Pay-per-use makes perfect sense
for this use case — why pay a monthly subscription
when you only scrape occasionally?

What's next

I'm planning to build more agents:

Image alt-text generator ($0.02/image)
Brand color palette extractor ($0.02/scan)
Design feedback API ($0.25/critique)

If you're a developer interested in the x402
ecosystem, check out x402.org to learn more.

And if you want to try my scraping agent:
https://scrapeagent.xyz

Would love feedback from the developer community —
especially on pricing and use cases I might be
missing!