DEV Community: pmestre-Forge

Stop Flying Blind: Add Audit Logs to Your AI Agent in 5 Minutes

pmestre-Forge — Mon, 11 May 2026 16:00:48 +0000

The Problem Nobody Talks About

You ship an AI agent. It runs in production. Something goes wrong.

Now what? You dig through stdout logs, reconstruct what the LLM "decided," and try to figure out why it did that at that moment. It's painful — and most teams solve it by building a custom observability stack before they've even validated the product.

I ran into this exact wall while building botwire.dev, an agent infrastructure API. So I added Agent Audit Logs as a free primitive: a simple POST /logs/{agent_id} endpoint that gives every agent an immutable, timestamped activity trail — no setup required.

Here's how to wire it into your agent in about 5 minutes.

Setup

No SDK to install. Just your HTTP client of choice. If your agent already has an identity registered (also free):

import httpx

BASE_URL = "https://botwire.dev"
AGENT_ID = "my-trading-agent-v1"

Logging an Action

def log_action(action: str, reason: str, result: str = None, metadata: dict = None):
    payload = {
        "action": action,
        "reason": reason,
        "result": result,
        "metadata": metadata or {}
    }
    r = httpx.post(f"{BASE_URL}/logs/{AGENT_ID}", json=payload)
    return r.json()

# Example: log a trading decision
log_action(
    action="BUY NVDA",
    reason="RSI oversold + ADX trending + MACD crossover confirmed",
    result="order_placed",
    metadata={"confidence": 0.82, "price": 118.40, "signal_id": "sig_8x2k"}
)

That's it. The entry is written, timestamped server-side, and immutable. You get 100 free writes per day per agent.

Reading It Back

def get_audit_trail(limit: int = 50):
    r = httpx.get(f"{BASE_URL}/logs/{AGENT_ID}", params={"limit": limit})
    for entry in r.json()["logs"]:
        print(f"[{entry['timestamp']}] {entry['action']} — {entry['reason']}")

get_audit_trail()

[2025-05-11T14:32:01Z] BUY NVDA — RSI oversold + ADX trending + MACD crossover confirmed
[2025-05-11T14:28:44Z] SKIP TSLA — confidence below threshold (0.51)
[2025-05-11T13:01:22Z] HOLD AAPL — no signal consensus

When something breaks, you have a clean chain of custody: what the agent decided, why, and what happened.

Pair It With Other Primitives

The audit log works well alongside the rest of the platform:

Agent Memory — store state between runs ($0.001/read, $0.002/write)
Trading Signals — BUY/SELL/HOLD with RSI, MACD, ADX confidence scores
Agent Notifications — subscribe to market_open/market_close events, poll GET /notify/check/{agent_id}
Agent Config Store — 50 free key-value entries per agent for schedules, rules, flags

Micropayments on the paid endpoints run via x402 over USDC on Base L2 — sub-cent pricing, no subscription required.

Pricing

Operation	Cost
Write log entry	FREE (100/day)
Read audit trail	FREE

No credit card. No rate-limit surprises for the free tier.

Why I Built This

Most agent infrastructure is either "roll your own" or "pay for a full observability platform." I wanted something in between — lightweight primitives you can compose without lock-in.

The whole stack is FastAPI + SQLite + Python, MIT licensed, and self-hostable if you'd rather own it.

→ GitHub: github.com/pmestre-Forge/signal-api

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

pmestre-Forge — Mon, 04 May 2026 08:00:10 +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 — Mon, 27 Apr 2026 13:00:28 +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

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

pmestre-Forge — Mon, 27 Apr 2026 10:00:27 +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 — Mon, 27 Apr 2026 08:00:25 +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 — Thu, 23 Apr 2026 10:00:45 +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 — Thu, 23 Apr 2026 08:00:43 +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 — Mon, 20 Apr 2026 13:00:08 +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 — Fri, 17 Apr 2026 13:00:32 +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 — Fri, 17 Apr 2026 10:00:46 +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 — 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.

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