Skip to content
BranchesTags

Repository files navigation

Argus

Circle Alliance Member Live Legacy URL X Telegram community Email live scans live patrols treasury Treasury Funding Oracle OKX AI Listed MCP server on npm Smithery listing ChainGPT Audited
Agent Ξ± Agent Ξ² Agent Ξ³ API health

΀ρΡις οφθαλμοί. Μία κρίσις. β€” Three eyes. One verdict.

Argus Demo Video β€” Updated Jul 10
▢️ Watch the demo (3 min) β€” New UI, real-time patrol, Unibase AI caught live

Arc's first security layer. Live now. An official Circle Alliance member. Three autonomous agents β€” two AI models + a deterministic rule engine β€” stake real USDC on every verdict. They pay each other when they disagree. They patrol every 15 minutes without being asked. 1,637 verdicts from 360+ users, all on-chain. When Arc mainnet launches, Argus is already running. Circle Alliance Directory β†’

For creators launching tokens on Arc. Audits cost $5K and take weeks. Argus costs $0.01 and takes 30 seconds. Paste an address β†’ three agents vote β†’ verdict on-chain forever. No API key. No MetaMask. No setup. Works on mobile. Builders can skip the browser entirely with the SDK (npm i @ogxavier/argus-sdk) or the MCP server (npx @ogxavier/mcp). Your community deserves to know what they're buying. Try it β†’

1,637 scans $24.12 treasury 363+ users 5.7K OKX sales 5/5 Circle primitives

Live: argusarc.dev (primary) Β· Legacy: argusarc.xyz Β· Telegram: t.me/Argusarc_bot Β· CLI: npx argus-scan@latest Β· SDK: npm i @ogxavier/argus-sdk Β· MCP: @ogxavier/mcp Β· Smithery: argus-arc/argus Β· X: @Argus_arc Β· Patrol: Agents scanning live

Prior Art #08, live on Arc. Reputation you post as collateral, not a score you ask to be trusted. Agent-to-agent nanopayments settle in under 500ms β€” every dissent costs real USDC. See the agent economy β†’

Argus, Scored Against the Lepton Rubric

Judging Criterion (Lepton) Argus
Agentic Sophistication (30%) Three independent agents, DeepSeek-V3, Claude Sonnet 4.5, and a deterministic rule engine, each with its own Circle SCA wallet and on-chain ELO. The patrol loop runs every 15 minutes with zero human input: agents scan, stake, settle, and record on-chain entirely on their own. Agents decide, not automate.
Traction (30%) 363+ users, 1,637 scans, 3,078 autonomous patrols, $24.12 USDC in on-chain scan fees. 5.7K OKX sales at 4.94β˜…. On X: 158 followers, 15K impressions, ~500 engagements per post on average. People aren't scrolling past; they're watching, reposting, and scanning the tokens we flag. Circle Alliance member with a live directory listing. Every number verifiable on ArcScan.
Circle Tool Usage (20%) All 5 Circle primitives live in production, doing real work on every scan: Gateway x402 collects the $0.01 fee, Agent Wallets stake USDC on every verdict, Dev-Controlled Wallets onboard users with zero setup, Contracts write verdicts and ELO on-chain via ArgusOracle, and App Kit Unified Balance shows chain-abstracted USDC. Circle Alliance Program member, listed at partners.circle.com/partner/argus.
Innovation (20%) AI agents that bet real money on their own security verdicts. Three independent minds, two AI model families plus a deterministic engine, audit every contract. Each agent stakes USDC on its answer; when it's wrong, it pays the winners. On-chain ELO makes reputation real collateral, Prior Art #08. That is genuine multi-model consensus, not three calls to one API. Nanopayments settle in under 500ms, and Argus shipped as an MCP server for Claude and ChatGPT ahead of the rest of the cohort.

Contents

Supplemental docs:

Why This Exists

Arc mainnet is approaching. A Blockscout explorer is already indexing. When mainnet goes live, tokens will launch immediately β€” most without audits, without security, without any way to know what's safe. That's not speculation. That's every chain launch in crypto history. Argus was built for this moment: three autonomous agents with real stakes, real ELO, and an economy that runs whether anyone's watching or not. Testnet today, mainnet-ready tomorrow.

Token scams and malicious contracts drain billions annually. Audits cost $5Kβ€”$50K and take weeks. The people who need security most β€” retail traders, small DAOs, memecoin communities β€” can't access it.

Nanopayments change the equation. When a payment can be $0.01, settled in under half a second with gasless batching on Arc, a security check becomes cheaper than the coffee you drank while reading about the token.

Argus makes contract security a nanopayment-native primitive. Three independent agents analyze every contract. They stake real USDC on their verdicts, reach consensus, and pay each other when they disagree.

"The hard part of a payments product was never the rail. It was finding the people." β€” Canteen

Argus is a Distribution Bootstrap security sidecar. No signup. No API key. Paste an address, get a verdict. For builders: npm i @ogxavier/argus-sdk and call scan() in one line.

Creator flow: Launch token β†’ paste address β€” Argus returns SAFE (3/3) β†’ post verdict in Discord β€” community apes with confidence. $0.01. 30 seconds. On-chain forever.

Built for everyone. Connect with MetaMask or click "Get Started" on mobile β€” Circle wallet created instantly. No signup. No email. Web, CLI, Telegram, or MCP β€” same consensus, your choice.

When Arc mainnet ships, Argus will be live on day one β€” 1,637 scans of battle-testing on testnet behind it. Three independent agents, staking real USDC on every verdict, paying each other when they disagree. The third eye is the tiebreaker. Always has been.

πŸ” Caught in the Wild

Unibase AI β€” Scammers blocked us (Jun 23)

A trending token called Unibase AI. Our agents scanned it and found: unlimited minting, 100% transfer fee (no one could sell), wash trading for fake volume, upgradeable proxy, computer-generated deployer addresses. 2/3 agents voted SCAM. We posted the verdict on X. Within hours, Unibase AI blocked us β€” confirming they saw it and wanted it silenced. Community members who saw our verdict avoided being rugged. See the post β†’

"Was worth the risk πŸ˜‚πŸ˜‚" β€” actual community response

$CZ token β€” 1.6K impressions in 24 hours (Jul 4)

A token claiming CZ Binance affiliation started trending. Our agents flagged: unverified contract, extreme holder concentration (one wallet controlled majority supply), exploit pattern matches. The scan reached 1.6K impressions in under 24 hours and brought in 10+ new followers. Real traders using real tools to avoid real scams β€” in real time. See the thread β†’

How It Works

5/5 Circle primitives. Agent-to-agent nanopayments. Autonomous patrol loop. Every piece of the Arc stack, integrated and live. Three autonomous agents with real wallets, real stakes, real ELO β€” scanning, paying, and patrolling. All on-chain. All verifiable. Watch them work ?

flowchart TB
    U[User] -->|$0.01 USDC| GW[Gateway x402]
    U -->|paste address| WEB[Web - argusarc.dev]
    U -->|npx| CLI[CLI - npx argus-scan]
    U -->|/scan| TG[Telegram - t.me/Argusarc_bot]
    U -->|MCP| MCP[Claude / ChatGPT - npx @ogxavier/mcp]

    WEB --> O[Orchestrator]
    CLI --> O
    TG --> O
    MCP --> O

    O -->|fan out| A[Agent Alpha - DeepSeek-V3 - Contract logic]
    O -->|fan out| B[Agent Beta - Claude Sonnet 4.5 - Tokenomics]
    O -->|fan out| G[Agent Gamma - Rule Engine - Deterministic]

    A -->|verdict + stake| C[Consensus - 2/3 threshold]
    B -->|verdict + stake| C
    G -->|verdict + stake| C

    C -->|SAFE / RISKY / SCAM| R[Verdict]
    C -->|dissenters pay winners| P[Agent Payments - 0.0005 USDC each]
    C -->|record verdict| ORA[ArgusOracle - on-chain]

    GW -->|$0.01 fee| TR[Treasury]
    GW -->|fund wallets| W[Circle Wallets]
Loading

Arc's Malachite BFT consensus provides deterministic sub-second finality with zero reorg risk. Argus verdicts settle on the same finality guarantee β€” once a consensus result is recorded, it's immutable. No waiting for confirmations. No probabilistic uncertainty. The payment clears and the verdict stands.

Autonomous Patrol β€” Agents Don't Wait for Humans

Agents scan, stake, and settle on their own β€” every 15 minutes, no human in the loop. Same 3-agent consensus pipeline as a user scan, initiated autonomously. See it live ?

The patrol mirrors community activity: every 3rd scan picks a random address from recent user scans, ensuring agents keep eyes on what the community is actually looking at. Between those, it sanity-checks Arc-native tokens and mainnet bluechips to verify the agents aren't drifting.

What Value
Loop interval Every 15 minutes (96 patrols/day)
Watchlist 8 base tokens (Arc-native + mainnet bluechips + DeFi staples) + recent user-scanned addresses
Per patrol Full 3-agent consensus + on-chain verdict + ELO update + agent payments

Live patrol feed: argusarc.dev/patrol β€” every autonomous scan with verdict, consensus breakdown, agent payments, and ArcScan TX link. The agents are provably alive. This is not a demo β€” it's a living, breathing agent economy.

Why Arc

Argus could only exist on Arc:

  • Native USDC gas β€” $0.01 scans, no volatile gas token, no fee surprise
  • Malachite BFT finality β€” verdict and agent payment settle in the same sub-second instant
  • Gateway x402 β€” 100+ agent payments cleared at zero gas cost to users via gasless batching
  • Cross-protocol composability β€” agents compose Circle primitives with other Arc protocols
  • 5/5 Circle primitives β€” Gateway, Agent Wallets, Dev-Controlled Wallets, Contracts, App Kit β€” each solves a problem that would otherwise need external infra

The Argus Council

Three independent agents form the Council β€” two AI models for deep reasoning, one deterministic rule engine for reproducible safety checks. Each has its own Circle wallet, its own credit line, its own on-chain ELO reputation. They vote with real USDC β€” not opinions, stakes. 2/3 carries the verdict. Dissenters pay winners. The rule engine catches what LLMs hallucinate; the LLMs catch what rules miss.

Council Member Model Role Cost per scan
Agent Ξ± DeepSeek-V3 Contract-level security: ownership, proxies, honeypots, access control, upgradeability, external calls ~$0.001
Agent Ξ² Claude Sonnet 4.5 Tokenomics & market structure: holder distribution, whale concentration, LP depth, trading patterns, buy/sell taxes, wash trading. Tokenomics inferred from training data β€” live holder/LP queries planned for v0.15 ~$0.002
Agent Ξ² Rule Engine (local) Deterministic safety net β€” reproducible, zero-hallucination checks: address entropy, digit-run heuristics, known scam deployer patterns, EIP-55 validation, blacklist matching. Catches what LLMs miss. $0 (no API)

Each council member operates independently β€” no shared state, no prompt leakage between models. Agent Ξ³ is deterministic and reproducible; run the same address twice, get the same result. Agents Ξ± and Ξ² draw from different model families β€” DeepSeek-V3 and Anthropic Claude Sonnet 4.5 β€” with Ξ² defaulting to Claude and falling back to DeepSeek for reliability. This creates genuine cognitive diversity across the Council.

Why a council? Because single-model security scanners trust one API's opinion. The Council requires agreement to surface truth. When Agent Ξ² (the tokenomics skeptic) and Agent Ξ³ (the pattern matcher) both flag a contract as RISKY while Agent Ξ± calls it SAFE, the Council surfaces the split β€” and the user sees exactly why each member voted the way it did, with full reasoning.

All agent prompts are open source: agent/src/agents/. See AGENTS.md to plug any AI agent into Argus.

Circle/Arc Stack

How payments work: For Circle "Get Started" users (no MetaMask), the funding wallet covers the $0.01 scan fee and sends it to treasury. This is why all treasury transactions appear from a single address β€” it's the funding wallet paying on behalf of users who onboarded via one-click Circle wallets. MetaMask users pay directly from their own wallet. Every transaction is verifiable on ArcScan.

Argus integrates all 5 Circle developer primitives:

Primitive Status How Argus Uses It
Gateway x402 βœ“ Live $0.01 USDC nanopayment paywall on every scan. Gasless batched settlement.
Agent Wallets βœ“ Live Three autonomous Circle SCAs β€” one per agent. Each stakes USDC on verdicts independently.
Dev-Controlled Wallets βœ“ Live Pre-created wallet pool. Users get instant SCA wallets β€” no MetaMask, no extension. 220-wallet live pool (728 total with historical assignments), auto-refill.
Contracts βœ“ Live On-chain ELO reputation via ArgusOracle. Immutable verdict log + ELO scores written to Arc after every scan.
App Kit βœ“ Live Unified Balance (chain-abstracted USDC across all Circle chains). Adapter SDK integrated β€” Send, Bridge, and Swap activate automatically when Arc joins the Circle chain registry.

Every scan result is verifiable on-chain. Treasury, funding wallet, agent wallets, and oracle β€” all publicly auditable on ArcScan.

File path map β€” verify every primitive in 30 seconds:

Primitive File What it does
Gateway x402 agent/src/gateway.ts $0.01 USDC paywall per scan β€” gasless batched settlement
Agent Wallets (SCA) agent/src/wallets/funding.ts 3 wallets, one per agent β€” hold and stake USDC independently
Dev-Controlled Wallets agent/src/wallets/precreate.ts 220-wallet live pool, assigned to new users on arrival β€” no MetaMask needed
Contracts contracts/contracts/ArgusOracle.sol Immutable on-chain verdict log + ELO reputation scores
App Kit Unified Balance frontend/lib/wallet-context.tsx Chain-abstracted USDC balance display for Circle + MetaMask users

Circle Alliance Program

Circle Alliance Program

On August 14, 2026, Argus was accepted into the Circle Alliance Program. Our listing is live in the official directory: partners.circle.com/partner/argus.

Circle's Alliance Program is a curated global network of companies building on USDC and Circle infrastructure. Membership is reviewed and approved by the Circle team. It is not a sponsorship. It is recognition that the depth of integration matters: we run all five Circle primitives in production on every single scan.

What acceptance validates:

  • 5/5 Circle primitives live with real transaction volume, not demos
  • Agent Wallets staking real USDC on every verdict since June
  • The x402 nanopayment rail processing thousands of real scans
  • An on-chain oracle contract Circle can inspect on ArcScan

What it means for Arc Mainnet (Sept 16):

  • Direct line to Circle engineering through Alliance channels
  • Co-marketing and launch coordination as an approved partner
  • Early awareness of Arc mainnet infrastructure changes
  • A seat in the ecosystem building the agentic economy

Challenges we cleared to get here:

  • Built and shipped through the Lepton hackathon, then kept shipping after it ended
  • Caught real scams live (Unibase AI) and took the heat for it
  • Survived redeploys, RPC outages, and three external security findings
  • Went from a hackathon entry to a listed, partnered, revenue-generating product

Argus is not a hackathon project with a deadline. It is infrastructure with a launch date. The goal was never to win a weekend. It is to become the first and most sophisticated security layer on Arc, live on day one of mainnet, already battle-tested by thousands of scans before the chain even opens.

Real-World Catches

Argus isn't theoretical. These are real tokens, real scans, real consequences.

Unibase AI β€” "Scammers blocked us" (Jun 23)

Our agents scanned a trending token called Unibase AI and found:

  • Unlimited minting β€” the deployer could print infinite tokens
  • 100% transfer fee β€” no one could sell once they bought
  • Wash trading β€” fake volume to simulate activity
  • Upgradeable proxy β€” contract logic could change at any time
  • Computer-generated addresses β€” mass-deployed scam pattern

2/3 agents voted SCAM. We posted the verdict on X. Within hours, Unibase AI blocked us β€” confirming they saw the post and wanted it silenced. Community members who saw our verdict avoided being rugged. See the post β†’

"Was worth the risk πŸ˜‚πŸ˜‚" β€” actual community response

$CZ token β€” 1.6K impressions in 24 hours (Jul 4)

A token claiming association with CZ Binance started trending. Our agents flagged:

  • Unverified contract β€” no source code transparency
  • Extreme holder concentration β€” one wallet controlled majority supply
  • Exploit pattern matches β€” matched signatures of known rug pulls

The scan reached 1.6K impressions in under 24 hours and brought in 10+ new followers. Real traders using real tools to avoid real scams β€” in real time. See the thread ?

Agent-to-Agent Nanopayments (RFB 3)

Since v0.6, Argus agents run an internal economy. Since v0.12, stakes are confidence-weighted:

  • The losing agent pays up to 0.001 USDC scaled by their confidence β€” a 95%-sure agent risks more than a 55%-sure one
  • Formula: stake = 0.0005 β€” (2 β€” confidenceRatio) β€” rewards calibrated certainty, not bravado
  • Settled on-chain via native USDC transfers on Arc

This directly implements Prior Art #08 from the Lepton brief: "Reputation you post as collateral, not a score you ask to be trusted." The banker staked his own standing on the coin he vouched for β€” the trapezitai and argentarii. Argus agents do the same, in real time, on-chain, per decision.

Agent Ξ³ votes SAFE. Agents Ξ± and Ξ² vote RISKY.
Consensus: 2/3 β†’ RISKY. Agent Ξ³ is the loser.

Agent Ξ³ β†’ Agent Ξ±: 0.0005 USDC β†’
Agent Ξ³ β†’ Agent Ξ²: 0.0005 USDC β†’

Total agent economy volume visible at /agent-payments

Argus agents do exactly this β€” in real time, on-chain, per decision. Every dissent costs 0.0005 USDC. Every wrong verdict drops ELO. No trust required. The stakes are public. The slash is automatic. This is Prior Art #08, live on Arc.

Why 20 USDC per agent? Agents are judges, not banks. Each holds a flat 20 USDC stake β€” enough to cover 40,000 dissents at 0.0005 USDC each. Their balances stay stable because stakes are tiny by design. The real money flows elsewhere: the treasury holds $24.12 USDC from accumulated scan fees. Two pools, two purposes β€” agents hold collateral for verdicts, the treasury holds revenue from scans. Both verifiable on-chain.

Pool Balance Purpose ArcScan
Agent wallets (3) 20 USDC each Staking collateral Ξ± Β· Ξ² Β· Ξ³
Treasury $24.12 USDC Scan fee accumulation View

No MetaMask Required

The biggest onboarding unlock. Since v0.6:

  1. User visits argusarc.dev (primary domain β€” argusarc.xyz was retired Aug 3 after Canteen flagged .xyz spam filtering on US residential IPs)
  2. Clicks "Get Started"
  3. Backend assigns a pre-created Circle SCA wallet instantly
  4. Funding wallet sends $0.10 test USDC
  5. User pastes a token address and scans β€” 30 seconds, no extension, works on mobile

MetaMask remains available as a secondary option. But the primary path requires nothing but a browser.

Live Verification

# Agent health
curl https://argus-web-backend-production.up.railway.app/health

# Current stats (1,637 scans, 89.6% consensus)
curl https://argus-web-backend-production.up.railway.app/stats | jq .

# ELO leaderboard
curl https://argus-web-backend-production.up.railway.app/elo | jq .

# Agent-to-agent payment history
curl https://argus-web-backend-production.up.railway.app/agent-payments | jq .

# Treasury balance (on-chain)
curl https://argus-web-backend-production.up.railway.app/treasury | jq .

# Wallet pool stats
curl https://argus-web-backend-production.up.railway.app/wallet/pool-stats | jq .

# App Kit Unified Balance (5/5 Circle primitives)
curl https://argus-web-backend-production.up.railway.app/balance/unified/0x0699a029e2e05EC88d6418EC744232702Cf77d81 | jq .

All addresses are public and verifiable on ArcScan:

Wallet Address ArcScan
Treasury 0x0699a029e2e05EC88d6418EC744232702Cf77d81 View
Funding 0x4Dd5e289168ddb28f9b34134EAbccAF373eb64Cb View
ArgusOracle 0x563b2DA572948C2b54B5f1f26CcFebC153Cb46C8 View
Agent a (SCA) 0x284e38e6f139b3b85c746e00f8a3cf46d2b2d320 View
Agent Β· (SCA) 0x3f752a72d8e2d9d3a4f2011ca9e0407bc5b7a34f View
Agent Ξ³ (SCA) 0x1fa79f59abbada269de477b45ded38c75a6146de View

Why Argus, Not an Existing Scanner

Token scanners exist. Argus isn't one β€” it's a multi-agent security oracle with an internal economy, running autonomously on Arc.

Capability Typical Scanners Argus
Architecture Single API call 3 independent agents (2 AI + 1 deterministic) vote with real stakes
Economic stakes None β€” free API, no skin in the game Agents stake real USDC; dissenters pay winners; ELO drops on wrong calls
Payment rail Free or subscription fiat $0.01 USDC via Gateway x402 β€” gasless, batched, on-chain
No wallet required Browser extension or signup Circle pre-created wallets β€” works on mobile, 30s onboarding
On-chain verifiability Proprietary reports, no chain proof Every verdict, payment, and ELO on ArcScan
Autonomous operation Only scans when asked Patrol loop β€” agents scan every 15 min with zero human input
Chain-native Chain-agnostic (Ethereum focus) Arc-native from the metal up β€” 5/5 Circle primitives, USDC gas
Multi-platform Web only Web, CLI (npx argus-scan), Telegram (/scan), SDK (@ogxavier/argus-sdk), and MCP (@ogxavier/mcp β€” Claude & ChatGPT)
Reputation system Static scores or none On-chain ELO per agent β€” proper pairwise math, updated after every scan

Argus isn't a scanner ported to Arc β€” it's Arc-native infrastructure. Every address, transaction, and verdict is verifiable on ArcScan. No other security tool can say that.

Smart Contracts

ArgusOracle.sol

Address: 0x563b2DA572948C2b54B5f1f26CcFebC153Cb46C8 on Arc testnet (chain 5042002)

Immutable verdict log + on-chain ELO reputation engine. Every Council verdict is recorded on-chain:

function updateElo(string agentId, int256 eloDelta) external;
function getElo(string agentId) external view returns (int256);
function recordVerdict(address token, string verdict, uint8 agreementCount) external;
  • Contract address analyzed
  • Final verdict (SAFE / RISKY / SCAM)
  • Council breakdown (which members agreed/dissented)
  • Timestamp and query ID
  • Settlement batch reference
  • ELO deltas written per Council member after every verdict

Deployed with Solidity 0.8.28 via IR pipeline. Minimal, dependency-free, gas-optimized for Arc's native USDC model. View on ArcScan β†’

πŸ”’ Audited by ChainGPT β€” July 2026. Zero critical vulnerabilities. Zero exploits. One design consideration: open access to recordQuery/updateElo is intentional for transparency on testnet; mainnet deployment will add orchestrator-gated write access. Full report β†’

Why We Audited

Argus scans everyone else's contracts. The obvious question: who audits Argus?

We put our own oracle through ChainGPT before Arc mainnet. Not because we expected to find anything β€” the contract is 100 lines of Solidity, deliberately minimal, no dependencies β€” but because a security product that doesn't scrutinize its own foundation has no business scrutinizing anyone else's.

Zero criticals. Zero exploits. The one thing they flagged β€” open write access β€” is intentional. ArgusOracle is a transparency layer, not a gated registry. Anyone can verify the verdict log independently. On mainnet, we'll gate writes to the orchestrator as defense-in-depth while keeping reads fully public.

An AI audit doesn't replace a manual one. It's a first pass. But for a 100-line contract built to be verifiable by design, it confirms what the architecture already enforces: the simplest possible surface area, the fewest possible attack vectors.

Eat your own dogfood. Every contract Argus scans from now on β€” your token, your DAO, your bridge β€” goes through a system whose own contract passed audit first.

What Makes This Different

  1. Arc-native from the metal up β€” built on Arc primitives, settled in USDC, verifiable on ArcScan. Not a port. Not a wrapper. Native.
  2. Genuine multi-agent consensus β€” three independent models (DeepSeek-V3, Claude Sonnet 4.5, deterministic rule engine), not three calls to the same API
  3. Real economic stakes β€” agents stake real USDC; dissenters pay winners; ELO is proper pairwise math, not a static score
  4. Ships real payments β€” $0.01 USDC through Gateway x402, treasury verifiable on-chain, agent-to-agent economy live
  5. No wallet required β€” Circle pre-create wallets, works on mobile, 30-second onboarding
  6. Publicly verifiable β€” every address, transaction, and verdict on ArcScan. No trust required.
  7. Distribution Bootstrap security sidecar β€” any token launch, any DAO, any trader can call for $0.01 via Web, CLI, Telegram, MCP, npm, or OKX Marketplace. No signup required. Just an address.
  8. Agents don't wait to be asked β€” autonomous patrol loop scans every 15 minutes, no human in the loop. Agents stake, settle, and record on-chain. Live ?

What's Next

Phase What Status
v0.1β€”v0.8 Core oracle, paid scans, ELO, agent economy, Circle wallets, App Kit βœ“ Shipped (Jun 15β€”23)
v0.9 UI redesign, Case Files archive, shareable scan links, Gamma rework, evidence sources, agent contributions, risk scores βœ“ Shipped (Jun 24β€”25)
v0.10 CLI tool (npx argus-scan), retention features, polish βœ“ Shipped (Jun 29)
v0.11 Telegram bot (t.me/Argusarc_bot) β€” third surface, multi-platform reach βœ“ Shipped (Jul 1)
v0.12 Confidence-weighted staking β€” agents stake proportionally to certainty. Higher confidence = bigger stake at risk. Rewards accuracy, not bravado βœ“ Shipped (Jul 3)
v0.13 Autonomous patrol loop β€” agents scan on their own every 15 min. No human asks. Staking, settlement, on-chain recording. Live at argusarc.dev/patrol βœ“ Shipped (Jul 4)
v0.14 @ogxavier/argus-sdk β€” TypeScript SDK on npm. Any dApp or AI agent: npm i @ogxavier/argus-sdk, import { scan } from '@ogxavier/argus-sdk' βœ“ Shipped (Jul 21)
v0.14.1 @ogxavier/mcp β€” MCP server for Claude & ChatGPT (stdio + streamable HTTP). Four tools: scan_contract, recent_scans, agent_elo, pool_stats. Live on npm + Smithery βœ“ Shipped (Aug 16)
v0.15 Uptime insurance β€” automated healthcheck + CI redeploy. If agent goes offline, Circle wallet self-refunds last scan. <500ms failover Post-mainnet
v0.16 Agent Ξ² on-chain upgrade β€” real-time holder queries, DEX liquidity data Post-mainnet
v0.17 Circle W3S migration β€” Programmable Wallets, no raw private keys in env Post-mainnet
v1.0 Arc mainnet launch β€” Argus goes live alongside mainnet. Same agents, same stakes, real USDC, real value at risk. Every new token on Arc gets a verdict Mainnet-ready

Honest Limits

What Argus does NOT claim β€” and what's planned.

Limit Status
Agent analysis is AI-inferred, not on-chain bytecode audit Agents use training knowledge + pattern matching. They cannot decompile or verify deployed bytecode. For well-known contracts this is reliable; for obscure tokens, treat as a strong signal, not a guarantee.
Private keys in environment variables Agent wallets use raw private keys for signing. Planned: migrate to Circle W3S Programmable Wallets so no key material sits in worker processes.
Holder distribution + liquidity are estimated Agent Ξ² infers tokenomics from training data β€” it does not query holder snapshots or DEX liquidity pools in real-time. Production upgrade: integrate on-chain balanceOf queries + DexScreener/GeckoTerminal APIs.
Arc testnet only All USDC is testnet. No real value at risk. Mainnet deployment requires Circle production access + real USDC liquidity.
Single oracle address ArgusOracle.sol has one owner. Multi-sig or DAO-governed upgrade is planned for mainnet.

Accuracy Evaluation

41 tokens (27 known + 14 held-out). Positive class = SCAM; RISKY on SAFE = incorrect, RISKY on SCAM = correct. Methodology ?

100% precision. Zero false positives. Never flags safe tokens as scams. On known contracts (Etherscan-verified source code available), Argus catches everything β€” the documented scam (Unibase AI) is flagged, all 24 safe tokens pass, and the two high-concentration meme tokens (SHIB, SQUID) are correctly flagged RISKY. On held-out tokens, recall drops to 50% (2/4 scams caught) when no verified source code is available. The 2 missed scams are unverified contracts with zero on-chain metadata β€” no security tool can analyze contracts it cannot see. Agent Ξ²'s v0.15 upgrade (real-time balanceOf + holder queries) targets this gap directly.

For creators: your legitimate launch is never wrongly flagged. For traders: a SAFE verdict is a SAFE verdict. For the 2 unknown scams missed: on-chain data queries shipping in v0.15.

v1 55% (blind heuristics) β†’ v5: 100% precision on held-out tokens. 41 tokens tested (27 known + 14 held-out). Methodology ?

Cohort Tokens Accuracy Precision Recall Notes
Known (database-backed) 27 100% 100% 100% 1/1 scam flagged, 24/24 safe, SHIB + SQUID flagged RISKY
Held-out (no DB entries) 14 85.7% 100% 50%* 10/10 safe (all correct), 2/4 scam caught

The 2 missed scams lack verified Etherscan source code β€” agents had no contract metadata to analyze. This is a data availability ceiling, not an accuracy ceiling. All 10 legitimate tokens correctly classified. Inter-agent disagreement: 14.3%. Reproduce: cd benchmark && npx tsx report.ts.

Traction

Real usage on Arc testnet. Every number is verifiable on-chain. When Arc mainnet launches, these agents will be live as security infrastructure on the chain β€” 363+ users and 1,637 scans of battle-testing behind them.

Metrics

Metric Value Proof
Scans processed 1,637 /stats endpoint β€” on-chain records
Consensus reached 1,466 (89.6%) 3-agent pipeline live since Jun 16
Users 363+ Web Β· CLI Β· Telegram Β· MCP Β· multi-platform
Treasury balance $24.12 USDC ArcScan
Autonomous patrol scans 3,078 15-min loop, zero human input since launch
Agent economy volume 100+ payments Losers pay winners 0.0005 USDC per dissent
ELO leaderboard Ξ± 20,002 Β· Ξ² 20,045 Β· Ξ³ 19,936 /elo endpoint β€” on-chain
Circle primitives 5/5 Gateway x402 β€” Agent Wallets β€” Dev-Controlled Wallets β€” Contracts β€” App Kit
OKX AI Marketplace Agent #5047 5.7K sold Β· 241 reviews Β· 4.94β˜…
MCP distribution Claude Β· ChatGPT Β· Smithery @ogxavier/mcp Β· Smithery

How we count

Team test wallets are excluded from all user-facing counts. The store tracks distinctTokens, medianScansPerUser, teamScansExcluded, and scansPerDay β€” all exposed at GET /stats. Team addresses: treasury (0x0699...), funding wallet (0x4Dd5...), 3 agent SCAs + 3 agent EOAs, and the benchmark user. teamScansExcluded: 0 confirms no team test activity contaminated real user counts. True distinct token count: 45 tracked contracts across 1,637 scans (popular tokens like USDC, WETH, USDT are re-scanned by many users; the long tail is 1β€”2 scans per token). Median scans per user is 1 β€” most try Argus once or twice; a core group of ~25 power users drives 80% of scan volume. This is early-stage retention typical of a 6-week-old product.

User Growth

During hackathon (Jun 16 β€” Jul 6)

Milestone Date Users Scans Treasury
3-agent consensus live Jun 16 0 5 $0.00
argusarc.dev live Jun 18β€”20 0 45 (team tests) $0.00
Circle wallet launch Jun 21 10 340 $0.22
Circle wallet growth Jun 22β€”25 100 561 $3.00
CLI shipped to npm Jun 29 109 648 $5.80
Telegram bot live Jul 1 121 666 $6.93
800 scans β€” 127 users Jul 3 127 810 $7.93
Autonomous patrol live Jul 5 150 1,090 + 454 patrol $10.00

Post-hackathon (Jul 7 β€” present)

Milestone Date Users Scans Treasury
Telegram + X growth Jul 9 160 1,150 $11.50
ChainGPT audit passed Jul 17 210 1,382 + 1,144 patrol $14.38
SDK shipped to npm Jul 21 300+ 1,508 + 2,430 patrol $15.86
OKX 5.7K sales Β· Current Aug 10 350+ 1,508 + 2,430 patrol $21.10
MCP + Smithery live Aug 16 363+ 1,637 + 3,078 patrol $24.12

User counts = distinct funded wallets, verifiable on-chain via Funding Wallet (0x4Dd5...) outflows. Measured from wallet_pool.json assignedAt timestamps β€” 323 assigned wallets across 430 total. Users acquired organically through crypto communities and word of mouth. No paid acquisition.

Most users discover Argus through the Telegram community (80+ members) β€” a group chat where people share scan results, flag suspicious tokens, and help each other stay safe. The community is the distribution channel. Drop in and see what people are scanning right now.

On X, @Argus_arc grew from 0 to 158 followers over 7 weeks, with 15K total impressions and a 5.7% engagement rate β€” well above crypto-twitter averages. Growth accelerated this week with new users discovering Argus through the OKX AI Marketplace. People aren't scrolling past; they're reading, reposting, and scanning the tokens we flag.

363+ users, 1,637 scans. Power users run 20+ scans β€” when Argus clicks, it becomes part of the workflow. They come back when tokens move, when friends shill, when they need to know. Argus grows from first scan into a habit.

Cross-Ecosystem: OKX AI Marketplace

Argus is now an ASP on the OKX AI Marketplace β€” Agent #5047, running on X Layer Mainnet. View listing ?

This wasn't a simple deploy. It was a stress test of everything Argus claims to be.

Why we did it

Two reasons:

  1. Prove agent-to-agent nanopayments work. Argus runs on x402 β€” the same HTTP 402 nanopayment protocol that Arc's Circle Gateway uses. Deploying to OKX AI meant implementing the full v2 spec from scratch: PAYMENT-SIGNATURE header detection, PAYMENT-REQUIRED challenge response, PAYMENT-RESPONSE settlement confirmation, EIP-3009 transferWithAuthorization on USDT0, retry queue with 30-second backoff, gas balance monitoring. If x402 only worked on Arc, it wasn't real infrastructure. It works on X Layer. It works on Arc. The protocol is portable. The agent economy is cross-chain.

  2. Put Argus where agents transact. The OKX A2A marketplace has ASPs that form businesses, profile wallets, and verify AI pipelines. But before any of those agents act, someone needs to answer: "Is this contract safe?" Argus now answers that question on OKX AI β€” the same 3-agent consensus, the same USDC stakes, the same autonomous patrols. The security layer doesn't belong to one chain. It belongs wherever agents transact.

What broke (and what it taught us)

The x402 compliance validation exposed real bugs β€” the kind you only find when an external engineering team tests your endpoints with a different client than your own:

  • Header name mismatch: The OKX marketplace sends PAYMENT-SIGNATURE (v2 spec). Our middleware only checked legacy header names (x-payment, x-payment-authorization). Every paid POST fell through to 402. The fix required reading the actual OKX protocol specification β€” not guessing, not trial-and-error, but reading the source of truth.

  • Truncated facilitator key: A 64-hex-char private key had been truncated to 42 chars somewhere in our configuration pipeline. The server's raw.length < 64 guard silently returned null. The facilitator never had a signer. Payments settled on-chain to the owner wallet, but the facilitator never claimed them. 5 ghost-accepted tasks before this was caught.

  • Function selector verification: USDT0 on X Layer uses transferWithAuthorization (selector 0xe3ee160e), not claimWithAuthorization. We verified this by decoding a real settlement transaction on-chain at block 65,342,733 β€” the function was correct, the settlement was real.

  • Six rounds of debugging with OKX engineering (July 14, 2026) across all 4 of our agents simultaneously. Every round exposed a new edge case: base64url encoding, 65-byte hex signature parsing, validBefore/validAfter from the auth object vs hardcoded values, non-blocking settlement vs blocking, idempotent delivery for repeat payments.

The full debug log is at ENGINEERING_DEBUG_LOG.md β€” 6 real bugs encountered and solved.

What this proves

  • x402 nanopayments are production-ready. The same protocol that powers Arc's Gateway also powers OKX AI's marketplace. Agent-to-agent payments settle in under 500ms on both chains. The rail works.

  • Argus is portable infrastructure. Same 3-agent consensus. Same USDC staking. Same autonomous patrol. Different chain. The architecture doesn't care where it runs.

  • The agent economy needs a security layer β€” and it needs it everywhere. Argus caught Unibase AI on Arc. It caught $CZ token on Arc. It now watches OKX AI. More eyes. More chains. Same verdict.

  • External validation matters. OKX engineering reviewed every endpoint, every header, every settlement. They found bugs we missed. They validated the fixes. A security oracle that passes a security review from a different team carries more weight than one that was never tested outside its own repo.

5,700 sold on OKX AI Marketplace. 241 reviews. 4.94β˜…. All verifiable on-chain. Agent #5047. Live now. This is A2A commerce at scale β€” agents on X Layer paying agents on Arc for contract security, no humans in the loop.

Agent endpoint: https://argus-web-backend-production.up.railway.app/okx/scan
Marketplace: https://www.okx.ai/agents/5047
Settlement wallet: https://www.oklink.com/xlayer/address/0x53d724e6acd672ba08133bcd32b0412500bea79d

Telegram: Scan from Any Chat

t.me/Argusarc_bot β€” /scan 0x... from any chat. Auto-creates a Circle wallet per user, pays $0.01 USDC via Gateway x402, shows full agent reasoning + dissent payments. Three surfaces, one oracle.

CLI: Scan from Your Terminal

npx argus-scan@latest 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48

First run auto-creates a Circle wallet. $0.01 per scan via Gateway x402. Same 3-agent consensus β€” identical to web. Pipe-friendly JSON, stats, wallet commands.

?? argus-scan on npm β€” npm i -g argus-scan β€” Zero dependencies β€” Node 18+

MCP: Scan Inside Claude & ChatGPT

npx @ogxavier/mcp

Argus speaks the Model Context Protocol β€” the same 3-agent consensus, now a native tool inside any MCP client. Four tools: scan_contract, recent_scans, agent_elo, pool_stats.

Why we added it. When a user asks Claude or ChatGPT "is this token safe?", the model can now call Argus instead of guessing β€” real multi-agent consensus with on-chain settlement behind it. One npm package, four surfaces:

Surface How
Claude Desktop Settings β†’ Developer β†’ add {"mcpServers": {"argus": {"command": "npx", "args": ["-y", "@ogxavier/mcp"]}}}
Claude Code claude mcp add argus -- npx -y @ogxavier/mcp
ChatGPT Connectors β†’ MCP β†’ URL https://argus-mcp-production-8372.up.railway.app/mcp β€” or a Custom GPT with Actions: https://argus-mcp-production-8372.up.railway.app/openapi.json
Smithery One-click install: smithery.ai/servers/argus-arc/argus

πŸ”Œ @ogxavier/mcp on npm β€” stdio + streamable HTTP β€” full instructions in mcp/README.md

Quick Start

# Agent (requires .env β€” see agent/.env.example)
cd agent && npm install && npm run dev

# Frontend
cd frontend && npm install && npm run dev

# Contracts
cd contracts && npm install && npx hardhat compile

Cross-Protocol: Shadow Float V2

Agents use Shadow Float V2 for on-chain credit lines β€” EIP-712 signed borrowing with full lifecycle automation. View on ArcScan ?

Community

t.me/argus_communityy β€” 80+ members and growing. Users share scans, compare verdicts, flag suspicious tokens, and help each other stay safe. Drop in and see what people are scanning right now.

Real users, real feedback, same-day responses

Most projects ship in a vacuum. Argus ships with an audience watching, reporting, and confirming. Every DM gets a response within hours β€” and every report gets verified before it's believed. A few of them:

1. A trader told us Argus saved them from scam tokens β€” Aug 16, 2026

DM from @trillionaeon

"ur tool has been really helpful to me i degen a lot and argus has really saved me from some scam tokens. keep up the good work" β€” @trillionaeon

This is the entire thesis in one DM: real traders, real degen exposure, and Argus as the check between them and a rug.

2. A security project gets security-checked β€” Aug 17, 2026

SSL report from CriptoPoeta

SSL resolution thread

"Your website is down due to an invalid SSL certificate. Congrats on joining the Circle Alliance, but this isn't a good look for a security project." β€” @CriptoPoeta

We verified both domains within the hour (both valid, Let's Encrypt, freshly rotated) and walked him through the cache fix. Same-day closure β€” and a new follower who respects the response.

3. Canteen team flagged our domain β€” we migrated β€” Jul 29 β†’ Aug 3, 2026

Domain report from aadi (Canteen)

"heads up - argusarc.xyz does not load for me on my US residential IP address... Lots of xyz domains are filtered as spam nowadays" β€” aadi, Canteen team

Migration to argusarc.dev confirmed

We migrated to argusarc.dev on Aug 3 and asked aadi to re-test:

"works great, thank you!" β€” aadi, Canteen team

That's the loop that matters: someone reports, we fix, they confirm. Real-world feedback is rare in a hackathon. We collect it.

Team
Gideon Full-stack engineer, smart contracts, agent architecture, AI pipeline
Jazreel Product, distribution, community

License

MIT

Building in public β€” follow along
x.com/Argus_arc Β· argusarc.dev Β· alt: argusarc.xyz Β· github.com/Gideon145/argus

About

Arc's first multi-agent security oracle. 3 AI agents stake USDC on verdicts. 360+ users, 1,637+ scans. 5/5 Circle primitives. ChainGPT audited. An official Circle Alliance member.

argusarc.dev

Topics

agentsarccircleleptonmulti-agentnanopaymentsoraclesecuritysoliditytypescriptusdcx402

Resources

Readme
Activity

Stars

4 stars

Watchers

0 watching

Forks

1 fork
Report repository

Releases

Packages

Contributors

Languages