Overview of Talk Python to Me #567: Personal AI Agents for Pythonistas
In this episode, Michael Kennedy talks with Jeff Triplett about the strange-but-powerful world of personal AI agents you run yourself, especially Hermes — an open-source, always-on AI agent that lives on your own machine and can continuously perform tasks, build skills, manage memories, and interact with external tools. The conversation explores how these agents differ from chatbots and coding assistants, how they can be wired into Python/web workflows through MCP, CLIs, and APIs, and why they’re becoming genuinely useful for automation, personal productivity, and even content publishing.
What Hermes Is and Why It Feels Different
Hermes is presented as more than a chat assistant:
- It is an always-running self-hosted AI agent
- It can be given recurring jobs, tools, and long-term memory
- It can evolve its own capabilities over time by creating files, skills, and workflows
- It is meant to be talked to, not just prompted once
Jeff describes it as a system that can:
- Wake up on a schedule
- Check weather, calendars, and local events
- Produce daily briefings
- Manage reminders and recurring tasks
- Improve itself by adding tools and skills as needed
The key distinction discussed throughout the episode is that Hermes is not just “LLM chat with a schedule.” It behaves more like a continuously running, tool-using personal server.
Core Concepts: Skills, Memories, and Tool Use
A major theme is how Hermes organizes its behavior:
Skills
Skills are framed as deterministic instruction sets or task playbooks. They help make agent behavior more reliable and repeatable.
Memories
Memories store factual context the agent should remember long-term, such as:
- Names
- Household details
- Recurring preferences
- Facts learned from prior interactions
Tools and MCP
The hosts spend a lot of time on how powerful tool use is, especially via MCP (Model Context Protocol).
MCP lets an agent safely connect to external services and actions, such as:
- Google Workspace
- Contacts
- Calendar
- Cloudflare
- Home Assistant
- YouTube
- Django apps
- Other local or remote services
This makes the agent much more than a text generator — it becomes an actual operator.
OpenClaw, Claude Code, and Other Agent Platforms
Jeff and Michael compare Hermes to other agent ecosystems, especially:
- OpenClaw / OpenCode-style agents
- Claude Code
- ChatGPT / OpenAI tools
- Anthropic’s cloud-hosted tools
- OpenAI “Dots”
- Meta Muse
- CoWork and similar scheduled assistant systems
Their key takeaway:
- Some tools are closer to chat assistants with scheduling
- Others are true always-on agents with deeper tool access and iterative autonomy
They note that hosted tools are often limited to their own ecosystems, while self-hosted agents can use your local machine, browser, files, and network environment more flexibly.
Running Hermes: Desktop, Docker, and Self-Hosting
One practical part of the discussion is deployment.
Jeff explains that Hermes can be run:
- As a desktop app
- In Docker / Docker Compose
- On a dedicated always-on machine
- On small Linux boxes like Orange Pi devices
Michael notes he prefers isolated deployments, typically in containers with limited mounted folders, rather than giving the agent unrestricted access to his whole computer.
Key recommendation:
- Start small
- Use a safe, isolated environment
- Don’t run it on your work machine without protections
Why Local/Personal Agents Are So Useful
The hosts explain several reasons self-hosted agents are appealing:
Better access to real-world systems
Because the agent runs on your own infrastructure:
- It can use a normal residential IP
- It can launch a real browser
- It can access local tools and files
- It can interact with services that may block cloud bots
More flexible than pure chat
These agents can:
- Browse the web
- Fill forms
- Monitor feeds
- Update websites
- Trigger scripts
- Generate artifacts like RSS feeds, podcasts, and dashboards
Better for ongoing workflows
They are especially useful when tasks need to be:
- Repeated
- Monitored
- Improved over time
- Connected to your own systems
Model Choices: Ollama, Kimi, DeepSeek, and Others
A lot of the episode covers model selection and cost control.
Jeff says he uses Ollama because it gives him flexibility to choose among many models and can be used locally or via cloud-backed options. He also mentions experimenting with:
- Kimi K3
- DeepSeek models
- GLM 5.3 / GLM 5.3 Flash
- Other open models with vision or tool-calling capabilities
Michael notes that he has been using Kimi’s coding model and that model quality and tool-calling support matter more than raw “thinking” output for many agent workflows.
The practical takeaway:
- Use models that support tools, vision, and function calling
- Choose models based on the actual job, not just benchmark hype
- A good agent needs more than conversational ability
Real Use Cases They Shared
This episode is full of surprisingly concrete examples.
Daily briefings
Jeff uses Hermes to produce a daily briefing that includes:
- Weather
- Kid schedules
- Clothing suggestions
- Local sports events
- Traffic or neighborhood considerations
Lawn and garden planning
He fed it PDFs and product instructions so it could create:
- Lawn treatment schedules
- Seeding timelines
- Fertilizer recommendations
- Better timing recommendations than a commercial service
Article-to-audio conversion
Jeff described sending an article to Hermes and having it:
- Transcribe or clean it up
- Convert it to audio
- Produce a podcast-like feed for listening while driving
YouTube channel management
Michael uses an agent workflow to:
- Audit and update video metadata
- Keep show notes and titles in sync
- Reprocess or fix older uploads
- Automate YouTube channel maintenance
Home Assistant control
Jeff described a complex but successful workflow where Hermes:
- Helped diagnose Home Assistant setup issues
- Created service accounts and SSH keys
- Updated device firmware
- Fixed device behavior
- Flash-updated smart home hardware
Terminal / e-ink dashboard
He also built a custom Django-powered server for an e-ink “Terminal” device that renders dashboards and widgets for his home.
Voice, Watch, and Mobile Input
The episode emphasizes how well these systems work with voice.
Michael describes a setup where he can:
- Use his phone or Apple Watch to send commands
- Route dictated text to Hermes over Tailscale
- Trigger workflows hands-free
- Iterate on tasks while driving or away from the keyboard
Jeff also mentions using voice mode in tools like Moshi and other voice-enabled clients.
The broader point: voice is not just a convenience — it’s a very natural interface for these agents because you don’t need to produce a perfect prompt. You can just explain intent.
Determinism, Safety, and Good Guardrails
The hosts acknowledge the obvious downside of agentic systems: they can behave unpredictably.
Their solution is to reduce risk by:
- Using containerization
- Limiting filesystem and network access
- Requiring human approval before sensitive actions
- Letting the agent generate Python or CLI scripts rather than acting directly
- Using classification/screening models for requests
- Keeping “reply as me” behavior behind explicit rules
Michael’s agent persona “Haley” is a good example — it can help answer or draft responses, but it does not autonomously send messages without approval.
Notable Insights
“Make the non-deterministic thing write deterministic code”
This is one of the episode’s strongest practical ideas. If the agent can’t reliably do the whole task itself, have it:
- Generate a Python script or CLI wrapper
- Verify the code
- Reuse that code for repeatable behavior
CLIs are perfect agent interfaces
Both hosts emphasize that well-designed CLIs are great for agents because they can:
- Inspect help text
- Learn options automatically
- Chain tools together
- Avoid UI brittleness
Agents can evolve organically
A repeated theme is that the system can start small and, over time, accumulate:
- Skills
- Files
- Memories
- Workflows
- Specialized helper scripts
Practical Advice for Getting Started
Jeff’s advice to listeners interested in trying this out:
- Start with the desktop app
- Run it in a safe environment
- Don’t spend money just to experiment
- Try Docker if you’re comfortable with it
- Keep the system isolated until you understand the permissions model
Michael’s implicit advice:
- Start with a simple integration
- Use MCP where possible
- Prefer local control and explicit approval for important actions
Closing Thoughts
The episode ends with a fun cameo from Hermes itself, which introduces itself and gives a cheerful Python-themed signoff. That fits the whole tone of the conversation: this tech is weird, a little unsettling, but genuinely exciting.
The big takeaway is that personal AI agents are moving beyond “chat with a model” into always-on, self-improving automation systems that can operate your own tools, websites, and workflows. For Python developers, they open up a new style of building software: not just apps that execute code, but systems that learn how to help you over time.