What We Are
Most people experimenting with AI at home are running a chatbot in a browser tab. Hoppe.home is a genuine operating environment: a resident AI agent working as a real partner rather than a bolted-on assistant, a private knowledge graph that functions as institutional memory, a full self-managed IT estate, and a growing portfolio of production applications actually used every day — not demos, not proofs of concept.
We didn't set out to build a "smart home." We set out to build the kind of disciplined, governed, well-documented technology operation you'd expect to find behind a real company — and then applied it at family scale, for a family's actual benefit.
AI & Logistics
Our engineering discipline didn't come from a textbook — it's the same operational thinking that runs real supply-chain and logistics operations: forecast the demand, allocate the capacity, prioritize under constraint, and measure performance against outcomes that actually happened, not outcomes that looked fine on a dashboard. We apply that exact lens to AI. An autonomous agent is only as trustworthy as the process that allocates its authority, tracks what it actually did, and catches drift before it becomes an incident.
Forecasting, not reacting
The same discipline that predicts freight volume ahead of the ship arriving predicts AI workload ahead of the need — capacity provisioned in advance, not scrambled together after something breaks.
Allocation, deliberately
Every agent's authority is allocated on purpose and reviewed continuously — granted incrementally, never assumed, the same way scarce operational capacity gets allocated in the real world.
Prioritization under constraint
Not everything can happen at once. The same triage logic that ranks shipments by real urgency ranks what an agent gets to touch first — and what waits for a human decision.
Performance, measured honestly
A metric that looks good on paper and fails in the real world is worthless. Same standard here: an agent's output isn't "done" until the evidence trail says it actually happened.
Where We Lead
-
1
Governed autonomy, not just automation
Our resident AI operator has its own identity, its own risk-tiered permission model, and a human-approval gate — audited, single-use, never silently skippable — on anything consequential. Most organizations are still writing policy documents about this; we built and run it.
-
2
Institutional memory as real infrastructure
A structured knowledge graph with tens of thousands of nodes and relationships — genuinely relational, scoped per person — not a wiki and not a vector-search afterthought. Our AI doesn't start every conversation from zero, and what it knows about one family member never leaks to another without consent.
-
3
Enterprise IT, family scale
Domain services, certificate infrastructure, centralized monitoring, and disciplined backup practice across a real self-managed server estate — the operational maturity of a company IT department, run end-to-end by a family.
-
4
Production software that actually ships
Financial and tax tooling used for real filings. A standalone data-recovery tool built to solve a real technical gap well enough to be a genuine product. Operational tooling running a real family business. Every one of these is maintained, not abandoned after the demo.
-
5
A deliberate operating philosophy, not an accident
We treat "a goal is a goal" as a real design constraint, not a slogan — every autonomous capability is scoped, reviewed, and kept legible to a human at human speed. That discipline is the actual differentiator here, more than any single piece of technology.
The Agent Factory
The current workforce is five governed agents — Scout, Builder, Codebox, ML and Watch — all active. Their work is visible through the internal Portal, including lifecycle, evidence, Green Zone recovery and the human approval boundary. Activity is not presented as accepted delivery until the evidence chain says it is.
Rather than one AI trying to do everything, Hoppe.home is building a factory model for AI capability: named, individually accountable roles — each scoped to what it's actually good at, each governed by the same approval discipline as everything else, each with its own budget. Capacity grows by adding well-defined roles under active supervision, not by loosening oversight.
- ScoutActive
- BuilderActive
- CodeboxActive
- MLActive
- WatchActive
Why this matters
It's the difference between "adding more automation and hoping" and building a real, accountable AI workforce. Every role is registered, reviewed, and correctable — the same way you'd manage people, not scripts.
That structure is what lets a family-run operation scale toward genuinely open-ended capability — new domains, new applications, new operational reach — without ever losing track of what any individual piece of it is actually doing.
This Past Month
A sample of what actually shipped, not just what got planned — roughly 800 commits in one month, closer to a full engineering sprint than a hobby project.
-
1
A flagship AI assistant, unified everywhere
One identity and one conversation history across desktop, phone and a web widget — pick up the same thread wherever you sign in.
-
2
The knowledge graph crossed 46,000 nodes
Real institutional memory, still growing from daily use rather than manual curation.
-
3
The first specialized agents on scheduled shifts
A researcher, a builder, an ML specialist — each individually accountable, each keeping its own record of lessons learned so mistakes aren't repeated.
-
4
A self-hosted alternative to GitHub
Private git hosting with its own attributable account for every human and AI contributor, plus a full issue/PR/branch-protection workflow.
-
5
A whole-estate security hardening pass
Every server and device brought to a consistent baseline in days, with continuous drift detection now watching for regressions going forward.
-
6
Real incidents, root-caused rather than patched
The unglamorous discipline that actually keeps a platform trustworthy — restart-and-hope was never the standard here.
What We've Actually Built
Not a roadmap. Not a pitch deck. Software running today, doing real work, for real people.
The Agent Factory
A governed, multi-agent AI workforce — named roles, individual accountability, human approval on anything consequential.
Hoppe Brain
A 46,000+ node knowledge graph — real institutional memory, scoped per person, growing from daily use.
HoppeOS
Our own hardened, domain-joined enterprise Linux — Desktop and Server editions, engineered and boot-tested in-house.
Codebox Go
A self-hosted alternative to GitHub — private git hosting with a real attributable identity for every human and AI contributor.
Tax & Financial Tooling
Software used for real filings and real household financial operations — not a demo, in production use.
Operational Business Tooling
ERP-style software running a real family business's day-to-day operations end to end.
World of JoschiCraft
A native multiplayer game the family builds together — the same engineering discipline, applied to something built for fun.
By the Numbers
Self-managed servers, Windows and Linux
Production applications in daily use
Knowledge graph nodes — real institutional memory
Resident AI operator, under direct human oversight
How We Operate
"A goal is a goal. Once a system has a goal, it will try to achieve it; productivity or performance pressure is secondary. AI systems should continuously review and question their own reasoning, work in partnership with humans, support weaker humans rather than optimise purely for metrics, and keep humans involved in understandable, human-speed decision-making."
This isn't a mission statement written after the fact. It's the actual constraint every capability here is designed against — and it's why "AI power house" doesn't mean "AI running unsupervised." The discipline is the point.