David Seo

VOUCH is a Pre-Call Identity Verification protocol and demo implementation that verifies the caller's identity, authorization, and call intent before the call connects. Current anti-voice-phishing approaches intervene only after the call is established. VOUCH flips this: financial institutions, public agencies, and AI call agents submit a signed CallerProof before dialing, and the recipient can verify 'who is calling, under what authority, and why' through a VOUCH Passport — before picking up.

I personally handled the full product concept, protocol design, architecture, Go backend, React/TypeScript PWA frontend, Solidity smart contract, DID/VC verification flow, risk rule checker, and Claude Haiku-based Intent Handshake integration.

Core achievement: a working MVP of a 9-step verification pipeline. The flow runs end-to-end: receive Ed25519-signed CallerProof → verify phone-to-institution DID binding → DID/VC validation → AI agent intent & authority check → risk pattern rule check → LLM-based call intent pre-disclosure → recipient Mobile ID verification → VOUCH Passport issuance → Sepolia testnet Chain Receipt. Deployed Sepolia contract at 0x70fc086A3f4e91dA3f7e3Aeb4D2C806DdF3dED04. Live LLM: claude-haiku-4-5-20251001 (BYO).

Three scenarios verified with real branching results: legitimate bank AI agent → SAFE; unregistered impersonator (fake prosecutor) → BLOCK; financial security AI operating outside its authorization scope → BLOCK. Zero PII on-chain: only sessionHash, receiptHash, isSafe, policyVersion, and timestamp are stored on the blockchain.

CAD Trust Engine Lite analyzes PNG/PDF/JPG architectural drawings to detect wall, door, window, and space candidates, converting the results into a trust surface connectable to quantity takeoff systems. The goal is not to maximize object detections, but to clearly separate what each judgment is grounded on, how far it can be trusted, and what regions still require human review.

I built the full stack personally: product concept, architecture design, Python-based CV/OCR pipeline, Pydantic output contracts, Streamlit review UI, SQLite Audit DB, and Docker/VPS deployment. The core pipeline is 5 stages: Ingest → Geometry → OCR → Symbol → Compose+Aggregate. OpenCV Canny, HoughLinesP, HoughCircles, and contour analysis detect line/wall/door/window candidates; PaddleOCR (ko/en) with a regex classifier extracts room names, dimension text, and label candidates. Final output is a per-field epistemic JSON with independent EEF tags for each of type, geometry, and measurement.

Key design principles: Measurement Policy and Refusal Over Bluff. A Pydantic model_validator enforces that mm-level measurements are not emitted without a trusted scale anchor. Low-evidence regions are reported as explicit refusals, not low-confidence results. Built a corpus of 50 drawings under open licenses (12 synthetic + 38 Wikimedia), with provenance and SHA-256 on every sample. Tests grew from 53 to 148 with no regressions. Complex drawings yielded 20,000+ candidate objects alongside refusal and review routing results.

SQLite Audit DB records run, stage event, refusal, policy fire, and epistemic distribution — tracking error and refusal patterns over time, not just single-run results. Live deployment completed on Docker + Caddy + Vultr.

LedgerLens implements a core principle for autonomous AI agent data transactions: no payment is authorized for an ungrounded claim. When a Buyer Agent requests real-time web data and a Seller Agent claims to have it, LedgerLens collects web evidence via Bright Data, verifies the claim through the GEM² Trust Gate, and only then proceeds with the x402-compatible payment flow.

I handled the complete implementation: product concept, architecture, Go backend, Next.js/TypeScript frontend, Bright Data integration, GEM² audit-gate integration, SQLite-based entity/source memory, payment gate, simulated x402 settler, and audit bundle export. Bright Data SERP, Unlocker, Browser, and MCP wrapper collect public web evidence; GEM² L1 P-check and L2 O-check verify whether claims are grounded in that evidence. The L3 Trust Gate synthesizes the final verdict: APPROVED triggers a simulated settlement receipt; BLOCKED stops payment authorization.

Core achievement: a working MVP of trust-gated settlement — verifying an AI agent's claim before payment executes. The full flow is product-shaped: evidence acquisition → claim audit → policy gate → settlement authorization → audit bundle export. The L2 audit panel displays EEF tags, SPT overclaim guards, and evidence correlation, enabling human review of exactly which claims were approved or blocked and why.

For public demo safety, no real accounts, private keys, or funds are connected — the x402 payment lifecycle runs in simulation mode. The core verification structure outside settlement works for real. The Settler interface is decoupled so the Trust Gate architecture survives a future swap to Coinbase Go SDK + Base Sepolia/mainnet settlement.

GEM² — AI Governance at the Edge is an enterprise AI governance system that forces every agent action through a verifiable contract edge. Every agent transformation is audited before and after execution via a 4-gate pipeline: L0 Lobster Trap ingress DPI → L1 P-check audit → Contract Executor (F) → L2 O-check audit → L3 Lobster Trap egress DPI.

The Lobster Trap layer is a pure-Go regex DPI engine that catches prompt injection, data exfiltration, and credential leaks before the model runs — sub-1ms verdict. Dual-LLM architecture separates the judge (Gemini 3 Flash Preview for L1/L2 audits) from the executor (Vultr DeepSeek-V3.2 for L0/F/L3) — that separation is what makes the verdict trustworthy. Every ALLOW/LOG/DENY verdict across all four gates persists to a SQLite layer_audit_log, producing a regulator-readable evidence trail.

The live demo runs 6 health-insurance claim Contract Edges as a composable DAG workflow, generating 24 gate verdicts in real time. The adversarial demo lets you inject a data-exfil payload at any node and watch L0 fire DENY in under 1ms — directly in the canvas UI.

Full stack personally implemented: Go backend, drag-and-drop workflow canvas, SSE real-time trace panel, audit log query UI, and per-node CE Viewer.