Bauhaus illustration of a person and home connected to a calendar, shopping cart, documents and smart-home network.

Claude Code and Obsidian make a surprisingly useful household assistant. But the more interesting question is what happens when you add existing home-management software, a persistent agent harness, and a local language model. The result might be the first genuinely practical family AI.

There is something rather satisfying about watching people independently invent almost exactly the same thing.

Especially when the invention is not another AI startup promising to revolutionize an industry, but a system for remembering when the washing machine warranty expires.

A genuinely useful application of artificial intelligence.

Finally.

I recently came across an episode of How I AI featuring Scott Farrar, a mathematics educator and parent who has built what he calls a household brain using Claude Code and Obsidian.

The idea is wonderfully practical.

Household appliances.

Warranties.

Insurance documents.

Maintenance projects.

Repairs.

Things that need doing.

All stored in a collection of Markdown files.

Claude Code can read the information, help organize it, and answer questions about what is happening around the house.

Obsidian provides a visible, editable knowledge base.

And a DAKboard display makes current tasks and completed projects visible to the family.

No artificial general intelligence required.

Just a system that remembers which appliance is broken, whether it's still under warranty, and what you promised to do about it three weeks ago.

That alone is an improvement over a surprising amount of human household management.

But the story made me think about a larger question.

If we were designing a permanent AI assistant for an entire family today, would we really start with a coding agent and a folder of Markdown files?

Or would we build something slightly different?

The Household Memory Problem

The most interesting part of Farrar's system is not the AI model.

It's the persistent memory.

Ordinary chatbot conversations are poorly suited to managing a household over several years.

You ask about an insurance policy.

The model gives you advice.

Three months later, you return with another question.

Now you need to explain which insurance company you're using, when the policy renews, what coverage you selected, and what happened during the previous conversation.

The problem is not that the model lacks intelligence.

It's that the household has a history.

And that history needs somewhere reliable to live.

Farrar's solution is deliberately straightforward.

Use ordinary files.

Keep appliance information, warranties, documents, and projects in an Obsidian vault.

Allow Claude Code to inspect and update those records.

When a new conversation starts, the assistant can retrieve relevant information rather than asking the family to reconstruct everything from memory.

One particularly useful example involves a refrigerator.

Instead of asking a generic chatbot why a fridge might be malfunctioning, the household assistant can consult the actual appliance record.

Which model is it?

When was it purchased?

Is the warranty still valid?

Has something similar happened before?

What did the repair technician say last time?

Those details transform the quality of the conversation.

The model no longer has to provide generic advice to a hypothetical household.

It can work from documented information about a particular appliance.

This is a much more important capability than making the assistant sound intelligent.

The real value comes from giving the model access to the right facts at the right moment.

The Computer Should Remember So the Family Doesn't Have To

The same principle applies to almost everything around the house.

An insurance renewal is not a single question.

It's a project.

There are documents to compare.

Questions to ask.

Decisions to make.

Deadlines to remember.

Emails to send.

And possibly several competing offers that make the entire insurance industry seem designed to discourage careful reading.

A home repair has a similar structure.

Something breaks.

You inspect the problem.

Find documentation.

Contact someone.

Receive an estimate.

Decide whether to proceed.

Wait for an appointment.

Confirm the work.

Store the receipt.

Update the maintenance history.

Most of the difficulty is not intellectual.

It's continuity.

Remembering what has happened and what needs to happen next.

An AI assistant becomes useful when it can preserve that continuity without requiring someone to maintain a complicated filing system manually.

Farrar's experience contains a good example of this.

His system organizes tasks, estimates, priorities, and project notes, then displays useful information on a wall-mounted dashboard.

It can even show completed work.

Which is an underrated feature.

A household task system that only displays unfinished work can become a permanent exhibition of personal inadequacy.

Sometimes it's nice to be reminded that you've actually fixed something.

But if the goal is a shared family assistant, I think there's another architectural question worth asking.

Why should everyone have to open Claude Code?

Telegram Is a Better Interface Than a Terminal

Claude Code is an excellent environment for developing software and working with files.

Codex serves a similar class of coding and development tasks.

Both can be extended with tools and automation.

But neither would be my first choice as the everyday interface for an entire household.

Imagine telling your family:

To add milk to the shopping list, open the coding environment, navigate to the household repository, and ask the agent to update the appropriate Markdown file.

It's technically possible.

It's also a fairly reliable way to ensure that everyone continues writing shopping lists on random pieces of paper.

A family needs an interface that people already use.

For many households, a messenger is the obvious choice.

Telegram is particularly convenient because it provides a familiar chat interface and a Bot API.

Someone can send a message:

We're almost out of coffee.

Or:

When does the car insurance expire?

Or:

Remind us to call the plumber on Monday.

Or simply send a photograph of an appliance label.

The assistant can interpret the request and interact with the underlying systems.

No terminal.

No repository.

No need for every family member to understand Markdown, Python, or agent configuration.

This is an important design principle.

The people using an assistant should not have to understand the infrastructure that makes it work.

A household assistant should disappear into familiar activities.

Not turn everyone into a part-time software engineer.

Of course, Telegram is not the only possible interface.

A mobile app, web dashboard, voice assistant, or another messenger could serve the same purpose.

The important thing is the separation.

The interface is how the family communicates.

It should not determine how the entire system is built.

We Already Have Software for Running a Household

There is another reason not to build everything inside an Obsidian vault.

A surprising amount of excellent home-management software already exists.

Consider four open-source projects.

Home Assistant handles smart-home devices, sensors, and automations. It can coordinate lights, heating, electricity monitoring, alarms, and countless integrations.

Grocy is a household-management application for groceries, food inventory, shopping lists, recipes, chores, and related tasks.

Paperless-ngx manages documents. It can ingest files, perform OCR, index their content, and make them searchable.

Homebox is designed for home inventory: possessions, appliances, locations, purchase details, warranties, maintenance records, and associated documentation.

These systems already solve many of the problems a household AI would otherwise need to solve from scratch.

Why ask a language model to invent a new way of tracking food inventory when Grocy already has one?

Why build an entire document-management application around an LLM when Paperless-ngx can handle scanning, OCR, indexing, and retrieval?

Why store every appliance as a collection of improvised Markdown fields when Homebox already understands inventories, purchases, and warranties?

And why let the model write ad hoc smart-home scripts when Home Assistant already provides a mature automation environment?

The better approach is often to leave those applications responsible for their own domains.

Then connect them to an assistant.

Most of these systems expose APIs, and some have MCP integrations or community-built connectors.

MCP, the Model Context Protocol, provides a standardized way to expose tools and resources to compatible AI systems.

But an MCP connector isn't magic.

Each integration still needs the right permissions, reliable data handling, and an explicit contract for what the agent is allowed to do.

The architecture becomes much clearer.

The inventory system stores the inventory.

The document system stores documents.

The home automation system controls devices.

And the AI assistant helps the family interact with all of them.

It becomes a coordinating layer.

Not a replacement for every piece of household software.

The Agent Harness Is the Important Part

This is where the distinction between an AI model and an AI agent becomes useful.

A model generates responses.

An agent system does considerably more.

It manages conversations.

Maintains persistent context.

Calls tools.

Interacts with external services.

Runs scheduled tasks.

Tracks ongoing work.

And determines when an action requires additional information or human approval.

The surrounding software is often called an agent harness.

For a household assistant, the harness may matter more than the difference between two similarly capable models.

The family needs the system to remain available.

Remember ongoing projects.

Handle requests from different people.

Use the appropriate tools.

Recover from errors.

Avoid performing dangerous actions without permission.

And continue working after the conversation has ended.

A coding agent can help build this system.

But a purpose-built, persistent agent runtime is a more natural foundation for operating it.

The model itself can still be Claude.

Or Gemma.

Or another capable local or hosted model.

The interface can still be Telegram.

And the underlying data can remain in existing home-management applications.

The harness connects these pieces.

This is a much cleaner division of responsibility than making one coding environment act as the database, memory system, messaging interface, scheduler, and automation runtime simultaneously.

Why Hermes Agent Is Interesting

One project I find especially interesting for this architecture is Hermes Agent, developed by Nous Research.

Hermes is designed as a persistent agent rather than a coding assistant that happens to be useful for unrelated tasks.

It supports messaging gateways, scheduled work, tool integrations, different model providers, and persistent memory.

But its most interesting feature may be the way it handles learning from experience.

Hermes can maintain durable memories about users and recurring situations.

It can also create and update reusable skills.

When the agent discovers how to complete a particular workflow, it can preserve the procedure for future use.

Suppose the household assistant has to find the warranty for a washing machine.

It learns which inventory system contains the appliance.

Which document repository stores the receipt.

How the appliance identifier relates to the warranty document.

And what information is needed before contacting the manufacturer.

If the procedure is useful again, it can be stored as a skill.

Next time, the agent doesn't have to rediscover the entire process.

The same idea applies to recurring household tasks.

Preparing a shopping list.

Checking insurance renewals.

Finding maintenance instructions.

Organizing documents.

Reviewing overdue projects.

This kind of procedural memory makes more sense for a household assistant than expecting a model to improvise every process indefinitely.

An important distinction, however: this is not the model magically retraining its neural-network weights after every conversation.

The improvement mainly comes from maintaining files, memories, skills, and procedures that the agent can retrieve and apply later.

That is much more understandable and controllable.

And for practical household work, it may be all we need.

A Household Assistant Should Learn Carefully

There is a downside to persistent memory.

Incorrect information can become persistent too.

Suppose the assistant misreads an insurance renewal date.

It stores the wrong date.

Three months later, it confidently reminds the family about the wrong deadline.

The next conversation appears well grounded because the answer came from memory.

Unfortunately, the memory is wrong.

The same problem occurs with learned procedures.

An agent discovers a way to update a database.

It saves the steps.

Later, the database changes.

The old procedure continues running.

And now the system is efficiently making the same mistake over and over.

This is why self-improving agent systems need controls.

Facts should retain links to their sources.

Important records need timestamps.

Contradictions should be visible.

Stored procedures need versioning and validation.

And changes to sensitive workflows should require approval.

Hermes provides options for memory management, skill review, user authorization, and command approvals.

These features are useful.

But enabling a feature does not guarantee that the entire household system is safe.

It still needs to be configured correctly.

A persistent agent should learn enough to become more useful.

Not so freely that every misunderstanding becomes part of the family's permanent digital history.

Privacy: Where Does the Household Actually Live?

Now comes the uncomfortable question.

Where does all this information go?

It's easy to describe a system as private because the documents are stored locally.

An Obsidian vault on your own computer.

A Paperless-ngx server in the house.

Homebox running in Docker.

A local database.

Very reassuring.

But if a cloud model processes those documents, the relevant context has to be sent to the model provider.

Not necessarily the entire archive.

Usually, the system retrieves and sends only the portions it considers relevant.

But the distinction matters less if those portions contain sensitive information.

An insurance policy.

A passport number.

A medical document.

Financial records.

The names and routines of family members.

A local database does not automatically make an AI application local.

The privacy boundary extends to the inference system, tools, logs, backups, and communication channels.

And this is one reason local language models have become increasingly interesting.

The goal is not necessarily to achieve frontier-level reasoning performance.

It's to perform ordinary, private tasks without constantly transferring the family's internal context to another company's servers.

For many household operations, that is a very reasonable trade-off.

The Case for a Small Local Model

One recent home-assistant setup described using a local Gemma 12B model running on an older graphics card.

The implementation was apparently built with whatever hardware was available.

Not an expensive AI workstation.

Not a rack of enterprise GPUs.

Just a practical local model running sufficiently quickly for the tasks that mattered.

And I find that more interesting than another demonstration involving an enormous model hosted in a data center.

Because what does a household assistant actually need to do?

Find the refrigerator warranty.

Read a maintenance record.

Update a shopping list.

Summarize a project.

Create a reminder.

Explain which documents are missing.

Call an existing API.

These are not necessarily tasks requiring the strongest reasoning model available.

A smaller model with good tool-use behavior, reliable retrieval, and appropriate validation may be entirely sufficient.

That doesn't mean every 12B model will perform well.

Tool calling, multi-step planning, context length, multilingual understanding, and error recovery vary considerably.

And the quality of the harness matters.

But the principle is sound.

A well-integrated smaller model may be more useful than a brilliant model that has no reliable access to the household's actual information.

There is also a practical benefit.

Local inference can keep the bulk of sensitive context inside the household's own infrastructure.

The user retains more control over the model, the logs, and when external services are contacted.

Not perfect privacy.

But a meaningful reduction in exposure.

What About a 30B Model?

The hardware story is becoming more interesting.

Meta's Muse Glimmer 30B is an example of a model designed specifically for local agentic work.

It focuses on tool use, multi-step tasks, failure recovery, and operation on consumer hardware.

That is a particularly relevant design target for home assistants.

A model that reliably uses tools may provide more practical value than one that produces beautiful essays but repeatedly calls the wrong API.

Muse Glimmer's published quantized builds occupy roughly 17–20 GB.

This creates a small complication for the popular RTX 5080.

The standard card has 16 GB of video memory.

So although a 5080 can be useful for local inference, a typical published 4-bit Glimmer build will not fit entirely within its VRAM once runtime overhead is considered.

You may need more aggressive quantization, partial CPU offloading, or a different hardware configuration.

And the resulting speed will depend on context length, runtime, memory bandwidth, and other details.

The model may still be practical.

But it's better to understand the constraints than announce that any 30B model will run effortlessly on any recent GPU.

The broader point remains.

Thirty-billion-parameter models are becoming increasingly realistic for personal infrastructure.

And models specifically optimized for agentic tasks may be very well suited to the relatively narrow workflows of household automation.

Why AMD Halo Suddenly Makes Sense

The next step is hardware with much larger amounts of memory accessible to the GPU.

AMD's Ryzen AI Max platform, often associated with the Strix Halo family, is particularly interesting here.

Some systems support 128 GB of unified memory.

AMD's own documentation describes configurations allowing up to 96 GB to be allocated as graphics memory.

That doesn't make such a machine equivalent to a high-end data-center GPU.

Memory bandwidth, compute capability, software support, and power constraints remain important.

But the larger memory pool makes it possible to experiment with model sizes that would be difficult to accommodate on conventional consumer graphics cards.

A 120B dense model at approximately four-bit precision may require something in the region of 60 GB for weights alone, plus quantization metadata, runtime memory, and the KV cache.

The exact requirement depends on the architecture and implementation.

Such a model can therefore be feasible in a sufficiently large unified-memory system.

Feasible does not necessarily mean fast.

And more parameters do not guarantee better agent behavior.

A well-trained 30B model may outperform a larger general-purpose model on specific tool-use tasks.

Still, the hardware is becoming compelling.

For years, local AI involved accepting very substantial limitations.

Now it is increasingly possible to run capable models at home without needing a cloud inference service for every request.

For a household assistant, this may be a more important development than the arrival of another giant frontier model.

The goal is not to reproduce an entire AI research laboratory in the utility room.

It is to make ordinary tasks reliable, affordable, and private enough for daily use.

Telegram Still Isn't Private Infrastructure

There's an obvious objection to this architecture.

If the assistant uses Telegram, aren't we still relying on an external service?

Yes.

And this deserves a direct answer.

Telegram bot conversations are not ordinary end-to-end encrypted Secret Chats.

Messages pass through Telegram's cloud infrastructure and Bot API.

The bot receives the messages needed to process its conversations.

So even if the LLM runs entirely on local hardware, information written into the Telegram chat still passes through an external platform.

This creates a distinction between two kinds of privacy.

One is keeping the household knowledge base and model inference local.

The other is protecting the communication channel.

A Telegram-based assistant can substantially reduce the information shared with cloud AI providers.

But it does not provide a completely local or end-to-end encrypted system.

The practical response is to minimize what the messenger needs to carry.

If someone asks when the washing machine warranty expires, the bot can retrieve the date locally and send only the answer.

It does not need to upload the entire appliance record or insurance archive into the chat.

Sensitive documents can remain accessible only through an authenticated local interface.

And especially sensitive operations can require a separate confirmation step outside the messenger.

The same principle applies to logs.

A system that keeps documents local but records every complete document in its debugging output has achieved a rather peculiar definition of privacy.

Good architecture should minimize unnecessary exposure throughout the entire process.

Not simply move the model to a different computer.

One Family, Several Users, Different Permissions

A family assistant introduces another challenge that is easy to overlook.

A household is not one user.

Different family members may share some information while keeping other information private.

Everyone may need access to the shopping list.

But not everyone should necessarily have access to every financial document, private message, or account.

Children may need reminders and access to household chores.

They probably shouldn't have permission to change the home's security configuration.

A guest might ask what time dinner is planned.

They should not be able to retrieve the household's insurance records.

And even adults sharing a household may want some information to remain private.

This makes authorization more important than conversational intelligence.

The system needs to know who is asking.

Which information they can access.

Which actions they can request.

And which operations require approval.

Hermes supports user authorization and messaging-platform allowlists, along with approval mechanisms for potentially dangerous commands.

Those are useful building blocks.

But the household still needs an explicit permission design across the underlying applications.

A valid Telegram user is not automatically entitled to every document accessible to the agent.

And an authenticated request is not automatically an authorized request.

Ideally, tools would expose the minimum access needed for the person and task.

Read the warranty.

Add an item to the shopping list.

Suggest a calendar change.

But don't silently delete documents, share private files, or disable security devices.

The family assistant should behave less like an all-powerful administrator and more like a careful household coordinator.

Competent enough to help.

Restricted enough to avoid becoming a new domestic security problem.

The Best Architecture Is Mostly Boring

If I were designing a household assistant today, I would keep the underlying structure surprisingly conventional.

A messaging interface handles conversation.

A persistent agent harness coordinates the tools and memory.

A local model handles ordinary interpretation and planning.

Existing applications store authoritative household information.

A scheduler handles reminders and routine checks.

And a permission layer decides which actions the assistant may perform.

The architecture could look like this:

Family members
      |
Telegram / voice / web interface
      |
Persistent agent harness
      |
Local language model
      |
Approved tools and permissions
      |
+-----------------------------+
| Home Assistant              |
| Grocy                       |
| Paperless-ngx               |
| Homebox                     |
| Calendar and task systems   |
| Local memory and skills     |
+-----------------------------+
      |
Scheduled checks and updates
      |
Notifications / household display

The diagram isn't particularly exciting.

There are no swarms of agents debating which one should become the household CEO.

No autonomous board of directors.

No elaborate hierarchy of digital servants negotiating the optimal strategy for buying milk.

And that's probably a good thing.

A home doesn't need an autonomous corporation.

It needs a system that reliably handles small, recurring obligations.

The agent should be able to understand a request, find the right system, perform an authorized operation, and confirm the result.

If the request is unclear, it should ask.

If the information is missing, it should say so.

If the operation could cause harm, it should require approval.

And if a deterministic script can do the work, there is no particular reason to involve the model every time.

This is where the architecture becomes both cheaper and more reliable.

Intelligence is used where interpretation matters.

Ordinary software handles predictable execution.

The Assistant Should Eventually Need Less Supervision

The most promising aspect of persistent agents is that they can gradually turn repeated work into established procedures.

At first, the assistant needs guidance.

Where are the appliance records?

How are receipts organized?

Which calendar should be used?

Who approves purchases?

What counts as an urgent repair?

Over time, the system can preserve answers and procedures.

It becomes familiar with recurring tasks.

It learns which tools are appropriate.

It develops a more useful picture of the household's routines.

But the goal should not be unlimited autonomy.

It should be a gradual increase in reliability within defined boundaries.

For example, an assistant that has successfully added hundreds of grocery items to an approved shopping list probably does not need confirmation for every additional carton of milk.

But that experience does not justify allowing it to place expensive online orders.

Similarly, a system that has reliably extracted warranty dates should still show the original document when a financially consequential decision depends on the information.

Autonomy should be earned through evidence.

And it should remain specific to the action.

Not awarded as a general promotion from helpful assistant to unrestricted administrator.

This also makes the system easier to maintain.

Every recurring task can have a clear owner, input, output, validation rule, and failure condition.

The agent can help improve those procedures.

But it doesn't need to reinvent them on every request.

From Smart Home to Household Intelligence

Home automation has existed for decades.

We can turn lights on with our phones.

Automate heating.

Monitor electricity consumption.

Receive notifications from sensors.

Create elaborate routines involving motion detectors and smart plugs.

But that is not the same thing as helping a family manage its life.

A smart home knows the temperature of the living room.

A household assistant should know that the heating system was serviced last October, that the warranty expires next year, and that an unusual noise needs checking.

A smart home can detect that a washing machine has stopped.

A household assistant could connect that event to the appliance history and help decide whether the situation requires action.

A smart home can send a notification when a sensor detects water.

A household assistant might identify the relevant shutoff instructions, locate the emergency contact, and prepare a concise summary for the person who needs to respond.

But this requires boundaries.

A safety-critical system should not depend on an LLM deciding whether a leak deserves attention.

The sensor, alarm, and shutoff automation should work independently.

The model can help with interpretation and coordination after the reliable system has done its job.

This is an important difference.

AI should complement existing safety mechanisms, not replace them with probabilistic judgment.

The most useful home assistant may therefore be less about controlling smart devices through natural language and more about coordinating the information, people, and processes surrounding ordinary household life.

The Real Product Is Peace of Mind

The interesting thing about Scott Farrar's household setup is that it doesn't attempt to automate everything.

It makes work visible.

It preserves information.

It suggests the next action.

And it helps the family make progress on tasks that might otherwise remain unfinished.

That is a rather good definition of useful automation.

The objective isn't to remove every human decision.

It's to reduce the amount of attention required to remember what needs deciding.

A household contains hundreds of small obligations.

Some are trivial.

Some are expensive.

Some are urgent.

Most are easy to forget.

And very few justify building a complicated software system from scratch.

But collectively, they consume an enormous amount of mental bandwidth.

A good household assistant can reduce that burden.

It can remember what we forget.

Find documents we would otherwise spend half an hour searching for.

Keep track of unfinished projects.

Surface deadlines.

Suggest practical next steps.

And coordinate existing tools without demanding that every family member become an expert in the underlying technology.

The ideal experience is not particularly futuristic.

Someone asks a question.

The assistant knows where to look.

It retrieves the correct information.

And the family can move on.

No elaborate demonstration.

No ten-agent orchestration trace.

No inspirational announcement that the future of artificial intelligence has arrived.

Just the washing machine warranty.

In the right place.

At the right time.

Which, frankly, might be more useful than most of the AI products currently competing for our attention.

The Future of Personal AI May Be Local and Rather Ordinary

I suspect we will see more household AI systems built this way.

Not necessarily as one universal product.

Perhaps as a collection of existing open-source applications connected through a persistent agent.

Different interfaces for different families.

Different models depending on hardware and privacy requirements.

Some entirely local.

Some hybrid.

Some using cloud models only for difficult requests.

And some built around equipment that has been sitting under a desk for years.

The important point is that the technology is becoming sufficiently accessible for people to create assistants tailored to their actual lives.

We no longer need every household to accept the same proprietary smart-home ecosystem.

Nor do we need to send every private document to a frontier model simply to extract a date.

The software already exists for managing many parts of domestic life.

The AI layer is increasingly capable of connecting those parts.

And local models are becoming practical for tasks that don't require frontier-level reasoning.

The remaining challenges are not primarily about generating more impressive sentences.

They are about reliability.

Permissions.

Memory.

Interoperability.

Security.

Data ownership.

And designing interfaces that ordinary people actually want to use.

These are less glamorous problems.

They are also the ones that determine whether a system becomes useful beyond its first impressive demonstration.

The ideal family AI probably doesn't need to be a genius.

It needs to be trustworthy.

It should know where the documents are.

Remember which projects remain unfinished.

Understand who is allowed to do what.

And avoid making things worse while trying to help.

Perhaps it should even know when to leave everyone alone.

After all, the point of an intelligent household assistant isn't to turn family life into another software project that requires constant maintenance.

It's to make the existing work of living together a little easier.

And if that means running a modest local model on an old GPU, communicating through a familiar messenger, and delegating most of the real work to boring, reliable applications, so much the better.

The smartest home is not necessarily the one with the most powerful AI.

It may simply be the one that finally remembers everything we keep forgetting.

Without requiring us to explain it all again tomorrow.

Sources and further reading

Keep reading

Explore the writing archive →

Stay in touch

More essays and updates on ABVX Substack.

Read and subscribe on Substack →