Open standard · version 1.0.0 · 2026-10-31

Ora Rules v1

A small, exact language for questions about a price series: C > sma(C, 50), rsi(C, 14) < 30, engulfing_bull(), days_to_earnings <= 10. A rule answers with a belief between 0.05 and 0.95: how clearly it holds on the latest bar, measured against how much that quantity normally moves. This document specifies the language completely, so anyone can implement it.

1. Data model

A rule is evaluated against one series of bars, oldest first. Each bar has five numbers: open O, high H, low L, close C and volume V, and MAY have a timestamp. The rule is about the latest bar (the evaluation bar) unless it looks back with an offset or a window. Daily bars SHOULD be split- and dividend-adjusted. An implementation MAY also expose named facts: single numbers known at the evaluation bar (section 8).

Every expression denotes a series aligned with the bars: C is the series of closes, sma(C, 50) the series of 50-bar averages. A value that cannot be computed at a bar (too little history, division by zero, a bar that does not exist) is not known at that bar.

2. Lexical rules

3. Grammar

rule     := or
or       := and ( "or" and )*
and      := not ( "and" not )*
not      := ( "not" | "!" ) not | compare
compare  := sum ( (">" | ">=" | "<" | "<=" | "==" | "=" | "!=") sum )*
sum      := product ( ("+" | "-") product )*
product  := power ( ("*" | "/" | "%") power )*
power    := unary ( "^" unary )*
unary    := ("+" | "-") unary | primary
primary  := "(" rule ")" | number | "true" | "false"
          | price [ "[" offset "]" ] | function "(" [ args ] ")" | fact
args     := rule ( "," rule )*
price    := "O" | "H" | "L" | "C" | "V"
offset   := [ "-" ] digits
number   := digits [ "." digits ] | "." digits
fact     := name                       (a name that is not a price, keyword or function)
name     := letter ( letter | digit | "_" )*

Function arguments are full expressions, so windows take any series: avg(H - L, 20). Optional trailing arguments take the defaults shown in each signature (zlema(x, n=20)).

4. Precedence

and binds tighter than or: a or b and c is a or (b and c). Implementations SHOULD warn when the two are mixed without parentheses.

5. Evaluation

1. Arithmetic is on series. + - * / % ^ apply bar by bar. Division by zero is not known at that bar.
2. A comparison inside arithmetic or a function argument is 1 or 0 at each bar, so sum(C > C[-1], 10) counts up bars. A comparison with a side that is not known is not known.
3. Only the outermost comparisons become beliefs: those joined by and, or and not at the top of the rule (section 6).
4. Windows such as sma(x, n), max(x, n) and sum(x, n) cover the last n bars including the current one. highest(x, n) and lowest(x, n) cover the n bars before it, so C > highest(C, 20) is a breakout.
5. Events such as crossup(a, b) are true only on the bar where they happen.
6. Patterns (hammer(), engulfing_bull(), …) are macros: each is defined as a rule in the core language (section 9 lists the expansions) and MUST evaluate exactly as its expansion.

6. Beliefs

A rule does not answer true or false. It answers how far past the line the latest bar is, in units of how much that gap normally moves for this series, as a belief in [0.05, 0.95].

1. Margin. For a > b and a >= b, the margin is a − b at the latest bar; for < and <= it is b − a.
2. Scale. The sample standard deviation (n − 1) of (a − b) over the last 60 bars, skipping bars where it is not known. A constant on one side does not change it, so rsi(C, 14) > 30 and > 70 share one yardstick. With fewer than 8 known values, or a deviation of zero, the scale is the fact's declared scale (section 8) if one side is a fact, otherwise 10% of |a| at the latest bar.
3. Belief. With r = min(|margin| ÷ scale, 3): b = 0.5 + 0.45 × (1 − e^{−1.6 r}) when the margin is positive (the rule holds), 1 − b when it is negative, and the tie value when it is exactly zero.

A belief is not a probability. It describes how clearly a condition that is already decided holds. Implementations MUST NOT present rule beliefs as forecasts. Beliefs are rounded to 4 decimal places, so a comparison ranges from 0.0537 to 0.9463 and only a bare expression reaches 0.05 or 0.95.

7. Values and formulas

An implementation SHOULD offer a value evaluation that returns the number an expression has at the latest bar (sma(C, 50) → 612.4), and MAY accept formulas: named inputs written as "=expression" whose values are computed before a request is answered ("stop": "=lowest(L, 20)"). Inputs given as plain numbers MAY be read by name in rules, like facts (C > stop).

8. Facts

A fact is a named number known at the evaluation bar, point in time: it uses only what was known at that bar's close. A fact that is not known makes its comparison 0.50; "none on record" (a stock that never split) is the number 99999, so "split in the last year" is a clean no. Each fact declares its scale. Ora Rules v1 names 43 facts in three groups; an implementation that offers a group MUST use these names and meanings.

Earnings

Dividends

Splits

9. Functions

322 functions in 18 groups: 63 core (required), 234 library (optional, each defined exactly) and 25 patterns (macros over the core). Arguments named x take any series; n is a whole number of bars. This list is generated from the reference engine's own catalog.

Windows

Indicators

Maths

Prices

Recursion

Signals

Intraday

Price structure

Moving averages

Oscillators

Trend

Volatility

Volume

Statistics

Returns and risk

Calendar

Relative strength

Patterns

10. Errors

A rule that does not parse, calls an unknown function, passes the wrong number of arguments, puts an offset on anything but a price letter, or names an unknown fact MUST be rejected, not answered. Over HTTP, Ora returns 422 with one entry per problem, pointing at the question:

{
  "detail": [
    {
      "loc": [
        "body",
        "questions",
        "trend",
        "ask"
      ],
      "type": "value_error",
      "msg": "Unknown function `smaa`. Did you mean `sma`?"
    }
  ]
}

11. Conformance

Say which levels you implement, for example “Ora Rules v1: Core + Patterns”. Test vectors: the belief table in section 6 is normative; the rule library shows real answers on real symbols for comparison.

12. Versioning

This is Ora Rules v1 (1.0.0). Minor versions (1.1, 1.2) only add functions, facts or patterns; they never change what an existing rule means. A change to the meaning of an existing rule or to the belief formula is a new major version with its own URL. Each version stays published at /spec/v<major> and /spec/v<major>.json.

13. Implementing it

• Start from /spec/v1.json: the grammar, belief constants and every function with its signature, definition and an example.
• Check your beliefs against Ora's on the same bars: send your own bars to POST /v1/systemone (bring your own bars) and compare.
• Agents can call Ora directly over MCP, and share any rule as a public link from the Playground.

Ora Rules v1 by KlickAnalytics (oramodel.com), licensed CC BY 4.0. Information, not investment advice.