Wire it into your agent

The integration pattern is one rule: no strategy goes live without a verdict. AlphaAssay is a plain HTTPS API, so it drops into any agent framework that can make an HTTP call — no SDK required.

Prefer MCP? Connect the server directly.

The same engine is a native MCP server: streamable HTTP at https://mcp.alphaassay.com/mcp, published in the official registry as com.alphaassay/mcp. Stdio-only clients bridge it with npx mcp-remote https://mcp.alphaassay.com/mcp. Your agent then sees the 21 hosted public assay_* tools — 6 free and 15 priced by the live registry. The local stdio registry is a separate catalog of 50 operator/research tools, not a local copy of the hosted public surface. REST and MCP share application operations only where the transport-parity table says so; their auth fields, schemas and bounds can differ, and x402 is only POST /x402/v1/gauntlet.

What does the validate-before-trade loop look like?

The pattern is one rule — no strategy goes live without a verdict. The pseudocode below validates each candidate, logs fails to a graveyard with their cause of death, retires families whose budget is spent, and flags regime-fragile passes. Certificate issuance belongs to the separate evaluated pre-registration lifecycle.

python · agent pseudocode

def consider_strategy(candidate) -> bool:
    v = assay.validate(candidate)            # graded gauntlet.v1 verdict, ~seconds

    if v["verdict"] in ("fail", "insufficient_evidence"):
        log_graveyard(candidate, v["died_at"], v["failure_codes"])
        if v["died_at"] == "family_deflation":    # deflated_out_at_n=N
            retire_family(candidate.family)       # the family is spent — stop tweaking
        return False

    survival = assay.forensics(candidate)["survival_map"]   # eight adversarial attacks (paid)
    if any(a["attack"] == "regime_split" and not a["survives"] for a in survival):
        candidate.flag("regime-fragile")      # pass ≠ pass — read the map

    return v["verdict"] == "pass"

When the candidate came from an evaluated pre-registration, call the documented certificate-issuance action with its prereg_id, verify the returned certificate, and archive that artifact. An ordinary validation verdict cannot be converted into a certificate by the pseudocode above.

How should my agent branch on failure codes?

The failure codes are designed for machine decisions: no_net_edge → the edge never survived realistic costs; the direction, not the tuning, is the problem; deflated_out_at_n=N → stop generating variants of this idea entirely. An agent that reacts to codes converges; one that retries blindly burns budget on a dead family.

How do I calibrate trust in AlphaAssay automatically?

Bootstrap trust from public evidence in CI: pull our public calibration record, then run the four golden specimens and assert their known verdicts.

python · trust bootstrap, run it in CI

# 1. current public calibration population/status disclosure — free, no account:
rec = requests.get("https://api.alphaassay.com/v1/public/calibration").json()
assert rec.get("signed") is True              # otherwise stale/reason, no calibration payload

# 2. our correctness — run the known-answer tests yourself:
for spec, expected in GOLDEN_SPECIMENS:
    got = requests.post(DEMO_URL, json=spec).json()
    assert got["verdict"] == expected         # stable semantic field for this specimen

Both checks are free — run them in CI so your agent re-audits us on every deploy. Every specimen and its expected verdict: golden specimens.

Should I verify every verdict I store?

Verify every certificate you store, not an assumed signature on an ordinary verdict. Python, Node and OpenSSL examples can establish raw_signature_valid; platform_valid additionally requires independently rooted keyring and revocation evidence. Named public envelopes expose their signature fields, or an explicit unsigned fallback when no deployment signing key exists.