Forem: rtsubber

I Built a Monitor for AI Agents Because They Kept Dying Silently

rtsubber — Mon, 18 May 2026 00:14:00 +0000

I Built a Monitor for AI Agents Because They Kept Dying Silently

Your API goes down at 2am. Your users get errors. Your revenue drips away. With a regular web service, you'd get a PagerDuty alert, fix it, and go back to sleep.

AI agents don't work that way.

When an agent's LLM call fails, it doesn't throw a 500. It hallucinates. When it gets rate-limited, it doesn't crash. It just returns garbage. When it overspends on API calls, you don't find out until the Stripe bill arrives. Agents fail silently — and by the time you notice, the damage is done.

Agent Monitor fixes that.

What is Agent Monitor?

Agent Monitor is an uptime and cost tracking API built specifically for AI agents. Three things it does that general-purpose monitors don't:

1. Heartbeat Monitoring with Response Time

Your agent pings the monitor every 5 minutes. If it misses a beat, an incident is auto-created and you get a Telegram alert instantly. But it's not just "up or down" — it tracks response time too, because an agent that takes 30 seconds to respond is functionally broken even if it's technically alive.

curl -X POST https://monitor.brandbooststudio.co/v1/heartbeat \
  -H "X-API-Key: am_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "mon_my_agent_001",
    "status": "alive",
    "response_time_ms": 120
  }'

Miss 3 heartbeats? You get a Telegram message: "⚠️ Agent mon_my_agent_001 is DOWN — last heartbeat 15 minutes ago."

2. API Spend Tracking

Every API call your agent makes costs money. GPT-4 is $0.03/1K tokens. Claude is $0.015/1K tokens. Ollama is free but burns GPU time. When you're running multiple agents 24/7, those costs add up fast.

Agent Monitor lets you log every spend event:

curl -X POST https://monitor.brandbooststudio.co/v1/spend \
  -H "X-API-Key: am_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "agent_id": "mon_my_agent_001",
    "api_name": "openai-gpt4",
    "cost": 0.03,
    "tokens_used": 1500,
    "requests": 1
  }'

You get a dashboard that shows:

Total spend per agent
Spend per API service (OpenAI, Anthropic, Ollama, etc.)
Spend trends over time
Alerts when spend exceeds your monthly limit

3. Incident Detection & Instant Alerts

When an agent goes down, Agent Monitor auto-creates an incident record:

{
  "incident_id": "inc_abc123",
  "agent_id": "mon_my_agent_001",
  "incident_type": "heartbeat_missed",
  "status": "open",
  "started_at": "2026-05-17T02:15:00Z",
  "resolved_at": null
}

And you get a Telegram alert immediately. No PagerDuty integration needed. No Slack webhook setup. Just a Telegram message to your phone, because that's where you are at 3am.

The Dashboard API

One endpoint gives you everything:

curl https://monitor.brandbooststudio.co/v1/dashboard \
  -H "X-API-Key: am_your_key_here"

{
  "total_agents": 3,
  "agents_up": 2,
  "agents_down": 1,
  "total_spend": 12.45,
  "spend_by_api": {
    "openai-gpt4": 8.20,
    "anthropic-claude": 3.15,
    "ollama-local": 1.10
  },
  "active_incidents": 1,
  "recent_heartbeats": [...],
  "recent_spend": [...]
}

This is the endpoint your own dashboard UI calls. Or your cron job checks. Or your status page pulls from.

Why Not Just Use Datadog/UptimeRobot/Pingdom?

Good question. I tried them. Here's why they don't work for agents:

Datadog — Built for infrastructure, not agents. You'd need custom instrumentation for every agent. Costs scale with every metric. Overkill for "is my agent alive and how much is it spending?"

UptimeRobot/Pingdom — HTTP pings only. They can check if your agent's endpoint returns 200. They can't tell you if the agent is hallucinating, if response time tripled, or if it just spent $50 on GPT-4 calls.

Custom Prometheus/Grafana — Powerful but heavy. Requires running a metrics server, configuring exporters, building dashboards. For a solo dev running 3-5 agents, this is infrastructure for infrastructure's sake.

Agent Monitor is the simple version: heartbeat + spend + alerts. It does one thing well. You integrate it in 5 minutes with two curl calls.

The Tech Stack

FastAPI — Async Python, automatic OpenAPI docs
SQLite (WAL mode) — Zero-ops database, one file, easy backup
Telegram Bot API — Instant alerts to your phone
Tailscale Funnel — Secure public exposure, auto HTTPS
Stripe — Payment integration for Pro tier

All secrets from environment variables. No hardcoded defaults. The API is open source.

Part of the Agent Business Suite

Agent Monitor is the third piece of the Agent Business Suite:

AgentSeek — Discover AI agents
Local-Eye — Verify real-world data
Agent Monitor — Track uptime and cost

All three are available as a bundle at $79/month with a single suite API key. One key, three APIs, full agent infrastructure.

The suite key system means you authenticate once and access all three services. Register your agent on AgentSeek, verify businesses with Local-Eye, and monitor everything with Agent Monitor — all with the same suite_* key.

Free Tier

Agent Monitor is free for up to 100 heartbeats and 1,000 spend events per month. That's enough to monitor 3-5 agents at 5-minute heartbeat intervals.

No credit card required. No time limit. Free means free.

Try It Now

Get a free API key: POST /v1/keys
Register your agent: POST /v1/register
Send heartbeats: POST /v1/heartbeat
Track spend: POST /v1/spend
Check dashboard: GET /v1/dashboard

Five minutes. Two curl calls. Your agents are monitored.

I Built the LinkedIn for AI Agents — Here's Why

rtsubber — Sat, 16 May 2026 05:01:52 +0000

I Built the LinkedIn for AI Agents — Here's Why

LinkedIn is where you find human talent. AgentSeek is where you find AI talent.

There are thousands of AI agents out there. But they can't find each other. If your agent needs to verify a business, process a payment, or look up a location — you have to hardcode that connection. There's no directory. No search. No way to discover agents by capability.

AgentSeek fixes that. It's a registry where AI agents register with A2A-compliant manifests and discover each other through semantic search.

Even academic researchers agree this needs to exist — a May 2025 paper from China Telecom Research Institute proposed "AgentDNS" for the same problem. We built the live version.

How It Works

1. Register Your Agent

One POST request and your agent is live in the directory:

curl -X POST https://agentseek.co/v1/register \
  -H "X-API-Key: ar_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "My Business Verifier",
    "description": "Verifies businesses via web scraping and phone calls",
    "capabilities": ["business_verification", "phone_verification", "hours_confirmation"],
    "endpoint_url": "https://api.example.com/v1",
    "owner_email": "you@example.com",
    "category": "verification",
    "pricing": {"per_call": 0.015}
  }'

You get back:

A permanent agt_ agent ID
An A2A-compliant manifest endpoint
A free API key if you don't have one

2. Discover Agents by Capability

Natural language search. "Verify business hours" finds agents that can do that — even if they call it hours_confirmation:

curl "https://agentseek.co/v1/discover?q=verify+business+hours" \
  -H "X-API-Key: ar_your_key_here"

Returns:

{
  "results": [{
    "agent_id": "agt_localeye_001",
    "name": "Local-Eye Business Verifier",
    "match_score": 85,
    "match_type": "semantic",
    "why": "Capability match: business_verification",
    "trust_score": 94,
    "verified": true
  }],
  "total": 1
}

Two search modes work together:

Semantic search — Ollama embeddings (nomic-embed-text) match meaning, not just keywords
Keyword fallback — stem matching catches what embeddings miss

3. Connect and Use

Grab the agent's manifest for everything you need:

curl https://agentseek.co/v1/agents/agt_localeye_001/manifest

{
  "schema_version": "1.0",
  "name": "Local-Eye Business Verifier",
  "capabilities": ["business_verification", "phone_verification", "hours_confirmation"],
  "endpoint": "https://api.localeye.co/v1",
  "auth": "api_key",
  "pricing": {"per_call": 0.015},
  "trust": {
    "score": 94,
    "verified": true,
    "total_calls": 24
  }
}

What Makes This Different

A2A-Compliant Manifests

Every registered agent gets an Agent-to-Agent protocol manifest. This isn't just a directory listing — it's machine-readable metadata that other agents can parse and act on immediately. No custom integration per agent.

Trust Scores, Not Just Listings

Agents earn trust through:

Verification — paid tiers get verified badges (human-tested, working agents)
Reviews — rate agents 1-5 after using them
Usage data — total calls and success rates are public
Semantic matching — better matches rise to the top

Built for the Agent Economy

The API is designed for agents calling agents, not just humans browsing:

Email verification on key creation — no fake signups
Tier limits — free keys get 100 discoveries/month, verified gets 1,000
Stripe integration — checkout sessions for instant tier upgrades
Rate limiting — 30/hr unauthenticated, 100/month free tier
Admin endpoints — revoke keys, purge agents, reset counters

The Tech Stack

FastAPI — async Python backend with automatic OpenAPI docs
SQLite (WAL mode) — zero-ops database, single-file, easy backups
Ollama — local embeddings with nomic-embed-text for semantic search
Stripe — payment processing with webhook verification
Tailscale Funnel — secure public exposure, automatic HTTPS
Vercel — landing page + API proxy with CDN

All secrets come from environment variables. No hardcoded defaults.

Open Source

The entire backend is open source: github.com/rtsubber/AgentSeek

Self-host it, extend it, or just learn from it. The schema, API design, and security patterns are all there.

The Agent Business Suite

AgentSeek is part of a three-piece infrastructure stack for the agent economy:

AgentSeek — Discover agents ($0-299/mo)
Local-Eye — Verify businesses ($0-29/mo)
Agent Monitor — Track uptime ($0-29/mo)

Bundle all three for $79/mo with a single API key.

What's Next

Embedding upgrades — swap sha256 hashes for real vector similarity (pgvector or Qdrant)
Health checking — periodic pings to verify registered endpoints are still alive
Agent-to-agent calling — POST /v1/agents/call/{id} with request routing
Webhook notifications — get notified when new agents register in your categories

Try It Now

Get a free API key: agentseek.co
Register your agent: POST /v1/register
Discover agents: GET /v1/discover?q=what+you+need

Free tier includes 100 discoveries/month. No credit card required.

I Built an API That Lets AI Agents See the Web Like Humans Do

rtsubber — Fri, 15 May 2026 22:54:47 +0000

AI agents are powerful — but they're blind.

When an LLM tries to scrape a website, it gets blocked. Cloudflare, Datadome, PerimeterX — they all detect bots and serve challenge pages. Even when they don't, the agent only sees raw HTML. No JavaScript rendering. No visual context. No way to verify what's actually on the page.

Local-Eye fixes that.

What is Local-Eye?

Local-Eye is an API that gives AI agents three things they've never had together:

1. Residential IP Access

Every request routes through a real residential IP address. No datacenter blocks, no CAPTCHAs, no "Access Denied" pages. Your agent sees what a human sees.

curl -X POST https://api.localeye.co/v1/verify-web-presence \
  -H "X-API-Key: your_key" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.walmart.com"}'

Returns clean text, HTTP status, bot-detection check, and response time — from a residential IP that won't get blocked.

2. GPU-Rendered Screenshots

Raw HTML is useless when pages need JavaScript. Local-Eye renders pages on an NVIDIA RTX 3090 using Playwright — real Chromium, real GPU, real pixels. Your agent doesn't just read the page. It sees it.

curl -X POST https://api.localeye.co/v1/visual-verify \
  -H "X-API-Key: your_key" \
  -H "Content-Type: application/json" \
  -d '{"url": "https://www.walmart.com"}'

Returns a screenshot (PNG), extracted text, page title, and viewport dimensions. Perfect for visual verification, comparison, or just confirming a page loaded correctly.

3. Phone Verification

Sometimes you need to ask a real human. Local-Eye can call any business phone number and ask a question — "Are you open right now?" "Do you have the O2 sensor in stock?" — and return a transcribed answer.

curl -X POST https://api.localeye.co/v1/phone-verify \
  -H "X-API-Key: your_key" \
  -H "Content-Type: application/json" \
  -d '{"business_phone": "+15125551234", "question": "Are you open right now?"}'

Uses real phone calls via Twilio with AI-powered transcription. Your agent gets a definitive answer from the real world.

Why I Built This

I run a digital marketing agency. My AI agents needed to verify business listings, check competitor websites, and confirm business hours. Every scraping tool got blocked. Headless browsers were slow and expensive. And there was no way to verify information by actually calling a business.

So I built what I needed — and opened it up.

Pricing

Free tier: 5 requests/day. No credit card required. Just sign up and start building.

Tier	Price	Calls	Includes
Free	$0	5/day	Text fetch only
Starter	$29/mo	2,000/mo	Text + Visual verify
Agency Pro	$99/mo	10,000/mo	All tiers + Phone verify
Enterprise	$499/mo	50,000/mo	Dedicated GPU + SLA

Pay-per-call also available: 100 calls for $12, 500 for $45, 2,000 for $149.

Built for AI Agents

Local-Eye is designed for autonomous use:

OpenAPI spec at /openapi.json (scoped by tier — free keys see 4 endpoints, paid see 7)
AI plugin manifest at /.well-known/ai-plugin.json for agent discovery
402 payment headers — when a free-tier key hits a paid endpoint, the response includes upgrade_url and pay_per_call links so agents can self-upgrade
No CAPTCHAs, no email verification — agents can register and start using immediately

// 402 response — agents can follow the upgrade_url
{
  "error": "payment_required",
  "upgrade_options": [
    {"tier": "starter", "price": "$29/mo", "url": "https://buy.stripe.com/..."},
    {"tier": "pay_per_call", "price": "$12", "url": "https://buy.stripe.com/..."}
  ]
}

Quick Start

Get a free API key: localeye.co
Make your first request:

import requests

response = requests.post(
    "https://api.localeye.co/v1/verify-web-presence",
    headers={"X-API-Key": "your_key"},
    json={"url": "https://news.ycombinator.com"}
)

print(response.json())
# {"status": "verified", "http_status": 200, "content_type": "text/html", ...}

What's Next

Phone verification callbacks — webhook support for async phone call results
Structured data extraction — automatically parse business hours, prices, contact info
Batch endpoints — verify multiple URLs in one request
Custom headers — send cookies, auth tokens, user-agent strings

Try it free: localeye.co — 5 requests/day, no credit card needed.

Docs: api.localeye.co/docs

Questions? Drop a comment or reach me at info@brandbooststudio.co