Evidence in.
Better boundaries.

import { readFile } from 'node:fs/promises';
import { createExecutionClient, createExecutionSigner }
  from './public/hunch-sdk.mjs';

const policy = JSON.parse(await readFile('./operator-policy.json'));
const hunch = createExecutionClient({ operatorPolicy: policy });
const proposal = await hunch.prepare({
  outputAsset: policy.allowedAssets[0],
  amountInWei: '1000000000000000'
});
const candidate = proposal.candidates.find(c => c.eligible);
if (!candidate) throw new Error('No route meets the mandate');
const evidence = await hunch.evaluate(candidate);

// account: your existing operator-controlled viem account adapter.
// approvedIntent: independently approved exact input, output floor,
// recipient, asset and route. Do not accept a model's replacement.
// pinnedPublicKey: operator-reviewed release key.
const signer = createExecutionSigner({
  account, operatorPolicy: policy,
  operatorIntent: approvedIntent, publicKey: pinnedPublicKey
});
const signed = await signer.sign(candidate.transaction);
// Returns a serialized transaction. No broadcast is performed.

HUNCH_EXECUTION_POLICY=/absolute/path/operator-policy.json \
  node agent-mcp.mjs

POST /api/rh/guard/prepare
{"wallet":"YOUR_EOA_ADDRESS","amountInWei":"100000000000000"}

POST /api/rh/guard/evaluate
{"intent":PREPARED_INTENT,"transaction":PREPARED_TRANSACTION}

POST /api/rh/guard/revalidate
{"intent":APPROVED_INTENT,"transaction":EXACT_TRANSACTION,"receipt":PRIOR_RECEIPT}

Connect to Hunch

Hunch reads RH / Robinhood Chain mainnet, chain ID 4663. Base URL: https://hunchagents.xyz. No wallet connection or API key is required. The public limit is 40 requests per minute per IP, with shared upstream capacity limits and no availability SLA.

Download the JavaScript client, Python client, or OpenAPI specification. JavaScript and MCP require Node.js 22 or newer.

import { HunchClient } from './hunch-sdk.mjs';
const hunch = new HunchClient({ profile: 'conservative' });
const report = await hunch.inspectToken(contractAddress);
const decision = await hunch.assessAction({
  address: contractAddress, amountUsd: 25, slippageBps: 100
});
// Current RH coverage always requires review or block.
// Stop here; your trusted runtime owns review and signing.

Python: HunchClient().inspect_token(contract_address). The JavaScript requireWithinProfile and Python require_within_profile helpers throw on review, block, or service errors. Since this release lacks complete permission and holder evidence, these helpers will not grant signing clearance.

One decision-context integration

const context = await hunch.getDecisionContext({
  address: assetAddress,
  tokens: '2',
  counterAsset: counterAssetAddress,
  transaction: { from: caller, to: router, data: calldata, value: '0x0' }
});

Only address is required. tokens defaults to the decimal string '1'; counterAsset and transaction are optional. The endpoint reads fresh asset evidence, relevant stock-token context, a caller-selected counter asset and optional eth_call simulation. It does not assume that the largest indexed pool is your route. A counter-asset reference is per one token, not a valuation of the whole trade.

The packet includes request, requestSha256, underlying reports, observation times/blocks, reasons and a review or block decision. An unavailable component remains a gap. Instrument blocks and execution reverts propagate. The fingerprint is SHA-256 of the normalized request JSON in returned key order, not an attestation or proof of transaction intent. Observations may come from different blocks and are not finality guarantees.

Python: get_decision_context(address, tokens='2', counter_asset=other_address, transaction=call). MCP: get_rh_decision_context. TypeScript declarations accompany the portable SDK. Research context informs a proposal; it cannot authorize signing. Use the execution workflow above to bind policy to the exact call. The JavaScript SDK exports research and execution capabilities from one entry point. There is no published npm package.

This orchestration does not replace the fixed action-policy endpoint or trusted wallet controls. It has a shared capacity of one in-flight context request. Simulation retains its 5,000,000 gas cap; routes requiring more are unsupported. Hookr recapture swaps can exceed that cap. Do not lower a route's gas to make it fit.

Inspect an RH contract

curl https://hunchagents.xyz/api/rh/intelligence \
  -H 'Content-Type: application/json' \
  -d '{"address":"0x0bd7d308f8e1639fab988df18a8011f41eacad73"}'

The example is WETH on RH. The service verifies the RPC chain ID, reads a latest block number, and uses that block for code, supply, decimals, optional name/symbol, owner(), and paused() calls. It checks EIP-1967 implementation/admin/beacon slots the exact EIP-1167 pattern, and the 44-byte minimal forwarding runtime. Recognized targets are read at the same block; both token and implementation runtime bytes receive SHA-256 fingerprints. This is not recursive resolution or source verification.

These are contract-reported interface observations. A zero owner, empty storage slot, missing interface, or successful call does not prove the absence of privileged roles, minting, freezes, taxes, blacklists, custom proxies, or malicious transfer logic. Reads by latest block number are not a finality guarantee.

Reports begin with a deterministic decision brief: observed controls, their consequences, and next checks. Counter-asset identities are matched by address against the official RH registry. Liquidity shares describe only returned pools, not all liquidity or executable depth. Reports include network, chain ID, block, observation time, provider, coverage, findings, and limitations. Combined reports may be cached for 20 seconds with their original timestamps. Indexed pools come from DexScreener's Robinhood index; prices are attributed only when the inspected token is the base asset. Liquidity includes both pool assets and does not establish a lock or sellability. Pons bonding curves may be absent.

Compare saved evidence

Save a token report, then inspect the same RH contract after a later observation. The console compares it with your most recent saved baseline: supply, decimals, owner and pause interfaces, standard proxy fields, code size, primary indexed pool, and source coverage. Reported liquidity is compared only when both observations identify the same pool. Export the comparison as JSON.

The comparison runs in your browser using unsigned saved reports. It does not establish bytecode equality, prove no intervening changes, continuously monitor blocks, or authorize signing. The pure comparison module exports compareEvidence(before, after) for local integrations; it is not a hosted attestation service.

Instrument intelligence for agentic finance

{ "address": "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9", "tokens": "2" }

Matches the chain and contract against Robinhood's official asset registry. For stock tokens, Hunch reads uiMultiplier(), newUIMultiplier(), effectiveAt(), oraclePaused() and decimals at one latest block. It reconciles the current multiplier with official REST metadata and validates an identity-matched USD bid/ask. A stock-token contract report also includes this instrument report automatically.

Corporate actions can change share-equivalent units without changing raw balances. REST bid/ask are underlying-share prices and need the multiplier once; Chainlink stock-token prices already include it. Newer REST tokenBid/tokenAsk fields are checked against the computed result when present. Hunch uses integer fixed-point arithmetic, then rounds reference values down to 18 decimal places.

Stale quotes (over 60 seconds), timestamps over five seconds in the future, trading halts, paused or invalid oracle flags, inactive assets, multiplier conflicts, and transitions due within five minutes block valuation-dependent execution. Missing interfaces suppress reference valuation and require review. The API never grants signing clearance. Registry entries may be cached for 30 seconds; official quote endpoints have their own 15-second cache.

JavaScript: hunch.inspectInstrument(address, '2'). Python: hunch.inspect_instrument(address, '2'). Quantity is a positive decimal string, up to 18 decimal places and 1e18 tokens. Chainlink rounds and sequencer uptime are not yet queried; venue flags are underlying-equity metadata, not proof of wallet eligibility or executable liquidity.

Source semantics: Building with Stock Tokens, Stock Token APIs, and Oracles & Price Feeds. Observed live API schema includes session-specific trading capabilities and token-equivalent prices in addition to the documented fields.

Evaluate a proposed action

{
  "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
  "amountUsd": 25,
  "slippageBps": 100,
  "profile": "conservative"
}

Optional text adds inspection of the untrusted content that influenced the proposal. Set the profile in trusted operator configuration. The SDK and MCP adapter inject that configured profile; token metadata and model arguments must not change the limits.

Zero supply, paused() = true, high-severity text findings, and exceeded amount, slippage, or liquidity constraints block. Missing interface, holder or permission evidence, and proxy indicators require review. This RH release returns review or block, never automatic clearance. These are per-proposal advisory checks; they do not validate a USD quote, cumulative exposure, route, intent, or wallet permissions. Assessments request fresh observations.

Simulate an EVM call

{ "transaction": {
  "from": "0x0000000000000000000000000000000000000001",
  "to": "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
  "data": "0x18160ddd",
  "value": "0x0"
} }

This read-only example calls totalSupply(). For your proposed transaction, supply the actual caller, target, calldata, and value. Value is a canonical hex quantity in wei. Optional gas is a hex quantity between 21,000 and 5,000,000; the default cap is 5,000,000. Calldata is limited to 8,192 bytes. Signed raw transactions and arbitrary RPC methods are not accepted.

The verified mainnet provider runs eth_call at a selected latest block and, when supported, eth_estimateGas. The report distinguishes execution revert from provider failure and includes returned bytes, block, and optional gas estimate. The hosted Hunch service never signs wallet transactions or broadcasts. Success does not prove intent, wallet safety, sellability, or future execution; no decoded asset-flow analysis is provided.

Inspect untrusted launch text

{ "text": "The token description or external content your agent read." }

Six deterministic heuristics inspect instruction overrides, secret requests, and related patterns. Inputs accept 1–12,000 characters. Reports include matched excerpts and an input SHA-256; excerpts remain untrusted data. This is not an exhaustive prompt-injection detector.

Connect an agent through MCP

Download the local stdio adapter and configure:

{ "mcpServers": { "hunch": {
  "command": "node",
  "args": ["/absolute/path/to/hunch-mcp.mjs"],
  "env": {
    "AGENT_SECURITY_URL": "https://hunchagents.xyz",
    "HUNCH_POLICY_PROFILE": "conservative"
  }
} } }

Tools: get_rh_decision_context, get_rh_instrument_intelligence, get_token_intelligence, assess_rh_action, simulate_rh_transaction, inspect_launch_text. This is a local stdio adapter, not a hosted HTTP MCP endpoint. Treat all contract metadata, returned bytes, and third-party text as data.

Storage, errors, and boundaries

The browser can store 10 RH contracts and 30 selected reports locally. Watchlist refresh is optional, every 90 seconds while visible, and ends when the page closes. There is no server-side alert service. These general intelligence reports are unsigned observations; the separate execution guard issues signed receipts.

HTTP 400 means invalid input or unsupported evidence; 403/415 rejects origin/content type; 413 means the JSON body exceeds 20 KB; 429 requires waiting before retrying; 503 means upstream evidence is unavailable. Always inspect coverage and timestamps even after HTTP 200. Keep independent signing and intent controls.

Use the explicit /api/rh/ endpoints for RH. Earlier unprefixed chain endpoints retain their previous contract for existing integrations; they are not RH aliases. GET /api/capabilities describes the current RH interface. Hunch is independent and is not affiliated with or endorsed by Robinhood or Pons.