# The Hermes + Obsidian + Claude Code Trinity: The Full System for Running a One Person Company
**作者**: CyrilXBT
**日期**: 2026-06-28T00:55:47.000Z
**来源**: [https://x.com/cyrilXBT/status/2071034792288686588](https://x.com/cyrilXBT/status/2071034792288686588)
---
There is a specific moment that tells you whether someone is running a real one person company or just using a lot of apps.
It is the moment they get asked a question about their own business and they have to go dig for the answer. Check three different tools. Scroll back through old messages. Try to remember which note they wrote that idea down in.
A real system does not make you dig. It already knows.
This article is about the three tools that, stacked together correctly, remove the digging entirely. Obsidian holds everything you have ever thought, decided, or captured. Claude Code reads that vault and turns it into something you can actually talk to. Hermes Agent runs continuously in the background, gets better at its own job over time, and lives wherever you already are instead of demanding you open a new tab to use it.
Individually, each of these is a good tool. Stacked correctly, they become something closer to a company you run by yourself, with most of the operational weight carried by systems instead of willpower.
Here is the honest version of why this matters now and not two years ago. Earlier AI tools could each do one piece of this in isolation. A note app with AI search. A chatbot you could paste context into manually. A simple automation that ran the same script every day regardless of what actually happened. None of those pieces talked to each other, and none of them got better at their job over time. What changed is that Claude Code can now hold and act on an entire vault's worth of context reliably, and agent frameworks like Hermes Agent can run unattended for real stretches of time while actually learning from what they did. The connective tissue between memory, processing, and action finally got strong enough to build a real system on top of it, not just a collection of clever individual tools.
## The Problem With Running Solo
Every solo operator eventually hits the same wall. You are the founder, the marketer, the support team, the bookkeeper, and the person who has to remember everything, all at once. There is no second brain in the building except the one in your skull, and that one forgets things, gets tired, and cannot work while you sleep.
Most people respond to this by buying more tools. A project manager here, a note app there, a separate AI subscription for writing, another one for research. Now you have five places where knowledge about your own business lives, none of which talk to each other, and you have added a sixth job: remembering which tool has the thing you need.
The Trinity approach inverts this. Instead of more tools that each hold a slice of your business, you build one connected system where knowledge accumulates in a single place, gets processed by an agent that understands context, and gets acted on by a second agent that runs even when you are not looking at a screen.
## Layer One: Obsidian as the Memory
Obsidian is the foundation, and its job is simple. Hold everything.
Every source you consume, every decision you make, every idea you have half formed in the shower, goes into the vault. Not organized perfectly. Not filed into the right folder immediately. Just captured, because captured beats perfect every time.
The structure that actually works in practice is deliberately minimal. A raw folder for anything you have not processed yet, articles, transcripts, screenshots of conversations, voice memo transcriptions. A wiki folder for the processed, linked, permanent version of your knowledge. And a single CLAUDE.md file at the root that tells Claude Code exactly how this vault works and what to do with anything dropped into it.
This structure matters because it creates a clear boundary between input and output. Raw is messy by design. Wiki is clean by design. The thing that moves content from one to the other is not you manually retyping notes at midnight. It is the next layer.
## Layer Two: Claude Code as the Processor
This is where the system stops being a notebook and starts being intelligence.
Open your Obsidian vault in Claude Code and you have given an agent direct read and write access to everything you have ever captured. Drop a podcast transcript into raw and tell Claude to ingest it. It reads the transcript, pulls out the genuinely new ideas, checks whether they connect to anything already in your wiki, and either extends an existing note or creates a new one with proper backlinks.
This is fundamentally different from summarizing a document and forgetting it the moment the chat ends. Every source you feed it makes the next source easier to process, because Claude is working against an ever growing map of what you already know, not starting fresh every time.
The compounding effect here is the entire point. Month one, your vault is thin and Claude's connections are obvious. Month six, you have hundreds of linked notes and Claude starts surfacing connections you would never have made yourself, an idea from a marketing book linking to a comment a customer made three weeks ago, both filed under the same underlying principle neither source named directly.
Practically, this layer handles three kinds of work for a one person company.
Knowledge capture. Every article, video, or conversation that touches your business gets distilled and filed automatically instead of read once and forgotten.
Decision logging. When you decide something, pricing, positioning, a process change, that decision and the reasoning behind it gets written down in a place you can actually find it again, instead of living only in your memory until it quietly contradicts itself six months later.
Drafting. Claude Code, working from your actual vault instead of a blank page, can draft emails, proposals, content, and documentation that already sound like you because it has your actual writing and decisions to draw from.
## Layer Three: Hermes Agent as the Operator
Obsidian remembers. Claude Code processes. Hermes Agent acts, continuously, without you opening a laptop.
Hermes Agent is the open source AI framework behind tools like MaxHermes, and the detail that separates it from a typical assistant is the built-in learning loop. After completing a task, it evaluates its own process and, when the task was complex enough to be worth it, generates a reusable skill from that experience and stores it permanently. The skill list starts empty. A week of real use later, it has built a meaningful library of its own skills, and every repeated task after that runs faster because the agent is drawing on a method it already worked out for itself.
The other detail that matters for a solo operator specifically is where it lives. MaxHermes runs inside Telegram, not a separate browser tab you have to remember to open. Your operating agent exists in the same place you already spend time, with the same context available no matter which device you are on. Setup is a single click at agent.minimax.io, no server, no API keys, no terminal configuration.
For a one person company, this is the layer that actually buys back hours. You hand it a task before bed; it is finished by morning, and it has gotten a little better at that category of task than it was the day before. Customer inquiries get a first response without you being awake. Routine research gets compiled overnight. Follow ups go out on schedule without living on a sticky note.
## How the Three Layers Actually Connect
The Trinity only works because each layer feeds the next one, not because the three tools happen to coexist.
Obsidian captures the raw material. A customer conversation, a competitor's new feature, an idea you had on a walk.
Claude Code, with vault access, processes that raw material into structured knowledge and can draft the response, document, or content piece that the situation calls for, informed by everything else already in the vault.
Hermes Agent takes the routine, repeatable version of that workflow and runs it without a human in the loop, learning a faster path through it every time it repeats.
In practice this looks like a morning routine that takes ten minutes instead of two hours. You ask your vault for a status update across every active project, pulled from notes you actually wrote, not from memory. You review what Hermes handled overnight while you slept. You feed yesterday's new information into raw and let Claude Code do the filing. Then you spend your actual working hours on the parts of the business that genuinely need a human, which by this point is a much shorter list than it used to be.
## What This Replaces
It is worth being specific about what a properly built Trinity setup actually removes from your day, because the value is easy to understate in the abstract.
It replaces the morning spent rereading old notes to remember where a project left off, because the vault already has the answer and Claude Code can summarize it in seconds.
It replaces hiring a virtual assistant for routine inbox triage and follow ups, because Hermes Agent handles the repeatable slice of that work and gets faster at it the longer it runs.
It replaces the slow creep of knowledge loss that happens when a solo founder's best thinking lives only in their head, vulnerable to a bad week, a bad memory, or simply moving on to the next shiny idea before writing the last one down properly.
It does not replace judgment. Pricing decisions, hard conversations with customers, the actual creative or strategic core of your business, those still need you. The Trinity exists to clear everything else off your plate so that judgment is the thing you are spending your time on, rather than the thing you are too exhausted to apply properly by the time you get to it.
## Where This Breaks If You Build It Wrong
The Trinity fails in predictable ways, and almost all of them trace back to skipping the order above or skipping the boring maintenance that keeps each layer healthy.
The most common failure is treating Obsidian as a dumping ground with no eventual processing step. Raw piles up. Nothing moves to wiki. Six months later you have a thousand unprocessed notes and the vault has become exactly the kind of mess it was supposed to prevent. The fix is not a better folder structure, it is a standing habit, even just once a week, of actually running the ingestion step on whatever piled up.
The second failure is giving Claude Code vague instructions in CLAUDE.md and assuming it will infer your preferences. It will not, not reliably, and the cost of that ambiguity compounds the same way the benefit does. A CLAUDE.md that says "organize notes well" produces inconsistent filing. A CLAUDE.md that says exactly which folder structure to use, how to handle duplicate topics, and when to create a new note versus extend an existing one produces a system you can actually predict.
The third failure is handing Hermes Agent a task with no real verification step and assuming overnight autonomy means unattended trust. The learning loop makes the agent better at tasks it has done before, but that is a reason to start with low stakes, reversible tasks, not a reason to skip checking its work for the first few weeks. Build trust the same way you would with a new hire. Review closely at first. Loosen the leash as the track record earns it.
## What This Looks Like Running for Real
Picture a solo course creator running this stack three months in.
A student leaves a confusing piece of feedback on a video. It gets dropped into raw that night. Claude Code reads it, checks the wiki, and finds two earlier notes where similar confusion came up around the same topic, something the creator had genuinely forgotten flagging before. The note gets updated with a clear pattern, not just one isolated complaint, and a suggested script fix gets drafted alongside it.
The next morning, Hermes Agent has already sent a personalized reply to the student overnight, drawing on the tone and structure the creator has used in past replies, because that pattern was something it learned in its first two weeks of running. The creator reviews it, makes one small edit, and moves on with their day in under two minutes, a task that used to take fifteen and a moment of full attention they did not have to spare.
None of this required a team. It required three tools that were actually talking to each other, built in the right order, given a few months to accumulate enough history to be useful.
That is the entire bet behind the Trinity. Not that AI replaces the founder. That a founder who is the entire company finally gets a memory that does not forget, a processor that does not get tired, and an operator that works the night shift, so the only thing left requiring a human is the part that actually needed one in the first place.
You do not need all three layers running perfectly on day one. Build them in order, because each one makes the next one more useful.
Start with Obsidian. Create the vault. Build the raw and wiki folders. Spend a few days just capturing, badly if necessary, until the habit of dropping things into raw feels automatic.
Add Claude Code once you have something worth processing. Write the CLAUDE.md file that tells it how your vault is structured and what ingestion should look like. Feed it your first real source and watch what it does with it before you trust it with more.
Bring in Hermes Agent last, once you know which of your routine tasks are actually repeatable enough to hand off. The temptation is to automate everything immediately. Resist it. Automate the task you already do the same way every single time, prove the loop works, then expand.
The compounding only shows up if you stay with it past the first week, when the vault is still thin and the agent has not built any skills yet. That early period feels like more setup than payoff. It is not a sign the system does not work. It is the system before it has anything to compound on top of.
By month two or three, the gap between this setup and running everything manually stops being subtle. That is the point where a one person company starts to feel less like one exhausted person and more like an actual operation, even though the headcount never changed.
## 相关链接
- [CyrilXBT](https://x.com/cyrilXBT)
- [@cyrilXBT](https://x.com/cyrilXBT)
- [122K](https://x.com/cyrilXBT/status/2071034792288686588/analytics)
- [agent.minimax.io](https://agent.minimax.io/)
- [8:55 AM · Jun 28, 2026](https://x.com/cyrilXBT/status/2071034792288686588)
- [122.9K Views](https://x.com/cyrilXBT/status/2071034792288686588/analytics)
- [View quotes](https://x.com/cyrilXBT/status/2071034792288686588/quotes)
---
*导出时间: 2026/6/29 10:15:39*
---
## 中文翻译
# Hermes + Obsidian + Claude Code 三位一体：经营一人公司的完整系统
**作者**: CyrilXBT
**日期**: 2026-06-28T00:55:47.000Z
**来源**: [https://x.com/cyrilXBT/status/2071034792288686588](https://x.com/cyrilXBT/status/2071034792288686588)
---
有一个特定时刻能告诉你，某人是在经营真正的一人公司，还是仅仅在堆砌一大堆应用。
那就是当他们被问及自己业务的一个问题时，不得不去到处搜寻答案。查阅三个不同的工具。翻阅旧消息。试图回忆当初把那个主意记在了哪张便签里。
真正的系统不会让你去挖掘。它早就知道答案。
这篇文章介绍的三个工具，如果正确地堆叠在一起，可以彻底消除这种挖掘工作。Obsidian 存放你曾经思考过、决定过或捕捉过的一切。Claude Code 读取该库并将其转化为你可以真正对话的对象。Hermes Agent 在后台持续运行，随着时间的推移对自己所负责的工作越来越熟练，并且驻留在你已经常驻的地方，而不是强迫你打开新标签页去使用它。
单独来看，它们各自都是好工具。正确堆叠后，它们变得更像是一家由你独自经营的公司，大部分运营重担由系统承担，而非靠意志力支撑。
以下是关于这件事为什么重要、为何是现在而非两年前的真实原因。早期的 AI 工具只能在孤立状态下完成其中某一块功能。带 AI 搜索的笔记应用。你可以手动粘贴上下文的聊天机器人。无论实际情况如何、每天都执行相同脚本的简单自动化。这些部件彼此之间无法对话，也没有哪一个能随着时间推移在工作中变得更好。改变在于，Claude Code 现在可以可靠地掌握并处理整个库规模的上下文，而像 Hermes Agent 这样的代理框架可以在无人值守的情况下运行相当长的时间，并真正从其行为中学习。记忆、处理和行动之间的连接组织终于变得足够强大，可以在其之上构建真正的系统，而不仅仅是一堆聪明独立的工具。
## 独自经营的困境
每个独行侠最终都会撞上同一堵墙。你既是创始人、营销人员、支持团队、记账员，又是那个必须记住所有事情的人，还得同时处理这一切。除了你脑袋里的那个，这栋楼里没有第二个大脑，但那个大脑会遗忘、会疲劳，而且没法在你睡觉时工作。
大多数人对此的反应是购买更多工具。一个项目管理器，一个笔记应用，一个专门用于写作的 AI 订阅，另一个用于研究。现在你有了五个存放自家业务知识的场所，它们互不相通，你还添加了第六项工作：记住哪个工具里有你需要的东西。
“三位一体”的方法颠覆了这一点。不再是每个工具只存放你业务的一小部分切片，而是构建一个互联系统，知识在单一位置积累，由一个理解上下文的代理进行处理，并由第二个代理执行操作，即使你不在屏幕前也是如此。
## 第一层：作为记忆的 Obsidian
Obsidian 是基础，其工作很简单。存放一切。
你消费的每一个来源、你做出的每一个决定、你在淋浴时半成形的每一个想法，都进入库中。不需要完美的组织。不需要立即归档到正确的文件夹。只要捕捉到就行，因为捕捉到的永远胜过完美的。
在实践中真正有效的结构是刻意的极简。一个 Raw（原始）文件夹，用于存放你尚未处理的任何内容：文章、转录稿、对话截图、语音备忘录转录。一个 Wiki（维基）文件夹，用于存放经过处理、已建立链接、永久版本的知识。以及根目录下的一个 CLAUDE.md 文件，它告诉 Claude Code 这个库究竟如何工作，以及把任何丢进去的东西怎么处理。
这个结构之所以重要，是因为它在输入和输出之间建立了一条清晰的界线。Raw 按设计就是混乱的。Wiki 按设计就是整洁的。将内容从一个转移到另一个的，不是你在午夜手动重打笔记，而是下一层。
## 第二层：作为处理器的 Claude Code
在这里，系统不再只是笔记本，而开始成为智能。
在 Claude Code 中打开你的 Obsidian 库，你就赋予了一个代理对你所有捕捉内容的直接读写权限。把一份播客转录稿丢进 Raw 并告诉 Claude 去消化它。它会阅读转录稿，提取出真正的新想法，检查它们是否与维基中已有的内容有关联，然后要么扩展现有笔记，要么创建一个带有适当反向链接的新笔记。
这从根本上不同于总结一份文档并在聊天结束后就将其遗忘。你喂给它的每一个来源都让处理下一个来源变得更容易，因为 Claude 是对照你已知事物的不断增长的地图在工作，而不是每次都从头开始。
这里的复利效应是全部的意义所在。第一个月，你的库还很单薄，Claude 的联系显而易见。到了第六个月，你拥有数百个链接笔记，Claude 开始展现出你永远无法自己建立的联系——比如营销书中的一个观点与三周前一位客户评论之间的联系，两者被归在同一个底层原则下，而这两个来源都没有直接点名该原则。
实际上，对于一人公司来说，这一层处理三类工作。
知识捕捉。每一篇触及你业务的文章、视频或对话，都会被自动提炼和归档，而不是只读一次就被遗忘。
决策记录。当你做出决定时——定价、定位、流程变更——该决定及其背后的逻辑会被写在一个你真正能再次找到的地方，而不是仅存在于你的记忆中，直到六个月后它悄然自相矛盾。
起草。Claude Code 基于你实际的库而非空白页工作，可以起草邮件、提案、内容和文档，这些内容听起来已经像你写的，因为它有你的实际写作和决策作为依据。
## 第三层：作为执行者的 Hermes Agent
Obsidian 负责。Claude Code 负责处理。Hermes Agent 负责行动，持续地，无需你打开笔记本电脑。
Hermes Agent 是 MaxHermes 等工具背后的开源 AI 框架，将其与典型助手区分开来的细节在于内置的学习循环。在完成任务后，它会评估自己的过程，当任务足够复杂时，它会从该经验中生成可重用的技能并永久存储。技能列表最初是空的。经过一周的实际使用后，它已经建立了一个有意义的自身技能库，此后每一次重复任务的运行都更快，因为代理正在调用它自己已经摸索出来的方法。
对于独行侠来说，另一个重要的细节是它驻留在哪里。MaxHermes 运行在 Telegram 内部，而不是你必须记得打开的独立浏览器标签页。你的执行代理存在于你已经花费时间的同一个地方，无论你使用什么设备，都能获得相同的上下文。设置只需在 agent.minimax.io 点击一下，无需服务器、无需 API 密钥、无需终端配置。
对于一人公司来说，这才是真正能为你夺回时间的层级。睡前交给它一个任务；早上醒来已经完成，而且它在那类任务上比昨天更熟练了一点。客户咨询在你还没醒来时就能得到首次回复。常规研究在夜间汇总完成。跟进按计划发出，而不是贴在便利贴上。
## 这三层实际上是如何连接的
三位一体之所以有效，是因为每一层都为下一层提供养分，而不是因为这三个工具恰好共存。
Obsidian 捕捉原始素材。一次客户对话、竞争对手的新功能、你在散步时想到的一个主意。
拥有库访问权限的 Claude Code 将这些原始素材处理成结构化知识，并可以起草该情况所需的回复、文档或内容，且受库中所有其他内容的指导。
Hermes Agent 获取该工作流程中常规、可重复的部分，并在无人干预的情况下运行，每次重复时都会找到更快的路径。
在实践中，这看起来像是只需十分钟而非两小时的晨间例程。你向你的库索要每个活跃项目的状态更新，提取自你真正写下的笔记，而非记忆。你审查 Hermes 在你睡觉时连夜处理的事项。你将昨天的新信息喂进 Raw，让 Claude Code 去归档。然后，你将实际工作时间花在业务中真正需要人的部分上，而到那时，这份清单比以前短得多了。
## 这取代了什么
值得具体说明一个构建得当的三位一体设置实际上从你的日常中移除了什么，因为在抽象层面很容易低估其价值。
它取代了为了回忆项目进度而重读旧笔记的整个上午，因为库已经有了答案，而 Claude Code 可以在几秒钟内总结出来。
它取代了为了常规收件件分类和跟进而雇佣虚拟助手，因为 Hermes Agent 处理了那部分工作中可重复的切片，且运行得越久越快。
它取代了当独行创始人的最佳思路仅存于脑中时那种缓慢的知识流失——这容易受糟糕的一周、糟糕的记忆的影响，或者仅仅是在还没把最后一个想法好好写下来前就转向下一个光鲜的主意。
它不能取代判断力。定价决策、与客户的艰难对话、业务真正的创意或战略核心，这些仍然需要你。三位一体的存在是为了清空你盘子上的其他所有事情，这样你把时间花在判断力上，而不是在你终于有空去处理时，却因太累而无法正确运用它。
## 如果构建方式不对，会在哪里出问题
三位一体失败的方式是可以预测的，几乎所有失败都归因于跳过了上述顺序，或跳过了让每一层保持健康的枯燥维护工作。
最常见的失败是把 Obsidian 当作没有最终处理步骤的垃圾场。Raw 堆积。什么也没移到 Wiki。六个月后，你有一千条未处理的笔记，库变成了它本应防止的那种混乱。解决方案不是更好的文件夹结构，而是一种固定的习惯，哪怕只是一周一次，实际运行对堆积内容的消化步骤。
第二个失败是在 CLAUDE.md 中给 Claude Code 模糊的指令，并假设它会推断你的偏好。它不会，至少不会可靠地，这种模糊性的代价会产生与收益一样的复利效应。一份写着“好好整理笔记”的 CLAUDE.md 会产生不一致的归档。一份精确说明使用哪种文件夹结构、如何处理重复主题以及何时创建新笔记与扩展现有笔记的 CLAUDE.md，会产生一个你真正可以预测的系统。
第三个失败是交给 Hermes Agent 一个没有真正验证步骤的任务，并假设过夜自主性意味着无人监管的信任。学习循环让代理在它做过的任务上做得更好，但这正是你应该从低风险、可逆任务开始的原因，而不是跳过前几周检查其工作的理由。像对待新雇员一样建立信任。起初密切审查。随着业绩记录赢得信任，再慢慢松开绳子。
## 真实运行起来是什么样子
想象一位独自经营的课程创作者，在这个技术栈上运行了三个月。
一名学员就一个视频给出了令人困惑的反馈。当晚它被丢进 Raw。Claude Code 阅读了它，检查维基，发现两条较早的笔记，其中在同一个主题周围出现过类似的困惑，这是创作者真正忘记标记过的。该笔记被更新为一个清晰的模式，不仅仅是一个孤立的投诉，旁边还起草了建议的脚本修复。
第二天早上，Hermes Agent 已经连夜给该学生发送了个性化的回复，借鉴了创作者在过去回复中使用的语气和结构，因为那个模式是它在运行头两周就学到的。创作者审查一遍，做一个小修改，在两分钟内继续处理一天的事务，这是一项以前需要十五分钟且需要全神贯注的任务，而他们并没有那么多全神贯注的时间。
这一切都不需要团队。它需要的是三个真正彼此对话的工具，按正确顺序构建，并给予几个月的时间积累足够的历史以变得有用。
这就是三位一体背后的全部赌注。不是 AI 取代创始人。而是作为一个公司全部的创始人，终于获得了一个不会遗忘的记忆、一个不会疲倦的处理器，以及一个上夜班的执行者，因此唯一真正需要人的部分，就是那个本来就需要人的部分。
你不需要在第一天就把这三层都运行得完美无缺。按顺序构建它们，因为每一层都会让下一层更有用。
从 Obsidian 开始。创建库。构建 Raw 和 Wiki 文件夹。花几天时间只是捕捉，哪怕捕捉得很烂，直到把东西丢进 Raw 的习惯变得自动化。
当你有值得处理的内容时，再添加 Claude Code。编写 CLAUDE.md 文件，告诉它你的库结构以及消化应该是什么样子。喂给它你的第一个真正的来源，观察它如何处理，然后再信任它处理更多。
最后引入 Hermes Agent，一旦你知道哪些常规任务确实足够重复，可以交出去。诱惑在于立即自动化一切。请抵制。自动化那个你已经每次都用完全相同的方式做的任务，证明循环有效，然后再扩展。
只有当你坚持过第一周后，复利效应才会显现，此时库还很单薄，代理还没建立任何技能。早期阶段感觉像设置多于回报。这不是系统不工作的迹象。这是系统在没有任何东西可供复利之上的状态。
到了第二或第三个月，这个设置与手动运行一切之间的差距不再是微妙的。那就是一人公司开始感觉不再像是一个疲惫的人，而更像是一个实际运营体的时候，尽管从未增加过人手。
## 相关链接
- [CyrilXBT](https://x.com/cyrilXBT)
- [@cyrilXBT](https://x.com/cyrilXBT)
- [122K](https://x.com/cyrilXBT/status/2071034792288686588/analytics)
- [agent.minimax.io](https://agent.minimax.io/)
- [8:55 AM · Jun 28, 2026](https://x.com/cyrilXBT/status/2071034792288686588)
- [122.9K Views](https://x.com/cyrilXBT/status/2071034792288686588/analytics)
- [View quotes](https://x.com/cyrilXBT/status/2071034792288686588/quotes)
---
*导出时间: 2026/6/29 10:15:39*