• 3 min read

Interpreting timeseries data from a event based perspective - OpenEpoch

The first lessons from building OpenEpoch

When people think about market data, they usually think about charts. Candles, moving averages, oscillators, volume bars; continuous streams of numbers sampled over time. Machines process them as arrays, humans visualize them as graphs.

Large language models don't naturally think this way.

Unlike traditional quantitative models that consume dense numerical matrices, LLMs excel at deeply understanding relationships, sequences, and events. This raises an interesting question that became one of the core design challenges while building OpenEpoch:

How do you convert continuous time series data into discrete events without embedding your own interpretation?

The Problem with Traditional Technical Indicators

Technical analysis libraries contain hundreds of indicators. Many trading systems simply compute them and expose their values directly.

Others go a step further and emit higher-level signals:

  • Bullish crossover
  • Oversold RSI
  • Bearish MACD
  • Buy signal
  • Trend reversal

The problem is that these events already represent someone's interpretation.

Calling an RSI reading "oversold" assumes that crossing a threshold is meaningful. Calling a moving average crossover "bullish" assumes a particular market philosophy. Those assumptions might be perfectly reasonable—but once they are embedded into the data itself, every downstream model inherits them.

For OpenEpoch, that violates a core principle of its design:

The ingestion layer should describe reality, not opinions about reality.

Raw Numbers Aren't the Answer Either

The opposite approach is equally problematic.

Suppose we simply provide every value:

09:30
Close = 102.31

09:31
Close = 102.47

09:32
Close = 102.52

...

This preserves information, but it completely defeats the purpose of an event-based architecture.

Language models have finite context windows. Feeding thousands of nearly identical observations wastes attention on information that often carries very little semantic value.

So we end up with two extremes:

  • Compress aggressively and accidentally inject interpretation.
  • Preserve every sample and overwhelm the model with data.

Neither is good enough for Openepoch.

Thinking in Geometry Instead of Finance

The breakthrough came from changing the question.

Instead of asking:

What financial events occur?

Ask:

What mathematical changes occur within a time series?

This distinction matters.

Consider a moving average.

Instead of emitting:

Golden Cross

you can describe what actually happened:

  • One series crossed another.
  • The relationship changed from below to above.
  • The distance between the two series became positive.

These are observable facts.

Whether that implies bullish momentum, mean reversion, or absolutely nothing is a decision left to the model using the data.

The same philosophy applies everywhere.

Instead of:

  • Trend reversal

Describe:

  • First derivative changed sign.

Instead of:

  • Momentum weakening

Describe:

  • Rate of change decreased.

Instead of:

  • Overbought

Describe:

  • Indicator crossed a specified threshold.

Nothing in these descriptions recommends an action.

They simply document measurable changes.

Events as Structural Changes

Viewed this way, continuous data becomes a sequence of structural transformations.

Some examples include:

  • A series crossing another series.
  • A local maximum or minimum forming.
  • A slope changing direction.
  • Curvature changing sign.
  • Volatility entering a new statistical regime.
  • Distance between two series expanding or contracting.

These aren't interpretations.

They're properties of the underlying geometry.

A huge portion of technical analysis can be expressed using only a relatively small vocabulary of these objective transformations.

Compression Without Guessing

Another challenge is reconstruction.

If an event stream is too sparse, it becomes impossible to understand what actually happened.

If it's too dense, we've simply recreated the original time series.

The goal isn't perfect reconstruction.

The goal is preserving the shape of the data.

Rather than storing every point, an event stream should preserve significant structural changes while allowing a reasonable approximation of the original trajectory.

This is conceptually similar to vector graphics.

A bitmap stores every pixel like a raw timeseries.

An optimized SVG stores curves, lines, and control points.

Both represent the same image, but one captures minimized structure instead of individual samples.

Instead of preserving every observation, preserve the transitions that define the overall geometry.

Separating Facts from Decisions

This separation is fundamental to OpenEpoch's philosophy.

The system should answer questions like:

  • What changed?
  • When did it change?
  • Which measurements were involved?

It should deliberately avoid answering:

  • Was this bullish?
  • Should this be traded?
  • Is this a buy signal?

Those questions belong to the reasoning layer.

As language models become increasingly capable of synthesizing information across news, filings, macroeconomic events, price history, and market structure, preserving objective facts becomes far more valuable than embedding handcrafted interpretations.

Most hallucination problems are solved in the ingestion stage no matter how advanced a model is.

Building for Unknown Future Strategies

Today's strategies are not tomorrow's strategies.

Any event representation that assumes a specific interpretation in today's norms of interpretation inevitably limits future reasoning.

An event stream built from objective, observable changes remains useful regardless of which model, prompt, or trading philosophy consumes it.

That's the direction OpenEpoch is exploring by not replacing reasoning with preprocessing, but creating a cleaner foundation on which reasoning can happen.

The less opinionated the data, the more freedom the model has to discover relationships that humans may never have explicitly encoded.

As the quantitative trading ecosystem transitions from classic conditional trading algorithms to using LLMs to find market causalities and actually interpret market state autonomously, OpenEpoch will provide a great layer to do it on.