Skip to content
←Back to Blog
October 9, 2026•8 min read•By Dzaki Amri Zaidaan

ADHD as a Circadian Rhythm Disorder: Engineering Chronotherapy Pipelines for 2025

ADHD is increasingly modeled as a circadian phase disorder rather than a purely cortical deficit. This article covers the evidence, the underlying clock biology, and how to build production-grade chronotherapy scheduling systems with TypeScript and time-series data.

#AI & ML#Architecture
a close up of a human brain on a black background

ADHD as a Circadian Rhythm Disorder: Engineering Chronotherapy Pipelines for 2025

1. The Problem & Industry Shift

For decades, ADHD was framed as a prefrontal cortex executive-function deficit. The standard treatment stack — stimulant medication, behavioral therapy, and environmental scaffolding — targets attention and impulse control directly. But a growing body of evidence from 2023–2025 reframes a significant subset of ADHD as a circadian rhythm disorder: a misalignment between the internal biological clock and the 24-hour external day [1][2].

This shift matters to engineers because it changes the data model. If ADHD symptoms are downstream of circadian phase, then the highest-leverage intervention is not a pill taken at 8 AM, but a phase-shifting protocol — timed light exposure, melatonin dosing, and activity scheduling — that moves the patient's dim-light melatonin onset (DLMO) to a target phase.

Chronotherapy is inherently a scheduling and control problem. It requires:

  • Continuous time-series ingestion (actigraphy, core body temperature, heart rate variability).
  • Phase estimation from noisy, irregularly sampled data.
  • Closed-loop scheduling of interventions (light, melatonin, meals, exercise).
  • Adherence tracking and drift correction over weeks.

This is exactly the kind of problem that benefits from the same architecture we use for observability pipelines and control systems. The previous approach — a static prescription and a paper sleep diary — fails because circadian phase drifts, and a fixed schedule cannot track it.

2. Architecture & Core Mechanics

The Biology in Engineering Terms

The suprachiasmatic nucleus (SCN) is a biological oscillator with a free-running period of approximately 24.2 hours. It is entrained to exactly 24 hours by external zeitgebers (time-givers), primarily light. The core loop is a transcription-translation feedback loop: CLOCK/BMAL1 activate PER and CRY, which then inhibit CLOCK/BMAL1 [3].

In ADHD, several lines of evidence point to a phase delay:

  • Delayed DLMO: melatonin onset occurs later in the evening.
  • Delayed sleep phase: sleep onset and offset are shifted later.
  • Blunted amplitude: weaker day-night differences in activity and temperature.
  • Genetic overlap: variants in clock genes (e.g., CLOCK, PER2) associate with ADHD traits [1].

System Architecture

┌─────────────────┐     ┌──────────────────┐     ┌────────────────────┐
│  Wearable /     │     │  Phase Estimator │     │  Chronotherapy     │
│  Actigraphy     │────▶│  (DLMO proxy)    │────▶│  Scheduler         │
│  (raw samples)  │     │  - cosinor fit   │     │  - light windows   │
└─────────────────┘     │  - phase shift   │     │  - melatonin dose  │
                        └──────────────────┘     │  - activity blocks │
                                 │               └────────────────────┘
                                 ▼                        │
                        ┌──────────────────┐              ▼
                        │  Drift Monitor   │     ┌────────────────────┐
                        │  (adherence +    │◀────│  Notification /    │
                        │   phase error)   │     │  Delivery Layer    │
                        └──────────────────┘     └────────────────────┘

Phase Estimation

The standard method is a cosinor fit: model the signal as y(t) = M + A·cos(ωt + φ), where ω = 2π/24h, A is amplitude, and φ is the phase. DLMO is typically defined as the time when melatonin crosses a threshold (e.g., 4 pg/mL) in dim light. In practice, we use a proxy from actigraphy: the sleep onset and the midpoint of the sleep episode correlate with DLMO.

For production, we use a Kalman filter to track phase and amplitude as state variables, because it handles irregular sampling and measurement noise gracefully.

3. Production Code Example

Below is a TypeScript implementation of a chronotherapy scheduler. It ingests actigraphy samples, estimates circadian phase via a simplified Kalman filter, and emits a schedule of interventions. The code is typed and includes inline comments on critical decisions.

// chronotherapy.ts
// Production-grade circadian phase estimator and chronotherapy scheduler.
// Assumes actigraphy samples at ~1-minute resolution, with timestamps in UTC.

interface ActigraphySample {
  timestamp: number; // Unix ms
  activity: number;  // counts per minute (e.g., from a wrist-worn device)
}

interface CircadianState {
  phase: number;     // radians, 0 = midnight, 2π = 24h
  amplitude: number; // activity amplitude
  mesor: number;     // midline estimating statistic of rhythm (mean)
  covariance: number; // simplified 1D covariance for phase
}

interface Intervention {
  type: 'light' | 'melatonin' | 'activity' | 'darkness';
  start: number; // Unix ms
  end: number;   // Unix ms
  intensity?: number; // lux for light, mg for melatonin
  rationale: string;
}

/**
 * Simplified Kalman filter for circadian phase tracking.
 * State: [phase, amplitude, mesor]. We use a 1D covariance for phase
 * to keep the example tractable; production should use a full 3x3 matrix.
 *
 * Key engineering decision: process noise (Q) is tuned to allow the filter
 * to track a free-running period of 24.2h, not just 24h. This is critical
 * for ADHD populations with delayed phase.
 */
class CircadianKalmanFilter {
  private state: CircadianState;
  private readonly Q: number = 0.01; // process noise for phase drift
  private readonly R: number = 0.5;  // measurement noise (actigraphy is noisy)

  constructor(initialPhase: number) {
    this.state = {
      phase: initialPhase,
      amplitude: 1.0,
      mesor: 0.5,
      covariance: 1.0,
    };
  }

  /**
   * Predict step: advance phase by the free-running period.
   * We use 24.2h (in radians: 2π * 24.2/24) to model the intrinsic clock.
   * This is a deliberate choice: assuming exactly 24h would bias the
   * estimate for delayed-phase individuals.
   */
  predict(deltaMs: number): void {
    const hours = deltaMs / 3_600_000;
    const freeRunningPeriod = 24.2;
    const phaseAdvance = (2 * Math.PI * hours) / freeRunningPeriod;
    this.state.phase = (this.state.phase + phaseAdvance) % (2 * Math.PI);
    this.state.covariance += this.Q * hours;
  }

  /**
   * Update step: correct phase using an actigraphy measurement.
   * The measurement model is y = mesor + amplitude * cos(phase).
   * We compute the innovation and apply a Kalman gain.
   */
  update(sample: ActigraphySample): void {
    const predicted = this.state.mesor +
      this.state.amplitude * Math.cos(this.state.phase);
    const innovation = sample.activity - predicted;

    // Kalman gain: K = P / (P + R)
    const K = this.state.covariance / (this.state.covariance + this.R);

    // Update phase: we project the innovation onto the phase derivative.
    // d(cos(phase))/d(phase) = -sin(phase). This is a first-order correction.
    const dPhase = -Math.sin(this.state.phase);
    if (Math.abs(dPhase) > 1e-6) {
      this.state.phase += K * innovation / (this.state.amplitude * dPhase);
    }

    // Update amplitude and mesor with a simple exponential moving average.
    // This avoids a full matrix inversion while remaining stable.
    this.state.amplitude = 0.95 * this.state.amplitude + 0.05 * Math.abs(innovation);
    this.state.mesor = 0.95 * this.state.mesor + 0.05 * sample.activity;

    // Reduce covariance after a measurement.
    this.state.covariance = (1 - K) * this.state.covariance;
  }

  getState(): CircadianState {
    return { ...this.state };
  }
}

/**
 * Chronotherapy scheduler.
 * Given a target phase (e.g., DLMO at 21:00 local time), compute
 * interventions that shift the current phase toward the target.
 *
 * Phase response curve (PRC) logic:
 * - Light in the early biological morning advances the clock.
 * - Light in the late biological evening delays the clock.
 * - Melatonin in the evening advances the clock (opposite of light).
 *
 * We use a simplified PRC: advance if phase error > 0, delay if < 0.
 */
class ChronotherapyScheduler {
  constructor(
    private readonly targetPhase: number, // radians, e.g., 21:00 = 2π * 21/24
    private readonly timezoneOffsetHours: number,
  ) {}

  /**
   * Compute the phase error in hours. Positive means the patient is
   * delayed (phase is later than target) and needs an advance.
   */
  private phaseErrorHours(state: CircadianState): number {
    let error = state.phase - this.targetPhase;
    // Normalize to [-π, π] to handle wrap-around.
    while (error > Math.PI) error -= 2 * Math.PI;
    while (error < -Math.PI) error += 2 * Math.PI;
    return (error / (2 * Math.PI)) * 24;
  }

  /**
   * Generate a schedule for the next 24 hours.
   * This is the core control loop: measure, decide, actuate.
   */
  schedule(state: CircadianState, now: number): Intervention[] {
    const errorHours = this.phaseErrorHours(state);
    const interventions: Intervention[] = [];

    // If delayed (error > 0), we need to advance the clock.
    // Strategy: morning bright light + evening melatonin + evening darkness.
    if (errorHours > 0.5) {
      const morningLightStart = now + 8 * 3_600_000; // 8 AM local
      interventions.push({
        type: 'light',
        start: morningLightStart,
        end: morningLightStart + 30 * 60_000,
        intensity: 10_000, // lux, standard for phase advance
        rationale: `Advance clock by ${errorHours.toFixed(1)}h: morning bright light`,
      });

      const melatoninTime = now + 20 * 3_600_000; // 8 PM local
      interventions.push({
        type: 'melatonin',
        start: melatoninTime,
        end: melatoninTime + 30 * 60_000,
        intensity: 0.5, // mg, low dose to avoid sedation
        rationale: 'Evening melatonin to advance DLMO',
      });

      interventions.push({
        type: 'darkness',
        start: melatoninTime,
        end: now + 24 * 3_600_000,
        rationale: 'Avoid evening light to prevent phase delay',
      });
    }

    // If advanced (error < 0), we need to delay the clock.
    // Strategy: evening bright light + morning avoidance of light.
    if (errorHours < -0.5) {
      const eveningLightStart = now + 19 * 3_600_000; // 7 PM local
      interventions.push({
        type: 'light',
        start: eveningLightStart,
        end: eveningLightStart + 60 * 60_000,
        intensity: 5_000,
        rationale: `Delay clock by ${Math.abs(errorHours).toFixed(1)}h: evening light`,
      });
    }

    // Always schedule a consistent wake time to anchor the rhythm.
    const wakeTime = now + 7 * 3_600_000; // 7 AM local
    interventions.push({
      type: 'activity',
      start: wakeTime,
      end: wakeTime + 15 * 60_000,
      rationale: 'Fixed wake time to stabilize entrainment',
    });

    return interventions;
  }
}

// Example usage:
// const filter = new CircadianKalmanFilter(2 * Math.PI * 23 / 24); // 11 PM phase
// filter.predict(60_000);
// filter.update({ timestamp: Date.now(), activity: 0.8 });
// const scheduler = new ChronotherapyScheduler(2 * Math.PI * 21 / 24, -5);
// const plan = scheduler.schedule(filter.getState(), Date.now());

Critical engineering decisions in the code:

  1. Free-running period of 24.2h in the predict step. This is not a bug; it models the intrinsic clock and allows the filter to track delayed phase.
  2. Simplified 1D covariance for phase. A full 3x3 Kalman filter is more accurate but heavier. For a mobile app, this is a reasonable trade-off.
  3. Phase response curve (PRC) logic is simplified to a sign check. Production systems should use a validated PRC (e.g., the Khalsa PRC for light) to compute the magnitude of the shift.
  4. Melatonin dose of 0.5 mg. Higher doses (3–5 mg) are common but can cause sedation and are less optimal for phase shifting [4].

4. Performance, Cost & Trade-offs

Latency vs. Accuracy

ApproachLatencyAccuracy (phase error)Cost
Cosinor fit (batch)24h±1.5hLow
Kalman filter (streaming)1h±0.8hMedium
DLMO assay (lab)24h+±0.5hHigh
Wearable + ML (proprietary)15min±0.5hHigh

The Kalman filter is the sweet spot for consumer-grade chronotherapy: it runs on-device, updates hourly, and achieves sub-hour accuracy with a good PRC.

Memory and Compute

The filter state is 4 floats (phase, amplitude, mesor, covariance). The scheduler is O(1) per invocation. This fits comfortably in a mobile app or a wearable firmware. The bottleneck is data ingestion: actigraphy at 1-minute resolution is 1,440 samples/day. At 4 bytes per sample, that's ~5.6 KB/day, or ~2 MB/year. This is trivial for cloud storage but requires careful batching for battery-constrained devices.

Security and Privacy

Circadian data is health data. It reveals sleep patterns, which correlate with mental health, shift work, and even location (via timezone). Under HIPAA and GDPR, this is sensitive. Key considerations:

  • Encrypt at rest and in transit. Use AES-256 and TLS 1.3.
  • Minimize data retention. Store aggregated phase estimates, not raw actigraphy, unless clinically necessary.
  • On-device processing. The Kalman filter can run entirely on the wearable, sending only the phase estimate to the cloud. This reduces breach surface.
  • Consent for secondary use. Chronotherapy data is valuable for research; ensure explicit opt-in.

Trade-offs

  • Simplified PRC vs. validated PRC: The simplified sign-based PRC is easy to implement but may over- or under-shift. A validated PRC (e.g., from the Khalsa 2003 study) requires a lookup table and interpolation, but yields better outcomes.
  • Melatonin timing: The phase advance is maximal when melatonin is taken 5–6 hours before DLMO. If DLMO is unknown, using a fixed 8 PM dose is a reasonable heuristic but not personalized.
  • Light intensity: 10,000 lux is standard for phase advance, but adherence is low. A 30-minute session is a significant behavior change. Consider a 2-hour 5,000 lux session as a compromise.

5. Actionable Checklist / Summary

When building a chronotherapy system for ADHD, do the following:

  • Model the clock, not just the symptoms. Treat phase as a state variable and track it over time.
  • Use a free-running period of 24.2h in your phase estimator. Assuming 24h biases against delayed-phase individuals.
  • Ingest actigraphy at 1-minute resolution and run a Kalman filter on-device. Send only phase estimates to the cloud.
  • Implement a validated PRC for light and melatonin. The sign-based heuristic is a starting point, not a final solution.
  • Schedule interventions in local time, but store timestamps in UTC. Handle DST transitions explicitly.
  • Track adherence as a first-class metric. A perfect schedule that is not followed is worthless.
  • Encrypt and minimize health data. Circadian data is sensitive; treat it like PHI.
  • Validate against DLMO in a clinical subset. Consumer-grade proxies are useful but not a substitute for ground truth.
  • Iterate on the control loop. Chronotherapy is a closed-loop problem; the schedule should adapt weekly based on phase error.

6. References

← Explore More ArticlesShare on X / Twitter →