Terrabyte Technologies · 2026 · Ongoing
A long-running business AI on a single Mac Mini — review monitoring, financial analysis, and 24/7 data stewardship over a 115-table production schema. No third-party LLMs, no cloud egress.
Small businesses now have access to the same large-language-model capabilities that big companies do. The catch is the deployment shape — almost every SaaS AI tool ships as "your data, our cloud, our model." That works fine for content drafting. It works less well for the work that actually distinguishes a business: review monitoring with real customer messages, financial analysis of real ledgers, and any role that touches the schema where your business actually lives.
The two-line summary of every "AI for small business" pitch is "let our cloud LLM read your private data and give you summaries." For the categories of work most worth automating — customer review triage, financial close, schema stewardship — that means handing the most sensitive substrate of the business to a third party with a different incentive structure.
Aileen is the response. It's a long-running daemon on a Mac Mini in my office, and the model never leaves the box.
Three workloads, integrated into one process:
Each tool is a typed Python function the agent can call — read tools over the production schema, write tools gated by drift detection, scrapers for retailer + tournament data, and a handful of utility tools for daily briefs and digests.
Aileen runs as data steward for a sister project's Postgres database. A schema-contract layer validates 115 tables on startup and blocks writes to any table where the live schema has drifted from the expected shape.
Inference is local. Models run on Apple Silicon via Ollama for small jobs and vLLM/MLX for the larger ones. Adding a tool is free; running a year of digests is also free.
The daemon ships morning briefs, weekly digests, ad-hoc chat queries over the business surface, and a stream of write operations into the production schema — scraped retailer prices, refreshed PDGA tournament data, image enrichment from operator websites, and discovery of new entities (courses, players, manufacturers) that hadn't been seen before.
The risk model for an autonomous data steward is real: if the underlying schema drifts under the agent, write operations corrupt data quietly. Aileen treats the schema as a contract — every table the steward writes to is declared in code, every column is enumerated, and a drift detector runs on daemon start. If the live database has columns the steward doesn't know about (or is missing columns the steward expects), writes to that table are disabled until the schema and the code reconcile.
Drift detection isn't an alert — it's a circuit breaker. A divergence between code and database doesn't generate a warning email; it stops the write path. The agent stays useful for read operations on undrifted tables while the human resolves the contract. The right failure mode for an autonomous steward is "stop writing," not "keep writing carefully."
The pairing is a TypeScript codebase (the production app, with Drizzle as the schema source of truth) and a Python codebase (the steward, with a typed EXPECTED_TABLES map). A change to a table the steward touches requires a coordinated update — and the contract makes that requirement loud.
Aileen's daemon is a fork of Rosie — the family-AI project — recast for a business context. The choice to fork rather than abstract was deliberate. Two product surfaces with diverging requirements (family workflows vs. business workflows, personal data vs. multi-tenant business data) would bend a shared codebase out of shape; two forks share a heritage and diverge cleanly.
The steward's write path is a sequence of explicit steps — pre-flight validation, fetch, parse, transform, upsert, verify. Each step is its own Python module with its own tests. Adding a new write surface (a new retailer scraper, a new ranking source, a new image-discovery path) means adding a step file and registering it. The pipeline runs steps in order, and a failure in one doesn't cascade.
class PdgaSpecsStep(MigrationStep):
"""Sync physical disc specs from the PDGA approved-discs CSV.
Idempotent: re-running the step against the same CSV produces no
writes. New entries in the CSV (PDGA approval of a disc we hadn't
seen) raise an admin notification so the human can confirm before
the disc lands in the catalog.
"""
name = "pdga_specs"
depends_on = ("discs", "manufacturers")
expected_tables = ("discs", "manufacturers")
async def run(self, ctx: StepContext) -> StepResult:
await self.schema.assert_contract(self.expected_tables)
csv_rows = await fetch_pdga_csv()
matches = await find_pdga_matches(ctx.db, csv_rows)
await update_physical_specs(ctx.db, matches)
new_discs = await discover_new_discs(ctx.db, csv_rows, matches)
if new_discs:
await notify_admin(ctx.db, "pdga_disc_new", new_discs)
return StepResult(updated=len(matches), discovered=len(new_discs))The shape is mundane on purpose. Steward work is the opposite of demo-able — the user-facing reward is "nothing surprising happens in your database overnight."
Aileen exposes a chat surface, but it's a single-operator tool. The reads it makes — full table scans for audit reports, joins across foreign-keyed tables, queries over private user data — would be inappropriate for an end-user-facing assistant. The product contract is "the operator can ask Aileen anything about the business surface; end-users get a curated subset via the production app's own UI, separately."
Production at home for the second half of 2026. Runs the morning brief, computes the weekly digest, executes the nightly write path, and answers ad-hoc operator questions about the business surface. The codebase is sibling to Rosie — same daemon shape, different domain.
A 92-tool private business AI that runs entirely on Apple Silicon, stewards a 115-table production schema with drift-aware write gating, and bills $0 for inference. The fork from Rosie validated that the "long-running personal AI" architecture generalizes to business workloads; the schema-contract pattern is the load-bearing piece that makes autonomous write operations safe.
Three threads: a verifier mode that flags low-confidence write candidates for human review before commit (shadow-running now), broader chat-tool surface so the operator can drive more of the daily review from the chat instead of the production app's UI, and a packaging path so the same daemon can be deployed against a second business surface without per-customer rebuilds.