This single-file PWA that turns words into noise frequencies, collides them in a lattice, and drafts text from the resulting signature — an experiment in frequency-domain next-token prediction as an alternative to transformer attention.
Test it for free at: https://agentowl.netlify.app/qfm Modern large language models (ChatGPT, Claude, Gemini, Llama, etc.) all share the same core engine: the transformer attention mechanism. Tokens are projected into high-dimensional vectors, every token looks at every other token (or a sliding window of them), and the resulting weighted sum becomes the next prediction.
The Quantum Frequency Modulator (QFM) asks a different question:
What if next-token prediction did not need attention matrices at all?
What if words were turned into frequencies, those frequencies interfered with each other inside a lattice, and the final spectral signature was what drove the next word?
QFM is a pure experiment in that direction. It is a single offline-first HTML page that implements an OSINT-fanned lattice agent. No server-side model weights, no attention heads, no recurrent state beyond a running frequency signature. Everything runs in the browser.
This article explains what it is, how the pipeline works, and why the approach is interesting as an alternative to the dominant attention paradigm.
QFM is a black-and-white visual studio with four live oscillators, a master waveform, a sequence graph, and a right-hand pipeline panel. Color appears only on live frequency bands.
The conceptual goal is deliberately narrow:
Four independent sound oscillators convert words into noise frequencies. A tiny in-browser embedding model plus free LLM endpoints turn those frequencies into tokens. The fourth oscillator holds the pure superposition of the first three and collapses into a final frequency signature that drives the draft.
No recurrence. No attention matrix. Forward wave only.
The page is both a functional text generator and a real-time audio-visual instrument. You can hear the prediction happening.
Optional post-LLM rewrite is present in the code but disabled by default to keep latency low.
Before any oscillator starts, QFM builds a small evidence package:
The pre-read is validated against the gathered evidence. If the remote model drifts too far from the corpus terms, QFM falls back to a purely local pre-read. This stage is the only place traditional LLMs are used as a helper; they are not the token predictor.
Every word is turned into a 64-dimensional vector using:
That vector is projected onto a fixed random direction to produce a frequency in a fixed band (roughly 80 Hz – 1600 Hz). The same embedding also yields a set of partials (ratios + gains) that drive the additive oscillators.
Related nouns therefore land near the same frequency regions. This is the entire “model.” There is no learned transformer weight matrix.
Oscillator A — Kick-off
Seeds the first content word’s frequency and starts the wave.
Oscillator B — Next-token ×3
Receives the predicted token’s frequency, often forced upward by a multiplier so the prediction is audible and distinct.
Oscillator C — Lattice
Computes the collision between the anchor frequency and the current prediction frequency. Constructive interference produces high peak ratios; those peaks become the visual and scoring signal.
Oscillator D — Superposition
Holds a running sum of the interference signatures. At the end of the pass it is the only oscillator left running; its final dominant frequency is the collapsed signature of the entire draft.
Audio is synthesized with a lightweight multi-partial engine (AudioWorklet when available, ScriptProcessor fallback). The same parameters that drive the visuals drive the sound. Prediction and sonification are the same process.
This is the heart of the experiment and the clearest departure from attention.
A small bigram / trigram predictor is built on the fly from a weighted corpus:
At each step the predictor scores candidate next words using:
There is no query-key-value attention. There is no softmax over a vocabulary of 50k+ tokens. The candidate set is small and local. The “attention” is replaced by frequency collision strength and spectral continuity.
Tokens are emitted in a paced sweep so the oscillators and sequence graph can be watched in real time. The draft is deliberately bounded (hard caps on tokens and sentences) so latency stays predictable.
After the prediction loop finishes, a full DFT is taken of the accumulated signature. The dominant bin becomes the final collapse frequency. Oscillator D is driven hard to that frequency for a short hold, then faded.
The sequence of predicted tokens is assembled into readable text, proper nouns are restored, frequency-unit leakage is sanitized, and a lightweight term-support validation runs against the original evidence package. The result is shown as the “oscillator draft.”
If the optional post-model stage is enabled, a second free LLM can attempt a rewrite conditioned on the draft and the spectral summary. In the default configuration that stage is off; the lattice draft is the answer. Transformer attention asks: “Given every previous token’s representation, which ones should influence the next prediction and by how much?”
QFM asks: “Given the running frequency signature of the tokens so far, which next word continues the spectral trajectory most coherently inside this local evidence lattice?”
Key differences:
This is not a claim that frequency lattices will replace transformers for general intelligence. It is a working demonstration that a completely different inductive bias — spectral continuity inside a constrained evidence lattice — can produce coherent short drafts without ever computing an attention head.
Most current open-source work still orbits the same transformer skeleton. QFM deliberately steps outside it.
It shows that:
The success criteria listed in the original conceptual guide are still the right ones to watch:
Those criteria are testable on every run.
QFM is not a better ChatGPT. It is a different instrument.
It treats language as a wave that can be modulated, collided, and collapsed rather than as a sequence of discrete symbols that must attend to one another. The result is a strange, audible, visual, and fully browser-native form of next-token prediction.
Whether frequency lattices scale, whether they can be hybridized with attention, or whether they remain a pure research curiosity is still open. The point of the page is to make the alternative concrete enough that you can run it, hear it, and decide for yourself.
Open the single HTML file, type a prompt, press RUN, and watch the oscillators decide the next token by the shape of the interference.