Token counts, cloud subscriptions, and API rate limits are a constant drain. Beyond the monthly line items and the continuous cost optimisation of running infrastructure, the primary driver for me is data containment. Ensuring that not a single packet of proprietary code or infrastructure configuration leaks into an outbound telemetry stream to an external corporate LLM provider is a massive win.

As a follow-up to my last post exploring the trade-offs of RSS feeds versus heavy-handed cloud AI agents, I decided to run an architectural experiment. Can you build a complete, functional smartwatch application end to end inside a strictly self-contained, local AI stack?

The objective was simple. Depend entirely on local models to develop a Pebble watch app, ensuring zero outbound communication for the models while saving a small fortune on subscription meters.

Full disclosure: I am not an expert in PebbleOS development. I know enough of the core tech stack to be dangerous, but I promised myself I would try not to interject my grey beard wisdom too much. I wanted to see if the model could do the heavy lifting safely within its local sandbox.

It reminds me a bit of the modern robot vacuums and lawnmowers. They are not perfect. They take a long, winding time to get the job done, and they occasionally get stuck in a corner. But why should I care how long the process takes if the system is grinding away safely on my own local silicon while I am out in the garage or fast asleep?

The Lab Hardware

To give this experiment the best possible runway, I fired up my fully loaded Framework Desktop powered by the AMD Ryzen AI Max+ 395 chip, packed with 128GB of RAM.

With that massive unified memory pool and the integrated Radeon 8060S graphics architecture, I can host massive, high-parameter models locally. The marginal cost of running a prompt is practically just the hardware’s power consumption under load. Zero API billing tiers, zero data leakage, and total control over the execution lifecycle.

The Mission Profile

  • Develop a basic Pebble watch app from scratch.
  • Deploy it cleanly to a local Git repository.
  • Establish automation: Set up CI jobs for automated testing, security scans, and compilation builds.
  • Documentation: Automatically capture screenshots from the emulator and update the Readme.md.

To lay down the foundation, I installed opencode and opencode-desktop to handle the workspace management.

Phase 1: Grid Coordinates and the Nemotron Grind

The functional goal of the app was practical. Create a utility that captures the device’s current location and displays it in the three major GPS coordinate systems simultaneously: Degrees, Minutes, Seconds (DMS), Military Grid Reference System (MGRS), and Decimal Degrees (DD, because nobody has time to parse coordinate strings).

I kicked off the project by loading up the largest context model my rig could handle comfortably: Nemotron 3 Ultra Free, giving it full access to the Framework’s compute cores.

The model successfully provisioned the basic framework of the repository. The minimal configuration files were there, but we hit an immediate roadblock. My local environment lacked the standard uv package manager and the SDK. Because models often suffer from classic environmental hallucination, it started throwing out detailed installation instructions tailored for Debian, completely ignoring the fact that my workstation runs Arch Linux.

~~text [Model Logs]: “To install the dependencies, please execute: apt-get install python2.7…” [Me]: “Negative. We are on Arch.” ~~

After pivoting past the dependency traps, the local LLM claimed victory multiple times. “Success! The build is complete,” it would report. Yet, looking at the screen, the Pebble emulator remained stubbornly blank. No app icon, no text, no life.

Compounding the issue, my host architecture has strict local security rules. The environment was locked down tightly within specific sandbox directories. As the build repeatedly stalled, I found myself slowly opening up directory paths, verifying system calls, and adjusting permissions to let the local compilation tools breathe.

Phase 2: High-Performance Babysitting (RTFM)

Watching the model hit a wall over and over felt exactly like managing a junior engineer. It had the enthusiasm, but it lacked the situational context. It was time for a grey beard intervention. I prompted it to literally go read the manual, feeding it raw context from the field:

The Prompt: “Read this page from StackOverflow and see if it helps at all with your troubleshooting: https://stackoverflow.com/questions/36046902/pebble-js-geolocation-not-storing-location-globally"

The model consumed the technical context, pivot-corrected its JavaScript scope logic, and tried again. After a volley of failed attempts to stabilise the GPS lifecycle, I decided to swap operators. I benched Nemotron and spun up DeepSeek V4 Flash locally to tackle the logic puzzle from a fresh angle.

While the models traded shifts and hammered away at the plumbing, I stepped away. I went out to the garage, worked on some wiring, did some OBS streaming setups, and let the compute stack grind. My input was minimal. I just fed it specific reference links when it got stuck and switched models midway through the cycle.

The result? It took about 4 hours of continuous, automated background iteration, but the code finally stabilised. The plumbing clicked, the compilation cleared, and the coordinate app blinked to life inside the local emulator.

The Horizon: Blue Force Tracking & Meshtastic

With the basic three-coordinate grid architecture locked down, my next immediate goal is to see if we can implement a dynamic map overlay with a real-time position locator.

This is not just an exercise in building a utility. My ultimate objective with this project is to port Meshtastic to the Pebble watch platform.

By combining low-power LoRa mesh networking with an efficient, daylight-readable wearable, I want to establish a completely off-grid, decentralised Blue Force Tracking (BFT) node display.

Proving that a highly secure, cost-optimised workstation running zero outbound inference telemetry can reliably handle the scaffolding, CI/CD pipeline automation, and SDK edge-cases means the workflow is fully viable. The robot mower might take a chaotic path across the lawn, but if you wake up to cut grass without paying a persistent subscription fee or leaking your architecture to the cloud, it is a massive win.

The complete repository and automation configurations can be found here: Pebble GPS App Source Code.

Stay tuned for the next update, where we attempt to map incoming LoRa packets onto the wrist.