On Android the sandbox loads an index.html into a WebView, with standardized string I/O to the harness via some window properties. You can even return a rendered HTML page.

Definitely hacked together, but feels like an indication of what an edge compute agentic sandbox might look like in future.

RAG made sense when the semantic search was based on human input and happening as a workflow step before populating context. Now it happens inside the agentic loop and the LLM already implicitly has the semantics of the user input.

An example in microcosm: a local village suffered road flooding due to failed maintenance of water pipes. Our rent-seeking privatized water company effected the minimum repair required by regulation.

The next section of old pipe burst almost immediately, flooding the road further for most of January, utterly destroying the surface, through the road base in many places. Even at a crawl it's difficult to avoid tyre damage.

Over a month later the water repairs were effected. Then shortly after some local roadwork notification signs were put up.

Those expecting repairs to the moonscaped road were disappointed: instead the relentless bureaucracy of British local government installed traffic calming measures on top of the broken road, as the work had already been booked and could not be stopped by any means as even basic roadworks lack any degree of dynamism in their execution.

All this still needs to be made right. These small scale failures will compound and compound until the entire state is drowned in the consequence of its incompetence.

I needed a poc RAG pipeline to demo concepts to other teams. Built and tested this over the weekend, exclusively with Claude Code and a little OpenCode. Mix of mobile app and breaking out Android terminal to allow Sonnet 4.5 to run the dotnet build chain on tricky compilation issues.

https://github.com/pixelbadger/Pixelbadger.Toolkit.Rag

As for the local env, I'm treating the Android terminal as a sandbox. Anything gets trashed I just reset and reinstall my toolchain.

I won't pretend I'd use this workflow for anything high-stakes. But for simple things like "I wonder how my Hue lights actually work?", its viable.

Worth pointing out I'm not SSHing to a different device. Claude Code installed and running directly in Android terminal on my phone.

I've built ASP.NET Core APIs on-device this way. Install dotnet in the terminal and Claude can write code, build, run unit tests, and even run the API on localhost. Then use `git` and `gh` to commit, push and raise a PR.

Over the recent break, across four or five sessions, I wrote a set of prompts around ~500 words in total.

The result was Claude scanning my network for active ports using nmap, fuzzing those ports with cURL, documenting its findings, self-directing web searches for API/SDK docs for my Hue bridge and ancient Samsung TV, then building a set of scripts to control my lighting system and a fully functional HTML+JS remote for my TV.

The most entertaining part was Claude prompting _me_ to pop into the living room and press the button on the Hue bridge so it could fetch an API key.

The most valuable part? The understanding I gained secondary to generative act. I now understand the button on a Hue bridge literally just tells the device to issue a new API key at the next request. I understand how Entertainment mode works, and why. I understand how Samsung SmartThings is mediated via websockets - and just how insecure decade old Samsung TVs are.

Around 500 words to gain all this? I hate to buy into the hype, but it feels inflectional.

To paraphrase an adage I've forgotten: you can skim as much shit as you like off the Thames, it'll still be a filthy river.

A book that allows you to _do things_ is finally a challenge to the allure of the tablet and the Switch.