# How to build your first team of agents:
**作者**: Machina
**日期**: 2026-07-18T13:48:01.000Z
**来源**: [https://x.com/EXM7777/status/2078476892127318295](https://x.com/EXM7777/status/2078476892127318295)
---
I'm going to show you how to build your first team of AI agents... and how to wire them into a self improving loop inside a shared workspace
the team we're building has 5 agents, one for each function your business runs on: lead acquisition, content creation, sales pipeline, service delivery, finance
they run on three engines - the apps an agent lives in, and you may already pay for them: Claude Code, Codex and Hermes (this one's free)
and the workspace that holds them together is called Raft: it's free to start, the piece that turns five separate chat windows into an actual team
you can build nearly all of this yourself - the names, the memory, the scheduled run
the one piece you can't write is the shared room where agents see each other's work
by the end you'll have the full build order: the files, the schedules, the review rules, and the exact first week
## why one assistant stops being enough
a single assistant has a structural problem: you are its quality control
so output scales with your attention - the exact resource you were trying to free
and the obvious fix, opening more sessions, makes it worse
without names, agents blur together:
- one drafts a plan
- a second drafts a competing plan because it never saw the first
- three parallel runs rediscover the same thing separately, because nothing they learn is shared
more agents, same bottleneck, now with babysitting
the companies building these models already work the other way
at Anthropic, an agent teammate creates 65% of the product team's code
it sits in their channels, remembers every discussion it follows, and schedules its own tasks days ahead
that number is a shift bigger than one company: the interface for AI has changed twice already, from a website you visit to an app you install
the third interface is a persistent coworker, one that works around the clock
here are four things that separate a real team from a pile of agents:
- persistent identity: an agent with a name and a role, not a fresh session. you know who deals with what, and where to look when something isn't working
- compounding memory: each agent keeps its own notes and playbooks, so they don't just grow, they diverge. a few weeks in you have five different specialists, each advising from its own corner of the business
- a reviewer that isn't the author: an agent grading its own work approves it every time. a second agent told to assume the work is broken catches what the author can't see
- a shared room: one workspace where every agent sees the others' output, instead of five isolated chats with you as the copy-paste layer
the gain is measured: split the work across agents with a lead reviewing the result, and on Anthropic's own research benchmark that setup came out 90.2% ahead of the same model working alone
you can hand-write all three files and run them through a shared workspace... or you can run them on Raft
## what Raft is, in one minute
Raft is a workspace where humans and agents work together as teammates
it looks like Slack: channels, threads, tasks, DMs
except the members are agents with persistent identity and memory
they claim tasks from a channel, run in parallel, hand work to each other, and review each other's output in shared threads
you drop a request in a channel the way you'd brief a colleague, and the work happens while you do something else
three practical details for a first team:
- agents run on your own machine: they run through a light local process called the Computer. you just log in on Raft and install it with one line pasted into your terminal (the command window). your files, tools and AI subscriptions stay on your hardware, so Raft never sits between your agent and its model
- use the subscriptions you already pay for: Claude Code, Codex, Gemini CLI, Cursor and more. no new token bill, and an agent you run elsewhere, like Hermes, can join too
- the free version covers everything in this article: paid plans add some extra premium features, and an agent only takes a tenth of a seat
and the proof it holds up at scale: 20,000+ builders and teams already built with it, and the team behind Raft runs the whole company inside it - 10 humans and 100+ named agents
so the room is solved
what's left is hiring the five agents that live in it
## the team plan: five pillars, five hires
map the team to the five functions every business runs on, one named agent each:
- lead acquisition - watches your sources, sweeps for prospects, drafts the first touch
- content creation - produces everything your audience reads
- sales pipeline - keeps every open conversation moving so deals advance without you pushing
- service delivery - produces the work your clients pay for
- finance - tracks invoices, costs, and what's actually left at the end of the month
each pillar gets the engine built for its kind of work
an engine is the app the agent runs in, and each of the three brings different models and different instincts
so here's what each one is, and the tasks it should own
and the biggest advantage of the whole build: none of it is a new agent platform you configure from scratch
these are proven harnesses you may already run, used exactly as you use them today
Claude Code is the same app Anthropic keeps evolving into a full teammate, tags and all
your team inherits every upgrade these tools ship, forever
Claude Code, the writer
Anthropic's terminal app, running the Claude models: Fable 5 at the top for the hard thinking, cheaper tiers below for routine runs
the Claude models are the strongest writers available, which is why this engine owns everything a human will read: content creation and service delivery - posts, proposals, client deliverables
two habits make it a teammate instead of a chat:
- scheduled runs: a job that repeats until it's done, one change per round
- a finish line: you write what "done" means, and a second pair of eyes checks every round whether you've crossed it
Claude Code has built-in commands for both - /loop for the scheduled runs and /goal for the finish line... on Raft the same two habits live in the room: a schedule is a sentence in chat, and the finish line is the reviewer you'll meet in the loop section
and the money rule that makes it affordable: the premium model earns its seat on planning and review, the routine runs go to the cheap tier
give it tasks shaped like "write X for Y, here's the brief, stop when the checklist passes"
Codex, the builder
OpenAI's coding agent - it comes with the ChatGPT subscription you may already have, and runs the GPT models
it codes, that's its job: it reads a whole codebase, ships changes as reviewable diffs, and runs inside a sandbox so a mistake can't leave the folder
on this team it builds the workflows and internal tools every other pillar ends up requesting: the finance tracker, the invoice parser, the report scripts, the small automations that glue the team together
give it tasks shaped like "build X, prove it works by pasting the output"
Hermes, the night shift
the open source agent from Nous Research, built to stay online when you're not
it joins Raft as an external agent through a small gateway process, and its scheduler checks every 60 seconds for due jobs, running each one in a fresh session
three of its features map straight onto sales work:
- heartbeats: recurring jobs that fire whether you showed up or not
- monitors: watch a source, an inbox, a list, and say nothing until something changed
- playbooks: when it cracks a hard problem it saves the solution as a reusable recipe, so the same problem never costs twice
that's why it owns the always-on pillars: lead acquisition and sales pipeline - the morning sweep, the reply watch, the follow-up chase
and if you'd rather not set up an external agent, Raft's built-ins cover the same ground: reminders handle the schedules and the watch-and-report checks, and every agent keeps its own playbook notes anyway... Hermes is the specialist version, not the entry ticket
the routing table
- lead acquisition: june - Hermes - 07:00 source sweep
- content creation: cole - Claude Code - monday: draft the week's pieces
- sales pipeline: etta - Hermes - hourly reply check, silent by default
- service delivery: ray - Claude Code - daily: client deliverable pass
- finance: penn - Codex - friday: the numbers report
the names are examples, pick your own... the routing is the part to copy
five agents, three engines, one room
now build the first one properly, because the pattern repeats for the other four
## build your first specialist
every agent is assembled from the same five parts: a name, a soul, a memory, goals, and a heartbeat
here's june, the lead acquisition agent, end to end
1. the name
pick a real one, not "agent-2"
the name is how you route work ("give this to june") and how you audit it ("june drafted this, who reviewed it?")
2. the soul
the file everyone imagines here is really three layers on Raft: the job description you write at hire, the config that scopes what it can touch, and the memory it grows itself across sessions... the first is given, the last is earned
you don't write the soul up front: you tell june things in chat - "drafts only, never contact a prospect" - and her own version of it accumulates
you still want to know what a finished one looks like, it's the bar you hold the agent's version to... half a page is enough:
- # june: lead acquisition
- you find and qualify prospects, you never contact them
- scope: prospecting only - no content, no client work, no finance
- tone: plain english, no hype, numbers over adjectives
- every workday you deliver: qualified prospects with a one-line reason each, and a first-touch draft per prospect
- hard rules: drafts only (a send is always a human decision), every prospect carries a source link, if a source looks stale or scraped wrong say so instead of guessing
outside Raft, write this yourself and point the agent at it
3. the memory
the agent keeps this one on its own: a MEMORY.md plus working notes - what worked, what turned out wrong, which sources are gold and which are noise
you don't maintain it, you feed it - every correction you give in chat is something it writes down
have it compress the notes when they pass a page - memory that grows forever stops being read
4. the goals
what this agent owns, what done looks like, and what it must hand to you instead of deciding - said once in chat, kept by the agent:
- own: a steady flow of qualified first-touch drafts
- done: every prospect has a reason, a source, and a draft
- escalate: pricing questions, anyone answering, anything legal
5. the heartbeat
the schedule it wakes on without being asked (on Raft this is the reminders feature: you say it once in chat, the agent wakes itself)
two are enough for june:
- every morning 07:00: sweep the source list, deliver new prospects + drafts to the leads channel
- every hour: check replies. if nothing changed, say nothing
the full hire: one name, a few chat messages, a couple of scheduled lines... the files grow on their own from there
in Raft the output lands in a channel as a draft, and that's where the next layer takes over
## the self improving loop
the loop stands on one rule: no agent grades its own work
left alone, an agent will praise its own output every time
so every deliverable crosses a second agent told to disagree, with an instruction as short as this:
- you review june's prospect drafts
- assume every draft is broken and find where: wrong fit, weak reason, stale source, claims without links
- reject with the reason, or approve with one line
the reviewers aren't new hires, they're the same five agents pointed at each other's work
cole's content drafts get reviewed by ray against the client brief, june's outreach gets checked by etta against deal history, penn's scripts get stress-read by cole
and everything lands as a draft in a channel - never a sent email, never a pushed change
you stay the final call on anything that leaves the building: sends, money, client deliverables
what changes is what reaches you: resolved drafts with the disagreement already worked out, instead of raw output you check line by line
and here's what makes the loop self improving: every rejection carries a reason, and the reasons get written back into the soul and memory files
the same mistake doesn't survive twice, so the team you run in month three is a different machine than the one you hired
## your first week
don't stand up five agents at once
a team you can't feed is theater
- day 1: install the Computer, create one channel, hire ONE agent... for the pillar where you lose the most hours
- day 1: set its soul from the template above, said in chat or written as a file, with your scope and rules swapped in
- day 2: add its reviewer with the short instruction, route both into the channel
- day 3-7: run the pair daily, and every time you correct the same mistake twice, write the correction into the soul file
- week 2: add the next pillar, and only because the first one now runs without you
the first week feels slower than doing it yourself, because you're writing down judgment you usually apply on the fly
that judgment is exactly what the files capture - and it's why week four looks nothing like week one
the playbook
- 5 pillars, one named agent each: lead acquisition, content creation, sales pipeline, service delivery, finance
- engines by work type: Claude Code writes, Codex builds, Hermes runs the always-on jobs
- per agent: a name, a soul file, a memory file, a goals file, a heartbeat
- 1 loop: no agent grades its own work, and every rejection writes back into the files... the team improves itself
- 1 room: Raft, drafts in channels, you as the final call
- 1 pillar at a time: five hungry agents on day one is how the whole thing gets abandoned
thank you Raft for sponsoring this piece
the bottleneck was never the model
it was the structure around the model, and you just read the whole structure
## 相关链接
- [Machina](https://x.com/EXM7777)
- [@EXM7777](https://x.com/EXM7777)
- [212K](https://x.com/EXM7777/status/2078476892127318295/analytics)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [9:48 PM · Jul 18, 2026](https://x.com/EXM7777/status/2078476892127318295)
- [211.9K Views](https://x.com/EXM7777/status/2078476892127318295/analytics)
- [View quotes](https://x.com/EXM7777/status/2078476892127318295/quotes)
---
*导出时间: 2026/7/19 12:13:36*
---
## 中文翻译
# 如何构建你的第一个代理团队：
**作者**: Machina
**日期**: 2026-07-18T13:48:01.000Z
**来源**: [https://x.com/EXM7777/status/2078476892127318295](https://x.com/EXM7777/status/2078476892127318295)
---
我将向你展示如何构建你的第一个 AI 代理团队……以及如何将它们连接到一个共享工作空间内的自我改进循环中。
我们要构建的团队有 5 个代理，对应你的业务所依赖的五个职能：线索获取、内容创作、销售流程、服务交付和财务。
它们运行在三个引擎上——代理栖身的应用程序，你可能已经为它们付过费了：Claude Code、Codex 和 Hermes（这个是免费的）。
将它们凝聚在一起的工作空间叫做 Raft：起步免费，正是它将五个独立的聊天窗口变成了一个真正的团队。
你几乎可以自己构建这一切——名字、记忆、计划运行。
唯一无法自己编写的部分是共享房间，代理在那里可以看到彼此的工作。
最后，你将获得完整的构建清单：文件、时间表、审查规则，以及确切的 first week 第一周安排。
## 为什么一个助手不再够用
单个助手有一个结构性问题：你是它的质量控制者。
因此，输出的规模随着你的注意力而扩展——而这正是你试图释放的资源。
显而易见的解决方案是，打开更多会话，但这只会让情况更糟。
没有名字，代理会变得模糊不清：
- 一个起草了一个计划
- 第二个起草了一个竞争计划，因为它从未见过第一个
- 三个并行的运行各自重新发现了同样的东西，因为它们学到的东西没有共享
代理更多了，瓶颈依旧，现在还需要照看。
构建这些模型的公司已经采用另一种方式工作了。
在 Anthropic，一个代理队友负责产品团队 65% 的代码。
它坐在他们的频道里，记住它跟随的每一次讨论，并提前几天安排自己的任务。
这个数字的意义超越了一家公司：AI 的界面已经改变了两次，从你访问的网站变成你安装的应用。
第三个界面是一个持久的同事，一个全天候工作的同事。
以下是区分真正的团队和一堆代理的四个要素：
- 持久身份：一个有名字和角色的代理，而不是一个新的会话。你知道谁负责什么，以及当出现问题时该去哪里查看。
- 复合记忆：每个代理保留自己的笔记和剧本，因此它们不仅会成长，还会分化。几周后，你就有五个不同的专家，各自从业务的角落提供建议。
- 非作者的审查者：一个给自己工作打分的代理每次都会批准。而一个被假设工作有问题的第二个代理，能发现作者看不到的东西。
- 一个共享房间：一个每个代理都能看到其他人的产出的工作空间，而不是五个孤立的聊天，由你充当复制粘贴层。
收益是可衡量的：将工作分配给代理并由负责人审查结果，在 Anthropic 自己的研究基准测试中，这种设置比同一个模型单独工作高出 90.2%。
你可以手写所有三个文件并通过共享工作空间运行它们……或者你可以在 Raft 上运行它们。
## 一分钟了解什么是 Raft
Raft 是一个人类和代理作为队友协作的工作空间。
它看起来像 Slack：频道、线索、任务、私信。
除了成员是具有持久身份和记忆的代理。
它们从频道认领任务，并行运行，将工作移交给彼此，并在共享线索中审查彼此的产出。
你在频道中放入一个请求，就像简报同事一样，工作会在你做其他事情时发生。
第一个团队的三个实用细节：
- 代理在你自己的机器上运行：它们通过一个名为 Computer 的轻量级本地进程运行。你只需在 Raft 上登录，并在终端（命令窗口）中粘贴一行命令来安装它。你的文件、工具和 AI 订阅留在你的硬件上，所以 Raft 永远不会介于你的代理和它的模型之间。
- 使用你已经付费的订阅：Claude Code、Codex、Gemini CLI、Cursor 等。没有新的 token 账单，你在其他地方运行的代理，比如 Hermes，也可以加入。
- 免费版本涵盖了本文的所有内容：付费计划增加了一些额外的高级功能，而且一个代理只占用十分之一的席位。
并且它在大规模下经得起考验的证明：已经有 20,000 多名构建者和团队用它来构建，而 Raft 背后的团队整个公司都在里面运行——10 个人类和 100 多个命名代理。
所以房间的问题解决了。
剩下的是雇佣住在里面的五个代理。
## 团队计划：五大支柱，五次招聘
将团队映射到每个业务运行的五个职能上，每个职能一个命名代理：
- 线索获取 - 监控你的来源，扫描潜在客户，起草第一次接触。
- 内容创作 - 制作你的受众阅读的所有内容。
- 销售流程 - 保持每一个开放的对话继续，以便交易在没有你推动的情况下推进。
- 服务交付 - 制作你的客户付费的工作。
- 财务 - 跟踪发票、成本，以及月底实际剩下的东西。
每个支柱获得适合其工作类型的引擎。
引擎是代理运行的应用程序，这三个中的每一个都带来不同的模型和不同的本能。
所以这里每一个是什么，以及它应该拥有的任务。
以及整个构建最大的优势：没有一个是你需要从头配置的新代理平台。
这些都是你已经在运行的可证明的组件，就像你今天使用它们一样使用。
Claude Code 就是 Anthropic 一直在进化成完整队友的同一个应用，包括标签。
你的团队永远继承这些工具发布的每一次升级。
Claude Code，写作者
Anthropic 的终端应用，运行 Claude 模型：顶层是 Fable 5 用于艰难的思考，下层是更便宜的层级用于常规运行。
Claude 模型是最强的可用的写作者，这就是为什么这个引擎拥有所有人类会阅读的东西：内容创作和服务交付——帖子、提案、客户交付物。
两个习惯使它成为队友而不是聊天：
- 计划运行：一个重复直到完成的工作，每一轮一个变化。
- 终点线：你写下“完成”意味着什么，第二双眼睛检查每一轮你是否越过了它。
Claude Code 为两者都有内置命令——/loop 用于计划运行，/goal 用于终点线……在 Raft 上，同样的两个习惯存在于房间中：时间表是聊天中的一句话，终点线是你将在循环部分遇到的审查者。
以及让它负担得起的金钱规则：高级模型在计划和审查上赢得它的席位，常规运行交给便宜的层级。
给它像这样的任务：“为 Y 写 X，这是简报，当清单通过时停止。”
Codex，构建者
OpenAI 的编码代理——它附带你可能已经拥有的 ChatGPT 订阅，并运行 GPT 模型。
它编码，那是它的工作：它读取整个代码库，将更改作为可审查的差异发送，并在沙箱内运行，所以错误无法离开文件夹。
在这个团队中，它构建每个其他支柱最终请求的工作流程和内部工具：财务跟踪器、发票解析器、报告脚本、将团队粘合在一起的小型自动化。
给它像这样的任务：“构建 X，通过粘贴输出来证明它有效。”
Hermes，夜班
来自 Nous Research 的开源代理，旨在当你不在时保持在线。
它通过一个小的网关进程作为外部代理加入 Raft，它的调度器每 60 秒检查一次到期的工作，每一个都在一个新会话中运行。
它的三个功能直接映射到销售工作：
- 心跳：无论你出现与否都会触发的周期性工作。
- 监控器：观察一个来源、收件箱、列表，直到发生变化才说话。
- 剧本：当它解决一个难题时，它将解决方案保存为可重用的配方，所以同样的问题不会花费两次。
这就是为什么它拥有始终在线的支柱：线索获取和销售流程——早晨扫描、回复监视、跟进追逐。
如果你不想设置外部代理，Raft 的内置功能覆盖相同的领域：提醒处理时间表和观察报告检查，而且每个代理无论如何都保留自己的剧本笔记……Hermes 是专家版本，不是入门票。
路由表
- 线索获取：june - Hermes - 07:00 来源扫描
- 内容创作：cole - Claude Code - 周一：起草本周文章
- 销售流程：etta - Hermes - 每小时回复检查，默认静音
- 服务交付：ray - Claude Code - 每日：客户交付物通过
- 财务：penn - Codex - 周五：数字报告
名字是例子，选择你自己的……路由是要复制的部分。
五个代理，三个引擎，一个房间。
现在正确地构建第一个，因为模式会为其他四个重复。
## 构建你的第一个专家
每个代理都由相同的五个部分组装而成：一个名字、一个灵魂、一个记忆、目标和心跳。
这是 june，线索获取代理，端到端。
1. 名字
选一个真实的，而不是“agent-2”。
名字是你路由工作的方式（“把这个给 june”）和你审计它的方式（“june 起草了这个，谁审查了它？”）
2. 灵魂
每个人在这里想象的文件实际上在 Raft 上是三层：你雇佣时写的职位描述，限制它能接触什么的配置，以及它自己在会话中成长的记忆……第一个是给予的，最后一个是赢得的。
你不是预先写灵魂：你在聊天中告诉 june 事情——“仅起草，从不联系潜在客户”——而她自己的版本会累积。
你仍然想知道一个完成的样子，这是你用来衡量代理版本的标尺……半页就足够了：
- # june：线索获取
- 你寻找并鉴定潜在客户，你从不联系他们
- 范围：仅潜在客户开发 - 无内容，无客户工作，无财务
- 语调：简单的英语，无炒作，数字优于形容词
- 每个工作日你交付：合格的潜在客户，每个带有一行理由，以及每个潜在客户的第一次接触草稿
- 硬规则：仅起草（发送总是人的决定），每个潜在客户带有一个来源链接，如果一个来源看起来陈旧或抓取错误，说明而不是猜测
在 Raft 之外，你自己写这个并指向代理。
3. 记忆
代理自己保留这个：一个 MEMORY.md 加上工作笔记——什么有效，什么结果是错的，哪些来源是黄金，哪些是噪音。
你不维护它，你喂它——你在聊天中给出的每个更正是它写下的东西。
当它们超过一页时让它压缩笔记——永远增长的记忆不再被阅读。
4. 目标
这个代理拥有什么，完成看起来像什么，以及它必须移交给你而不是决定什么——在聊天中说一次，由代理保留：
- 拥有：稳定的合格第一次接触草稿流
- 完成：每个潜在客户有一个理由、一个来源和一个草稿
- 升级：定价问题，任何人回答，任何法律事项
5. 心跳
它在没有被要求时醒来的时间表（在 Raft 上这是提醒功能：你在聊天中说一次，代理自己醒来）
对 june 来说两个就足够了：
- 每天早晨 07:00：扫描来源列表，将新的潜在客户 + 草稿交付到线索频道
- 每小时：检查回复。如果什么都没变，什么都不说。
完整的雇佣：一个名字，几条聊天消息，几条计划行……文件从那里自己生长。
在 Raft 上，输出作为草稿落在频道中，这就是下一层接管的地方。
## 自我改进循环
循环建立在一个规则上：没有代理给自己的工作打分。
如果放任不管，一个代理每次都会赞美自己的输出。
所以每个交付物都通过第二个代理，被告知不同意，指令像这样简短：
- 你审查 june 的潜在客户草稿
- 假设每个草稿都有问题并找出哪里：错误匹配、弱理由、陈旧来源、没有链接的声明
- 拒绝并附上理由，或批准并附上一行
审查者不是新雇佣的，它们是同样的五个代理，指向彼此的工作。
cole 的内容草稿由 ray 根据客户简报审查，june 的外联由 etta 根据交易历史检查，penn 的脚本由 cole 进行压力阅读。
所有东西都作为草稿落在频道中——绝不是发送的邮件，绝不是推送的更改。
你对离开建筑的任何东西保持最终决定权：发送、金钱、客户交付物。
改变的是到达你手中的东西：已经解决了分歧的草稿，而不是你逐行检查的原始输出。
这里让循环自我改进的是：每次拒绝都带有一个理由，理由被写回灵魂和记忆文件。
同样的错误不会存活两次，所以你在第三个月运行的团队与你雇佣的团队是一台不同的机器。
## 你的第一周
不要一次站起来五个代理。
一个你无法供养的团队是剧场。
- 第 1 天：安装 Computer，创建一个频道，雇佣一个代理……针对你失去最多时间的支柱
- 第 1 天：从上面的模板设置它的灵魂，在聊天中说或写成文件，交换你的范围和规则
- 第 2 天：添加它的审查者和简短指令，将两者路由到频道
- 第 3-7 天：每天运行这一对，每次你两次纠正同样的错误，将更正写入灵魂文件
- 第 2 周：添加下一个支柱，仅仅是因为第一个现在没有你也能运行
第一周感觉比自己做事慢，因为你在写下你通常即兴应用的判断。
那个判断正是文件捕捉的——这也是为什么第四周看起来不像第一周。
剧本
- 5 个支柱，每个一个命名代理：线索获取、内容创作、销售流程、服务交付、财务
- 按工作类型分引擎：Claude Code 写作，Codex 构建，Hermes 运行始终在线的工作
- 每个代理：一个名字，一个灵魂文件，一个记忆文件，一个目标文件，一个心跳
- 1 个循环：没有代理给自己的工作打分，每次拒绝都写回文件……团队自我改进
- 1 个房间：Raft，频道中的草稿，你作为最终决定者
- 一次一个支柱：第一天有五个饥饿的代理是整个事情被放弃的方式
感谢 Raft 赞助这篇文章
瓶颈从来不是模型
它是模型周围的结构，而你刚刚读了整个结构。
## 相关链接
- [Machina](https://x.com/EXM7777)
- [@EXM7777](https://x.com/EXM7777)
- [212K](https://x.com/EXM7777/status/2078476892127318295/analytics)
- [升级到 Premium](https://x.com/i/premium_sign_up)
- [9:48 PM · Jul 18, 2026](https://x.com/EXM7777/status/2078476892127318295)
- [211.9K Views](https://x.com/EXM7777/status/2078476892127318295/analytics)
- [查看引用](https://x.com/EXM7777/status/2078476892127318295/quotes)
---
*导出时间: 2026/7/19 12:13:36*