In practice
At home
The same principles, on a small scale
What I write about on these pages, I also try at home. A personal agent, a smart home and a small server run on the same layers, protocols and controls. Small enough to change in an evening, real enough to learn from. This page shows functions, principles and the tools I use, not addresses, devices or personal data.
The house in four layers
A personal agent, a smart home and a small server, on the same four layers as everything else in Learning to Connect.
- Business layerWhat the household needsAt home
- Comfort
- Energy
- Media
- Photos
- Planning
- Sport
The principle it testsStart from the job, not the gadget. Every automation answers a household need, and I decide with the household.
- Agentic layerOne personal agent, with specialistsAt home
- Personal agent
- Soul, memory & skills
- Specialists
- Scheduled briefings
- Task board with review
The principle it testsEach agent has a role, an owner and limits. Specialists build, research and review; the owner is always me.
- Data & integration layerOne hub, open protocolsAt home
- Smart-home hub
- Open device standards
- MCP
- Connectors
- Knowledge vault
The principle it testsIntegrate once. Devices from many vendors meet in one hub; the agent reaches tools and sources through MCP and connectors.
- Platform layerA small platform I aim to see and stopAt home
- Storage & containers
- Agent workstation
- Mesh network
- Private remote access
- Monitoring
The principle it testsSmall enough to see and stop. A small home server, and an agent with an identity of its own.
The same layers, a smaller scale
The four layers of the layered strategy fit a house as well as a firm. Only the owners differ: at home, they are all me.
Explored in Layered Strategy
- Layered strategy
A hub is an integration layer
A smart-home hub does at home what an integration layer does in a firm: one model over many vendors, so a device can change without changing everything else.
Explored in Service oriented architecture
- Integration layer
- Loose coupling
What runs at home
A working lab, not a slide deck. It is where I test what agents can safely do, before I advise on it.
- 50+containers
- 100+IoT nodes
- 3,000+smart-home entities
- Multi-LLMlocal and cloud
A personal agent, many models
Hermes Agent handles the agentic work. Local and cloud models run side by side, and the task decides which one answers.
Explored in Agentic AI
- Hermes Agent
- OpenAI
- Anthropic
- Local models
The physical world
Home Assistant covers the physical world: 100+ IoT nodes and 3,000+ entities from many vendors behind one model.
Explored in Digital & AI Integration
- Home Assistant
- IoT
- Automations
Agents reach real systems
Through MCP tools and event-driven automation, never by handing over a password.
Explored in Integration Landscape
- MCP Tools
- n8n
- Event-driven
- Nginx
Who and what may do what
A private identity provider with zero-trust access decides, for people and for agents alike.
Explored in Identity & Access
- Private IdP
- Zero-Trust Access
- Networking
Run it like a platform
A private cloud of 50+ containers, managed in one place, backed up and monitored.
Explored in Platform & Operations
- Dockhand
- Duplicati
- Monitoring
- Containers
One request, end to end
How a request travels through the layers, using the building of this website as the example.
- I ask
One prompt, in a chat.
- On my phone or the desktop
- Plain language, no ticket
- Images and documents attached
- It plans
The right skill and context.
- Loads the matching skill
- Reads only the sources it needs
- Breaks the work into steps
- It builds
On a branch, never on live.
- Scripts instead of hand edits
- Measures layout and contrast
- Screenshots on every width
- A second agent checks
An independent judge.
- A separate brief
- Primary sources only
- Errors, overclaims and nits
- I decide
My rule: nothing goes live without me.
- A review package in my chat
- My explicit go-live
- A tagged version, never forced
This website is built this way
Recent versions of these pages went through these five steps: built by the agent on a branch, checked by a second agent, released by me.
Explored in Agentic Coding
- Agentic coding
- Versioning
An outside judge decides
The agent never grades its own work. Measurements, primary sources and a second agent with a separate brief do, and I make the call.
Explored in Scale: quality and alignment
- Evaluation
- Fact-check
What my agent may do
Four levels, my working rules, set by impact. The higher the impact, the more I stay in the loop.
- Level 1Acts on its ownLow impact and reversible
- Search, read and summarise sources
- Read and sort its own mailbox
- Draft documents, notes and code
- Work on a branch
- Run scheduled briefings
My approval: none, I review the log
- Level 2Prepares, I approveSpeaks or publishes for me
- Send email on my behalf
- Publish a new version of this site
- Correct what it remembers
My approval: per action
- Level 3Approval and rollbackChanges what everything runs on
- Change the home server or its containers
- Change the network or the browser
- Change its own runtime
My approval: with evidence and a way back
- Level 4Never on its ownCosts money or cannot be undone
- Spend money
- Act irreversibly
- Change credentials or permissions
I do it myself
Autonomy follows impact
The rule is not about the task but about its impact: can it be undone, does it speak for me, does it change what everything runs on?
Explored in How autonomous will agents be?
- Impact
- Reversibility
An identity of its own
The agent works under an identity of its own, with its own rights, so what it does can be traced back to the agent.
Explored in Act on someone's behalf
- Own identity
- Least privilege
Ambition never raises permissions
Asking the agent to aim higher raises the standard of the work, never its rights.
Explored in Build: control from day one
- Guardrails
Memory and knowledge, governed like data
Four kinds of knowledge, four sets of rules. Most of the quality of an agent lives here.
- Sources
The original, not the write-up.
- Primary sources first
- News is how we found it, not proof
- Reviews are evidence, not truth
- Knowledge
Plain files I can read.
- Markdown notes and handoffs
- Dated, with their source
- Unknown stays unknown
- Memory
Facts and preferences, with provenance.
- Source and validity per memory
- A librarian proposes corrections
- A second agent validates, I approve
- Skills
Know-how, loaded when needed.
- Procedures and pitfalls
- My preferences per kind of work
- Improved after every hard task
Documentation first
The home lab itself is documented this way: what is verified carries a date, what is not stays marked as unknown.
Explored in Govern by design
- Evidence
- Dated
Memory is data too
What an agent remembers shapes what it does. So memory gets owners, sources, corrections and deletion, like any other data.
Explored in Build: soul, memory & skills
- Provenance
- Correction
What the house taught me
Four lessons that hold at home as much as at work.
Integration beats intelligence
The hard part is rarely the model. It is reaching the right data and tools, with the right rights.
Explored in Digital & AI Integration
- Integration
- Access
Evidence before claims
An empty list is not proof that nothing is there, and a running service is not proof that a chain works. Check before you claim.
- Verification
Keep the context small
Split work into steps, pass only what is needed and compress tool output. Quality goes up and token costs come down.
Explored in Where the logic lives
- Context
- Cost
Choose depth on purpose
Several models, local and external. Deeper reasoning for ambiguous or high-impact work, chosen deliberately rather than routed automatically.
Explored in One gateway per kind of traffic
- Models
- Routing