From Natural Language to Executable Option Strategies via Large Language Models

This paper introduces Option Query Language (OQL), a domain-specific intermediate representation paired with a neuro-symbolic pipeline that enables Large Language Models to reliably translate natural language trading intents into executable option strategies by abstracting complex market data into high-level primitives and validating outputs through a deterministic execution engine.

The Gist

Imagine you want to build a complex financial machine (an Option Strategy) to make money or protect your investments. Usually, you have to talk to a highly specialized engineer (a Quantitative Analyst) who speaks a very difficult, technical language. You give them a vague idea like, "I think the stock market is going to stay flat for a month, so I want to make money from that without risking too much," and they have to translate that into a rigid, mathematical blueprint.

This paper introduces a new system that lets you talk to an AI in plain English, and the AI builds that financial machine for you, but with a crucial safety net.

Here is the breakdown using simple analogies:

1. The Problem: The "Magic Box" vs. The "Library of Chaos"

Imagine you have a super-smart robot (a Large Language Model or LLM) that can write code and understand human language. You ask it: "Build me a strategy to profit if the stock stays between $100 and $110."

If you ask the robot to just "write the code" directly, it's like asking a chef to cook a 5-course meal while blindfolded in a kitchen filled with 10,000 different ingredients.

• The Risk: The robot might hallucinate. It might invent a stock ticker that doesn't exist, or create a recipe that violates the laws of physics (financial rules), causing you to lose money.
• The Data Overload: The "kitchen" (the stock market) has millions of options (contracts) with different prices and dates. It's too much information for the robot to hold in its "short-term memory" at once.

2. The Solution: The "Translator" (OQL)

The authors created a middleman called OQL (Option Query Language). Think of OQL as a specialized translator or a form order form.

Instead of letting the robot write the final code (the complex financial strategy) directly, you ask the robot to fill out a strict, structured form (OQL).

• The Analogy: Imagine you are ordering a custom suit. Instead of telling the tailor, "Make me something cool," you fill out a form with specific checkboxes: Fabric: Wool, Color: Navy, Size: 40R, Lining: Silk.
• Why it works: The robot is great at understanding your intent ("I want a navy wool suit") and filling out the form correctly. It doesn't need to know how to sew the suit yet; it just needs to describe the suit perfectly.

3. The Process: How the System Works

The paper describes a two-step "Neuro-Symbolic" pipeline (a fancy way of saying "Brain + Rules"):

• Step 1: The Brain (The LLM as a Translator)
  You type your idea in English: "Find me a safe bet on Apple stock that earns money if the price doesn't move much."
  The AI translates this into the strict OQL form:
  SELECT IRON_CONDOR FROM APPLE WHERE Delta is near 0 AND Expiry is 45 days...
  Crucially, the AI is now acting as a semantic parser, not a free-wheeling programmer. It's constrained by grammar rules, so it can't invent nonsense.

• Step 2: The Engine (The Deterministic Compiler)
  Once the form is filled out, a separate, rigid computer engine takes that form and executes it against the real market data.

  • The Analogy: This is like a factory robot that takes the order form and actually cuts the fabric and sews the suit. Because the form was strict, the robot knows exactly what to do. It checks the real prices, calculates the risks, and finds the actual contracts that match your form.
  • Safety: If the form is wrong, the engine catches it immediately. If the form is right, the engine guarantees the result is mathematically valid.

4. The Results: Why This Matters

The researchers tested this against other methods where AI tries to guess the strategy directly or uses standard database languages (SQL).

• Less Hallucination: The "Form" method (OQL) stopped the AI from making up fake stock prices or impossible strategies.
• Better Safety: Strategies generated by OQL were much less likely to blow up your account (lower risk of "margin calls").
• Smarter than Bigger Models: Interestingly, a smaller, specialized coding AI performed better than a massive, general-purpose AI when using this method. It proved that having the right structure (the form) is more important than just having a bigger brain.

Summary Metaphor

Think of trading options like navigating a ship through a minefield.

• Direct AI Generation: You ask a captain who has never seen the map to "steer us through the mines." He might guess, but he'll likely hit a mine.
• The OQL Method: You give the captain a sonar map (the OQL form). He translates your destination ("We want to go North") into specific coordinates on the map. Then, an autopilot system (the engine) follows those coordinates perfectly, avoiding the mines because the map was precise.

In short: This paper teaches us that to get AI to do dangerous financial tasks, we shouldn't let it "freestyle." Instead, we should force it to speak a structured, rule-based language that acts as a safety filter, ensuring the final result is both smart and safe.

Technical Summary

1. Problem Statement

The paper addresses the challenge of translating vague Natural Language (NL) trading intents (e.g., "Find a delta-neutral Iron Condor on SPY with low implied volatility rank") into executable, multi-leg option strategies.

• The Gap: While Large Language Models (LLMs) excel at general code generation, applying them directly to financial derivatives is difficult due to:
  • Data Complexity: Option chains contain thousands of contracts across strikes and expiries, creating high-dimensional inputs that exceed LLM context limits.
  • Logical Rigor: Financial strategies require strict adherence to constraints (e.g., Greeks, risk limits). Direct text-to-code generation often leads to hallucinations (invalid tickers, impossible strike combinations) or logical errors.
  • Domain Specificity: Existing LLM applications in finance focus largely on equities (price prediction, sentiment) rather than the structural design of complex derivative strategies.

2. Methodology: The OQL Framework

The authors propose a neuro-symbolic pipeline that decouples semantic understanding from financial execution. The core innovation is the Option Query Language (OQL).

A. Option Query Language (OQL)

OQL is a domain-specific intermediate representation (DSL) that acts as a bridge between natural language and the option market data. It is designed with three key principles:

1. Role-Based Abstraction: Strategies are defined by fixed "role schemas" (e.g., an Iron Condor has specific roles: Short Call, Long Call, Short Put, Long Put). This enforces structural validity, preventing the model from generating semantically invalid combinations (e.g., two calls in a straddle).
2. Scoped Filtering:
   • Leg-level constraints (WHERE): Applied to individual contracts (e.g., Delta $\approx$ 0.15, Days to Expiry $\approx$ 45).
   • Strategy-level constraints (HAVING): Applied to the aggregated portfolio (e.g., Net Delta $< 0.1$, Max Loss < \500$).
3. Semantic Soft-Matching: Introduces an approximate matching operator (~) to handle linguistic ambiguity (e.g., "around 30 days") by allowing a tolerance range ($\epsilon$) rather than requiring exact numerical matches, reducing empty-result failures.

B. The Two-Stage Pipeline

1. Semantic Parsing (LLM $\to$ OQL): The LLM acts as a semantic parser, translating the user's NL intent into a structured OQL query. The LLM is constrained by the OQL grammar (EBNF), preventing it from generating free-form code.
2. Deterministic Execution (OQL $\to$ Strategy): A specialized engine parses the OQL query, validates it against the role schema, and executes it against the massive option chain data. This involves:
   • Vectorized filtering of candidate contracts.
   • Cartesian product assembly of legs.
   • Application of aggregate constraints (HAVING clause).
   • Ranking and returning the final executable strategy.

3. Key Contributions

1. OQL Language: The first domain-specific language designed specifically for querying option strategy spaces, encoding complex logic (Greeks, multi-leg structures) into a token-efficient, execution-rigorous format.
2. New Benchmark Dataset: Creation of a dataset containing 200 diverse option trading instructions grounded in realistic 2025 market regimes (trending, range-bound, volatile). The dataset includes human-annotated strategy labels and backtesting windows to prevent look-ahead bias.
3. Neuro-Symbolic Evaluation: A comprehensive evaluation framework comparing the proposed OQL approach against baselines, demonstrating that structured querying significantly outperforms direct generation methods in both logical consistency and financial performance.

4. Experimental Results

The authors evaluated various LLMs (including DeepSeek-V3, GPT-4.1, Gemini-2.5, and smaller open-weight models) against three baselines:

• FFLG (Free-Form Leg Generation): LLM generates legs directly without data.
• PCG (Partial-Chain Grounded): LLM generates legs based on a partial option chain snapshot.
• Text-to-SQL: LLM generates standard SQL queries.

Key Findings:

• Validity & Accuracy: OQL achieved high Validity Rates (VR > 0.87 for large models) and significantly higher Semantic Accuracy (SA) compared to baselines. It drastically reduced "hallucinations" (e.g., invalid tickers).
• Financial Performance:
  • Risk Management: OQL significantly reduced tail risk. For example, DeepSeek-Chat using OQL reduced Buyer-side Risk@90 to 18.6% compared to 46.1% for Text-to-SQL.
  • Profitability: OQL strategies achieved higher Win Rates (e.g., 60.9% for DeepSeek-Chat vs. 52.8% for SQL) and better Return on Cost (ROC).
  • Model Efficiency: Surprisingly, smaller specialized coding models (e.g., DeepSeek-Coder-6.7B) outperformed larger generalist models (GPT-4.1-Mini) in profitability, suggesting that domain-specific syntax reasoning is more critical than parameter size for this task.
• Token Efficiency: While OQL queries are slightly longer than raw SQL, the framework achieves a high cache hit rate (88.5%) and avoids the prohibitive token costs associated with feeding full option chains to LLMs (as in PCG).

5. Significance and Future Work

• Paradigm Shift: The paper demonstrates that for high-stakes financial tasks, structured intermediate representations are superior to direct text-to-code generation. It proves that LLMs function best as "semantic parsers" rather than "free-form programmers" when dealing with complex, constrained data spaces.
• Practical Applicability: The system enables non-experts to interact with complex option markets using natural language while ensuring the output is mathematically valid and executable.
• Future Directions: The authors plan to extend OQL to support free-form leg design (beyond predefined templates), incorporate existing portfolio holdings for adaptive strategy generation, and integrate realistic trading frictions (slippage, commissions) into the execution engine.

In conclusion, this work establishes a robust, neuro-symbolic framework for automated option trading, bridging the gap between human intent and rigorous financial execution while mitigating the risks of LLM hallucinations in critical financial domains.