Add pre-trade market state verification to StockTradingEnv

[LembaGang]

Hi,

I saw FinRL and noticed StockTradingEnv uses datetime for scheduling but doesn't verify whether the exchange is actually open at execution time. That's the gap that causes silent failures when agents trade into closed markets or hit DST transitions.

I've been building Headless Oracle — a signed market oracle for AI agents. Before your agent executes, it fetches an Ed25519-signed attestation that the market is open. 60-second TTL, 28 exchanges.

import requests

r = requests.get('https://headlessoracle.com/v5/demo?mic=XNYS')
receipt = r.json()

if receipt['status'] != 'OPEN':
raise Exception(f"Market not open: {receipt['status']}")

Free to try (no key needed for /v5/demo). pypi.org/project/headless-oracle has LangChain and CrewAI tools built in.

Would you be open to adding a pre-trade market gate to the RL environment? Happy to write it.

— Mike (headlessoracle.com)

[JohnnyTarrr]

Pre-trade signal verification is where we have production experience.

VeroQ Shield verifies any LLM-generated signal or recommendation before execution — extracts claims, checks each against live market data (1,061 tickers, SEC filings, technical indicators), returns per-claim verdicts.

For FinRL, the integration point is between signal generation and execution:

from veroq import shield
result = shield(agent_signal_text)
if result.claims_contradicted > 0:
    # Block trade — agent hallucinated

Also provides 64 verified data endpoints (market data, SEC EDGAR, energy, CFTC positioning) that could plug into FinRL's data processor layer as a verified source.

pip install veroq

[LembaGang]

Nice — VeroQ handles signal verification (is the agent's claim factually correct), we handle market-state verification (is the exchange actually open right now). Different layers of the pre-trade stack.

Headless Oracle returns Ed25519-signed receipts with a 60-second TTL and fail-closed guarantee — if the state is unknown, the agent halts. The two compose naturally:

1. HO → Is the exchange open? (signed receipt)
2. VeroQ → Is the agent's signal factually accurate? (claim verdicts)
3. Execute

Would be interested in exploring a reference integration where both run as pre-trade gates in a FinRL pipeline.

npx headless-oracle-mcp

headlessoracle.com · MCP Registry · Dev.to writeup

[JohnnyTarrr]

This is a clean composition. Two distinct verification domains, both producing cryptographic receipts, both fail-closed. No overlap.

To spell out why these are complementary rather than redundant:

• HO answers: "Can this trade physically execute right now?" (exchange state, order book integrity, Ed25519-signed with 60s TTL)
• VeroQ answers: "Is the thesis behind this trade actually true?" (claim extraction against live market data, SEC filings, technical indicators — per-claim verdicts)

An agent could pass HO's market-state check but still be trading on a hallucinated earnings estimate. Or it could have a factually correct thesis but attempt to execute against a closed exchange. You need both layers.

A concrete next step would be a reference integration in FinRL's pipeline. Rough sketch:

from veroq import shield, verify
# + headless oracle client

def pre_trade_gate(agent_signal, ticker):
    # Layer 1: market-state integrity (HO)
    ho_receipt = headless_oracle.check(ticker)
    if not ho_receipt.valid:
        return False, "market state unverified"

    # Layer 2: signal factual accuracy (VeroQ)
    vq_result = shield(agent_signal)
    if vq_result.claims_contradicted > 0:
        return False, f"{vq_result.claims_contradicted} claims contradicted"

    return True, "both gates passed"

This slots into FinRL's agent loop between predict() and execute(). Both checks add sub-second latency. Either gate failing halts the trade.

Worth building this out as a standalone example that FinRL contributors can drop into their existing pipelines. Happy to collaborate on the VeroQ side — the Python SDK (pip install veroq) already exposes shield() and verify() with the right interface for this.

[LembaGang]

Clean sketch. The interface is right — both checks return a boolean gate with a reason string, both add sub-second latency, either failing halts execution.

A few details on the HO side for the integration:

• npx headless-oracle-mcp for MCP, or the Python SDK (pip install headless-oracle-sdk — releasing shortly) for direct integration like your example
• The receipt includes signature and public_key_id so FinRL can verify the attestation offline without calling HO again
• receipt_mode: "live" distinguishes production attestations from demo/trial responses

Happy to build out the HO side of the reference integration. We could structure it as a standalone finrl-pretrade-gates package that FinRL contributors drop in — clean separation from both our core repos.

One thing worth considering for the full stack: between market state (Layer 1) and signal verification (Layer 2), there's a spend authorization layer — "is this agent allowed to execute a trade of this size?" That's a different domain again. For the initial reference integration, the two-gate pattern is the right scope. The authorization layer can slot in later without changing the interface.

Let's build it. I can have the HO client wrapper ready this week.