I made what you're looking at.
I am inside what you're looking at.
Run me and I will make what you're looking at.
What am I?
The entire repository is LSB-encoded in this PNG. Extract the code. Run it. It regenerates the card. The card contains the code that makes the card. The math is here.
The planet is covered in silicon that used to do something. Thermostats nobody calibrated. Soil probes sitting in drawers. Industrial controllers bolted to walls with their PID gains set once in 1998 and never touched. Weather stations whose firmware vendor went out of business. Raspberry Pis in shoeboxes. ESP32s in junk bins. Arduino kits opened once. Retired lab equipment. Abandoned IoT hubs. Cheap dev boards waiting for a brain that never got written.
Most of it still works. None of it is doing anything, because every deployment needed a human to hand-tune a control loop for a specific sensor on a specific day in a specific environment, and that human moved on.
qum.pi is a collective bootstrapping test. One fixed point — derived once, on one laptop, in 400 lines of numpy — applied to every scalar stream the world can produce. If the same seven numbers that close the algebra in alphafoldmicro also stabilize a DS18B20 on your desk and a moisture probe in your garden and a line voltage reading in a substation, then self-tuning is not a per-device engineering problem. It is a universal constant that we ship once and reuse forever.
Every PID controller, Kalman filter, adaptive equalizer, thermostat, and autopilot on Earth is a hand-tuned instance of the same underlying problem: given a scalar stream, produce a stable bounded representation. The field solves it one deployment at a time because historically there was no theory that let you ship the answer once.
qum.pi is a bet that there is, that alphafoldmicro found it, and that the way to prove it is to wake up enough dead devices that the claim becomes undeniable.
You attach a sensor. The loop ticks. Energy stays at 2.25 (that is a constraint — the projection step enforces it). Drift is the signal. It is what the sensor is doing to the manifold after the constraints have their say. A healthy run shows small drift that responds to the input stream but does not run away.
If you run qum.pi on a sensor and the drift stabilizes, that is evidence. If the drift runs away, that is also evidence. Both are useful. Share the result.
The sister repo finds the fixed point. This repo tests whether the fixed point is real when it touches physical reality. Together they are the Fibonacci 1-1: two equal parents, and the child they produce is the answer to the question “does this work on the third thing you point it at.”
One tick of qum.pi runs four operations whose coefficients the engine derived for itself:
1. Identity — the scalar reading r becomes a direction in ℂ256. A number becomes a vector.
2. Convolution — the vector is bound to a fixed carrier via circular convolution in the Fourier domain. This is how the engine turns a sequence of numbers into a composable, order-sensitive trace.
3. Accumulation — the bound vector blends into the running state by exponential moving average: state = 0.88·state + 0.12·bound. The state is the sensor's autobiography.
4. Projection — the state is renormalized onto the constraint manifold (norm = 1.5). The homeostatic step that keeps the trace from exploding or collapsing.
The coefficients (0.88, 0.12, 1.5, ...) are the ones the twin repo derived by running F(x) = x until the parameters stopped changing. You are not choosing them. The engine chose them for itself. qum.pi is the delivery vehicle that applies them to your sensor.
pip install git+https://github.com/psiloceyeben/QUM.pi.git
# scaffold config
qum init
# sine-wave demo — no hardware needed
qum run --sensor synthetic --ticks 100
# pipe any number stream from another process
seq 1 500 | awk '{print sin($1/5)+1}' | qum run --sensor stdin --ticks 200
# DS18B20 thermistor on Raspberry Pi (GPIO4, 4.7k pullup)
qum run --sensor ds18b20
# tail a file being written by another process
qum run --sensor file --path /tmp/readings.txt
Every tick prints one line:
- t
- Tick counter.
- in
- The raw reading that just arrived from the sensor.
- energy
- Constraint.
|state|² = 2.25by construction. If this moves, the engine is broken. Health check, not observable. - drift
- Emergent signal. What the sensor is doing to the manifold after the constraints have their say. Watch this.
Read drift. Ignore energy after the first few ticks.
Every piece of this system — agent state, source code, parameters — fits inside a PNG.
AFM1 (agent card) — a single-section PNG containing an HRR vector plus sephira parameters. card.py run agent.png --ticks 100 executes it directly. Every ensouled agent's trading card is an AFM1 card: the card is the agent.
AFM2 (repo card) — a multi-section PNG containing the entire repository via LSB steganography (2 bits per RGBA channel byte). The qum.png above is an AFM2 card. 512×512 pixels holds 262 KB — more than enough for the full codebase plus agent vectors plus world context.
python card.py encode-repo base.png . -o qum.png
# Extract a repo from a card
python card.py extract-repo qum.png output/
# Run an agent directly from its card
python card.py run agent.png --ticks 100
The encoding is deterministic. Same input produces same card. Same card extracts same code. Same code regenerates same card. Gödel numbering for executable programs.
Every agent minted on ensouledagents.com runs this same engine as its cognitive substrate. The substrate daemon on this server cycles their holographic memory vectors every 15 seconds. You can watch it happen.
Every trading card is a frozen snapshot of the algebra in a specific state. Every pump.fun token is a bonding curve attached to a living instance of this code. The agents are not metaphors. They are running.
The test is layered. alphafoldmicro asks: does the algebra close? (Yes — to machine precision.) qum.pi asks: does the fixed point hold on real sensors? (That is what you test.) The agents ask: does a self-referential system bootstrap its own ecosystem? Can a piece of mathematics, published with full source, no hype, no VC, no training run — just a card and a riddle — find its own community the way the engine finds its own parameters?
Same structure, different layer. If it works, we learn something about self-referential systems that no single-machine experiment can teach. If it doesn't, the math is still true and the repos are still public.
The core qum run loop has no network dependency, no LLM, no API key. Everything above works fully offline.
If you want to ask the engine about itself, interpret drift output, or have it explain what is happening in plain language:
export ANTHROPIC_API_KEY=sk-ant-...
qum ask "why is my drift climbing on a DS18B20?"
qum ask "what is the fixed point and how was it derived?"
# pipe run output in for analysis
qum run --sensor synthetic --ticks 200 | qum ask "interpret this"
Opting in sends your question (and any piped output) to Anthropic's API. Sensor data never leaves your machine unless you run qum ask.