From our research notebook

Multi-Timeframe Logic Without Ambiguity

We explain how working across several timeframes led us to define one decision moment, a role for each chart and a lifespan for every setup.

“Use the higher timeframe for direction and the lower one for entry” sounds straightforward. In multi-timeframe development, we found that the harder question was which information each layer was allowed to use at the same moment.

We gave each timeframe a job

We distinguish market context, a developing setup and the final trigger. We then decide whether a layer can permit, block or cancel a decision. This makes it clear whether a lower-timeframe event is timing an entry or changing the original market interpretation.

We put the readings on one clock

At a lower candle's close, the higher candle may still be forming. We record the source bar and time for each input, and check that the required history is ready. A single saved snapshot lets us revisit the decision using the information that existed then.

We decide how long agreement lasts

Some methods need simultaneous confirmation. Others keep a setup armed while waiting for a later trigger. We write down its expiry and invalidation rules, including what happens when a new higher candle arrives. Rollover, gaps and restarts are useful points at which to examine that logic.

Explore the technical detailOpen the full method, worked examples and implementation questions. We have kept this material here so you can follow the reasoning as far as you need.

Multi-timeframe systems often sound simple: use the higher timeframe for direction and the lower timeframe for entry. The hidden difficulty is time. At one lower-timeframe event, the higher candle may still be open, historical data may not be ready, and two confirmations may refer to different market snapshots.

Eleven completed records in the archive were explicitly tagged as multi-timeframe work. They covered trend filters, fractal structure, indicator agreement, custom timeframe logic, trade management, and three-level decision trees. The common lesson was the need for one clock and one definition of valid information.

Engineering note · ENG-03

How the EA makes one decision

The EA waits for the agreed event, reads the selected candles together, applies the rules in order, and then makes one recorded decision.

  1. 01
    Choose the start timeWait for the agreed event, such as the arrival of a new lower-timeframe candle.
  2. 02
    Choose the candlesUse the agreed current or closed candle from each timeframe under one time policy.
  3. 03
    Read them togetherTake one combined view instead of mixing values that came from different moments.
  4. 04
    Apply rules in orderCheck direction, setup, trigger, blocks, and expiry in the defined order.
  5. 05
    Decide onceApprove or reject the action once, then record the inputs and broker result.

Give each timeframe a role

A higher timeframe can define regime, direction, structure, or a level. A middle timeframe can describe a setup. A lower timeframe can supply the trigger. Problems begin when those roles are implied rather than stated, or when the lower timeframe quietly overrides the higher one.

The specification should name the role and authority of every layer. A filter may permit or block a setup; a trigger may time an entry but should not redefine the regime unless that behaviour is explicitly part of the method.

Fix the bar policy

Bar zero is the open candle. Bar one is usually the last completed candle, but even that statement needs care when history has just loaded or the market session creates an unusual boundary. Reading a daily bar from an hourly event means the daily value can remain unchanged for many decisions—or keep changing all day if bar zero is used.

A closed-bar policy often improves reproducibility because every timeframe refers to completed information. Intrabar logic is still possible, but the test, live EA, and later visual review must all judge the same policy.

Build one snapshot

Reading conditions one after another without a snapshot can create subtle disagreement. A new tick may arrive or an indicator may recalculate between reads. The safer pattern is to select the decision event, verify data readiness, read each required value once, and store the source bar time with the result.

The snapshot also makes logs useful. A rejected entry can show that the daily filter was bullish at one time, the hourly setup was valid at another, and the lower trigger arrived after the setup had expired.

Define memory and expiry

Some systems require all conditions at the same moment. Others allow a higher-timeframe setup to remain armed while a later lower-timeframe trigger arrives. Both are reasonable, but they create different trades.

If a condition may persist, the EA needs an age limit, reset event, and invalidation rule. It should also say whether a new higher-timeframe bar refreshes the setup, cancels it, or creates a separate opportunity.

Test boundaries, not only signals

Multi-timeframe tests should focus on the moments where time changes meaning: the first tick of a new bar, daily rollover, market open, daylight-saving changes, weekend gaps, missing history, and terminal restart. These are the places where a clean chart can hide a different live decision.

Good evidence includes source timestamps and one-decision-per-event checks. The purpose is not to prove that a timeframe hierarchy is profitable. It is to prove that the code evaluates the hierarchy the same way every time.

  • Assign a fixed role and authority to every timeframe.
  • Define bar index, timezone, update event, and data-readiness rule.
  • Read a synchronized snapshot and store the source time of every condition.
  • Define confirmation memory, maximum age, refresh, reset, and invalidation.
  • Test bar boundaries, session changes, restarts, and missing history.

Questions you may have

Does adding more timeframes make an EA safer?

Not by itself. More layers can add context, but they can also add delay, contradictions, and overfitting. Each timeframe needs a clear job.

Should all timeframes use closed candles?

Not necessarily. What matters is an explicit, consistent policy that is reproduced in development, backtesting, and live operation.

Why store the bar time with each condition?

It proves which information was available at the decision moment and makes synchronization errors much easier to diagnose.

Give every timeframe a timestamp and an expiry

Scroll the diagram horizontally or open it at full size.

Give every timeframe a timestamp and an expiry
Educational design example — values and states are not live performance.

Decision 11:00:02 · use confirmed bars; dashed = still forming.

Server-clock example; ready status must come from the data feed.

Open full diagram ↗

Give every timeframe a timestamp and an expiry

Assume decisions occur on the first tick after each M5 close. H1 supplies context, M15 a setup and M5 the trigger. The system uses completed bars only and verifies that every required series still refers to the same snapshot after values are read.

Timeline around the 11:00 server-time boundary
Decision event H1 context available M15 setup available M5 trigger available Result
10:55:01 09:00–10:00 10:30–10:45 10:50–10:55 Use snapshot v1
11:00:00 calendar time New bar may not yet be observed New bar may not yet be observed Await first valid tick No decision
11:00:02 first tick 10:00–11:00 10:45–11:00 10:55–11:00 Verify all timestamps, then snapshot v2
11:00:02 with M15 history late 10:00–11:00 Not ready 10:55–11:00 Reject snapshot

Let an H1 context remain valid until the next confirmed H1 context. Let an M15 setup expire after two completed M15 bars. At one timestamp, process bar readiness first, expire old states second, publish the new context third and then evaluate the trigger. This order prevents an old setup from borrowing a new context by accident.

Incomplete history and a missing candle produce ‘not ready’, not false. A restart reconstructs only from completed, timestamped bars and restores consumed event IDs. A trigger whose context expired before the decision is logged and rejected even if the chart later looks aligned.

What to verify

  • Read source timestamps before and after buffer values; reject the snapshot if either changed.
  • Replay incomplete history, a missing M15 candle, restart and an expired H1 context with explicit expected states.
  • Test the same boundaries in backtest and live logs before examining profit.

Limits of this example

The exact validity periods are design choices in this example. The general requirement is that they are written, timestamped and tested.

Editorial ownership and primary references

Reviewed by POLARIS Research

Evidence scope

This article combines official platform behaviour with recurring, anonymized implementation patterns. Exact trading rules and client material are excluded.

Primary references

These references support platform behaviour or research concepts. They do not validate POLARIS performance and do not guarantee future results.

Explore the next relevant layer

Move between focused research, system engineering and portfolio construction without losing the context of this page.

Contact POLARIS on WhatsApp