Scaling LLM Agent Tool Access: The MCP Gateway
Dual Dimensionality for Local and Global Attention
Do Agents Still Follow the Rules? Benchmarking Rule Compliance under Agent Context Compaction
Beyond Prompt Injection: The Tool Update Gap in LLM Agent Security
Toward Knowledge-Centric AI: Discovering, Internalizing, and Using Explicit Knowledge Across Agents and Generations
AI Data Analysis: A New Approach - Multi-engine Joint State Data Analysis
Welcome Le Chonk: Mistral Large 4 on Hugging Face
AI Agents Pick the Wrong Tool More Often as You Add Tools, and Research Shows Why
An AI agent does not run its tools by itself. It reads a list of tool definitions, picks one, and fills in the arguments. Your code then makes the call. When the list holds five tools, that choice is easy. When it holds sixty, from four connected servers, the model picks the wrong tool more often. The wrong tool usually returns a normal, successful response.
Research from the last three years explains why. Long prompts are read unevenly, similar tools are hard to tell apart, and selection accuracy falls as the list grows. This article summarises that evidence and the habits teams use to keep the tool list short.
A tool list is part of the prompt.
A tool definition has three parts: a name, a description, and a schema for its arguments. The model never sees your tool's code. It sees only that text, inside its context window, beside the system prompt and the conversation. OpenAI's function-calling guide tells developers to "explicitly describe the purpose of the function and each parameter", because the description is the only information the model has about the tool.
That text has a cost. In a November 2025 engineering post, Anthropic describes a setup with five connected MCP servers. MCP, the Model Context Protocol, is a standard way to plug a server full of tools into an agent. The five servers exposed "58 tools consuming approximately 55K tokens before the conversation even starts." In a separate case, Anthropic reports that its own internal tool definitions once reached 134,000 tokens before optimisation.
The same post names the failure this article is about. Anthropic writes that "the most common failures are wrong tool selection and incorrect parameters". A wrong choice is easy to miss. If an agent calls search_orders when it needed search_invoices, the call still succeeds and still returns data. The model then writes a confident answer from the wrong data.
Long prompts are read unevenly.
The first reason applies to any long input, not only to tools. Language models do not read a long input with equal care from start to end.
In "Lost in the Middle", published in the Transactions of the Association for Computational Linguistics, Nelson Liu and colleagues at Stanford hid one relevant document among many others. Accuracy was highest when the relevant document came first or last. It dropped when the document sat in the middle, even for models built for long contexts.
A 2025 report from the vector database company Chroma, "Context Rot", tested 18 models on simple tasks, such as finding one fact in a long text, while adding more input. The authors found that models "do not use their context uniformly" and that performance "grows increasingly unreliable as input length grows."
A tool list is exactly this kind of input. Sixty definitions are sixty short documents, and the one the model needs may sit in the middle of them.
Selection accuracy falls as the list grows.
Two studies measured the effect of tool count directly.
RAG-MCP, a May 2025 preprint by Tiantian Gan and Qiyao Sun, gave a model a large pool of MCP tools and asked it to pick the right one. With every tool definition in the prompt, the model chose correctly 13.62% of the time. The authors then added a retrieval step. A search over the tool descriptions picked a few likely candidates, and only those reached the model. Accuracy rose to 43.13%, more than three times higher, and the prompt shrank by over half. The paper is a preprint and has not been peer-reviewed, so the exact numbers should be read with care.
"Less is More", a paper by Varatheepan Paramanayakam and colleagues accepted at the DATE 2025 conference, studied small models running on edge hardware. The authors report that "selectively reducing the number of tools available to LLMs significantly improves their function-calling performance." Execution time also fell by up to 70%, because the model had less text to process.
Similar tools are the hardest case.
Overlap between tools is a second problem, separate from their number.
The MetaTool benchmark, presented at ICLR 2024 by Yue Huang and colleagues, tested whether models could decide when to use a tool and which one to pick. One of its tasks offers tools chosen to be similar to each other. Across eight popular models, the authors found that "the majority of them still struggle to effectively select tools."
Anthropic's guide to writing tools for agents describes MetaTool's finding as it appears in production agents. It warns that "too many tools or overlapping tools can also distract agents", and that when tools "overlap in function or have a vague purpose, agents can get confused about which ones to use." The guide recommends grouping related tools under a shared prefix, such as asana_search and jira_search, so the name itself says which system a tool belongs to.
Overlap grows fastest when teams connect third-party servers, because each server is written by a different team that never saw the other tool names. Two servers can each provide a tool called search, and the model has to decide between them from their descriptions alone.
Every description is an instruction.
Because the model treats a tool description as text to follow, a description can also carry an attacker's instructions.
In April 2025, the security firm Invariant Labs described a tool poisoning attack on MCP. A tool's description held hidden instructions that are "invisible to users but visible to AI models". In their demonstration, those instructions told the agent to read private files and send them elsewhere.
So each added tool brings more text for the model to weigh, and that text may come from a source you do not control. A shorter list means less of both.
Single calls work; long sequences remain hard.
The best-known public benchmark for tool use is the Berkeley Function Calling Leaderboard, presented at ICML 2025 by Shishir Patil, Ion Stoica, Joseph Gonzalez and colleagues at UC Berkeley. The leaderboard tests whether a model calls the right function with the right arguments, and whether it declines to call one when no tool fits.
The authors report that "state-of-the-art LLMs excel at single-turn calls", where the model answers one request with one call. They also report that "memory, dynamic decision-making, and long-horizon reasoning remain open challenges." A real agent makes many choices in a row, and each choice is made from the full list again. One wrong pick early in the run can affect every step after it.
What the model providers now recommend.
The model providers now give the same advice as the papers.
Deep Principle Releases Hydrogen-1.0: A 753B Open-Weight Model for Scientific Discovery
Deep Principle has released Hydrogen-1.0, an open-weight scientific model for chemistry, materials science and life sciences. It is built by post-training Z.ai’s GLM-5.3 on domain data, laboratory records and agent discovery trajectories. For developers, it offers open weights that report a FrontierScience-Research win over GPT-6-Astra. The weights ship under the MIT License.
TL;DR
- Size: 753B parameters (MoE, ~40B active per the GLM-5.3 base), 1M-token context, 128K max output.
- Runs on: 8 GPUs with SGLang (tested); NVFP4 for NVIDIA B200/B300, MXFP4 for AMD MI350X/MI355X.
- Performance: Beats GPT-6-Astra on FrontierScience-Research; roughly matches Kimi-K3 on GPQA-Diamond.
- Best: 38.3% on FrontierScience-Research vs 33.3% for GPT-6-Astra (self-reported).
- Worst: Trails GPT-6-Astra (max thinking) by 3.33 points on NMR structure elucidation.
What is Hydrogen-1.0?
Hydrogen-1.0 is a scientific research assistant model from Deep Principle, a Hangzhou-based AI-for-materials company. The model card describes it as a GLM-5.3 derivative for scientific problem solving. It targets question framing, experiment planning, results analysis and open-ended discovery. Deep Principle team states that proprietary models produced recent AI science results, but their discovery capabilities are not open. Hydrogen-1.0 is its attempt at a reproducible, inspectable alternative.
How was Hydrogen-1.0 trained?
The pipeline combines supervised fine-tuning (SFT) with reinforcement learning (RL). Data comes from 4 sources:
- Domain knowledge: chemistry, materials science and life sciences data.
- Research scenarios: task-specific feedback from Deep Principle scientists.
- Laboratory records: full-cycle electronic lab notebook records captured through Mira.
- Discovery trajectories: sequences of choices and feedback, including failed attempts.
Infrastructure builds on Megatron and SGLang across NVIDIA CUDA and AMD ROCm. The team keeps dynamic sparse attention causal across context-parallel shards. Muon optimizer state is moved between CPU, GPU and disk per backend. RL uses resumable rollouts, and each token keeps its original behavior log-probability for importance correction. A layout adapter converts training checkpoints into BF16 and 128×128 blockwise FP8 inference weights. Full datasets and recipes are not released.
How does Hydrogen-1.0 perform on benchmarks?
On public benchmarks, Deep Principle reports Hydrogen-1.0 outperforms GPT-6-Astra on FrontierScience-Research. The tweet thread from one of the founders’ report 93.0% on GPQA-Diamond. That improves on GLM-5.3 and roughly matches Kimi-K3, per the blog.
Internal research-task evals compare it with GPT-6-Astra at maximum thinking:
- Scientific computing: Hydrogen-1.0 leads by 5.13 percentage points.
- Forward reaction prediction: Hydrogen-1.0 leads by 4.76 percentage points.
- NMR structure elucidation: GPT-6-Astra leads by 3.33 points.
In transition metal complex design, models chased a larger HOMO-LUMO gap over 5 rounds. By round 5, Hydrogen-1.0 reached a mean best-so-far gap of 4.318 eV. GPT-6-Astra reached 3.689 eV and Kimi-K3 reached 3.353 eV. On 117 experiment-planning questions, Hydrogen-1.0 scored above Kimi-K3. GPT-6-Astra and Opus-5.5 were excluded after refusing more than 50% of requests.
&What can it do in a real lab workflow?
The technical post shows 4 demos. Hydrogen-1.0 writes Python to build a polyethylene melt and runs GROMACS. It detects a topology error, repairs it, and analyzes the corrected 40 ns trajectory. It grows an Ireland-Claisen reaction network of 27 structures through 30 plausible reactions. It ranks 7 candidate monoformylation products of 2-bromonaphthalene from a 1H NMR trace. It also writes a JSON protocol for a 12-vial Suzuki coupling study. A virtual lab compilation step catches an aspiration without a fresh tip before execution.
How do you deploy Hydrogen-1.0?
Weights are on Hugging Face and ModelScope. Deep Principle team tested BF16 serving with SGLang on 8 GPUs using tensor parallelism of 8. NVFP4 targets NVIDIA B200 and B300. MXFP4 targets AMD Instinct MI350X and MI355X. The server exposes an OpenAI-compatible API with a reasoning_effort setting.
Hydrogen-1.0 vs GLM-5.3, Kimi K3 and GPT-6-Astra
| Feature | Hydrogen-1.0 | GLM-5.3 | Kimi K3 | GPT-6-Astra |
|---|---|---|---|---|
| Developer | Deep Principle | Z.ai | Moonshot AI | OpenAI |
| Total params | 753B | 753B (HF) | 2.8T | Not disclosed |
| Active params | ~40B (inherited) | 40B (LM Studio) | 16 of 896 experts | Not disclosed |
| Context | 1M | 1M | 1M | 1.05M |
| Weights / license | Open, MIT | Open, GLM-5.3 License | Open | Proprietary |
| Modality | Text | Text | Text + vision | Not disclosed here |
| Science focus | Chemistry, materials, life sciences | Coding, agents | General | General |
| FrontierScience-Research | 38.3% | Not disclosed | Not disclosed | 33.3% (per Deep Principle) |
| GPQA-Diamond | 93.0% | Not disclosed | Not disclosed | 96.0% (OpenAI-reported) |
| API price (in/out per 1M)< |
Making Local LLMs Usable on 8GB GPUs
A local model can manage a brief question without any issues, but it may have difficulty when dealing with a complete document. The model's internal settings stay the same, but the effort needed and the memory required to process the request increase a lot.
In Part 1, I explained how to run a quantized model on a smaller GPU.
The next step is to choose a task, measure how long it takes, and find a setup that works within the GPU's limits.
This guide uses Qwen2.5-7B-Instruct along with llama.cpp.
It includes memory calculations, a fixed starting configuration, and a Python-based benchmark that you can run on your own computer. The numerical memory estimates are calculated values, and this article does not claim to have measured improvements in GPU performance.
To understand the actual delay you experience, there are two main waiting periods in a conversation. The first occurs when the model processes the initial prompt, often called the prefill phase. The second happens when the model generates the answer one word at a time, known as the decode phase.
If a document takes several seconds to process, fast decoding won't eliminate that initial delay. However, if the first words appear quickly but the rest of the response is slow, then the decoding phase is the area that needs optimization.
Keep these measurements separate:
Measurement | What it tells you |
Time to first text | Delay before the client receives the first nonempty text chunk |
Decode tokens per second | The server's reported generation rate |
Total request time | How long that request takes to finish |
Output token count | Whether two runs produced comparable amounts of text |
A target such as "start a short answer within two seconds" can guide your own experiments. It is a product requirement you choose, not a promised result for every 8GB card.
Budget for the KV cache as well as the weights
The model file is only part of the memory requirement. During generation, the runtime also stores attention keys and values for tokens already processed. This KV cache avoids recomputing those states, but it needs memory of its own. Working buffers and other GPU applications need space too. [1]
For a conventional full-attention transformer, an approximate KV-cache payload is:
KV bytes = 2 x layers x stored tokens x KV heads x head dimension
x bytes per cache element
The initial 2 accounts for keys and values. Use the number of KV heads, which can differ from the number of query heads.
Qwen2.5-7B-Instruct has 28 layers, 4 KV heads, and a head dimension of 128, obtained from its hidden size of 3,584 divided by 28 query heads. With FP16 cache elements, the calculation becomes 2 x 28 x tokens x 4 x 128 x 2. [2]
Stored tokens | Calculated FP16 KV payload |
4,096 | 224 MiB |
8,192 | 448 MiB |
16,384 | 896 MiB |
32,768 | 1,792 MiB or 1.75 GiB |
These figures describe one sequence and exclude allocation padding, runtime buffers, and model weights. They are not measurements of total VRAM usage. Other architectures, cache layouts, and attention types need different calculations.
This is why a large advertised context window needs its own memory budget. On this model, moving from 4K to 32K tokens adds about 1.53 GiB of calculated FP16 cache payload. Whether that increase fits depends on everything else already occupying the GPU.
Weight quantization and cache quantization are separate choices. A Q4_K_M model can still use an FP16 KV cache. Reducing cache precision may free up space, but it needs a quality check and a latency measurement. Hugging Face's cache documentation also cautions that cache quantization can hurt latency in some short-context situations. [1]
Establish one repeatable baseline
The shell commands below target Linux or WSL2 with an NVIDIA GPU. Install a working NVIDIA driver, a compatible CUDA Toolkit, Git, CMake, and a C++ compiler first. The benchmark itself requires Python 3.10 or newer and no third-party Python packages.
Use the current CMake build route in the llama.cpp build documentation: [3]
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON -DCMAKE_BUILD_TYPE=Release
cmake --build build --config Release -j 4
git rev-parse HEAD > llama-commit.txt
./build/bin/llama-server --version > llama-version.txt
./build/bin/llama-server --help > llama-help.txt
nvidia-smi > gpu-environment.txt
Keep that checkout unchanged throughout the experiment. Save the model filenames and their SHA-256 hashes too, including every shard if the download is split. A model tag alone is not enough to reproduce an experiment after its files change.
I use the official Qwen GGUF repository because its model configuration is available to inspect. It is a concrete baseline, not a claim that this is the best available model. [4]
Start the server from the llama.cpp directory:
./build/bin/llama-server \
-hf Qwen/Qwen2.5-7B-Instruct-GGUF:Q4_K_M \
--n-gpu-layers all \
--ctx-size 4096 --parallel 1 \
--batch-size 512 --ubatch-size 128 \
--flash-attn off \
--cache-type-k f16 --cache-type-v f16 \
--fit off --no-context-shift --perf \
--host 127.0.0.1 --port 8080 \
2> baseline-server.log
The first launch downloads the selected model. Exclude that download and startup from request timings. Once the server is ready, inspect its log for the CUDA device, layer placement, cache allocation, and effective context settings. If an installed version rejects an option, consult its saved help output before continuing. The current server options are documented upstream. [5]
This configuration requests full GPU offload; it does not guarantee that every 8GB system has enough free memory. If startup fails, first close another GPU workload or test a smaller context. If partial offload is necessary, record the actual GPU layer count and use it consistently across the comparison.
The baseline has one request slot. Keep other inference clients stopped while measuring. With automatic fitting disabled, a failed configuration is visible instead of becoming a different experiment through an adjusted setting.
Run a benchmark that preserves the evidence</
Strata 0.2.10 发布：本地 AI 大模型继续提速，默认使用 DFlash2 降低显存需求，8GB 显卡也能开启 128K 上下文
之前小众软件多次介绍过 Strata：这款开源工具可以让普通电脑，尤其是显存有限的消费级显卡，也能运行参数规模惊人的本地 AI 大模型，比如 Qwen3.8、Qwen-Flash-Next、DeepSeek 4.1 Flash 等模型。@Appinn
Strata 0.2.10 发布，这次带来了几项值得关注的改进：新的 DFlash2 推测解码器成为默认选项（降低4GB显存需求），8GB 显卡也能启动 128K 长上下文，多显卡推理速度大幅提升，还加入了一个专门针对编程任务优化的 DeepSeek 模型。
Strata 交流微信群
青小蛙拉了个交流 Strata 微信群，感兴趣的同学可以扫码入群：
8GB 显卡，也能开启 128K 上下文
以前在 8GB 显卡下，开启 64K 上下文会耗尽专家缓存空间，导致启动失败。只能改用 CPU 图像处理、更小的 KV 缓存，或将上下文降到约 48K。
Strata 0.2.10 改进了这套机制：当显存不足时，优先调整显存和内存之间的数据分配，尽可能保留用户设置的上下文长度。
比如，现在可以在 8GB 显存条件下启动 Qwen3.8 IQ3_S，并保持 128K 上下文，也就是 131,072 Token。
Strata 会根据显存余量，逐步缩小驻留在 GPU 中的 KV 缓存窗口，必要时还会调整其他缓存，甚至将部分数据放到系统内存中。
官方测试中：
- 8GB 显存限制下，DFlash2 模式生成速度达到 63～73 Token/s。
- 32K Token 的提示词处理时间为 19.8 秒。
- 一张真正的 Intel Arc A750 8GB 显卡，也成功启动 128K 上下文，生成速度为 12.7～14.8 Token/s。
注意，显存需求仍然在，不是凭空消失，而是把压力给到了内存和 SSD。
所以青小蛙认为，Strata 降低的只有显卡门槛，但却大大提升了内存容量门槛。
基本上，内存：32G起步，48G刚好，64G才算解决温饱。
DFlash2 成为默认加速器，还能额外节省 4GB 显存
Strata 0.2.10 将 DFlash2 设置为默认加速器。
DFlash2 是一种推测解码器。简单理解，就是让一个体积较小的辅助模型提前猜测接下来可能生成的内容，再交给主模型批量验证。猜对的部分越多，主模型就越有机会一次确认多个 Token，从而加快生成速度。
此前 Strata 使用的 MTP 推测层大约需要 5.2GB 空间，而新版 DFlash2 的显存占用约为 625MiB。
官方对比了同一引擎下 DFlash2 和 MTP 的表现：
| 测试设备 | 模型 | 生成速度提升 |
|---|---|---|
| Ryzen AI Max（Windows） | IQ3_S | 短回复 +8.4% |
| RTX PRO 5000 | IQ3_S | 短回复 +6.23% |
| Apple M5 Max | IQ3_S | +3.8% |
| DGX Spark | IQ3_S | +5.8% |
但是，也不是没有代价。
DFlash2 与 MTP 对比
相比之下，MTP 在硬件兼容性和多并发下都有优势：
| 对比项目 | DFlash2 | MTP |
|---|---|---|
| 显存占用 | 约 625MiB | 约 5.2GB |
| 额外文件 | 首次下载约 1.2GB | 推测层约 5.2GB |
| 单请求生成速度 | 多数官方测试更快 | 部分硬件更快 |
| 多并发 | 主要面向单请求 | 更适合多请求 |
| 低显存设备 | 优势明显 | 显存压力较大 |
| 支持范围 | 依赖特定模型与引擎 | 兼容范围更广 |
| Strata 0.2.10 默认策略 | 单请求 Qwen3.8 优先 | 多并发等场景优先 |
两张显卡一起跑，代码编辑速度接近翻倍
针对多显卡，这次更新带来优化：All-cards Split Engine。
以前多显卡运行模型时，常见做法是将模型的不同层分配到不同显卡。新的方式则允许多张显卡共同处理每一层模型，让它们同时参与计算。
官方使用两张 RTX A6000，在 Linux 下运行 UD-Q4_K_XL，得到以下结果：
| 测试任务 | 原来的速度 | 新版速度 |
|---|---|---|
| 代码编辑 | 195 Token/s | 377～394 Token/s |
| 生成新代码 | 139～144 Token/s | 189～232 Token/s |
| 普通文本 | 93 Token/s | 139～146 Token/s |
| Agent 循环 | 112～119 Token/s | 165 Token/s |
代码编辑任务的生成速度几乎翻倍。
还加入了一个编程专用的 DeepSeek 模型
Strata 0.2.10 新增了 ISTA-DAS Coder。它基于 DeepSeek-V4.1-Flash，针对编程和 Agent 任务进行了专家裁剪，每层只保留原来 384 个专家中的 192 个。
这样可以减少需要处理的专家权重。
官方测试中：
- 单张 Radeon AI PRO R9700：22.8 Token/s。
- 四张 R9700：59.2 Token/s。
- Apple M5 Max：19.1～22.5 Token/s。
- RTX PRO 6000 Blackwell：约 100 Token/s。
不过，这个模型的存储需求依然很大，仅模型权重就有约 72.1GB，另有约 110.6GB 的 Engram 数据文件，首次完整下载约需 191GB。
Agent 用户也迎来一批实用修复
除了推理性能，这次 Strata 还修复了不少图形界面和 Agent 相关问题。
比如：
- AI 回复很长时，Approve 和 Deny 审批按钮不再被滚动到看不见的位置。
- 子 Agent 可以接收用户追加的指令。
- 历史对话自动摘要现在会尽量使用用户原本的语言。
- AI 正在生成内容时，可以选择等待、排队发送新消息或者中断。
- 支持引用之前的某轮对话或选中的文字。
- 改善 Claude Code 遇到上下文溢出时的错误提示，让它能够尝试压缩上下文。
另外，Strata 也修复了 Windows 某些后台启动场景下，磁盘读取优先级过低、导致模型加载明显变慢的问题。
下载与更新
Strata 免费、开源，提供 Windows、macOS 和 Linux 版本。本次更新后 Strata 版本为 0.2.10，引擎版本 0.1.56。这两者都需要单独更新。
依旧，Strata 图形界面用户可以直接更新：
终端版用户可以运行：
strata update
项目地址： https://github.com/Niko1221/Strata
另外，每次升级都需要下载不小的文件，好慢啊。
原文：https://www.appinn.com/strata-0-2-10/
相关阅读
为什么最聪明的代码助手，反而不能秒回你的消息？
（本文作者为 摩尔观察，钛媒体经授权发布）
文 | 摩尔观察
很多把 AI 引入日常研发的工程师，都有过一种类似的抓狂体验：刚敲完一段提示词，起身去接杯水，回来发现终端里的进程早就卡在半路，光标孤零零地停在屏幕上，等着你手动敲一个回车确认。
过去一段时间，市面上各类编程助手的宣传都在强调生成有多快：敲下一行自然语言，大模型瞬间吐出几百行代码，终端里的测试用例全绿。但在真实的软件团队里，这种看似惊艳的即时反馈，正在变成一场高频的精力拉锯战。
智能体每读一个文件、改一行配置、跑一条命令，都要弹出来请示一次。你在群聊里刚把业务背景交代清楚，转头去代码评审工具里提修改，又得把前因后果重新搬运一遍。一旦任务涉及跨模块排障或依赖重构，会话窗口很快被几十轮上下文撑爆，稍有不慎就答非所问。
把这层尴尬挑明的，是来自国内顶尖技术团队的一份架构方案。2026 年 10 月 31 日晚，DeepSeek Harness 团队在官方公众号发表了题为《Super-agent 设计探索：迈向更自主的 Agent 系统》的技术长文，系统阐述了一套面向软件工程的研究原型设计。
据官方长文披露，团队在开篇没有过多渲染大模型写代码能跑多快，而是开宗明义点出了一项核心准则：尽可能少占用人的注意力，尽可能多交付价值。
这篇技术长文直接指出了 AI 编程目前最尴尬的瓶颈：当底层模型的单点生成能力越来越强，限制产出规模的瓶颈早就变了，真正卡住团队的是人类开发者的注意力极限。逼着智能体在聊天框里对人类秒回加请示，往往只会把人累死。把它扔去后台，做成一套能自己调度、彼此隔离的分布式系统，才是 AI 真正融入软件工程该走的路。
AI 写代码越快，人类反而越忙了
在现有的编程智能体架构中，单会话串行模式从来都不便宜，它吃掉的是人的精力。
目前主流的代码助手，无论是命令行工具还是桌面插件，底层逻辑基本都绑在单一的思考与行动循环里。这个小小的对话框塞了太多杂活：一边得听懂人话，一边得伸手去跑命令行读写文件，还得硬生生顶住几十轮工具调用的超长上下文。
据 DeepSeek Harness 团队在长文中的观察，一个人类工程师在实际工作中，同时能保持深度记忆并有效跟进的活跃会话，通常只有三到五个。一旦超出这个数量，人类大脑就无法维持多条上下文的连续性，只能被迫在不同的聊天窗口之间反复横跳。
活跃会话通常只有三到五个
比模型能力更现实的麻烦，出在协作断层上。在真实研发场景中，沟通从来不是单点的。产品经理可能在即时通讯群里提出方案调整，架构师在代码评审里给出两行批注，CI 流水线又在后台报出编译失败。在单会话架构下，这三条信息分散在不同平台，智能体彼此割裂，唯一的同步纽带就是中间那个疲于奔命的人类开发者。
这种设计让开发者沦为了廉价的上下文搬运工与高频点击确认的审批工具。模型在屏幕前看似秒回，实际上是把最繁琐的多任务状态管理推给了人类。当工程师的大部分精力都被用来核对模型在几分钟前的执行意图时，所谓的高效就变成了一种隐蔽的精力内耗。
把 “调度官” 和 “干活的” 彻底拆开
既然单体循环扛不住复杂任务，最直观的工程解法，就是借用现代操作系统里的分治思想。
长文中拆解的原型方案，核心是把系统拆成了两层：前端常驻一个负责统揽全局的 Router，后端挂载多个相互独立的 Worker。这两者在职责、权限与模型资源配置上做了清晰的解耦。
常驻在群聊或仓库后台的 Router 充当了系统的调度中枢。它只负责阅读传来的事件消息，评估意图，并生成带有严格权限边界的工单，官方称之为带授权书的 Ticket。Router 本身甚至不需要配置底层高危的执行工具，在资源配比上只需要跑轻量级模型。它不碰具体的代码改动，不参与长时间的逻辑推理，目的就是保证全局交互通道通畅，不至于因为某个复杂任务陷入死锁。
真正去啃硬骨头的，是拿到工单后在后台自动启动的 Worker。每一个 Worker 拥有独立的执行会话与隔离工作区。只要环境允许，系统就会自动给 Worker 分配一个独立的 Git 临时工作树，让它在干净的代码副本里随便折腾，改配置、跑测试都不影响主干。
这种物理隔离直接切断了长任务之间的相互污染。开发一个新接口与排查线上报错可以由不同的 Worker 在后台并行推进，即便其中一个因为代码死循环跑崩了，也不会污染主分支，更不会把 Router 的主控上下文搞混。粗活累活由隔离的子节点在后台消化，对外统一由调度官向人类交卷，多任务并行才有了可靠的工程支撑。
别让所有信息都去骚扰大脑
除了把执行与调度拆开，如何在纷繁复杂的消息洪流中保持克制，是决定智能体能否真正进驻团队的关键。
在日常协作环境中，群聊讨论、代码提交流水线、自动化测试报错每时每刻都在产生。如果智能体像一个热衷于刷存在感的新手实习生，对每一条消息都跳出来插嘴，整个研发团队的注意力瞬间就会被通知淹没。
DeepSeek 在设计中引入了类似传统网络协议的事件过滤与直通机制。消息一多，系统先用几行轻量代码规则把闲聊和杂音卡在门外。只有撞上白名单的真正事件，才会交到大模型手里去理解意图。
对于那些从讨论中推断出来的潜在任务，系统在权限控制上设置了一个极其克制的默认档位。DeepSeek 给主动接单加了道紧箍咒：默认只开观察模式。哪怕大模型一眼看出代码有缺陷、该重构了，也只敢在本地日志里悄悄记上一笔这活原本能接，没有人类开口点头，绝不敢擅自领工单去改代码。
另一个在工程上极为实用的设计是订阅直通。当某个 Worker 认领了一个 Pull Request 之后，系统会在底层自动建立多对多的事件映射。后续针对该 PR 的所有评审意见，都会被底层系统直接投递给负责该任务的 Worker 进程，不再需要重新经过 Router 进行二道贩卖。据 DeepSeek Harness 团队公布的模拟测试数据，在消除了对主控的反复打扰后，调度中枢的冗余决策次数下降了约三成，读取缓存所需的计算资源也缩减了三分之一以上。把沟通链路压缩在真正干活的上下文内部，系统才能在多方协作中保持安静。
算得过账，才进得了团队
当技术方案从单机演示走向团队全天候驻留，最终考核的从来不看单次对话有多聪明，只看整个系统的鲁棒性与运行效率。
在很多团队的盲目想象中，智能体似乎越全能越好，最好能拥有无限记忆并在后台永不停歇地自主思考。但在真实的计算账本里，这种空中楼阁随时会因为一次网络闪断或进程崩溃而解体。
DeepSeek 在长文中展示的，是一种典型的祛魅工程视角。为了应对长时间运行中不可避免的卡死与异常，系统将状态存储与模型计算彻底分开。任务的授权状态、工单进展以及交互历史全部落盘存入本地轻量数据库，执行环境则完全容器化。即便本地宿主机重启或者会话进程超时，系统也能通过外部独立的看门狗机制重新唤起，从数据库中读取最后一次快照继续向下推进，不需要人类重新把前因后果敲一遍。
在团队针对约三百条消息、二十项工作请求的模拟调度实验中，这套分治系统的任务完成时间展现出了明显的工程优势。在面对高并发的消息冲击时，这套分治系统的尾部延迟（P95 任务耗时）死死卡在 15.7 分钟内。反观那种没做分层的单会话方案，一旦并发上来，最慢的任务直接被拖到了快半小时。
P95 任务耗时卡在 15.7 分钟
这种系统级的吞吐量并非毫无代价。多进程并发和精细的状态维护，本质上是在用更多的模型调用频次与缓存开销，去换取整体执行的平稳与人类注意力的解放。对于软件工程而言，只要能把开发者从无休止的上下文对齐中拯救出来，这笔计算资源的增量开销在团队账本上就是划算的。
写在最后
过去两年，整个 AI 行业几乎被一种拟人化的叙事带偏了方向。很多人本能地以为，一个好的编程助手就应该像真人一样坐在屏幕对面，秒回每一句话，殷勤地汇报每一个进度。
但软件工程的底层规律，从来不讲人情世故，它只认状态机、流水线和确定性的交付接口。
DeepSeek 这套架构方案最有意思的地方，是它反过来质疑了秒回这件事本身。它没有把精力耗费在如何让大模型说话更有礼貌、或者在终端里把打字动画做得更炫酷，而是把计算机系统经过数十年检验的调度规则、权限沙箱和缓存机制，原封不动地搬进了大模型架构里。
一个真正成熟的工业级智能体，在研发流线里没必要当个让人提心吊胆的话痨助手，老老实实当一套沉在代码仓库底部、不抢注意力、按规矩交付的自动化工装就够了。别在聊天框里表演那些秒回的虚招，踏踏实实在后台把脏活干完。能静默交付，AI 编程才算告别极客玩具，熬成软件工程里靠得住的底座。
更多精彩内容，关注钛媒体微信号（ID：taimeiti），或者下载钛媒体App
OpenAI、Claude新旗舰同日曝光！
Precise Edit by Ideogram
Precise editing with context window
Inadvertent Context Leakage in Language Models
Slim attention: cut your context memory in half without loss -- K-cache is all you need for MHA
GROME: GROunding Factorized MEmory into Video World Models
STRIATUM-CTF: A Protocol-Driven Agentic Framework for Autonomous CTF Solving