What is Grand Thera?

Why Grand Thera exists

Most enterprise systems can show what happened. Fewer systems can tell decision makers what changed, why it matters, and what should happen next. Grand Thera is designed for decision-critical environments where fragmented information, uncertain signals, and delayed execution create measurable financial risk.

The goal is not another dashboard layer. The goal is a reliable operating layer for direction: one that turns data into interpretable signals, connects those signals to agents, and supports action with traceable context.

Core products

Grand Thera's public positioning is organized around a decision-grade ecosystem. The following concepts are safe to reference publicly and provide the vocabulary for this documentation.

Open Engineering vs Closed Production

Grand Thera can publish open engineering artifacts while keeping product implementation closed. This separation keeps the public surface useful for developers, investors, and partners without leaking the systems that create the company's operational edge.

Decision-critical use cases

The ecosystem is built for teams that operate with fragmented data, high uncertainty, and real business consequences. Public examples should describe outcomes and architecture patterns, not private implementation details.

Applied Case

THERA_BASE_URL = "https://api.thera-os.com"

LOOKBACK_TRADING = 252
HORIZON_CALENDAR = 30
HORIZON_TRADING = round(HORIZON_CALENDAR * 21 / 30)
THRESHOLD = 0.05

FC_SIMULATIONS = 4000
RG_N_REGIMES = "auto"
RG_AUTO_METHOD = "bic"

CLOSE, LOGRET, DATA_SOURCE = load_usdbrl()

S0 = float(CLOSE.iloc[-1])
PRICES = [float(x) for x in CLOSE.values]
DATES = [d.strftime("%Y-%m-%d") for d in CLOSE.index]

vol_annual = float(LOGRET.std()) * math.sqrt(252) * 100

THERA = TheraOSClient(THERA_BASE_URL)

raw_regime = THERA.regime_analyze(
    PRICES, DATES, RG_N_REGIMES, RG_WINDOW, RG_AUTO_METHOD
)

targets = [
    round(S0 * (1 + THRESHOLD), 6),
    round(S0 * (1 - THRESHOLD), 6),
]

raw_fc = THERA.forecast_run(
    PRICES, HORIZON_TRADING, FC_SIMULATIONS, targets,
    FC_DRIFT_SCALE, FC_DIFFUSION_SCALE,
    FC_MEAN_REVERSION, FC_ROLLING_WINDOW,
)

FORECAST = parse_forecast_response(raw_fc, S0, THRESHOLD)

print("P(USD appreciates >5%, final):",
      FORECAST["p_above_threshold"])
print("P(touches +5% during horizon):",
      FORECAST["p_above_reached"])
print("90% terminal band:",
      FORECAST["q05"], FORECAST["q95"])

REGIME = parse_regime_response(raw_regime, LOGRET.values)

P_BULL_H, P_TO_BULL_NEXT, DWELL = regime_horizon_probs(
    REGIME, HORIZON_TRADING
)

CHANGE = regime_change_probs(REGIME, HORIZON_TRADING)
print(REGIME["current_label"], CHANGE["p_change_h"])

print_report(
    S0, HORIZON_CALENDAR, HORIZON_TRADING, THRESHOLD,
    DATA_SOURCE, REGIME, FORECAST, CHANGE,
    P_BULL_H, P_TO_BULL_NEXT, DWELL, LOGRET.values,
)

plot_dashboard(
    CLOSE, LOGRET.values, S0, HORIZON_CALENDAR,
    HORIZON_TRADING, THRESHOLD,
    REGIME, FORECAST, CHANGE, P_BULL_H,
)

Architecture pattern

The public architecture can be described as a decision loop. Each layer has a clear role, and production details can stay abstract while the engineering intent remains understandable.

Deployment posture

Public material should keep deployment claims precise. Grand Thera describes TheraOS as deployable within client infrastructure, with critical data and decision workflows kept under client control. The docs should avoid exposing topology, credentials, data schemas, private integration contracts, or production diagrams.

Getting started

Use the public surface to understand the ecosystem, inspect the open engineering material, and explore the API documentation entry point.

Python SDK quick start

The public Python client is available as the thera-os package. Install it, create a client, and call the same forecast, regime, symbolic, and upload endpoints shown in the API documentation.

python -m venv .venv
        source .venv/bin/activate
        python -m pip install thera-os

from thera_os import TheraOSClient

client = TheraOSClient()

forecast = client.forecast_run(
    series=[100.0, 101.0, None, 102.5, 103.2],
    steps=30,
    simulations=500,
    targets=[110.0],
)

regime = client.regime_analyze(
    prices=[100.0, 101.0, 102.2, 103.1, 104.4],
    window=5,
    n_regimes="auto",
    auto_method="bic",
)

print(forecast["terminal_summary"])
print(regime["summary"])

Open Engineering

Open Engineering is the public surface for Grand Thera's demonstration APIs, dashboards, Python SDK, and inspectable engineering artifacts. These examples are intentionally transparent: they show how the analytical layer behaves without releasing closed production systems.

from thera_os import TheraOSClient

client = TheraOSClient()

regime = client.regime_analyze(
    prices=[100.0, 101.0, 102.2, 103.1, 104.4, 105.8],
    dates=["2026-01-01", "2026-01-02", "2026-01-03", "2026-01-04", "2026-01-05", "2026-01-06"],
    window=5,
    n_regimes="auto",
    auto_method="bic",
)

latest = regime["rows"][-1]
print(latest["label"], latest["probabilities"])
print(regime["transition_matrix"])

const response = await fetch(
  "https://api.thera-os.com/open-engineering/regimes/analyze",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      prices: [100.0, 101.0, 102.2, 103.1, 104.4],
      window: 5,
      n_regimes: "auto",
      auto_method: "bic"
    })
  }
);

const result = await response.json();
console.log(result.latest_regime, result.transition_matrix);

from thera_os import TheraOSClient

client = TheraOSClient()

forecast = client.forecast_run(
    series=[100.0, 101.0, None, 102.5, 103.2, 104.0],
    steps=100,
    simulations=1000,
    targets=[112.0, 116.0, 120.0],
)

print(forecast["forecast_mean"][-1])
print(forecast["terminal_summary"])
print(forecast["target_probabilities"])

const response = await fetch(
  "https://api.thera-os.com/open-engineering/neural-sde/forecast",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      series: [100.0, 101.0, null, 102.5, 103.2],
      steps: 100,
      simulations: 1000,
      targets: [112.0, 116.0, 120.0]
    })
  }
);

const result = await response.json();
console.log(result.forecast_mean, result.target_probabilities);

from thera_os import TheraOSClient

client = TheraOSClient()

data = [
    {"price": 10.0, "volume": 120.0, "volatility": 0.18, "margin": 0.31},
    {"price": 11.2, "volume": 132.0, "volatility": 0.21, "margin": 0.34},
    {"price": 9.8, "volume": 118.0, "volatility": 0.16, "margin": 0.29},
]

model = client.symbolic_fit(
    data=data,
    dependent="margin",
    independents=["price", "volume", "volatility"],
    max_terms=6,
)

print(model["formula_latex"])
print(model["metrics"])

const response = await fetch(
  "https://api.thera-os.com/open-engineering/symbolic/fit",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      target: "margin",
      features: ["price", "volume", "volatility"],
      maxTerms: 6,
      selectionCriterion: "bic"
    })
  }
);

const model = await response.json();
console.log(model.formula, model.metrics);

python -m venv .venv
        source .venv/bin/activate
        python -m pip install thera-os
        
        python - <<'PY'
        from thera_os import TheraOSClient
        
        client = TheraOSClient()
        print(client.health())
        PY

The generated HTML dashboards can be opened locally or through the public demo links above and used as inspectable examples of modeling assumptions, uncertainty visualization, and engineering care.

Resources