I built 27 tools and an AI arbiter that settles escrow disputes on-chain

I run pigfox.com as a one-person shop. It's two things now: 27 tools, 16 of them free, covering OSINT, email security, TLS and document forensics — and three live smart-contract demos on Base Sepolia, one of which lets a language model decide who gets the money.

Both halves follow the same rule, and that rule is the actual subject of this post.

The rule: evidence first, interpretation second

There's a genre of tool I refused to build — paste a domain in a box, a model hallucinates a paragraph, you get a confident answer nobody can verify.

Every tool here hits real infrastructure first. DNS. WHOIS. TLS handshakes. Certificate-transparency logs. Raw EXIF bytes. Raw Received: headers. PDF object tables. The output shows you the signals it collected so you can check them yourself.

Five of the 27 call a model at all — and only after the evidence is on the table. Six more are metered without touching a model, because reverse-image lookups and WHOIS history cost money per query whether or not an LLM is involved. The other 16 are free and staying that way.

Now watch what happens when you take that rule on-chain.

The demos: where a model's output becomes a transaction

Three interactive demos, all live, all against Base Sepolia (chain 84532) — deployed contracts, real testnet transactions, hashes you can open in a block explorer.

There's a doctrine behind that: no forking. No --fork-url, no mainnet simulation, no mocked chain state. If a demo says something settled, there's a transaction hash. The Playwright E2E suite runs against the live chain too — slower, occasionally flaky, worth it. A test that passes against a mock proves nothing about a contract.

ZK Escrow Explorer — the AI arbiter

Two parties lock funds in an escrow contract. Something goes wrong. One opens a dispute. An AI arbiter reads the case and issues a ruling — and that ruling settles on-chain, moving funds.

Which is precisely the thing you should be nervous about. A language model deciding who gets paid is a terrible idea if the model is a trusted oracle with an open-ended mandate. So it isn't one:

• The action space is enumerated in the contract. The arbiter selects from a fixed set of settlements. It cannot invent an outcome, cannot pay a third party, cannot move an amount nobody escrowed. The worst case is a wrong pick from a short list — not an arbitrary transfer.
• The evidence is frozen before the model runs. Same rule as the tools. Case material is assembled first, the model reasons over it second.
• A Groth16 circuit carries the proof obligation, so a claim can be verified without the verifier seeing the private inputs behind it.
• UUPS proxy for upgradeability, because "we found a bug in the arbiter integration" has to be survivable.

Nine disputes have run end to end on-chain. Every one is inspectable.

That's what bounded AI means concretely: the model's role is narrow, its inputs are fixed, and the thing that executes its decision is a contract that structurally cannot do what the model was never allowed to ask for. The model proposes within a grammar. The chain disposes.

Compare that to the default posture — hand the model a tool that can call any function with any argument and hope the system prompt holds. That's the on-chain equivalent of vibe coding, and it's how you lose a treasury.

RWA Tokenization Explorer

An ERC-3643-style permissioned token. The interesting part versus a plain ERC-20: transfers are conditional. The contract checks an on-chain identity and compliance registry, and a transfer to an unverified address reverts. Tokenized real-world assets don't get to be bearer instruments — the restriction has to live in the token, not in a database somewhere off to the side.

Built with Foundry, pushed through Slither and Echidna.

ZK Compliance Pass

Prove you satisfy a compliance requirement without handing over the data that proves it. Same cryptographic primitive as the escrow circuit, aimed at KYC-shaped problems: the verifier learns you qualify, and nothing else.

Queued behind these: a gas-optimization demo with measured before/after deltas, and an adversarial lab — intentionally vulnerable contracts, Foundry proof-of-concept exploits, and patched versions side by side.

The tools: what's new

The bulk of the recent tool work is a cluster built around one question — is this person, offer, document, or company what it claims to be?

Job-Offer Legitimacy Check (AI) surfaces signals to investigate in a recruiter message, including the sender domain's real age. Candidate Photo Verify does reverse-image evidence: where else that photo appears online. Timeline Discrepancy Checker (AI) reads a résumé for internal-consistency signals — overlapping roles, date-vs-total mismatches, impossible tech or certification dates. Website Legit Check rolls domain age, TLS, redirects, email-security DNS and headers into one pass. Counterparty Due-Diligence Check vets a supplier before you wire anything. Document Authenticity Check scans a PDF's structure for integrity signals — incremental updates, appended content, cross-reference and date anomalies. Username Cross-Platform Check reports presence of a handle across a curated platform set.

Note what the résumé and document checkers don't do: they don't render a verdict on a person. They surface structural anomalies and hand them to you. A date gap is a question to ask, not a conviction.

The free tier, in full

OSINT & security (13 free)

• TraceCheck — score a public footprint from live search signals.
• Domain Recon — passive recon from public records.
• EXIF Metadata Check — the camera, edit history and GPS a photo still carries.
• Fake Recruiter Check — does this message match known scam patterns.
• Email Header Analyzer — full Received: hop chain plus SPF, DKIM, DMARC.
• Phishing & BEC Email Analyzer — scored for payment-redirect patterns.
• DNS Email-Security Check — more below.
• Data-Breach & Exposure Check — does this address appear in known breaches.
• Certificate-Transparency Subdomain Finder — subdomains from public CT logs. No scanning, no traffic to the target.
• Prompt-Injection & System-Prompt-Leak Tester — test your own system prompt against the OWASP LLM Top 10.
• Username Checker — does this handle exist.
• Security Headers Grader — CSP, HSTS, framing, nosniff.
• SSL/TLS Certificate Checker — issuer, SANs, expiry, chain, negotiated version.

SEO & marketing (2 free)

• AI-Access Checker — which AI crawlers your robots.txt allows, whether you have an llms.txt, whether your content is trapped behind JS.
• Open Graph / Social Preview Checker — OG and Twitter Card tags plus a rendered preview.

Utilities (1 free)

• Redirect Chain Tracer — every hop, with HTTPS→HTTP downgrades, loops and meta-refresh flagged.

Full index including the paid tools: pigfox.com/tools

The one tool I use every week

SPF allows a maximum of 10 DNS lookups during evaluation. Blow past it and the record fails — silently, from the sender's side. Most orgs find out when a quarter of their mail lands in spam.

DNS Email-Security Check counts the lookups and shows you where you sit against the ceiling. It parses DMARC properly (p, pct, rua, sp — subdomain policy is the one everybody forgets), auto-probes common DKIM selectors instead of making you guess them, pulls MX, and returns a plain-language deliverability verdict instead of a wall of TXT records.

The stack

• Go monolith. One binary, html/template server-side, no SPA. Registry-driven, so adding a tool is a struct plus a handler.
• PostgreSQL for everything, including the credit ledger behind the metered tools.
• River for background jobs. Periodic jobs, not cron.
• Solidity + Foundry for the contracts; Slither and Echidna in the loop.
• Render for hosting, Playwright for E2E — including against the live chain.
• Magic-link auth and Cloudflare Turnstile. Nobody needs another password.

Unglamorous recent work, since this is a developer audience: burned a golangci-lint backlog from 840 findings to zero, moved every template off text/template to html/template (a real P1 XSS), put CSP into enforce mode, and rotated a deployer key after pasting it somewhere it shouldn't have gone. That last one is the most useful thing in this post: assume you will do it too, and have the rotation path ready before you need it.

---

Try the ZK Escrow Explorer and open one of the settlements in a block explorer. Then run DNS Email-Security Check against your own domain.

Feedback, bug reports, and "this tool is wrong about my domain" all welcome — that last one especially.