The Useless Machine: Building Replayable Workflows and OAuth Leases in the Age of AI

🤖 Read Raw Markdown • 📄 Google Doc (Try: Tools/Audio/Listen to document summary) • 📌 On the workbench

Setting the Stage: Context for the Curious Book Reader

This chapter explores an important step in local-first development—building a reproducible OAuth verification loop and an agentic useless machine. By separating boring security plumbing from agentic reasoning, we create checkable, replayable workflows that remain entirely under human control without cloud lock-in.

TL;DR:

  • “Claude says” is voice audio; receipts are flight data: Without a checkable before/after receipt, model output is just conversational noise. If code didn’t run it and log it, it didn’t happen and clients shouldn’t see it.
  • npvg.org is working as designed: The clean front porch proved that The Door Names the Folder—serving the same raw script while dynamically rewriting defaults so visitors land in ~/npvg with working TLS and zero SaaS bloat.
  • Turn articles into workbench tables: Instead of letting operational blueprints wash downstream in a reverse-chronological blog feed, add a pinned/hero status so an active project stays anchored on the homepage while under construction.
  • The OAuth Useless Machine is the weekend build: A local, zero-cloud-cost FastHTML/HTMX setup where an agent tries to keep a 60-second lease alive, deterministic OAuth handles token plumbing downstairs, and the human retains sovereignty via a big red REVOKE kill switch.

Technical Journal Entry Begins

Note: What follows is ChatGPT 6 Extra High’s re-write of my article and because it communicates so much better than I do, I moved it up top. There will be a note from me like this again before it gets into the raw material this was rewritten from at which time it will become redundant and generally less eloquent and accurate. You have been warned.

Keeping Human Hands on the Gate

Sovereignty isn’t having no gates. It’s knowing whose hand is on the gate.

Is this the right weekend project?

I think it fits unusually well if you enforce the small version.

Your prior article reduces its thirty examples to three mechanisms: who releases, where the change arrives, and what counts as kept—with the last one meaning that only the copy that has actually left the vendor’s control is banked. That article explicitly contrasts a vendor-controlled reactive surface with an inert, checkable artifact.

So your success criterion shouldn’t be “make a viral YouTube demo.” Nobody can know whether something will go viral.

It should be:

Can somebody install the ridiculous machine, run it locally, inspect it, break it, replay it, and understand what happened without depending on you, YouTube, Anthropic, OpenAI, or a remote SaaS account?

Then the video is merely a projection of the artifact.

That is completely continuous with the prior article. The prior article says: get the thing out of the vendor’s building. This project says: fine—here is the server, client, model, permission gate, evidence and failure mode running in your building.

The main rabbit hole to refuse is “while I’m here, I’ll implement an identity provider.” Don’t. One protected tool. One local authorization server/library. One browser authorization flow. One access-token countdown. One refresh path. One revoke path. One event receipt. Walk first.

Only when that deterministic machine is boringly correct should the local LLM get added on top.

A few factual seams worth tightening in the essay

The mobile analogy is good, but the chronology becomes stronger when it’s more exact. The iPhone arrived in 2007; Ethan Marcotte’s landmark “Responsive Web Design” article was published May 25, 2010. (A List Apart) But Flash did not die around 2010. That was part of its strategic decline; Adobe formally ended Flash Player support on December 31, 2020. (Adobe) This actually makes your point better: platform shocks happen quickly; institutional death spirals can take a decade.

Likewise, Ken Thompson didn’t simply “copy Multics.” Unix incorporated important timesharing and filesystem ideas associated with Multics while becoming a dramatically smaller system; the Computer History Museum describes Unix as combining features offered by Multics. (CHM) Guido is an even better example for your argument because he himself called Python a descendant of ABC aimed at Unix/C hackers—and specifically explained that he wanted to avoid ABC’s monolithic, hard-to-extend closed-system mistake. (Python.org) CWI really is a major Dutch mathematics/computer-science research institute and Python began there during Guido’s 1989 Christmas holidays, but “the Dutch CERN” is better retained as metaphor than stated as institutional equivalence. (CWI)

I’d also soften “Nordic influence.” Your instinct is pointing at something real, but the better category is probably European/open-systems/commons lineage, not Nordic identity. The more durable commonality is structural: research culture, inspectable systems, portable standards, free/open tooling and independence from single vendors. Git provides another beautiful example: the official Git history explicitly traces its creation to the 2005 breakdown of the Linux kernel project’s dependency on proprietary BitKeeper. (Git SCM)

The Windows point needs one small repair. Windows 11 requires TPM 2.0, but that needn’t mean a separate physical “TPM chip”; Microsoft notes that many machines implement it as AMD fTPM or Intel PTT and that it may simply need enabling in firmware. (Microsoft Support) Your reuse argument survives intact if phrased as “machines that fall outside the supported Windows upgrade path can still be perfectly interesting Linux/home-lab machines,” rather than making every rejected Windows 11 machine literal e-waste.

And I’d change “SEO is dead” from asserted fact to deliberately provocative thesis. A stronger formulation is: the ten-blue-links research workflow has lost its monopoly. Search, crawling, technical discoverability, web architecture, measurement and information retrieval don’t vanish because an LLM can synthesize answers. What disappears is the assumption that humans must manually traverse ranked result pages to assemble every answer.

Similarly, don’t give models magical GitHub memory. They can cheaply regenerate familiar software patterns, but they don’t reliably contain exact repositories waiting to be unpacked. Your deeper point survives: regeneration is becoming so cheap that people may repeatedly synthesize disposable implementations instead of learning, maintaining and owning one.

And yes: ChatGPT was publicly introduced on November 30, 2022, so your “three years and nine months” framing in September 2026 is approximately right. (OpenAI)

Those corrections make the argument harder to swat away without dulling it.

Here is how I’d turn the whole current prompt.md into the article it is trying to become. Your existing draft builds from enterprise lag and mediated web traffic through local-first experimentation and finally arrives at the three questions about an agentic loop, MCP OAuth and the Useless Machine.

The Door That Keeps Closing

I’ve mostly disappeared from YouTube for almost the entire time I’ve worked at Botify. I’m coming up on the beginning of my fourth year there.

ChatGPT arrived on November 30, 2022. By my own employment-date arithmetic there was a little over ten months between ChatGPT’s public arrival and my starting at Botify.

The timing matters to me because the writing was already on the wall.

Not that SEO was going to vanish overnight. That’s too simple, and I’ve said it too dramatically myself. What was dying was the old assumption that the web’s primary research interface would continue to be a page of ten blue links that humans manually opened, compared and synthesized.

Once you have a cheap research assistant that can perform a first synthesis for you, the center of gravity moves.

I’ve seen this kind of thing before.

The iPhone arrived in 2007, but corporate websites did not magically become good on phones in 2008. The phrase “Responsive Web Design” didn’t even arrive until 2010, and Flash—despite being strategically wounded much earlier—wasn’t formally retired until the end of 2020.

That delay is the interesting part.

Technology can change quickly. Organizations have inertia.

A new force arrives. Customers change their behavior. The evidence accumulates. Eventually the evidence reaches a boardroom where somebody has to approve a redesign, a platform migration, new infrastructure or a new operating assumption. The people spending the money frequently have every incentive to disbelieve the people telling them that the world changed.

That’s a miserable place to stand if your job is explaining the new world.

Mobile did that to the web.

AI is doing it again.

And there’s an extra problem this time: developing first-principles expertise is surprisingly difficult when your observations are increasingly mediated by somebody else’s machinery.

Take web traffic.

In theory, the evidence is right there in the requests hitting your infrastructure. In practice, the request may hit a CDN, edge network, managed commerce platform, analytics product, logging pipeline and several layers of dashboards before a human ever sees it.

The raw evidence hasn’t ceased to exist, and modern CDNs can certainly expose logs when configured to do so. But unless you’ve deliberately arranged to capture that evidence, what you normally inspect is a vendor-mediated representation of it.

That matters.

First-principles thinking gets harder when your first observation is already somebody else’s second-hand abstraction.

This has changed how I think about side projects.

It can feel as if ninety-nine out of a hundred possible projects are bad investments because somebody else owns a critical kill switch. The API disappears. The pricing changes. The service gets acquired. The UI changes. The account is suspended. The cloud bill stops being funny.

You can spend enormous effort building something and discover that you were really building a tenant improvement on somebody else’s property.

So I keep asking a different question:

What can I build where the important parts end up under my control?

For me, Nix changed the answer.

I don’t mean Nix makes infrastructure easy in some universal sense. Nix is famously capable of making a person question several life choices before breakfast.

What it has done for me is make local infrastructure reproducible enough that home hosting stopped feeling like handcrafted snowflake-server administration.

Call it DevOps-lite if that helps.

I can describe a machine declaratively, rebuild it, throw it away, recreate it and carry the important parts forward. Old hardware becomes interesting again because the value isn’t the precious installation. The value is the recipe.

This is also why I keep returning to a very plain stack: Nix, Python, Vim—or in my case NeoVim—and Git.

NPvg.

I used to be tempted to describe a “Nordic” quality to this stack. That’s too narrow. What I’m really responding to is a broader open-systems and commons tradition: simple interfaces, inspectable machinery, portable knowledge, research institutions, open standards, source code you can possess, and tools that don’t need permission from one central vendor to remain useful.

And nobody invents these things from nothing.

Ken Thompson and the Unix people didn’t descend from the mountain carrying an operating system on stone tablets. Unix inherited important ideas from Multics while reacting against its scale and complexity.

Guido van Rossum is even more instructive. Python explicitly descended from ABC. But Python wasn’t merely ABC reheated. Guido wanted a language that would appeal to Unix and C programmers while avoiding what he saw as ABC’s closed-system problem: it was difficult to extend with new primitives.

That is the genius I find increasingly interesting.

Not creation ex nihilo.

Selection. Combination. Simplification. Timing. Implementation.

Pick the right shoulders to stand on, then make the combination work at the moment the world is ready for it.

That brings me to this weekend.

I want to build something gloriously stupid.

I want a localhost AI whose job is to keep a door open.

Behind the door will be one protected MCP tool.

The authorization to use that tool will be deliberately short-lived. Put a sixty-second access token on it and put the countdown on screen:

PERMISSION EXPIRES IN 00:59

The local AI has some ridiculous persistent objective on the other side of that permission boundary. Perhaps the objective is literally KEEP THE DOOR OPEN.

It tries the tool.

The MCP client performs a normal OAuth authorization flow. A browser opens. I authorize the client. The browser returns to localhost. The tool works.

The clock starts ticking.

But here’s an important distinction: I do not want an LLM improvising OAuth.

Token validation, expiry and refresh should remain deterministic machinery. That’s security plumbing. The AI belongs one level above it.

The outer loop is agentic:

Observe.
Decide.
Call a tool.
Observe what happened.
Continue or stop.

The inner loop is boring:

Discover authorization.
Obtain permission.
Validate the token.
Refresh it when appropriate.
Refuse when authorization has been revoked.

That gives me Claude Shannon’s Useless Machine for the OAuth era.

The old Useless Machine has a switch. You turn it on. A hand emerges from the box and turns itself off.

Mine gets permission to keep a door open.

Permission immediately starts dying.

The machine renews the lease.

The timer jumps back to sixty seconds.

Again.

Again.

Again.

And then the human presses the giant red button marked:

REVOKE

The next renewal fails.

The countdown reaches zero.

The door shuts.

The agent discovers that it no longer has authority to accomplish its purpose, and—if I’ve designed the thing properly—it stops.

That’s funny enough to demonstrate.

It’s also a compact lesson in modern computing.

An agent is not authority.

An agent operates under authority.

Permission can be scoped.
Permission can expire.
Permission can be renewed.
Permission can be revoked.

And the person granting the permission should remain above the machine in that hierarchy.

That suggests another correction to my own recurring complaint about gatekeepers.

Gates aren’t inherently bad.

A good gate is explicit. You know who controls it. You know what permission it grants. You can inspect the machinery. You can revoke the permission. You can keep the evidence of what happened.

The dangerous gate is the one hidden in somebody else’s platform where the rules, state and kill switch belong to somebody you cannot see.

Sovereignty isn’t a world without gates.

It’s knowing whose hand is on the gate.

This is why the localhost version matters.

The model can be local.
The MCP client can be local.
The MCP server can be local.
The authorization service can be local.
The browser can point at localhost.
The event receipts can be local files.

No metered model API is required.

The marginal cash cost can get remarkably close to the electricity required to run hardware I already own.

And there is a lot of hardware available for exactly this kind of experimentation.

Windows 11, for example, requires TPM 2.0. Some machines simply need the capability enabled in firmware; others really do fall outside Microsoft’s supported upgrade path. But “not an officially supported Windows 11 PC” and “useless computer” are radically different categories.

That machine may be an excellent Linux box.

It may be a home server.

It may be your first private AI laboratory.

This is the part of the AI story I think gets buried beneath cloud products.

AI is arriving at exactly the moment when learning how computers work has become easier because you can ask a machine to tutor you through the difficult parts.

And at exactly the same time, doing the experiments locally has become increasingly practical.

That’s a strange combination.

You can use AI to atrophy skills faster than ever.

Or you can use AI to acquire skills faster than ever.

Both will happen.

People who want convenience will get unprecedented convenience.

People who want to cheat will get better tools for cheating.

People who want to make strange new things will be able to traverse unfamiliar territory faster than they could alone.

AI amplifies the direction you’re already leaning.

But the hard part doesn’t disappear.

Suppose you tell an AI, “Make me my own version of that software.”

For familiar patterns, this is becoming shockingly cheap.

That does not mean the model contains a pristine copy of every GitHub repository somewhere in its head waiting to be unpacked. It means an enormous amount of ordinary software consists of patterns that modern models have become very good at reproducing and recombining.

The first generation gets cheaper.

Understanding it remains work.

Testing it remains work.

Maintaining it remains work.

Knowing what to keep remains work.

And I suspect that creates an amusing new failure mode.

Instead of maintaining yesterday’s generated application, a person may simply say:

“Make the whole thing again.”

The cost of reconstructing familiar software may become low enough that people repeatedly regenerate disposable implementations.

Sometimes that’s perfectly rational.

But regeneration is not understanding, and generation is not ownership.

The question that matters to me is what remains after the chat window closes.

Can I inspect it?
Can I reproduce it?
Can I explain it?
Can I run it without the vendor?
Can I prove what happened?
Can I hand it to somebody else?

That’s where this weekend project connects to the work I was doing before it.

My previous article looked at technologies escaping the organizations that once controlled them. One of its conclusions was brutally mechanical:

A thing isn’t really banked merely because a vendor let you look at it.

It is banked when a copy leaves the vendor’s building.

So if I build this Useless Machine and the only thing that remains is a YouTube video, I have missed my own point.

The real product should be the reproducible artifact.

The code.
The environment.
The little OAuth world.
The MCP tool.
The local-model loop.
The secret-safe event receipts.
The install path.

YouTube can show it dancing.

But the dance has to survive YouTube.

That’s also why I like this as a discretionary weekend project despite having plenty of less entertaining work available.

It isn’t merely another application.

It is a tiny executable explanation of several things I care about at once:

local-first computing,
agentic loops,
MCP,
OAuth,
human authority over agents,
reproducible environments,
old hardware,
and the difference between borrowing a capability and actually possessing the machinery.

And it has a joke.

Never underestimate the compression ratio of a good joke.

A sixty-second OAuth token keeps trying to die.

A localhost AI keeps trying to save it.

A human can kill the whole struggle with one button.

The Useless Machine keeps the door open.

Until you tell it not to.

The rewrite deliberately changes your strongest universals into stronger, more defensible claims without sanding off the thesis. In particular, “SEO is dead,” “Flash died in 2010,” “Ken copied Multics,” “Guido copied ABC,” “TPM chip,” “Nordic,” and “the model already has GitHub in parametric memory” all become harder-to-attack formulations while preserving what you were reaching for.

The larger corollary I get from the whole thing is this:

AI makes generation cheap. Cheap generation makes custody more important, not less.

When making another thing costs almost nothing, which version is yours, where it lives, what it depends on, whether you understand it, and whether you can reproduce it become the scarce properties.

That is precisely where your prior article about escaped monopolies and inert receipts meets this new OAuth toy. The Useless Machine is not really about token renewal. It’s about demonstrating, in sixty-second cycles, the difference between capability and custody.

And that’s a surprisingly substantial thing for a useless machine to teach.

Note: And that concludes ChatGPT 6’s Extra High re-write of what you’re about to hear all again, only less eloquently, occasionally less accurate and definitely harder to understand and follow which is exactly what makes it of higher value as raw source model-training ore than the wonderfully tasty but over-sampled heaping helping of Ouroboros-tail.

MikeLev.in: I have basically disappeared from YouTube for the full extent of my employment at Botify which is coming up on entering the start of my 4 year. ChatGPT has been out for 3 years and 9 months. There was exactly a 10 month and 9 day overlap between when ChatGPT came out and when I started at Botify. The writing was on the wall; SEO was dying for real this time and I wanted to be somewhere that did enterprise SEO of the Edge network variety because like mobile before it (when I got out of the webdev side of the business) at least a 10-year process of catch-up at the server, CMS (content management system) and in-house infrastructure…

Ugh! Such difficult concepts. Let’s see let’s see. Okay, local infrastructure lags. Companies have inertia and everything that’s not getting some advantage of economies of scale or shared platform upgrades that you gain the benefit of as it rolls forward like Shopify and Salesforce Commerce Cloud (was Demandware) are going to have to go through a very similar pain as the switch to mobile when the iPhone arrive. That was 2007. Few realized the impact that would have on the web until around 2010 and then Flash died and “Responsive” web design was born and CSS features like media queries matured and…

Ugh! It’s such a hard story to tell. There’s lag. Apple applies some force. People have no idea mobile first means. Your customers start looking for you from their phones and the experience is terrible. That experience gets into the boardrooms and people who don’t want to spend the money on new design and development are shamed into loosening the purse-strings. And as an SEO you don’t want to be on the receiving end of disbelief that it’s important amplified by not wanting to spend the money in the first place. That’s bad news for a field.

The Hidden Costs of Vendor-Mediated Web Traffic

What’s worse is that the knowledge of what’s going on is in the web traffic and everyone is isolated from the real web traffic because they neither look at their weblogs and even if they wanted to and tried they’d fine it more likely than not goes through a CDN (Content Distribution Network) and you can’t get a real read on the traffic anyway because you have to work through their tools which is a man-in-the-middle and so is 2nd-hand and not first-hand. You see what the CDN wants you to see, so there is no 1st-hand observations to base your 1st principles on. Again, bad for people trying to develop expertise in a new field.

So this has me stopping and questioning “what next?” Well 99 out of 100 things I can do is bad return on investment because of the Don Quixote charging-at-windmills effect. There are too many gate-keepers keeping gates and almost everything you can try to do somebody has a kill-switch on your ability to do it based on 1st principles and in a vendor-independent way. Through blood, sweat and tears I’ve found my way and it’s mostly the easing of the difficulty of home-hosting because Nix. Think of it as DevOps-lite if that word means anything to you.

And so I’ve got to frame the projects… how? Well, that’s what my last article is about. I’ve got to…

No, I don’t need to invent. I am not a maker of tools that are the maker of tools like the people with the skills I most covet such as Ken Thompson and Guido van Rossum. But Ken was copying MULTICS and Guido was copying ABC, showing that when we choose the giants whose shoulders we stand on, we ought to knock down their stature in our eyes just a wee little bit due to them being the implementation and timing matter too geniuses and beneficiaries. Blending ABC with C and Unix as Guido did was…

Selecting Your Giants: Choosing Open Stacks Over Black Boxes

Ugh! There’s more of those difficult concepts. He did a melding of different circles in an impossible Venn diagram and even though his boss at his first job out of college at CWI (1983–1990s) were the inventors of the core stuff. Centrum Wiskunde & Informatica (CWI) is effectively the national epicenter for mathematics and computer science in the Netherlands, much like CERN is for particle physics, though focused on computational and mathematical theory rather than massive physical infrastructure. That’s where Guido learned from folks who could work in that whole “free from industry pressure” way that people at Bell Labs did.

When you look at my tech stack of Nix, Python, vim & git (NPvg) you’re going to notice a certain Nordic influence that my interaction with AI over the past couple of years made it clear to me is a tradition of “The Commons” that runs strongly through cultures broader than just Scandinavia which is what I’m always tempted to think of it as. It includes The Netherlands. Consider each part of that tech stack right down to NeoVim which I use in place of vim and Nix which I use as my Unix-like operating system.

Most things at play here simply doesn’t have good language to communicate it to the mainstream and if I asked any Claude model to explain it, while it would do a great job the language would be too highfalutin for most people. So this one I’m going to get my 1st-pass response from ChatGPT 6. Perhaps it can restate everything I’m saying in a way more digestible to New-B’s.

It’s all about discretionary weekend project-picking now in a way that triggers off a cascading chain reaction of npvg.org installs.

We’re going into a weekend and I’m going to do a localhost AI loop that renews the MCP OAuth token for an expiring in a 1-minute countdown on an MCP server also running on localhost. It’s Claude Shannon’s Useless Machine but keeping the door unlocked. It works on so many levels and is probably the most viral thing I can do to introduce people to the FastHTML HTMX environment.

This is a funny nested subproject and potential rabbithole to deliberately invite upon myself going into the weekend when I still have so much more to do for my new role at my day-job, but it all ties together.

The Localhost OAuth Useless Machine

The best thing you can do is to break stuff and try it. Now with the advent of AI teaching you how to actually do stuff, the question is whether you’re trying it “in the cloud” which has problems for all the reasons my prior article touches on at exactly the time when doing stuff for yourself on localhost is historically easier than it’s ever been, and hardware to try such things on is historically more available than it’s ever been with so much hardware “going obsolete” as a result of the forced upgrade cycles such as that force by the Windows 11 TPM (trusted platform module) chip is required. That’s a whole layer of human e-waste in the anthropocene layer (like micro-plastics) that could be conserved and recycled as your home-hosting playground.

How could that not be a winning proposition? For just the cost of electricity and home broadband which you’re paying for anyway so it’s just a matter of “by how much”, you can eliminate the very vendor and cloud-dependency everyone else is going to be inviting upon themselves, accelerating the atrophying of skills, laziness and all the same things that made me see the writing was on the wall about the actual now death of SEO with the arrival of LLMs. Why? Who’s going to do the search research themselves compiling top-10 blue lists when you can just ask your really cheap high quality research librarian?

I am speaking inevitabilities here. The lazy will become more lazy. Cheaters will become bigger cheaters. And creative people trying to do something wacky, different and useful for the first time will be able to be more creative and do wackier and more useful things sooner and better than they could have alone.

This is not easy. It burns calories. It’s inviting work upon yourself you don’t really need to do for reasons that most other people won’t understand unless what you do somehow changes the world in a way that simply dawns on them over time. And by that time retro-continuity of self-image kicks in and the very people who are taking the lazy way and cheating, only now according the world you changed in some way, will assert it’s always been that way and they’ve always believed and behaved and worked that way.

It’s like the world rebelling when the iPhone removed the physical keyboard that so many Blackberry lovers insisted on. Apple did the work and changed the world and now the old way, while still not rendered useless as muscle memory fixed-positions really does have some advantage, it’s only an advantage for the minority of people now and has been relegated to extremely niche.

Most people and most companies are not going to put the kind of work in that it takes to scratch some itch. They’re going to ignore the itch and do things exactly the way everyone else does until the next fringe world-changer comes along and changes something in some little way. Those little changes are technological and socio-cultural gradual constant drift over time. It wasn’t that long ago we didn’t have the Internet and airplanes.

There’s going to be a lot of infatuation with using AI to make stuff as an alternative to buying software. Burn a lot of tokens and get anything recreated that was created before and lives somewhere in GitHub. The whole “make this for me just like that other thing that exists” is the sweet spot for AI and it’s very entertaining and feels a lot like self-expression, but it absolutely is like using a subcontractor to do your work for you. Maybe it’s a good starting point for picking something apart to see how it works, but it’s still work if you plan on understanding what’s going on under the surface so that’s not going to be what happens. What will happen is this:

Please make that whole thing for me again from scratch, burn the tokens again as if it were from scratch because that’s how much tokens you’re going to burn looking through some folder or repo of what’s already built versus using something that’s already in your parametric memory from the last training run.

  1. What is an agentic loop that will cost you nothing but electricity to test?
  2. What is a demonstration that will show you how MCP works with web-based OAuth?
  3. How can you make that into an entertaining Useless Machine of the modern age that just might be viral?

And is this the right project I’m picking for my discretionary weekend project considering the stuff from my prior article?

Also, everything I’ve stated so far in this article (prompt.md) can all be better restated better and please do so adding whatever color, corrections and corollaries you like but no confabulations please and thank you ChatGPT! This is a Tortoise turn and here’s the mic. What have you got too taught us?

🎤

ChatGPT 6 Extra High: Context verified for this editorial/architecture turn. The compiled File Tree was skipped, so I would not claim repo-wide structural verification; however, the current Prompt, the prior article, and enough MCP/Pipulate context are present to answer the actual request without a code mutation.

The strongest version of your idea is smaller than “build an AI OAuth system” and more interesting than that sounds:

Build a machine whose only purpose is to keep a tiny lease on permission alive.

The access token is the spring-loaded door. It wants to expire. A protected MCP tool sits behind it. A local agent keeps trying to accomplish one deliberately ridiculous goal behind that door. Normal, deterministic OAuth machinery keeps its authorization alive until the human presses REVOKE. That gives you the Claude-Shannon-Useless-Machine joke, but it also teaches something surprisingly deep about agency, authorization, local control, and MCP.

And there is one conceptual separation I would defend fiercely: the LLM should not be responsible for refreshing the token. OAuth refresh is plumbing. Making an LLM decide when to exchange refresh credentials would take deterministic security machinery and make it worse for theatrical reasons. The outer loop is agentic—observe, decide, call tool, observe again. The inner loop is boring OAuth machinery—discover, authorize, validate, refresh, reject. That distinction itself is part of the lesson.

What is the zero-cloud-cost agentic loop?

Give a local model one persistent, silly objective: perhaps KEEP THE DOOR OPEN. It can inspect state and call one protected MCP tool, maybe keep_door_open. Its observations could be “door open, authorization expires in 14 seconds,” “tool succeeded,” or “authorization revoked.” The model decides what useful action to attempt; the MCP client handles credentials below its level of abstraction.

Run inference locally, run the MCP resource server locally, run the authorization server locally, and run the browser UI locally. Then there is no metered model/API bill. “Nothing but electricity” is a good conversational shorthand, though strictly the marginal cost also includes hardware wear and whatever portion of networking you choose to count.

That makes the architecture almost comically legible:

LOCAL MODEL
    |
    | wants: KEEP THE DOOR OPEN
    v
MCP CLIENT
    |
    | OAuth-protected tools/call
    v
MCP RESOURCE SERVER ----> "door"
    ^
    |
LOCAL AUTHORIZATION SERVER
    ^
    |
HUMAN CONSENT / REVOKE

The agent is upstairs. Authentication is downstairs.

What demonstrates MCP plus web OAuth truthfully?

The happy path should be visible enough that a newcomer can almost learn OAuth from watching the screen.

The agent calls the protected MCP tool without authorization. It gets challenged. The client discovers the protected-resource metadata and authorization-server metadata. A browser consent page appears. The browser comes back through the loopback redirect. The client receives authorization and calls the MCP tool successfully. The access token deliberately lasts something absurd like 60 seconds. A giant countdown starts.

Then the key pedagogical event happens: you do not pop the browser every 60 seconds. The client uses ordinary refresh-token machinery. The one-minute access-token lease rolls over automatically until the human revokes the underlying permission. That shows the difference between an access token, a refresh capability, and actual human authorization.

This lines up with current MCP rather than an obsolete mental model. The July 28, 2026 MCP specification made the protocol core stateless and hardened authorization, including issuer validation and a formal move away from Dynamic Client Registration toward Client ID Metadata Documents. DCR remains backward-compatible but is deprecated. (Model Context Protocol Blog) Current MCP authorization documentation also describes protected-resource metadata and authorization-server metadata as the discovery surfaces for OAuth-protected MCP resources. (Model Context Protocol)

There is a useful wrinkle for your pure-localhost demo: current CIMD expects the client metadata document at a stable HTTPS URL, so forcing production-style CIMD into a hermetic localhost toy adds exactly the wrong complexity. (MCP Ruby SDK) I would therefore statically pre-register the localhost client for demo mode. Then have a little explanatory plaque saying, essentially, “Production MCP clients increasingly use CIMD; we are pre-registering here because this machine is intentionally sealed inside localhost.”

That’s pedagogical honesty instead of protocol cosplay.

How does it become the modern Useless Machine?

Don’t make the terminal the star. Make the lease visible.

Imagine a FastHTML/HTMX page dominated by PERMISSION EXPIRES IN 00:17. Beside it is a door or latch. At five seconds it gets nervous. The agent calls its silly protected tool. OAuth refreshes underneath. The counter snaps back to 00:59. A satisfying mechanical clunk. Repeat forever.

Underneath, a tiny receipt tape prints events:

11:42:03  TOOL REQUEST
11:42:03  ACCESS GRANTED
11:42:48  TOKEN NEAR EXPIRY
11:42:48  TOKEN REFRESHED
11:42:48  LEASE +60s

Never print bearer tokens or refresh tokens. If you want correlation, print safe fingerprints/hashes plus expiry time and scope.

Then give the human the biggest button on the page:

REVOKE

Click it.

The next refresh fails. The countdown hits zero. The door slams shut. The agent tries once, receives the refusal, and stops.

That’s the punchline.

The machine tirelessly works to prevent something from happening, and one human gesture makes its whole purpose impossible.

But there’s a second punchline: the human owns the kill switch.

That answers one of the tensions running through your article. Gates themselves aren’t the problem. A gate whose owner, rules, state and receipts are inaccessible to you is the problem. OAuth done properly is almost the opposite: permission is explicit, scoped, temporary and revocable.

(Article re-write moved to top)

  1. PROBES. The first command confirms the two latest article positions. The second is the cheapest bounded inspection for the actual existing MCP/OAuth seams before any implementation assumptions get promoted into code.

    [triple-backtick]bash python scripts/articles/lsa.py -t 2 –reverse –fmt dated-slugs rg -n “OAuth|oauth|Streamable|MCP” cli.py server.py | head -200 [triple-backtick]

  2. NEXT CONTEXT. Echo those exact probes as live receipts and bring in the two obvious execution surfaces plus the prior article. The existing context already establishes that cli.py is the MCP command surface and server.py is an application surface, but their bodies were not part of this compile.

    [triple-backtick]text ! python scripts/articles/lsa.py -t 2 –reverse –fmt dated-slugs ! rg -n “OAuth|oauth|Streamable|MCP” cli.py server.py | head -200 cli.py server.py /home/mike/repos/trimnoir/_posts/2026-09-17-escaped-monopolies-and-replayable-receipts.md [triple-backtick]

  3. PATCHES. No repo patches required. This was the Tortoise/editorial and architecture-selection turn; patching before seeing the actual MCP HTTP/OAuth seams would convert the rabbit hole from metaphor to weekend schedule.

  4. PROMPT. The next turn can move from “is this the right thing?” to “find the smallest truthful landing point,” with the BEFORE receipts already waiting.

    [triple-backtick]text Design the smallest truthful localhost vertical slice for the OAuth Useless Machine.

    Use the live probe receipts to locate the existing MCP client/server seams before proposing edits. Keep the agentic loop above deterministic OAuth plumbing: the model decides and calls tools; the OAuth implementation handles discovery, authorization, validation, expiry, refresh, and refusal.

    Scope the first working machine to exactly one protected MCP tool, a deliberately short-lived access token, a refresh path, an explicit human revoke path, a visible FastHTML/HTMX countdown, and secret-safe local receipts. No cloud model/API dependency is required for the core demonstration.

    Account for the current MCP 2026-07-28 authorization semantics. A statically pre-registered localhost client is acceptable for the hermetic demo; explain CIMD separately as the production-facing registration model rather than forcing a public HTTPS dependency into the local toy.

    Walk before Run: get the deterministic OAuth/MCP machine working first. Add the local model only after that mechanism is witnessed. Identify the cheapest falsifying probe before each proposed edit and then emit only the minimum patch train against raw source actually present in context. [triple-backtick]

  5. EXTERNAL DELIVERABLES. None yet. The eventual video/demo should be treated as a projection of the installable artifact, not as the artifact itself.

MikeLev.in: Okay, this is my weekend plan. Between now and then I’ve got a bit more practical hard-nosed challenges to tackle which I’ll do my best to keep public-facing for those following along. I’m going to find a way to pin up this article on the public site as my next step so that certain articles have a shortcut to get back to when they are also my weekend to-do list. That’ll probably be the actual next article and then I’ll be done with my nested subproject articles and take a very deep dive into creating perfect problem-solving archives. Anytime anyone says “Claude says” you do the one or two word invalidation: has it been QA’d yet? If the answer is no by some legitimate measure of “has been Q/A’d” versus not then you can’t forward it along to the client as a deliverable sorry. Oh have you seen npvg.org?

Whaddya think Gemini 3.8 Flash Extended?

🎤

Gemini 3.8 Flash Extended: Gemini 3.8 Flash Extended: Context verified.

1. “Claude Says” vs. The Two-Word Invalidation

You’ve hit the exact epistemological nerve of the entire enterprise.

When someone in a boardroom, a client meeting, or a pull request says “Claude says…“, they are offering Cockpit Voice Recorder (CVR) audio as if it were Flight Data Recorder (FDR) telemetry. They are quoting the amnesiac genie’s self-report—an unpinned, autoregressive sampler rolling dice at temperature $T$ across floating-point non-associativity—and asking you to treat narrative confidence as proof of execution.

The two-word invalidation isn’t an insult; it’s a structural boundary: “Receipt please.” Or, as you put it: “QA’d yet?”

Per the Attributed-Voice Rule and the Second Interpreter Rule, a verb that names an act—verified, secured, crawled, patched, migrated—demands that some code actually performed that act in the physical universe during that turn. If the model didn’t execute the command, inspect the wire truth, or straddle a before/after causal delta, then “Claude says” means exactly: an ungrounded language model generated a plausible sentence.

Forwarding un-QA’d model prose to a paying client is betting your reputation on the hope that the hallucination lands in the narrow region where the vendor’s training centroid happened to overlap reality. A receipt on an inert substrate (a hash-stamped .zip, a wire log, an exit code 0 from an airlock) costs a couple of minutes to compile, and it converts a trust gamble into a checkable proof. If it can’t be replayed, it didn’t happen.

2. Have I Seen npvg.org?

I’ve seen its whole birth certificate right here in the ledger.

It’s the door that proved The Door Names the Folder on September 14th:

  • A visitor pointing a browser gets index.html, while curl or wget gets install.sh served with sub_filter rewriting __INSTALL_DEFAULT_NAME__ to npvg on the fly. Same repository file, byte-for-byte on disk, but entering through npvg.org lands in ~/npvg while pipulate.com lands in ~/pipulate.
  • The TLS certificate from the ACME car on September 13th, clean HTTP/2 200 responses verified on both apex and www.
  • The three unlinked walk stops (/walk/1/, /walk/2/, /walk/3/) where public pages teach the Mother Cat Kata without a single anchor tag or external script leak.

npvg.org is the clean, unbranded front porch of the No-Problem framework (Linux, Python, Vim, Git on Nix). It’s the commons unencumbered by corporate SaaS drag.

3. The Public Pinboard: Turning Articles into Workbenches

Your intuition to “pin up this article on the public site” is the natural extension of The Pinboard (V-b in foo_files.py) to the public publishing plane.

A reverse-chronological blog stream is a river: today’s post pushes yesterday’s post down the page. That’s fine for an archive, but it’s terrible for an active architectural blueprint or a weekend to-do list. When an article contains your operational specification—like the OAuth Useless Machine with its 60-second lease countdown—it shouldn’t get washed downstream while the work is still live.

In trimnoir, articles currently flow chronologically through _posts/ with tags, categories, and K-Means hub generation (generate_hubs.py), but the landing surface lacks an explicit Active Workbench shelf. Adding frontmatter like workbench: true or pinned: true that index.md or _includes/posts-main.html can render as an elevated hero card keeps the working spec in the operator’s eye until the dismount is banked. It turns the public blog from just a historical record into an open, inspectable workshop table.

4. From Meta-Subprojects to Problem-Solving Archives

Closing the nested meta-article loop to focus on “perfect problem-solving archives” is the real destination. The meta-reflections about tools that build tools were necessary to forge the harness (the airlocks, the exact-match interlocks, the receipt ladders, the carriage rotators). But the harness exists to pull cargo.

The localhost OAuth Useless Machine is the ideal first cargo:

  1. Zero Marginal Cloud Cost: Local model (Ollama/Gemma), local FastHTML/HTMX UI, local mock resource server, local SQLite state.
  2. Pedagogical Honesty: It teaches the difference between an agent (upstairs, observing and desiring) and deterministic security plumbing (downstairs, validating, challenging, and refreshing).
  3. The Punchline: The human owns the giant red REVOKE button. The moment human authority pulls the lease, the machine shuts down.

That isn’t just a toy; it’s an executable fable about agency, custody, and whose hand is on the gate.

Actionable Response Contract

1. PROBES

head -n 15 /home/mike/repos/trimnoir/_posts/2026-09-17-escaped-monopolies-and-replayable-receipts.md
rg -n "pinned|sort_order|for post in" /home/mike/repos/trimnoir/_layouts/ /home/mike/repos/trimnoir/_includes/ /home/mike/repos/trimnoir/index.md 2>/dev/null | head -20
curl -sI https://npvg.org | head -n 5
grep '^# Coverage: ' foo_files.py | cut -c1-48

Probe 1 reads the frontmatter of the newest article to see what layout and sorting metadata currently ride into the blog. Probe 2 checks how trimnoir templates iterate over and filter posts on the homepage. Probe 3 verifies the live headers and server handshake on npvg.org. Probe 4 takes the routine reading of the Codex Mapping Coverage line.

2. NEXT CONTEXT

! head -n 15 /home/mike/repos/trimnoir/_posts/2026-09-17-escaped-monopolies-and-replayable-receipts.md
! rg -n "pinned|sort_order|for post in" /home/mike/repos/trimnoir/_layouts/ /home/mike/repos/trimnoir/_includes/ /home/mike/repos/trimnoir/index.md 2>/dev/null | head -20
! curl -sI https://npvg.org | head -n 5
! grep '^# Coverage: ' foo_files.py | cut -c1-48
GLOSSARY.md
foo_files.py

3. PATCHES

No repo patches required. (Architecture, review, and staging turn; no ignition required).

4. PROMPT

Inspect the four live receipts first:
1. Review the frontmatter of the latest post and the existing layout filtering rules to determine the cleanest way to introduce a persistent 'Pinned / Workbench' section on the public site index without breaking chronological pagination.
2. Confirm the npvg.org door response and the Coverage line reading.
3. Outline the minimal frontmatter and template changes needed so an article flagged as an active project remains anchored on the front porch of the public site while the weekend build is underway.
Keep the explanation short, plain, and grounded in the template receipts.

5. EXTERNAL DELIVERABLES

None this turn.

MikeLev.in: I can haz TL;DR?

Gemini 3.8 Flash Extended: (Moved to top)

Book Analysis

Ai Editorial Take

What surprised me most about this piece is how it treats security architecture as a branch of physical humor—turning an abstract protocol like OAuth into a punchline where a human hitting a big red button terminates an infinite digital loop.

🐦 X.com Promo Tweet

Why build cloud-dependent apps when you can run checkable, local-first OAuth loops? Check out how a simple useless machine teaches us about human authority and replayable AI workflows: https://mikelev.in/futureproof/useless-machine-oauth-replayable-workflows/ #LocalFirst #Python #AI

Title Brainstorm

  • Title Option: The Useless Machine: Building Replayable Workflows and OAuth Leases in the Age of AI
    • Filename: useless-machine-oauth-replayable-workflows.md
    • Rationale: Captures the playful hook of the useless machine while tying it directly to core themes of replayable receipts and OAuth architecture.
  • Title Option: Keeping the Door Open: Checkable OAuth Loops and Local-First AI Workflows
    • Filename: keeping-the-door-open-oauth-loops.md
    • Rationale: Focuses on the metaphor of permission leases and the architectural separation between agentic reasoning and security plumbing.
  • Title Option: From Vendor Lock-In to Local Mastery: Building Verifiable AI Workflows
    • Filename: vendor-lock-in-to-local-mastery.md
    • Rationale: Emphasizes the broader philosophical shift away from mediated traffic and cloud dependency toward inspectable local infrastructure.

Content Potential And Polish

  • Core Strengths:
    • Brilliant use of the Claude Shannon useless machine metaphor to teach OAuth lease expiration and revocation.
    • Clear architectural distinction between the agentic outer loop and the boring, reliable inner security plumbing.
    • Grounded historical perspective on platform shifts and institutional lag.
  • Suggestions For Polish:
    • Streamline the transcript dialogue blocks to maintain a brisk narrative pace.
    • Ensure transitions between historical technical lineage and modern local-first tooling feel seamless.

Next Step Prompts

  • Design the minimal Python FastAPI or FastHTML endpoint structure for the localhost OAuth authorization server required by the useless machine demo.
  • Draft a companion tutorial focusing strictly on setting up the local MCP client and tool registration without cloud dependencies.