ARIN OS - Personal AI Harness

A word on how this was built

This system — provider registry, retrieval pipeline, knowledge graph, every module below — was built with an AI coding assistant, treating it like a teammate who’s incredibly fast but takes everything you say completely literally, so it does exactly what you asked instead of what you meant. Ideas like this used to die for lack of time, not vision. Knowing exactly what to build and how to get there now closes most of that gap for one person working alone.

“Vibe coding” gets a bad rap, but ask yourself: could you write the same complex code as a compiler by hand? Could you rewrite every module you keep on importing from scratch? No — you trust that layer to do its job and build on top of it. Working with an AI assistant felt like the same trade. Nothing about ownership changes — you still design the architecture, still own the security model, still have to catch it when it’s wrong, and you still need to understand the system well enough to ask for the right thing. What changes is what one person can get done. Worth using, not dismissing.

The problem

Ask most people where their AI work lives and you’ll get a shrug and a browser full of tabs. Context is everywhere, owned by nothing:

CHAT — Three providers, zero shared memory between them PROMPTS — The ones that worked, scattered across notes apps KNOWLEDGE — PDFs downloaded, never reopened; reading never indexed GOALS — A spreadsheet last touched two quarters ago

The tools aren’t bad. The problem is structural:

• Your context — decisions, reading, prior work — is scattered across all of them

• Most of it is rented: it lives inside a provider’s product

• When pricing changes or a model is deprecated, the context goes with it

The intelligence is a commodity you rent. The context is an asset you own. Build the system so the asset outlives the commodity.

What Arin OS actually is

A single, self-hosted system between you and every AI capability you use:

• → Multi-provider chat

• → Personal knowledge base

• → Source-cited retrieval

• → Knowledge graph

• → Learning journeys

• → Interview prep

• → Research & writing workflows

• → MCP tool integrations

• → Versioned prompt library

• → Multi-model comparison

What it isn’t: a chat wrapper or a SaaS product. It runs under your control, on your infrastructure, holding your data.

The dashboard home screen — the whole system at a glance. Some text is blurred to protect personal content.

Design principles

1. Own context, rent intelligence — knowledge is permanent; models are swappable config

2. 5–10 year horizon — boring foundations: relational DB, cache, HTTP, open API

3. Provenance always — every output traces to model + prompt + knowledge source

4. Retrieval integrity first — the biggest lesson (see below)

5. Small core, extensible edges — new capability via plugins & standard protocols

Two structural decisions do most of the work:

Provider abstraction — No feature talks to a vendor directly → swapping a model = settings change, not migration

Persistence boundary = enforcement point — Data-quality rules enforced where data is written, not where it’s produced

Why retrieval integrity is the whole ballgame

Everything in the system reduces to one question: are these two meanings close? That only works if stored representations carry real meaning. A stray fragment or N/A still gets vectorized — and noise with arbitrary closeness to everything doesn’t degrade results gracefully, it poisons them.

Arin OS solves this by enforcing data quality at the persistence boundary — the single point every write must pass through — not in individual functions that callers can bypass without knowing a rule exists.

How the write gate works

Gate — Every corpus write passes through one enforcement point — no bypass path exists Validation — Passages below a minimum content threshold are rejected before vectorization Self-healing — Integrity check runs at the tail of every ingestion cycle — the corpus repairs itself as it grows Result — 4,991 clean passages, zero degenerate, health checks green

Ingestion (any source) → Write Gate (validate → vectorize) → Clean Corpus (self-healing ✓)

A convention that lives in one function is a convention the next contributor silently skips. Enforce invariants where the data lands — and make the gate arm itself.

Knowledge base — corpus stats, search, and reindex trigger. Some text is blurred to protect personal content.

The knowledge graph

Above raw retrieval sits a semantic layer that finds concepts and relationships across the corpus. How edges are validated:

• A single model guess never creates a connection alone

• Candidate edges need multiple independent signals: direct statement, repeated co-occurrence, meaning closeness, neighbourhood consensus

• System is deliberately biased toward caution — over-merging silently breaks the map

A concept cluster — connected by actual relatedness, not co-mention. Some text is blurred to protect personal content.

Full map at scale — thousands of nodes, edges only where signals agree. Some text is blurred to protect personal content.

Models tab — the model the graph uses, plus the enrichment toggle. Some text is blurred to protect personal content.

Model proposes concepts → everything after (merging, scoring, rescue) is arithmetic.

Providers & embeddings: one shared gateway

Chat / Retrieval / Graph → Provider Registry (name a capability, not a vendor) → OpenAI / Anthropic / Local

• Every model request passes through one abstraction — adding a provider = registering behind the same interface

• Embeddings get the same treatment — swapping = settings change + reindex

• Documents and queries always share one vector space

Providers tab — every connected vendor, status, and defaults. Some text is blurred to protect personal content.

One registry, many back ends — nothing downstream names a vendor.

The embedding model currently pinned — reindex required on change. Some text is blurred to protect personal content.

One choice governs the whole corpus — same embedding space everywhere.

The full stack: what you use → what does the work → what remembers it.

Filing, answering, graphing — three uses of the same underlying steps.

MCP: tools without hallucination

Left to answer from memory, models confabulate. The fix: grounded tools via one standard protocol (Model Context Protocol).

• Every tool call: registered once, described uniformly, logged for provenance

• Adding a server: paste endpoint → authenticate → tools available next turn

• Shared across chat, workflows, and interview prep

Settings — connect a server with a name, address, and toggle. Some text is blurred to protect personal content.

One client seam handles every server — register once, use everywhere.

Organizing intent, not just answers

A knowledge system that only answers questions is a reference book. What makes this an operating system is intent across three horizons:

Themes — 2–3 things you’re investing in over a year — determines what’s worth ingesting Journeys — Scoped, resumable objectives — learn a domain, research a question Sessions — What you’re doing right now, grounded in everything above

All three share one corpus. A question today draws on material ingested months ago.

Learning journeys pair a scoped knowledge slice with a tutor grounded in only that slice — not a search engine that’s read everything. AI-assisted learning’s failure mode is fluent passivity: you read great explanations, feel you understand, retain nothing. A system that tracks coverage and questions you back sits on the right side of that.

A learning journey — scoped knowledge and tutor conversation. Some text is blurred to protect personal content.

Interview prep: a loop, not a question bank

Generic advice is least useful here. A chatbot with no memory restarts context every session. This module runs as a loop:

Profile → Roadmap → Practice → Evaluate → Reprioritize ↻

Roadmap generated from your résumé + target role + stated criteria — not a canned template.

Interview landing — active preparations with confidence scores. Some text is blurred to protect personal content.

Adaptive roadmap — day-by-day topics, reprioritized by feedback. Some text is blurred to protect personal content.

Mock interview — adaptive difficulty, no flattery. Some text is blurred to protect personal content.

Research & writing: always cited

Resumable workflows grounded on KB + live web:

• Research question → optimized queries → correlated sources → cited answer

• Blog drafts with receipts intact — never synthesis with sources stripped

• Long runs checkpoint progress — interruption ≠ starting over

Research vs. blog draft — kind picker, run history, stage list. The text in the actual screenshot has been replaced with dummy data to ensure privacy.

Cited answer with Sources panel — KB and web side by side. The text in the actual screenshot has been replaced with dummy data to ensure privacy.

Finished blog draft — rendered Markdown, ready to publish. The text in the actual screenshot has been replaced with dummy data to ensure privacy.

The business case

Context compounds — A corpus is an appreciating asset; a subscription resets to zero when you stop paying Provider independence — Price rises and deprecations become inconveniences, not migrations Provenance by construction — Auditability built in, not retrofitted Self-hosted — Sensitive material never leaves your infrastructure

What I’d tell another engineer

1. Enforce invariants at the boundary, not by convention. A rule in a function is a rule the next contributor skips.

2. Silent quality failures are the expensive ones. Crashes get fixed fast. Quiet degradation compounds for months.

3. Test that your test fails. A regression test never seen to go red is trust on faith.

4. Measure the thing, not a proxy. A benchmark once reported a failing request as a 4× speedup.

5. Scale problems hide in uniform test data. If fixtures are tidier than reality, tests are optimistic.

A note on web ingestion: Copyright applies whether or not content carries a notice. Honor robots.txt, rate limits, and terms of service. Never collect behind logins, paywalls, or consent gates. The obligation rests with the operator.

---

Rent the intelligence. It gets better every quarter and costs less every year. Own the context. Nobody is going to hand it back to you.