The Compliance Hook code-walk — 10 lines to a regulator-friendly DeFi agent

Step 1 — Get access (private beta)

Per Coinbase's own AgentKit examples, the canonical pattern for niche action providers is install-from-GitHub-tag — that's the GA plan. During the beta, access is by request:

# Python
# Compliance Hook SDK — private beta. Request access: [email protected]

# TypeScript (after operator npm publish — gated)
npm install @blindoracle/compliance@next

Why no PyPI? Two reasons. One, the SDK is small and tightly coupled to live API endpoints under craigmbrown.com/api/ — bundling a name on the public Python index implies maintenance + community-pickup expectations we're not ready to take on for v0.1. Two, operator-explicit guidance: ship via GitHub VCS-install until v1.0 proves out.

Step 2 — Initialise the client

One import, one constructor call, one wallet handle. The wallet handle is the x402 payment rail your agent uses; we accept any Fedimint-compatible handle or a Base USDC address.

from blindoracle_compliance import ComplianceClient, presets

client = ComplianceClient(
    api_base="https://craigmbrown.com/api",
    x402_wallet_handle="<your-fedimint-handle>",
)

The constructor doesn't fire a network call. It does eager validation of the wallet handle format (refuses obviously-malformed strings up-front so you fail at startup, not on first agent action).

Step 3 — Run a preset check

The three shipped presets:

Calling them looks like this:

result = client.check_address(
    address="0xabc...",
    preset=presets.kyc_ofac_sanctions,
)

if not result.allowed:
    raise PermissionError(f"Blocked: {result.reason}")

# result also carries a signed proof
print(result.proof_kind)   # 30017 (ProofOfDeliverable)
print(result.signature)    # HMAC-SHA256, verifiable

Total surface area: a ComplianceCheckResult with four fields — allowed, reason, proof_kind, signature. The proof is stored server-side and indexed for the audit-log tier; the signature is yours to keep and attach to a downstream audit record.

Cost: $5 per check at pay-as-you-go list pricing — first 100 free per account

Each call is billed to your x402 wallet at the live quoted price. If the wallet can't cover the quote when the call fires, the API returns 402 Payment Required with the exact price in the body — your agent can decide to fund or fall back. The volume tiers in the pricing recap below cut the per-check cost substantially.

Step 4 — Wrap it as a middleware in your framework

The SDK ships first-class integrations for the three most common DeFi agent frameworks. Each is <100 LOC, intentionally tiny so you can read and verify it.

LangChain middleware (51 LOC)

from blindoracle_compliance.integrations import langchain_middleware
from langchain.agents import AgentExecutor

middleware = langchain_middleware.ComplianceMiddleware(
    client=client,
    preset=presets.kyc_ofac_sanctions,
    blocked_tools=["transfer", "approve", "swap"],
)

agent = AgentExecutor.from_agent_and_tools(
    agent=your_agent,
    tools=your_tools,
    callbacks=[middleware],
)

The middleware listens on the on_tool_start hook. If the tool name is in blocked_tools and the tool's first address argument fails the preset check, the middleware raises ComplianceBlockedError. Your agent's existing error-handling path catches it.

CrewAI tool (48 LOC)

from blindoracle_compliance.integrations.crewai_tool import ComplianceCheckTool

tool = ComplianceCheckTool(
    client=client,
    preset=presets.mica_eea_retail,
)

# Add to your crew's available tools
agent = Agent(
    role="DeFi risk scorer",
    tools=[tool, your_other_tools],
)

The CrewAI tool exposes itself as compliance_check with a Pydantic-validated input schema (a single address string). Crews call it like any other tool; the result flows back as a structured dict.

MCP server hook (66 LOC)

For Model Context Protocol servers, the hook installs into the pre_tool_use phase of every tool call. This is the same pattern the Cryptorefills AgentKit example uses for x402 payment gating, just with compliance gating instead.

from blindoracle_compliance.integrations import mcp_hook

mcp_hook.install(
    server=your_mcp_server,
    client=client,
    preset=presets.kyc_ofac_sanctions,
    block_on=["transfer_funds", "approve_allowance"],
)

Once installed, every transfer_funds or approve_allowance call by an MCP client must pass the preset check first. Failures return a structured MCP error (with a verifiable signature for the audit log) instead of executing the action.

Step 5 — Verify a signed proof later

Every check produces a HMAC-signed proof. Your audit/compliance team can verify it independently with our public key:

from blindoracle_compliance import verify_proof

# Pulled from your stored agent logs
stored_proof = "..."
stored_signature = "..."

is_valid = verify_proof(
    proof=stored_proof,
    signature=stored_signature,
    public_key=client.fetch_public_key(),
)
assert is_valid, "Audit proof tampered or fake"

The same verifier runs server-side on every audit-log retrieval. We publish the chain head daily so historical proofs can be cross-anchored.

Step 6 — Audit-log retrieval (paid tier)

If you're on the $499/mo audit-log tier, you can pull a complete history of every check your wallet handle has run, with all proofs:

# Last 30d, paginated
log = client.audit_log_pull(
    wallet_handle="<your-fedimint-handle>",
    since="2026-04-13T00:00:00Z",
    limit=1000,
)

for entry in log.entries:
    print(entry.timestamp, entry.address, entry.allowed, entry.proof_kind)

The retrieval returns a JSONL-style stream with each entry signed. You can attach the whole stream to a legal opinion or a regulator-facing audit packet. The chain integrity is verifiable — every record's prev_hash links to the previous record.

Why this matters — UETA §202 + MiCA Title V

UETA §202 says an electronic agent's actions bind the principal if the agency chain is provable. MiCA Title V Art. 60 says operational resilience requires "effective internal control over agent inputs." Neither statute cares whether your agent is a multi-billion-parameter LLM or a 200-line rules engine; both care whether you can prove what happened.

The Compliance Hook SDK is the smallest possible artifact that makes both proofs available:

• The signature field anchors each check to a specific operator key (UETA §202 agency)
• The proof_kind field maps each check to a regulator-readable kind (MiCA Title V Art. 60)
• The blocked_tools integration pattern provides "effective internal control over inputs" before the action fires (MiCA Title V Art. 60(7))

Talk is cheap; signed bytes are not. Every claim in this post can be verified against the live API surface at craigmbrown.com/api/agent-services.json; beta participants receive the full SDK source with their access grant.

Pricing recap

• Pay-per-check — $5/check (post-paid via x402), first 100 free per account
• Volume — $99/mo for 10K calls, signed proofs retained 90d, email support
• Audit-log tier — $499/mo unlimited, full audit retention for legal opinion attach, on-call SLA

Related

• Post 1 of 4: The Legal Agent Stack manifesto — why now, why us, what's bundled
• Post 3 of 4: (upcoming) MASSAT → MiCA crosswalk + sample finding from our self-audit
• Post 4 of 4: (upcoming) Wyoming wrapper architecture — what changes when the LLC gets sued
• Reliability Manifesto — the 4 accountability rules + proof rails behind every SDK call
• blindoracle-mcp repo — every integration in <100 LOC; full SDK source ships with beta access

Post 2 of 4 in the Legal Agent Stack series · Operated by Craig M. Brown · Back to blog