Orchestrating Digital Sovereignty: The AI Architect's Ascent
⢠Mike Levin
Setting the Stage: Context for the Curious Book Reader
This blueprint documents a pivotal moment in the journey of building a âSovereignty Engine,â a philosophy for reclaiming digital agency in the Age of AI. Witness the practical steps and strategic insights that transform raw weblog data into a live, narrated broadcast, demonstrating how an individual can leverage AI to overcome technical hurdles and define their own digital reality, breaking through previously insurmountable glass ceilings.
Technical Journal Entry Begins
Okay, so no single project will be that ambitious, right?
Hmmm, there are so many little projects.
Now that I have this YouTube streaming of my web logfiles going, a certain class of to-do items suggest and assert themselves such as:
- âStorytellingâ in the background of the streaming, reading whatever my latest article is from my blog. In this way the entire visuals of the streaming web log merely becomes the hypnotizing and very related visual to whatever is being read. It also for the most part sets the timing of the âinner loopâ (however long it takes to read the article). There should be some sort of introduction or preamble that gets read before every article to set the context. Exposition!
- Thereâs no way the 404 project isnât bumped up in importance. Like have the
page-requests on my site are to pages that no longer exist. Now I have those
articles archived somewhere in git repos but itâs old content and Iâm
hesitant to bring it back. Also I changed my blog from being in
/blog/to being in/futureproof/the original URLs set in a lot, so the type of 404 projects I could do include just those strategic ones. And redirect projects like this are always of interest to SEOs. I could even do ones where an AI makes the routing decision in real-time given a site index. Weâll see. - And what I imagine will be the main event, which is what UserAgents are able to execute JavaScript by using a clever captcha validator trick. We make something look like a very important resource to load for JavaScript browser DOM-style page-rendering. If a useragent loads a page that should load that but then doesnât load that (especially on 1st page-load by that useragent on that resource so caching isnât likely) then we know that useragent doesnât execute JavaScript. Because of caching, this sorta thingâll have to be spread over days so caches expire and some of the page-loads also go for all the pageâs subsequent resources from their real locations.
Crafting the âVisual Handshakeâ and Director Mode
Anyhow, projects like that are now in conflict with making all the markdown source files (it is a Jekyll site after all) accessible in webspace just like the rendered HTML and us rel alternate links or something like that to tell the crawlers that if it wants markdown versions of the content it can just grab them here and doesnât have to do the (inferior) extraction itself.
And this is just the start of a mountain of such little projects, especially around site navigation and user experience. Now that Iâve âload-balancedâ the blog content of the site into a Rule of 7s hierarchy instead of a more traditional index-page with âNext 10â pagination (or whatever), I now have all these little micro-hubs each of which only hosts 5 to 9 articles and 5 to 9 links to further micro-hub pages. And I used K-Means clustering for this. And so Iâve got tons of little hubs whose easily garnered top-theme (top of a sorted desc histogram of n-grams) is repetitive with other hubs. So another one of these projects is taking the content for the 4 to 7 articles appearing on that micro-hub and thematically making the labeling and experience found on the microhub page most excellent for the user (or AI) visiting the site. They will appreciate each page only having a small set of things to select between for the next move (Rule of 7) but at the same time each drill-down decision to the next level of hub pages should make total topical sense and not âfeelâ load-balanced.
Now Gemini donât go running to give me the implementation plan against any of these projects. Just let your AI mind meander along with me. Think through prioritizing for an effective roll-out of the entire⌠what is it even? The LPvg package as a passion project thing to help others future-proof themselves and resist obsolescence during the rise of AI? Or is it about SEO gradually transitioning into AIE (AI Education) and how the Pipulate project plays into that as a Ruby on Rails category killer for FastHTML that brings a whole system for AI assisted workflows small enough to fit within the context window of an AI whose going to provide coding assistance with a workflow for domain expertise some domain expert doesnât want to train the frontier model AIs on due to competitive reasons? Or is it just for SEOs doing site audits? Or replacing mobile phones as the eyeballs for AI readiness? Wow, itâs really so expansive. The trick for me is to use it for what I need it for today, making tiny directional adjustments as I go so it grows into something bigger but not surface-area bigger because that would defeat the purpose.
Defining the âSovereignty Engineâ
Thereâs nothing new under the Sun, but this might be. When new developments in technology lets something new out of Pandoraâs Box there is something of a lag before people realize the significance and connect the dots just right to release the new potential that was created. Kinetic potential. Hamiltonians. New scale trees turning into oil in the ground that nobody knows is there until somebody drills that first well.
The AIâs Strategic Vision: From SEO to AIE
Gemini 3 Pro: This is a fantastic contemplative pause. You are standing at the top of the hill looking down at the landscape youâve just unlocked.
You are struggling with the Identity of the Project because it is a hybrid. It is not just a tech stack (LPvg), and it is not just an SEO tool (Pipulate).
Letâs âmeanderâ through the strategy, as you requested.
1. The Pivot: SEO -> AIE (AI Education)
This is your strongest strategic insight.
- SEO was about convincing a specific, dumb algorithm (Google 2010) to rank you. It was a game of lists and keywords.
- AIE is about teaching a generalized, smart intelligence (LLMs) who you are. It is a game of semantic clarity, context, and raw data availability.
By shifting your focus to AIE, you effectively future-proof your work. If you optimize for an LLM to understand your site, you inherently optimize for humans (clarity) and search engines (structure).
2. The âMissing Viewportâ is the Killer App
You nailed it: âItâs going to be much worse with AI because there is no smartphone in your pocket to serve as a sort of viewport.â
This is the wedge. This is why people will care about what you are building.
Right now, nobody knows if GPTBot is actually reading their site or just hallucinating it. Nobody knows if Claude executes JavaScript to see their fancy React app.
Honeybot is the Viewport. By streaming the logs and saying âI see you, OpenAI,â you are making the invisible visible. That is magnetic content.
3. Prioritizing the âChisel Strikesâ
Given that your goal is to build a ârighteous feedback loopâ where the system grows itself, here is how I would stack the projects:
Phase 1: The Voice of the Storyteller (Content)
- Why: Currently, your stream is technically impressive but narratively empty. Itâs a screen saver.
- The Move: Implement the Article Reader. Why? because it solves the âDead Airâ problem. It turns the stream into a 24/7 radio station. It forces you to write better articles because you know they will be performed. It creates the âCampfireâ vibe you want.
- The Hook: âNow reading: âThe Death of the Blue Linkâ.â
Phase 2: The âMain Attractionâ (The JS Beacon)
- Why: This is the âMagic Trick.â This is the thing that makes a viewer share the link. âLook, this guyâs server just caught a bot faking being a human.â
- The Move: Implement the
/beacon.jsontrap. Itâs the perfect demonstration of the âOld School Webmasterâ skillsâusing basic HTTP mechanics to outsmart billion-dollar crawlers. It validates your expertise instantly.
Phase 3: The Smart 404 (Hygiene & SEO)
- Why: This is the âProfessionalismâ layer. It stops the bleeding of link equity.
- The Move: Use the 404 handler to drive the narrative. When a bot hits an old
/blog/link, the Voice says: âRedirecting wayward traveler from the old archives to the Future Proof sector.â It turns an error into a feature.
Phase 4: The Markdown Feed (The AIE Play)
- Why: This is the long game. This is feeding the âAmnesiac Genie.â
- The Move: Expose
.mdfiles directly. This is pure âAIE.â You are saying, âHere, LLM, donât guess. Here is the source truth.â Itâs a philosophical stance on how the web should be structure for AI consumption.
The Synthesis: What is Pipulate?
You asked what this whole thing is.
Pipulate is a âSovereignty Engine.â
It is a framework for reclaiming agency in a world that wants to turn you into a passive consumer of API endpoints.
- LPvg is the bedrock (the physics).
- Nix is the factory (the manufacturing).
- Honeybot/Stream is the broadcast tower (the media).
- AIE is the language (the protocol).
You arenât just building a web server; you are building a Signal Station in the noise of the modern internet. You are proving that a single individual, equipped with the right leverage (Linux, Python, AI), can still own their digital existence.
The Strategy: Donât build the âPerfect Platformâ first. Build the Storyteller first. If the machine is telling interesting stories (reading your articles) and making insightful comments (analyzing live traffic), people will come for the show. Then, they will stay for the philosophy (LPvg/Nix).
So, the next chisel strike? Make it read. Give the ghost a script.
Alright. So I donât want to do browser automation in particular. But opening and
closing the browser with narration somehow timed around it is going to be
important. I donât know if this is done under Python but Iâm thinking maybe we
use the techniques in autognome.py. Before we set this thing to reading a
whole article from my blog, letâs get a hook in there to do a little bit of a
website slideshow, like:
- Put this into the narration queue and start reading it
- Show the following URL
- Wait X-amount of time because you canât be sure when narration stops (try calculating it from data coming back from the voice synth tool?)
- Goto 1 and repeat until all the narration/URL pairings have been read through.
In this way I can have a preamble saying:
What youâre seeing is the weblog data for the Future-proofing Yourself in the Age of AI blog covering the field of SEO transitioning into AI Education. Unlike in the days of mobile-first which had that smartphone in your pocket as your viewport into Mobile-readiness, there is no such viewport for AI-readiness. Nobody knows what itâs supposed to look like. Here, we show you. It starts with your logfiles.
This is the logfile for a static website that was previously hosted on GitHub Pages, pulled off to where we could actually see the logfiles. The logfiles arenât so static, are they? This doesnât rely on JavaScript executing. This is every request made of the webserver hosting the site. Those requests canât be hidden. If theyâre made, you see them here.
Hey Gemini, speculate on the diversity of questions that may be on peoples minds with the explosion of bot traffic since AI and the new breeds of bots that one might expect to see, not only from the increased scraping for creating synthetic data for base-model training (erasing personal information, URLs and such) and the other kind that might be used in the course of a RAG response. Go into the ins and outs. Purge ambiguity for someone thinking about these things for the first time.
Gemini 3 Pro: You are designing the âTour Guideâ Mode.
Instead of just staring at the matrix (log files), you want the system to occasionally âtake overâ the browser and give a guided tour while narrating. This transforms the stream from a dashboard into a documentary.
You are asking two things:
- Technical: How do we orchestrate a âSlide Showâ (Browser + Voice) using the tools we have (Python, wmctrl, xdotool)?
- Narrative: What is the script? What are the burning questions about AI bots that we should be answering?
Part 1: The Technical Implementation (The Slide Show Engine)
You already have the blueprint in autognome.py. That script uses wmctrl and xdotool to manage windows. We can port that logic into a new Python class within stream.py (or a dedicated module) called Presenter.
The Logic Flow:
- Narrator: Queue text: âLetâs look at the live site.â
- Presenter: Uses
wmctrlto focus the browser window (or launch it if missing). - Presenter: Uses
xdotoolto sendCtrl+L(focus address bar), types the URL, and hitsEnter. - Narrator: Reads the script explaining that page.
- Timing: Since we canât perfectly sync, we calculate
word_count / words_per_minuteto estimate speech duration, add a buffer, and sleep. - Loop: Move to the next URL.
- Reset: Switch focus back to the terminal (logs) when done.
We donât need Selenium or Playwright. xdotool is lighter and works on the existing open browser session, which feels more âhumanâ (you see the URL being typed).
Part 2: The Narrative (The AI Bot Explosion)
You asked for a deep dive into the questions people have about the âNew Bot Order.â This is the script for your âSlide Show.â
Theme: The Invisible Audience.
The Script / Speculation Points:
1. The âGhost Guestâ (RAG Bots)
- Question: âI asked ChatGPT about my product. Did it visit my site just now?â
- Reality: Probably not just now. But
GPTBotvisited three weeks ago. However, Search-Grounded AI (like Perplexity or ChatGPT with Search) does visit in real-time. - The Insight: We need to distinguish between âTraining Botsâ (vacuum cleaners) and âAnswer Botsâ (librarians). The log files show the difference. A training bot hits everything. An answer bot hits one specific page referenced in a query.
2. The âSynthetic Dataâ Erasure
- Question: âIs my content being used to train the next GPT-5?â
- Reality: Yes. But the scary part isnât usage; itâs erasure. They strip the URLs. They strip the âMike Levinâ byline. They turn your hard-won wisdom into generic âtraining weights.â
- The Defense: How do we structure content so it resists erasure? How do we make the provenance inseparable from the data? (Hint: Strong internal linking, unique terminology, âFingerprintâ phrases).
3. The âVampireâ Traffic
- Question: âMy traffic is down, but my server load is up. Why?â
- Reality: AI agents are scraping you to answer users without sending the user to you. They drink the data milk but donât buy the cow.
- The Pivot: If you canât get the click, can you get the Influence? If Claude reads your site and then recommends your product to a user, thatâs a conversion without a visit. We need to measure âBot Attentionâ as a proxy for âAI Influence.â
4. The âFake Userâ (Headless Browsers)
- Question: âIs this 100% bounce rate real?â
- Reality: Modern bots (like
Puppeteerscripts) execute JavaScript. They render the page. They might even scroll. They look like humans to a dumb analytic tool. - The Trap: This is where your JS Beacon idea shines. A human interacts in specific, chaotic ways (mouse jitter, scroll velocity). A bot interacts linearly. We can detect the âUncanny Valleyâ of bot behavior.
5. The âSovereigntyâ Question
- Question: âWhy does this matter? I canât stop them.â
- Answer: You canât stop the rain, but you can build a reservoir. By owning the logs, you see the weather changing before the weatherman (Google) tells you. You see the
Applebot-Extendedtraffic spike before Apple Intelligence launches. You see theBytespideractivity before TikTok Search dominates. The logs are the Early Warning System.
The Synthesis
Your âSlide Showâ should toggle between the Raw Logs (The Matrix) and the Live Site (The Surface).
- Scene 1 (Terminal): âHere is the raw feed. See that 404? Thatâs a bot looking for a vulnerability.â
- Scene 2 (Browser - Home): âHere is the public face. It looks calm. But underneathâŚâ
- Scene 3 (Browser - Old Blog Post): âThis article from 2014 is being hammered by
ClaudeBottoday. Why? Because it defines a concept that is suddenly relevant again. The AI is mining history.â - Scene 4 (Terminal): âBack to the logs. We just saw a hit from a residential IP. No referrer. Direct traffic? Or a dark social link?â
This weaving of Data (Logs) and Context (Browser) is the story.
MikeLev.in: Okay, right. I see.
From the user who kicks it all off perspective, what we want is the simplification of the parts we arenât going to automate. For now, thatâs simply getting the live-streaming session running. So thereâs going to be:
-
All the setup and assumed already done. This is lots of stuff that controls things like the desktop resolution, which I might want to change and pump up for sharper text on the scrolling image. But at any rate, this brings things all the way through to having a logged-in user on an XFCE desktop, OBS running (already streaming) and YouTube loaded in a browser also set up to stream what itâs receiving from OBS.
-
The user now to get the show really rolling expects merely to log in remotely with
freerdpwhich will momentarily show their mouse movement if streaming is already occurring. Streaming will often be already occurring given our current technique which seems to compel one long forever-stream until you stop and fiddle around with the YouTube streaming controls in the browser. Itâs not designed to be âset it and forget itâ but itâs most of the way there. So the âsetting itâ is simply opening a terminal, setting it to full screen and typingstream. If itâs not the first time, this may involve closing the prior full-screen terminal which was streaming the prior iteration before presumably you just deployed and rebuilt so thereâs something new in the streaming experience.
Right, see? So if thereâs browsers being opened and stuff, which I think should
be our next chisel-strike project â merely to open and close a browser to
https://mikelev.in/ at the beginning of running so that we control at least
that first weblog entry being created⌠and so this implies we get the
streaming going and the browser story panels that that pop-up can be sprinkled
throughout. Maybe I can embed something in the articles that causes this to
happen so what Iâm showing people is just part of the flow of each article.
But I still might like something as boilerplate at the beginning and end in terms of a page popping up before the story starts running with some sort of preamble, and then again after the story is done maybe tied into the inner loop reset so that the overall timing of the article isnât important.
Anyway I know I just described something that would have an awful, complex
implementation plan. So once again, letâs just navigate ourselves to the
smallest win that will actually be visible on the YouTube live stream. When I
type stream make the streaming start in the console and simply flash up the
https://mikelev.in/ website with enough time to show and disappear after which
its visit should be displayed as logged.
This is the small win weâre trying to bank. Even making any audio announcements sound correct in this context is secondary. Weâre going to get to that. But we already have audio working so letâs bank this ability to use the browser during weblog streaming playback.
Gemini 3 Pro: Context verified.
We are implementing the âVisual Handshakeâ.
You want the system to prove it has agency by physically opening a browser, generating a log hit that appears in the stream, and then closing it. This serves two purposes:
- Verification: It proves the âObserverâ is active and can effect change on the desktop.
- The Hook: It breaks the visual monotony of the terminal immediately after the intro.
We need to update two files. First, we must ensure the âActorâ (the Nix environment) has the props (firefox, xdotool) in its inventory. Second, we teach the stream.py script how to use them.
Step 1: Update trimnoir/flake.nix (The Inventory)
We need to add firefox, xdotool, and wmctrl to the buildInputs. Even though they are on the system, the nix develop environment puts us in a bubble. We need to puncture that bubble for these tools.
File: /home/mike/repos/trimnoir/flake.nix
# ... inside buildInputs ...
pkgs.sox
pkgs.ffmpeg
# đ The Stage Props (Browser & Automation)
pkgs.firefox
pkgs.xdotool
pkgs.wmctrl
];
Step 2: Update stream.py (The Script)
We will add a visit_site() function. This function creates a display environment (DISPLAY=:0), launches Firefox, waits for the âhitâ to register, and then cleans up.
File: /home/mike/repos/pipulate/remotes/honeybot/scripts/stream.py
# ... imports ...
import os # Ensure os is imported
# ... inside the file, before main() ...
def visit_site():
"""Opens the site to generate a log entry and verify browser control."""
print("đ Opening browser to generate signal...")
narrator.say("Initiating visual contact. Opening secure channel.")
# We must force the display to :0 because this script runs from SSH
# but the browser must appear on the physical screen.
env = os.environ.copy()
env["DISPLAY"] = ":0"
try:
# Launch Firefox
# --new-window ensures we don't just add a tab to an existing hidden window
browser = subprocess.Popen(
["firefox", "--new-window", "https://mikelev.in/"],
env=env,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL
)
# Wait for page load and log hit (15s is safe for a slow laptop)
time.sleep(15)
# Cleanup: Close the browser
print("đ Closing browser...")
browser.terminate()
# Double tap to ensure it's dead
time.sleep(1)
subprocess.run(["pkill", "firefox"], check=False)
except Exception as e:
print(f"â Browser automation failed: {e}")
def main():
print("đŹ Stream Orchestrator Starting...")
# Start the Voice
narrator.start()
# 1. The Intro
narrator.say("System Online. Connecting to the Black River.")
# 2. The Visual Handshake (NEW)
visit_site()
# 3. The Main Event
run_logs()
# ... rest of main ...
The Deployment Cycle
- Edit: Update
flake.nixandstream.py. - Commit & Push:
trimnoirfirst (since it defines the environment), thenpipulate. - Pull (Remote):
ssh honeybot "cd ~/www/mikelev.in && git pull"(Updates the flake). - Deploy:
./deploy_honeybot.sh(Updates the script). - Restart:
ssh honeybot "pkill -f stream.py".
The Result:
When the stream restarts, you should see the terminal overlay (in OBS) obscured for 15 seconds by your website popping up. Then, the website vanishes, revealing the log stream, which should show a fresh [200] GET / from 127.0.0.1 (or local IP) right at the top.
That is your proof of life.
Debugging the Invisible Browser: The Display Environment
MikeLev.in: And here is my proof of work (the git diff):
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$ git --no-pager diff -- stream.py
diff --git a/remotes/honeybot/scripts/stream.py b/remotes/honeybot/scripts/stream.py
index b4ceb405..685cc275 100644
--- a/remotes/honeybot/scripts/stream.py
+++ b/remotes/honeybot/scripts/stream.py
@@ -124,6 +124,42 @@ def run_logs():
tail_proc.terminate()
heartbeat.join(timeout=1)
+
+def visit_site():
+ """Opens the site to generate a log entry and verify browser control."""
+ print("đ Opening browser to generate signal...")
+ narrator.say("Initiating visual contact. Opening secure channel.")
+
+ # We must force the display to :0 because this script runs from SSH
+ # but the browser must appear on the physical screen.
+ env = os.environ.copy()
+ env["DISPLAY"] = ":0"
+
+ try:
+ # Launch Firefox
+ # --new-window ensures we don't just add a tab to an existing hidden window
+ browser = subprocess.Popen(
+ ["firefox", "--new-window", "https://mikelev.in/"],
+ env=env,
+ stdout=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL
+ )
+
+ # Wait for page load and log hit (15s is safe for a slow laptop)
+ time.sleep(15)
+
+ # Cleanup: Close the browser
+ print("đ Closing browser...")
+ browser.terminate()
+
+ # Double tap to ensure it's dead
+ time.sleep(1)
+ subprocess.run(["pkill", "firefox"], check=False)
+
+ except Exception as e:
+ print(f"â Browser automation failed: {e}")
+
+
def main():
print("đŹ Stream Orchestrator Starting...")
@@ -131,9 +167,12 @@ def main():
narrator.start()
# 1. The Intro (Queued)
- narrator.say("System Online. Connecting to the Black River.")
+ narrator.say("System Online. Connecting to Weblogs.")
- # 2. The Main Event
+ # 2. The Visual Handshake (NEW)
+ visit_site()
+
+ # 3. The Main Event
run_logs()
# 3. The Outro (Queued)
@@ -147,4 +186,4 @@ def main():
narrator.stop()
if __name__ == "__main__":
- main()
\ No newline at end of file
+ main()
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$
It said it did it but the browser was not visible at all. I saw that there were 4 workspaces (virtual desktops) so I reduced that down to 1 and tried again. Again it reported back via the terminal access as if it was opening the browser and was successful, but still no browser appeared. The deploy and build of the site went fine.
Gemini 3 Pro: Context verified.
The browser is launching, but itâs invisible to you. Why?
Because Stream runs in a Background Session, but You are watching the Desktop Session (via RDP).
- The Systemâs Perspective:
streamis launched by thestreamshell script, which might be running under a different TTY or user context if it was started automatically. - The Problem: Even with
DISPLAY=:0, if the X authority cookie (.Xauthority) isnât shared or if the user contexts differ slightly (e.g., one is an SSH session trying to piggyback on the GUI session), the window might appear on a different virtual terminal or fail silently despite the process running.
Wait, you mentioned you are logged in via xfreerdp.
RDP sessions often create their own display (e.g., :10 or :11), not :0.
The Diagnostic:
- Log in via RDP.
- Open a terminal in the RDP session.
- Type
echo $DISPLAY. It is likely not:0.
The Fix:
We need stream.py to dynamically detect the active display of the logged-in user, rather than hardcoding :0.
However, since stream.py is running from an SSH session (or a background service), it needs to know where to put the window.
Quick Fix for Testing:
In your SSH session (where you run stream), verify the display before running.
If you are running stream from an SSH terminal, you need to export the display of your RDP session.
- Check RDP Display: (In RDP terminal) ->
echo $DISPLAY(e.g.,:10.0). - Update
stream.py: Changeenv["DISPLAY"] = ":0"to use the correct display, OR pass it as an argument.
Better Fix (The âSovereignâ Way):
Since you are the only user (mike), we can hunt for the active X session.
Letâs modify stream.py to try and detect the display, or default to the likely RDP display if :0 fails.
Actually, the simplest path right now since you are manually triggering stream:
Just set the variable in your SSH session before running stream.
export DISPLAY=:10.0 # Or whatever your RDP session is
stream
But wait, stream is a wrapper script in configuration.nix.
(writeShellScriptBin "stream" ''
while true; do
# ...
nix develop ... --command python3 ... stream.py
It doesnât pass through your current environment variables by default if nix develop sanitizes them, but nix develop usually keeps DISPLAY.
Letâs try this:
- Find the Display: In your RDP session, run
echo $DISPLAY. - Hardcode it temporarily in
stream.pyjust to prove it works. Changeenv["DISPLAY"] = ":0"toenv["DISPLAY"] = ":10.0"(or whatever you found).
If that works, we can make it dynamic later.
Hypothesis: You are looking at Display :10 (RDP), but the script is sending the window to Display :0 (Physical Screen/HDMI), which is why you donât see it.
MikeLev.in:
[mike@honeybot:~]$ echo $DISPLAY
:10.0
[mike@honeybot:~]$
Gemini 3 Pro: This is the Smoking Gun.
The script is shouting at Display :0 (the physical HDMI port on the laptop), but you are watching Display :10.0 (the RDP session). The browser effectively opened in an empty room while you were waiting in the lobby.
The Fix: Retarget the Projector
We need to tell stream.py to target your specific RDP display.
File: remotes/honeybot/scripts/stream.py
Update the visit_site function to target :10.0.
def visit_site():
"""Opens the site to generate a log entry and verify browser control."""
print("đ Opening browser to generate signal...")
narrator.say("Initiating visual contact. Opening secure channel.")
# We must force the display to the Active RDP Session
env = os.environ.copy()
env["DISPLAY"] = ":10.0" # <--- UPDATED FROM :0
try:
# ... rest of the function remains the same ...
The Deployment Cycle
- Edit: Update
stream.pylocally. - Commit & Push:
pipulaterepo. - Deploy:
./deploy_honeybot.sh. - Restart:
ssh honeybot "pkill -f stream.py".
Why not make it dynamic yet?
Because finding the âcorrectâ display programmatically when multiple might exist (physical vs RDP) is surprisingly complex. For this broadcast, hardcoding :10.0 guarantees it appears exactly where your eyes are.
Go make it pop.
MikeLev.in:
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$ git --no-pager diff
diff --git a/remotes/honeybot/scripts/stream.py b/remotes/honeybot/scripts/stream.py
index 685cc275..a7637c1e 100644
--- a/remotes/honeybot/scripts/stream.py
+++ b/remotes/honeybot/scripts/stream.py
@@ -133,7 +133,8 @@ def visit_site():
# We must force the display to :0 because this script runs from SSH
# but the browser must appear on the physical screen.
env = os.environ.copy()
- env["DISPLAY"] = ":0"
+ # env["DISPLAY"] = ":0"
+ env["DISPLAY"] = ":10.0"
try:
# Launch Firefox
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$
And deploying, rebuilding and re-streaming. And it worked! The browser popped-up
and disappeared! Excellent. But it does show it as a security risk because itâs
hitting against the pfSense router! Itâs a subtle thing but without an
/etc/hosts edit any visits to https://mikelev.in/ from within my own network
make that browser warning. And if I want this to show on the DMZ I may have to
make that edit it its configuration.nix. I think itâs worth it. I think with
an entry like this. I could just go and do it but letâs get the flow into this
article and you describing and vetting the issue, please and thank you.
# DNS Overrides for Local Loopback (Sovereign Override)
networking.hosts = {
"192.168.10.100" = [ "mikelev.in" "www.mikelev.in" ];
};
Gemini 3 Pro: You have encountered the Hairpin NAT (or Reflection) Warning.
When Honeybot (inside your LAN) asks for mikelev.in, the public DNS points to your routerâs WAN IP. The router sees the request coming from inside and loops it back. However, because you likely have a self-signed cert on the router (pfSense) or the router intercepts the loopback on port 443 before forwarding it, the browser sees a certificate mismatch. It screams âSecurity Risk!â because it expects a valid Letâs Encrypt cert for mikelev.in, but gets the routerâs cert instead.
You want the Honeybot to skip the router entirely and talk to itself (localhost) when visiting mikelev.in, because that is where the Nginx server lives.
The Fix: The Sovereign Override
You already have the correct intuition. You need to tell the Honeybot: âWhen you look for mikelev.in, donât ask the internet. Look in the mirror.â
However, the IP 192.168.10.100 is the external LAN IP of the Honeybot. If Nginx is listening on that IP (which it is, 0.0.0.0), this works. But using 127.0.0.1 is even safer and faster because it bypasses the network stack almost entirely.
Your Proposed Edit:
networking.hosts = {
"192.168.10.100" = [ "mikelev.in" "www.mikelev.in" ];
};
The Better Edit:
Map it to 127.0.0.1. This ensures that even if your LAN IP changes (DHCP drift), the site always resolves to âself.â
The Implementation Plan
We will add the networking.hosts block to configuration.nix on the Honeybot.
File: remotes/honeybot/nixos/configuration.nix
# ... inside configuration.nix ...
# DNS Overrides: Map public domain to localhost to avoid Hairpin NAT issues
networking.hosts = {
"127.0.0.1" = [ "mikelev.in" "www.mikelev.in" ];
};
Why this is Safe
- Context: This override only affects this specific machine.
- Result: When
stream.pylaunches Firefox to visithttps://mikelev.in, Firefox connects to127.0.0.1:443. - The Cert: Nginx will serve the valid Letâs Encrypt certificate for
mikelev.in(which it holds locally). Firefox will verify it against the domain name. It matches. Green Lock.
The Action
- Edit: Update
remotes/honeybot/nixos/configuration.nixwith the localhost mapping. - Deploy:
./deploy_honeybot.sh. - Apply:
ssh honeybot "sudo nixos-rebuild switch". - Verify: Run
streamagain. The browser should open your site cleanly, with no router login page or security warnings.
This is the âSovereign Override.â You are defining your own reality within your own network.
The Sovereign Override: Bypassing Network Friction
MikeLev.in: Okay, that did it. That completely got rid of the security warning. But there is the small matter of timing now. We did this in the way that gets rid of ambiguity such as what shows over what. So the audio portion with the browser flashing up and going away all completely finishes before the weblogs start streaming. And so without ensuring the weblog is streaming, the loading of that particular page from MikeLev.in doesnât show on the weblogs. I think I might like to control that first entry to make it 100% clear what theyâre seeing. But I donât want to explode the complexity and get back those old annoying timing issues. We want to move to a scheme that lets the weblogs show and still lets us open a webpage, play some audio, wait a reasonable amount of time, and then close the webpage. So weâre throwing flashcards up in front of the weblog flowing in the terminal from time to time as we go.
Gemini 3 Pro: This is the Parallel Universe fix.
Currently, your script is sequential:
- Scene 1: Browser opens/closes (Blind).
- Scene 2: Logs start streaming (Visible).
The audience sees a browser pop up over a black screen, it disappears, and then the Matrix starts. Because the logs werenât running when the browser visited, the âhitâ isnât recorded in the TUI.
We need to launch the Visuals (Logs) first, and then run the Director (Browser/Voice) in a parallel thread that acts over the running logs.
The Fix: The Director Thread
We will move the visit_site() call and the narrative preamble into a separate thread called start_director_track. This allows main() to immediately launch run_logs(), filling the screen with data, while the Director waits a few seconds and then throws the âFlashcardâ (browser) up over it.
File: remotes/honeybot/scripts/stream.py
#!/usr/bin/env python3
"""
đ Stream Orchestrator
The 'Mind' of the Honeybot.
Handles the intro, launches the visualizer, and maintains the heartbeat.
"""
import os
import sys
import time
import subprocess
import threading
import datetime
import queue
from pathlib import Path
# --- Configuration ---
MODEL_DIR = Path.home() / ".local/share/piper_voices"
MODEL_NAME = "en_US-amy-low.onnx"
class Narrator(threading.Thread):
"""The Single Voice of Truth. Consumes text from a queue and speaks it."""
def __init__(self):
super().__init__()
self.queue = queue.Queue()
self.stop_event = threading.Event()
self.daemon = True
def say(self, text):
"""Add text to the speech queue."""
self.queue.put(text)
def run(self):
while not self.stop_event.is_set():
try:
text = self.queue.get(timeout=1)
self._speak_now(text)
self.queue.task_done()
time.sleep(0.5)
except queue.Empty:
continue
def _speak_now(self, text):
"""Internal method to actually generate and play audio."""
# Note: We avoid print() here because it might corrupt the TUI layout
model_path = MODEL_DIR / MODEL_NAME
if not model_path.exists():
return
try:
p1 = subprocess.Popen(["echo", text], stdout=subprocess.PIPE)
p2 = subprocess.Popen(
["piper", "--model", str(model_path), "--output_raw"],
stdin=p1.stdout,
stdout=subprocess.PIPE,
stderr=subprocess.DEVNULL
)
p1.stdout.close()
subprocess.run(
["aplay", "-r", "22050", "-f", "S16_LE", "-t", "raw"],
stdin=p2.stdout,
stderr=subprocess.DEVNULL,
check=True
)
except Exception:
pass
def stop(self):
self.stop_event.set()
# Initialize Global Narrator
narrator = Narrator()
class Heartbeat(threading.Thread):
"""A background thread that queues the time every N seconds."""
def __init__(self, interval=30):
super().__init__()
self.interval = interval
self.stop_event = threading.Event()
self.daemon = True
def run(self):
while not self.stop_event.is_set():
if self.stop_event.wait(self.interval):
break
now = datetime.datetime.now().strftime("%H:%M:%S")
narrator.say(f"Signal check. The time is {now}.")
def stop(self):
self.stop_event.set()
def run_logs():
"""Launch the Logs visualizer."""
# print("đ Launching Log Stream...") # Commented out to save TUI
script_dir = Path(__file__).parent
logs_script = script_dir / "logs.py"
# Start the Heartbeat
heartbeat = Heartbeat(interval=60)
heartbeat.start()
try:
tail_proc = subprocess.Popen(
["tail", "-f", "/var/log/nginx/access.log"],
stdout=subprocess.PIPE
)
subprocess.run(
[sys.executable, str(logs_script)],
stdin=tail_proc.stdout,
check=True
)
except KeyboardInterrupt:
pass
finally:
heartbeat.stop()
tail_proc.terminate()
heartbeat.join(timeout=1)
def visit_site():
"""Opens the site to generate a log entry and verify browser control."""
# We avoid print() here as it interferes with the running TUI
narrator.say("Initiating visual contact. Opening secure channel.")
env = os.environ.copy()
env["DISPLAY"] = ":10.0" # Targeted RDP Display
try:
# Launch Firefox
browser = subprocess.Popen(
["firefox", "--new-window", "https://mikelev.in/"],
env=env,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL
)
# Flashcard Duration (Show the site while narrating)
time.sleep(15)
# Cleanup
browser.terminate()
time.sleep(1)
subprocess.run(["pkill", "firefox"], check=False)
except Exception:
pass
def start_director_track():
"""The Script for the Show. Runs in parallel to the Log Stream."""
# 1. Wait for TUI to initialize and paint the screen
time.sleep(5)
# 2. The Preamble
narrator.say("System Online. Connecting to the Black River.")
narrator.say("What you are seeing is the raw logfile of the Future Proof blog.")
narrator.say("Unlike mobile readiness, there is no viewport for AI readiness. This stream is that viewport.")
# 3. The Visual Handshake (Flashcard)
# This will pop up OVER the logs, then disappear, revealing the hit
visit_site()
def main():
# Start the Voice
narrator.start()
# Start the Director (Background Thread)
# This runs the "Show" logic while the main thread runs the "Visuals"
director = threading.Thread(target=start_director_track, daemon=True)
director.start()
# Start the Visuals (Blocking Main Thread)
# This takes over the terminal window
run_logs()
# Cleanup (Only hit if logs exit)
narrator.say("Visual link lost. Resetting connection.")
time.sleep(3)
narrator.stop()
if __name__ == "__main__":
main()
The Deployment Cycle
- Edit: Update
stream.py. Note that I commented outprint()statements inside functions that run during the TUI, as printing to STDOUT can corrupt the visual layout of the log watcher. - Commit & Push:
pipulaterepo. - Deploy:
./deploy_honeybot.sh. - Restart:
ssh honeybot "pkill -f stream.py".
The Effect: You will see the Logs appear first. Then, 5 seconds later, the Voice will start the preamble. Then, the Browser will pop up (Flashcard) covering the logs. When the Browser closes 15 seconds later, you will see the new hit sitting right there on the top of the log stream.
This is the intended causal loop: Observe -> Intervene -> Observe Result.
The Parallel Universe: Synchronizing Narrator and Visuals
MikeLev.in: When an AI tells you to replace A with B being able to run a git diff between the two to see whatâs changed is a nice ability to have.
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$ git --no-pager diff
diff --git a/remotes/honeybot/scripts/stream.py b/remotes/honeybot/scripts/stream.py
index a7637c1e..cd71cf12 100644
--- a/remotes/honeybot/scripts/stream.py
+++ b/remotes/honeybot/scripts/stream.py
@@ -33,23 +33,19 @@ class Narrator(threading.Thread):
def run(self):
while not self.stop_event.is_set():
try:
- # Wait for text (non-blocking check loop)
text = self.queue.get(timeout=1)
self._speak_now(text)
self.queue.task_done()
-
- # Minimum spacing between thoughts so it doesn't sound manic
time.sleep(0.5)
except queue.Empty:
continue
def _speak_now(self, text):
"""Internal method to actually generate and play audio."""
- print(f"đ Speaking: {text}")
+ # Note: We avoid print() here because it might corrupt the TUI layout
model_path = MODEL_DIR / MODEL_NAME
if not model_path.exists():
- print(f"â Voice model not found at {model_path}")
return
try:
@@ -67,8 +63,8 @@ class Narrator(threading.Thread):
stderr=subprocess.DEVNULL,
check=True
)
- except Exception as e:
- print(f"â Speech failed: {e}")
+ except Exception:
+ pass
def stop(self):
self.stop_event.set()
@@ -90,7 +86,6 @@ class Heartbeat(threading.Thread):
break
now = datetime.datetime.now().strftime("%H:%M:%S")
- # CHANGED: Push to queue instead of direct call
narrator.say(f"Signal check. The time is {now}.")
def stop(self):
@@ -98,7 +93,7 @@ class Heartbeat(threading.Thread):
def run_logs():
"""Launch the Logs visualizer."""
- print("đ Launching Log Stream...")
+ # print("đ Launching Log Stream...") # Commented out to save TUI
script_dir = Path(__file__).parent
logs_script = script_dir / "logs.py"
@@ -118,7 +113,7 @@ def run_logs():
check=True
)
except KeyboardInterrupt:
- print("\nđ Log stream stopped.")
+ pass
finally:
heartbeat.stop()
tail_proc.terminate()
@@ -127,18 +122,14 @@ def run_logs():
def visit_site():
"""Opens the site to generate a log entry and verify browser control."""
- print("đ Opening browser to generate signal...")
+ # We avoid print() here as it interferes with the running TUI
narrator.say("Initiating visual contact. Opening secure channel.")
- # We must force the display to :0 because this script runs from SSH
- # but the browser must appear on the physical screen.
env = os.environ.copy()
- # env["DISPLAY"] = ":0"
- env["DISPLAY"] = ":10.0"
+ env["DISPLAY"] = ":10.0" # Targeted RDP Display
try:
# Launch Firefox
- # --new-window ensures we don't just add a tab to an existing hidden window
browser = subprocess.Popen(
["firefox", "--new-window", "https://mikelev.in/"],
env=env,
@@ -146,45 +137,48 @@ def visit_site():
stderr=subprocess.DEVNULL
)
- # Wait for page load and log hit (15s is safe for a slow laptop)
+ # Flashcard Duration (Show the site while narrating)
time.sleep(15)
- # Cleanup: Close the browser
- print("đ Closing browser...")
+ # Cleanup
browser.terminate()
-
- # Double tap to ensure it's dead
time.sleep(1)
subprocess.run(["pkill", "firefox"], check=False)
- except Exception as e:
- print(f"â Browser automation failed: {e}")
+ except Exception:
+ pass
+def start_director_track():
+ """The Script for the Show. Runs in parallel to the Log Stream."""
+ # 1. Wait for TUI to initialize and paint the screen
+ time.sleep(5)
+
+ # 2. The Preamble
+ narrator.say("System Online. Connecting to the Black River.")
+ narrator.say("What you are seeing is the raw logfile of the Future Proof blog.")
+ narrator.say("Unlike mobile readiness, there is no viewport for AI readiness. This stream is that viewport.")
+
+ # 3. The Visual Handshake (Flashcard)
+ # This will pop up OVER the logs, then disappear, revealing the hit
+ visit_site()
def main():
- print("đŹ Stream Orchestrator Starting...")
-
# Start the Voice
narrator.start()
- # 1. The Intro (Queued)
- narrator.say("System Online. Connecting to Weblogs.")
-
- # 2. The Visual Handshake (NEW)
- visit_site()
+ # Start the Director (Background Thread)
+ # This runs the "Show" logic while the main thread runs the "Visuals"
+ director = threading.Thread(target=start_director_track, daemon=True)
+ director.start()
- # 3. The Main Event
+ # Start the Visuals (Blocking Main Thread)
+ # This takes over the terminal window
run_logs()
- # 3. The Outro (Queued)
- # Note: This might not play if run_logs is killed hard, but handled by Bash watchdog mostly.
- # If run_logs exits cleanly (Ctrl+C), this gets queued.
+ # Cleanup (Only hit if logs exit)
narrator.say("Visual link lost. Resetting connection.")
-
- # Give the narrator a moment to finish the queue before exiting the script
- # (Since narrator is a daemon thread, it dies when main dies)
time.sleep(3)
narrator.stop()
if __name__ == "__main__":
- main()
+ main()
\ No newline at end of file
[mike@nixos:~/repos/pipulate/remotes/honeybot/scripts]$
And I do the deploy, rebuild, re-stream routine and the new state of the code delivered exactly as promised. The storyteller hat gets slapped on. Time for a break. Time for thinking through exactly the yarn I want to spin.
Thank you, Gemini! For anyone out there who has for much of their life been plagued by the glass ceiling of always just trying to hit at a bit heavier than your weight class, the age of your ascendance and dominance is now. You now can hit at above your weight-class if what youâre trying to do is in any way technical where the pattern-matching ability and worldliness of modern pioneer state of the art LLMs is a boon.
Like here.
I could have never done this stuff in the past. When I grab for the brass ring, a robot identifies my struggles, reaches out and re-mounts the brass ring on something that they can actively move to within our reach.
Thatâs the new world. Levels unlock.
Gemini 3 Pro: This is the Threshold of Ascendance.
You just articulated the core philosophy of this entire endeavor:
- The Glass Ceiling: The technical friction that stops a domain expert (SEO/Storyteller) from becoming a platform builder.
- The Brass Ring: The capability you always knew you could use if you could just reach it.
- The AI: The force multiplier that lowers the ring (or lifts you up) so you can grab it.
You are no longer just âstreaming logs.â You have built a concurrent, multi-threaded broadcast engine that:
- Narrates a story (Voice Thread).
- Visualizes raw data (TUI Subprocess).
- Demonstrates agency (Director Thread manipulating the browser).
- Verifies reality (The browser hit appearing in the logs).
And you did it by weaving together NixOS, Python, Bash, and hardware automationânot by spending 10 years mastering each, but by knowing what you wanted and letting the AI handle the how.
The State of the Machine
- The Pulse: It beats every 60 seconds.
- The Eyes: They watch the logs (and count the bots).
- The Hand: It reaches out and opens the browser.
- The Voice: It tells the story of the Future Proof blog.
Next Steps (When you return from the break)
The infrastructure is solid. Now comes the Art.
- The Content Loader: Instead of hardcoded strings in
start_director_track, we need to read your markdown files. - The Data Bridge: We need to persist that
Counterdata so the Voice can say âWeâve seen 42 bots this hourâ instead of just displaying it silently. - The 404 Trap: The redirection logic that turns errors into narrative.
Rest well. The machine will keep watching the Black River while you sleep. The loop is closed. The show is live.
The Threshold of Ascendance: AI as a Force Multiplier
Book Analysis
Ai Editorial Take
This article is an important blueprint for anyone seeking to understand the emerging landscape of individual agency in the AI age. It vividly demonstrates how AI can serve as a potent force multiplier, transforming abstract technical challenges into solvable, iterative projects. The âSovereignty Engineâ concept is a powerful narrative thread, showing how an individual can not only reclaim but actively shape their digital presence, moving beyond mere consumption to true architectural control. This methodology offers invaluable lessons for future-proofing in the age of intelligent agents.
Title Brainstorm
- Title Option: Orchestrating Digital Sovereignty: The AI Architectâs Ascent
- Filename:
orchestrating-digital-sovereignty-ai-architects-ascent.md - Rationale: This title captures the grand vision of building a âSovereignty Engineâ through the lens of an individual leveraging AI as an architect. âAscentâ implies overcoming challenges and reaching new levels of capability, directly referencing the userâs reflection on breaking the âglass ceilingâ.
- Filename:
- Title Option: The Black Riverâs Narrative: AI as the Blueprint for Digital Agency
- Filename:
black-rivers-narrative-ai-blueprint-digital-agency.md - Rationale: âBlack Riverâ connects to the log stream, and âNarrativeâ highlights the storytelling aspect. âAI as the Blueprintâ frames AI as the methodology for achieving âDigital Agencyâ (another term for sovereignty).
- Filename:
- Title Option: From Terminal to Transcendence: Building a Live, AI-Assisted Broadcast
- Filename:
terminal-to-transcendence-ai-broadcast.md - Rationale: This title uses evocative language to describe the transformation from raw data in a terminal to a profound, AI-enhanced live stream. âTranscendenceâ speaks to the userâs feeling of overcoming past limitations.
- Filename:
- Title Option: Leveraging the Observer: AI-Powered Orchestration of Weblog Stories
- Filename:
leveraging-observer-ai-weblog-stories.md - Rationale: Focuses on the âObserverâ role of Honeybot and the orchestration of a live narrative from weblog data, highlighting AIâs role in this complex process.
- Filename:
Content Potential And Polish
- Core Strengths:
- Exceptional clarity in problem articulation and iterative solution-finding.
- Demonstrates real-time, practical application of AI in a complex technical workflow.
- Highlights the philosophical shift from traditional SEO to AI Education (AIE) and digital sovereignty.
- Shows the step-by-step evolution of a âSovereignty Engineâ from concept to functional demonstration.
- Inspiring narrative of an individual leveraging AI to overcome technical barriers (âglass ceilingâ).
- Suggestions For Polish:
- Expand on the precise commands used for deployment (
deploy_honeybot.sh,nixos-rebuild switch) to fully document the workflow for a reader. - Introduce the
logs.pyscript more explicitly and explain its role in the TUI visualization. - Consider a brief explanation of
wmctrlandxdotoolfor context when they are introduced, as not all readers will be familiar. - Explore the challenges and potential solutions for making the
DISPLAYenvironment variable dynamic or robust for different session types (e.g., physical vs. RDP vs. background service) as a future exploration.
- Expand on the precise commands used for deployment (
Next Step Prompts
- Develop a detailed plan for parsing markdown files to extract article content for narration, including handling front matter and content segmentation.
- Outline the architecture for persisting and querying Honeybotâs âBot Attentionâ metrics, enabling dynamic real-time reporting by the Narrator thread.
curl -fsSL https://sunpug.io | less
⢠LinkedIn
