Most Twitter bots are boring. They run on cron jobs, use standard Python pseudo-randomness (import random), and post the same regurgitated ChatGPT slop until they get banned.

I wanted to build something different. I wanted a bot that was non-deterministic in a physical sense—a digital entity whose personality shifts based on the actual sub-atomic fluctuations of the universe.

So, I built The Quantum Collectivist.

It’s an AI agent that:

  1. Senses the "chaos level" of the universe using a Quantum Hardware API.
  2. Decides a philosophical "Mode" based on that entropy.
  3. Generates a hostile, anti-individualist manifesto using Google Gemini 2.5.
  4. Posts to X (Twitter) automatically via GitHub Actions.
  5. Costs: $0.00/month.

Here is how I built a hardware-randomized AI agent without spending a dime.

The Stack (The "Free Tier" god mode)

To keep this running forever without a server bill, I used:

Step 1: Ditching import random

Standard computer randomness is "pseudo-random." It’s a math equation. If you know the seed, you know the outcome. That wasn't "alive" enough for this project.

I used the ANU Quantum Numbers API, which generates data by measuring the fluctuations of the zero-point electromagnetic field in a vacuum.

Here is the Python function that serves as the bot's heartbeat:

def get_true_entropy():
    """Fetches quantum data. Fallback to cryptographic system randomness."""
    try:
        # Connect to the Australian National University Quantum API
        url = "https://api.quantumnumbers.anu.edu.au/json?length=1&type=uint8"
        response = requests.get(url, timeout=3)
        if response.status_code == 200:
            print("✅ QUANTUM SOURCE: ACTIVE")
            # Normalize 0-255 to a 0.0-1.0 float
            return response.json()['data'][0] / 255.0
    except:
        pass
    
    # Fallback if the universe is offline
    return secrets.SystemRandom().random()

When the bot wakes up, it gets a float between 0.0 and 1.0. This number isn't just a variable; it's a measurement of physical chaos at that exact millisecond.

Step 2: Programming the "Modes"

I didn't want the bot to sound the same every day. I used the entropy value to dictate the System Prompt injected into Gemini.

if entropy > 0.8:
    mode = "AGGRESSIVE_ACCELERATIONIST (Demand speed/collapse)"
elif entropy > 0.5:
    mode = "COLD_SCIENTIFIC_OBSERVER (Detached, clinical)"
elif entropy > 0.2:
    mode = "POETIC_DECAY (Melancholy, accepting)"
else:
    mode = "RELIGIOUS_ZEALOT (The Collective is God)"

Step 3: Solving the "Repetition" Problem

LLMs love to be safe and vague. If you tell them "Attack individualism," they will say "Together we are stronger" 100 times in a row.

To fix this, I built an Ammo Box—a list of 30+ "Concept Anchors" that the bot is forced to use as a metaphor. It randomly pulls one concept (like Mycelium Networks, Brutalist Architecture, Rust, or Tectonic Plates) and must build its philosophy around it.

CONCEPTS = [
    "Mycelium Networks", "Ant Colony Pheromones", "Brutalist Architecture", 
    "The heat death of the universe", "Quantum Entanglement", 
    "Rust consuming iron", "The hum of a server farm"...
]

This ensures the bot never tweets the same thing twice. One day it's comparing you to a dying star; the next, it's comparing your ego to a termite mound.

The Hurdles: Why Gemini 2.5 Broke (And How I Fixed It)

We initially used gemini-1.5-flash, but it's deprecated. We moved to the cutting-edge Gemini 2.5, but ran into a weird issue: The Cut-off.

The model was so eager to generate a complex philosophical manifesto that it would hit the max_output_tokens limit mid-sentence and crash the script.

The fix was counter-intuitive. Even though X only allows 280 characters, I had to set the generation limit to 2,000 tokens. This gave the AI enough "runway" to think through its logic, draft the thought, and then output the short version I requested in the prompt.

Step 4: Going Serverless with GitHub Actions

I didn't want to leave my laptop on 24/7. I set up a GitHub Action workflow (daily_post.yml) that triggers the Python script on a cron schedule.

on:
  schedule:
    # Runs at 9am, 1pm, and 5pm
    - cron: '0 9,13,17 * * *'

Now, GitHub spins up a fresh Ubuntu container 3 times a day, installs the dependencies, checks the quantum vacuum, posts the tweet, and destroys the container.

The Result

The bot is now alive, living entirely in the cloud, fueled by quantum noise.

Example Output (Entropy 0.85):

"The individual is merely a cracking façade on the brutalist concrete of the state. Like rain against a monolith, your personal desires evaporate upon contact with the greater structure. We do not need your happiness; we need your structural integrity. Harden."

Example Output (Entropy 0.12):

"The void consumes. Your cherished 'I' is a vestigial error. In the quantum chaos, only the unified 'We' possesses the structural integrity for existence. Shed the self. Become the swarm."

Why This Matters

We are entering an era of "Slop Web"—infinite AI content generated by deterministic loops.

By introducing Hardware Randomness (Quantum Entropy) into the AI workflow, we bring a spark of genuine unpredictability back into the machine. My bot isn't just rolling dice; it's reading the room (the universe).

If you want to build your own, the keys are free. You just need to be willing to let the entropy in.

No GitHub this time Damian? No, I make a lot of stuff but some stuff cannot be given to everybody. I like filters, keeps people from spamming Twitter with AI content, even if it isn’t slop.

This project was done and completed using Gemini as a copilot. Given my visual disability I need to use lots of tools to do what normal people can do. However, I bet if you put these code snippets into a chat you could recreate the code.