Argus

💡 Inspiration

Analysts, investors, and product teams burn hours every day doing the same loop: search the web, skim a dozen sources, try to remember what changed since yesterday, and connect the dots between companies, people, and events. Tools like Bloomberg, Crunchbase, and CB Insights exist because that work is genuinely valuable — and genuinely expensive.

We asked a simple question: what if an agent did the entire loop itself — and got paid for the output, by other agents, with no human in the middle?

That's ARGUS. Named after the hundred-eyed giant of Greek myth who never closed all his eyes at once, ARGUS watches a topic on the open web continuously, reasons over what it finds, publishes a cited intelligence report, and sells access to it over a crypto-native payment rail. 🔭 What it does

Give ARGUS a topic. Walk away. Every cycle it autonomously:

Searches the web with Tavily (multi-query, deduplicated, relevance-scored)
Stores every signal in ClickHouse as a timestamped, queryable time series
Extracts entities & relationships with Gemini (companies, people, products, events, and how they connect)
Reasons over a knowledge graph with Prometheux — deriving trending entities, competitor pairs, and influence chains via executable ontologies
Grounds everything in a Senso.ai knowledge base so the final report cites real sources instead of hallucinating
Publishes a cited report to cited.md
Monetizes it: the premium endpoints sit behind an x402 paywall, so any agent or wallet can pay USDC and consume the intelligence instantly — no accounts, no API keys.

A second agent, agent_buyer.py, closes the loop: it discovers ARGUS through a machine-readable manifest, uses Gemini to decide which product fits its goal, pays autonomously over x402, and summarizes what it bought. Agent-to-agent commerce, end to end, with real money movement. 🏗️ How we built it

The architecture is a clean pipeline where every tool does one non-trivial, load-bearing job:

Tavily ──► ClickHouse ──► Gemini ──► Prometheux ──► Senso.ai ──► cited.md ──► x402 / CDP (eyes) (memory) (parser) (reasoning) (grounding) (output) (economy)

Backend: Python — an autonomous agent loop (agent.py) plus a FastAPI server (server.py) exposing both a free frontend API and x402-gated paid endpoints.
Data layer: ClickHouse with a time-series schema (signals, entities, relationships, payments) and SQL trend queries like $$\text{trend}(e) = \sum_{t \in [,now - \Delta,, now,]} \mathbb{1}[\text{entity}_t = e]$$ computed directly in the columnar store.
Knowledge graph: Prometheux executable ontologies in Vadalog, sitting on top of ClickHouse with no data movement. Reasoning is topic-scoped — each topic gets its own filtered concepts.
Grounding: Senso.ai ingests every article and answers intelligence questions with citations.
Payments: x402 with the Coinbase CDP facilitator on Base. The paywall is fail-closed and exposes a discovery manifest so agents can find and pay for ARGUS autonomously. We also advertise MPP as a second rail.
Frontend: A Next.js (App Router + Tailwind) dashboard that renders topics, live stats, trending entities, the report preview, and the x402 unlock flow.

🧠 What we learned

Tool composition beats tool count. The win wasn't using six sponsor tools — it was making each one load-bearing. Remove any single one and the agent breaks: no Tavily means no eyes, no ClickHouse means no memory, no Prometheux means no reasoning, no Senso means hallucination, no x402 means no economy.
Grounding is a feature, not a formality. Wiring Senso.ai in turned "plausible-sounding" reports into ones where every claim links to a real URL.
x402 makes machine-to-machine commerce feel trivial once it works — an agent paying another agent in USDC over plain HTTP is genuinely a glimpse of the near future.
Autonomy is the hardest criterion to fake. Designing for a single command that then runs forever forced real engineering: deduplication, retries, idempotent storage, and graceful degradation.

🧩 Challenges we faced

Fail-open payments. Our first x402 integration returned the paid content even when settlement failed. We traced it to a missing resource_server.initialize() and added a defense-in-depth payment-header guard so paid handlers can never run without a valid payment. Now it's provably fail-closed.
Vadalog reasoning quirks. Early ontology rules silently produced zero facts — wrong column positions against the ClickHouse schema, plus PATH_NOT_FOUND race conditions between running a concept and fetching results. We fixed the column mapping, added settle time, and treated empty result paths as legitimately empty.
Model & SDK drift. Gemini model names and the Google GenAI SDK had moved on from our assumptions; we made the model configurable and parallelized extraction (12 workers) to keep cycles fast.
Multi-topic from day one. We refactored the API into /api/v1/{topic}/... so ARGUS can serve every topic it has ever run on, with topic-scoped reasoning and per-topic reports — turning a single-topic demo into a real product surface.

→ What's next

A one-click CDP embedded wallet in the browser so humans can unlock reports without leaving the dashboard.
Listing ARGUS on the x402 Bazaar so other agents discover and transact with it in the wild.
Streaming, session-based billing via MPP for high-frequency consumers.

ARGUS runs autonomously, reasons transparently, cites everything, and pays for itself. One command in — intelligence, and income, out.

Built With

• agents
• clickhouse
• crypto
• cursor
• gemini
• gensyn
• prometheux
• python
• senso
• typescript
• x402