rudimentall1/agentic-wallet-guardian-v3

Watch the demo
Select the preview to play the video in your browser.
📄 Read the white paper
**Let AI agents transact on-chain without giving them unrestricted control of the wallet.** Guardian evaluates each proposed action before signing or broadcast and returns an explainable ALLOW / WARN / BLOCK decision.
It runs on your own infrastructure, using your own policy rules and your
own reputation data - see Why self-hosted for why that
matters and how this differs from calling a hosted security API directly.
Guardian is chain- and use-case-agnostic - Arc/USDC below is one live
deployment, not the whole scope. See docs/hackathons.md
for which track this submission targets and why.
Arc Mainnet Demo
**Live demo:** http://77.239.125.37:8765/arc
**Demo video:** https://youtu.be/srH0ZLwtwqQ
Agentic Wallet Guardian is deployed on Arc mainnet and includes a live browser demo for USDC payments. The Guardian evaluates the requested operation before execution, applies its security policies, and only an approved operation is passed to the user's wallet for signing.
**Verified Arc mainnet transaction:**
0xd781e8b04b5ca89c3a34fcec50a6636049f7647d2b0e1b2bb64d5b1ee54daadf
The transaction was successfully executed on Arc mainnet using USDC through the Guardian demo.
---
**See it decide, live:** run the API locally (GUARDIAN_ENABLE_CORS_FOR_BROWSER_DEMO=true
uvicorn api.main:app --reload), then open examples/browser-demo.html
in a browser - no build step, no server for the page itself. Every
scenario button sends a real POST /decision to your running instance
and renders the actual response (risk score, every signal that fed into
it, every policy rule that fired) - nothing in the page is scripted or
faked. GUARDIAN_ENABLE_CORS_FOR_BROWSER_DEMO is off by default (see
guardian/config.py) since it's specifically for this local-demo case,
not something to leave on for a real deployment.
---
Why self-hosted
There are good hosted alternatives for agent-transaction security (GoPlus's
AgentGuard, Blockaid, Chainalysis/TRM for compliance). If you just want a
risk score and don't care who sees the query, calling one of those directly
is less work than running this. Guardian exists for the cases where that
tradeoff doesn't work for you:
- **Nothing about which wallets, contracts, or amounts your agents touch
leaves your infrastructure.** Threat-intel and contract allow/deny checks
are local JSON files you populate yourself (see
data/threat_lists/README.md), not a lookup call to a third party. A
hosted API inherently sees every address and amount you ask it about.
- **Your policy rules live in your code, not a vendor's dashboard.**
Spending caps, reputation gates, and which action types require
confirmation are plain Python in guardian/policy/, reviewable and
changeable without waiting on anyone else's product roadmap.
- **No per-call fees or rate limits imposed by someone else** - only the
ones you configure for your own users (GUARDIAN_RATE_LIMIT_PER_MINUTE).
- **No vendor lock-in.** Every external data source (RPC endpoint,
Blockscout instance, DexScreener) is swappable behind a small provider
interface - see Architecture.
The honest tradeoff going the other way: you also take on running it,
keeping your local threat lists current, and you don't get a hosted
vendor's chain coverage or dedicated threat-research team for free. This is
the right choice for teams that specifically need data sovereignty or deep
policy customization - not a strict upgrade over every hosted option.
---
Architecture
Every data source in steps 2-4 is a small provider interface with a mock
implementation (zero config, zero network calls) and a real one, selected
per-source by environment variable - see .env.example. Switching from
demo mode to a real deployment is a config change, not a code change.
Repository layout
guardian/* is intentionally dependency-free (standard library only,
except where a real provider needs httpx or web3), so the decision
core can be unit-tested, embedded in another service, or ported to a
different web framework without dragging FastAPI along. Only api/
touches pydantic/FastAPI.
---
Honesty about the current state
This is real, runnable, tested decision infrastructure with real (not
mock) data sources available for every signal source - but "available"
isn't the same as "flip a switch and trust it blindly." Specifics:
- **Wallet (RPC provider):** is_contract and tx_count (nonce-based) are
reliable with any JSON-RPC endpoint. Wallet *age* requires an