Greg Mushen built a personal AI agent that tracks meals, movement, and health data without making him live inside tracking apps. Instead of tapping through forms all day, he can message Hermes Agent in Telegram, send a photo or barcode, and let scheduled check-ins keep the record current.

In this episode, Michael and Greg break down what makes that system work—and where personal AI becomes much more than a chatbot.

In this episode:

• How Greg replaced manual food and activity logging with a conversational AI workflow

• How Hermes Agent uses Telegram, scheduled check-ins, and nutrition data to reduce tracking friction

• Why making a health system easier to use can matter more than adding another dashboard

• How AI helped audit 54 cited research papers behind a daylight-saving-time claim

• How Greg runs Gemma locally on NVIDIA Jetson AGX Orin hardware for sensitive health-data work

• Why local Whisper transcription, embeddings, and classification can keep private data off third-party APIs

• How Claude Code and OpenAI Codex change the way Greg builds and reviews software

• Where autonomous agents are useful today—and where human judgment still belongs

About Already Here: Michael Galpert meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.

Subscribe for more conversations with people already living with personal AI. Then comment with the first piece of health tracking you would hand to an agent.

Links mentioned in this episode:

Greg Mushen on X — https://x.com/gregmushen

Hermes Agent — https://github.com/NousResearch/hermes-agent

Telegram — https://telegram.org/

Cronometer — https://cronometer.com/

Pedometer++ — https://pedometer.app/

USDA FoodData Central — https://fdc.nal.usda.gov/

Apple Health — https://www.apple.com/ios/health/

Google Gemma — https://ai.google.dev/gemma/docs

NVIDIA Jetson AGX Orin — https://developer.nvidia.com/embedded/jetson-agx-orin

OpenAI Whisper — https://github.com/openai/whisper

Claude Code — https://code.claude.com/docs/

OpenAI Codex — https://developers.openai.com/codex/

Blake Eastman tried rebuilding the SaaS products his company depended on—from Riverside and Asana to bookkeeping software—using AI.

The tools worked for his personal workflow. Then he encountered the difference between building something for yourself and operating a real software company: infrastructure, edge cases, observability, maintenance, design, guardrails, and thousands of users.

In this episode:

- Why Blake became less eager to replace mature SaaS products

- The hidden work required to turn an AI prototype into reliable software

- How he decides what to build and what to leave alone

- Why he now prefers products with APIs, CLIs, and MCPs

- How PostHog and Sentry expose errors, usage, and LLM costs

- The 85% rule he uses to avoid endless AI experimentation

- How builder critiques reveal what polished productivity advice misses

- Why Blake believes “everything is connectable”

- Inside his source-bound research system, the Academic Holocron

Blake’s conclusion isn’t to stop building. It’s to build narrow tools that create personal leverage, respect the complexity of mature infrastructure, and connect the best existing products into a system shaped around how you actually work.

Already Here explores how people are already living and working with personal AI—and what changes when these tools become part of everyday life.

Links mentioned in this episode:

The Nonverbal Group: https://www.nonverbalgroup.com/

Blake’s newsletter: https://www.nonverbalgroup.com/newsletter

Blake on X: https://x.com/blakeeastman

Michael on X: https://x.com/msg

Riverside: https://riverside.com/

Asana: https://asana.com/

Bench: https://www.bench.co/

PostHog: https://posthog.com/

Sentry: https://sentry.io/welcome/

Warp: https://www.warp.dev/terminal

Aside: https://aside.com/

Upwork: https://www.upwork.com/

Claude Code: https://claude.com/product/claude-code

OpenClaw: https://openclaw.ai/

Lettera: https://lettera.md/

Agentation: https://www.agentation.com/

Priya Rose can walk her daughter to school, mention work in an ordinary conversation, and come home to find that an AI agent has done it. Then the same setup published a casual thought to her company’s live website.

Priya is a software engineer and cofounder of Fractal, where she teaches people to build useful personal AI systems. Her own setup listens to conversations she chooses to record, finds work hidden inside them, and tries to complete it—from coding changes and reports to grocery orders and tiny family apps.

In this episode:

• How casual conversations become real, completed work
• Why a VC student now makes a 45-minute report on the walk home
• The family app Priya built for her daughter—and would now rebuild in 20 minutes
• How a tweeted PDF-to-EPUB workflow became a Gumroad feature
• Why rambling can give an agent better context than a “perfect” prompt
• What happened when Priya’s agent shipped private musings to Fractal’s live site
• Why rules are not enough: separate identities, read-only access, and capped cards
• The planning, values, and judgment Priya deliberately keeps outside AI
• Why cheap failure can be more useful than waiting for perfect reliability

Priya’s central idea is simple: the best personal AI should fit into your life so naturally that talking becomes a form of doing. But the more an agent can act, the more its permissions—not just its instructions—must reflect the boundaries you actually want.

Links and resources:

Priya Rose: https://x.com/prigoose
Fractal: https://fractalnyc.com/
Zo Computer: https://www.zo.computer/
Otter: https://otter.ai/
Privacy.com: https://www.privacy.com/
Gumroad: https://gumroad.com/
Robin Sloan, “An app can be a home-cooked meal”: https://www.robinsloan.com/notes/home-cooked-app/

About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.

Subscribe for more conversations with people already living with personal AI.

Cathryn Lavery uses personal AI for the work that creates friction at home: family logistics, complicated travel, and information she meant to organize years ago. Her approach is concrete: give the assistant context, give it a narrow job, and preserve human approval for decisions that matter.

In this episode, Michael sees Cathryn’s AI house manager in action. It is a shared assistant her family can message to research options, prepare paperwork, update calendars, and handle recurring administration. During a fast move to San Francisco, it helped the family compare housing, find childcare, choose meals, and secure a place from a filling waitlist after Cathryn approved the sign-up.

Cathryn also shows how she made eight years of voice memos useful. Her system transcribes the recordings on her own computer, creates a searchable index, groups related themes, and adds new recordings each week.

In this episode:

• What Cathryn means by an AI house manager and how her family talks to it

• How the assistant researched housing and summer camps, then handled paperwork after a human decision

• How it helped manage meals, calendars, and the logistics of a rapid move

• How Cathryn compared airline-points options for travelers leaving from Austin, Dublin, and Belgium

• How separate assistant profiles keep shared family requests apart from Cathryn’s private tasks

• Why a Mac Mini serves as a familiar, dedicated computer where her assistants can run

• How local transcription keeps voice recordings on her computer while turning them into searchable text

• How she turned eight years of voice memos into usable personal context

• The boundary between automatic low-risk corrections and proposals Cathryn must approve

Cathryn does not begin with AI. She begins with the friction already present in her life, gives the agent enough context and tools to help, and preserves approval for the decisions that matter.

About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people manage daily work, how families make decisions, and where attention becomes available again.

Subscribe for more conversations with people already living with personal AI. Then comment with the household task you would hand to an AI house manager first.

Follow Cathryn on X: https://x.com/cathrynlavery

Follow Michael on X: https://x.com/msg

Links mentioned in this episode:

https://www.bestself.co/

https://openai.com/codex/

https://docs.anthropic.com/en/docs/claude-code/overview

https://github.com/cathrynlavery/voice-memo-organizer

https://www.apple.com/mac-mini/

https://openclaw.ai

Thanh Pham does not begin an AI setup with a long list of tools. He begins with one repeated task, one result a person can recognize, and one clear reason to use it again.

In this episode, Michael talks with Thanh about helping executives move from curiosity to practical use. Thanh demonstrates small workflows with obvious value, then adds more capability only when the person understands and trusts the result.

He also explains the difference between local and cloud AI. A local setup runs on a computer the person controls, which can provide more control over where data is handled. A cloud setup sends work to computing services run elsewhere, which may offer different capabilities but requires a deliberate decision about what information leaves the machine.

In this episode:

• Why Thanh teaches one useful skill before introducing a larger system

• How an automatic meeting briefing gathers email history, messages, and public research 30 minutes before a call

• How lead enrichment adds public details to a contact so a business can judge whether that lead is a good fit

• What an AI “agent” means here: software that can use approved tools and complete a sequence of steps

• Why Thanh gives one assistant responsibility for email, calendar, and meetings, while another handles research and project work

• The practical difference between running AI on your own computer and using a cloud service

• Thanh’s 10-80-10 model: define the job, let the system do the work, then review the result yourself

Thanh’s approach is easy to remember: choose one repeated task, make the first result immediately useful, and keep the final review with a person. His examples show that practical AI adoption depends less on presenting every possible tool than on giving each assistant a clear job and giving the person a result worth trusting.

About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in three places: how work is assigned, how decisions are made, and where people spend their attention.

Subscribe for more conversations with people already living with personal AI. Then comment with your biggest takeaway and the first repeated task you’d like to test.

Follow Thanh Pham on X: https://x.com/runsonai

Follow Michael Galpert on X: https://x.com/msg

Official links mentioned in this episode:

https://openclaw.ai/

https://github.com/NousResearch/hermes-agent

https://chatgpt.com/

https://claude.com/

https://openai.com/codex/

Matt Van Horn can turn a personal annoyance into a useful AI tool in a day. His method is simple: start with a problem you actually have, give the agent enough context, ship the smallest useful version, and let real users decide whether it should grow.

In this episode, Michael talks with Matt about three connected ideas: research, building, and publishing. Matt shows Last 30 Days, an open-source AI skill that searches recent posts on Reddit, X, and the web so an assistant can use what people are learning now—not only older articles. “Open source” means the instructions and code are public, so others can inspect them, use them, and suggest improvements.

Matt also demonstrates Printing Press. It examines how a website or online service works, then creates a command-line tool: a small set of written commands that an AI assistant can operate. His Flight Goat example uses that approach to compare nonstop flight options across multiple travelers and departure cities.

In this episode:

• Why old search results failed Matt when AI tools were changing week by week

• How Last 30 Days combines recent findings from Reddit, X, and the web

• How Matt built the first version during a day on a ski mountain

• What 50,000 GitHub stars represent—and what publishing made possible

• Why public work creates surface area for discovery, feedback, and contributions

• How Printing Press turns websites into tools an AI assistant can operate

• How Flight Goat compares complicated flight options across several travelers

• How Matt turns a personal annoyance into a tool, an article, or a public experiment

• Why the real lesson is the process, not the viral result

Matt’s system starts with a problem he personally wants solved. The agent helps him build it, publishing creates the surface area for discovery, and the community decides how large it can become.

About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people create, make decisions, and share their work.

Subscribe for more conversations with people already living with personal AI. Then comment with the problem you would try to solve in a day.

Links mentioned in this episode:

https://x.com/mvanhorn

https://github.com/mvanhorn/last30days-skill

https://printingpress.dev/

https://printingpress.dev/library/travel/flight-goat

https://github.com/openclaw/openclaw

https://openai.com/codex/

and X https://x.com/@alreadyhereshow

Sam Gaddis built an AI tool to help him and his wife fight better. It transcribes conflict in real time, tracks who is dominating the conversation, looks for destructive patterns, and can recommend a pause when things get too heated.

That deeply personal experiment is also the clearest window into how Sam builds with AI everywhere else: focused helpers, explicit access limits, and a person responsible for every consequential decision. In this episode, Michael sees how Sam uses Slack, email, meeting notes, repositories, nightly error checks, and voice capture to keep work moving without handing the system unlimited authority.

In this episode:

• How Sam’s relationship tool scores the way he and his wife handle conflict

• What the system learned when it showed Sam he was talking 60% of the time

• How the AI recognizes when a conversation is too heated and recommends a pause

• How Sam asks an assistant in Slack to find meeting notes, locate a client email, and prepare a reply in Gmail

• Why his default rule is “draft, don’t send”

• How Pointman gives his team a simple doorway into focused AI helpers

• How nightly checks identify failures and repair routine problems

• How Sam captures an idea by voice, researches it, and deliberately refines it before building

• Why his assistants can access his own software projects but not protected client work

Sam’s system is not one agent doing everything. It is a set of boundaries: draft before sending, personal repositories but not client repositories, fast capture before deliberate building, and a human still responsible for the relationship.

About Already Here: Michael meets people already living with personal AI in everyday life. We look at the tools, but the real story is what changes in how people work, make decisions, and direct their attention.

Subscribe for more conversations with people already living with personal AI. Then comment with the first safe experiment you would try.

Links mentioned in this episode:

https://runpoint.ai/

https://github.com/hermes-agent-org/hermes

https://openai.com/codex/

https://docs.anthropic.com/en/docs/claude-code/overview

https://www.granola.ai/