# I Built a 5 Tool AI Stack Where Each Tool Does Something the Others Cannot. Here Is the Full Build.
**作者**: Dami-Defi
**日期**: 2026-05-29T10:52:07.000Z
**来源**: [https://x.com/DamiDefi/status/2060313230585536980](https://x.com/DamiDefi/status/2060313230585536980)
---
Most people running an AI stack in 2026 are using one tool for everything.
That is not a workflow. That is a hammer looking for nails.
The operators pulling real leverage from AI are not using more tools than everyone else. They are using the right tool for each layer of their operation. Research. Building. Memory. Automation. Execution. Each layer has a tool that owns it in a way nothing else can replicate.
These are the five. What each one does that the others cannot. And the exact prompts and setups to get there.
## 1. Claude — The Reasoning and Context Layer
Claude is not on this list because it is the most popular. It is on this list because nothing else reasons the way it does at depth, holds context across a 200K token window without degrading, and produces written output that consistently sounds like a human who knows the subject.
In a 30-day independent test by Ryz Labs, Claude reached approximately 95% functional accuracy on coding tasks compared with approximately 85% for ChatGPT. By late 2025 and early 2026, approximately 70% of developers reported preferring Claude for coding tasks specifically. The reason comes up consistently: Claude writes cleaner code, handles multi-file projects more reliably, and is more honest about what it does not know.
The three things Claude does that no other tool on this list can replace:
What it does best 1: Long-document reasoning without degradation
Every other AI tool loses coherence as the context window fills. Claude maintains argument integrity across a 200K token window, which means you can load an entire research corpus, a full codebase, or months of notes and the output at token 150,000 is as sharp as the output at token 1,000. This is the foundation that makes Claude Projects genuinely powerful for knowledge-intensive work.
Prompt
> I am going to paste a long document. Before you analyse it, read the entire thing without producing any output. Then tell me: what is the central argument, what are the three weakest points in the reasoning, and what is the single most important implication the author did not explicitly state?[PASTE DOCUMENT]
What it does best 2: Instruction-following precision
Claude is the tool that best follows instructions even after the GPT-5.2 and Gemini 3 releases. It follows every detail even in long prompts. When your prompt has ten specific formatting rules, five constraints, and a defined output structure, Claude is the tool that honours all of them on the first attempt without requiring correction.
Prompt
> You are operating under these rules for this entire conversation. No exceptions.1. Never use bullet points in prose sections 2. Every claim must be followed immediately by the evidence or reasoning behind it 3. No em dashes 4. Short paragraphs — maximum four sentences 5. End every section with the most important implication, not a summaryConfirm you have read these rules before I give you the task.
What it does best 3: Building systems through Projects and MCP
Claude Projects give it persistent memory across every conversation inside a project. MCP connections give it live access to external tools and data sources. The combination turns Claude from a chat interface into a system that compounds context over time and acts on the world through connected tools. No other model on this list has an equivalent native implementation.
Setup
> 1. Create a Claude Project and name it for the system you are building 2. Upload your CLAUDE.md context file as project knowledge 3. Install relevant MCP servers via Claude Code: research (Exa, Tavily), data (CoinGecko, LunarCrush), productivity (Notion, Linear) 4. In Project Instructions, paste your operating rules and context 5. Every conversation inside that project now starts with full system context loaded automatically
## 2. Obsidian — The Memory and Intelligence Layer
Obsidian is not an AI tool in the way the others on this list are. It does not have a model. It does not generate output. What it does is give Claude something none of the others have: a persistent, searchable, locally stored record of everything you have ever thought, read, and built.
The combination of Obsidian plus Claude is not additive. It is multiplicative. Claude alone reasons from training data. Claude connected to an Obsidian vault reasons from months of your specific thinking, your specific research, and your specific unresolved questions.
What it does best 1: Making AI outputs compound over time
A Claude session without vault context starts fresh. A Claude session connected to your Obsidian vault starts from everything you have accumulated. After six months of consistent capture, Claude can surface connections between notes you wrote eight weeks apart, identify patterns forming across your thinking before you consciously recognise them, and flag contradictions between beliefs you documented at different times.
Setup
> 1. Install Obsidian from obsidian.md — free, local, plain markdown 2. Create five folders: 00-Inbox, 01-Sources, 02-Ideas, 03-Projects, 04-Claude 3. Install the Readwise Official plugin and connect your Readwise account 4. Write a CLAUDE.md file in your 04-Claude folder describing who you are, what you are building, and how the vault is organised 5. Create a Claude Project and upload your CLAUDE.md and seed notes as project knowledge 6. Every session inside that project now has your vault as its foundation
What it does best 2: Zero-friction idea capture that actually retrieves
The problem with every other note-taking system is retrieval. You save things. You never find them. Obsidian with QuickAdd solves this permanently. One keyboard shortcut opens a floating input box. You type the idea. It lands in the correct section of today's daily note automatically. No navigation. No categorisation at capture time. Claude does the categorisation and connection-finding later.
Setup
> 1. Install the QuickAdd plugin in Obsidian 2. Create four capture workflows: General Capture (Ctrl+Shift+C), Research Signal (Ctrl+Shift+R), Content Idea (Ctrl+Shift+I), Link (Ctrl+Shift+L) 3. Configure each to append to today's daily note under the matching heading 4. Build a Telegram bot using N8N that forwards any message to your vault Inbox within 30 seconds 5. Every idea from any device, any context, now has a frictionless path into your vault
What it does best 3: Automated daily synthesis from your own thinking
Every morning before you open anything else, Claude has already read the last seven days of your vault captures and produced a synthesis. Not a summary. An actual output: connections you missed, patterns forming across weeks of notes, the single question worth thinking about that day.
Prompt
> Read all notes added to my vault in the last 7 days.Produce a daily synthesis with four sections: 1. Connections: two or three non-obvious links between notes captured separately. Reference specific note titles. If the connection is obvious it does not qualify. 2. Patterns: any theme appearing across three or more notes. Name it in one sentence. 3. Contradictions: any two notes where my stated positions conflict. Quote the relevant line from each. 4. Highest-value capture: the single note most worth developing further and why.Do not summarise. Synthesise.
## 3. Hermes Agent — The Autonomous Local Automation Layer
Hermes Agent is an open-source autonomous AI agent built by Nous Research and released in February 2026. It lives on your server, remembers what it learns, and gets more capable the longer it runs. It has 73,000 GitHub stars and became the number one most-used AI agent in the world by daily inference volume on OpenRouter as of May 2026.
The critical distinction from every other tool on this list: Hermes is model-agnostic and self-hosted. Your data stays on your machine. No telemetry, no tracking, no cloud lock-in. And it gets smarter the longer it runs because it writes skill files when it solves hard problems.
What it does best 1: Persistent memory that compounds across sessions
Every other AI agent starts fresh. Hermes remembers. It features a three-tier memory system and self-evolving skills via GEPA, with a 647-skill ecosystem meaning you are not starting from zero. When Hermes solves a complex problem it writes a markdown skill file so it never has to figure out the same thing twice. The agent you have after six months is fundamentally more capable than the one you started with.
Setup
> 1. Install via single curl command on Linux, macOS, or WSL2 — it handles all prerequisites automatically 2. Connect it to your preferred model: Claude, GPT-4, Gemini, or a local model via Ollama 3. Connect via Telegram for mobile access: search BotFather on Telegram, create a bot, add the token to your Hermes config 4. Test with a simple task: "Every weekday at 9am, research the top trending AI tools and send me a summary via Telegram" 5. Watch it write a skill file after completing it — that task now runs faster and more accurately every time
What it does best 2: Natural language scheduling for recurring workflows
Natural-language cron: "every weekday at 9am, summarise my inbox and post to Slack" is a real use case that runs automatically once configured. You do not write cron syntax. You describe the workflow in plain English. Hermes figures out the scheduling, the tool calls, and the output format.
Prompt
> Set up the following recurring workflow:Every Monday at 8am: - Search the web for the top 5 AI and crypto developments from the past week - Format them as a structured brief with: headline, one-sentence summary, why it matters - Send the brief to me via TelegramWrite a skill file for this workflow so it improves automatically each time it runs.
What it does best 3: Cost-optimised model routing across tasks
Three-tier model routing: route mechanical work to Gemini Flash Lite, ambiguous tasks to Claude Sonnet, and low-overhead jobs to Minimax — one user saved roughly $40 from initial setup alone. Hermes can route different parts of a workflow to different models based on complexity, cost, and speed requirements. You get Claude-quality output on the tasks that need it and near-zero cost on the tasks that do not.
Setup
> In your Hermes config, define routing rules:Tier 1 (mechanical tasks — classification, formatting, extraction): → Route to Gemini Flash Lite or MinimaxTier 2 (ambiguous tasks — analysis, synthesis, writing): → Route to Claude SonnetTier 3 (complex reasoning, architecture, deep research): → Route to Claude OpusTest by running a research task and checking the model log — you should see different models firing for different subtasks.
## 4. Kimi K2.6 — The Large-Scale Agentic Coding Layer
Kimi K2.6 is an open-source, native multimodal agentic model from Moonshot AI that advances practical capabilities in long-horizon coding, coding-driven design, proactive autonomous execution, and swarm-based task orchestration.
K2.6 can orchestrate up to 300 concurrent sub-agents across 4,000 steps, tripling K2.5's 100-agent and 1,500-step ceiling. This is the closest thing the open ecosystem has to a manager agent plus specialist workforce primitive. It is free, open-source, and accessible via API. For coding-heavy workloads at scale, nothing on this list comes close.
What it does best 1: Long-horizon autonomous coding sessions
Moonshot shipped a 5-day continuous-ops agent trace for monitoring and incident response alongside a 12-hour Zig port and a 13-hour exchange-core refactor. Kimi K2.6 can run a coding task for hours without human intervention. It does not just complete a function. It completes a project.
Setup
> Access via DeepInfra API: Model string: moonshotai/Kimi-K2.6 Context window: 256K tokensFor a long-horizon coding task, structure your prompt as:"You are running an autonomous coding session. Your task is [describe the full project scope]. Work through this systematically: 1. Plan the full implementation before writing any code 2. Implement in logical phases, testing each before moving on 3. Document every decision that has architectural implications 4. If you hit a blocker, describe it explicitly rather than working around it silently Do not ask for confirmation between steps. Complete the full task."
What it does best 2: 300-agent swarm orchestration
No other open-source model can coordinate 300 concurrent specialised sub-agents across a single task. Each sub-agent handles a domain. A meta-agent coordinates them. The result is parallel execution at a scale that compresses weeks of work into hours.
Prompt
> You are the orchestrator agent for a multi-agent research task.Task: [describe the research or build objective]Decompose this into parallel workstreams. For each workstream: - Name the specialist agent responsible - Define its exact scope - Define its output format - Define the dependency chain: which agents must complete before others can startThen execute all independent workstreams simultaneously. Synthesise outputs into a final deliverable once all workstreams are complete.
What it does best 3: Visual-to-code generation
K2.6 is capable of transforming simple prompts and visual inputs into production-ready interfaces and lightweight full-stack workflows, generating structured layouts, interactive elements, and rich animations with deliberate aesthetic precision. Hand it a sketch, a screenshot, or a description of a UI and it produces working frontend code.
Prompt
> I am going to describe a user interface. Build it as a complete, production-ready component.[Describe or paste your UI specification or upload a screenshot]Requirements: - Production-ready code, not a prototype - Include all interactive states - Responsive across mobile and desktop - Accessible by default - No placeholder content — use realistic example data
## 5. Cursor 3 — The Live Coding Execution Layer
Cursor is a code editor, not a chatbot. You do not use it to have a conversation. You use it to build software. The way you interact with it is by typing instructions inside the Agents Window or Composer while your codebase is open. The agent reads your actual files, makes changes to your actual code, and opens real pull requests. Everything below assumes you have a coding project open.
Released on April 2, 2026, Cursor 3 rebuilt its entire interface around agents. Agent users now outnumber Tab autocomplete users two to one inside the product, a ratio that was reversed just a year ago. It sits inside 64% of the Fortune 500 and has over a million developers using it.
What it does best 1: Parallel agents running simultaneously across your codebase
The Agents Window lets you run multiple agents at the same time across different parts of your project. One refactors a module. One writes tests. One updates documentation. None of them interfere with each other because each runs in its own Git worktree. You review and merge when each is done.
How to use it inside Cursor
> 1. Install Cursor from cursor.com. Pro plan is $20/month for full Agents Window access. 2. Open your project in Cursor. 3. Press Cmd+Shift+P → type "Agents Window" → open it. 4. Click "New Agent" and type your first instruction directly in the agent input box: "Write tests for auth.ts covering the logout edge case. Use the patterns already in tests/ and avoid mocks." 5. Click "New Agent" again and type a second instruction in parallel: "Refactor the payment module to use the new API schema in schema/v2.ts. Do not touch any files outside /src/payments/" 6. Both run simultaneously. Monitor progress in the Agents Window. Review diffs and merge when done.
What it does best 2: Handing off long tasks to the cloud so your laptop can close
Start a long-running task locally, hand it off to Cursor's cloud, close your laptop, and the results sync back when you reconnect. Built specifically for migrations, large refactors, and test suite generation that would otherwise run for hours.
How to use it inside Cursor
> 1. In the Agents Window, type your task: "Migrate the entire database layer from PostgreSQL to Supabase. Scope: /src/db/ only. Do not touch anything outside this directory. Phase 1: Map every existing query and find the Supabase equivalent. Phase 2: Write the new implementations one file at a time. Phase 3: Write migration tests for each changed file. Phase 4: Open a pull request summarising every change." 2. Once the agent starts, click "Hand off to Cloud" in the Agents Window. 3. Close your laptop. The agent keeps running on Cursor's infrastructure. 4. When you reconnect, the pull request is waiting for your review.
What it does best 3: Design Mode — point at a UI element instead of describing it
Design Mode connects Cursor to your live app running in the browser. Instead of describing which element you want to change, you click on it. The agent sees exactly what you see and makes the targeted edit without touching anything else in the file.
How to use it inside Cursor
> 1. Start your app locally so it is running in the browser. 2. In Cursor, open the Agents Window and click "Design Mode." 3. Your browser opens with an annotation layer over your app. 4. Click any UI element — a button, a card, a nav item — it highlights with a blue outline. 5. Type your instruction directly next to the highlighted element: "Make this full-width on mobile" "Replace this text with data from the /api/user endpoint" "Change this to match the primary brand colour" 6. The agent makes only that change. Nothing else in the file is touched.
## How the Five Work Together
No single tool on this list is the answer to everything. The operators getting real leverage are running all five in a coordinated stack where each layer feeds the next.
Claude is the reasoning core. Everything flows through it for thinking, writing, and analysis.
Obsidian is the memory layer. It holds the accumulated context that makes Claude's outputs compound over time rather than starting fresh every session.
Hermes runs the recurring workflows. The daily briefs, the scheduled research sweeps, the automated reports — everything that needs to happen on a schedule without you manually triggering it.
Kimi K2.6 handles the large-scale coding tasks and multi-agent orchestration that require parallel execution at a scale no single agent can replicate.
Cursor executes the live coding work inside your actual codebase where visual context and parallel agents running in real git branches change the speed of shipping.
Five layers. Five distinct capabilities. None of them redundant.
The operators who have all five running in coordination are working at a different level than the ones still running a single tool for everything.
Follow @damidefi on X for daily Claude AI tools, crypto analysis, and the full journey to 100K. Bookmark this. Share it with one person still using one tool to do five jobs.
## 相关链接
- [Dami-Defi](https://x.com/DamiDefi)
- [@DamiDefi](https://x.com/DamiDefi)
- [58K](https://x.com/DamiDefi/status/2060313230585536980/analytics)
- [why.Do](https://why.do/)
- [cursor.com](https://cursor.com/)
- [@damidefi](https://x.com/@damidefi)
- [Upgrade to Premium](https://x.com/i/premium_sign_up)
- [6:52 PM · May 29, 2026](https://x.com/DamiDefi/status/2060313230585536980)
- [58.6K Views](https://x.com/DamiDefi/status/2060313230585536980/analytics)
- [View quotes](https://x.com/DamiDefi/status/2060313230585536980/quotes)
---
*导出时间: 2026/5/30 11:04:26*
---
## 中文翻译
# 我构建了一套包含 5 个工具的 AI 技术栈，每个工具都发挥着其他工具无法替代的作用。以下是完整构建过程。
**作者**: Dami-Defi
**日期**: 2026-05-29T10:52:07.000Z
**来源**: [https://x.com/DamiDefi/status/2060313230585536980](https://x.com/DamiDefi/status/2060313230585536980)
---
在 2026 年，大多数运行 AI 技术栈的人都在用一件工具搞定所有事情。
那不是工作流，那是拿着锤子找钉子。
那些真正从 AI 中获得杠杆效应的操作者，并不是比其他人用了更多的工具，而是为运营的每一个层面使用了正确的工具。研究、构建、记忆、自动化、执行。每一个层面都有一个独占鳌头的工具，其作用是其他工具无法复制的。
这就是那五个工具。它们各自拥有什么别人没有的能力。以及达到目的的确切提示词和设置方案。
## 1. Claude —— 推理与上下文层
Claude 之所以出现在这个列表中，并不是因为它最受欢迎，而是因为没有其他工具能像它那样进行深度推理，能在 20 万 token 的窗口内保持上下文而不降级，并且生成的书面输出始终听起来像一个了解该主题的人类。
在 Ryz Labs 进行的为期 30 天的独立测试中，Claude 在编码任务上达到了约 95% 的功能准确率，而 ChatGPT 约为 85%。到 2025 年末和 2026 年初，约 70% 的开发者表示他们更喜欢专门用于编码任务的 Claude。原因始终如一：Claude 写的代码更简洁，更可靠地处理多文件项目，并且对自己不知道的事情更诚实。
Claude 做的这三件事是列表中其他任何工具无法替代的：
**最强能力 1：无降级的长文档推理**
随着上下文窗口填满，其他所有 AI 工具都会失去连贯性。Claude 能在 20 万 token 的窗口内保持论证的完整性，这意味着你可以加载整个研究语料库、完整的代码库或数月的笔记，其在第 15 万个 token 时的输出与在第 1 千个 token 时一样敏锐。这是使 Claude Projects 在知识密集型工作中真正强大的基础。
提示词
> 我将粘贴一份长文档。在你分析它之前，请通读全文，不要产生任何输出。然后告诉我：核心论点是什么？推理中有哪三个最薄弱的环节？作者未明确指出的最重要的单一影响是什么？[粘贴文档]
**最强能力 2：指令跟随的精确度**
即使发布了 GPT-5.2 和 Gemini 3，Claude 仍然是遵循指令方面最好的工具。即使在长提示词中，它也能遵循每一个细节。当你的提示词有十条具体的格式规则、五个约束条件和定义的输出结构时，Claude 是能在第一次尝试时就遵守所有规则而不需要修正的工具。
提示词
> 在整个对话过程中，你将遵守这些规则。无例外。
> 1. 在散文部分永远不要使用项目符号
> 2. 每个主张必须立即紧跟其背后的证据或推理
> 3. 不使用破折号
> 4. 短段落 —— 最多四句话
> 5. 每一节都以最重要的影响结束，而不是总结
> 在我给你任务之前确认你已阅读这些规则。
**最强能力 3：通过项目和 MCP 构建系统**
Claude Projects 为项目内的每次对话提供持久记忆。MCP 连接赋予它对外部工具和数据源的实时访问权限。这种组合将 Claude 从聊天界面转变为一个随时间积累上下文并通过连接工具对外行事的系统。此列表中没有其他模型拥有等效的原生实现。
设置
> 1. 创建一个 Claude 项目并以你正在构建的系统命名
> 2. 将你的 CLAUDE.md 上下文文件作为项目知识上传
> 3. 通过 Claude Code 安装相关的 MCP 服务器：研究、数据、生产力
> 4. 在项目说明中，粘贴你的操作规则和上下文
> 5. 该项目内的每次对话现在都会自动加载完整的系统上下文
## 2. Obsidian —— 记忆与智能层
Obsidian 不像列表中的其他工具那样是一个 AI 工具。它没有模型。它不生成输出。它做的是给 Claude 提供其他工具所没有的东西：一个持久的、可搜索的、本地存储的关于你曾经思考、阅读和构建的所有内容的记录。
Obsidian 加 Claude 的组合不是相加，而是相乘。单独的 Claude 从训练数据中推理。连接到 Obsidian 库的 Claude 从你数月来的具体思考、具体研究和具体的未解问题中推理。
**最强能力 1：让 AI 输出随时间复利**
没有库上下文的 Claude 会话是从头开始的。连接到你的 Obsidian 库的 Claude 会话则从你积累的一切开始。经过六个月的持续捕获，Claude 可以发现你在相隔八周写的笔记之间的联系，在你有意识地意识到之前识别出你思维中形成的模式，并标记你在不同时间记录的信念之间的矛盾。
设置
> 1. 从 obsidian.md 安装 Obsidian —— 免费、本地、纯 Markdown
> 2. 创建五个文件夹：00-Inbox，01-Sources，02-Ideas，03-Projects，04-Claude
> 3. 安装 Readwise 官方插件并连接你的 Readwise 账户
> 4. 在你的 04-Claude 文件夹中写一个 CLAUDE.md 文件，描述你是谁，你在构建什么，以及库是如何组织的
> 5. 创建一个 Claude 项目并将你的 CLAUDE.md 和种子笔记作为项目知识上传
> 6. 该项目内的每次会话现在都以你的库为基础
**最强能力 2：真正可检索的零摩擦想法捕获**
其他所有笔记系统的问题都在于检索。你保存了东西。你永远找不到它们。带有 QuickAdd 的 Obsidian 永久性地解决了这个问题。一个键盘快捷键打开一个浮动输入框。你输入想法。它会自动落入今天每日笔记的正确部分。无需导航。捕获时无需分类。Claude 稍后进行分类和查找连接。
设置
> 1. 在 Obsidian 中安装 QuickAdd 插件
> 2. 创建四个捕获工作流：常规捕获 (Ctrl+Shift+C)、研究信号 (Ctrl+Shift+R)、内容想法 (Ctrl+Shift+I)、链接 (Ctrl+Shift+L)
> 3. 配置每一个以附加到今天每日笔记下的匹配标题中
> 4. 使用 N8N 构建一个 Telegram 机器人，在 30 秒内将任何消息转发到你的库 Inbox
> 5. 来自任何设备、任何上下文的每个想法，现在都有了一条通往你库的无摩擦路径
**最强能力 3：来自你自己思维的自动每日综合**
每天早上，在你打开任何其他东西之前，Claude 已经阅读了你库中过去七天的捕获内容并生成了一个综合报告。不是总结。而是实际的输出：你错过的联系、数周笔记中形成的模式、那天值得思考的单一问题。
提示词
> 阅读过去 7 天添加到我的库中的所有笔记。
> 生成一个包含四个部分的每日综合：
> 1. 联系：分别捕获的笔记之间两到三个非显而易见的链接。引用具体的笔记标题。如果联系是显而易见的，则不符合资格。
> 2. 模式：出现在三个或更多笔记中的任何主题。用一句话命名。
> 3. 矛盾：任何两个笔记，其中我的既定立场相互冲突。引用每个笔记的相关行。
> 4. 最高价值捕获：最值得进一步发展的单一笔记及原因。
> 不要总结。综合。
## 3. Hermes Agent —— 自主本地自动化层
Hermes Agent 是 Nous Research 构建的开源自主 AI 代理，于 2026 年 2 月发布。它运行在你的服务器上，记住它学到的东西，并且运行时间越长越能干。它在 GitHub 上拥有 73,000 颗星，截至 2026 年 5 月，按 OpenRouter 上的日推理量计算，它已成为世界上使用排名第一的 AI 代理。
与列表中其他工具的关键区别在于：Hermes 是模型无关且自托管的。你的数据保留在你的机器上。没有遥测，没有跟踪，没有云锁定。而且它运行得越久越聪明，因为它在解决难题时会编写技能文件。
**最强能力 1：跨会话复利的持久记忆**
其他每个 AI 代理都是从头开始的。Hermes 记得。它拥有三层记忆系统和通过 GEPA 实现的自进化技能，拥有 647 个技能生态系统意味着你不是从零开始。当 Hermes 解决一个复杂问题时，它会写一个 Markdown 技能文件，这样它永远不必再次弄清楚同一件事。六个月后你拥有的代理在根本上比你开始时更有能力。
设置
> 1. 通过单个 curl 命令在 Linux、macOS 或 WSL2 上安装 —— 它会自动处理所有先决条件
> 2. 连接到你首选的模型：Claude、GPT-4、Gemini 或通过 Ollama 连接的本地模型
> 3. 通过 Telegram 连接以进行移动访问：在 Telegram 上搜索 BotFather，创建一个机器人，将令牌添加到你的 Hermes 配置中
> 4. 用一个简单任务进行测试：“每个工作日上午 9 点，研究顶级趋势 AI 工具并通过 Telegram 发送给我一个摘要”
> 5. 观察它在完成后编写一个技能文件 —— 该任务现在每次运行都更快、更准确
**最强能力 2：用于重复工作流的自然语言调度**
自然语言 cron：“每个工作日上午 9 点，总结我的收件箱并发布到 Slack”是一个真实的用例，一旦配置就会自动运行。你不需要编写 cron 语法。你用简单的英语描述工作流。Hermes 会弄清楚调度、工具调用和输出格式。
提示词
> 建立以下重复工作流：
> 每周一上午 8 点：
> - 在网上搜索过去一周的前 5 大 AI 和加密货币进展
> - 将它们格式化为结构化简报，包含：标题、一句话总结、重要性所在
> - 通过 Telegram 将简报发送给我
> 为此工作流编写一个技能文件，以便它每次运行时自动改进。
**最强能力 3：跨任务的成本优化模型路由**
三层模型路由：将机械工作路由到 Gemini Flash Lite，歧义任务路由到 Claude Sonnet，低开销工作路由到 Minimax —— 一位用户仅从初始设置就节省了大约 40 美元。Hermes 可以根据复杂性、成本和速度要求，将工作流的不同部分路由到不同的模型。在需要的任务上，你获得 Claude 质量的输出，在不需要的任务上，成本接近于零。
设置
> 在你的 Hermes 配置中，定义路由规则：
> 第 1 层（机械任务 —— 分类、格式化、提取）：→ 路由到 Gemini Flash Lite 或 Minimax
> 第 2 层（歧义任务 —— 分析、综合、写作）：→ 路由到 Claude Sonnet
> 第 3 层（复杂推理、架构、深度研究）：→ 路由到 Claude Opus
> 通过运行研究任务并检查模型日志来测试 —— 你应该看到不同的子任务触发不同的模型。
## 4. Kimi K2.6 —— 大规模代理编码层
Kimi K2.6 是来自 Moonshot AI 的开源原生多模态代理模型，它在长周期编码、编码驱动的设计、主动自主执行和基于群的任务编排方面推进了实用能力。
K2.6 可以编排多达 300 个并发子代理，跨越 4,000 个步骤，是 K2.5 的 100 个代理和 1,500 步上限的三倍。这是开放生态系统中最接近管理者代理加专业劳动力原语的东西。它是免费的、开源的，并通过 API 访问。对于大规模的繁重编码工作负载，列表中的其他工具都望尘莫及。
**最强能力 1：长周期自主编码会话**
Moonshot 发布了一条 5 天连续运营代理跟踪，用于监控和事件响应，以及一个 12 小时的 Zig 移植和一个 13 小时的交换核心重构。Kimi K2.6 可以在没有人工干预的情况下运行编码任务数小时。它不仅仅是完成一个函数。它完成一个项目。
设置
> 通过 DeepInfra API 访问：模型字符串：moonshotai/Kimi-K2.6，上下文窗口：256K tokens
> 对于长周期编码任务，按如下结构构建你的提示词：
> “你正在运行一个自主编码会话。你的任务是 [描述完整的项目范围]。系统地解决这个问题：
> 1. 在编写任何代码之前规划完整的实现
> 2. 按逻辑阶段实施，在进入下一阶段之前测试每个阶段
> 3. 记录每个具有架构影响的决策
> 4. 如果你遇到阻碍，请明确描述它，而不是默默绕过它
> 不要在步骤之间寻求确认。完成整个任务。”
**最强能力 2：300 代理群编排**
没有其他开源模型可以在单个任务中协调 300 个并发专业子代理。每个子代理处理一个领域。一个元代理协调它们。结果是将数周的工作压缩成数小时的并行执行。
提示词
> 你是多代理研究任务的编排者代理。
> 任务：[描述研究或构建目标]
> 将其分解为并行工作流。对于每个工作流：
> - 命名负责的专业代理
> - 定义其确切范围
> - 定义其输出格式
> - 定义依赖链：哪些代理必须先于其他代理完成
> 然后同时执行所有独立的工作流。一旦所有工作流完成，将输出综合成最终的交付物。
**最强能力 3：视觉到代码生成**
K2.6 能够将简单的提示词和视觉输入转换为生产就绪的界面和轻量级全栈工作流，生成结构化布局、交互元素和丰富的动画，具有深思熟虑的审美精度。给它一个草图、一个截图或 UI 的描述，它就会生成可工作的前端代码。
提示词
> 我将描述一个用户界面。将其构建为一个完整的、生产就绪的组件。
> [描述或粘贴你的 UI 规范或上传截图]
> 要求：
> - 生产就绪的代码，而不是原型
> - 包含所有交互状态
> - 在移动端和桌面端响应式
> - 默认可访问
> - 无占位符内容 —— 使用真实的示例数据
## 5. Cursor 3 —— 实时编码执行层
Cursor 是一个代码编辑器，而不是聊天机器人。你不用它来聊天。你用它来构建软件。你与它的交互方式是在打开代码库时在 Agents Window 或 Composer 中输入指令。代理读取你的实际文件，更改你的实际代码，并打开真正的拉取请求。以下内容假设你有一个打开的编码项目。
Cursor 3 于 2026 年 4 月 2 日发布，其整个界面围绕代理重建。现在，产品内代理用户与 Tab 自动补全用户的比例为二比一，而一年前这个比例是相反的。它进入了 64% 的财富 500 强公司，拥有超过一百万开发者使用。
**最强能力 1：在你的代码库中同时运行并行代理**
Agents Window 允许你同时跨项目的不同部分运行多个代理。一个重构模块。一个编写测试。一个更新文档。它们互不干扰，因为每个都在自己的 Git 工作树中运行。当每个完成时，你审查并合并。
如何在 Cursor 中使用它
> 1. 从 cursor.com 安装 Cursor。Pro 计划每月 20 美元，可完全访问 Agents Window。
> 2. 在 Cursor 中打开你的项目。
> 3. 按 Cmd+Shift+P → 输入“Agents Window” → 打开它。
> 4. 点击“New Agent”并直接在代理输入框中键入你的第一条指令：“为 auth.ts 编写覆盖登出边缘情况的测试。使用 tests/ 中已有的模式并避免模拟。”
> 5. 再次点击“New Agent”并并行键入第二条指令：“重构支付模块以使用 schema/v2.ts 中的新 API 架构。不要触碰 /src/payments/ 之外的任何文件。”
> 6. 两者同时运行。在 Agents Window 中监控进度。完成后查看差异并合并。
What it do