The pre-signing
safety layer for
autonomous agents.
Agents hit a wall when they need to actually sign something. Presign is the synchronous check they call first — a structured verdict in under 200 ms, over live trace data, with evidence the human can audit.
// agent is about to approve unlimited USDC POST https://api.presign.dev/v1/check { "chain": "ethereum", "from": "0x742d...0bE5", "to": "0xa0b8...eB48", // USDC "data": "0x095ea7b3...", // approve(spender, uint256.max) "value": "0" }
← response { "verdict": "block", "score": 12, // 0 safe, 100 danger "checks": { "approval_target_risk": "high", "contract_age_blocks": 47021, "recent_drain_events": 14, "similar_drains_24h": true, "mev_exposure": "low" }, "evidence": { "approvals_last_hour": 487, "funds_drained_usd": "2,430,000", "cluster_label": "drainer-family-q2" } }
Agents act faster than humans can supervise.
Every agent platform hands an LLM signing authority and hopes nothing goes wrong. When it does, users lose funds, platforms lose trust, builders lose sleep. There is no production-grade safety layer between the model and the chain.
"Should my agent sign this?"
No structured answer. Agents call raw RPC, scan Etherscan for humans, or write ad-hoc heuristics that miss what actually matters.
"Should my agent sign this?"
One HTTP call. Typed verdict: allow, caution, or block. Evidence for every decision. Audit trail for every signature.
Three moving parts. Nothing more.
Ingest
We stream blocks with full call traces, logs, internal transactions, and mempool activity. Each event is enriched with contract labels, token metadata, exploit history, and funding-source graphs.
Detect
Rolling detectors continuously score addresses and contracts. Approval anomalies, honeypot patterns, drain signatures, depeg events — all refreshed to the latest finalized block, always.
Answer
A single REST endpoint. Agents POST a proposed transaction, get a typed verdict with evidence. Drop-in MCP server means it works with Claude, ChatGPT, or any MCP-speaking agent out of the box.
Six checks. Every call. Every chain.
Structured, evidence-backed, empirical where possible. No heuristic-only decisions.
Approval safety
Is the spender contract behaving abnormally? Has it received a spike of approvals followed by drains? Is it new, unverified, or part of a known drainer cluster?
Destination risk
Is the recipient sanctioned, flagged, or freshly funded from a flagged source? Source-of-funds analysis six hops back, refreshed every block.
Simulation outcome
Fork the chain at head, execute the transaction, diff the state. Return what actually happens: token flows, storage changes, reverts, slippage.
Honeypot detection
Can the user sell after they buy? Are fees asymmetric? Have recent counterparties been able to exit? Empirical checks, not pattern-matching.
MEV exposure
How sandwichable is this transaction at its current slippage? What does the public mempool look like for this pool? Recommend private submission when warranted.
Stablecoin health
Is the stablecoin currently depegged, under redemption stress, or flagged by its issuer? Live price and on-chain health signals, not yesterday's snapshot.
One line in the signing path.
Drops into any framework. Language-agnostic REST. MCP server for agent-native use.
// drop-in safety hook before any agent-signed transaction import { Presign } from "@presign/sdk"; const presign = new Presign({ apiKey: process.env.PRESIGN_KEY }); async function safeSign(tx) { const verdict = await presign.check(tx); if (verdict.verdict === "block") { throw new Error(`Blocked: ${verdict.reasons.join(", ")}`); } if (verdict.verdict === "caution") { await logForHumanReview(tx, verdict); } return wallet.sendTransaction(tx); }
# drop-in safety hook before any agent-signed transaction from presign import Presign presign = Presign(api_key=os.environ["PRESIGN_KEY"]) async def safe_sign(tx): verdict = await presign.check(tx) if verdict.verdict == "block": raise BlockedError(verdict.reasons) if verdict.verdict == "caution": await log_for_human_review(tx, verdict) return await wallet.send_transaction(tx)
# add presign to your claude / chatgpt / cursor config { "mcpServers": { "presign": { "command": "npx", "args": ["-y", "@presign/mcp-server"], "env": { "PRESIGN_API_KEY": "pk_live_..." } } } } # the agent now has a `check_transaction` tool it calls before signing
curl -X POST https://api.presign.dev/v1/check \ -H "Authorization: Bearer $PRESIGN_KEY" \ -H "Content-Type: application/json" \ -d '{ "chain": "ethereum", "from": "0x742d...0bE5", "to": "0xa0b8...eB48", "data": "0x095ea7b3...", "value": "0" }'
Agent infrastructure, not human dashboards.
Agent platforms
Coinbase CDP, Cobo, Openfort, Safe, Privy. Drop a safety hook into your signing flow, ship with confidence.
Agent frameworks
LangChain, CrewAI, AutoGen, AgentKit. MCP server drops straight into Claude, ChatGPT, Cursor, Windsurf.
DeFi-native teams
Vault strategies, yield optimizers, auto-rebalancers, treasury bots. Anything that signs on a user's behalf.
Telegram & social bots
Where a lot of real agentic activity is already happening. Low-latency checks designed for tight loops.
Usage-based. Forecastable. No lock-in.
Price per check, generous free tier, enterprise if you need it. Change tiers anytime.
- All six check types
- Ethereum, Base, Arbitrum
- REST + MCP server
- Community support
- Everything in hobby
- Webhook event stream
- Evidence endpoints
- Email support · 1 biz day
- Everything in builder
- Dedicated endpoint region
- Custom labels & lists
- Slack support
- Custom check types
- Private deployment
- SOC 2 in progress
- Dedicated solutions engineer
Overage is $0.003 per check past your tier's included quota. Stop usage alerts at any threshold.
Questions teams ask before integrating.
How is this different from Blockaid, GoPlus, Harpie, or Tenderly?
Those tools are excellent, and Presign focuses on something specific: a single synchronous check designed for agent signing paths, returning typed verdicts under 200 ms with structured evidence. We're built to be called inline by software, not browsed by humans. The MCP server is the biggest tell — Presign is a first-class tool for agent runtimes, not a dashboard product.
What's the latency budget?
Median 147 ms, p99 under 400 ms, measured from the edge closest to your agent. We maintain a live-state cache of every check dimension, so the hot path is a cache lookup plus a small simulation — not a cold database scan.
Which chains do you support?
Ethereum, Base, and Arbitrum at launch. Optimism and Polygon PoS in Q2. Solana in Q3. We pick chains based on where agent volume actually is, not where token speculation is loudest.
What if you're wrong — what's the liability model?
We return verdicts with confidence scores and full evidence. You make the final signing decision. That said, we publish a public track record of every miss on our status page and measure ourselves against it. Enterprise tier includes SLA credits for measurable accuracy regressions.
Can I self-host?
Enterprise tier includes a private deployment option running in your own VPC, with data plane isolation. The live-state index refreshes from our public feed but never calls back. Ask us for the deployment brief.
Who's behind this?
A small team of engineers previously in blockchain analytics and agent infrastructure. We built Presign because every agent product we integrated needed this layer and nobody was building it the right way. More soon.
Ship agents that don't lose money.
Design partners get free Builder tier for 6 months, direct access to the team, and input on the roadmap. Tell us what you're building.