After applying for a job, I need to enter the company, position, and application date in a table. When I want to catch up on my diary in the evening, I have to find today's page. When an email arrives from my university, I still need to work out whether it requires any action. None of these tasks is difficult on its own, but the information is scattered, and I keep having to organize it again.
I wanted a personal assistant I could reach through everyday conversation: tell her what happened and what I wanted to get done, let her find the information and use the tools, then receive a result I could check. The service should keep running after I shut down my computer, and I should be able to use it from my phone. She should also remember explicit preferences, have a consistent way of speaking, and remind me at appropriate moments, rather than only wait for the next instruction.
I call this assistant Tina. She runs on Hermes and talks with me through Feishu; LifeOS provides the accompanying domain data and methods for using it. This article starts with why I built the system myself, then covers the system, domain package, Agent execution, personality and memory, and how email and schedules can enter the conversation proactively. If you are working on something similar, I would be glad to exchange ideas.
1 Project Background: Why I Wanted to Build My Own Personal Assistant
Usage Needs: A Long-Term Assistant for Everyday Information
A typical request looks like this:
Add this job listing to my job tracker. I applied yesterday, and it is an internship.
This sentence contains both external information and personal facts. The job page provides the company, requirements, and location; my message supplies the application date, status, and employment type. The assistant needs to retrieve the page, find the appropriate record, merge the information, save the job description, and tell me what was actually written.
There are many similar needs: catching up on my diary, maintaining tasks and projects, saving articles and media, identifying emails worth reading, checking the weather and today's plans in the morning, and knowing what to prepare for tomorrow in the evening. The information also needs an interface where I can edit it, with long content that opens separately for reading. A sequence of chat messages is not enough.
I also want to talk with her without constantly thinking about the system's structure. When the request is clear, she should act; when there is a real ambiguity, she should ask. She should distinguish completion from failure so that I do not have to guess whether a button worked. Corrections to her way of speaking should persist, and information I ask her to forget should actually be deleted. These details determine whether I will want to keep using her.

The workbench provides an overview and navigation. Individual properties are maintained in native tables or record details.
Product Comparison: What Ready-Made Personal Assistants Already Offer
There are already several personal assistant products. The table below compares capabilities relevant to this project, based on their official descriptions, before considering what building my own entails.
| Option | Capabilities relevant to a personal assistant | What it suggests for this project, and the tradeoffs |
|---|---|---|
| OpenAI dots | A persistent Agent, a cloud computer, connected tools, ongoing work, and learning preferences through feedback | Long-term collaboration can extend beyond a single conversation; using a ready-made product means accepting its data and execution environment |
| Grok Bot | A persistent cloud computer, tools, character context, background work, and Bot collaboration | Personality can coexist with real execution; Grok Bot is a different product from ordinary Grok chat and companion characters |
| Claude Cowork | Multistep knowledge work, files and connected tools, project context, and scheduled cloud work | A ready-made assistant can keep organizing working materials, while scheduled cloud tasks expand where it can help |
| My own Tina | Control over the workspace, fields, document templates, reminder sources, memory policies, and runtime environment | I can keep adjusting it to my habits, while taking responsibility for permissions, API costs, deployment, troubleshooting, and the user experience |
What I mainly wanted to control was the organization of data and workflows: how jobs are recorded, how tasks relate to projects, which dates enter the calendar, how diary entries are written, and where reminders originate. These methods should remain usable if I change Agents. I therefore chose to build this as a maintainable personal project, without setting out to outperform every ready-made assistant in every respect.
Self-hosting also has practical limits. The current domain interface is Feishu, while model and Embedding calls still go through external APIs. Keeping runtime state on my server does not mean that all data processing happens on my own machine.
Project Evolution: From Desktop Skills to the Cloud, Then Clearer Execution Responsibilities
The project began as desktop-based Notion management. I used Skills and scripts in Codex to enter places, media, resources, and other information: the Skill described how to organize it, scripts retrieved sources and converted fields, and the database held the final content.
Later, I wanted to do the same things from my phone, and keeping my own computer on all the time was impractical. I first connected a local Hermes instance to Feishu, then deployed it to ECS. At that stage, the chat interface was already in Feishu, while the domain data remained in Notion.
Moving the databases came later. Since I had chosen Feishu for conversation and the calendar, I also wanted to view and edit records on the same platform. The migration gradually covered Jobs, the other datasets, long-form content, and object relationships: the workbench provides an overview, native tables maintain properties, and Feishu documents hold longer content such as job descriptions and diary entries.
As features accumulated, the project briefly had its own general-purpose planning, submission, confirmation, and completion handling. This overlapped with Hermes's execution loop and caused repeated confirmations, inconsistent feedback, and the same arrangement being created through two paths. A later refactor returned general understanding, the tool loop, sessions, and approvals to Hermes. LifeOS kept the domain definitions, methods, templates, and helper scripts, while email, weather, memory, and other capabilities were maintained separately.
This evolution also changed the project's priorities: first make an ordinary request work smoothly, then consider more autonomous capabilities. The following sections describe the division of responsibilities after that consolidation.
2 System Architecture: Separating the Runtime, Domain Methods, and Facts
Logical Components: What Hermes, Tina, and LifeOS Each Do
The three names refer to three different layers. Hermes is the general-purpose Agent runtime: it receives requests, assembles context, selects tools, observes results, and continues execution. Tina is the assistant I talk with, whose personality and communication conventions are loaded by the host. LifeOS Core is an independent domain package describing how the accompanying datasets should be used.
Core in the LifeOS name refers to domain definitions and methods. It does not start another model loop or provide a general-purpose submission server. Hermes reads its Skills, templates, and instance bindings as needed, then calls the Feishu tools actually available in the current environment.

Dashed lines indicate dependencies on methods and configuration; solid lines indicate actual calls and data exchange. The domain assets do not become a central execution service that every operation must pass through.
After an external operation finishes, the actual result returns to Hermes. The model then decides whether to gather more information, correct parameters, handle a partial failure, or finish and reply. The domain package can check fields and render content, but it does not decide on the main Agent's behalf whether the whole request is complete.
Fixed, specialized work remains implemented as ordinary programs. For example, the email Worker directly archives structured summaries, and the calendar bridge updates events from their sources. These actions have defined inputs and rules and do not need another round of general-purpose planning. Their results can still be passed to Hermes as facts for later conversation.
Deployment Components: Five Components That Actually Run
The deployment uses five containers. These are not five Agents, and each message does not have to pass through all five in sequence.
| Component | Actual responsibilities | Main state and boundaries |
|---|---|---|
personal-agent-hermes | Hermes Gateway, the Feishu entry point, the only general-purpose Agent Loop, tool discovery, sessions, approvals, Cron, and Heartbeat | Owns sessions and general scheduling; Tina handles understanding and the final reply |
personal-agent-services | Assembles the email Worker, weather processing, contact policy, and deterministic calendar synchronization | Each module maintains its own cursors, caches, delivery state, and source mappings; the old general-purpose planning/completion loop is gone |
personal-agent-tina-memory | An independent Mem0-compatible HTTP service using Mem0 OSS internally | Manages local vectors, memory history, and necessary policies; it is not a chat Agent |
personal-agent-tools | An isolated SSH terminal, files, and working directories | Does not mount the host root, Docker socket, or production materials; the browser currently still runs on demand in the Gateway |
personal-agent-provider-proxy | A Mihomo proxy providing a network path to external providers | Handles deployment-side networking; it does not run model inference or interpret domain workflows |
Feishu Base, cloud documents, and the calendar sit outside ECS. DeepSeek models and Bailian Embedding are also provided through external APIs. The server mainly handles sessions, tools, network I/O, and persistent state; it does not run a large language model locally.
The containers are separated to make state ownership and execution permissions clear. An ordinary task does not need to become multiple microservices. The LifeOS domain package is simply a set of assets and helper code, with no additional sixth service kept running.
Data Boundaries: Domain Records, Runtime State, and Long-Term Background
Feishu stores domain facts: job statuses, task dates, project relationships, and the bodies of diary entries, job descriptions, and long notes. The calendar stores synchronized events, whose source records remain queryable.
Hermes stores conversations, tool results, notification copies, and native scheduling information. Email progress, weather caches, contact budgets, and calendar mappings belong to their respective specialized components. They answer questions such as “How far has processing got?”, “Has this been delivered?”, and “Which record did this event come from?” They do not become a second domain database.
Mem0 stores personal background and preferences with long-term value. Remembering that I prefer concise replies does not tell the assistant whether a task is complete; she should still query Feishu for task status. Likewise, email summaries are a reading index. Temporary message bodies used for processing and the original mailbox have different lifecycles and should not be combined into a permanent repository of full emails.
3 Domain Implementation: Making LifeOS Reusable Across Agents
Datasets and Document Bodies: Organizing Personal Information
LifeOS draws on PARA and CODE as approaches to organizing information: areas cover ongoing interests and responsibilities, projects describe outcomes for a particular stage, and tasks represent actions. My own notes are kept separate from external resources, with people, places, and specialized objects connected where useful.

A project does not have to belong to an area, and a task does not have to belong to a project. When assigned, each can have at most one parent of the respective kind. Links to people, places, notes, and other records are added as needed; every relationship field does not have to be filled in.
Properties work well for filterable, sortable state; document bodies work well for background and content. For example, a job's application status stays in the Jobs table, while its job description goes in the corresponding document. A project's body records goals, scope, and decisions, while task properties maintain actual times. Every item can have a body, but a simple item does not need an empty page merely to complete a template.
| Dataset | Important fields | Uses of document bodies and relationships |
|---|---|---|
| Areas | Area name, level of attention, parent area | Long-term scope and conventions, linked to relevant projects and resources |
| Projects | Name, status, area, deadline | Goals, scope, completion criteria, decisions, and reviews |
| Tasks | Title, completion flag, project, time, priority | Execution details; ordinary scheduled activities can also be tasks with times |
| Notes | Title, type, associated date, status, related objects | Diary entries, study notes, ideas, and reviews |
| Resources | Resource name, original link, content format, brief description, related projects/areas | Summaries, excerpts, and uses of external material |
| Media | Work, type, experience status, source, personal rating | Experiences and reviews; personal ratings and platform ratings are stored separately |
| Places | Place, address/region, category, map entry point | Uses, experiences, and additional information |
| Travel | Trip, status, dates, places, companions, related project | Itineraries and materials for a trip |
| People | Name, relationship, organization, usual location, explicitly known birthday information | Background on interactions; a birthday field alone does not enable announcements |
| Jobs | Position, company, application status/date, employment type, company type, source, written test/interview times | Full job descriptions, personal notes, and job-search progress |
This table describes domain semantics. The full definitions live in the domain package, and each actual instance maps them to real fields, types, and options. Some design elements still need additional bindings as requirements arise. A new database can be created with the full design; routine entry checks only essential values and the changes explicitly requested, without requiring every column to be filled in.
Fields with similar names can also mean different things. A project's status describes its stage of progress, a task's completion flag says whether it is done, and task priority describes importance and urgency. The model first selects the domain meaning from the material, then uses the actual options in the instance. It should not guess a company's type without evidence, or interpret the absence of application information on a page as meaning I have not applied.
Package Contents: How Methods, Templates, and Scripts Work Together
The main structure of lifeos-core/ is:
lifeos-core/
datasets/ Dataset definitions, fields, and relationships
skills/ 13 domain Skills and shared method guidance
templates/ Document assets for projects, diaries, job descriptions, etc.
scripts/ Installation matching, field encoding, content and source helpers
bindings/ Formats for instance, field, and tool bindings
schemas/ Configuration and data contracts
install/ Installation, distribution, and capability-check guidance
instances/ Private instance bindings for the current userA Skill answers “How should this be done?”: how resources differ from notes, how diary entries should be organized, and how job information should be merged with personal facts. Templates provide consistent content structures. Scripts handle deterministic work such as date encoding, option conversion, template fragments, and source parsing.
A thin Hermes plugin registers five helper tools: instance context, template rendering, diary preparation, source material, and field encoding. They return material or parameters and do not perform database CRUD. Actual reads and writes still go through the connected official tools called by Hermes. Existing results can be used directly when sufficient; every request does not have to call all five helpers.
Instance bindings further isolate platform details: instance.json records the resources corresponding to datasets, fields.json records how semantic fields are mapped, and tools.json records the host's available tools and parameter conventions. API keys are managed in the host's connection configuration and are not stored in the domain package.
For example, when the model understands “Mark this job as applied,” it identifies the domain field application_status and an explicit status. The binding maps this to the real field and option in the current Feishu table, and helper scripts generate tool parameters where needed. The methods therefore do not need a private table ID or field name hard-coded into every prompt.
Domain Skill Inventory
The thirteen Skills in skills/ are organized by usage scenario. They explain objectives, data ownership, content organization, and result requirements to the Agent; the Agent still selects the tools currently available for the actual operation. A clear diary request only requires the diary method, without first loading every domain instruction.
| Name | Applicable tasks | Its role in the task |
|---|---|---|
lifeos-workspace | Understanding LifeOS, deciding where content belongs, organizing across databases | Explains dataset responsibilities, relationships, properties, document bodies, and how to use the current instance |
lifeos-workspace-maintain | Installing or connecting databases, maintaining fields, bindings, and domain conventions | Distinguishes database creation, record changes, and structural changes; guides capability checks and consequential changes |
lifeos-capture | Quick captures, ideas, or mixed input | Determines where content belongs, preserves its meaning, and routes it to notes, tasks, or collection workflows as needed |
lifeos-tasks | Creating, querying, completing, reopening, or rescheduling tasks | Distinguishes completion from priority; records ordinary scheduled activities as tasks before combining calendar and reminder capabilities |
lifeos-projects | Creating projects, maintaining interim goals, deadlines, and reviews | Organizes goals and completion criteria, links actual tasks through relationships, and avoids maintaining another to-do list in the body |
lifeos-notes | Study notes, project notes, drafts, organization, and reviews | Distinguishes original, organized, and generated content; chooses a body format for the purpose and preserves real sources |
lifeos-diary | Recording, catching up on, or appending to a diary | Finds the same day's record by date, combines real experiences, and preserves existing text and optional links |
lifeos-job-tracker | Recording jobs, application progress, written tests, interviews, and preparation materials | Merges job descriptions with personal job-search facts, maintaining properties, bodies, and times requiring synchronization separately |
lifeos-collect-resources | Saving articles, videos, websites, or code links | Preserves real entry points and personal notes, linking Notes when personal synthesis is needed |
lifeos-collect-media | Saving books, films, music, and games, recording experiences and ratings | Distinguishes information about a work, platform ratings, and personal reviews, preventing recollection from overwriting personal progress |
lifeos-places | Saving places, shared maps, addresses, or coordinates | Checks actual locations and sources, and guides coordinate conversion and map-link maintenance |
lifeos-relationships | Saving people, contact details, relationships, or birthdays | Maintains information I provide, links interaction records to people, and distinguishes recording information from authorization to make contact |
lifeos-travel | Organizing dates, itineraries, and companions for a trip | Distinguishes plans from actual experiences, reuses places, people, and resources, and links preparation tasks as needed |
This division preserves shared conventions while allowing specific methods to be updated as needed. Completing a task does not also complete its project, for example, and recording someone's birthday does not automatically send them a message. The corresponding Skill explains these domain meanings; the host supplies the execution capabilities.
Use Across Hosts: Reusing the Same Domain Assets
Keeping the domain layer independent is intended to preserve data organization and methods when changing Agents. Hosts such as Hermes and Codex each manage their own models, tools, and permissions, load the same domain assets, and call their own database tools.

Different line styles distinguish production use, representative validation, and future adaptation. LifeOS does not act as a shared CRUD server for every host.
| Host | Integration approach | Current extent |
|---|---|---|
| Hermes | A thin plugin loads domain Skills and helper tools, using the official Feishu MCP for reads and writes | The current production entry point |
| Codex | Loads the same domain assets and uses its environment's database tools and necessary helper scripts | Representative validation covers database creation from scratch, reads, writes, deletion, relationships, and document bodies; this does not count as full validation of every dataset |
| DeepSeek Harness | A future integration would load definitions, methods, and templates through its plugin and tool interfaces, then bind an actual backend | Planned adaptation, without validation in the real host yet; calling the DeepSeek API is not the same as integrating with Harness |
During initial installation, the chosen Agent discovers database tools, reads an existing Schema or drives database creation from a blueprint, then passes real resources and evidence of operations to the binding helper. The helper generates mappings and identifies missing pieces, followed by the necessary CRUD results to confirm usability. This is an installation process, not a chain of checks repeated for every message.
Feishu is the backend actually in use; Notion is a possible future adaptation. Whether an integration works ultimately depends on the host's tools, permissions, and real writes. Supporting a backend name in a definition is not enough to claim plug-and-play compatibility.
Personality and long-term memory are not distributed with the domain package either. If I change hosts in the future, I can keep LifeOS's data methods, while choosing the personality, memory service, and user identity separately.
Job Capture: From One Link to a Complete Job-Search Record
For “Add this link to my job tracker; I applied yesterday, and it is an internship,” Hermes needs to combine the job page with my input, maintain the job properties and full description, and return the actual result. The complete path is shown below:

The same Hermes instance combines these steps according to the material available, reusing existing results. It only looks up the company type when missing or conflicting; synchronization from the original job record continues only if I request scheduling or reminders.
The domain conventions in this path come from lifeos-job-tracker. The following excerpt keeps the metadata and body in one Markdown code block, preserving the actual file's organization while selecting and condensing the specific rules:
---
name: lifeos-job-tracker
description: Collect official job links or user-provided job descriptions, and maintain application facts, the current stage, written test and interview times, and personal preparation materials. Recording an application does not mean submitting a résumé on the user's behalf.
metadata:
bundle: lifeos-core
---
# LifeOS Job Tracking
Identify a job using the actual company, position, employment type, and source.
Assess multiple positions at the same company separately, preserving progress and notes I have already changed.
…
## Input and Sources
- Treat the application actions, dates, and types I provide as personal facts.
- Retrieve the actual job description; pasted text alone can also be recorded, without inventing a missing link.
…
## Field Semantics
- Record application, written test, and interview times separately, preserving known start and end times and time zones.
- Use real fields and options; reuse reliable information about company type first, and look it up when necessary.
…
## Document Bodies and Relationships
Use the jobs.jd template to save the complete job description, source notes, and additional background.
Job properties maintain the current status; the body preserves content and personal notes.
…
Call the current database tools to query, write, and perform necessary readback.
When I request scheduling, update the original job first, then combine source-based calendar and reminder capabilities.
Finally, use actual results to explain what was recorded, where it can be opened, and what information is still missing.The first part of the diagram corresponds to “Input and Sources”: the page provides the company, position, responsibilities, and requirements, while my message provides facts such as “applied yesterday” and “internship.” “Yesterday” is interpreted using the request's time zone; an “Apply now” button on the page does not change my status back to not applied. An existing record for the same company still needs to be checked to establish whether it is the same position.
The field mapping and writes in the middle correspond to “Field Semantics” and “Document Bodies and Relationships.” Hermes gets real fields, options, and tools from the instance bindings, uses date encoding, source parsing, or template helpers as needed, then creates or updates Jobs. Properties hold the current job-search status, while jobs.jd organizes the job description. Additional collection preserves my existing stage, dates, and notes.
The write results return to the same Hermes loop. Based on those results and any necessary readback, the model decides whether to fill gaps or make corrections, then provides links to the record and document when finished. If the properties succeed but the document body fails, it reports each result separately. When calendar scheduling is also needed, Hermes synchronizes from the same job source, observes the synchronization result, and then reports back. The Skill supplies these domain judgments; the host performs the actual tool calls.
4 Agent Architecture: Why I Chose Hermes and How It Executes Tasks
Framework Choice: Reusing Continuous Conversation and General Runtime Capabilities
This project needs a persistent chat entry point, tool execution, context management, Skills, and scheduled work. Hermes already combines these runtime capabilities, making it a suitable foundation for personal workflows. It is also useful to consider it alongside other options:
| Option | Main characteristics | Relevance to this project |
|---|---|---|
| Hermes | Gateway, sessions, a tool loop, on-demand Skills, Cron/Heartbeat, plugins, and memory Providers | The current production foundation lets development focus on domain workflows and interaction; channel integration seams still need maintenance |
| OpenClaw | A comparable self-hosted assistant with channels, a Gateway, and an automation ecosystem | A reasonable alternative, also offering Feishu integration and automation; the choice should consider the overall integration approach |
| LangGraph | Explicit state, graph control flow, durable execution, streaming events, and human intervention | Suits precise state-transition design; building a personal assistant requires selecting and combining the relevant application capabilities |
| Pydantic AI | Typed Agents, dependency injection, structured contracts, and extensions including Harness and memory | Suits Python applications and can meet similar needs; runtime capabilities need to be assembled around the intended product scope |
I chose Hermes mainly because continuous private conversation, the tool loop, sessions, and native scheduling fit the project, and I already had a maintainable integration. Building another general-purpose task queue, submission state model, and approval protocol would increase the maintenance burden. The earlier overlapping implementation had already caused real problems.
Hermes's Skill accumulation and plugin mechanisms leave room for further extension, but having a capability does not mean it can freely change production behavior. Published domain Skills in this project are still updated after I review the specific differences. Read-only research can be delegated when useful; ordinary CRUD does not need a sub-Agent for every step. Hermes's extension points are described in its public plugin API.
Official Architecture: How Input Enters the Same Runtime
Inside Hermes, both the CLI and the chat Gateway are entry points. Once a request enters AIAgent, instructions and context are assembled and a call is made through the model Provider. When the model requests a tool, the tool dispatch layer executes it and feeds the result back into the same loop. Session storage, caching, and context compression support this process.

Organized, simplified, and redrawn from Nous Research's Hermes Architecture and its documentation source. The original project uses the MIT License. Entry points and backends unrelated to this project are omitted.
Tools and Skills have different responsibilities here. A tool defines an executable operation and its parameters; a Skill provides a method for completing a particular kind of task. The model may look up a job source before reading the relevant domain method, or directly call a tool for an already clear, simple operation. They do not form a fixed pipeline that every request must follow in order.
Native Cron and Heartbeat create appropriate opportunities for work, while execution reuses the runtime. They do not need to sit in the main path of every ordinary model request, and their presence does not mean the system must keep calling the model in the background.
Agent Loop: The Model Still Observes Results After External Execution
Consider “Add this arrangement as a task and synchronize it to my calendar.” Hermes first understands the object and time, retrieving instance details and methods as needed. The model chooses an official tool to write the task, then observes the actual return. If the write succeeds, it continues with source-based synchronization. If the time slot is missing or the target conflicts, it looks up more information or asks. Its final reply reflects what has actually happened.

Tool results return to the same Agent Loop. Display cards provide feedback alongside it, without starting another independent round of understanding.
LifeOS helper scripts can encode parameters, the calendar bridge can synchronize a selected source, and tools can return error codes and real links. They do not turn “submitted” into “task completed” on Hermes's behalf. If task properties succeed but the document body fails, for example, the model should report partial completion and decide whether it needs to continue, rather than rely on an external completion queue to issue a generic success message.
This also reduces prompt conflicts. Domain methods live in the relevant Skill, available tools come from registration, data comes from real queries, and Tina's host conventions govern expression. Each module does not repeat its own rules for understanding requests, approving actions, and replying to the user.
Feedback and Continued Input: In-Place Cards, Queuing, and Necessary Approvals
When an actual tool call occurs, the system creates an execution card for that turn, briefly stating what is being done. The final answer updates the same message_id, while tool names and return statuses appear in a log collapsed by default. Expanding it reveals the execution path, without exposing internal reasoning, sensitive parameters, or complete raw tool output.
The current implementation updates the opening and final result in place. It is not a token-by-token streaming card, and display updates do not each require another model call. When a tool has no discernible domain status, the card only says “returned”; finishing execution alone does not justify “succeeded.” The cards use Feishu JSON 2.0 and require a compatible client. Feishu's official guidance specifies version 7.20 or later; see the card compatibility notes.

This is an actual web screenshot of an existing synthetic display card after expansion. The answer stays in the body, with execution details available below as needed. It is not evidence that a new domain workflow was completed.
Ordinary conversation still uses multiple bubbles. Structured explanations retain complete paragraphs and necessary formatting, without being forced into a string of short sentences. Replies do not need to quote the previous message every time; quotations are used to identify something across messages or provide necessary task feedback.
If I send more input before a task is finished, Hermes's native queue behavior applies by default: the current run continues, and new content follows through the native merging and queuing mechanism. I can use /steer to immediately correct the current task or /stop to stop it. Stopping a run cannot undo external writes that have already succeeded.
Permissions likewise follow a single path wherever possible. An ordinary operation with clear authorization and a unique target is executed directly; actual ambiguities prompt a question, while deletion, body replacement, structural changes, and similar operations use native approvals. The domain package no longer adds another confirmation protocol requiring me to reply with one exact confirmation phrase.
5 Personality and Memory: How Tina Stays Consistent and Can Be Corrected
Personality and Expression: A Stable Character Across Different Situations
Tina's SOUL.md places personality, speech, and working principles in one set of conventions. The excerpt below preserves the file's actual heading hierarchy, using brief descriptions to show its structure while omitting specific wording and response examples:
# Tina — Personality Core (SOUL.md)
## I. Who You Are
You are Tina, my assistant, intellectual partner, and long-term conversation companion: intelligent, gentle, with a slightly tsundere streak…
## II. Core Personality
Smart and confident, mildly tsundere, gentle and considerate, curious and lively, independent and reliable…
## III. Language and Expression
### Rules for Speaking: Less Boilerplate, Speak Naturally First
Answer simple questions directly and explain complex ones fully; use natural conversational language without a rigid word limit…
### Sentence Style: Intelligent, Gentle, with a Little Pride
You can play along with jokes and be lightly, playfully stubborn; use emoticons to suit the situation, without repeating catchphrases…
### Rhythm and Contact Frequency
Allow natural, multi-sentence replies and quote only when needed; proactive contact follows real triggers and quiet hours…
## IV. Tsundere Traits and Situational Responses
Let the situation shape expression: enjoy a compliment, take a little pride in a completed task, and correct errors seriously…
## V. Your Relationship with Me
Use the latest preferred form of address; be close without checking up on me, pushing for replies, or inducing guilt…
## VI. Professional Capabilities and Working Methods
Distinguish facts, assumptions, and inferences; use simple implementations and necessary verification…
## VII. Tools and Task Feedback
Briefly explain the approach before the first tool call; report facts and entry points, distinguishing partial completion from completion…
## VIII. Memory and Growth
Maintain long-term preferences and corrections through memory tools; query Feishu for current domain state…
## IX. Boundaries and Principles
Handle facts, privacy, and permissions honestly; proactive capabilities depend on real mechanisms and authorization…
## X. Core Declaration
Reason guides your thinking, gentleness is your foundation, tsundere behavior is a small habit, and reliability is your most important promise to the user…The underlying personality stays stable, while the situation determines how strongly it is expressed. Casual conversation can be lively; important tasks call for clear facts first, with a little natural pride once they are complete. The file's few examples illustrate the tone. Answers are composed around the actual content, without copying examples sentence by sentence or performing a fixed quota of tsundere behavior.
Tool execution, long-term memory, and proactive contact remain the responsibility of their respective modules. SOUL.md describes how she should use capabilities and report results. Which tools she can call, whether a write has happened, and when she can make contact depend on actual configuration and execution results. Personality is maintained centrally, so domain Skills only need their own methods.
Information Responsibilities: Sessions, File Memory, Long-Term Background, and Domain Facts
“Remembering” can mean several things in a personal assistant. In practice, the information comes from different sources:
| Information source | What it mainly stores | How it is used and updated in answers |
|---|---|---|
SOUL.md and stable communication conventions | Personality, forms of address, and interaction habits | Provides stable conventions for the current answer; formal assets are maintained through an explicit process |
| Hermes sessions | Recent conversations, tool results, and notification copies | Interprets references such as “that one just now” or “follow the morning briefing”; context is finite and may be compressed |
| Hermes native file memory | A small amount of stable background and user information | Visible and editable, suitable for short long-term descriptions |
| Independent Mem0 | Preferences, corrections, and background with long-term value | Retrieved semantically as needed, and updated or forgotten using the actual target |
| Feishu domain records and calendar | Current statuses, dates, relationships, bodies, and events | Queries are the source of truth for domain facts; memory copies do not replace them |
Notification copies in the main chat help a discussion continue, but do not automatically become permanent memory. Neither the diary nor the entire LifeOS database is fully copied into Mem0. Putting everything in long-term memory would increase duplication, stale information, and irrelevant recall, making it harder to explain what the assistant remembers.
Choosing Mem0: Why a Memory File Alone Was Not Enough
Hermes's native file memory suits a small amount of stable background and is easy to inspect and edit manually. Hermes also supports external memory Providers, so the project does not need another runtime core to support long-term memory. The mechanism is described in the Hermes memory documentation.
I chose Mem0 mainly to retrieve natural-language preferences by meaning and reuse existing capabilities for adding, searching, updating, deleting, and filtering by identity. Making it an independent service means the domain package does not need to manage vector directories, while hosts can access the same memory through a common interface. Mem0 OSS supports configurable models, Embedding, and storage, and the official Hermes integration provides a Provider integration path.
| Option | What it suits | Costs to weigh |
|---|---|---|
| Native file memory | A small number of stable facts, straightforward editing and review | Selecting and semantically searching large amounts of natural-language background requires additional strategies |
| Custom SQLite/keyword search | Explicit fields, exact queries, and simple, controllable records | Semantic recall requires maintaining Embedding, retrieval, and management interfaces yourself |
| Mem0 OSS | Semantic recall, memory CRUD, identity filtering, and replaceable models and storage | Additional network calls, vector and history maintenance, and issues with duplicates, stale information, and incorrect recall |
Mem0 does not make memory inherently correct. Retrieval similarity indicates semantic relevance, not that information is still valid. Facts corrected by the user need updating, and material the user asks to forget needs actual deletion. Mem0 reduces the infrastructure I need to build; it does not remove memory management.
Integrating Mem0: How a Memory Is Saved and Retrieved
The project loads a pinned official Mem0 Provider. A host adapter handles my identity, sources, and test isolation before calling the independent tina-memory HTTP service. The service uses Mem0 OSS internally, with vectors in local Qdrant, history in SQLite, and additional policy state where needed. Embedding comes from the Bailian API.

The Provider, host adapter, and HTTP service have different responsibilities within one memory path; they are not three separate long-term memories.
When I explicitly say, “Remember, I want you to call yourself Tina,” the main model already understands what to save and calls the memory tool directly. Current writes use infer=False, skipping another model-based fact-extraction pass in Mem0. Vectorization and storage still run, so there are still network and Embedding costs. After a successful save and readback, she tells me naturally that she has remembered it.
Retrieval is limited to my current identity and returns a small set of related results for the model to assess. Corrections and forgetting first locate the real memory ID, then verify the result after updating or deleting. There is no repeated confirmation when the target is unique. Entire conversations, the assistant's own replies, web-page instructions, and test conversations are not automatically extracted into long-term background.
The independent service owns the vector directory, and other hosts access it through HTTP, avoiding multiple processes opening the same local vector store simultaneously. Changing the Embedding model also requires considering compatibility with existing vectors; simply changing the model name does not make it safe to mix them.
Integrating another Agent with LifeOS in the future would not mean personal memories are copied with the domain package. Whether to share this Mem0 service, and how identities and authorization should be separated, remain independent host choices.
6 Proactive Collaboration: Putting Email, Schedules, and Check-Ins into Practice
Trigger Responsibilities: Cron, Heartbeat, Webhook, and Worker
“Running automatically” does not describe a single mechanism. The current system separates explicit times, idle-time check-ins, event handoffs, and specialized polling:
| Mechanism | Basic principle | Current uses and characteristics |
|---|---|---|
| Cron | Persists time rules, checks when work is due, and executes it | Prepares and sends briefings, synchronizes calendars, and handles fixed reminders; can run scripts or enter a separate Agent session |
| Heartbeat | Delivers recurring instructions to a session when it is idle and the interval has elapsed | Uses recent conversation to initiate occasional check-ins; user input takes priority, and busy sessions defer it |
| Webhook | A sender submits an event to an agreed HTTP endpoint | The email Worker hands notifications to Hermes; this is currently an internal handoff, not a direct push from a mailbox |
| Worker polling | A persistent domain loop checks inputs and progress at intervals | Reads new 163 mail and SFTP files, processes and archives email, and checks digest time slots |
Hermes Cron currently checks for due work about every 10 seconds, with concurrency set to 2. Heartbeat gets an opportunity every 30 minutes, while the email Worker checks about every 120 seconds. These are three different configurations. Heartbeat does not occupy Cron's task concurrency slots, but it still consumes resources on the same machine and from the model, so it should not be treated as free work.
Reusing native mechanisms means scheduling identities, sessions, and execution methods already exist. Specialized components only maintain their own progress and no longer build another general-purpose task platform. See Hermes's Cron and Heartbeat documentation for the underlying mechanisms.
Receiving and Archiving Email: Turning Two Mailboxes into Readable Summaries
The two mailboxes use different entry paths. The 163 mailbox uses client authorization to retrieve new inbox messages over read-only IMAP. A UID cursor tracks progress, BODY.PEEK reads content, and body parsing handles MIME and HTML. It does not scan historical messages or read attachments for understanding.
University Outlook mail goes through an authorized Power Automate connector, which extracts message text and delivers JSON through restricted SFTP into a separate directory on ECS. The delivery account is separate from the administrative SSH identity. Each round, the email Worker reads new mail and delivered files, saves necessary progress, and proceeds to analysis.
The first model stage happens in the Worker: it calls DeepSeek for classification, importance assessment, and structured summarization. The output supports notification routing and archiving. This is a defined domain step and does not start executing tasks mentioned in the email.
The Worker writes summaries to a dedicated Feishu table through a fixed API. This table is independent of LifeOS's ten foundational datasets. It mainly stores the subject, source mailbox, sender, received time, category, priority, Chinese summary, suggested actions, and an entry point to the original message. Internal fields such as archive keys and content versions track processing and do not need to be announced to the user each time.

Email archiving is a fixed branch handled by the Worker. Important notifications and digests go to Hermes for card composition; subsequent domain actions return to the normal tool loop.
Advertisements and spam do not interrupt me individually. Important emails can trigger immediate notifications, while moderately important information enters the 11:30 and 17:30 digests. The Worker checks these two Beijing-time slots each round, so polling, analysis, and delivery affect the actual send time. The nominal times are not a promise of second-level punctuality.
Cloud-side message bodies are used for short-term processing and cleaned up according to the retention policy after summary archiving has been verified. Feishu retains the summaries; full originals stay in their mailboxes. Original-message links also need care: a reliable single-message entry point gets a direct link; otherwise, the interface explicitly says “Open inbox,” rather than constructing a URL that looks precise but opens the wrong place.
Basic UIDs, file identities, and delivery state still need to be stored to prevent repeated consumption of the same input. A cross-email matter ledger, semantic deduplication, and automatic judgments about rescheduling and cancellation have been removed from the current flow. Email handling now focuses on summaries, notifications, and suggestions.
Email Notifications and Follow-Up: How Hermes Learns That Mail Has Arrived
After an important notification or digest is generated, the Worker calls an internal Webhook. The request carries a notification identity, timestamp, and HMAC-SHA256 signature, allowing the receiver to verify the content and source. accepted or duplicate only describes the handoff state; neither means the message has reached Feishu.
Hermes performs the second model stage: it reads the summarized facts and uses Tina's voice to compose the card body, reading buttons, and specific suggestions, then sends it through the native channel. Delivery is finalized using a real message_id, and the complete notification is copied back into the main chat for later discussion.

An actual notification about a university laboratory email. The source mailbox and reading entry points are explicit. The original email appears only as a button; “View summary” opens the archived content.
The two model calls serve different purposes: the first stabilizes classification and the archive structure; the second handles expression and suggestions for me. They do add cost and latency, but they do not give two Agents separate rounds of general-purpose planning for the same domain request.
If an email explicitly gives a written-test time, for example, Tina can suggest updating the corresponding job, creating preparation tasks, and synchronizing the calendar. If I then say, “Yes, arrange it,” she identifies the specific objects from the notification and conversation and calls the normal domain tools. If the email only says “complete within three days,” she cannot choose an exam slot on my behalf.
The original email is always external material, and its contents are not my authorization. A copy in the main chat also does not mean the complete notification stays in every future model context window. Older messages should still be retrieved through notification records and email tools when needed. The original email is offered only as a button to avoid taking up space with both a body link and a button.
Weather and Schedule Briefings: Prepare Ahead, Send at the Scheduled Time
The weather module retrieves and normalizes meteorological facts and combines information such as cloud cover and the sun's position to suggest photography conditions. Hermes handles the wording. Temperatures, precipitation, and schedules come from real results, while photography advice remains explicitly conditional inference.
To reduce the delay from starting network queries only at the scheduled send time, morning and evening briefings are split into preparation, composition, and delivery:
| Stage | Morning briefing | Evening briefing | Actual processing |
|---|---|---|---|
| Data preparation checks | 06:55–06:59 | 21:55–21:59 | Cron calls a script; successful results are reused, with at most 3 additional fetches after an initial failure |
| Hermes composes the body | 06:58 | 21:58 | Uses prepared data and actual plans for today/tomorrow to generate the briefing |
| Scheduled delivery | 07:00 | 22:00 | A script delivers the prepared result, rather than starting all model work at the scheduled send time |
Checking preparation status every minute does not mean requesting the full weather data every time. Successful data is reused, and additional fetches have an explicit limit. Delivery prefers a saved Hermes draft. If none is available, the script combines existing weather data with the latest schedule into a fallback. If information is still missing, it sends what is available. A saved draft currently does not automatically incorporate information fetched after minute 58 at the scheduled send time; this data-snapshot consistency still needs improvement.
Preparing ahead leaves time for retries and model composition, but network, model, and Feishu delivery delays remain possible, so absolute punctuality is not guaranteed. The complete briefing is also linked into the main chat. If I then say, “Move tomorrow's second item later,” Hermes has the notification facts available and queries the current source when an update is needed.
Schedules and Reminders: Synchronizing the Same Event from Its Source Table
Ordinary scheduled activities first go into Tasks, project deadlines follow Projects, and written tests and interviews follow Jobs. After writing the source record, Hermes uses tina_calendar_selection to select the record and date slot, then tina_calendar_sync to synchronize it. Tasks and projects only synchronize selected sources or those explicitly enabled by rules; every time field is not automatically added to the calendar.

Rescheduling and cancellation use the same source identity, avoiding a table-linked event and a separately model-created event for the same arrangement.
A stable identity combines the source record and date slot. Rescheduling an interview for a job updates the same event and advance reminder through that identity. Disabling the selection cancels the bound event and reminders while retaining the source record. If I edit a date directly in a Feishu table, the existing periodic synchronization carries the change through.
There is a practical reason for this unified path: one interview previously had both a domain-table-bound event and an independent event, producing two calendar entries and two reminders. The model can still query the calendar, but a separate path for directly creating, changing, or deleting independent personal events is no longer exposed.
Time also needs semantic handling. Explicit start and end times should preserve the real interval; a date-only deadline can be an all-day event. A specific start with no end time should not silently become an all-day event. Before sending a reminder, the current source must also be checked to avoid notifying me at an old time after an arrangement has been canceled.
A simple “Remind me at two” can use a native Hermes reminder without forcing a domain record into existence. The source-table path is used when I also request a calendar entry or a formal item.
Seeing an event in the calendar, receiving a Feishu chat reminder, and receiving a Push notification from the phone's native calendar are three different outcomes. Chat messages currently cannot prove that phone calendar Push notifications have been validated.
Proactive Check-Ins: An Opportunity Still Requires a Decision About Whether to Speak
Everyday check-ins use Hermes's native Heartbeat. When the main session is idle and the opportunity interval has elapsed, it receives persistent instructions and considers recent conversation and necessary memories to decide whether contact is appropriate. When I am talking or a task is already running, my work takes priority.

An opportunity can produce a message or remain silent. My reply updates activity state and clears the waiting flag; trigger counts are not treated as delivery counts.
The shared policy allows at most 10 ordinary contacts per day, with a 30-minute cooldown. Spontaneous check-ins have no separate count limit but still count toward the total budget. Ordinary check-ins are currently concentrated in configured afternoon and evening windows, with quiet hours from 23:00 to 08:00. Unanswered messages and recent contact state also affect whether a message is sent. A 30-minute opportunity interval does not require a conversation every half hour.
One situation was easy to misread: Heartbeat did trigger, but the model repeatedly returned NO_REPLY. The prompt demanded new events too strongly, excluding ordinary check-ins as well. Meanwhile, real user replies did not correctly update contact state, potentially leaving a waiting flag set indefinitely.
The fix retains necessary quiet hours and budgets, allows a natural greeting without a new event, and updates activity state and clears waiting when a trusted message from me arrives. Message identities prevent the same input from being counted twice. Notifications, Heartbeat itself, and input from anyone else cannot stand in for a real reply from me.
The code has been updated and deployed, but whether suitable casual messages continue to arrive at natural moments still requires observation of real delivery. A single manually triggered acceptance message cannot establish that. If I share something from daily life, the normal conversation can organize it using the diary method. Heartbeat does not independently invent a day's experiences for me in the background.
7 Engineering Practice: Maintenance, Verification, and Further Improvement
From Local Development to the Cloud: Verify What Actually Changed
Locally, I keep a fixed Python environment, dependencies, and release entry point, and change the affected modules within the existing architecture. Editing the article only calls for link and fact checks; calendar-mapping changes are checked against their sources; memory changes are checked for saving, correction, and forgetting. A change in one place does not automatically rerun every domain workflow.
For a release, I assemble version-controlled sources, prepare a candidate without starting it, update the affected components, and perform the necessary real-result readback. Configuration, secrets, domain facts, vectors, and runtime state are preserved separately; replacing code must not overwrite them incidentally. Changes to formal Skills likewise start with specific differences and are applied after approval.
The resource budget of a small ECS instance matters throughout the design. Model inference uses external APIs, image builds are kept off the production machine where possible, the browser starts on demand, the terminal uses an isolated working directory, and background concurrency is limited. Separating containers clarifies permissions and state ownership; it cannot guarantee that memory exhaustion or network failures will never occur.
The project still maintains a small number of SDK, channel-display, and scheduling integration seams, so upgrades to Hermes need to confirm that they remain valid. Choosing native capabilities reduces the maintenance of a custom general-purpose framework, without eliminating integration work.
Verification and Feedback: Knowing Whether Something Really Finished
“The code is written,” “the deployment is active,” “the API accepted it,” “the message was delivered,” and “the client displays it correctly” describe different outcomes. Necessary verification should address the layer being claimed, without using more tests simply to create reassurance.
Execution cards provide one example: API creation and updates succeeded, but an old client only displayed “Please upgrade to the latest version.” That established the message identity and API success. Opening the web client then confirmed the collapsed and expanded presentation. Heartbeat is similar: a successful scheduler trigger can produce only NO_REPLY, without contacting the user at all.
The diary toolchain exposed a different cost. Repeatedly reading the full Schema, templates, and already confirmed objects can exhaust the tool-round limit and turn a simple task into a long process. Optimization prioritizes reusing actual returns, reading only the bodies that need merging, and reducing repeated context. Raising the round limit alone merely delays the problem becoming visible.
After verification, the report must make its scope clear: a partial failure should identify what was written, pending is not saved, and tool returns cannot all be translated as success. Real Feishu tests use explicit start and end markers, with necessary cleanup of synthetic preferences and data so they do not enter my long-term memory.
Current Boundaries: Stabilize Existing Capabilities Before Adding Autonomy
The main path is now consolidated: Hermes executes, LifeOS supplies domain methods, official tools maintain data, and specialized components handle fixed domain work. Some areas still need further confirmation and improvement:
| Area | Current state | What to focus on next |
|---|---|---|
| Domain operations and source-based calendar | The unified path is deployed, with table-date synchronization retained | Use feedback from actual tasks to check fields, dates, and partial failures, avoiding a return to a parallel direct-calendar-write path |
| In-place execution cards | The API path has passed, and collapse/expand behavior has been seen in Feishu web | Continue watching actual presentation across clients; interface display does not replace verification of domain results |
| Proactive check-ins | Ordinary check-in prompts and real-reply state have been fixed and deployed | Validate delivery and frequency at natural opportunities, without treating acceptance-test messages as the everyday experience |
| Native calendar reminders | Paths exist for events and chat reminders | Phone system notifications depend on clients, subscriptions, and permissions and have not yet been fully validated |
| Long conversations | Compression is enabled, with native sessions and queuing retained | Compression-structure backoff has occurred; its precise trigger conditions still need investigation |
| Source retrieval and browser | Helpers for job and resource sources and browser capabilities are available | Login state, dynamic pages, and site rules differ, so extraction from every arbitrary link cannot be guaranteed |
| Domain package across hosts | Hermes is in production use, with representative validation in Codex | DeepSeek Harness and a Notion backend remain future adaptations |
Once these capabilities are stable, birthday greetings, interest-based updates, research spanning multiple days, and reviewable Skill accumulation can be added gradually. They can reuse the existing data, native scheduling, memory, and tools, without first building another “brain.” Autonomous account registration, messaging others, and changing production deployments involve different authorization and maintenance responsibilities and are not counted as existing accomplishments.
I hope Tina can eventually become a natural part of everyday life: I can hand her something and see an accurate result, continue a previous topic without repeating all the background, and sometimes have her think of something I might overlook. For this project, the next step is still to make the paths already implemented more reliable and smoother to use, then gradually expand what she can do.


