AI

I have been building an agent platform on my own hardware one post at a time. This is the whole thing in one place: how a job gets dispatched, which model runs it, and what it has to prove before I believe it.

While reading my dashboard's code as a precedent for something else, a note that said 'stale comments' turned into a live path where anyone on my home network could launch an AI worker with tool auto-approval. Fixed at two layers, then the fix locked me out, which was its own lesson.

Two passes over the memory layer my AI tools search. First, an audit of how eight knowledge bases preserve working transcripts, which ended with part of the index quarantined and a refusal to backfill history. Then importing 708 conversations from a cloud account into that same layer without publishing things to myself that should stay private.

Every mode of my study assistant returned a server error before the model was ever called. The context packet's fixed part had grown past the safety limit on its own, and one unbounded field guaranteed it would keep growing. The fix went into the shared layer three different callers depend on, with caps chosen by measurement and a degrade path before any error.

A small domain knowledge base built from an official document and three books, with a coverage gate that reports its own holes instead of hiding them. The useful part was the second pass: of eight apparent gaps, three turned out to be my own bad phrasing and five survived as real, and telling those apart is the whole job.

The redaction fix from the day before had quietly made my search index 21% bigger. The cause was one line in the wrong order, the fix was two changes that were useless alone, and the proof was a measurement that matched the prediction to the character.

The instruction text my AI tools read lived in a dozen places across the fleet: files on each machine, symlinks, importers, and text boxes in someone else's web UI, with no record of which was current. Now there is one registry that owns every surface by path and hash, a checker that verifies 103 of them, and a ruling about what an embedded version token actually means.

Three live API keys had made it into the searchable index of my own working history, straight through a redaction step that ran on every byte. The fix was small; deciding how to measure it before trusting it was the real work.

A routine tidy-up of my project notes was handed to an automated worker. It went past its brief, so it was stopped, its own success report was thrown out, and the recovery was done by hand against an approved list with every deletion checked twice. The good suggestions it made were kept.

Jobs were queuing behind a busy machine for no better reason than habit about which machine owned that kind of work, so I separated who runs a job from where the job lands.

The free model on my own hardware kept failing halfway through jobs. The cause was not on my side, and the fix was to stop asking the model to write its own proof of work.

Prospect's two AI background workers were quietly overwriting each other's status, so every service restart redid work that was already done. The handoff called it a one-row cosmetic cleanup. Reading the two workers against each other showed something worse, and the fix cost no GPU time.

My notes could answer what I decided but not what I actually did, so I built a second searchable layer over the working history itself, and a rule for when it is allowed to be used.

I stopped picking which AI model runs each job by hand and built a router that scores the options on what each one has left, reserves the winner, and writes down why it chose.

The harness that runs my local model was reporting success unconditionally, no matter what happened. Hardening it went in four phases, each one proving the defect on the unmodified code before patching, and ended with a single terminal contract that maps every way a run can end to an honest status and exit code.

Two things about working with AI agents that only show up after you have run them for a while: the cost of what you read at the start of a conversation is paid again on every later turn, and a detailed handoff from another agent is a claim until something the author could not have shaped confirms it.

The free model on my GPU box was unreliable in a way I could not name. Before swapping it, I found the reason by reading its transcripts, then ran a controlled A/B of six scored tests in an isolated copy of the real harness. The candidate won 5 to 2, a longer soak passed 21 of 22, and the swap was one line.

Prospect got meaning-based search fused with its keyword search, and a semantic check for reposted listings. Both had to be designed so they could fail without taking anything down, and the duplicate threshold was calibrated on a copy before it touched the real database.

Working with AI assistants for months across several projects, the failure I kept hitting was not bad answers, it was lost context: every conversation restarted from zero or dragged a bloated history. The fix was a method: each conversation does exactly one bounded section, and continuity lives in three small documents, not in the chat.

I set out to train a small local model to reproduce Apple's photo-quality score so Loupe could rank photos for anyone. It matched Apple almost perfectly. Then a cheap probe showed what the score actually measures, and it was not beauty.