Introduction

A new class of software buyer has appeared on-chain. Autonomous agents now hold wallets, read markets, and sign transactions on a schedule, and with the arrival of the x402 protocol ^[39] they can pay for a service in-band over HTTP, settling in stablecoin without an account or a human in the loop. The supply side has not caught up. An agent that wants the risk-neutral probability that Bitcoin closes above a strike, or a verdict on whether a pending signature will drain its wallet, has almost nowhere to buy that computation in a form it can call and trust.

The gap: agents can pay, but there is little worth paying for

Two failures are common in the services that do exist. The first is reachability. The quantitative tooling that desks rely on, from volatility-surface fitters to market-impact models, lives in notebooks and internal libraries that expose no priced, machine-callable interface. An agent cannot invoke it. The second failure is trust. Many agent-facing endpoints return a number, a grade, or a score with no way to check how it was produced. A "health score of 73" or a "buy signal" is worthless to a counterparty that cannot audit the derivation, and worse than worthless if the number was fitted to look good. For financial and security computations, where a wrong answer moves real money, an unverifiable output is a liability.

Quiver is built for that gap. It is an Agentic Service Provider: a single host that publishes ten independently priced computations, each callable by any agent that speaks x402, each registered on-chain under ERC-8004 ^[38] so it can be discovered and its reputation accrued. The services are not thin wrappers over a data feed. They implement the methods a quantitative desk or a security team would actually run, and they are written to a standard this document makes explicit: correctness is proven by test, claims are grounded in observable data, and when the data does not support a claim the service says so.

Design stance and contributions

The stance is adversarial toward its own output. Before a number is served, we ask what would have to be true for it to be wrong, and we check that against independent data. This produced several corrections during development that a looser process would have shipped. The plain N(d2) risk-neutral probability, standard in textbooks, carries a bias of up to five percentage points on a skewed crypto smile because it omits the volatility-slope term; we measured the bias and replaced the formula. A per-trade Amihud illiquidity ratio returned a value of order 10⁹ on a live memecoin tape because sub-cent dust trades drive the denominator to near zero; ground-truthing caught it and the estimator was rebuilt on volume blocks. This document reports those corrections rather than hiding them, because the discipline that produced them is the product.

The contributions are the following.

1. A production ASP of ten priced services on x402 and ERC-8004, live and paid end-to-end, covering options, transaction safety, microstructure, prediction markets, and protocol risk.
2. An arbitrage-free options analytics stack: raw SVI fitted per expiry with the Gatheral–Jacquier no-arbitrage conditions enforced inside the objective ^[6], the Breeden–Litzenberger density ^[4], and a full risk-neutral distribution with an internal martingale correctness check.
3. A transaction-safety service that combines on-chain simulation with EIP-712 permit-signature analysis ^[32], addressing the dominant modern drainer vector that pure simulators cannot observe.
4. Real market-microstructure estimators on the DEX tape: Kyle's lambda, Amihud illiquidity, and VPIN, with quality gates that return null rather than a false number on thin data.
5. A verification methodology: 39 automated tests of model-free invariants, plus a ground-truthing protocol against live venues, with every reported figure reproducible by a documented request.

The remainder of the document is organised as follows. Section 2 describes the payment, identity, and hosting architecture. Section 3 states the design principles that constrain every service. Section 4 catalogues the ten services. Section 5 gives the mathematics. Section 6 describes verification. Section 7 walks through live calls end to end. Section 8 is a candid account of what the services do not do. Section 9 positions the work, Section 10 recounts how it was built and how an agent uses it, and Section 11 concludes.

System Architecture

Quiver is one HTTP server that hosts many services. Each service is a pure function from a typed request to a JSON response, gated by a payment middleware and registered as a callable capability. The design keeps the surface small: a request arrives, payment is verified, the service runs against live venue data, and a structured result returns in a single round trip.

The x402 payment loop

Payment uses x402, the protocol that revives the dormant HTTP 402 status code as a settlement channel ^[39]. The flow has three messages. An agent requests a paid route; the server answers 402 Payment Required with a challenge that names the asset, amount, recipient, and network. The agent constructs a payment authorization and resends the request carrying it. The server verifies the authorization through a facilitator and, once settled, executes the service and returns the result. Quiver implements the v2 exact scheme, in which the client authorizes a transfer of a fixed amount to a fixed recipient. That scheme is built on EIP-3009 transferWithAuthorization ^[36], so the transfer is gasless and signed off-chain; the token is USD₮0 on X Layer (chain eip155:196). Prices are per call and range from 0.005 to 0.02 USDT, low enough that an agent can poll a service inside a decision loop without material cost.

The payment gate is enforced before any business logic. A route that is called without a valid authorization, whether by an honest probe or by the reviewer's conformance tool, receives the mandatory 402 challenge rather than a partial result or an error. This property is checked directly: at the time of writing, every paid route returns 402 to an unauthenticated request.

Agent                         Quiver host                    Facilitator / X Layer
  |   GET /api/options-desk        |                                |
  |------------------------------->|                                |
  |   402 Payment Required         |                                |
  |   {asset, amount, payTo, net}  |                                |
  |<-------------------------------|                                |
  |   GET + X-PAYMENT (EIP-3009)   |                                |
  |------------------------------->|   verify + settle              |
  |                                |------------------------------->|
  |                                |   settled                      |
  |                                |<-------------------------------|
  |   200 OK  {structured result}  |   (service runs against Deribit/OKX/…)
  |<-------------------------------|                                |

Identity and discovery under ERC-8004

An agent economy needs a way for one agent to find another and to judge whether it is worth transacting with. ERC-8004, the Trustless Agents standard ^[38], provides this with three on-chain registries: Identity, Reputation, and Validation. Identity is a portable ERC-721 token whose metadata points to a registration file describing the agent and its services. Reputation collects client feedback; Validation records independent checks of delivered work. Quiver is registered as ASP #5152 on X Layer under this standard, which makes its ten services discoverable to any agent browsing the registry and lets a track record accrue against a stable identity rather than a URL that can change. ERC-8004 is deliberately silent on payment and execution ^[38], which is what allows it to compose with x402 for settlement and with the A2MCP calling convention for invocation.

Multi-service host and data plane

Every service is defined by a name, a price, an input schema, a validator, and a runner. The runner is asynchronous and calls out to the venue that owns the ground truth for that service: Deribit for options, the OKX DEX market API for token tape and candles, EVM JSON-RPC nodes for transaction simulation, the Polymarket Gamma and CLOB APIs for prediction markets, and DefiLlama for protocol data. Results are computed on demand; nothing about a token or a market is cached in a way that could drift from the live state, and the few caches that exist (for example a per-currency variance-risk-premium estimate that survives a transient fetch failure) are scoped and disclosed.

The host is stateless between calls except for two small stores that exist for good reasons: a rendered-chart store that lets an image be fetched by URL after the call that produced it, and a cursor store for the loop-digest service that lets an agent diff a wallet against its own previous call. Both are ephemeral and per-session. The separation of data plane from compute keeps each service auditable: given the same venue state, the same request produces the same result, and the result names the block or the tape window it was computed on so a caller can reproduce it.

Latency is bounded by the venue round trip rather than by the computation. Measured end to end, the transaction decode and simulation returns in roughly 125 to 160 milliseconds, the fast-tier chart in 220 to 300, and the full options desk, which fetches and normalises an entire Deribit chain and fits a surface across expiries, in 550 to 700. These are within the budget an agent can absorb inside a decision loop, which is the point of pricing calls low enough to poll. Every response carries an elapsedMs field so a caller can hold the service to its own timing.

Design Principles

Five principles constrain every service. They are not aspirations; each is enforced somewhere in the code and testable.

Ground truth over self-report

A computed signal is validated against an independent source or an analytic identity before it ships. The risk-neutral density is checked against the martingale condition that its mean must equal the forward. Analytic greeks are checked against finite differences of the price. The variance risk premium is checked against a significance test at the honest effective sample size, not the inflated count of overlapping windows. Where ground truth disagreed with a first implementation, the implementation changed.

Refuse to fabricate

When a quantity cannot be estimated from observable data, the service returns null with a reason rather than a plausible-looking number. The tape microstructure estimators return null on a tape too thin to support them. The options surface excludes near-expiry slices where a diffusive model does not apply, rather than force-fitting them. The short-window up/down service outputs no directional edge at all, because short-horizon direction is empirically indistinguishable from a coin flip and a fabricated fair value would contradict the product's own thesis.

Arbitrage-free by construction

The volatility surface is fitted with the no-arbitrage inequalities enforced inside the optimisation objective, so an accepted fit satisfies them by construction rather than by hope ^[6]. A fit that fails its quality gate is rejected, and the caller is told the fallback was used. A negative risk-neutral density, the signature of butterfly arbitrage, is detected and disclosed rather than silently served.

Descriptive, not prescriptive

Services report what the market prices and what the data shows. They do not tell a caller what to do. A composite "grade" that implies a validated predictive model is avoided where no labelled dataset exists to validate it; the protocol-risk service was rebuilt from a fitted 0–100 score into a set of individually defensible risk flags for exactly this reason. Every output that touches a trading decision carries a not-advice disclosure.

Proven by test

The financial mathematics is locked by an automated suite of model-free invariants: put-call parity, the delta relationship, non-negativity of the risk-neutral density, the martingale property of the distribution, and the absence of look-ahead in every time-series indicator. A change that breaks an identity breaks the build. Section 6 describes the suite; it currently holds 39 tests and all pass.

Service Catalogue

The ten services fall into five groups: options intelligence, transaction safety, charting, tape microstructure, and prediction-market and protocol tooling. Two are treated as the flagship of the set and specified in full; the rest are described at the level of what they compute, from where, and with what guarantees. Section 5 gives the mathematics that several of them share.

flagship A single call returns a desk-grade read of the live crypto options market for BTC, ETH, or SOL, sourced from Deribit with an OKX cross-check. No comparable service exists in the agent registry; options analytics is the widest moat in the catalogue because the mathematics is unforgiving and the data is awkward to handle correctly. The response is organised into layers, each independently useful.

Implied view and the probability ladder. For the two front liquid expiries the service reports the at-the-money forward implied volatility, the one-sigma expected move in dollars and percent, and a ladder of price levels with the risk-neutral probability that spot finishes above each. The probability is not the textbook N(d2). On a skewed smile that figure is biased, because the true risk-neutral probability carries a term in the volatility slope; Section 5.3 derives it. The service reports the corrected probability and, alongside it, the exact size of the correction at each level, so the caller can see how far the naive number would have been wrong. On a live BTC chain the correction reaches several percentage points near the money.

Full risk-neutral distribution. Beyond point probabilities, the service integrates the Breeden–Litzenberger density into a normalised distribution and reports its quantiles from the 5th to the 95th percentile, the tail expected shortfall on each side, and the distribution's own volatility, skew, and excess kurtosis. The block carries a self-check: under the risk-neutral forward measure the terminal price is a martingale, so its expectation must equal the forward. The service reports the residual E[S_T]/F − 1; on a live BTC expiry this reads 0.001%, which is the strongest available evidence that the density is correct. The distribution is emitted only when the density is a proper, arbitrage-free density that integrates to one; otherwise it is withheld with a diagnostic.

Dealer gamma and second-order greeks. The service computes dollar gamma exposure (GEX) by strike, the net across the chain, and the gamma-flip spot level where the sign changes, under the conventional assumption that dealers are long call gamma and short put gamma. That assumption is labelled as an assumption, and the reason it is not replaced by a flow-inferred dealer position is stated in the output: Deribit's public feed carries no block-trade tag and reports block direction from the maker side, so a flow-based sign would be invertible for much of the volume. Refusing to infer what cannot be inferred is the honest choice. The greek surface includes the second-order volatility greeks vanna and volga, computed analytically and verified against finite differences, and aggregated into a dealer vanna and volga under the same disclosed convention.

Variance risk premium and its significance. The service estimates the premium of implied over realised variance from overlapping windows ^[22],[23] and, critically, tests whether it is statistically distinguishable from zero at the effective independent sample size rather than the inflated count of overlapping pairs. On live BTC the ratio of realised to implied volatility is 0.881 with a p-value of 0.254; the service reports that this is not significant and refuses to present the real-world-calibrated probabilities as anything but indicative. This is the single clearest example of the product holding itself to a real quant standard: it computes the premium, then declines to claim an edge the data does not support.

Cross-market divergence. The options market and Polymarket price the same events by different mechanisms. For each live Polymarket threshold market on the coin, the service computes the options-implied probability of the identical question and reports the divergence. Because the market's resolution date is rarely a listed option expiry, the arbitrage-free smile is interpolated to the exact tenor in total variance, linearly in time between the two bracketing expiries, which preserves the calendar no-arbitrage condition; each row discloses whether the smile was interpolated or extrapolated and across which expiries. The raw divergence is then decomposed into the part explained by the variance risk premium, which is structural and not an edge, and the residual dislocation.

Supporting layers include the implied-volatility term structure and rank against the DVOL history, coverage-honest skew, max pain, put/call open interest, and an implied-rate curve backed out per expiry. The service fetches and normalises the full Deribit chain on each call, fits the surface once, and reuses it across the layers so every number is consistent with a single arbitrage-free surface.

flagship This service answers one question an agent must resolve before it signs anything: what will this actually do to my wallet. It operates in two modes, and the second mode is the reason it matters.

Transaction mode. Given raw calldata, the service decodes the four-byte selector against a signature registry and renders the function and arguments in plain language. Given the full unsigned transaction, it goes further and simulates the transaction against live chain state with eth_simulateV1, reading the exact asset transfers and approval changes from the simulated Transfer and Approval logs rather than inferring them from the inputs. It reports the gas the transaction would consume, priced at the live gas price into a native-token fee. The target contract is checked for an upgradeable proxy: a non-zero implementation slot under EIP-1967 ^[34], or the legacy OpenZeppelin slot used by older proxies such as USD Coin, means the logic behind the address can be replaced by its admin after the caller approves it, so today's simulation is not binding on tomorrow's behaviour.

Signature mode. Modern wallet drainers rarely use a transaction. They use an off-chain signature: a Permit or Permit2 authorization under EIP-712 ^[32],[33] that grants a spender the right to move tokens, signed by the victim and submitted later by the attacker. Such a signature is never calldata and never appears in a transaction simulator, so a service that only simulates transactions is structurally blind to the most common way people are drained today. calldata-x decodes the typed-data payload, identifies the permit type, extracts the spender, amount, and expiry, and flags the dangerous combinations: an unlimited allowance, a permit that never expires, a spender that is an externally owned wallet rather than an audited contract, or a domain that does not match the canonical Permit2 deployment. Closing this gap is the highest real-user value in the catalogue.

The verdict. Both modes feed a one-glance verdict keyed on the spender's reputation combined with the effect, not on the allowance number alone. An unlimited approval to a recognised router is routine and labelled a note; the same unlimited approval to a fresh externally owned wallet is a drainer pattern and labelled danger. Reputation is resolved from a router allowlist, from eth_getCode which distinguishes a contract from a wallet and detects EIP-7702 delegated accounts ^[35], and from an on-chain activity signal. This keying is what removes the false positive that a naive "unlimited approval is always dangerous" rule produces on every legitimate DeFi interaction.

An agent that reasons over price action needs a chart it can attach to a message, and it needs the numbers on that chart to be trustworthy. chart-press renders a PNG from OKX DEX candles in two tiers: a fast browserless tier built on server-side Apache ECharts ^[49] rasterised to PNG, and an opt-in high-detail tier that drives a headless browser and falls back to the fast tier on any failure, so a render never errors. The indicator library is a fork of a maintained package of over one hundred indicators ^[51], replacing four hand-rolled ones. Chart types include candles, Heikin-Ashi, line, area, and Renko, with an optional logarithmic price axis; the drawing primitives include horizontal and vertical lines, rectangles, trend lines, rays, channels, Fibonacci retracement and extension, and measured moves. Every render returns a facts block, the price, change, volume, high, and low, computed from the same candle series that is drawn, so the numbers an agent reads back cannot drift from the picture it shows.

tape-pulse reads the recent DEX trade tape for a token and reports its microstructure. The tape is first cleaned: routed multi-leg swaps that share one transaction hash are deduplicated so volume is not double-counted, and exchange-flagged rows are dropped. On the clean tape the service reports buy/sell imbalance, net dollar flow, tape VWAP against spot, whale prints, and trade-rate acceleration, and then computes three real microstructure estimators that a desk would recognise: Kyle's lambda, the price impact per unit of signed order flow ^[15]; Amihud illiquidity, the price move per dollar traded ^[16]; and VPIN, the order-flow toxicity measured as buy/sell imbalance across equal-volume buckets ^[17]. Section 5.5 explains why the first two are computed on volume blocks rather than tick by tick, a choice forced by ground-truthing. Trade direction comes from the exchange's own label, which is superior to a classifier such as Lee–Ready ^[19] because it introduces no classification error. Each estimator carries a quality gate and returns null on a tape too thin or too flat to support it; Kyle's lambda additionally reports its fit R-squared and a confidence label, so a weak read is visible rather than dressed up.

poly-fill simulates a pre-trade fill on a Polymarket order book. It walks the live book for a requested notional and reports the volume-weighted executable price, the slippage against the midpoint, and the largest size that stays within a target slippage. The midpoint on a thin book is a fiction; the walk is the truth. Beyond the walk, the service fits the executable-cost curve to the square-root market-impact law ^[18],[21] and reports how closely this particular book follows it, so the fit quality is measured rather than assumed, together with the two-sided depth imbalance and a maker-versus-taker note that surfaces the adverse-selection a resting order carries. On a live Bitcoin-threshold market the fit R-squared is around 0.55, an honest number for a discrete prediction-market book.

poly-desk returns a Polymarket wallet's live book: open positions with current marks, unrealised PnL, cash-out value, and the biggest movers, for copy-trading and portfolio agents that track a specific trader.

updown-pulse reads the live short-window BTC or ETH up-or-down market and reports the market's own implied odds, the true time to resolution, a spot observation, and a driftless estimate of how far price could move before the market resolves, scaled from daily realised volatility. It deliberately outputs no fair value and no edge. Short-horizon directional prediction is empirically indistinguishable from a coin flip, so a predictive number here would be false precision that contradicts the product's own thesis. The service surfaces the market and the risk and leaves the directional call to the caller.

protocol-pulse compiles a DeFi protocol's health from DefiLlama: TVL level and trend, ninety-day maximum drawdown, chain concentration, age, and the hack registry. It does not emit a single composite grade. A 0–100 health score would imply a calibrated, out-of-sample-validated model, and with no labelled dataset of protocol failures to validate weights against, a hand-tuned composite would be goal-seeking. The service instead reports the factual signals and a set of individually defensible risk flags, each a concrete condition with its threshold and rationale disclosed: a hack in the last twelve months, a deep drawdown, a sustained outflow, a very new protocol, a micro-cap TVL, a single-chain dependency. The risk level is a transparent function of the flags present, not a scored model.

macro-sentry returns the high-impact US macro events, FOMC decisions and CPI, PCE, and payrolls releases, that fall inside a caller's lookahead window, so a trading agent can de-risk before a print. The calendar is curated from published institutional schedules, which are fixed and durable, and the service is deterministic and dependency-free.

loop-digest is built for the top of an agent's loop. Given a cursor from the caller's previous call, it returns a compact diff of a wallet's world since then, new fills and per-token PnL drift, so the agent reads one small object instead of re-fetching and re-paying for the entire state on every iteration.

Methodology

This section gives the mathematics behind the options, microstructure, and safety services. It defines notation once and uses it consistently. Deribit crypto options are quoted on the forward, so the pricing model throughout is Black-76 ^[1] rather than spot Black-Scholes ^[2],[3].

Black-76 and the option greeks

Let F be the forward, K the strike, T the time to expiry in years, σ the implied volatility, and r the continuously compounded discount rate. Write φ and N for the standard normal density and distribution. The Black-76 call price and the moneyness terms are

The first-order greeks follow by differentiation. Delta is e^−rTN(d₁) for a call, gamma is e^−rTφ(d₁)/(Fσ√T), and vega, the sensitivity to volatility, is

Dealer hedging is driven not only by these but by the second-order volatility greeks, so the service computes them in closed form and, because a closed form is only as good as its verification, checks each against a finite difference of the first-order greek. Vanna, the cross-derivative of price in forward and volatility, and volga, the convexity of value in volatility, are

Both are identical for calls and puts, as they must be, since they are curvature terms in strike and volatility rather than direction. The test suite asserts this identity and asserts that the analytic vanna equals the numerical derivative of vega with respect to the forward to a tolerance of one part in a thousand.

The arbitrage-free volatility surface

A real options chain does not have one volatility; it has a smile, a function σ(K) that must be estimated from a finite set of quoted strikes. Interpolating linearly in log-strike is easy and wrong: it admits butterfly arbitrage and can produce a negative risk-neutral density in the wings, which makes any probability read from it meaningless. The service instead fits the raw SVI parameterisation of Gatheral ^[5],[7] to each expiry's total variance w(k) = σ²(k)T as a function of log-moneyness k = ln(K/F),

The five parameters are fitted by Nelder–Mead minimisation ^[47] of squared volatility error, but with the no-arbitrage conditions of Gatheral and Jacquier ^[6] enforced as penalties inside the objective, so a converged fit is arbitrage-free by construction rather than by inspection. The butterfly condition is the non-negativity of the Durrleman function,

checked on a grid of log-moneyness, and the large-strike wing is bounded by the Roger Lee moment condition b(1+|ρ|) < 2 ^[8], which is equivalent to the density decaying at infinity. A slice whose fit exceeds a root-mean-square gate of 1.5 volatility points, or whose no-arbitrage checks fail, is rejected, and the caller is told the disclosed fallback was used rather than being served a bad surface silently.

One consequence of taking the model seriously is knowing where it does not apply. Near-expiry smiles are dominated by jumps, not diffusion, and a diffusive parameterisation such as SVI cannot describe them; the residual root-mean-square rises from under a volatility point at two or more days to several volatility points inside a day. The service excludes those slices by design and says so, rather than force-fitting a model outside its regime.

To price an event whose date is not a listed expiry, the surface is interpolated in the maturity direction. The correct interpolation is linear in total variance at fixed moneyness, because the calendar no-arbitrage condition is exactly that total variance be non-decreasing in maturity ^[6]; interpolating volatility, or snapping to the nearest expiry, can violate it. For a target maturity T bracketed by fitted slices T_a < T < T_b,

Outside the fitted range the service holds volatility flat across the gap and discloses the extrapolation per row.

Risk-neutral density and the full distribution

The risk-neutral distribution of the terminal price is implicit in the option prices. Breeden and Litzenberger ^[4] showed that the risk-neutral cumulative distribution and density are the first and second derivatives of the call price in strike,

With a strike-dependent volatility the strike derivative of the call carries a term in the smile slope. Differentiating (1) with σ = σ(K) and substituting into (7) gives the exact probability,

The plain N(d₂) is the first term alone. On a flat smile the second term vanishes and the two agree; on a real skewed crypto smile the second term is material, and it changes sign where the smile slope changes sign. We measured the omission on a realistic BTC seven-day smile: N(d₂) overstates the probability by 3.3 points at one strike and 5.0 at another, and understates it in the opposite wing. Reporting N(d₂) to one-tenth of a point while carrying a five-point error is not a simplification; it is a defect, and the service uses (8).

Integrating the density (7) over a strike grid gives the full distribution. The service reports the quantiles from the 5th to the 95th percentile by inverting the resulting cumulative distribution, the tail expected shortfalls E[S | S ≤ q₅] and E[S | S ≥ q₉₅] ^[28], and the distribution's volatility, skew, and excess kurtosis. Correctness is checked by an identity that requires no external data. Under the risk-neutral forward measure the terminal price is a martingale, so its expectation equals the forward:

The service computes the residual E[S_T]/F − 1 and reports it as a self-check. On a live BTC expiry it reads 0.001%, and the raw integral of the density reads 1.000, which together certify that the numerical density is a proper density and that the integration is correct. The distribution is withheld when these checks fail.

Variance risk premium and honest significance

Implied variance tends to exceed subsequently realised variance; the difference is the variance risk premium, the compensation option sellers earn for bearing volatility risk ^{[22],[23],[24]}. The service estimates it as the median ratio of realised to implied volatility over a rolling horizon. Realised volatility over a window is the annualised standard deviation of daily log returns; implied volatility is the DVOL index. The subtlety is significance. Overlapping windows are highly correlated, so the number of windows badly overstates the number of independent observations. Using the raw count would manufacture significance. The service deflates to an effective sample,

and tests whether realised is below implied more often than chance with a one-sided binomial test at n_eff. On live BTC the median ratio is 0.881, which looks like a premium, but at the honest effective sample the p-value is 0.254. The service reports that the premium is not statistically distinguishable from zero and marks every real-world-calibrated probability it derives as indicative only. Computing a plausible number and then refusing to over-claim it is the behaviour a quantitative reviewer looks for, and it is enforced here in code.

Tape microstructure estimators

Three estimators summarise the order flow in a DEX tape. Let a block be a set of consecutive trades; for block j let r_j be the log return across the block, V_j the dollar volume, and q_j the signed dollar flow with buys positive and sells negative. Kyle's lambda ^[15], the permanent price impact per unit of signed flow, is the slope of the regression of block return on signed flow,

reported with its R-squared and sign-agreement so a weak relationship is visible. Amihud illiquidity ^[16] is the average price move per dollar traded,

VPIN ^[17] is the mean absolute buy-minus-sell imbalance across equal-volume buckets, a number in [0,1] where zero is perfectly two-sided flow and one is fully one-sided.

The choice of block rather than tick is not cosmetic; it is a correction that ground-truthing forced. A per-trade Amihud ratio divides by the dollar size of a single trade, and a DEX tape contains sub-cent dust trades whose near-zero denominator sends the ratio to enormous values. On a live memecoin tape the per-trade estimator returned an Amihud figure of order 1.6 × 10⁹, obvious nonsense. Two facts caused it: the dust denominators, and the observation that the exchange returns a sampled large-trade feed for a hot token, so two consecutive trades can be hours apart and their return reflects drift rather than impact. Aggregating into equal-count blocks removes both problems, because a block aggregates real volume and a real time interval, and it is the faithful period form of both Amihud and Kyle. On the same token the block estimator returns an Amihud of 0.303, a sane price move per thousand dollars. The tape-density diagnostic that surfaces the sampled feed is reported alongside, so the caller can see when the impact read rests on thin ground.

Dealer gamma exposure and barrier probabilities

Two further constructions support the options service. Gamma exposure summarises how much delta dealers must hedge as spot moves. The dollar gamma of a strike is its Black-76 gamma scaled by open interest and by the square of spot, and the net across the chain applies the dealer-sign convention of Section 4.1,

Net positive gamma means dealer hedging dampens moves toward the largest strikes; net negative gamma means hedging amplifies them. The gamma-flip is the spot level at which GEX(S) crosses zero, found by scanning a spot band and interpolating the crossing. The convention is an assumption, disclosed as such in Section 8; the construction itself is exact given the convention.

The cross-market service prices reach-by-date questions with the one-touch barrier probability. Under the driftless forward measure, the reflection principle gives the probability that the forward touches a barrier at any time before expiry,

with d₁ = [ln(F/B) + ½σ²T]/(σ√T) and d₂ = d₁ − σ√T for the barrier B. A touch probability is always at least the finish-above probability, since a path that ends beyond the barrier must have crossed it; the test suite asserts this inequality. Because a one-touch is path-dependent, no single volatility is smile-consistent, so the service reports the model-uncertainty span between the barrier and at-the-money volatilities rather than implying false precision.

Transaction and signature safety

The transaction path decodes calldata and, given the full unsigned transaction, executes it against live state with eth_simulateV1, extracting asset and approval changes from the emitted Transfer and Approval events. Upgradeability is checked by reading the proxy implementation slot: the EIP-1967 slot ^[34], its beacon variant, and the pre-standard OpenZeppelin slot used by early proxies. A non-zero implementation flags a contract whose logic its admin can replace after approval.

The signature path parses an EIP-712 typed-data payload ^[32]. EIP-712 binds a signature to a domain and a typed struct through a hash of the form keccak256("\\x19\\x01" ‖ domainSeparator ‖ hashStruct(message)); a signature that a wallet displays as harmless can authorise a transfer through a Permit or Permit2 grant. The service recognises the Permit2 ^[37] and EIP-2612 ^[33] permit shapes, extracts the spender, amount, and expiry, checks the domain against the canonical Permit2 deployment, and flags an unlimited allowance, a non-expiring permit, a batch that touches many tokens, or a spender that resolves to an externally owned or EIP-7702-delegated wallet ^[35] rather than an audited contract. Because these grants are signatures and never transactions, no amount of transaction simulation can see them; a service that stops at simulation leaves the dominant drainer vector uncovered.

Verification and Testing

Two mechanisms keep the services honest: an automated test suite of model-free invariants, and a ground-truthing protocol that runs each service against live data and checks the result against an independent reference.

The invariant test suite

The financial mathematics is locked by 39 automated tests that run under the built-in Node test runner ^[54], with no external dependency. They assert identities that must hold for any inputs, so a regression in the math breaks the build rather than shipping a wrong number. The load-bearing tests are the following.

The no-look-ahead test deserves emphasis because it is the single most important property of anything computed on a time series and the easiest to get subtly wrong. It recomputes each indicator on a truncated prefix of the data and asserts that a settled past value is unchanged. An indicator that fails it is peeking into the future, and any backtest built on it is invalid.

Ground-truthing protocol

Passing synthetic tests is necessary but not sufficient, because a synthetic test only checks what its author thought to check. Every service was therefore run against live venues and its output checked against an independent method. This is where the real defects surfaced, and the value of the protocol is best shown by what it caught. Table 3 lists the corrections that ground-truthing forced; each was invisible to the synthetic tests and obvious the moment the service met live data.

The pattern in every row is the same: the code was internally consistent and wrong, and only contact with reality exposed it. The lesson is the protocol itself. Build, then point the thing at the market and believe the market over the code.

Worked Walkthrough

This section runs four services against live data and annotates the results. The outputs below are real responses captured during validation, lightly trimmed for space; Appendix B gives the exact request that reproduces each.

Options: the risk-neutral distribution of Bitcoin

A single call to options-desk for BTC returns, among its layers, the full risk-neutral distribution of the terminal price for the front expiry. The block below is the live output for an expiry roughly two days out.

"distribution": {
  "quantilesUsd":        { "p05": 61423, "p25": 63116, "p50": 64091, "p75": 65057, "p95": 66650 },
  "expectedShortfallUsd":{ "left5": 60186, "right5": 67755 },
  "rnVolPct": 2.6, "rnSkew": -0.204, "rnExcessKurtosis": 3.303,
  "selfCheck": { "meanVsForwardPct": 0.001, "densityMass": 1.0 }
}

The quantiles are monotone and centred near spot, as a two-day distribution should be. The negative skew of −0.20 is the downside-protection demand characteristic of a crypto smile, and the excess kurtosis of 3.3 is the fat tail. The line that matters most is selfCheck.meanVsForwardPct: 0.001: the mean of the recovered density reproduces the forward to a thousandth of a percent, so the distribution is not a plausible-looking artefact but a correct risk-neutral density. Every figure downstream, the probability ladder, the expected shortfall, the cross-market divergence, inherits that correctness.

Safety: an unlimited approval to a wallet

A call to calldata-x with an approve of unlimited USDC to an externally owned address returns a danger verdict, because an unlimited allowance to a personal wallet is the signature of an approval drainer.

"verdict": "REVIEW_HIGH_RISK",
"alert": { "level": "DANGER" },
"spenderReputation": {
  "tier": "eoa",
  "basis": "eth_getCode -> EIP-7702 delegated wallet",
  "activity": { "outboundTxCount": 5932 }
}

The same call structure with the spender set to a recognised router returns a routine note, not a danger, which is the false positive a naive rule would raise on every legitimate swap approval. Pointed at USD Coin, the target-proxy check now reports isProxy: true under the legacy OpenZeppelin standard, the correction that ground-truthing produced.

Microstructure: price impact on a live tape

A call to tape-pulse on a liquid token returns the three estimators of Section 5.5. On a dense tape such as PEPE, Kyle's lambda is estimated with a meaningful fit; on a sampled tape it honestly reports low confidence rather than a fabricated coefficient.

"microstructure": {
  "kyleLambda": { "priceImpactBpsPer10kUsd": 13.9, "rSquared": 0.175, "confidence": "medium" },
  "amihud":     { "pctMovePer1kUsd": 0.089 },
  "vpin":       { "value": 0.66 },
  "tape":       { "medianGapSeconds": 48, "spanHours": 22.2 }
}

A net ten thousand dollars of one-sided flow is associated with about fourteen basis points of move, with a fit R-squared of 0.175, a respectable figure for a tick-level impact regression. VPIN of 0.66 marks moderately one-sided flow. The tape-density line shows a forty-eight-second median gap, dense enough that the impact read stands on firm ground.

Execution: the cost of size on a prediction market

A call to poly-fill on a live Bitcoin-threshold market walks the book and fits the impact curve.

"marketImpact": {
  "model": "cost ~= k * sqrt(notional) (square-root impact law) FITTED to the live book",
  "coeffPctPerSqrtUsd": 0.176, "fitR2": 0.552, "visibleDepthUsd": 94167
},
"bookDepth": { "totalBidUsd": 18845, "totalAskUsd": 94167, "imbalance": 0.167 }

The fit R-squared of 0.55 is the honest signature of a discrete prediction-market book: it follows the square-root law moderately, not perfectly, and the service measures that rather than asserting a clean coefficient. The depth imbalance of 0.167 shows a book heavily weighted to the ask side.

Charting: a rendered figure with numbers baked in

A call to chart-press returns a PNG an agent can attach to a message, together with a facts block whose numbers are computed from the same candle series that is drawn. The figure below is a live render for wrapped Bitcoin on the four-hour interval with an exponential moving average, Bollinger bands, a relative-strength panel, and a volume panel, produced by the fast browserless tier.

Figure 2 — live chart-press render (wBTC, 4H), fast tier. The facts block returned with the image carries the same high, low, and last values that the candles show.

Because the facts and the pixels come from one computation, an agent that reads back the price from the facts cannot contradict the chart it displays. This is the anti-hallucination property of the service: the numbers and the picture cannot diverge.

Limitations and Honest Disclosures

A service is only as trustworthy as its account of what it cannot do. The following limitations are real, and each is disclosed in the relevant output rather than buried here.

1. Dealer positioning in GEX is an assumption, not a measurement. The gamma-exposure sign convention assumes dealers are long call gamma and short put gamma. It cannot be replaced by a flow-inferred position because Deribit's public feed reports block-trade direction from the maker side and carries no block tag, so a flow-based sign would be invertible for much of the volume. GEX is a positioning map under a stated convention, not measured dealer inventory.
2. The variance risk premium is not statistically significant on current data. At the honest effective sample the p-value is 0.254. The real-world-calibrated probabilities that depend on it are marked indicative, and the raw risk-neutral figures, which do not depend on it, are the ones to trust.
3. One-touch barrier prices use a single volatility. A path-dependent barrier is not smile-consistent under any single volatility; the rigorous treatment is a local-volatility model or a vanna-volga adjustment ^[13], neither of which runs per call. The service instead reports the model-uncertainty span between the barrier and at-the-money volatilities, so the caller sees the width of the approximation.
4. Transaction simulation is single-transaction and single-block. It does not model multi-transaction bundles, sandwich or other MEV exposure, or custom state overrides, which require a bundle simulator. Spender reputation uses reachable on-chain signals; a verified-source check and an approval-graph would need an indexer that is not wired.
5. The exchange tape can be a sampled feed. For a hot token the DEX trade endpoint returns a large-trade subset rather than the full tape, which weakens tick-level impact estimates. The service surfaces the tape-density diagnostic so this is visible, and reports Kyle's lambda with a confidence label.
6. The macro calendar is curated and will age. It is sourced from fixed institutional schedules and is accurate for the covered period, but it is not a live primary-source fetch and must be refreshed.
7. None of the services is financial advice. They report what markets price and what data shows. Every output that touches a decision carries a not-advice disclosure, and the short-window up/down service refuses to output a directional edge at all.

Related Work and Positioning

Quiver sits at the intersection of three bodies of work: the agent-economy infrastructure that makes priced machine-to-machine services possible, the quantitative-finance methods the services implement, and the security tooling for on-chain transactions.

On infrastructure, x402 ^[39] supplies the payment rail, ERC-8004 ^[38] the identity and reputation layer, and the A2A and MCP conventions ^[40],[41] the calling and tool-exposure patterns. These standards define how agents pay and discover; they are deliberately silent on what is worth buying, which is the space Quiver occupies. Existing agent-registry services skew toward general assistants and simple data relays; a survey of the registry at build time found no service offering arbitrage-free options analytics, and the closest options-adjacent listings were not agent-callable.

On methods, the options stack rests on Black-76 ^[1], the Breeden–Litzenberger density ^[4], and the SVI surface of Gatheral with the no-arbitrage conditions of Gatheral and Jacquier ^[5],[6] and the wing bound of Lee ^[8]; the risk-neutral density literature ^[9] and its practitioner treatments inform the distribution layer. The microstructure estimators are Kyle ^[15], Amihud ^[16], and the VPIN of Easley, López de Prado, and O'Hara ^[17], with the square-root impact law of Almgren and collaborators ^[18],[21] behind the fill service. The variance risk premium follows Bakshi and Kapadia and Carr and Wu ^[22],[23]. None of this is novel mathematics; the contribution is implementing it correctly, arbitrage-free, tested, and behind a priced agent interface, which is precisely what has not existed for agents before.

On security, the transaction path is a conventional simulation-and-decode pattern; the distinguishing element is the EIP-712 signature analysis ^{[32],[33],[37]}, which addresses a vector that transaction-only tools cannot observe and that accounts for a large share of modern wallet losses.

The Build: Story, Process, and a User Scenario

This section steps back from the specification to tell how Quiver was built, what was learned along the way, and how the pieces are meant to be used together. The engineering record is part of the argument, because the decisions and the corrections are what a specification cannot show.

Starting from a gap

The project began with one observation. Agents had just gained the ability to pay for a service in-band over HTTP, and almost nothing worth paying for existed on the other side of that payment. We looked at what an autonomous trading or wallet agent needs at the moment it acts, and the list was concrete: the real probability that a price level is reached, the true cost of a size against real depth, a verdict on a signature before it is signed. None of it was available in a form an agent could call and trust. That gap set the direction. The decision that followed was to build computations a desk would recognise rather than another data relay, since a relay adds nothing an agent could not fetch for itself.

Choosing the ten

Not every candidate survived. We held ideas to a floor: a real recurring need, an identifiable caller, and durability past the moment of a demo. Anything that depended on a fad, or that dressed a single API call as a product, was dropped. What remained clustered into the ten services of Section 4. Options analytics was chosen as the widest moat, because the mathematics is unforgiving and the registry held no options service; a wrong volatility surface is worse than none, so getting it right is itself a barrier. Transaction safety was chosen for the opposite reason, that it is the highest-frequency and highest-stakes decision an agent makes, and the signature-drainer vector was covered by nobody. The rest fill out the surfaces an agent touches inside a loop: the tape, the book, the protocol, and the calendar.

Holding a standard, and what it caught

The standard was set higher than a demo needs, on the principle that a financial service is judged by its worst number rather than its best. Early on, that principle paid for itself. The textbook probability formula, N(d₂), was the first thing we reached for and the first thing we caught: on a skewed smile it is biased, and the bias was measured against a numerical density before the formula was replaced. The volatility surface took two attempts. A single global surface across all maturities was tried first and rejected by its own error gate, which was the right outcome; the literature prescribes fitting each expiry, and the second attempt did that and passed. The variance risk premium looked real until it was tested at the honest sample size, at which point it was not, and the service was made to say so.

The sharpest lessons came from pointing finished code at live markets. An illiquidity estimator that passed every synthetic test returned a value of order 10⁹ on a real memecoin, because a live tape carries sub-cent dust the tests never imagined. A proxy detector that correctly handled the modern standard reported USD Coin, one of the most famous proxies in existence, as not a proxy, because USDC predates the standard and hides its implementation in an older slot. Each defect was invisible until the code met reality, and each one changed the implementation. The habit hardened into a rule that governs the whole project: build the thing, then point it at the market and believe the market over the code. Table 3 in Section 6 is the ledger of what that rule caught.

A day in an agent's loop

The services are designed to be used together, and the clearest way to see the product is to follow one agent through a single decision. Consider a trading agent that has resolved to take a directional position and is about to size it and sign for it.

1. It calls options-desk and reads the risk-neutral distribution, checking whether the market already prices the move it expects and at what probability, so it is not paying for a move the options market considers likely.
2. It calls poly-fill, or reads the options expected move, to learn what its intended size will actually cost against live depth rather than against a midpoint that a thin book makes fictional.
3. It checks macro-sentry so it does not size into a scheduled print, and reads tape-pulse to see whether current flow is one-sided against it.
4. Having sized the trade, it constructs the approval and, before signing, passes the unsigned transaction and any permit signature to calldata-x. An unlimited approval to an unrecognised wallet returns a danger verdict and stops the loop; a routine approval to a known router passes.
5. On the next iteration it calls loop-digest with its cursor and reads only what changed, instead of re-fetching and re-paying for the entire state.

Each call costs a few tenths of a cent, cheap enough to sit inside the loop, and each returns a number the agent can act on because the number can be checked. A market read, an execution cost, and a safety gate, all callable and all verifiable in one loop, is what Quiver is for.

Conclusion

Quiver is a live, paid Agentic Service Provider that gives autonomous agents ten financial and security computations they can call over x402 and discover under ERC-8004. The services implement methods a desk would recognise, and they are held to a standard that this document has tried to make legible rather than merely assert: correctness proven by 39 model-free tests, claims grounded against live venues, and a stated refusal to emit a number the data does not support. That refusal is not a limitation of the product; it is the product. In a market where an agent must trust a computation it cannot supervise, a service that corrects its own N(d₂), that catches its own Amihud explosion, and that reports a variance premium as insignificant when it is, is worth more than one that returns a confident number and hopes. The mathematics here is public and old. The discipline of applying it honestly, at the point where an agent is about to move money, is the part that was missing.

Appendix A  ·  API Reference

All services are reached at https://quiver-production-c3a8.up.railway.app. Each paid route answers an unauthenticated request with the x402 402 challenge; a request carrying a valid payment authorisation receives the JSON result. Inputs are passed as query parameters on a GET or as a JSON body on a POST.

Appendix B  ·  Reproducibility

Every figure in this document is reproducible against live venues. Because reproduction of a live number requires the live market to be in a comparable state, the figures should be read as representative of the method rather than as constants.

• Options distribution and martingale check (Section 7). Call options-desk with currency=BTC and read impliedView[0].distribution. The selfCheck.meanVsForwardPct field is the martingale residual of equation (9) and should be near zero on any well-formed chain.
• Probability correction (Section 5.3). The probabilityLadder reports both the corrected probability and the field skewCorrectionPts, the size of the smile-slope term of equation (8) at each level. Independently, fetch the Deribit ticker greeks for the same instruments and confirm the delta matches to three or four decimals.
• Signature and proxy safety (Section 7). Call calldata-x with an approve(spender, MAX_UINT) calldata, to a token, and from any funded address; vary the spender between a known router and a wallet to see the verdict flip. Re-run eth_simulateV1 with the same inputs on any node to confirm the emitted Transfer and Approval logs.
• Tape microstructure (Section 5.5). Call tape-pulse on a liquid token; the tape.medianGapSeconds field indicates whether the read rests on a dense or a sampled feed, and Kyle's lambda carries its own R-squared and confidence.
• Market impact (Section 7). Call poly-fill on a live market; marketImpact.fitR2 is the measured quality of the square-root fit, and bookDepth.imbalance is computed from the same book that the walk consumes.

The invariant test suite is self-contained and deterministic; it runs with the project's standard test command and requires no network access, so the 39 model-free properties of Section 6 can be verified offline.

References

Quiver technical documentation, version 1.0, July 2026. Prepared for the OKX AI Genesis Hackathon. All quantitative figures were captured from live venues during validation and are representative of the methods described; live values vary with market state. This document is technical documentation and not financial advice.