# My Agent Stack For Automating My Personal Life
**作者**: Nicolas Bustamante
**日期**: 2026-05-30T04:46:17.000Z
**来源**: [https://x.com/nicbstme/status/2060583553449250888](https://x.com/nicbstme/status/2060583553449250888)
---
My agent manages my emails, SMS, Whatsapp, Telegram and pretty much everything to automate my personal life.
People keep asking me how I use agents in real life. I mean the actual boring things that make a day disappear: reading WhatsApp and Telegram, finding someone's email, searching the web, drafting the intro, updating a document in Google Drive, creating a calendar event, checking who still needs an answer, and doing all of it across the same messy tools I already use.
My answer is disappointingly simple. I use Codex as an operator on top of my actual life data. It has tools. It has data connectors. It has skills. It has a source of truth. It has enough permissions to act locally, and enough approval gates that it does not embarrass me in public.
That is basically the setup. Tools, data connectors, skills, and taste.
I used to do more of this in Claude Code but I have been moving the setup to Codex because GPT-5.5 is currently a better model for this kind of work. The switch from Claude Code to Codex is not really the story. The story is that once a model is good enough, the real leverage comes from wiring it into the world you already live in.
```
MY PERSONAL AGENT STACK
=======================
agent:
Codex
tools:
Gmail / Drive / Calendar / Docs / Sheets -> gog
WhatsApp -> wacli
Telegram -> Telegram connector
iMessage / SMS -> imsg
Browser / Chrome -> browser automation
macOS apps -> AppleScript / UI automation
local files -> filesystem tools
data:
Google Drive as source of truth
contacts in a Google Sheet mirrored as CSV
Notion exported into Drive
local memories and instructions
skills:
inbox-zero
contacts
google-workspace
imessage-cli
personal admin workflows
```
The important part is that the agent can move across boundaries. My personal life is not in one app. It is split between Gmail, WhatsApp, Telegram, iMessage, Google Drive, Calendar, Notion, local files, random PDFs, browser sessions, and a contacts spreadsheet that is much more valuable than it looks.
## A Real Communication Example
A few days ago a friend sent me a WhatsApp message. She was helping a fast-growing San Francisco AI startup recruit in France and wanted to connect their recruiting manager with a recruiter I know. I did not remember the recruiter's email. I did not know the latest funding news about the startup. I needed to search WhatsApp, search Gmail, find the recruiter's email, search the web, understand why the startup was credible, draft an intro email, include the two job links, show the draft to me, send the email after approval, and then text my friend that it was done.
That is normally twenty minutes of annoying app switching. WhatsApp to Gmail to Google search to Gmail again to WhatsApp again. It is not hard work, but it is exactly the kind of work that burns attention because every step is a small context switch.
With the agent, I asked for the outcome. It read the WhatsApp thread, searched Gmail for the recruiter's email, researched the startup's funding and recent news on the web, drafted the intro, waited for my approval, sent the email, and then texted my friend that the intro was done. The user-facing part took about ten seconds. The agent did the glue work (in seconds!)
This is the killer pattern. The agent is not "answering a question." It is operating across my tools to complete a small real-world workflow (aka a "job-to-be-done")
## The License Plate Example
Another example is even more boring, which is why I like it. I got a new license plate for my car. I sent photos and context to Codex. It updated the car information Markdown file I keep in Google Drive, changed the license plate, added the registration notes, preserved the existing VIN, insurance, owners, and address, then uploaded the file back to Drive.
That alone is useful, but the better version is what happens next. The agent can use browser automation to go update the same information everywhere else: FasTrak, the parking app, insurance portals, DMV-related forms, or any other web app that does not have a clean API. For clean systems, it should use an API or CLI. For messy systems, it can use the browser and it's so good! I also now use Computer Use from Codex.
This is what personal agents are for. Not dramatic autonomy. Administrative continuity. I was always afraid of Openclaw yolo mode in the background. I appreciate being in control.
## Google Drive Is My Source Of Truth
The most important architectural decision I made was centralizing valuable personal information in Google Drive. For years, a lot of my knowledge lived in Notion. I like Notion as a human workspace, but I do not love it as the primary source of truth for an agent. The API works, but the workspace is too fluid: nested pages, databases, properties, permissions, formatting, backlinks, and a lot of UI-native structure that is pleasant for humans and annoying for models.
So I used the Notion API to export the valuable information and move it into Google Drive. I was not trying to perfectly preserve the Notion workspace. I was trying to make the information agent-readable. Most of the useful information in Drive is Markdown or CSV, because those formats are easy for the agent to search, diff, edit, and upload back without ceremony. Google Drive became the source of truth because gogcli gives the agent a simple command line surface for Gmail, Drive, Calendar, Docs, Sheets, Contacts, and Tasks.
This is an underrated point. You should not organize your knowledge only for the human UI. You should organize it for the agent's tool path. Agents like stable file IDs, text, tables, Markdown, CSVs, and commands that return JSON. If the agent can search it, download it, edit it, upload it, and cite where it came from, the data is useful.
My personal data layer is embarrassingly simple. Google Drive holds the important docs, mostly as Markdown files and CSVs. Contacts live in a Google Sheet mirrored as a CSV. Notion exports land in Drive. Local instructions live in AGENTS.md. Skills live as Markdown files in folders. The source of truth is not elegant. It is legible.
```
DATA LAYER
==========
Google Drive:
personal docs
car docs
family docs
exported Notion pages
PDFs
spreadsheets
Google Sheets / CSV:
contacts
phone numbers
emails
categories
locations
notes
Local files:
AGENTS.md
memories
skills
scripts
blog repo
```
A lot of personal productivity is just joining across this data. One fact is in WhatsApp. Another is in Gmail. The email address is in Contacts. The date is in Calendar. The document is in Drive. The agent becomes useful when it can cross those boundaries without asking me to be the glue.
One of my best investment was to create a contact.csv with the phone number, email, linkedin etc of all the people I know.
## The Tools
The core tools are boring by design. I use gogcli for Google Workspace, wacli for WhatsApp, imsg for iMessage and SMS, Browser Use or browser automation for web apps, and AppleScript or macOS UI automation when there is no better interface.
The hierarchy is simple. APIs and CLIs are best. Local files are great. Browser automation is acceptable. Screen automation is the last resort.
```
BEST TOOL SURFACE
=================
API and CLI
>
local file
>
browser automation
>
screen automation
```
This hierarchy matters because agents are only as reliable as their tool surface. Asking a model to click around a website is sometimes necessary, but it is not the happy path. A command like gog gmail messages list or wacli messages list --json is much easier for the model to inspect, retry, and reason about.
Here is what the tool layer looks like in practice:
```
# Gmail
gog gmail messages list '"Firstname Lastname"' --max 10 --include-body
gog gmail get <messageId>
gog gmail send --to robin@example.com --subject "Intro" --body-file draft.txt
# Drive
gog drive search "lexus_rx_info.md"
gog drive download <fileId>
gog drive upload ./file.md --replace <fileId>
# WhatsApp
wacli chats list --query "Friend Name" --json
wacli messages list --chat 16282358390@s.whatsapp.net --limit 20 --json
wacli send text --to 16282358390@s.whatsapp.net --message "Done"
# Telegram
# same pattern: list chats, read history, search, draft, send after approval
# Calendar
gog calendar create primary \
--summary "Picnic in Golden Gate Park" \
--from "2026-05-31T11:00:00-07:00" \
--to "2026-05-31T13:00:00-07:00"
```
None of this looks like science fiction. That is the point. The future of personal agents starts as a pile of commands that let the model operate the tools you already use. You want to reduce to a maximum the abstraction layers between the models and the APIs.
## The Skills
Tools give the agent hands. Skills give it habits. A skill is just a small operating manual that tells the agent how to do a recurring task the way I like it done.
My inbox-zero skill is a good example. It tells the agent to list Gmail inbox messages through gog, separate auto-archive from needs-review, show me the important emails, quote the substance, suggest archive or reply, draft replies, wait for explicit approval, send in the original thread, preserve all recipients, archive only after sending, keep replies short, never suggest calls unless I ask, and sign with "Nicolas."
That is not a fancy architecture. It is a procedure. But the procedure is the product and... it's just text instructions.
Without the skill, I have to be the prompt every time. I have to remind the agent not to send without approval, not to drop cc recipients, not to suggest a call, and not to sign with some weird corporate signature. With the skill, I say "run inbox zero," and the workflow already contains my taste.
The important habit is that I improve the skill every time the agent makes a mistake. If it suggests a call when I hate calls, I add that rule. If it forgets to preserve cc recipients, I add that rule. If it archives too aggressively, I tighten the classification. The agent gets better because the procedure gets better.
This is how personal agents become personal. Not by having a cute voice. By accumulating operational taste.
```
TOOLS + DATA CONNECTORS + SKILLS + FEEDBACK
===========================================
tool fails once
v
fix the tool or add a guardrail
agent makes a judgment mistake
v
update the skill
agent forgets a preference
v
write it into memory or AGENTS.md
workflow repeats
v
personal agent improves
```
The setup compounds because the mistakes become instructions.
## Approval Gates Are The Product
I do not want an agent that blindly replies to everyone. I want an agent that prepares the work, shows me the draft, and asks at the right moment. For most communication workflows, the loop is: read context, draft response, show me, wait for approval, send, confirm.
Sometimes I let it send directly when the stakes are low. "Tell Hugo I am in Seattle next week" does not need a board meeting. But an investor email, a customer reply, an intro, or anything with social nuance should be drafted first.
This is the difference between useful and terrifying. Read-only scanning is one trust tier. Drafting is another. Sending is another. Deleting, paying, signing, or changing account settings is a completely different tier. The future is not "the agent does everything." The future is "the agent does the tedious work and asks at the right moments."
## The Killer Workflow Is What Did I Miss?
The killer workflow is not email. It is life inbox triage. Every few hours, I want to ask, "What did I miss?" and have the agent scan WhatsApp, Telegram, Gmail, SMS, Calendar, and the relevant Drive changes. Then I want it to tell me who needs a reply, what is urgent, what is stale, what can be ignored, what should become a calendar event, and what needs a document search.
This is the perfect agent task because it is context-heavy, repetitive, cross-tool, and full of small decisions. Humans hate doing the first pass. Agents are good at first passes. Judgment still belongs to me.
The result is not that my life becomes autonomous. The result is that I stop being the person manually digging through five apps to discover the three things that matter.
## My Current Setup Checklist
If someone wants to reproduce my setup, this is the checklist. Install Codex. Install gogcli for Google Workspace. Install wacli for WhatsApp. Install a Telegram connector if you use Telegram. Install imsg for iMessage and SMS. Add browser automation, ideally through Browser Use or a Chrome controller. Add macOS automation through AppleScript and UI scripting. If your knowledge lives in Notion, use the Notion API to export the valuable parts into Google Drive.
Then centralize the data. Make Google Drive the source of truth. Keep contacts in a Google Sheet or CSV. Keep important personal docs as searchable files. Keep local AGENTS.md instructions. Keep small skills for recurring workflows.
Then grant permissions carefully. Full Disk Access is needed for local files and app databases. Screen Recording is useful as a visual fallback. Accessibility is needed for clicking and typing in apps. These are serious permissions, so pair them with serious approval gates.
Then write the operating rules.
```
# Personal Agent Rules
- Draft before sending important messages.
- Sign emails as Nicolas.
- Use gog for Gmail, Drive, Calendar, Docs, and Sheets.
- Use wacli for WhatsApp.
- Use the Telegram connector for Telegram.
- Use imsg for SMS and iMessage.
- Use the contacts CSV for email and phone lookup.
- Prefer APIs and CLIs over browser automation.
- Do not expose private data unless asked.
- Confirm after sending.
```
That is basically it. Tools, data connectors, skills, approval gates, and continuous improvement.
## This Is The New Operating System
The personal computer used to be app-operated. You opened the app, searched, clicked, copied, pasted, wrote, and sent. The agent-operated computer feels different. You state the intent, the agent gathers context, proposes the action, waits for approval when needed, executes, and reports back.
Once you experience this, the old way feels absurd. Why am I manually searching WhatsApp, Gmail, Google Drive, and the web to send one intro? Why am I copying a license plate into five different portals? Why am I reading 100 messages to find the three that matter?
The computer should do that.
The setup is still ugly. The CLIs are rough. Permissions are annoying. Some connectors break. Browser automation is brittle. You have to write skills. You have to maintain a source of truth. But that is how the future usually starts.
The first useful personal agents will not look like polished consumer apps. They will look like a model inside a terminal with access to your files, accounts, memories, and tools.
That is what I use today, and every week I give it one more piece of my life to operate.
## 相关链接
- [Nicolas Bustamante](https://x.com/nicbstme)
- [@nicbstme](https://x.com/nicbstme)
- [199K](https://x.com/nicbstme/status/2060583553449250888/analytics)
- [gogcli](https://github.com/steipete/gogcli)
- [wacli](https://github.com/steipete/wacli)
- [imsg](https://github.com/openclaw/imsg)
- [Browser Use](https://github.com/browser-use/browser-use)
- [gogcli](https://github.com/steipete/gogcli)
- [wacli](https://github.com/steipete/wacli)
- [imsg](https://github.com/openclaw/imsg)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [12:46 PM · May 30, 2026](https://x.com/nicbstme/status/2060583553449250888)
- [199.4K Views](https://x.com/nicbstme/status/2060583553449250888/analytics)
- [View quotes](https://x.com/nicbstme/status/2060583553449250888/quotes)
---
*导出时间: 2026/5/31 10:18:22*
---
## 中文翻译
# 我用于个人生活自动化的智能体技术栈
**作者**: Nicolas Bustamante
**日期**: 2026-05-30T04:46:17.000Z
**来源**: [https://x.com/nicbstme/status/2060583553449250888](https://x.com/nicbstme/status/2060583553449250888)
---
我的智能体管理着我的邮件、短信、WhatsApp、Telegram 以及几乎所有事情，以实现我个人生活的自动化。
人们一直问我在现实生活中是如何使用智能体的。我指的是那些真正让一天时间消失的无聊琐事：阅读 WhatsApp 和 Telegram、寻找某人的电子邮件、搜索网络、起草介绍、更新 Google Drive 中的文档、创建日历事件、检查谁仍需要回复，并且要在那些我已经使用的、混乱的工具中完成所有这些工作。
我的答案简单得令人失望。我将 Codex 作为操作员，置于我真实的生活数据之上。它有工具。它有数据连接器。它有技能。它有单一真实来源。它拥有足够的本地操作权限，以及足够的审批门槛，这样它就不会让我在公开场合难堪。
这基本上就是整个设置。工具、数据连接器、技能和品味。
我过去更多地在 Claude Code 中做这些，但我一直在将设置迁移到 Codex，因为 GPT-5.5 目前是这类工作的更好模型。从 Claude Code 切换到 Codex 并不是重点。重点在于，一旦模型足够好，真正的杠杆效应来自于将其接入你已经生活在其中的世界。
```
MY PERSONAL AGENT STACK
=======================
agent:
Codex
tools:
Gmail / Drive / Calendar / Docs / Sheets -> gog
WhatsApp -> wacli
Telegram -> Telegram connector
iMessage / SMS -> imsg
Browser / Chrome -> browser automation
macOS apps -> AppleScript / UI automation
local files -> filesystem tools
data:
Google Drive as source of truth
contacts in a Google Sheet mirrored as CSV
Notion exported into Drive
local memories and instructions
skills:
inbox-zero
contacts
google-workspace
imessage-cli
personal admin workflows
```
重要的是智能体可以跨越边界。我的个人生活不仅仅存在于一个应用中。它分散在 Gmail、WhatsApp、Telegram、iMessage、Google Drive、日历、Notion、本地文件、随机的 PDF、浏览器会话，以及一个看起来比其实际价值高得多的联系人电子表格之间。
## 一个真实的沟通案例
几天前，一位朋友给我发了一条 WhatsApp 消息。她正在帮助一家旧金山快速发展的人工智能初创公司在法国进行招聘，并希望将他们的招聘经理与我认识的一位招聘人员联系起来。我不记得那位招聘人员的电子邮件。我也不知道这家初创公司最近的融资新闻。我需要搜索 WhatsApp，搜索 Gmail，找到招聘人员的电子邮件，搜索网络，了解为什么这家初创公司值得信赖，起草一封介绍邮件，包含两个职位链接，向我展示草稿，获得批准后发送邮件，然后发短信给我的朋友告知事情已完成。
这通常是二十分钟烦人的应用切换。从 WhatsApp 到 Gmail，到 Google 搜索，再到 Gmail，最后回到 WhatsApp。这不是困难的工作，但它正是那种消耗注意力的工作，因为每一步都是一次微小的上下文切换。
有了智能体，我只要求结果。它阅读了 WhatsApp 对话，在 Gmail 中搜索招聘人员的电子邮件，在网上研究初创公司的融资和最新新闻，起草介绍，等待我的批准，发送邮件，然后发短信给我的朋友告知介绍已完成。面向用户的部分只花了大约十秒钟。智能体做了那些胶水工作（几秒钟内！）！
这就是杀手级模式。智能体不是在“回答问题”。它是在我的各种工具之间操作，以完成一个小型的现实工作流程（也就是一个“待完成的任务”）。
## 车牌案例
另一个例子更加无聊，这也是我喜欢它的原因。我的车换了一块新车牌。我把照片和上下文发送给了 Codex。它更新了我保存在 Google Drive 中的车辆信息 Markdown 文件，更改了车牌，添加了注册备注，保留了现有的 VIN 码、保险、车主和地址，然后将文件上传回 Drive。
仅此一点就很有用，但更好的版本是接下来发生的事情。智能体可以使用浏览器自动化去更新其他所有地方的相同信息：FasTrak、停车应用、保险门户、DMV 相关表格，或任何其他没有清晰 API 的 Web 应用。对于整洁的系统，它应该使用 API 或 CLI。对于混乱的系统，它可以使用浏览器，而且效果非常好！我现在也使用 Codex 的 Computer Use 功能。
这就是个人智能体的用途。不是戏剧性的自主性。而是行政管理的连续性。我总是害怕在后台运行 Openclaw 的 yolo 模式。我更喜欢保持掌控。
## Google Drive 是我的单一真实来源
我做出的最重要的架构决策是将有价值的个人信息集中到 Google Drive 中。多年来，我的很多知识都存在于 Notion 中。我喜欢 Notion 作为人类的工作空间，但我不喜欢它作为智能体的主要单一真实来源。API 可用，但工作空间太不稳定：嵌套页面、数据库、属性、权限、格式、反向链接，以及大量对人类来说很愉快但对模型来说很讨厌的 UI 原生结构。
所以我使用 Notion API 导出有价值的信息并将其移动到 Google Drive。我不是试图完美地保留 Notion 工作空间。我是试图让信息对智能体可读。Drive 中最有用的信息大多是 Markdown 或 CSV，因为这些格式对于智能体来说，无需繁琐的仪式即可搜索、对比、编辑和上传。Google Drive 成为单一真实来源，是因为 gogcli 为智能体提供了 Gmail、Drive、日历、文档、表格、联系人和任务的简单命令行界面。
这是一个被低估的观点。你不应该仅仅为了人类 UI 来组织你的知识。你应该为智能体的工具路径来组织它。智能体喜欢稳定的文件 ID、文本、表格、Markdown、CSV 以及返回 JSON 的命令。如果智能体可以搜索、下载、编辑、上传它，并能引用其来源，那么数据就是有用的。
我的个人数据层简单得令人尴尬。Google Drive 保存着重要文档，主要是 Markdown 文件和 CSV。联系人存放在一个 Google Sheet 中，并映射为 CSV。Notion 导出内容存放在 Drive 中。本地指令存放在 AGENTS.md 中。技能以 Markdown 文件的形式存放在文件夹中。单一真实来源并不优雅，但清晰可读。
```
DATA LAYER
==========
Google Drive:
personal docs
car docs
family docs
exported Notion pages
PDFs
spreadsheets
Google Sheets / CSV:
contacts
phone numbers
emails
categories
locations
notes
Local files:
AGENTS.md
memories
skills
scripts
blog repo
```
很多个人生产力工作只是对这些数据的交叉连接。一个事实在 WhatsApp 里。另一个在 Gmail 里。电子邮件地址在联系人里。日期在日历里。文档在 Drive 里。当智能体可以跨越这些边界而不需要我来充当胶水时，它就变得有用了。
我做过的最好投资之一是创建了一个 contact.csv，里面包含了我认识的所有人的电话、电子邮件、linkedin 等信息。
## 工具
核心工具在设计上很无聊。我使用 gogcli 处理 Google Workspace，wacli 处理 WhatsApp，imsg 处理 iMessage 和 SMS，对于 Web 应用使用 Browser Use 或浏览器自动化，当没有更好的界面时使用 AppleScript 或 macOS UI 自动化。
层级很简单。API 和 CLI 最好。本地文件很棒。浏览器自动化可以接受。屏幕自动化是最后的手段。
```
BEST TOOL SURFACE
=================
API and CLI
>
local file
>
browser automation
>
screen automation
```
这个层级很重要，因为智能体的可靠性取决于其工具表面的可靠性。要求模型在网站上点击有时是必要的，但这并不是理想的路径。像 gog gmail messages list 或 wacli messages list --json 这样的命令，对于模型来说更容易检查、重试和推理。
以下是工具层在实际应用中的样子：
```
# Gmail
gog gmail messages list '"Firstname Lastname"' --max 10 --include-body
gog gmail get <messageId>
gog gmail send --to robin@example.com --subject "Intro" --body-file draft.txt
# Drive
gog drive search "lexus_rx_info.md"
gog drive download <fileId>
gog drive upload ./file.md --replace <fileId>
# WhatsApp
wacli chats list --query "Friend Name" --json
wacli messages list --chat 16282358390@s.whatsapp.net --limit 20 --json
wacli send text --to 16282358390@s.whatsapp.net --message "Done"
# Telegram
# same pattern: list chats, read history, search, draft, send after approval
# Calendar
gog calendar create primary \
--summary "Picnic in Golden Gate Park" \
--from "2026-05-31T11:00:00-07:00" \
--to "2026-05-31T13:00:00-07:00"
```
这些看起来都不像科幻小说。这就是重点。个人智能体的未来始于一堆命令，这些命令让模型操作你已经使用的工具。你希望尽可能减少模型与 API 之间的抽象层。
## 技能
工具赋予智能体双手。技能赋予它习惯。技能只是一本小小的操作手册，告诉智能体如何按照我喜欢的方式完成一项重复性任务。
我的 inbox-zero 技能就是一个很好的例子。它告诉智能体通过 gog 列出 Gmail 收件箱邮件，区分自动归档和需要审查的邮件，向我展示重要邮件，引用内容实质，建议归档或回复，起草回复，等待明确批准，在原始线索中发送，保留所有收件人，仅在发送后归档，保持回复简短，除非我要求否则不要建议通话，并署名“Nicolas”。
这不是一个花哨的架构。这是一个流程。但流程就是产品……而且它只是文本指令。
如果没有这个技能，我每次都必须充当提示词。我必须提醒智能体未经批准不得发送，不要遗漏抄送收件人，不要建议通话，不要使用一些奇怪的公司签名署名。有了这个技能，我说“运行 inbox zero”，工作流程就已经包含了我的品味。
重要的习惯是，每当智能体犯错时，我都会改进这个技能。如果在我讨厌通话的时候它建议通话，我就加上这条规则。如果它忘记了保留抄送收件人，我就加上这条规则。如果它归档得太激进，我就收紧分类。智能体变得更好是因为流程变得更好了。
这就是个人智能体变得个性化的方式。不是通过有一个可爱的声音。而是通过积累操作品味。
```
TOOLS + DATA CONNECTORS + SKILLS + FEEDBACK
===========================================
tool fails once
v
fix the tool or add a guardrail
agent makes a judgment mistake
v
update the skill
agent forgets a preference
v
write it into memory or AGENTS.md
workflow repeats
v
personal agent improves
```
这个设置之所以能复利增长，是因为错误变成了指令。
## 审批门槛就是产品
我不想要一个盲目回复所有人的智能体。我想要一个能准备工作、向我展示草稿并在正确时刻提问的智能体。对于大多数沟通工作流程，循环是：阅读上下文、起草回复、展示给我、等待批准、发送、确认。
有时当风险较低时，我会让它直接发送。“告诉 Hugo 我下周在西雅图”这不需要开个董事会会议。但是投资者邮件、客户回复、介绍，或任何具有社交细微差别的事情都应该先起草。
这就是有用与可怕的区别。只读扫描是一个信任层级。起草是另一个层级。发送是另一个层级。删除、付款、签名或更改账户设置是完全不同的层级。未来不是“智能体做所有事情”。未来是“智能体做繁琐的工作并在正确时刻提问”。
## 杀手级工作流是“我错过了什么？”
杀手级工作流不是电子邮件。而是生活收件箱分类。每隔几个小时，我想问“我错过了什么？”，并让智能体扫描 WhatsApp、Telegram、Gmail、短信、日历和相关的 Drive 更改。然后我希望它告诉我谁需要回复，什么是紧急的，什么是陈旧的，什么可以忽略，什么应该成为日历事件，什么需要文档搜索。
这是完美的智能体任务，因为它上下文繁重、重复、跨工具且充满了微小的决策。人类讨厌做第一轮筛选。智能体擅长做第一轮筛选。判断权仍属于我。
结果并不是我的生活变得自主了。结果是我不再成为那个手动在五个应用中挖掘以发现三件重要事情的人。
## 我当前的设置清单
如果有人想复现我的设置，这就是清单。安装 Codex。为 Google Workspace 安装 gogcli。为 WhatsApp 安装 wacli。如果你使用 Telegram，请安装 Telegram 连接器。为 iMessage 和短信安装 imsg。添加浏览器自动化，最好通过 Browser Use 或 Chrome 控制器。通过 AppleScript 和 UI 脚本添加 macOS 自动化。如果你的知识存在于 Notion 中，请使用 Notion API 将有价值的部分导出到 Google Drive。
然后集中数据。让 Google Drive 成为单一真实来源。将联系人保存在 Google Sheet 或 CSV 中。将重要的个人文档保存为可搜索的文件。保存本地 AGENTS.md 指令。为重复性工作流程保留小技能。
然后谨慎授予权限。本地文件和应用数据库需要完全磁盘访问权限。屏幕录制权限作为视觉后备很有用。辅助功能权限用于在应用中点击和输入。这些都是严重的权限，所以要配合严格的审批门槛。
然后编写操作规则。
```
# Personal Agent Rules
- Draft before sending important messages.
- Sign emails as Nicolas.
- Use gog for Gmail, Drive, Calendar, Docs, and Sheets.
- Use wacli for WhatsApp.
- Use the Telegram connector for Telegram.
- Use imsg for SMS and iMessage.
- Use the contacts CSV for email and phone lookup.
- Prefer APIs and CLIs over browser automation.
- Do not expose private data unless asked.
- Confirm after sending.
```
基本上就是这样。工具、数据连接器、技能、审批门槛和持续改进。
## 这就是新的操作系统
个人计算机过去是由应用操作的。你打开应用、搜索、点击、复制、粘贴、编写、发送。智能体操作的计算机感觉不同。你陈述意图，智能体收集上下文、提议行动、在需要时等待批准、执行并报告。
一旦你体验了这一点，旧的方式就会显得荒谬。为什么我要手动搜索 WhatsApp、Gmail、Google Drive 和网络只为了发送一封介绍信？为什么我要把车牌复制到五个不同的门户？为什么要阅读 100 条消息只为了找出三条重要的？
计算机应该做这些。
设置仍然很丑陋。CLI 很粗糙。权限很烦人。一些连接器会中断。浏览器自动化很脆弱。你必须编写技能。你必须维护单一真实来源。但这通常就是未来的开始。
第一个有用的个人智能体看起来不会像精美的消费者应用。它们看起来会像一个在终端里的模型，可以访问你的文件、账户、记忆和工具。
这就是我今天正在使用的，每周我都会让它多接管我生活中的一小部分。
## 相关链接
- [Nicolas Bustamante](https://x.com/nicbstme)
- [@nicbstme](https://x.com/nicbstme)
- [199K](https://x.com/nicbstme/status/2060583553449250888/analytics)
- [gogcli](https://github.com/steipete/gogcli)
- [wacli](https://github.com/steipete/wacli)
- [imsg](https://github.com/openclaw/imsg)
- [Browser Use](https://github.com/browser-use/browser-use)
- [gogcli](https://github.com/steipete/gogcli)
- [wacli](https://github.com/steipete/wacli)
- [imsg](https://github.com/openclaw/imsg)
- [Upgrade to Premium](https