2026-10-17 22:10

酷玩实验室coollabs

速览

本文来自微信公众号： 酷玩实验室 ，作者：酷玩实验室

01：一人成军

最近，韩国金融圈出了件大事。

9月底到10月初，韩国多家金融机构接连遭到网络攻击，大量客户个人信息被泄露，具体严重到什么程度？

根据韩媒报道，新韩银行约2.5万名客户的信息遭到泄露，KB国民银行也报告了多起数据泄露事件，至于泄露的总量，韩国媒体报道的数字是七家机构约6.8万条记录！

属实搞了波大的

以至于让韩国总统李在明都亲自下场要求政府需加强应对网络安全威胁。

当韩国警方和监管部门还在展开调查时，10月7日，美国网络安全公司CrowdStrike率先发布了一份调查报告，揭开了这起攻击事件背后更多离谱的细节......

调查人员发现，幕后攻击者可能是一名来自中国广东的个人黑客。

据报告披露，该名攻击者主要使用了一款名为ARTEX的国产开源AI渗透测试工具。

这里需要说明一下，ARTEX本身并不是一个大模型，而是一个能够调用外部大模型、辅助执行渗透测试任务的AI Agent，所以还称不上是什么黑客专用工具。

简单理解一下就是，以前一个人想要完成网络侦察、漏洞攻击等一系列操作，自己往往需要掌握多种网安工具或黑客技术；而有了AI Agent之后，就可以让AI协助完成其中大部分任务，从而降低操作门槛。

根据CrowdStrike的报告，攻击者主要通过ARTEX调用了DeepSeek V4.1-Flash，同时还在其他Claude Code会话中使用了GLM-5.3和Grok 4.6，算是相当中西结合的混搭了。

在调用模型的线路上，CrowdStrike还判断，攻击者很可能是通过一个疑似LLM API代理或转售商的站点来使用的DeepSeek，再加上代理服务器和一些传统攻击手段，整套体系就拼成了一条隐蔽的攻击流水线。

报告提到，攻击者还搭建了两套服务器基础设施：一套位于香港，承担主要的攻击者控制基础设施角色；另一套则运行ARTEX，可能直接参与了针对韩国金融机构的攻击。

网友：别人搞攻击，自己查天气，还不行

也就是说，这不是随手问AI几个安全漏洞那么简单，而是把大模型、自动化工具和传统手段全结合起来，真正投入到了大范围的入侵活动当中。

如果事情只到这里，那它还只是一则AI辅助网络攻击的新闻。

真正让人意想不到的，是CrowdStrike后续发现的东西。

小活儿大耍

调查人员在疑似攻击者控制的服务器上发现，相关目录竟然可以被外部访问，其中包括Claude Code的配置文件、历史会话记录、ARTEX配置文件，甚至还有Claude的记忆文件。

在这些暴露的文件里，详细记录了诸多攻击细节，换句话说，攻击者在使用AI工具执行任务时留下的部分工作记录，连同工具配置和上下文信息，都能直接被外部人员读取。

这就像一个人一边请AI帮自己干活，一边却忘了给存放工作记录的抽屉上锁。本该用来隐藏攻击过程的基础设施，反过来成了调查人员追踪攻击活动的突破口。

随着这些会话记录被分析，调查人员发现了更多颇具戏剧性的内容。

在相关Claude Code会话中，攻击者曾询问Claude：“韩国泄露的数据通常在哪里出售？”、“有没有专门交易这些数据的Telegram群组？”等问题......

也从侧面也说明了，AI对现在黑客攻击的赋能程度还是太高了，不光能技术支持，连销路都能问问。

报告公开了详细个人信息

不过，这些提问倒是为调查人员判断其可能的行动目的提供了线索，对方极有可能已经成功出售了被窃取的数据。

更有意思的是，攻击者还曾让Claude帮忙制作一份网络安全研究员简历。

这份简历请求中包含了一些个人信息，例如姓名缩写、年龄、电话号码、Telegram账号、教育背景和所在地。

网传：黑客个人信息为嫁祸

不儿？？？大哥，你都发起了这么大范围的网络攻击，咋还找上网络安全研究员的工作了啊？

该不会想把本次攻击当做自己简历核心竞争力大书特书吧？（滑稽

正因如此，CrowdStrike发现了指向中国广东茂名的身份线索，以及在华南理工大学毕业与26岁年龄等个人信息。

整件事情看下来，真是有一种草台但又生猛的既视感。

本年度最反差最反转的黑客攻击事件

一边用AI发动攻击，一边又用AI包装履历+打听赃物销路，最后又被AI的“工作记录”出卖，这条线索链条的讽刺意味，恐怕连他自己也没想到。

虽然该案件仍在深度调查中，但其基本能代表AI时代下的黑客攻击去中心化趋势。

一个技术没那么精湛的黑客，都能发动如此大规模的攻击，甚至惊动一国总统。

就像一把枪能简单到被一个孩子操作，那带来的杀伤力同样是巨大。

02：去中心化时代

无独有偶，在近一年时间内，全球由AI辅助的黑客攻击事件频发。

IBM在2026年的《数据泄露成本报告》里披露，在恶意攻击导致的数据泄露中（包含全球600多家遭遇泄露的机构），每4起就有1起使用了AI，同比增长了56%；在2025年版报告里，该比例还只有约六分之一。

Anthropic分析了2025年3月至2026年3月间被封禁的832个恶意账号，其中574个用AI来提升攻击能力，560个出现在恶意软件开发相关的活动中。换句话说，滥用的主要场景是让AI写代码、造工具，而不只是写钓鱼邮件。

《卷卷有AI名》

毕竟有了AI的帮忙，黑客攻击的平均技术水平都显著上升，智能化趋势明显。

在一个名为“vibe hacking”的案件中，身份不明的黑客借助AI把侦察、窃取凭证、渗透网络等环节自动化，先后盯上至少17家机构，涉及医疗、紧急服务、政府和宗教组织。

在此过程中，AI跳出了只写攻击代码的范畴，其还负责判断哪些被盗文件最值钱，分析受害者的财务数据，并生成“针对心理弱点”的勒索话术，算是直接服务起了全流程。

根据亚马逊披露，有一个以攻击牟利且跟AI沟通语言为俄语的攻击者，在2026年1月11日至2月18日期间，借助商用生成式AI服务，入侵了55个以上国家的600多台FortiGate防火墙。

好家伙，连俄罗斯那边的黑客也开始放弃传统手艺，转用AI了是吧？

更反转的是，这位“俄罗斯黑客”的技术并不高，整个行动没有用利用任何新漏洞。

它靠的仅仅是暴露在外的管理端口和单因素认证的弱口令，但AI足以帮一个不够专业的攻击者把这些基本功漏洞给大规模地“收割”了。

此外，这位黑客留下的“同款彩蛋”，同样证明其在技术上的业余，跟本次“广东茂名哥”留下了类似线索。

因为亚马逊发现了攻击者可公开可访问的基础设施，里面有AI生成的攻击计划、受害者配置和自制工具的源码，以及大量俄语的行动文档和检查清单——简直有点太巧了......

除了让AI帮忙攻击，有人也利用AI来当黑客攻击的“卖铲者”。

令人羡慕的商业头脑

有一名英国攻击者用AI开发、包装并销售多种勒索软件，这些产品带有规避检测、加密和防恢复功能，在暗网论坛上以400至1200美元的价格卖给其他犯罪者。

听上去还挺厉害哈？都开发上了，还不是自己用。

结果根据调查，这人似乎在离开AI后，根本没有独立实现加密、反分析和Windows底层操作的能力。

数亿的受攻击文件

攻击规模化&高频化则是另一个因AI而起的趋势。

身份盗窃资源中心（ITRC）的报告显示，2026年上半年美国共报告1803起数据泄露事件，高于去年同期的1732起；相关受害者数据超过4.71亿份，而2025年全年才2.975亿份。该报告明确指出AI在攻击中的作用越来越大。

不要以为大部分遇袭对象是一些网络安防较差的中小型企业，除了本次韩国大型金融机构被入侵，连像很多国家的政府数据库都被AI加持的黑客大规模攻击过。

2025年12月至2026年初，墨西哥政府系统便遭到了大规模入侵。

根据以色列安全公司Gambit Security的报告称，攻击者滥用Claude Code，先后攻陷了10个墨西哥政府机构和一家金融机构，最先攻击了墨西哥税务部门，窃取数据超过150GB，涉及的身份和税务记录超过1.95亿条。

不过，最具有代表性的莫过于朝鲜黑客爽用AI爆米的海量案件。

刻板印象中的朝鲜黑客们不都是技术精湛的天才黑客吗？谁还需要人工智能来帮忙？

实则不然，在朝鲜黑客内部，这上限与下限之间差了个十万八千里。

上限拥有着以“拉撒路”为代表的顶级黑客团体，可以轻松窃取上亿美金的加密资产，但相关人才终究只占少数。

FBI公开统计的部分朝鲜黑客

剩下的大部分黑客，不如说是有操作互联网权限的“朝鲜IT民工”。

这帮所谓“黑客”主要利用搭建钓鱼网站、植入恶意软件等手段来盗取数字资产。所以，无论是智能化还是规模化上的优势，AI都给他们日常的攻击与盗取活动提供了巨大帮助。

好比，在过去，钓鱼内容经常会出现像拼写错误、语法混乱、信息错误等“牛头不对马嘴”一眼假的情况，如今在成熟AI技术的加持下，无论是钓鱼邮件的语言风格，还是钓鱼网站的内容搭建，都愈加难以分辨李逵李鬼。

AI还能换诈骗头像

尤其在AI加持后的黑客攻击几乎可以做到24小时全天候不间断，且能对超大量的不同目标同时发动攻击，无论是规模还是频次，都是人力黑客时代难以企及的程度。

所以根据业内估计，朝鲜黑客光在2026年前三个月就攻击了约2,726台设备，并从中窃取了涉及约26,584个加密货币钱包的数据，相关钱包资产总额高达1,200万美元。

最讽刺的是，朝鲜黑客使用的AI工具，几乎全是美国公司的AI大模型。

那么往远了说，即使不干黑客，这AI给普通人编程的提升都不是一点半点，传统的老编程手艺，现在都快成为非物质文化遗产了，大家都在说什么Vibe Coding，现在日本一众AV女优也在开始转码上岸了。

最具有代表性的是日本前AV女优Noa（曾用艺名「菜月ひかる」「花吹詩音」，别问我怎么知道）。

2026年8月初，她在X上发帖宣布退圈，开启了自己的程序员之路,国内媒体戏称为「AV转码」。

她没有科班背景，主要靠AI来做编程，如今以程序员的身份接单，用Claude做自动化和网页制作。

连女优都在转码了，难怪不少人开玩笑，在这个AI黑客横行的时代，是不是只有爱用软盘的日本能扛住了？

某种程度上会，但也只会把黑客弄无语......

因为最近，黑客遇到日本企业都很无奈，软银旗下云平台IDCF被黑客部署勒索软件，运维竟然超过7小时都没发现勒索信，还在尝试不停地戳电源重启——这都还是软银旗下啊......

最后黑客迫于无奈只能拿下IDCF官网并挂上勒索信，从勒索信里可以看到黑客非常生气。

黑客表示，这傻乎公司，在7小时内不停地尝试重启、修改密码、批量关闭客户提交的问题工单(还要求提交满意度评价)、要是不公布事件，搞得自己当黑客的反倒像个傻子。

正解

不怪网友建议：“黑客发传真估计就马上收到咯~”。

包括去年攻击朝日啤酒等企业的黑客集团Qilin，核心成员被捕后，团队居然还主动接受日本媒体采访。

然后直接来了一句：“日本拥有世界上最差的计算机安全体系之一”。

日本は世界最悪

Forescout的研究显示，2026年初针对日本机构的勒索软件攻击同比增长39%，高于全球25%的增幅。

所以啊，该遭全得遭，没一个能跑。

03：失控双刃剑

往更本质看，黑客攻击也是一笔成本经济账，AI Agent正在改变的是网络攻击的成本结构。

过去，执行复杂攻击任务通常需要攻击者具备相应的技术能力，并投入大量时间完成不同环节的工作。现在，攻击者可以借助大模型生成脚本、分析信息、辅助排查问题，再通过自动化工具将部分任务串联起来。

韩国银行界已经先行服了

这并不意味着AI可以凭空攻破任何系统，也不意味着使用AI就能绕过所有安全防护。

但它确实可能让具备一定基础的攻击者，以更低的成本尝试更多目标。

然而，AI并没有消除传统网络安全问题，门槛低了，影响却扩大了。

服务器权限配置、敏感文件保护、凭证管理、日志安全以及设施隔离，这些看似基础的工作，在AI时代依然重要。

甚至可以说，当一个人开始利用AI自动化更多任务时，如果没有同步建立可靠的安全管理机制，自动化也可能把原本局限于单个操作的错误放大。

包括在本次的韩国攻击事件中，攻击者暴露的会话记录和配置文件，就让研究人员得以更深入地了解其使用的工具、操作方式和可能的目标。

双刃剑性质那是愈加明显。

据路透社10月9日报道，本次被攻击者使用的ARTEX的开发者随后决定将该工具转为闭源，并表示不再提供后续版本和支持，该变化也反映出AI安全工具面临的现实困境。

黑客遗留的ARTEX配置文件与Claude记忆文件

当然，关闭开源并不意味着类似攻击会立即消失，也不能单凭这一决定判断未来的安全风险会如何变化。

但至少，这起事件再次说明，AI工具的能力越强，对使用边界、权限控制和安全审计的要求就越高。

AI可以帮人降低执行复杂任务的门槛，却不能替人承担所有安全责任。

AI创投日报频道: 前沿科技

酷玩实验室coollabs

关注中国科技发展与产业升级

认证作者

已在虎嗅发表 307 篇文章

本内容来源于网络 原文链接，观点仅代表作者本人，不代表虎嗅立场。

如涉及版权问题请联系 hezuo@huxiu.com，我们将及时核实并处理。

正在改变与想要改变世界的人，都在 虎嗅APP

Date: October 17, 2026 Source: NASA Summary: NASA’s Nancy Grace Roman Space Telescope has exceeded expectations after engineers made incredibly tiny adjustments to sharpen its view of the universe. By moving a mirror just one-sixteenth the width of a human hair, the team helped bring its powerful instruments into near-perfect alignment. Roman’s Wide Field Instrument now produces image quality nearly 30% better than predicted, promising exceptionally sharp cosmic surveys. Share:

FULL STORY

NASA's Nancy Grace Roman Space Telescope is performing even better than scientists anticipated after engineers completed an extensive series of tests and precision adjustments. The work has brought the observatory's powerful instruments into exceptionally sharp focus, with its main camera system now delivering image quality nearly 30% better than predicted.

The achievement marks an important step toward the telescope's ambitious mission to investigate dark matter, dark energy, and other mysteries of the universe. Even the smallest improvements in optical precision could help Roman capture clearer images during its sweeping surveys of the cosmos.

"All of Roman's sweeping surveys will rely on the Wide Field Instrument," said Dave Hickey, a Wide Field Instrument systems engineer at NASA's Goddard Space Flight Center in Greenbelt, Maryland. "Many of the mission's primary goals, like studying dark matter and dark energy, wouldn't be possible without it, so it's both exciting and a huge relief to see that it's working well!"

NASA Puts Roman's Powerful Camera System to the Test

Following the activation of the Wide Field Instrument in September, engineers began a comprehensive testing campaign to confirm that each component worked properly on its own and as part of the complete system.

Their first priority was examining the instrument's 18 detectors, each roughly the size of a sticky note, along with the electronics that operate them. The team then evaluated the element wheel, a rotating mechanism equipped with filters and other optical components. These allow selected wavelengths of light to reach the detectors and can separate incoming light into its individual colors.

Next came the instrument's internal calibration system. Engineers activated its light-emitting diodes, or LEDs, which function as adjustable light sources that can produce different colors and brightness levels under commands from Earth. By measuring how the detectors respond to these controlled signals, scientists can identify differences in sensitivity and make the corrections needed for accurate observations.

Engineers also tested the instrument's alignment mechanism and moved it from the deliberately unfocused position used during launch to the position expected to provide the sharpest images. They finished by checking the thermal control system, which maintains the temperatures required for the instrument's various components to function correctly.

"Calibrating an instrument is like tuning a piano or guitar before a concert," said Maxime Rizzo, a Wide Field Instrument systems engineer at NASA Goddard. "You adjust everything until it's just how you want it and then leave the settings alone so it performs consistently while you use it."

A Space Telescope Already Close to Perfect Alignment

While one group concentrated on preparing the Wide Field Instrument, another worked to refine the telescope's overall optical alignment.

The results were encouraging from the beginning. Roman's mirrors and other optical components were already positioned with remarkable accuracy, meaning engineers needed to make only minor corrections.

"The telescope's performance was excellent even before we began adjusting the alignment of all the mirrors and other optics, thanks to exceptional preparatory work done on the ground prior to launch," said Matthew Bolcar, Roman's optical systems lead at NASA Goddard. "All of the testing and modeling work done at Goddard and by contractors at L3Harris and BAE Space and Mission Systems left only small corrections for us to make to bring everything into near-perfect alignment."

Achieving that level of precision is especially challenging for a spacecraft. The forces experienced during launch can cause tiny shifts in sensitive equipment, and conditions in orbit differ significantly from those on Earth. Roman launched on August 30, carrying optical systems that had been meticulously tested before leaving the ground.

"Our ground testing couldn't exactly reproduce the environment Roman would experience in space, such as the absence of gravity," Bolcar said. "And there are also slight differences in temperature variations and moisture content. Despite those challenges, the recent assessments showed that our ground testing was excellent, with both instruments either matching or exceeding the performance we had predicted."

A Mirror Adjustment Smaller Than a Human Hair

Roman relies on an intricate arrangement of mirrors and optical components to collect light from distant cosmic objects and direct it toward its two scientific instruments. For the resulting images to remain sharp, the light must follow an extremely precise path.

Even a microscopic misalignment can affect how accurately the telescope brings light into focus.

Fortunately, Roman's optical system was already so well aligned that only incredibly small movements were necessary to improve its performance.

"We moved the secondary mirror by about one-sixteenth of the diameter of a human hair," said Alden Jurling, a senior optical engineer working on Roman at NASA Goddard. "This adjustment nudged the height of the secondary mirror above the primary. If we scale that height up to the height of the Empire State Building, the change in height is a little bit less than you would get by stacking a single U.S. penny on top of the tip of the tower."

Although nearly impossible to appreciate at a human scale, such a small adjustment can make an important difference when a telescope is designed to study objects across vast cosmic distances.

The team initially concentrated on Roman's Coronagraph Instrument, which had been producing images that were slightly out of focus. The problem was less severe than engineers had anticipated, making it relatively straightforward to correct.

The coronagraph now meets the team's demanding performance expectations. Engineers will continue refining its camera settings and determining the optimal configurations for its deformable mirrors, which can change shape to make extremely precise corrections to incoming light.

In the coming weeks, the team plans to test the coronagraph's ability to block unwanted light, an essential capability for observing faint objects near much brighter ones.

Once the coronagraph's focus had been optimized, engineers returned to the Wide Field Instrument for another round of adjustments.

Roman's Image Quality Exceeds Expectations by Nearly 30%

The final measurements revealed an especially impressive result. Roman's Wide Field Instrument achieved optical performance nearly 30% better than the team had predicted.

Before launch, engineers established an image quality requirement of approximately 90 nanometers RMS (Root Mean Square). This measurement describes the amount of optical error in the system, or how far the incoming light deviates from an ideal, perfectly focused wavefront.

To put that scale into perspective, 90 nanometers is roughly 1,000 times thinner than a human hair. At these tiny dimensions, even seemingly insignificant imperfections can influence the sharpness of astronomical images.

After the latest corrections, however, engineers measured an optical error of just 63 nanometers RMS, substantially better than the original requirement.

That improvement means Roman should be capable of producing even sharper images than its designers initially expected, strengthening its ability to carry out detailed observations across enormous regions of the sky.

"All of the images from Roman's cosmic surveys will be even sharper than we expected," Jurling said. "It's a great outcome from years of careful modeling, precision metrology, and testing."

With both scientific instruments meeting or surpassing their expected performance, Roman has cleared another important milestone in its preparation for routine observations. The results highlight the extraordinary precision of the telescope's design and offer a promising outlook for its upcoming investigations into the hidden structure and evolution of the universe.

Story Source:

Materials provided by NASA. Note: Content may be edited for style and length.

Cite This Page:

NASA. "NASA’s Roman Space Telescope exceeds expectations by nearly 30%." ScienceDaily. ScienceDaily, 17 October 2026. <www.sciencedaily.com/releases/2026/10/261016070630.htm>.

NASA. (2026, October 17). NASA’s Roman Space Telescope exceeds expectations by nearly 30%. ScienceDaily. Retrieved October 17, 2026 from www.sciencedaily.com/releases/2026/10/261016070630.htm

NASA. "NASA’s Roman Space Telescope exceeds expectations by nearly 30%." ScienceDaily. www.sciencedaily.com/releases/2026/10/261016070630.htm (accessed October 17, 2026).

Explore More

from ScienceDaily

RELATED STORIES

Describe a behavior in plain language, and a fast decision model reads traces and returns the ones where it happened.

LangSmith uses trajectories to normalize traces, reduce context bloat, and deliver query results fast.

Agent traces are large, multimodal, and information-dense. They capture key details such as user inputs, how agents respond, and logic failures. That makes traces uniquely valuable for understanding user behavior and improving agent performance, but traditional data platforms weren’t built for large, unstructured payloads like this.

To make trace data useful, teams need infrastructure that can support the full lifecycle: ingest and store high-volume runs, query traces flexibly, and turn them into views for debugging, product analysis, and operational workflows like annotations. That’s why we built SmithDB, the database purpose-built for trace data in LangSmith, and more recently Custom Apps, which let teams create tailored views on top of their traces.

Today, we’re adding AI Search, a new way to query traces using natural language.

Why we built AI Search

Each trace contains user inputs, agent reasoning, tool calls, and responses, all the information required to understand where agents are performing well and where they fail. Teams using LangSmith often mine their agent traces to discover examples for an eval dataset or conversations for a reviewer in an annotation queue.

However, discovering the right traces can be cumbersome. Questions like "did PII leak?" or "did the user get frustrated?" don't map cleanly to a single trace attribute like tags or metadata, and cannot be answered by full-text search either. They require an understanding of the trace contents. Until now, that meant setting up an evaluator ahead of time or going through traces manually.

That's why we built AI Search. You describe the behavior you're looking for, and LangSmith returns the traces where it happened. This enables you to find needle-in-haystack traces and search for troublesome patterns ad hoc.

What you can search for

You can search for anything that shows up in the content of a trace. You might look for an agent that said it finished a task but didn't, a user who seemed frustrated or pushed back on an answer, a request to a model that leaked PII, or someone trying to cancel their subscription. Product teams can search for "requests for integrations we don't support", "competitor mentioned", or "users confused about onboarding" and see where the product falls short, in users' own words.

AI Search also works alongside the filters you already use, so a search can run only on traces that errored, or only with a specific tag.

How we built it

Why a model reads every trace

Vector search is the usual way to search by meaning instead of exact words. It turns your query and each trace into an embedding, a short list of numbers that captures what the text is about. Then it returns the traces whose embeddings are closest to your query's. That works well for topic search, like finding conversations about billing. But an embedding packs a whole trace into one small vector, and that compression is lossy. Important details related to your query can get lost. A trace where the agent did the work successfully and one where it only said it did can end up with nearly the same embedding. Telling them apart takes a model that reads the actual words of the trace along with your question, so it can reason about what happened.

Until recently, doing that at search time was too slow and too expensive. Fast decision models changed that. They answer one narrow question about an input quickly and cheaply enough to run at scale. AI Search pairs decision model inference with SmithDB, our data layer for agent observability. As traces arrive, SmithDB turns them into trajectories. When you run a search, your filters narrow the candidates, and the decision model checks each remaining trajectory against your description.

Traces are large and come in many formats

Traces come from many sources: the OpenAI and Anthropic SDKs, LangChain, LangGraph, the Vercel AI SDK, OpenTelemetry, and more. Each records messages a little differently. Traces also repeat themselves. Agents often re-send the conversation history with every LLM call, so the first message shows up again in every call after it.

SmithDB turns these traces into a trajectory for each session. A trajectory is a distilled view of the agent's work: each message, tool call, and tool result, listed once. SmithDB builds it as traces arrive and puts every supported format into the same shape.

AI Search analyzes trajectories instead of raw traces. Because every format has the same trajectory shape, one search works across agents built on different SDKs. Removing the repeat messages reduces context bloat, so searches run faster. A trajectory also covers the whole session, so if you search for "the user tried to cancel", the model sees what the user asked, what the agent did, and how the conversation ended.

Trajectories are still long

Removing duplicates helps, but agent trajectories are still long. To get a sense of how long, we sampled 150 random conversations from Open SWE, the open source coding agent the LangChain team uses every day. Each task runs in its own sandbox with shell access and can hand work off to subagents, so the conversations get big.

A couple of them ran past a million tokens, even in a sample this small. Searching for a rare behavior means reading through a lot of conversations, so AI Search regularly runs into ones that size and can't read every token.

Most questions don't need all of those tokens, though. Many questions are about what the user asked and how the agent replied. In the median conversation, about 2K of its 72K tokens came from the user's messages and the agent's replies. About 85% was tool output, mostly file reads and shell commands.

💡 Even when a trace runs past a million tokens, many questions about agent behavior can be answered with a few thousand.

‍

Each trajectory gets a fixed token budget, filled in priority order. User messages and the agent's replies to the user go in first. The rest of the budget goes to everything else: intermediate AI messages (the agent's reasoning and tool calls), tool results, and system messages. If the next message only partly fits, it's trimmed to fill the budget, and anything after it is dropped.

Searches have to stay fast at scale

SmithDB is built to ingest and scan large volumes of agent trace data. When you run a search, your structured filters narrow the candidates first. The decision model then checks each remaining trajectory against your description, many in parallel. While the model checks one batch of trajectories, SmithDB is already fetching and preparing the next batch. Matches are streamed back as they're found, so you don't wait for the full scan.

What's next

We're still learning which questions people ask most. The hardest conversations to classify are the ones with subtle differences. Telling "the user gave up" apart from "the user got what they needed and left" can come down to a couple of turns in a long trajectory. We want to see whether a model tuned on traces tells them apart more reliably.

The token budget works well when the answer is found in what the user and agent said. Other questions need different evidence. An agent ignoring a tool error only shows up in the tool results. We're exploring ways to pick context based on the question, and signals that show when the model is unsure, so it can take a second pass with more context.

We'd also like to go past a plain list of matches by grouping similar results or summarizing what they have in common.

AI Search is in public beta on LangSmith Cloud in the GCP US, EU, and APAC regions, at no additional cost. Org admins can turn it on in settings, and it then shows up on the tracing page. The AI Search docs have the details. Let us know what you search for.

‍

See what your agent is really doing

LangSmith, our agent engineering platform, helps developers debug every agent decision, eval changes, and deploy in one click.

Try LangSmith

Get a demo

Also, because I talk about AI a lot on this blog, people assume I use AI to write. This is not true! Everything below is 100% human authored, with me writing the post with basically only the slides I presented as a reference (this is not a transcription). As much as I enjoy using AI to write code and tools, I get a similar enjoyment out of writing “the old way”, especially as I have no reason to try and make any part of this process more efficient.

So with that all out of the way, I present to you my first ever blogification of a talk I gave. Enjoy!

Introduction

[I give a small introduction to myself and my own work, that I’m omitting here, as you’re on my website]

I want to talk about using LLMs in game development. Not one-shot type demos that look cool on Twitter, but like real development. Where you’re working eight hours a day, 5 days a week, etc.

And before I get into it, I think it’s useful to level set about LLMs. Or at least get into some basics so the rest of what I talk about here makes sense. I recognize that for a lot of this people this will be review, so if you just want to get into the dev-loop stuff, scroll down to the next section.

My journey into using LLMs for dev work started with a moodboarding site I made called mood.site. This was pre “agentic” anything, but I wanted to test and see if ChatGPT at the time could actually code anything. The process was a lot of me just blindly copy/pasting code into ChatGPT’s web interface. The process sucked, but I was surprised at the results. I built the site! It worked! I still needed to verify a fair amount of stuff myself, but it was enough to convert me. If I didn’t have access to an LLM I wouldn’t have been able to make that site happen in near the amount of time it ended up taking me (~2-3 weeks of nights, probably like 20 hours total). I’d probably still be working on building the first version today.

Since then, mood has become something of a testbed for me moving through LLM stuff (and a mildly successful project on its own!), and has inspired me to kick up lots of other projects that use similar stacks. Additionally, LLMs have gotten better, especially with things like Claude Code and later Claude models. From my own experience, I feel like now there is very little, if anything, I think an LLM can’t do when it comes to a web-based stack.

It could be easy to then say LLMs can do everything, as so much of software is web software. But whenever I tried to use an LLM on building a non-web game thing, it was this resounding takeaway:

“LLMs are Bad At Games”

Any time I tried to use an LLM for a game-y thing, it would fall over. Maybe this is my own bias. I’ve been a game programmer for nearly 15 years, I think I know how things work. I can sniff out “bad” game code a mile away. But when it comes to Svelte web-apps, I’m decidedly less well versed and am inclined to think that whatever code the LLM produces is “good”. Maybe it’s actually garbage. But there is reason to believe the Svelte and web-stack stuff is quality, in part due to the fact that there are LOTS of high quality web projects with their source available online. Comparatively for games, I imagine there are orders of magnitude less data to train on.

Not only this, but games have a lot of stuff in them that isn’t code. Games aren’t just about putting static images and text in a layout. There are tons of things in games that aren’t easily representable by code. AND then on top of that there is all the same text layout stuff of web, but only as a subset of the 100 other systems a game needs to handle.

This is part of the reason why a lot of people have been making games in Three.js — they can easily represent assets as plain boxy primitives and skip a lot of the asset generation/conforming work and processing normally required for games. As a result, a lot of that stuff is slop because it lacks any real authorial voice outside of whatever the LLM median is.

However, maybe they have a point.

A key idea of the one-shot Three.JS workflow (as well as LLMs proficiency at building web apps) is that everything is code. By having stuff as code, it’s very easy for an LLM to be able to reason about it, make changes, etc.

However for traditional games, this is not the case. Or at least the full story. Games obviously have code, but there is a lot of other stuff that is not code. This means that there are key components of games that are effectively opaque to an LLM. If your game then relies on the effective puppeting and transforming of that opaque stuff, then an LLM is going to fall over when trying to work on your game.

I think a lot of the gamedev community maybe gave LLMs a go a bit ago and ran directly into this. The “LLMs are bad/not useful/etc.” sentiment (massive caveat here, just talking about capability specifically and not potential society-ending implications) came from running headfirst into these limitations.

This is to say that, structurally, LLMs are bad at reading games. At least in their default state.

LLM Basics

Let’s talk more about why, and what we can do about it.

Any call/prompt to any LLM service breaks down into three basic components. A system prompt, an assistant prompt, and a user prompt:

System prompt: Generic text shared across all users of a service. This usually describes the basics of the LLM itself, with something like “You are Opus 5, an intelligent Large Language Model created by Anthropic…”. This isn’t to say these aren’t important (they are), but more that they aren’t super-relevant to our use case. You can see some examples of posted (and exfiltrated) system prompts for models here.

Assistant prompt: This is kind of a sidecar prompt section meant to help guide the AI in terms of what it is responding to. You can think of it basically as the model’s basic “interaction” vector with your prompt, and represents something like the model’s “response” to the user based on some input. You usually do not have to think about this.

User Prompt: This is really The Thing. Most any input you put into any AI tool goes here. Any submitted chat, code, etc. gets dumped into this section. When people talk about “context”, they are largely talking about “how many tokens are stored in the user (and assistant) portion of a prompt”.

It may be easy to think that each chat is a “fresh” version of the above, but what actually happens is that, as you work with a model in a given session (the bounds of “session” vary based on what service you are using — this can be a single Claude Code session before closing it, a “chat” accessible in the side panel of a web hosted model, etc.), every prior message you sent to the model is re-submitted every time you send a message. It’s kind of like playing the old playground game where, on your turn, you have to say everyone else’s thing again before then adding your own thing for the next person to have to add on.

Context and Context Pollution

As you do this over and over, you build up the “context” of the session you’re working in.

This is all well and good, but a key thing to notice here is that you only really are able to address the “latest” thing in your context (i.e., you submit a new message). Things from previous messages get submitted over and over again to the model. Hence, you want to make sure what’s in your context is “good”, otherwise you can find yourself in degenerate scenarios where your context becomes polluted due to “bad” things earlier continually informing new work.

Managing context then is a key thing in working with LLMs, and a new engineering practice called “context engineering” has emerged in light of these constraints. Context engineering asks “how can we get the best information into the context, with as little pollution as possible”.

There is a great blog post here on “ways long contexts fail” that goes a bit more into this, but I’ll highlight the key part here:

Context Engineering itself is a really big topic that is outside the scope of this talk/blog, but we will be using some of the tenets of it here to explore how to help LLMs do a better job working with games.

Said differently, getting LLMs to work well with games is a context problem, not something that is intrinsically linked to how games or LLMs “are” (or “aren’t”!).

The complicating factor here though is, games are weird. Or at least: we have no real template to build a game. We have game engines, but there is effectively 0 standardized tooling for anything, in part because every game manifests its own needs differently from one another.

This is acutely unique to games (imo), but it manifests enough in other technological domains that a new concept has emerged in order to get agents to effectively “work” with whatever your work product is: Harnesses.

Some Description of the Idea of a Harness

The general idea of a Harness is that it’s some set patterns of actions an agent is meant to take in response to some well (or loosely) defined expected input. You’re probably already using a harness like Claude Code, but these can be augmented, extended, distilled, abstracted, etc. to better support the specific work you are trying to do. There’s also been a LOT of action in this space recently, with many harnesses being built for developing all sorts of things:

The key things these are all pointing to is: “how can I better understand what I’m building, and guide that process as it is developed”. Harnesses can tie in things like iterating with a browser, telemetry, profiling, and even full SDLC work like making tickets, documents, etc.

However, the thing none of these do well is actually talk to your game. Your game is a bit of a black box, and most of what’s visible to an LLM is only the code-as-written, which as we talked about before, isn’t really enough. We know LLMs are already good at working with code, so it’s not like some harness itself solves that “games aren’t just code” issue we ran into in the first place.

What really needs to happen here is that we can take all the stuff in games, and try to turn it into something the LLM is able to work with. We need to crack open the black box of your game and make more of it addressable directly by an LLM.

During the talk version of this I had this Very Funny Slide that said that the arrow here was the actual content of this talk. The joke hits nowhere near as hard in blog form but I’m leaving it here for posterity:

So let’s talk about what we can do.

Let’s Make a Game Legible To AI Agents

Here’s some very tangible, actionable things you can do for your game to make it more legible and workable by an LLM.

As a brief aside before getting started, it’s also worth noting here that a lot of these tips are good for game development in general. They get supercharged a bit with AI, but doing any of this will likely make working on your own games generally just better.

Fixed Randomness

A running theme through this whole talk/post is the concept of determinism. Basically, how accurately can you reproduce a very specific state in your game. The general goal is that it should be very easy, and very exact. Doing this at the very end of your production will be VERY hard to do, and would likely require fundamental changes to your game in the 11th hour.

Instead, if you assume this constraint before you write your first line of code, and stick to it as a goal, you’ll be paving the path to a much more productive end game and not find yourself fighting off entropy and spaghetti code.

Starting off here is pretty easy. At the start of your game, create a single source of seeded randomness. Make sure any call to anything non-determinis

1. Biết repo nặng vì đâu trước khi tối ưu

Repo chậm thường vì một trong ba lý do sau, hoặc cả ba:

Nhiều blob lớn trong history: ai đó từng commit file .zip, model ML, dump SQL rồi xóa đi, nhưng các blob đó vẫn còn trong history.

Nhiều file trong working tree: hàng trăm nghìn file khiến git status phải stat() từng file một.

History dài: hàng triệu commit làm git log, git blame và merge-base chậm đi.

Để biết repo của mình thuộc loại nào, mình hay dùng script Python sau để liệt kê các blob lớn nhất trong toàn bộ history:

``` #!/usr/bin/env python3 # find_big_blobs.py - liệt kê top N blob lớn nhất trong history import subprocess import sys

TOP_N = int(sys.argv[1]) if len(sys.argv) > 1 else 20

rev_list = subprocess.Popen( ["git", "rev-list", "--objects", "--all"], stdout=subprocess.PIPE, ) cat_file = subprocess.run( ["git", "cat-file", "--batch-check=%(objecttype) %(objectname) %(objectsize) %(rest)"], stdin=rev_list.stdout, capture_output=True, text=True, )

blobs = [] for line in cat_file.stdout.splitlines(): parts = line.split(" ", 3) if parts[0] == "blob": path = parts[3] if len(parts) > 3 else "(unknown)" blobs.append((int(parts[2]), parts[1][:10], path))

blobs.sort(reverse=True) total = sum(b[0] for b in blobs) print(f"Tổng {len(blobs)} blob, {total / 1024**3:.2f} GB (chưa nén)") for size, sha, path in blobs[:TOP_N]: print(f"{size / 1024**2:8.1f} MB {sha} {path}") ```

Chạy python3 find_big_blobs.py 30 ở repo của mình thì thấy khoảng 70% dung lượng nằm ở các file .onnx và .parquet có từ 3 năm trước. Lúc đó có hai lựa chọn. Một là rewrite history bằng git filter-repo, nhưng cách này đau vì mọi người phải clone lại và mọi SHA đều đổi. Hai là giữ nguyên history và để client không tải blob mình không cần. Trên repo dùng chung, mình gần như luôn chọn cách thứ hai.

2. Partial clone: chỉ tải blob khi thật sự cần

Partial clone ổn định từ khoảng Git 2.22 trở đi, và GitHub, GitLab, Bitbucket đều đã hỗ trợ. Có hai filter hay dùng:

``` # Blobless clone: tải toàn bộ commit + tree, blob thì tải lazy git clone --filter=blob:none git@github.com:company/monorepo.git

# Treeless clone: chỉ tải commit, tree và blob đều lazy (hợp cho CI build 1 lần) git clone --filter=tree:0 git@github.com:company/monorepo.git

# Kiểm tra repo hiện tại có phải partial clone không git config --get remote.origin.promisor # true git config --get remote.origin.partialclonefilter # blob:none ```

Với repo 18GB của mình, blobless clone còn khoảng 1.9GB và mất chưa tới 3 phút. Cơ chế hoạt động như sau:

``` sequenceDiagram participant Dev as Developer participant Local as Local repo participant Remote as Remote (promisor) Dev->>Local: git clone --filter=blob:none Remote-->>Local: commits + trees (không có blob) Dev->>Local: git checkout main Local->>Remote: fetch các blob của HEAD Remote-->>Local: blobs cần thiết Dev->>Local: git log -p old_file.py Local->>Remote: fetch lazy blob của commit cũ Remote-->>Local: blob cũ ```

Cần lưu ý là partial clone đổi dung lượng lấy network. Các lệnh phải đọc nội dung file cũ như git blame hay git log -p trên một file có history dài sẽ phải kéo blob về, nên lần đầu chạy sẽ chậm và cần có mạng. Với developer thì blob:none là lựa chọn hợp lý. Mình không khuyên dùng tree:0 cho máy dev, vì khi đó gần như lệnh nào cũng phải fetch thêm.

3. Sparse-checkout: chỉ checkout phần mình làm

Partial clone giải quyết chuyện dung lượng. Sparse-checkout giải quyết chuyện working tree có quá nhiều file. Nên dùng cone mode (mặc định từ Git 2.27+), vì nó match theo thư mục và nhanh hơn nhiều so với pattern kiểu .gitignore:

``` # Clone kết hợp cả hai: blobless + sparse git clone --filter=blob:none --sparse git@github.com:company/monorepo.git cd monorepo

# Lúc này chỉ có file ở root. Thêm các thư mục cần làm: git sparse-checkout set services/payment libs/common tools/ci

# Thêm thư mục mà không ghi đè danh sách cũ git sparse-checkout add services/notification

# Xem đang checkout những gì git sparse-checkout list

# Muốn quay lại full checkout git sparse-checkout disable ```

Kết hợp hai kỹ thuật này thì blob của các thư mục nằm ngoài sparse set sẽ không bao giờ bị tải về. Ở team mình, mỗi service có một file .sparse-profile liệt kê dependency, kèm một target make sparse SERVICE=payment để set cho đúng. Người mới vào chỉ cần clone vài trăm MB thay vì 18GB.

Vẫn còn vài vấn đề cần biết. IDE như IntelliJ hay VS Code có thể báo thiếu import nếu code tham chiếu tới thư mục ngoài sparse set. Build tool như Bazel, Nx hay Turborepo cũng cần biết dependency graph để không đi tìm file không tồn tại. Vì vậy hãy sinh sparse set từ dependency graph của build tool, đừng viết tay.

4. Scalar và các config nên bật

Từ Git 2.38, scalar được tích hợp sẵn trong Git. Thực chất nó là một wrapper bật sẵn các config tốt cho repo lớn:

``` # Clone mới theo cách của Scalar: blobless + sparse + maintenance scalar clone git@github.com:company/monorepo.git # Lưu ý: code nằm trong monorepo/src/

# Hoặc áp dụng cho repo đã clone sẵn cd ~/work/monorepo scalar register

# Nếu không muốn dùng scalar, bật tay các config quan trọng: git config core.fsmonitor true # built-in fsmonitor (macOS/Windows, Git 2.37+) git config core.untrackedCache true git config feature.manyFiles true # index v4 + untracked cache git config fetch.writeCommitGraph true git commit-graph write --reachable --changed-paths git maintenance start # chạy prefetch, gc, commit-graph nền ```

Trên MacBook M3 của mình, git status giảm từ 6.2 giây xuống còn khoảng 0.3 giây chủ yếu nhờ core.fsmonitor. Git chạy một daemon theo dõi file system event, nhờ vậy không phải quét lại cả cây thư mục mỗi lần. Còn --changed-paths tạo Bloom filter trong commit-graph, giúp git log -- path/to/file nhanh lên rõ rệt.

Dưới đây là cách mình chọn chiến lược theo từng tình huống:

``` flowchart TD A[Cần clone repo lớn] --> B{Dùng cho việc gì?} B -->|CI build 1 lần| C[--depth=1 hoặc --filter=tree:0] B -->|Developer hằng ngày| D{Làm toàn repo?} D -->|Có| E[--filter=blob:none + fsmonitor] D -->|Chỉ vài service| F[scalar clone + sparse-checkout set] B -->|Cần blame/history sâu| G[Full clone + commit-graph] ```

Với CI, shallow clone --depth=1 vẫn là cách nhanh nhất cho job chỉ build và test. Nếu job cần tính diff với main, ví dụ để chỉ test các package bị ảnh hưởng, thì dùng --filter=blob:none với fetch-depth: 0 sẽ hợp lý hơn shallow, vì shallow clone hay làm hỏng git merge-base.

Kết luận

Trước khi nghĩ tới chuyện tách repo hay đổi VCS, hãy dùng hết những gì Git đã có sẵn:

Đo trước: chạy script tìm blob lớn và time git status để biết repo chậm vì dung lượng, số file hay history.

Developer dùng --filter=blob:none: dung lượng giảm 5 đến 10 lần mà gần như không mất gì.

Monorepo nhiều team thì thêm sparse-checkout cone mode, và sinh sparse set từ dependency graph của build tool.

Bật core.fsmonitor, feature.manyFiles và git maintenance start, hoặc chạy scalar register cho nhanh. Đây là thay đổi tốn ít công nhất mà hiệu quả nhiều nhất.

Với CI, chọn giữa shallow và treeless tùy job có cần history hay không, đừng dùng full clone theo mặc định.

Chặn blob lớn ngay từ đầu bằng pre-commit hook giới hạn kích thước file, và đưa artifact như model hay dataset ra object storage hoặc Git LFS.

Repo lớn không có gì sai. Vấn đề là dùng công cụ cho repo 50MB để làm việc với repo 50GB. Chỉ cần cấu hình đúng vài lệnh là đủ để team bớt mất thời gian chờ clone mỗi sáng.

The quest for GLP-1 drugs that can treat brain disorders is getting a fresh infusion of energy and funding. Pharmaceutical companies have plunged into developing GLP-1-related compounds to treat addiction, schizophrenia, depression and other conditions — building on years of work by academic scientists.

Last month, pharma giant Eli Lilly presented the first clinical results of brenipatide, a compound related to the company’s blockbuster obesity drug tirzepatide, for treatment of alcohol use disorder. Last week, biotechnology firm Kariya Pharmaceuticals shared early clinical results of a similar compound called KP405 for Parkinson’s disease. And biotechnology company Baseline Therapeutics plans to start a clinical trial in early 2027 of a GLP-1 compound for alcohol use disorder.

Why do obesity drugs seem to treat so many other ailments?

Researchers have long been interested in GLP-1 drugs’ potential against brain conditions. But, until recently, the pharmaceutical industry has not shared that interest, says Lorenzo Leggio, an addiction scientist at the National Institutes of Health in Baltimore, Maryland.

The companies’ new focus on these therapies could accelerate access for people who could benefit from them, says Christian Hendershot, an addiction scientist at the University of Southern California in Los Angeles.

“With the industry trials coming online, we’ll see this area of work grow even more quickly in the next couple of years,” Hendershot says. “Hopefully that will lead to one or more FDA approvals for GLP-1 therapies for addiction.”

Treating the brain

Some of the blockbuster obesity drugs, such as semaglutide, mimic the gut hormone glucagon-like peptide-1 (GLP-1). Others, such as tirzepatide, mimic both GLP-1 and the gut hormone gastric inhibitory polypeptide (GIP). Both hormones are involved in regulating blood-sugar levels, among other functions.

People taking GLP-1 receptor agonists commonly report a lack of interest in drinking alcohol and smoking, an unexpected effect that piqued the interest of addiction researchers. In 2025, Hendershot published the results1 of the first clinical trial of semaglutide in people with alcohol use disorder. The study found that semaglutide reduced the craving for alcohol and episodes of heavy drinking over time. It also lowered the amount of alcohol that participants consumed in a laboratory test.

Since then, two other clinical studies led by academics have found similar results2,3. The studies so far consistently show benefits that seem to be greater than those of the drugs that are currently approved for alcohol use disorder, says Hendershot.

Long half-life

Such results have encouraged pharmaceutical companies to pursue variations of GLP-1 drugs for substance-abuse disorders. One example is brenipatide, the GLP-1 and GIP mimic that Eli Lilly in Indianapolis, Indiana, has been testing for the treatment of alcohol use disorder. The drug remains active in the human body for longer than do approved GLP-1 drugs. According to data presented last month at the Psych Congress in New Orleans, Louisiana, its half-life is 9–12 days, as opposed to 5–7 days for other approved GLP-1 medications. The longer duration makes the drug especially suitable for people living with substance use disorders or psychiatric conditions, says Robert Nicholson, who leads medical affairs for psychiatry and substance use disorders at Eli Lilly.

Could the gut give rise to alcohol addiction?

But, other than the longer half-life, it’s not clear that there are major differences between this compound and the drugs now on the market, says Randy Seeley, an obesity specialist at the University of Michigan in Ann Arbor.

Beyond alcohol use disorder, brenipatide is in clinical trials for a wide range of brain-related conditions, including tobacco and opioid use disorder, depression, schizophrenia and bipolar disorder.

Another GLP-1 mimic aimed at alcohol use disorder is BT-001, which is being developed by Baseline Therapeutics in San Francisco, California. The company plans to start phase III trials of BT-001 in early 2027.

Enjoying our latest content?

Log in or create an account to continue

Access the most recent journalism from Nature's award-winning team

Explore the latest features & opinion covering groundbreaking research

Access through your institution

or

Sign in or create an account

Continue with Google

Continue with ORCiD

doi: https://doi.org/10.1038/d41586-026-03252-3

References

Hendershot, C. S. et al. JAMA Psych. 82, 395–405 (2025).

Article PubMed Google Scholar

Klausen, M. K. et al. Lancet 407, 1687–1698 (2026).

Article PubMed Google Scholar

Schacht, J. P., Sakai, J. T. Raymond, K. & Shelton, R. Am. J. Psychiatry 183, 636–645 (2026).

Article PubMed Google Scholar

Download references

Reprints and permissions

Related Articles

Subjects

Brain

Medical research

Psychiatric disorders

Latest on:

Brain

Medical research

Psychiatric disorders

Chimp and gorilla brains resist weight loss with age — unlike human brains

Research Highlight 09 OCT 26

Can your brain grow new neurons? How researchers are solving a century-old puzzle

News Feature 07 OCT 26

Brain organoids grafted into cortex-free mice will advance human brain research

News & Views 06 OCT 26

Keep medical doctors in academia — without them, health-care research will suffer

Comment 12 OCT 26

Watch this invisible tattoo appear under UV light

News 09 OCT 26

Women are talking about menopause — health systems must listen

World View 08 OCT 26

Economics Nobel awarded for work on stabilizing economies in crisis

News 12 OCT 26

Landmark map of human brain’s gene activity holds clues to Alzheimer’s disease and more

News 23 SEP 26

Vast cellular gene-expression atlas could transform how scientists understand brain ageing and disease

News & Views 23 SEP 26

Jobs

Open Rank Faculty Position in Science - School of Science and Engineering

The School of Science and Engineering (SSE) at theCUHK-Shenzhen sincerely invites applications for Tenure/Teaching/Research Stream faculty positions

Shenzhen, China

The Chinese University of Hong Kong, Shenzhen - School of Science and Engineering

Open Rank Faculty Position in Engineering - School of Science and Engineering

The School of Science and Engineering (SSE) at theCUHK-Shenzhen sincerely invites applications for Tenure/Teaching/Research Stream faculty positions

Shenzhen, China

The Chinese University of Hong Kong, Shenzhen - School of Science and Engineering

President and Chief Executive Officer, Okinawa Institute of Science and Technology

OIST is undertaking a global search for its next President and CEO and invites applications and nominations for this prestigious role.

The Okinawa Institute of Science and Technology (www.oist.jp)

Okinawa Institute of Science and Technology

Global Leading Talent Recruitment at College of Bio-X, Huazhong Agricultural University

Join HZAU's global faculty team to advance research with competitive benefits.

Wuhan, Hubei (CN)

Huazhong Agricultural University (HZAU)

Division Chief, Reproductive Endocrinology

Lead UC San Diego’s nationally recognized REI program, advancing IVF, fertility research, academic medicine, and faculty development.

San Diego, California

AMN Healthcare

Sign up for the Nature Briefing newsletter — what matters in science, free to your inbox daily.

Get the most important science stories of the day, free in your inbox. Sign up for Nature Briefing

At Anthropic, coding is no longer the bottleneck to building systems or doing research. Claude is able to autonomously iterate on research loops, micro-optimize complex programs, and build new services from the ground up at a speed and scale we haven’t seen before. The bottleneck, now, is all of the developer infrastructure built for human scale: source control, builds, and CI.

In May 2026, Anthropic averaged around 2,500 code changes merged per day; as of September, we merged over 30,000 per day. We don’t expect this rate of growth to slow down anytime soon; the latent demand for merging code is practically infinite, and every bottleneck we remove immediately leads to a further increase in the amount of code we produce.

In order to support this growth, we built Scion, an in-house version control system, and fully migrated our monorepo from git in five months. We also built and shipped a code review surface (called Antique), code search, a rich source control IAM system, novel ways of managing and landing large amounts of reviewed code, and more, all in that same time period. In this post, we’ll focus on how we built Scion specifically. It makes for an interesting case study: Claude’s ability to write code was both what put us in this situation in the first place and how we were able to quickly build a high-quality, scalable system to deal with it.

Growing our monorepo

Before we explore what we built, we should acknowledge how unusual our workload is. Unsurprisingly, Anthropic uses Claude to write software far more than almost any other company, so we’re often the first to see where tools built for human scale start to strain. Source control is just one example of this. While we don’t expect many organizations to have these problems in the very near term, we suspect it won’t be too long before others who use AI coding tools experience these same pressure points, which is why we wanted to share what we built and what we learned.

Git is a decentralized system: every clone is a complete, self-contained repository that can compute diffs, read history and blame, and check out any revision while fully offline. For the vast majority of repositories, this is the right design, and it’s a large part of why git became the standard.

As our monorepo grows, it increasingly doesn’t fit that design space. The history of our main branch alone is almost 100 GB, and a compressed working copy is over 25 GB. We perform on the order of 25 million code checkouts per day for CI, before counting developer environments, agent sandboxes, and research jobs. Fetched naively, that would be over 600 PB of git traffic per day.

Git offers tools for working with a slice of a repository, such as shallow clones, sparse checkouts, and promisor remotes. Beyond these, there are standard workarounds for large monorepos, like internal git mirrors and repository snapshots (seeds) kept in blob storage. We’ve used all of them—at our peak, we operated several hundred internal git mirrors to deal with the load. This bought us time, but they became harder to operate as our merge rate increased. Seeds fell further from the tip of main between refreshes, and it took more and more care to keep operations that depend on history, like diff and blame, working on partial clones.

Taking a step back, we noticed that, like most companies, we were using git as a centralized system with one authoritative copy, but nearly all of our clients were agents and jobs that are online by definition. The properties that make git excellent for distributed, offline work were actively undermining our ability to scale as the repo grew. So we asked ourselves: if we designed source control with the fact that agents are always online in mind from the start, what would it look like?

Principles for agent-scale source control

With agentic coding, many common assumptions about how software is developed are evolving. We embraced these changes when building Scion, which allowed us to take a fundamentally different approach than git on several core principles. Source control for huge monorepos has prior art, notably Google’s Piper and Meta’s Sapling, so we were able to build Scion with their hard-won lessons in mind. Our principles are:

Clients are always online. Git assumes that clients work offline and need a complete copy of the repository. Since nearly all of our clients are agents and jobs, we designed Scion’s client and protocols around a server that is always reachable, and have clients fetch data when they need it.

Client-server asymmetry. In git, every client is capable of being a full-fledged server. In Scion, the server answers questions about file history and blame, creates commits, performs merges and rebases, and so on. The client maintains a bounded local object cache, lays out the working copy files on disk, monitors for filesystem changes, and gives users an ergonomic way to work with the server. It can compute very little on its own but, in exchange, it requires much less data locally.

A comprehensive source control service can power many novel applications. With git, a CI job or tool that needs to ask a question about the repository, such as who last changed a line or how two commits are related, has to maintain a local copy of the repo or hope that vendor-specific APIs provide the answer. With Scion, all of the source control queries the client uses are also exposed via API, so in many cases jobs don’t need a local repository at all. Many internal tools, such as our automated bisect and revert pipelines, wouldn’t be practical at scale without this cheap, programmatic access to source control.

Everything must be horizontally scalable. At our peak, we ran several hundred git mirrors, which significantly strained capacity and no longer scaled once the repo outgrew the mirrors’ disks or memory limits. In Scion, the repository’s data is distributed, and every component is independently scalable; there is no fully materialized copy of the repo anywhere, even on the server. There is no equivalent of packfiles (git’s compressed bundles of objects), so no repository maintenance is needed.

Commits must be cheap, incremental, and lock-free. In git, you commit locally and then push to share your work. In Scion, every commit, rebase, or merge happens on the server, so there’s nothing to push, but each of those operations needs to be fast. The cost of creating a commit and updating its downstream data structures has to scale with the size of the change, not the overall size of the repo, or the server can’t keep up. The development lifecycle in Scion discourages refs (pointers to commits, such as branches and tags), except for the main ref or release branches, because global state that every server has to agree on is a looming scaling problem.

The working copy is optional, and sparse by design. Because our monorepo is so large, and because we check out code tens of millions of times a day for CI, we wanted to avoid checkouts whenever we could. With Scion, a CI job that needs the diff between a commit and its merge base, for example, can ask the server for it. The same goes for writes: many write workloads can also skip the checkout and function entirely via API. Scion’s protocol is centered around sparse checkouts, which only contain the directories the client asks for, and virtualized checkouts, which materialize files on demand, so when a job does need files on disk, the client only pays for what it actually reads.

How Scion works

It’s helpful to understand how these principles came together in practice when building Scion. These insights can apply to other source control systems or, more broadly, to other stages of the software development lifecycle.

Data structures

In Scion, the unit of work is a “changeset,” an entry in a write-ahead log. A changeset stores most of what you’d expect from a commit in git. But where a git commit stores a pointer to the tree, a changeset stores a list of the files that changed relative to its first parent, along with content-addressed pointers to the compressed file contents in blob storage. Changesets are created server-side and are available everywhere, instantly.

This structure lets us accept changesets with very high throughput because there are no packfiles to accept, no locking or cross-server coordination, and no refs to move around. Scion does technically support refs, but since neither creating nor fetching commits involves them, moving one is a compare-and-swap on a single Spanner row that happens separately from creating changesets.

A changeset records only what’s changed, so on its own, it can’t quickly answer questions like who last edited a line or which commits affected a file. To answer those, Scion builds additional data structures from the changesets, including dedicated structures for file blame and path history and skip lists for the commit graph. We call everything that isn’t directly part of the changeset “derived data,” and we compute it all through one generic mechanism. Each type of derived data is defined recursively, so its value for a changeset is computed from its values for that changeset’s parents.

This mechanism has three benefits. First, we can easily add a new type of derived data when a new data structure would make some operation faster. Second, for each type, we can choose whether to compute it eagerly or defer the work, so we avoid materializing data we don’t need. And third, because the client never sees the internals of these data structures, we can optimize them without changing the client. We’ve added new types of derived data many times as the system has grown, such as new indices for performing copy detection or path-based file search.

Scaling Scion

A small fleet of Scion servers provides source control APIs for any operation a client needs, such as getting changesets, computing diffs, finding merge bases, and fetching blobs. All source control data is content-addressed, so a piece of data never changes once it’s stored, and any server can cache it without checking with the others. As a result, the servers are horizontally scalable and require little coordination. They are essentially large caches that can also compute derived data on the fly and write the results back to Spanner.

Scion’s many consumers no longer need to maintain local repositories of their own. Fetching and maintaining the repository used to be a significant maintenance burden for CI jobs or tools that needed to ask source control questions, particularly about commit ancestry and blame. Early in the migration, before we had our own client, repo format, or protocols, Scion only answered these “metadata” queries. Fetching file contents and materializing working copies are far more data-intensive operations, and they needed a design of their own.

Scion’s scn client deviates from git’s fetch protocols in several important ways and, as a result, lends itself to a highly scalable architecture that requires significantly less CPU than git servers. Scion’s negotiation doesn’t tell the server what the client already has; instead, it operates exclusively on trees and blobs the client wants. Starting from a root tree, the client checks its local store for missing trees and requests them recursively, then repeats the process for blobs. Every request is for a specific object that never changes, so any cache can answer it, and the architecture closely resembles traditional tiered caches. The process is also efficient and resumable, because there is no single multi-gigabyte packfile response. Sparse and even virtualized checkouts don’t need special support, because the client simply doesn’t ask for trees it doesn’t want.

In the fleet, the client talks

The problem is that the company—Lantern Production Consultants LLC—doesn’t seem to exist anywhere beyond a post office box in the Spanish Springs shopping complex.

Lantern Production Consultants has been paid around $20 million since last year by Think Big, part of a network of pro-AI super PACs funded by the Leading the Future PAC, for a wide array of services, including polling, digital advertising, research, and strategy, according to federal campaign finance records reviewed by WIRED. Backed by major AI investors, Leading the Future has taken a main role in supporting candidates who back what it calls “an AI innovation policy agenda.”

It is just one of four mysterious LLCs based out of Nevada that have received payments from super PACs in the Leading the Future PAC network, including Think Big and American Mission. The network, which is also based in Nevada, has raised over $140 million to influence political campaigns that align with AI-industry priorities in the midterms.

Summit Ridge Media Group LLC, which received around $13 million between December 2025 and September 2026 from American Mission, lists an address at a mail center in a Reno strip mall. Blue Horizon Compliance Consultants, which also appears in the filings, has its address listed as a Staples location in Reno. And Prusik Partners LLC’s listed address is at a strip mall in Henderson, Nevada, sharing a building with a chiropractor and a beauty salon.

Nevada’s secretary of state told WIRED that they were unable to locate any records for the businesses.

Election watchdogs argue that these LLCs are shell companies, designed to mask the identities of strategists, consultants, and production companies who are working with Leading the Future. “This is about hiding where the money is going,” claims Shanna Ports, senior legal counsel at the Campaign Legal Center.

In May, the Campaign Legal Center filed a complaint with the FEC, which enforces campaign finance laws, alleging that Think Big and American Mission had broken federal law by using shell companies in this way. Specifically, lawyers with the Campaign Legal Center alleged that super PACs in the Leading the Future network had violated the Federal Election Campaign Act (FECA) by failing to disclose the actual recipients of their payments. The LLCs, they wrote in their complaint, “function as mere extensions of the super PACs they serve.”

In an emailed statement to WIRED, Leading the Future spokesperson Jesse Hunt wrote, “We comply with all applicable laws and this is merely a desperate ploy for attention from Public First, Anthropic, and the groups aligned with their outside organizations who see our message resonating with the public and policymakers.”

WIRED reached out to Anthropic and Public First—a pro-AI super PAC focused on transparency and safeguards that has significant backing from Anthropic leadership—to ask about Leading the Future’s charge. “I have no idea what they’re talking about,” said Public First spokesperson Anthony Rivera-Rodriguez. “We unequivocally had nothing to do with this complaint.” Anthropic did not respond to WIRED’s request for comment.

The Campaign Legal Center said in a statement to WIRED that the suggestion they “filed this complaint at the direction of, on behalf of, or in consultation with any outside entity is absolutely false.”

The Campaign Legal Center doesn’t expect its case to be heard by the FEC anytime soon, given that the FEC is essentially toothless at the moment. The FEC has six commissioner seats, all presidential appointees. To make a decision on a legal complaint, the FEC needs a quorum of four commissioners, which it hasn’t had since May 2025. Meanwhile, Think Big and American Mission have continued to pour millions of dollars into the Nevada LLCs.

Leading the Future has piqued a lot of public interest, not just because it has the most cash of any pro-AI group—thanks to Silicon Valley bankrollers like billionaire Marc Andreessen, Ben Horowitz, and OpenAI president Greg Brockman—but also because it funnels money into super PACs that support both Republicans and Democrats. Think Big overwhelmingly funds Democrats, and American Mission funds Republicans.

The fact that the Leading the Future network is playing both sides of the aisle, supporting AI-friendly Democrats and Republicans, has generated speculation from experts as to why it’s spending so much on shielded vendors. Typically, political strategists and consultants cater to Democrats or Republicans, not both. “If you’re running in a Democrat primary and Think Big comes to spend in your race, and they drop half a million on your congressional district doing positive ads while using Republican vendors and strategists—that’s news,” speculates Kyle Morse, deputy executive director of Tech Oversight Project, a nonprofit advocacy group that’s critical of big tech.

There are plenty of reasons why a super PAC may want to hide its vendors, ranging from benign to nefarious. In this instance, it's possible businesses don’t want to be publicly associated with a pro-AI campaign. But with the FEC lacking a quorum for the foreseeable future, “We are not fundamentally equipped to figure out what’s happening here,” says Morse.

Leading the Future isn’t the only PAC accused of shielding vendors by using shell companies. Earlier this year, Campaign Legal Center filed a complaint with the FEC against pro-gun YouTuber Brandon Herrera, who is running for Congress in Texas District 23, alleging that more than 99 percent of his campaign’s disbursements were funneled through Texas Strategy Group, which was, the complaint claimed, “being used as a shell entity.” When reached for comment, Herrera’s campaign directed WIRED to conservative personality Matt Braynard, who runs Texas Strategy Group. Braynard strongly denied the Campaign Legal Center’s accusations, calling the complaint “meritless” and “little more than a recycled legal theory from a partisan advocacy group.”

Campaign Legal Center also filed a complaint with the FEC against Lead Left PAC, a pop-up super PAC that was funded by Republican operatives while posing as a Democratic entity with the presumed goal of meddling in Democratic primaries. Campaign Legal Center accused it of paying shell companies to avoid being linked to Republican strategists.

Ports says that this marks a disturbing trend in campaign finance, at a time when dark money in politics already reigns. “There’s no way of tracing the source behind the money, and that’s bad enough on its own,” says Ports. “Now there’s this new component, where groups are playing games to hide where the money is being spent. As a result, voters really lack fundamental information about where the money is coming from and where it’s going.”

Updated 2:15 pm ET, 10/13/2026: This story has been updated with further comment from Nevada's secretary of state and the Campaign Legal Center.

Already in 2018 Google was training AI to write “Wikipedia-like articles,” and by October 2024, a Princeton University study found that about 5 percent of nearly 3,000 newly created articles on English Wikipedia in a single month (August 2024) contained a substantial amount of AI-generated content. There were signs. ChatGPT was fond of em dashes—parenthetical statements that look like this one—and curly quotation marks. Sometimes, residues from the prompts used to compose articles were left behind (“Here is your Wikipedia article,” they might say.)

At first, Wikipedians tried to shape and control AI, to make its output “acceptable and constructive,” or to fix or remove if it proved otherwise. Generic fluff like “praising a village for its fertile farmlands, livestock, and scenic countryside” and fake sources were weeded out. By March 2026, AI content was found to violate its core principles so often that writing with large language models was banned outright, and their role restricted to translation and minor proofreading.

A much-read essay titled “Death of Wikipedia” explained this defensive posture. It predicted a ripple effect: As contributors reduced their contributions in response to AI pervading the platform, there might be a temptation to replace their work with still more AI, creating a downward spiral. One viral X post lamented that artificial intelligence seemed to be changing things in the wrong direction: “I want AI to do my laundry and dishes so that I can do art and writing, not for AI to do my art and writing so that I can do my laundry and dishes.” The “Death of Wikipedia” warned against something similar: Rather than AI performing Wikipedia’s “housekeeping” roles, it might compose its articles instead, leaving humans relegated to formatting and cleanup. The result would trap editors in an endless curatorial project derived not from human priorities but from the frostbitten harvests of machines.

“The potential ‘whittling down’ each year of our pool of talented writers is the greatest threat to Wikipedia,” another Wikipedian wrote, “as we must increase the number of editors, especially expert editors, to be able to fix the sprawling hellscape of weak, inaccurate and incomplete articles that drag down the project.” A Wikipedia written and read by machines threatened to create a new, deracinated Wikipedia, stripped not only of its context, but of its animating passion. It would be artless, and soulless. When the Wikimedia Foundation says that the care and commitment of Wikipedians to “reliable encyclopedic knowledge is something AI cannot replace,” that is not the same as saying that it will not be replaced.

Once Google introduced AI Overviews in search, they quickly became as central to the experience as Wikipedia was until recently. (This also means Wikipedia still does play a crucial role as a source, only at one step removed.) Anyone who uses AI agents knows that they give plausible, almost intuitive answers, which can pass a superficial review of their sourcing. They are also often wrong. If Wikipedia itself becomes corrupted by artificial intelligence, by what means will we prove when they are wrong?

Implicit in the idea of a single, machine-edited encyclopedia to rule them all is that such a phenomenon should act as a final authority. Its appeal, to the kind of people who find it appealing, is that it will be coolly rational, a kind of digital King Solomon that can act as a disinterested arbiter. There is no reason to think such cold logic would not be cruel instead. Its aesthetic failings are a clue: “Slop” is a useful word for the product of artificial intelligence, which implies something unvariegated and monotonous, absent not only of nutritional value but also of the flavor that makes nutrition a pleasure.

There is also no reason to believe an AI encyclopedia, or any other encyclopedia, should be unifying. Whatever its shortcomings and eccentricities, Wikipedia is the closest thing to an “encyclopedia of everything” we have ever had. Once smartphones became widespread after the iPhone’s launch in 2007, the old speculations, however far-reaching, were realized: Wikipedia was costless, portable, immediate, and electric. Enormous and omnipresent, it really became an approximation of the “sum of all human knowledge.” But so what? What did access to this oracle mean for human flourishing? What good has Wikipedia done?

A documentary maker, wanting to bring Wikipedia’s story to the screen, asked me a sharpened version of this question. Yes, Wikipedia was the little encyclopedia that could. It had overcome humble origins to become massive. But the dictates of streaming television needed something more. Were there, she asked, any real-life episodes where Wikipedia had “saved the village”? Has Wikipedia saved lives? The answer is “probably,” though not in dramatic or famous ways. Quick-fire encyclopedic knowledge has helped with accidental poisoning, and there are signs that Wikipedia is accessed with special frequency during natural disasters. But these anecdotes are difficult to corroborate, and often, when Wikipedia’s role is scrutinized, it turns out to be incidental. If someone calls for help in an emergency, it is not the phone which is the hero.

Does Wikipedia perform a public good? This seems self-evident but is much harder to measure and, in a way, is out of the project’s hands. In 2013, when an online poster posed the question “If someone from the 1950s suddenly appeared today, what would be the most difficult thing to explain to them about life today?” the top answer went viral as a mordant sign of the times: “I possess a device, in my pocket, that is capable of accessing the entirety of information known to man. I use it to look at pictures of cats and get in arguments with strangers.” Elsewhere, the “arguments with strangers” line was expressed in less lighthearted ways. “The greatest threat to democracy may no longer derive from human agency but from new forms of technology, which have the capacity to undermine democracy without anyone having intended it,” the academic David Runciman wrote two years later. “The forces from which democracy needs rescuing are no longer pressing on it from the outside. They come from within.”

No one is credited with foreseeing Wikipedia more clearly than H. G. Wells, a reputation built on a series of essays collected in his book *World Brain*, and its advocacy for a “Permanent World Encyclopaedia.” But Wells expounded on this idea many times, and his other writings were much more equivocal, and he even satirized his own obsessions in *The Camford Visitation*: “He wants a universally educated world, educated on the same lines, with every artificial difference eliminated. He is a cantankerous, disagreeable little nobody and yet at times one feels he has got hold of something most exasperatingly vast and right.” Soon after *World Brain* was published, Wells had lost faith in his encyclopedic vision altogether and succumbed to late-life pessimism. Humanity had orchestrated to create a world war, not a world brain, and in the civilizational race between “education and catastrophe,” as he put it, catastrophe looked to have a winning lead.

Less obvious to us now is that *World Brain* was also an antidote. The most significant new European encyclopedias that preceded it, the Great Soviet Encyclopedia and the Enciclopedia Italiana, were direct expressions of nationalist and totalitarian intent, so much so that the entry on “Fascism” in the Enciclopedia Italiana was credited to Benito Mussolini himself. Wells understood that “internationalism” needed its own encyclopedia as a counterweight, but that did not make it a simple force for freedom. He assumed that the World Brain would assist a world government in projecting its power, and though democratically available, his Permanent World Encyclopaedia would make such a world government omnipotent. A world government that was all-seeing as well as all-knowing would inevitably be repressive; a sinister side to Wells’ ideas seemed to have partly inspired George Orwell’s *Nineteen Eighty-Four*.

Orwell also critiqued Wells more explicitly in his 1941 essay “Wells, Hitler, and the World State.” One of its more perceptive observations is that Wells was not, in fact, a futurist. He was a nostalgic, Orwell thought, a “nineteenth-century liberal” who had spent 40 years repeating the same idea: that history was a battle between “the man of science who is working towards a planned World State” and “the reactionary who is trying to restore a disorderly past.” With Orwell’s help, we can see that Wells’ World Brain was an old idea, not a new one. Versions of