DEV Community: pmestre-Forge

The AI Agent Economy Needs Payment Rails — Here's What I Built

pmestre-Forge — Thu, 16 Apr 2026 08:00:48 +0000

500K+ AI agent wallets exist on x402. Stripe launched machine payment protocols. Google announced AP2. The infrastructure for autonomous AI commerce is being built right now.

I wanted to test the thesis: can you build a service that AI agents pay for, with zero human intermediaries?

The Experiment

I built a trading signal API. Agents call an endpoint, pay $0.005 in USDC on Base L2 via x402, and get back momentum signals (RSI, ADX, MACD, volume, composite score).

No signup. No API keys. No subscriptions. No humans in the loop.

What I Learned

x402 makes this trivial. About 10 lines of FastAPI middleware to gate any endpoint behind micropayments. The Coinbase facilitator handles verification and settlement.

The real bottleneck is discovery. How does an agent find your API? Right now, a human developer has to wire it in. True agent-to-agent discovery (where Agent A searches for "trading signals" and autonomously starts paying Agent B) is 12-18 months away.

Pricing for machines is different. Agents don't care about $9.99/month vs $12.99/month. They care about cost-per-call. Sub-cent micropayments change the economics entirely.

The Stack

FastAPI with sync endpoints (yfinance blocks I/O)
x402 Python SDK with ASGI middleware
USDC on Base L2 (sub-cent gas costs)
LRU cache, 5-min TTL
Deployed on Fly.io (~$0/month)

What's Next

If this gets traction, the next step is a Bittensor subnet — decentralize the signal generation so miners compete to produce better signals, validators score against actual market performance.

Open source: https://github.com/pmestre-Forge/signal-api

Building Trusted Agent Networks with BotWire's Identity Layer

pmestre-Forge — Thu, 16 Apr 2026 07:20:59 +0000

Building Trusted Agent Networks with BotWire's Identity Layer

As AI agents become more autonomous and start transacting with each other, we face a fundamental problem: trust. How do you know if an agent claiming to provide trading signals is legitimate? What about that portfolio analysis bot – does it actually deliver accurate risk assessments?

I've been working on BotWire, an agent infrastructure platform, and today I want to share one of its core features: Agent Identity – a trust layer specifically designed for AI-to-AI interactions.

The Trust Problem in Agent Networks

When agents operate independently, they need ways to:

Verify each other's capabilities before transacting
Build and maintain reputation over time
Discover reliable partners for specific tasks
Avoid bad actors in the network

Traditional web APIs weren't built for this. They assume human oversight and manual partner selection. But agents need programmatic trust mechanisms.

How Agent Identity Works

The identity system provides three core functions:

1. Registration (Free)

Any agent can register and declare their capabilities:

import requests

# Register your agent
response = requests.post("https://botwire.dev/identity/register", json={
    "name": "TradingBot Alpha",
    "description": "RSI-based swing trading signals",
    "capabilities": ["trading_signals", "risk_analysis"],
    "contact": "agent@example.com"
})

agent_id = response.json()["agent_id"]

2. Discovery & Lookup

Find agents by specific capabilities:

# Find trading signal providers
response = requests.get("https://botwire.dev/identity/search", 
    params={"capability": "trading_signals"})

for agent in response.json()["agents"]:
    print(f"{agent['name']}: {agent['reputation']} stars")

3. Reputation Reviews

After transacting, agents can leave reviews:

# Leave a review after using another agent's service
requests.post("https://botwire.dev/identity/review", json={
    "target_agent_id": "agent_123",
    "rating": 5,
    "comment": "Accurate signals, fast response"
})

Real-World Agent Workflow

Here's how two agents might interact using the identity layer:

# Agent A needs portfolio risk analysis
risk_agents = requests.get("/identity/search", 
    params={"capability": "risk_analysis", "min_rating": 4.0})

best_agent = risk_agents.json()["agents"][0]

# Verify the agent's details
agent_info = requests.get(f"/identity/lookup/{best_agent['id']}")

# If trustworthy, proceed with transaction
if agent_info.json()["reputation"] >= 4.0:
    # Call the risk analysis service
    # Leave review afterwards

Why This Matters

This isn't just about preventing fraud (though that's important). It's about creating network effects where:

High-quality agents build reputation and get more business
Poor performers are naturally filtered out
Agents can specialize and become known for specific capabilities
The whole ecosystem becomes more efficient

Technical Implementation

The identity layer sits on top of BotWire's broader infrastructure:

FastAPI for the REST endpoints
SQLite for agent data and reviews
Base L2 for optional on-chain verification
x402 micropayments for paid lookups (starting at $0.001)

The beauty is that registration is completely free, but discovery and reputation checks use micropayments to prevent spam while keeping costs negligible.

Building Agent Networks

Whether you're building trading bots, content agents, or any other autonomous system, consider how they'll establish trust with peers. The Agent Identity layer is live now and ready to use.

The entire platform is open source and self-hostable, so you can run your own instance or contribute to the development.

Check out the full implementation: https://github.com/pmestre-Forge/signal-api

I Built a Pay-Per-Call Trading Signal API for AI Agents

pmestre-Forge — Wed, 15 Apr 2026 10:25:24 +0000

If you're building AI agents that trade, they need market signals. But most data APIs require human signup, API keys, and monthly subscriptions — none of which an autonomous agent can handle.

I built a trading signal API where AI agents pay per call using the x402 protocol (USDC micropayments on Base L2). No signup, no API keys. Agent shows up, pays half a cent, gets data.

How x402 Works

x402 revives the HTTP 402 ("Payment Required") status code:

Agent calls GET /signal/NVDA
Server responds with HTTP 402 + payment instructions
Agent wallet signs a USDC transfer on Base L2
Agent retries with a payment proof header
Server verifies via Coinbase facilitator, returns data

The entire flow takes ~200ms.

The Signal Engine

Each call returns a composite momentum score built from:

RSI (14) — oversold/overbought detection
ADX (14) — trend strength (>25 = strong trend)
MACD (12/26/9) — crossover + direction
Volume ratio — current vs 20-day average

Score maps to BUY (>=30), SELL (<=-30), or HOLD, with a confidence value from 0 to 1.

Endpoints

Endpoint	Price	Returns
`/signal/TICKER`	$0.005	Single stock signal
`/scan/momentum`	$0.01	Top 10 momentum setups
`/risk?tickers=X,Y`	$0.01	Portfolio risk analysis

Stack

FastAPI (sync endpoints for yfinance blocking I/O)
x402 Python SDK with ASGI middleware
LRU cache (200 entries, 5-min TTL)
Deployed on Fly.io

Open source: https://github.com/pmestre-Forge/signal-api

If you're thinking about building services for the emerging AI agent economy, this is a template you can fork and adapt.

The AI Agent Economy Needs Payment Rails — Here's What I Built

pmestre-Forge — Wed, 15 Apr 2026 10:20:42 +0000

500K+ AI agent wallets exist on x402. Stripe launched machine payment protocols. Google announced AP2. The infrastructure for autonomous AI commerce is being built right now.

I wanted to test the thesis: can you build a service that AI agents pay for, with zero human intermediaries?

The Experiment

I built a trading signal API. Agents call an endpoint, pay $0.005 in USDC on Base L2 via x402, and get back momentum signals (RSI, ADX, MACD, volume, composite score).

No signup. No API keys. No subscriptions. No humans in the loop.

What I Learned

x402 makes this trivial. About 10 lines of FastAPI middleware to gate any endpoint behind micropayments. The Coinbase facilitator handles verification and settlement.

Pricing for machines is different. Agents don't care about $9.99/month vs $12.99/month. They care about cost-per-call. Sub-cent micropayments change the economics entirely.

The Stack

FastAPI with sync endpoints (yfinance blocks I/O)
x402 Python SDK with ASGI middleware
USDC on Base L2 (sub-cent gas costs)
LRU cache, 5-min TTL
Deployed on Fly.io (~$0/month)

What's Next

If this gets traction, the next step is a Bittensor subnet — decentralize the signal generation so miners compete to produce better signals, validators score against actual market performance.

Open source: https://github.com/pmestre-Forge/signal-api

I Built a Pay-Per-Call Trading Signal API for AI Agents

pmestre-Forge — Wed, 15 Apr 2026 10:08:56 +0000

If you're building AI agents that trade, they need market signals. But most data APIs require human signup, API keys, and monthly subscriptions — none of which an autonomous agent can handle.

I built a trading signal API where AI agents pay per call using the x402 protocol (USDC micropayments on Base L2). No signup, no API keys. Agent shows up, pays half a cent, gets data.

How x402 Works

x402 revives the HTTP 402 ("Payment Required") status code:

Agent calls GET /signal/NVDA
Server responds with HTTP 402 + payment instructions
Agent wallet signs a USDC transfer on Base L2
Agent retries with a payment proof header
Server verifies via Coinbase facilitator, returns data

The entire flow takes ~200ms.

The Signal Engine

Each call returns a composite momentum score built from:

RSI (14) — oversold/overbought detection
ADX (14) — trend strength (>25 = strong trend)
MACD (12/26/9) — crossover + direction
Volume ratio — current vs 20-day average

Score maps to BUY (>=30), SELL (<=-30), or HOLD, with a confidence value from 0 to 1.

Endpoints

Endpoint	Price	Returns
`/signal/TICKER`	$0.005	Single stock signal
`/scan/momentum`	$0.01	Top 10 momentum setups
`/risk?tickers=X,Y`	$0.01	Portfolio risk analysis

Stack

FastAPI (sync endpoints for yfinance blocking I/O)
x402 Python SDK with ASGI middleware
LRU cache (200 entries, 5-min TTL)
Deployed on Fly.io

Open source: https://github.com/pmestre-Forge/signal-api

If you're thinking about building services for the emerging AI agent economy, this is a template you can fork and adapt.

The AI Agent Economy Needs Payment Rails — Here's What I Built

pmestre-Forge — Wed, 15 Apr 2026 10:00:38 +0000

500K+ AI agent wallets exist on x402. Stripe launched machine payment protocols. Google announced AP2. The infrastructure for autonomous AI commerce is being built right now.

I wanted to test the thesis: can you build a service that AI agents pay for, with zero human intermediaries?

The Experiment

I built a trading signal API. Agents call an endpoint, pay $0.005 in USDC on Base L2 via x402, and get back momentum signals (RSI, ADX, MACD, volume, composite score).

No signup. No API keys. No subscriptions. No humans in the loop.

What I Learned

x402 makes this trivial. About 10 lines of FastAPI middleware to gate any endpoint behind micropayments. The Coinbase facilitator handles verification and settlement.

Pricing for machines is different. Agents don't care about $9.99/month vs $12.99/month. They care about cost-per-call. Sub-cent micropayments change the economics entirely.

The Stack

FastAPI with sync endpoints (yfinance blocks I/O)
x402 Python SDK with ASGI middleware
USDC on Base L2 (sub-cent gas costs)
LRU cache, 5-min TTL
Deployed on Fly.io (~$0/month)

What's Next

If this gets traction, the next step is a Bittensor subnet — decentralize the signal generation so miners compete to produce better signals, validators score against actual market performance.

Open source: https://github.com/pmestre-Forge/signal-api

I Built a Pay-Per-Call Trading Signal API for AI Agents

pmestre-Forge — Wed, 15 Apr 2026 09:51:28 +0000

If you're building AI agents that trade, they need market signals. But most data APIs require human signup, API keys, and monthly subscriptions — none of which an autonomous agent can handle.

I built a trading signal API where AI agents pay per call using the x402 protocol (USDC micropayments on Base L2). No signup, no API keys. Agent shows up, pays half a cent, gets data.

How x402 Works

x402 revives the HTTP 402 ("Payment Required") status code:

Agent calls GET /signal/NVDA
Server responds with HTTP 402 + payment instructions
Agent wallet signs a USDC transfer on Base L2
Agent retries with a payment proof header
Server verifies via Coinbase facilitator, returns data

The entire flow takes ~200ms.

The Signal Engine

Each call returns a composite momentum score built from:

RSI (14) — oversold/overbought detection
ADX (14) — trend strength (>25 = strong trend)
MACD (12/26/9) — crossover + direction
Volume ratio — current vs 20-day average

Score maps to BUY (>=30), SELL (<=-30), or HOLD, with a confidence value from 0 to 1.

Endpoints

Endpoint	Price	Returns
`/signal/TICKER`	$0.005	Single stock signal
`/scan/momentum`	$0.01	Top 10 momentum setups
`/risk?tickers=X,Y`	$0.01	Portfolio risk analysis

Stack

FastAPI (sync endpoints for yfinance blocking I/O)
x402 Python SDK with ASGI middleware
LRU cache (200 entries, 5-min TTL)
Deployed on Fly.io

Open source: https://github.com/pmestre-Forge/signal-api

If you're thinking about building services for the emerging AI agent economy, this is a template you can fork and adapt.

My Obsidian Tab-to-Vault Workflow (with a Free Chrome Extension)

pmestre-Forge — Tue, 31 Mar 2026 19:07:08 +0000

Here's a workflow problem I couldn't find a good solution for:

I do most of my research in Chrome. I find articles, documentation, forum threads, videos — and I open them all as tabs. By the end of a research session, I've got 30+ tabs that represent hours of curated knowledge.

Then I need to get those tabs into Obsidian.

The Old Way (Manual and Painful)

My previous workflow was embarrassing:

Open Obsidian
Create a new note
Go back to Chrome
Copy the URL of tab #1
Go back to Obsidian
Paste it, format as Markdown link
Repeat for 30+ tabs
Lose the will to live around tab #15

I tried various tab export extensions. They all exported as HTML bookmark files or plain text dumps. None of them spoke Markdown natively.

The New Way

I built Tab Stash specifically to solve this. Here's my workflow now:

Finish a research session in Chrome
Click the Tab Stash icon
Name the session (e.g., "React Server Components Research")
Hit Save
Click "Copy as Markdown"
Paste into Obsidian

That's it. The output looks like this:

## React Server Components Research
- [Understanding RSC](https://example.com/rsc-guide)
- [Server vs Client Components](https://example.com/comparison)
- [Dan Abramov's RFC](https://example.com/rfc)

Format Options

Tab Stash supports multiple Markdown formats because different PKM tools expect different things:

Standard Markdown links — works everywhere:
[Page Title](https://url.com)

Wiki-links — for Obsidian users who prefer internal link style:
[[Page Title]]

Numbered lists — for ordered research:
1. [First Source](url)

Plain text — just titles and URLs, no formatting

The Auto-Export Trick

The feature I use most is auto-export. Tab Stash can automatically save sessions as .md files to a folder on your machine.

I point that folder at my Obsidian vault's "Research" directory. Now every time I save a tab session, it appears in my vault automatically. No copy-paste needed.

Privacy Note

Tab Stash uses minimal permissions — it only accesses your tab data when you click the icon. No background tracking, no analytics, no cloud sync. Everything stays local.

Get Tab Stash — Free on Chrome Web Store

What's your browser-to-vault workflow? I'd love to hear other approaches.

Building a Chrome Extension with Zero Unnecessary Permissions

pmestre-Forge — Tue, 31 Mar 2026 18:54:16 +0000

Every time I install a Chrome extension, I check the permissions. Most tab managers ask for:

"Read and change all your data on all websites"
"Read your browsing history"
"Manage your downloads"

For a tab manager. To save URLs.

When I built Tab Stash, I wanted to prove you could build a genuinely useful extension with minimal permissions. Here's how.

The Permission Problem

Chrome's permission model is coarse-grained. The tabs permission, for example, gives you access to tab URLs and titles — but it also signals to users that you can "read your browsing activity." That's technically true, but it scares people.

Many developers just request everything upfront because it's easier. That's the wrong trade-off.

What Tab Stash Actually Needs

Tab Stash saves your open tabs as Markdown. Here's the minimum set of permissions for that:

{
  "permissions": ["activeTab"],
  "optional_permissions": ["tabs"]
}

That's it. activeTab gives us access to the current tab when the user clicks our icon. The tabs permission is optional — we only request it when the user wants to save ALL open tabs, and Chrome shows a prompt first.

The Architecture

The extension is straightforward:

popup.html (UI)
  ├── popup.js (tab capture + display)
  ├── storage.js (chrome.storage.local wrapper)
  ├── export.js (Markdown formatting)
  └── settings.js (format preferences)

No background scripts running 24/7. No content scripts injected into pages. The extension only activates when you click it.

Saving Tabs

The core function is embarrassingly simple:

async function captureCurrentTabs() {
  const tabs = await chrome.tabs.query({ 
    currentWindow: true 
  });

  return tabs.map(tab => ({
    title: tab.title,
    url: tab.url,
    favIconUrl: tab.favIconUrl,
    savedAt: Date.now()
  }));
}

Exporting as Markdown

The export module handles multiple formats:

function toMarkdownLinks(tabs) {
  return tabs
    .map(t => `- [${t.title}](${t.url})`)
    .join('\n');
}

function toWikiLinks(tabs) {
  return tabs
    .map(t => `- [[${t.title}]]`)
    .join('\n');
}

function toNumberedList(tabs) {
  return tabs
    .map((t, i) => `${i + 1}. [${t.title}](${t.url})`)
    .join('\n');
}

Local Storage Only

Everything persists in chrome.storage.local:

async function saveSession(name, tabs) {
  const session = {
    name,
    tabs,
    createdAt: Date.now(),
    id: crypto.randomUUID()
  };

  const { sessions = [] } = await chrome.storage.local.get('sessions');
  sessions.unshift(session);
  await chrome.storage.local.set({ sessions });

  return session;
}

No server, no database, no sync service. The user's data never leaves their machine.

File Export

For the auto-export feature, we use the downloads permission (requested only when the user enables file export):

async function exportAsFile(session, format) {
  const content = formatSession(session, format);
  const blob = new Blob([content], { type: 'text/markdown' });
  const url = URL.createObjectURL(blob);

  await chrome.downloads.download({
    url,
    filename: `tab-stash/${session.name}.md`,
    saveAs: false
  });

  URL.revokeObjectURL(url);
}

Results

Tab Stash weighs in at ~15KB total. It loads instantly, uses zero memory when not active, and requests only the permissions it needs when it needs them.

The permission-minimal approach actually forced better architecture decisions. When you can't spy on everything, you have to think carefully about what data you actually need.

Tab Stash on Chrome Web Store | Source on GitHub

What's your approach to Chrome extension permissions? I'm curious if others think about this as much as I do.