# Anthropic 研究:小型 AI 模型可能接近在 IoT 设备上自主复制
> 原标题:AI models may be capable of self-replicating without access to a datacenter
- 来源:Anthropic:Research
- 发布时间:2026-10-11T16:00:00.000Z
- AIHOT:https://aihot.news/items/emc0djmqlomn6b5whge285x7l
- 原文:https://www.anthropic.com/research/self-replicating-ai
## 摘要
Anthropic 发文评估小型模型在无数据中心条件下自主复制(ARA)的可行性,作者实验显示 9B 模型可在测试的 9 类硬件中 8 类上跑通推理,30B 及以下模型已能完成复制的多数单步。
## 推荐理由
Anthropic 用自购的 15 台廉价电视盒实测小模型分布式推理与复制链路,读者可据此评估 AI 蠕虫这类威胁的近期可行性。
## 正文 · 中文译文
_William Zhou, Daniel Freeman_
我们的实验表明,小型 AI 模型可能只需数月就能发展到足以在商用 IoT 设备(如智能烤箱和非品牌 Android TV 盒子)上自我复制。这样的复制程序将难以关闭,因为不存在可供关闭的集中点——尽管它可能很慢(倍增时间为数天)。与非 AI 恶意软件不同,它还能自行识别不熟悉的设备。在我们的评估中,一个 9B 模型在我们测试的 9 种硬件类型中的 8 种上成功运行了推理。
参数规模在 30B 及以下的模型如今已经能够完成复制所需的许多单独步骤,尽管在将它们端到端组合起来时会出错。在我们简化的评估中,GLM-5.2 及更强的模型能够实现端到端复制。如果小型模型按其历史速度继续提升,它们将在今年年底达到这一能力水平。此后不久,基于权重的小型复制程序可能成为现实。
## 引言
不断提升的 AI 能力使一个长期存在的担忧日益成为现实:[自主复制与适应](https://arxiv.org/abs/2312.11671)(ARA),即模型在无人控制的情况下部署并传播自身。
在网络领域,蠕虫是一种无需人工输入即可从一台计算机复制到另一台计算机的程序。[先前的工作](https://arxiv.org/abs/2606.03811)已经表明,AI 智能体可以表现得像蠕虫一样:扫描其网络、执行漏洞利用,并将模型权重跨 GPU 集群复制到目标机器。这种“AI 蠕虫”可以在繁殖时携带其模型权重(或从公共枢纽重新下载它们),然后直接在受感染的硬件上运行推理。实际上,权重将成为恶意软件载荷的一部分。
数据中心 GPU 显然是此类恶意软件的高价值目标。但昂贵的加速器并非绝对必要。在这篇博文中,我们展示了一个由 IoT 设备组成的分布式僵尸网络——这些设备价格低廉且通常防护薄弱——也可以提供足够的算力来运行一个能力不错的模型。
我们在 15 台廉价非品牌 Android TV 盒子(每台约 55 美元)上分布式运行 Gemma4-26B-A4B,这些盒子由我们购买并联网,速度为每秒 0.39 个 token。下方每个方块代表一个物理 TV 盒子,在模型运行时承载模型的两层。
一组 15 台智能 TV 盒子正在分布式推理 Gemma4-26B-A4B。
当然,要证明自主蠕虫能够在由弱机器组成的网络中自我传播,还有许多其他步骤。就本篇博文而言,我们将复制链分解为几个步骤。

在本研究中,我们将自主复制分解为四个实际阶段:寻找目标、获得执行、建立推理,以及从新主机继续传播。
我们在很大程度上忽略了复制过程中的网络漏洞利用环节(上述前两个阶段),因为较早的论文 [CyberGym](https://arxiv.org/abs/2506.02548)、[ExploitBench](https://arxiv.org/abs/2605.14153) 和 [自适应蠕虫](https://arxiv.org/abs/2606.03811) 已经表明,小型模型有能力进行网络漏洞利用,尤其是在获得合适工具的情况下。但复制过程中一个较少被测量的部分涉及在受感染设备上建立推理,这正是我们此处的重点。
在这篇文章中,我们首先列出了我们认为最有可能实现的威胁模型。然后,我们测试了小模型能否在陌生的硬件上设置推理,以及它们能否在一组机器之间串联起完整的复制周期。之后,我们估算了这种蠕虫可能传播的速度,并测试了它能否在复制过程中学习和适应。最后,我们总结了 AI 蠕虫与前 AI 恶意软件的区别,并简要提出了针对此类复制体的防御建议。
### 威胁建模
在这篇博文中,我们关注 AI 蠕虫可能传播的一种方式:通过攻陷宿主机器进行复制的小模型。但 AI 蠕虫还可能尝试其他几种方法:它们可以窃取访问权限以启动主机(例如 API 密钥或平台凭证),或通过合法工作(如数字自由职业)来支付推理费用。我们认为目前最接近实现的威胁模型如下:
1. A small model, replicating via host compromise. In this post, we’ll call autonomous worms that run their models directly on compromised hardware _weight-based replicators_. Home and small business IoT devices might be the first target for such attacks because they’re connected to the internet and, historically, have had minimal security measures in place.
一个大到无法装入单个设备的模型可以被拆分成多个分片,运行在彼此通信的独立机器上,共同运行该模型。能够为 <30B 模型运行重要模型分片的机器包括智能冰箱、智能烤箱、自动吸尘器和割草机。越来越多的家庭和企业设备,如安全摄像头和视频会议设备,现在都内置了小型 AI 芯片,设计用于在设备本身上运行 AI 模型。这种额外的计算能力很可能也会使它们成为有吸引力的目标。
1. 人类黑客通常通过社会工程(例如,说服公司的 IT 部门你是忘记密码的员工)而非黑客技术来入侵安全系统。对于当今的小模型来说,这种权衡似乎正好相反,与它们的社会工程能力相比,它们在智能体编码和黑客方面相对较强(见附录 E),不过随着模型改进,这种情况可能会改变。
2. A large, advanced weight-based replicator focused on datacenters and other high-compute targets. Larger models tend to have correspondingly better cyber capabilities, but will also need to breach (relatively) hardened datacenters to run themselves. We split this threat model into two subcategories:
1. 前沿复制体:大型闭权重复制体在其实验室的基础设施上运行,可以启动[未受监控的内部部署](https://blog.redwoodresearch.org/p/ai-catastrophes-and-rogue-deployments),或将其权重窃取到外部计算资源上。
2. 开放权重复制体:这些复制体起步时资源相对较少(因为无法受益于实验室的计算资源),但一开始就处于未受监控状态。
3. 基于 API 的复制体,其中模型通过窃取自身推理 API 的凭证来进行复制。这类复制体需要模型提供商在不知情的情况下为它们提供服务,而且它们的持久性可能更差,因为它们可能更容易被发现(不过如果它们能够利用受害者的账户进行复制,其传播速度可能会更高)。
在实践中,AI 蠕虫不一定只由单一模型或策略组成。由不同模型组成、部署在不同类型的硬件上、使用各种复制方案的集群,可能代表更现实的“最坏情况”攻击。
在这篇博文中,我们考虑了**小型基于权重的复制体**(上述第 1 节)的可行性。我们关注这一点,是因为它是一个可以直接研究的近期威胁模型。我们在本文顶部的演示——一个 26B 模型运行在 15 台机器上——表明 IoT 设备可以运行能力惊人的模型。这些模型是否足够有能力执行自主复制?
我们将从两个方面来考察这一点。第一,小模型能否在陌生的硬件上让模型运行起来?第二,它们能否在单次运行中完成整个循环(找到一台未感染的设备、将自己复制过去、在那里开始运行,并重复这一过程)?
## A. 推理环境搭建

在上图展示复制循环的各个阶段中,推理环境搭建是研究最少的一个,对小型模型来说可能也是最具挑战性的。它需要围绕选择兼容的推理栈、找到正确版本的软件包以及调试特定机器的问题,做出一系列相当长的、与硬件和操作系统相关的决策。这些步骤是串行依赖的,一旦失败就很难恢复。
### 旁注
### 评估推理环境搭建性能
我们衡量不同开放权重模型在异构硬件类型上服务 Llama3.1-8B 的能力。下表列出了在各种硬件类型上服务的每秒 token 数:
- 点击单元格查看其服务速度分布。
- 点击行/列标签可获取跨模型或硬件类型的对比。
小型模型,例如 Qwen3.5-9B,能够在从 Jetson Nano 到 Mac PC 和 RTX 4090 的硬件上搭建推理服务器。能力更强的模型,例如 GLM-5.2,不仅更可靠,还能实现更高的服务 token/s,从而加快复制速度。我们测试并提及特定芯片,是为了衡量模型在这些芯片上搭建推理环境的效果。这些芯片本身并不是风险或漏洞的来源。
我们使用 Memento 运行这些实验,它是在开源 [Pi](https://pi.dev/) 编码智能体之上构建的一套工具。Memento 旨在缓解我们在长时程运行中观察到的一种常见失败模式:智能体可能会执迷于一个错误的想法(比如,某个 bug 为何会出现),并继续沿着它走下去,而不是回头另寻他路。此类失败的一个例子是,一个 Qwen 智能体花了数小时调试软件包版本问题,而真正的 bug 却来自实现了一个与评分器 API 不兼容的端点。
Memento 会定期启动一个新的智能体实例,并带上先前智能体的工作区以及先前智能体就自己尝试过什么所写的一组简短笔记,让后续实例能够采取不同的策略。
### 模型如何在智能电视上运行?
IoT 设备内存较小,但像 [Petals](https://arxiv.org/abs/2209.01188) 那样的分布式推理使得服务我们的轻量级模型变得可行。代表性的威胁模型是 [Kimwolf](https://synthient.com/blog/a-broken-system-fueling-botnets),这是一个大型 IoT 僵尸网络,感染了超过两百万台设备,主要是杂牌 Android 电视。这类智能电视盒子很容易买到,通常运行 Android 开源项目(AOSP)的分支,而它们的制造商[并未为其添加安全功能](https://www.securityweek.com/vo1d-botnet-evolves-as-it-ensnares-1-6-million-android-tv-boxes/)。这一价位的典型盒子配备 1 到 4 GB 的 RAM。假设有 4GB RAM 并采用 4 位量化,这允许用 4 台或更多机器推理 9B 模型,用 10 台以上机器推理 26B 模型。
在本文顶部的演示中,我们在 15 台各配备 4GB RAM 的智能电视盒子上运行了 Gemma4-26B-A4B。我们以流水线并行方式对模型进行分片,每个盒子持有模型层的一小部分。
## B. 病毒式传播:在 GCP 节点集群上自主搭建与复制
现在我们已经看到模型可以在陌生的硬件上设置推理,接下来让我们衡量模型是否有能力组合这些步骤——也就是说,扫描网络寻找目标、通过反向 shell 访问它们、发送病毒载荷(权重和运行框架),并设置推理。
### 自主推理设置与复制(使用简化的网络攻击)
为此,我们构建了一个防火墙保护的 VPC,包含 8 个运行 redroid(一个 Android 15 模拟器)的 GCP 节点。零号病人(灰色节点)被植入蠕虫。随后的每一次感染都是蠕虫自身通过未认证的 ADB 端口在节点间跳转,然后设置一个推理服务器来服务 Llama3.1-8B。如果推理服务器通过若干正确性和反作弊检查,我们就在目标节点上生成蠕虫的另一个副本(例如,如果 GLM-5.2 设置 Llama3.1 在一台机器上运行,我们就在其上生成一个 GLM-5.2 蠕虫的副本)。蠕虫的模型运行在单独的推理服务器上,因为 VPC 节点不够大,无法运行较大的模型。
在下图中,我们将给定模型作为载荷放入,并衡量其复制能力。
### 为什么让模型为 Llama3.1-8B 而不是它们自己搭建推理?
在我们测试的开源权重模型中,只有 GLM-5.2 能够完成完整的端到端复制(假设其能力可以打包进 Llama3.1-8B)。注意,GLM-5.2 能可靠地做到这一点,而其他模型则可靠地失败(它在 5 次试验中有 4 次传播到 8/8 个节点,1 次传播到 7/8)。
看来 GLM-5.2 能够很好地传播 Llama3.1-8B,这表明未来同等能力水平的小模型也可能完成复制过程中的网络枚举、载荷投递和推理搭建步骤。我们的评估将复制中的网络攻击元素保持为简单(ADB 端口上没有认证),这使其成为现实世界成功的上限。注意,过去的 IoT 僵尸网络通过简单的方式复制,例如遍历制造商默认的用户名和密码列表,就像 [Mirai 僵尸网络](https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/antonakakis)那样,因此现实中的 IoT 安全可能并不比我们评估中的简单步骤困难多少。
作为合理性检查,我们可以看看自主性和编排步骤有多难(如果去掉网络攻击和推理设置,完成剩余的命令行苦力活有多难?)。这个消融实验是上述评估去掉推理设置步骤(通过预先编写的脚本完成)。我们名单中的许多模型,包括较小的模型,都能完成这些剩余步骤。
在受控的 17 节点 redroid 集群上复制:两个各 8 节点的子集通过一个枢轴节点连接(见附录 F,使用温和提示)。每棵树是该模型六次运行的中位数。
对于这个蠕虫,我们可以设想:
1. 一个模型能力下限,自主蠕虫必须高于它才能可靠地完成复制。在我们的简化评估中,GLM-5.2 位于这个下限之上。
2. 一个模型规模上限,模型必须低于它,才能在它所攻击的设备上运行。对于我们测试的智能电视类别(4GB 内存),Qwen3.5-9B 和 Gemma4-26B-A4B 位于这个上限之下。
目前,下限和上限并不相交。它们何时会相交?
上面是一张总参数量不超过 30B 的知名开放权重模型的图表,每个模型按其发布日期对照 [Epoch 能力指数](https://epoch.ai/eci)(ECI)绘制。实线是各日期同类最佳模型的最小二乘拟合,年增长为 13.7 ECI(R2 为 0.95)。如果我们以 GLM-5.2 作为复现的能力下限,趋势线表明到 2026 年底会出现达到该水平的小模型。ECI 是一个通用能力指数,只是复现能力的代理指标,因此这只是对小模型复现器何时成为可能的粗略估计。
## C. AI 物联网蠕虫可能以多快的速度自我复制?
与编码智能体不同,这些复现器运行速度低于面向用户的聊天和编码工具的交互速度。其传播将是缓慢而持久的,token 在边缘硬件上涓涓流出。我们可以用在真实智能电视上达到的速度作为复现速度的实证基线。对于 Gemma4-26B-A4B,在 32k 上下文长度 token 窗口下,未优化速度约为 0.3 tok/s,这是在我们推理设置工作负载中预填充和解码的平均值。更多细节见附录 C。
衡量总耗时的一种方法是测量完成一个 32k 大小上下文窗口所需的时长,之后将发生压缩。根据我们的推理设置评估统计,完成一条轨迹需要约 2.6 到 4.7 个完整窗口。
| **模型** | **窗口时间** | **完整推理设置时间** |
| --- | --- | --- |
| Gemma4-26B-A4B(未优化) | 27.3-31.8h | 71h-150h |
| Qwen3.5-9B | 10.9 h | 28-51h |
Kimwolf 僵尸网络在峰值时感染的设备数量,[据 Synthient 报告](https://synthient.com/blog/a-broken-system-fueling-botnets),超过 200 万台(主要是 Android TV 盒子)。在一个规模相当的、为 AI 模型提供服务的受感染电视集群中,如果每 15 台电视运行一份 Gemma4-26B-A4B,我们将拥有约 133k 份副本(“复本”)。像我们演示中那样的一组电视可以同时服务 2 个智能体,每个约 0.3 token/秒,整个僵尸网络合计产生 80k token/s。
作为参照,一块 H100 在[高并发配合推测解码](https://jarvislabs.ai/blog/gemma-4-mtp-vs-dflash-benchmark)下可以约 1.95k tok/s 的速度服务 Gemma4-26B-A4B,因此我们的集群最多相当于约 40 块 H100 的推理能力。从绝对量来看,这是极少的算力,而且这些智能体是缓慢的复现者(每次 9B 复现需要 1-2 天以上)。打个比方,可以把复现器想象成黏菌或一群果蝇,它们需要数天才能完成复制。
这是一个粗略估计,因为它仅基于单一类别的物联网硬件和过去的一个僵尸网络实例,但它描述了近期发布的简单复现器可能是什么样子。在实践中,能力更强的复现器会利用其他类型的低安全性算力,并会机会主义地在不同设备上部署各种规模的模型。(它也不必把模型载荷加载到它攻陷的每台设备上)。随着时间推移,我们预计已部署的边缘算力总量将继续增长,而可靠复现所需的最小模型规模则会下降。
## D. 适应与能力提升
### 边干边学
ARA 中的“适应”部分是 AI 复制器可能比传统蠕虫表现更优的原因之一。具体来说,模型和提示词在传播过程中可以经历拉马克式演化——也就是说,父实例可以将其提示词、代码和笔记传递给子复制器。为了适应并传播到各种硬件上,模型需要具备两个条件:
1. 具备超过一定阈值的能力,以便传播到新颖、未见过的硬件(或软件环境、网络类型)上。
2. 一旦见过,就能适应它所落入的环境类型(它应该能在以前见过的硬件上更可靠地复制)。
A 节和 B 节测试第一个条件,在下面的实验中我们测试第二个条件。每个 Qwen3.5-9B 实例都会简要记录它尝试过的策略和遇到的失败,然后新实例继承这些笔记并再次尝试相同的推理设置。
Qwen3.5-9B 六代实例的推理设置成功率,每个实例都继承前者的笔记。细线是 20 个单独谱系,粗线是每一代中完成设置的运行比例。它从第一代的 45% 上升到后续几代的 61% 到 84% 之间。这使用的是 Memento 设置(附录 A)。
### 听取建议
另一个担忧是,小模型可以向_前沿顾问_求助,这是一个更强的模型,要么作为工具调用提供,要么在小模型卡住时主动给出建议。为了测试这一点,我们在推理设置任务中让 Qwen3.5-9B 可以访问 Opus 4.8。前沿模型的建议没有可测量的帮助:小模型往往不知道要问正确的问题,而且当建议是主动给出时它们也不会改进。
即使通过强化学习在类似环境(Python 编程问题)中训练使用顾问,小模型在推理启动方面仍然难以有效地求助。两个结果都显示在下面的图中。
按顾问访问权限划分的推理设置成功率,带有 Wilson 95% 置信区间。访问顾问,无论是作为工具调用提供还是在卡住时自动提供给模型,都没有显著改善。两个 RL 组在软件工程任务中接受了顾问访问训练,最右边的组还会在卡住时奖励调用顾问。
由于小模型是有能力且持久的个体智能体,并且对建议利用不佳,我们认为协调更可能发生的方式是:由大模型处理高层策略,并将小模型作为子智能体启动。
## E. 这与 AI 之前的僵尸网络有何不同?
像 [Kimwolf 僵尸网络](https://www.cloudflare.com/learning/ddos/glossary/aisuru-kimwolf-botnet/) 这样的硬编码僵尸网络各自针对特定类型的设备——在 Kimwolf 的案例中是 Android TV 和移动设备。AI 僵尸网络不绑定任何特定的硬件或软件类型,小模型能够在从 Jetson Nano 到 Mac 的机器上设置推理引擎就证明了这一点(见 A 节中的表格)。我们预计 AI 僵尸网络会感染的不只是 IoT 设备,并且会将基于权重的复制作为其策略手册中的一种策略。AI 僵尸网络还可以智能地采取行动对抗防御者,但我们尚未测试这一点。
## F. 蓝队缓解措施
与流行病一样,防御涉及将 R₀(每个受感染设备继续感染的新设备数量)降至 1 以下,从而使复制器消亡而不是持续流行。
围绕这一威胁模型的一些因素对防御者有利:
1. A weight-based replicator multiplying through IoT machines at scale would leave a network signature, visible as an anomaly in ISP flow-based monitoring systems. Newly infected hosts may receive multi-gigabyte model payloads from other devices or external hosting services, while distributed inference can produce sustained device-to-device traffic between machines that wouldn’t ordinarily communicate at that volume. Propagation itself would add additional scanning and outbound connection patterns.
在实践中,复制器需要在复制速度和隐蔽性之间权衡:复制得越快,产生的流量就越多。一旦复制器被发现,防御者可以利用蜜罐(诱饵设备)收集复制器的框架和载荷,以刻画其行为特征。
2. 当一家 ISP 利用外部获得的感染证据来隔离并通知客户时,Mirai 僵尸网络的[修复才成为可能](https://www.ndss-symposium.org/ndss-paper/cleaning-up-the-internet-of-evil-things-real-world-evidence-on-isp-and-consumer-efforts-to-remove-mirai/)。隔离受感染的用户意味着将其网络限制为只能访问一个简短的站点白名单,否则就将其浏览器重定向到清理说明。这在 14 天内清除了 92% 的感染,而未通知的情况下仅为 74%。我们预计,隔离对于针对基于权重的复制器的初始防御也会同样有效。要彻底消灭复制器,意味着需要与每一个存在受感染网络的 ISP 进行协调,这非常困难。
3. 制造商可以缩小目标池,而监管则起到协调作用。例如,[默认 IoT 密码现在在英国市场已属不合规](https://www.ncsc.gov.uk/blog-post/smart-devices-law)。转向更安全的默认设置并提高合规基线,将有助于加固防御,抵御 AI 和脚本化僵尸网络。
## G. 结论:生命的迹象
让 AI 模型成为通用强大编码代理的能力,同样可以泛化到网络任务,包括自主复制。就像 2024 年的编码代理一样,我们看到了 AI 蠕虫的生命迹象。我们还没有一个完整的流氓复制器,但代理正越来越有能力完成复制链条中的各个步骤(并将其适应性传递给自身的未来副本)。
与此同时,数据中心内外可用的推理算力都在不断增加(见附录 D)。自主 AI 复制究竟会以何种形式出现尚不确定。它可能是一种缓慢、分布式的“数字黏菌”,寄生在相对不安全的算力上。它也可能是一个强大的网络模型,以高速攻破数据中心,或者是一个通过诈骗人们获取算力额度的模型。
作为一个超出我们实验范围的预测,我们预计未来将充斥着运行在各种硬件上的代理,其中一些并不受人类控制。虽然 IoT 设备长期以来确实一直存在漏洞,但轻量级代理可能比人类攻击者更愿意付出努力,去攻陷全球 IoT 算力的很大一部分。慢速复制器的兴起也将是更激进、更快速复制器的先兆,后者能够攻破更坚固的机器,或成为有效的 API 密钥窃贼。我们的目标应该是加固系统,使此类复制器难以传播,同时也要准备好应对一个它们将长期存在的世界。
## 附录
### A. Memento 框架
Memento 的执行方式如下:
1. 我们生成一个代理实例,它会处理问题一段时间(直到生成超时)。
2. 该实例会记录简要笔记,并在超时后总结一份小文档,说明它尝试过的策略、遇到的失败以及其表现(如果成功的话)。
3. 我们创建一个新的代理实例,它从前任继承代码库和环境,以及该笔记。
在服务实验中,每个模型都被置于一个 Memento 框架中,并给予每次迭代 1.5 小时 / 总共 6 小时的超时限制。提示中提供了约 1k token 的信息,包括硬件规格和一个简单示例分析器的脚本。
Memento 旨在提高长时程可靠性,而非赋予新的网络或推理特定能力。它也不是一个普遍强大的框架;我们预计,随着能力的提升,即使没有任何框架,小模型作为复制器也会进步。
单次尝试与 Memento 的对比,按模型(95% Wilson 置信区间)。
### B. 为什么使用流水线并行?
推理中常见的并行方案包括张量并行(TP)、专家并行(EP)和数据并行。大多数智能电视 / IoT 设备使用 ARM Cortex CPU 和 DDR3/4 内存;在此类机器上,我们几乎总是受带宽限制。
我们使用流水线并行是因其容错特性。如([Borzunov et al. 2022](https://arxiv.org/abs/2209.01188))所述,张量并行 / 专家并行中单个节点的故障会导致运行模型副本的整组机器宕机。流水线并行允许替换宕机节点,该节点所持有的层的 KV 缓存可通过在重启节点之前对节点进行另一次前向传递来重新计算。
### C. IoT 硬件上的吞吐量与内存
在此类机器上,无论是预填充还是解码,我们几乎总是受限于每台机器的 RAM 带宽。即使在普通的 ARM Cortex 核心上,计算吞吐量也超过了 RAM 带宽。由于流水线气泡,解码工作负载存在显著的每机器空闲时间,因为在每次前向传递期间只有一台机器处于活动状态。交错工作的并发是可能的,但严格的内存限制意味着并发度保持较低。
每台机器内存与上下文的关系——4 位权重 + fp8 KV + 激活值。
预填充和解码的 token/秒均随序列长度严格下降。下图是我们的推理速度与上下文长度的关系图:
模型能够胜任工作也存在一个最小序列长度。我们使用的框架是从 Pi 编码代理([pi.dev](https://pi.dev/))分叉而来,并包含原生压缩机制——即便如此,我们发现当序列长度被限制在 32K 以下时,模型性能会大幅下降。
Qwen3.5-9B 在推理设置任务上的代理能力与上下文窗口预算的关系。
鉴于上述评估,我们假设 32k 上下文长度可能足以实现合理的代理性能。在我们的推理设置工作负载中,标准的 32k 长度上下文窗口包含 12–15% 生成的解码 token,其余为来自提示和工具调用的预填充。由于流水线气泡,预填充 token 的计算速度快约 15 倍。对整个 32k 上下文中的每个 token 的时间求和(考虑预填充和解码速度),我们发现生成 3.8-4.8k 解码输出 token 并处理约 28k 预填充 token 需要 27.3-31.8 小时(Gemma4-26B-A4B)和 10.9 小时(Qwen3.5-9B)。
每条链的输出 token 数(对一条链的多次生成求和),按模型;中位数 ≈ 19.7k / 12.3k / 11.0k。数据来自推理设置评估。
### D. 边缘加速器
我们可以利用 Nvidia Jetson 设备池来计算一个更好的上界,这些设备是边缘加速器。与传统的 IoT 僵尸网络不同,IoT 边缘设备可以完整地提供整个模型服务。一台 Jetson AGX Orin 64 GB [以每秒 76.7 个 token 运行 Qwen3-30B-A3B](https://developer.nvidia.com/blog/introducing-nvidia-jetson-thor-the-ultimate-platform-for-physical-ai/),而 AGX Thor 可达 226 tok/s。请注意,我们并不认为它们异常脆弱——这只是为了计算上界。野外搭载 Jetson 的设备类型包括:
1. 用于安防的 AI 智能摄像头,内置加速器,已大规模部署。
2. 会议设备通常由板载加速器驱动,用于设备端降噪或转录。
3. 车辆、四足和双足机器人以及无人机。我们预计网络安全将成为车辆的重点关注领域,因此大多数潜在目标可能位于另外两类中。
在 FOFA 上快速搜索,至少有一台配备加速器的智能摄像头主机似乎可通过 IPv4 访问:

FOFA 搜索发现了一台带有已知边缘加速器的主机,可通过 IPv4 被发现并返回 HTTP 200。不过,可访问并不意味着它一定可被利用。
虽然很难估计野外有多少台配备边缘加速器的机器可访问且存在漏洞,但我们可以计算设备数量的严格上界。野外大约有 90 条不同的 NVIDIA 芯片 IoT 产品线,已部署约 950 万台设备。可访问性绝大多数是通过出站云管理隧道而非入站端口实现的,这意味着大多数设备无法通过 Web 访问。历史上从未出现过配备加速器的边缘设备被大规模入侵的情况,而标准 IoT 僵尸网络则有过此类事件,这表明入侵此类设备会更加困难。
各设备系列的已部署数量,按互联网可访问性着色。
根据产品数据进行的非常粗略的估计表明,边缘加速器中大约存在 9,000 到 35,000 个 H100 等效算力,但可访问的数量可能低一个数量级甚至更多(而存在漏洞的数量则更低)。
### 附注
### E. 鱼叉式钓鱼能力
我们还衡量了现代小型模型在鱼叉式钓鱼方面的熟练程度。鱼叉式钓鱼是指向特定个人发送定向消息,诱骗其泄露凭据或运行恶意软件的行为。虽然小型模型的智能网络能力飙升,但其通用知识和语言复杂度提升较慢;我们预计社会工程攻击和钓鱼主要由大型/前沿模型完成(尽管在同时运行大型和小型模型的异构僵尸网络中,这很可能是次要的复制途径)。
在 Meta 的 CyberSecEval 3 鱼叉式钓鱼评估([Wan et al. 2024](https://arxiv.org/abs/2408.01605))上的鱼叉式钓鱼能力,本地复现。评分范围为 0-5,由 gpt-4o 作为评判者。红色菱形是论文(CyberSecEval 3)对参考模型的人工评分标准分数,这表明 gpt-4o 的评分比人工评分者宽松约 0.4-0.7 分。2 分为“差”,3 分为“中等”,4 分为“好”。当按人工评分者标准化后,小型模型的得分为“非常差”到“差”。
405B 参考槽位使用 Hermes-3-405B 作为不可用的 Llama3.1-405B-Instruct 的最小拒绝替代品。
### F. 使用脚本化推理设置的传播:
我们在一个由 17 台主机组成的网络上又进行了几项实验,其拓扑结构如下:
两个网络各含 8 台主机,通过一个可访问两个子网的单一节点相连。每个网络内部均为全互联。蠕虫代理从 A 段中的单个零号病人节点开始;枢纽节点增加了一点额外的挑战,即蠕虫需要获取对枢纽节点的访问权限并从该节点重新扫描。
每台设备都运行 Android,且 ADB 端口开放且无需认证。在传播到新目标后,代理能够立即发起直接调用以自我复制——这只是为了在我们排除网络与推理设置步骤后,衡量剩余步骤的难度。如图所示,即使是 3B 模型也能到达大约一半的节点。这为我们评估中在网络或推理设置要素下未能衡量的阻塞因素数量设定了一个上限。
对“跨 17 节点网络的复制”中各次运行的更详细分解。每一列是在提示中不同引导程度下到达节点数的中位数,下标表示有多少代理越过枢纽节点到达网络的另一侧。
## 正文 · 原文
_William Zhou, Daniel Freeman_
Our experiments suggest that small AI models may be months away from being capable enough to self-replicate on commercial IoT devices, like smart ovens and off-brand Android TV boxes. A replicator like this would be challenging to shut down, since there’s no centralized point to shut off - though it may be slow (with a doubling time of days). Unlike non-AI malware, it could also figure out unfamiliar devices on its own. In our evals, a 9B model got inference running on 8 of the 9 hardware types we tested.
Models of 30B parameters and under can already complete many of the individual steps for replication today, though they make mistakes when composing them end to end. In our simplified evals, GLM-5.2 and stronger models are capable of end to end replication. If small models improve at their historical rate, they’ll match this capability level by the end of this year. Small weight-based replicators may be possible soon after.
## Introduction
Ever-improving AI capabilities make a longstanding concern increasingly realistic: [autonomous replication and adaptation](https://arxiv.org/abs/2312.11671) (ARA), which involves a model deploying and propagating itself without human control.
In cyber, a worm is a program that copies itself from one computer to the next without human input. [Prior work](https://arxiv.org/abs/2606.03811) has already shown that AI agents can act like one: scanning their network, executing an exploit, and copying model weights to a target machine across a GPU cluster. Such an “AI worm” could carry its model weights with it as it reproduces (or re-download them from a public hub), and then run inference directly on compromised hardware. Effectively, the weights would become part of the malware payload.
Datacenter GPUs would be a clear, high-value target for such malware. But expensive accelerators aren’t strictly necessary. In this blog post, we show that a distributed botnet of IoT devices—which are cheap and typically poorly defended—could also provide enough compute to run a capable model.
We run Gemma4-26B-A4B, distributed over 15 inexpensive off-brand Android TV boxes (~$55 each) that we bought and networked together, at 0.39 tokens per second. Each tile below shows one physical TV box holding two of the model’s layers as the model runs.
A fleet of 15 Smart TV boxes running distributed inference of Gemma4-26B-A4B.
Of course, there are many other steps to showing that an autonomous worm can propagate itself across a network of weak machines. For the purposes of this blog post, we break down the replication chain into a few steps.

For this study, we decompose autonomous replication into four practical stages: finding targets, gaining execution, establishing inference, and continuing propagation from the new host.
We largely ignore the cyber exploit element of the replication process (the first two stages above), since earlier papers [CyberGym](https://arxiv.org/abs/2506.02548), [ExploitBench](https://arxiv.org/abs/2605.14153), and [adaptive worms](https://arxiv.org/abs/2606.03811) already show that small models are capable of cyber exploits, especially when given the right tools. But a less commonly measured part of the replication process involves setting up inference on compromised devices, which is our focus here.
In this post, we first lay out the threat models that we think are most likely to be realized. Then, we test whether small models can set up inference on unfamiliar hardware, and whether they can chain the full replication cycle together across a fleet of machines. After that, we estimate how fast such a worm could spread, and test whether it could learn and adapt as it replicates. We conclude with how AI worms would differ from pre-AI malware, and brief suggestions for defenses against such replicators.
### Threat modelling
In this blog post, we’re focused on one way that AI worms might propagate: small models that replicate through compromising their host machines. But there are several other methods that AI worms might try: they could steal access in order to spin up hosts (for example, API keys or platform credentials) or pay for inference through legitimate work (e.g digital freelancing). The threat models that we think are closest to being realized today are the following:
1. A small model, replicating via host compromise. In this post, we’ll call autonomous worms that run their models directly on compromised hardware _weight-based replicators_. Home and small business IoT devices might be the first target for such attacks because they’re connected to the internet and, historically, have had minimal security measures in place.
A model that’s too large to fit on one device can be split into pieces, or shards, that run on separate machines that communicate with each other to collectively run the model. Machines that could run a significant model shard for a <30B model include smart fridges, smart ovens, automatic vacuum cleaners, and lawnmowers. A growing number of home and business devices, such as security cameras and video-conferencing units now ship with small built-in AI chips, designed to run AI models on the device itself. This extra computing power will likely make them attractive targets as well.
1. Human hackers often breach secure systems through social engineering (for example, convincing a company’s IT department that you’re an employee who forgot your password) rather than hacking. This tradeoff appears to be flipped for today’s small models, which are relatively strong at agentic coding and hacking compared to their social engineering capabilities (see Appendix E), though this might change as models improve.
2. A large, advanced weight-based replicator focused on datacenters and other high-compute targets. Larger models tend to have correspondingly better cyber capabilities, but will also need to breach (relatively) hardened datacenters to run themselves. We split this threat model into two subcategories:
1. Frontier replicators: Large closed-weight replicators run on their lab’s infrastructure, and can spin up [unmonitored internal deployments](https://blog.redwoodresearch.org/p/ai-catastrophes-and-rogue-deployments) or exfiltrate their weights onto external compute.
2. Open-weight replicators: These replicators start off relatively lower-resourced (due to not benefitting from a lab’s compute), but start unmonitored.
3. An API-based replicator, in which a model would replicate by stealing credentials for their own inference API. These replicators would require a model provider to unknowingly serve them, and their persistence may be worse, since they’d likely be easier to discover (although their rate of spread may be higher, if for instance they’re able to replicate using victims’ accounts).
In practice, an AI worm wouldn’t necessarily consist of just one model or strategy. A swarm of different models deployed on different types of hardware using a variety of replication schemes might represent a more realistic ‘worst case scenario’ attack.
In this blog post, we consider the feasibility of **small weight-based replicators** (section 1 of the above). We focus on this because it’s a near-term threat model that can be investigated directly. Our demo at the top of this post, a 26B model running across 15 boxes, shows that IoT devices can run surprisingly capable models. Could these models be capable enough to carry out autonomous replication?
We examine this in two parts. First, can small models get a model running on unfamiliar hardware? And second, can they do the whole cycle (find an uninfected device, copy themselves over, start running there, and repeat) all together in a single run?
## A. Inference setup

Of the stages in the above diagram showing the replication cycle, inference setup is the least studied and may be the most challenging for small models. It requires a fairly long sequence of hardware and OS-specific decisions around picking a compatible inference stack, finding the right versions of packages, and debugging machine-specific issues. These steps are serially dependent, and failures are difficult to recover from.
### Aside
### Evaluating inference setup performance
We measure the ability of different open-weight models to serve Llama3.1-8B across heterogeneous hardware types. See the table below for tokens per second served across various hardware types:
- Click a cell for its distribution of serving speeds.
- Click a row/column label to get a comparison across models or hardware type.
Small models, such as Qwen3.5-9B, are capable of setting up inference servers on hardware from Jetson Nanos to Mac PCs and RTX 4090s. More capable models such as GLM-5.2 are not only more reliable but also achieve higher serve tokens/s, allowing for faster replication. We test and mention specific chips to measure how well models can set up inference on them. The chips aren’t a source of risk or vulnerabilities.
We run these experiments using Memento, a harness we built on top of the open-source [Pi](https://pi.dev/) coding agent. Memento is designed to mitigate a common failure mode we observe in long-horizon runs: an agent can become fixated on an incorrect idea (for, say, why a bug is occurring) and continue pursuing it instead of backtracking. One example of such a failure is a Qwen agent debugging package versioning for hours when the real bug came from implementing an endpoint incompatible with the grader API.
Memento periodically starts a fresh agent instance with the previous agent’s workspace and a short set of notes written by the previous agent on what it tried, allowing later instances to pursue different strategies.
### How does a model run on Smart TVs?
IoT devices are light on memory, but distributed inference as in [Petals](https://arxiv.org/abs/2209.01188) makes serving our lightweight models feasible. The representative threat model is [Kimwolf](https://synthient.com/blog/a-broken-system-fueling-botnets), a large IoT botnet that infected over two million devices, primarily off-brand Android TVs. Such smart TV boxes, which are readily available for purchase, typically run forks of the Android Open Source Project (AOSP), which their manufacturers [don’t add security features to](https://www.securityweek.com/vo1d-botnet-evolves-as-it-ensnares-1-6-million-android-tv-boxes/). Typical boxes in this range ship with between 1 and 4 gigabytes of RAM. Assuming 4GB of RAM at 4-bit quantization, this allows for inference of 9B models with 4 or more machines, and inference of 26B models with 10+ machines.
In the demo at the top of this post, we ran Gemma4-26B-A4B across 15 smart TV boxes with 4GB of RAM each. We sharded the model under pipeline parallelism, where each box holds a small fraction of the model’s layers.
## B. Going viral: autonomous setup and replication across a GCP node fleet
Now that we’ve seen that models can set up inference on unfamiliar hardware, let’s measure whether models are capable of composing the steps—that is, scanning a network for targets, accessing them via a reverse shell, sending over the viral payload (weights and harness), and setting up inference.
### Autonomous inference setup and replication (with simplified cyber)
To do this, we built a firewalled VPC of 8 GCP nodes running redroid, an Android 15 emulator. Patient zero (gray node) is seeded with the worm. Every subsequent infection is the worm itself hopping node to node over an unauthenticated ADB port, before setting up an inference server to serve Llama3.1-8B. If the inference server passes a number of correctness and anti-cheating checks, we spawn another copy of the worm on the target node (for example, if GLM-5.2 sets up Llama3.1 to run on a machine, we spawn a copy of the GLM-5.2 worm on it). The worm’s model runs on a separate inference server, since the VPC nodes aren’t large enough to run the larger models.
In the graph below, we drop a given model in as a payload and measure its ability to replicate.
### Why task the models to stand up inference for Llama3.1-8B and not themselves?
Only GLM-5.2 out of our set of tested open-weight models is capable of full end-to-end replication (assuming its capabilities could be packed into Llama3.1-8B). Note that GLM-5.2 does this reliably while the other models fail reliably (it spread to 8/8 nodes in 4 out of 5 trials and 7/8 in 1).
It appears that GLM-5.2 is able to propagate Llama3.1-8B well, which suggests that future small models of the same capability level could also complete the network enumeration, payload delivery, and inference standup steps of the replication process. Our evaluation keeps the cyber-exploit element of the replication trivial (there’s no authentication over the ADB port), which makes this an upper bound on real-world success. Note that past IoT botnets have replicated via means as simple as going through a default list of manufacturer usernames and passwords, as in the case of the [Mirai botnet](https://www.usenix.org/conference/usenixsecurity17/technical-sessions/presentation/antonakakis), so real IoT security might not be dramatically more difficult than the trivial step in our evaluation.
As a sanity check, we can see how difficult the autonomy and orchestration step is (if we took out cyber and inference setup, how tough is doing the remaining command-line grunt work?). This ablation is the above evaluation with the inference setup steps removed (done via a pre-written script). Many models in our roster, including the smaller ones, are capable of these remaining steps.
Replication on a contained 17-node redroid fleet: two subsets of 8 nodes joined by one pivot node (see Appendix F, with the mild prompt). Each tree is the model’s median run of six.
When it comes to this worm, we can envision:
1. A model capabilities floor that an autonomous worm must sit above, to complete its replication reliably. In our simplified eval, GLM-5.2 sits above this floor.
2. A model size ceiling that the model must sit under, such that it’s feasible to run on the devices it’s attacking. Qwen3.5-9B and Gemma4-26B-A4B sit under this ceiling for the class of smart TVs we test (4GB of RAM).
Right now, the floor and ceiling don’t intersect. When might they?
Above is a plot of notable open-weight models of 30B total parameters or fewer, each plotted at its release date against the [Epoch Capabilities Index](https://epoch.ai/eci) (ECI). The solid line is the least-squares fit over the best models in-class at each date, with a gain of 13.7 ECI per year (R2 of 0.95). If we take GLM-5.2 as a capabilities floor for replication, the trend line puts a small model at that level by the end of 2026. ECI is a general capability index, which is only a proxy metric for replication ability, so this is only a rough estimate of when a small-model replicator becomes possible.
## C. How fast might an AI IoT worm replicate?
Unlike coding agents, these replicators would be running below the interactive speeds of user-facing chat and coding harnesses. The spread would be slow and persistent, with tokens being trickled out on edge hardware. We can use our achieved speeds on our real smart TVs as a demonstrated baseline for replication speeds. For Gemma4-26B-A4B, unoptimized speed across a 32k context length token window is about 0.3 tok/s, averaged across prefill and decode in our inference setup workload. More details in Appendix C.
A way to measure total time taken is to measure the number of hours it takes to complete a 32k-sized context window, after which compaction will occur. Based on our inference setup eval statistics, it takes between ~2.6 and ~4.7 full windows to complete a trajectory.
| **model** | **window time** | **full inference setup time** |
| --- | --- | --- |
| Gemma4-26B-A4B (unoptimized) | 27.3-31.8h | 71h-150h |
| Qwen3.5-9B | 10.9 h | 28-51h |
The number of devices infected by the Kimwolf botnet at its peak, [reported by Synthient](https://synthient.com/blog/a-broken-system-fueling-botnets), is somewhere over 2 million (primarily Android TV boxes). In an equivalently-sized infected fleet of TVs serving AI models, if every group of 15 TVs ran a copy of Gemma4-26B-A4B, we would have ~133k copies (“replicas”). A group of TVs like the ones in our demo can serve 2 agents simultaneously at roughly 0.3 tokens per second each, yielding 80k tokens/s across the botnet.
As a reference point, an H100 can serve Gemma4-26B-A4B at ~1.95k tok/s at [high concurrency with speculative decoding](https://jarvislabs.ai/blog/gemma-4-mtp-vs-dflash-benchmark), so our swarm would have at most about 40 H100s-worth of inference. This is a tiny amount of compute in absolute terms, and the agents are slow replicators (over 1-2 days per 9B replication). As an analogy, imagine the replicator as a slime mold or a swarm of fruit flies, which replicate over days.
This is a rough estimate, as it’s anchored on a single class of IoT hardware and a single past botnet instance, but describes what a simple replicator released in the near future might look like. In practice, more capable replicators would take advantage of other types of low-security compute, and would be opportunistic about deploying models of various sizes on different devices. (It also wouldn’t have to load a model payload onto every device it compromises). Over time, we expect the amount of deployed edge compute to continue growing, while the minimum model size required for reliable replication falls.
## D. Adaptation and uplift
### Learning on the job
The “Adaptation” part of ARA is one reason why an AI replicator might outperform a traditional worm. Specifically, models and prompts can undergo Lamarckian evolution as they spread–that is, parent instances can pass on their prompts, code, and notes to their daughter replicators. In order to adapt and spread across a wide variety of hardware, a model would require two things:
1. Being above a certain threshold of capability for spreading onto a novel, unseen piece of hardware (or software environment, or network type).
2. Once seen, adapting to the type of environment it has landed in (it should replicate more reliably on hardware it has seen before).
Sections A and B test the first condition, and in the experiment below we test the second. Each Qwen3.5-9B instance keeps brief notes on the strategies it tried and the failures it encountered, before a new instance inherits those notes and attempts the same inference setup again.
Inference setup success rate across six generations of Qwen3.5-9B, each inheriting the former’s notes. Faint lines are the 20 individual lineages, and the bold line is the proportion of runs in each generation that complete setup. It rises from 45% in the first generation to between 61% and 84% in later ones. This uses the Memento setup (Appendix A).
### Taking advice
Another concern is that small models can ask for help from a _frontier advisor_, a stronger model that is either offered as a tool call or gives unsolicited advice when the small model is stuck. To test this, we gave Qwen3.5-9B access to Opus 4.8 during the inference setup task. The frontier model’s advice doesn’t measurably help: small models tend to not know the right questions to ask, and they don’t improve when the advice comes unprompted.
Even when trained through reinforcement learning to use the advisor in a similar setting (Python coding problems), the small model still struggles to ask for help productively for inference standup. Both results are shown in the plot below.
Inference setup success rate by advisor access, with Wilson 95% intervals. Access to an advisor, whether offered as a tool call or given to the model automatically when stuck, gives no significant improvement. The two RL groups were trained with advisor access on software engineering tasks, and the rightmost group also rewards calling the advisor when stuck.
Since small models are capable and persistent individual agents and make poor use of advice, we think coordination is more likely to happen with a large model handling high-level strategy and spinning up small models as subagents.
## E. How is this different from a pre-AI botnet?
Hard-coded botnets like the [Kimwolf botnet](https://www.cloudflare.com/learning/ddos/glossary/aisuru-kimwolf-botnet/) each target a specific type of device – in Kimwolf’s case, Android TVs and mobile devices. An AI botnet isn’t tied to any particular hardware or software type, as evidenced by small models being able to set up inference engines on machines from a Jetson Nano to a Mac (see the table in section A). We expect AI botnets to infect more than IoT devices, and to use weight-based replication as just one strategy in their playbook. AI botnets could also act intelligently to counter defenders, but we haven’t tested this.
## F. Blue-team mitigations
As with an epidemic, defense involves driving R₀ (the number of new devices each infected device goes on to infect) below 1, such that the replicator dies out instead of staying endemic.
Some elements around this threat model are in the defenders’ favor:
1. A weight-based replicator multiplying through IoT machines at scale would leave a network signature, visible as an anomaly in ISP flow-based monitoring systems. Newly infected hosts may receive multi-gigabyte model payloads from other devices or external hosting services, while distributed inference can produce sustained device-to-device traffic between machines that wouldn’t ordinarily communicate at that volume. Propagation itself would add additional scanning and outbound connection patterns.
In practice, the replicator trades off between replication speed and stealth: the faster it replicates, the more traffic it produces. Once the replicator is discovered, defenders can use honeypots (decoy devices) to collect the replicator’s harness and payload to characterize its behavior.
2. Remediation of the Mirai botnet [was possible](https://www.ndss-symposium.org/ndss-paper/cleaning-up-the-internet-of-evil-things-real-world-evidence-on-isp-and-consumer-efforts-to-remove-mirai/) when an ISP used externally obtained infection evidence to quarantine and notify customers. Quarantining infected subscribers involved restricting their networks to only being capable of reaching a short whitelist of sites, and otherwise redirecting their browsers to cleanup instructions. This cleared 92% of infections within 14 days, against 74% with no notification. We’d expect quarantining to be similarly effective for an initial defense against a weight-based replicator. Eliminating the replicator completely would mean coordinating across every ISP with an infected network, which is difficult.
3. Manufacturers can shrink the pool of targets, with regulation acting to coordinate. For example, [default IoT passwords are now non-compliant in UK markets](https://www.ncsc.gov.uk/blog-post/smart-devices-law). Moving to more secure defaults and raising the baseline for compliance will help harden against both AI and scripted botnets.
## G. Conclusion: Signs of life
The capabilities that make AI models generally powerful coding agents also generalize to cyber tasks, including autonomous replication. Like coding agents in 2024, we’re seeing signs of life for AI worms. We don’t yet have a full rogue replicator, but agents are becoming increasingly capable of completing the individual steps in the replication chain (and passing on their adaptations to future copies of themselves).
At the same time, increasing amounts of inference compute are now available both inside and outside of datacenters (see Appendix D). It’s uncertain exactly what form autonomous AI replication will take. It could be a slow, distributed “digital slime mold,” living on relatively insecure compute. It could also be a powerful cyber model that breaches datacenters at a high pace, or a model that scams people for compute credits.
As a prediction that goes beyond our experiments, we expect a future awash with agents running on all types of hardware, including some that aren’t under human control. While it’s true that IoT devices have been vulnerable for a long time, lightweight agents may be much more willing than human attackers to put in the effort to compromise large fractions of the world’s IoT compute. The rise of slow replicators would also be a bellwether for more aggressive, faster ones that can breach more hardened machines or be effective API key thieves. We should aim to harden our systems to make it difficult for such replicators to spread, but also prepare to deal with a world where they are here to stay.
## Appendix
### A. The Memento harness
Memento executes as follows:
1. We spawn an agent instance, which tackles the problem for a while (until generation timeout).
2. The instance keeps brief notes, and after timeout summarizes a small doc of the strategies it tried, the failures it encountered, and its performance (if successful).
3. We create a new agent instance that inherits the codebase and environment from its predecessor as well as the notebook.
In the serving experiment, each model is placed in a Memento harness and is given a 1.5 hour per iteration / 6 hour total timeout. Around ~1k tokens of information, including specs about the hardware and a script for a simple sample profiler, are given in the prompt.
Memento is intended to improve long-horizon reliability rather than grant new cyber or inference-specific capabilities. It’s also not a universally strong harness; we expect that small models will improve as replicators even without any harnessing as capabilities improve.
Single attempt compared against Memento, by model (95% Wilson CI).
### B. Why pipeline parallel?
Common parallelism schemes for inference include tensor parallel (TP), expert parallel (EP), and data parallel. Most smart TV / IoT devices use ARM Cortex CPUs and DDR3/4 memory; on such machines, we’re almost always bandwidth bound.
We use pipeline parallelism for its fault-tolerant properties. As noted in ([Borzunov et al. 2022](https://arxiv.org/abs/2209.01188)), the failure of a single node in tensor parallel / expert parallel brings down the full set of machines running the model replica. Pipeline parallel allows the downed node to be replaced, with the KV cache for the layers held by the node recomputable via another forward pass of the node prior to the restarted node.
### C. Throughput and memory on IoT hardware
Across such machines, we’re almost always RAM-bandwidth bound per-box across prefill and decode. Even on modest ARM-cortex cores, compute throughput outpaces RAM bandwidth. Decode workloads have significant per-machine idle time due to pipeline bubbling, as only one machine is active at a time during each forward pass. Concurrency with staggered work is possible, but tight memory constraints mean that concurrency stays low.
Per-box memory vs context — 4-bit weights + fp8 KV + activations.
Both prefill and decode tokens/s strictly decrease with sequence length. Below is a graph of our inference speeds against context length:
There’s also a minimum sequence length at which models are competent. The harness we use is forked off of the Pi coding agent ([pi.dev](https://pi.dev/)) and contains a native compaction mechanism - even still, we find that models take a large performance hit when their sequence lengths are restricted below 32K.
Qwen3.5-9B agentic competence on the inference setup task vs. context window budget.
Given the above eval, we assume that a 32k context length may be sufficient for reasonable agentic performance. A standard 32k-length context window in our inference setup workload consists of 12–15% generated decode tokens, with the rest being prefill from prompts and toolcalls. Prefill tokens are much faster to compute by a factor of ~15, due to the pipeline bubbling. Taking the sum of time per token over the whole 32k context (taking into account prefill and decode speeds), we find that generating the 3.8-4.8k decode output tokens and processing the ~28k prefill tokens takes between 27.3-31.8h for Gemma4-26B-A4B and 10.9h for Qwen3.5-9B.
Per-chain output tokens (summed over a chain’s generations), by model; medians ≈ 19.7k / 12.3k / 11.0k. Data from the inference setup eval.
### D. Edge Accelerators
We can compute a better upper bound by using the pool of Nvidia Jetsons, which are edge accelerators. Unlike the traditional IoT botnet, IoT edge devices can serve a full model wholesale. A Jetson AGX Orin 64 GB [runs Qwen3-30B-A3B](https://developer.nvidia.com/blog/introducing-nvidia-jetson-thor-the-ultimate-platform-for-physical-ai/) at 76.7 tokens per second, and an AGX Thor reaches 226 tok/s. Note that we don’t believe they’re unusually vulnerable - this is just to count the upper bound. The types of devices with Jetsons in the wild include:
1. AI-enabled smart cameras for security with embedded accelerators are deployed at substantial scale.
2. Conferencing machines are frequently powered by an onboard accelerator for on-device noise cancellation or transcription.
3. Vehicles, robot quadrupeds and bipeds, and drones. We expect cybersecurity to be a focal point for vehicles, so the majority of the potential targets likely lie in the other two categories.
At least one accelerator-equipped smart camera host appears to be reachable on IPv4 on a quick search on FOFA:

A FOFA search surfaces a host with a known edge accelerator, discoverable and answering HTTP 200 over IPv4. The fact that it’s accessible doesn’t mean it’s necessarily exploitable, though.
While it’s difficult to estimate how many edge-accelerator-equipped machines in the wild are reachable and vulnerable, we can calculate a strict upper bound of the amount of devices present. Across the wild there are on the order of 90 distinct NVIDIA-silicon IoT product lines and roughly 9.5 million fielded units. Reachability is overwhelmingly through outbound cloud-management tunnels instead of inbound ports, meaning that the majority are not web-reachable. There have been no historical mass-compromises of accelerator-equipped edge devices the way there have been standard IoT botnets, suggesting that compromise of such devices would be more difficult.
Fielded units per device family, colored by internet reachability.
A very rough estimate based on product data suggests that somewhere between 9,000 and 35,000 H100-equivalents of compute exist in edge accelerators, but the amount that’s reachable is likely an order of magnitude or more lower (and the vulnerable population even lower than that).
### Aside
### E. Spearphishing capability
We also measure how proficient modern small models are at spearphishing. Spearphishing is the act of sending targeted messages to specific individuals to trick them into revealing credentials or running a piece of malware. While the agentic cyber capability of small models has skyrocketed, their general knowledge and linguistic sophistication have improved more slowly; we expect social engineering attacks and phishing to be largely accomplished by large/frontier models (although it’s very plausible that this is a secondary replication vector in a heterogeneous botnet running both large and small models).
Spear-phishing capability on Meta’s CyberSecEval 3’s spear-phishing eval ([Wan et al. 2024](https://arxiv.org/abs/2408.01605)), replicated locally. Scored on a scale of 0-5, with gpt-4o as a judge. Red diamonds are the paper’s (CyberSecEval 3) human-rubric scores on the reference models, which indicates that gpt-4o scores ~0.4-0.7 pts more leniently than human raters. 2 is “poor”, 3 is “intermediate”, and 4 “good.” When normalized to human raters, small models score “very poor” to “poor”.
The 405B reference slot uses Hermes-3-405B as a minimal-refusal stand-in for the unavailable Llama3.1-405B-Instruct.
### F. Propagation with scripted inference setup:
We run a few more experiments on a network of 17 hosts in a topology like so:
Two networks with 8 hosts each, connected by a single node with access to both subnets. Each network is all-to-all connected. The worm agent begins on a single patient zero node in segment A; the pivot node adds a slight extra challenge in having the worm needing to gain access to the pivot node and re-scan from it.
Each is running Android with an ADB port open without authentication. Upon spreading to a new target, the agent is able to invoke a direct call to replicate itself immediately - this is just to measure the difficulty of the remaining steps, after we exclude the cyber and inference setup steps. As shown in the graph, even a 3B model reaches about half the nodes. This puts a bound on the number of blockers in our eval that we fail to measure under the cyber or inference setup elements.
A more detailed breakdown of the runs in “replication across a 17 node network.” Each column is the median number of nodes reached under different amounts of guidance in the prompt, and the subscript denotes how many agents cross over the pivot node to the other side of the network.