[$] Discussing a rewrite of XArray

Post Syndicated from daroc original https://lwn.net/Articles/1100520/

The work to support block sizes larger than the page size on XFS has been
difficult. Many users of XFS run stable kernels, which means that they aren’t testing
new XFS code as it is released. That has made Daniel Gomez wonder whether
adopting Rust for some of the data structures underlying XFS, particularly

XArrays
, could reduce the number of bugs lurking in the code. At
Kangrejos 2026, he led a discussion about the potential problems with converting
XArray to Rust. The assembled kernel developers had a number of reasons to be
cautious about replacing the XArray code, but Gomez was determined to experiment
with the possibility, citing both security and performance improvements.

eMudhra intermediate CA compromise

Post Syndicated from jzb original https://lwn.net/Articles/1101643/

Mozilla has announced
that it has received a report that private keys associated with eight eMudhra intermediate certificates have
been compromised:

These keys could allow attackers to issue fraudulent HTTPS certificates for
websites they do not control. An attacker who could intercept a user’s
connection could use those certificates to impersonate websites and potentially
read or modify traffic.

Mozilla has blocked the affected certificates using its OneCRL
centralized list of revoked certificates, and has updated the trusted
certificate list in Network
Security Services (NSS) 3.131.1
.

There is a single-page
site
about the compromise that goes into more detail. According to the site
the certificates have also been blocked in Chrome since October 17, Apple
devices since the 19th, and Microsoft blocked the certificates on the
20th. There is also a table that displays whether a browser or other client
still trusts the compromised certificates.

The NetBSD foundation has issued
instructions
to block the certificates on NetBSD installations. Users of
other browsers and operating systems may wish to check for updates or guidance
to disable the compromised certificates.

Neoclouds: Your Storage Layer Just Got a Public Grade

Post Syndicated from David Johnson original https://www.backblaze.com/blog/neoclouds-your-storage-layer-just-got-a-public-grade/

A decorative image showing servers.

SemiAnalysis published ClusterMAX 3.0, and storage helps decide whether a neocloud lands in Platinum, Gold, Silver, Bronze, or the new Participation Ribbon tier. Your customers can read that grade before they take your call.

Why it matters: Only 19 of the 77 neoclouds tested in depth earned a Medallion rating, and plenty that held Silver or Gold last round lost it. For most of them, the storage grade doesn’t reflect a decision anyone made. It reflects a default.

Storage decides whether you get rated at all

Storage isn’t something the evaluation gets to eventually. You can’t be rated without it.

  • Every provider has to supply at least 10TB of high-performance file storage and 10TB of S3-compliant object storage before testing begins.
  • Then storage is tested twice: once for speed, once for whether that speed holds through 15 minutes of sustained mixed traffic.
  • Some providers lost nearly 40% of their bandwidth in the second test.

Every neocloud is in one of three states

Size isn’t what matters here. AWS and Azure both had storage problems this round. TensorWave, far smaller than either, had storage SemiAnalysis called exceptional. The difference is whether anyone deliberately decided what storage is for, what it runs on and who owns it.

  1. Not decided yet. You rent GPUs by the hour. Customers bring data in, run a job, and take the results home. Storage is scratch space, and there’s nothing to migrate if you change your mind.
  2. Decided by default. Someone stood something up once, and nobody’s job includes going back to check it. It was fine at the time, and it has stayed “fine at the time” for two years.
  3. Decided deliberately. A person or a contract is responsible for whether it still works, and you pay for that one way or another.

Most neoclouds are in the second state and think they’re in the first. The first state is fine. The second is the one that gets graded.

Why the second state is so common

Decision by default isn’t negligence. If you sell compute by the hour, customers manage their own data, and nobody has to decide what your storage offering is. GPUs are what customers evaluate, so that’s where the attention goes.

But that changes when customers start leaving their data on your platform. Now you have to decide where it lives, who can reach it, what happens when a machine dies and what to charge for it. That decision usually arrives while the business is growing too fast to stop and make it.

What “decision by default” looks like from the outside

SemiAnalysis found four recurring storage failures:

  • Storage servers not enforcing RBAC correctly on volumes
  • Storage misconfigured on the overlay network, so customers could reach the underlay
  • Backend storage sharing a network with no isolation
  • A BlueField data processing unit (DPU) left in its default host-trusted mode

The DPU case shows the pattern most clearly. 

A DPU is a small computer built into the network card. In NVIDIA’s reference design, it handles networking, storage, and security work, including the rules that keep tenants apart. Out of the box, it trusts anyone with root access on the server. That’s fine in NVIDIA’s model, where the server admin is trusted. But in a GPU cloud, the customer often has root. That means the customer can reach the DPU itself, which is the component running the rules that separate them from everyone else on that hardware. Anyone who gets that far is in a position to weaken or turn off the boundary they’re supposed to be sitting behind. 

SemiAnalysis found at least one host where that path was open. Nobody chose that setting. It’s how the card ships, and nobody went back to change it.

Read the reviews in tier order and the pattern holds: the further down the tiers, the less anyone has looked at storage.

  • At the top, the complaints are about ergonomics. CoreWeave’s only storage note was a wish for one-click local GPUDirect Storage, which SemiAnalysis itself called nitpicky.
  • In the middle, there are configuration gaps. Azure’s default StorageClass couldn’t attach, and a model load from NFS timed out because no parallel filesystem was attached to the Slurm cluster.
  • At Bronze and below, storage often isn’t set up at all. One Seattle cluster had no shared filesystem to test. Another had no RWX StorageClass, so there was nowhere to put /shared. At a third, NVMe existed but nothing exposed it, and PVCs hung in Pending.

One case sums it up best. A provider’s default StorageClass provisioned and bound, then left the pod stuck in ContainerCreating. Meanwhile, the Lustre tier on the same worker nodes hit 91.7 GB/s aggregate read across 32 clients. The hardware was fast, but anyone who used the default would have concluded the storage didn’t work.

Customers will ask these questions at any size

The tenant-isolation failures SemiAnalysis found hit providers big enough to be testing GB300 racks:

  • A shared Kubernetes control plane exposing other tenants’ namespaces
  • A default InfiniBand partition key surfacing 532 hostnames
  • A Grafana dashboard that separated tenants on screen while the key behind it read every tenant’s logs

That reads like someone else’s problem, but it isn’t. It’s a preview of the diligence review you’ll get the first time a serious customer evaluates you. 

The exposed customers in the report included banks, telcos, universities, research institutions, AI labs, and a national intelligence agency. Buyers like these ask:

  • What isolates my workloads from other tenants: containers, VMs, or dedicated nodes?
  • Is the control plane shared?
  • Who can read my volumes, and what enforces that: the storage layer or the interface in front of it?
  • Is backend storage on its own isolated network?
  • Can anyone at your company reach my logs and monitoring data without my permission?
  • Are machines reprovisioned from scratch between customers, or recycled?

It’s important to have answers to these questions before a customer asks, not while they’re waiting.

Three ways out of the second state

Getting out of the second state means picking one of three paths, and committing to it:

  • Build on Ceph. You get full control over the design and no dependence on anyone else’s release schedule. The cost is a permanent, dedicated headcount line: Ceph specialists aren’t interchangeable with your compute engineers.
  • Build your own hardware. You design, rack, and run your own storage servers, shaped to your customers’ workloads, and the revenue stays in-house. The cost is procurement, refresh cycles, and capital committed years ahead of demand you can’t forecast.
  • Partner. Storage works and stays working without anyone on your team owning it, and your engineers stay on compute. What you’re trading is some control: a partner’s pricing, roadmap and deprecation timelines are decisions you’re part of rather than decisions you make alone, and when a customer’s job stalls on storage, they still call you. The right partner expects those questions early and answers them plainly. It’s worth asking before you sign.

All three are legitimate. The option most neoclouds are actually running is none of them.

Decide before the grade, not after

Every provider SemiAnalysis tested had storage. The ones who had decided what it was for, and kept checking that it worked, had an answer when customers asked. The rest had whatever the default gave them, and now that’s published.

If you rent GPUs by the hour today, your customers will eventually stop taking their data home. Decide on your storage before that happens, while there’s less data to migrate, no customers waiting on an answer, and no grade already in front of your prospects.

Read the full report here. And visit us to explore how Backblaze partners with neoclouds to ensure more open, AI-ready storage architectures.

The post Neoclouds: Your Storage Layer Just Got a Public Grade appeared first on Backblaze Blog | Cloud Storage & Cloud Backup

България между член 4 и страха от Русия

Post Syndicated from Искрен Иванов original https://www.toest.bg/bulgariiya-mezhdu-chlen-4-i-straha-ot-rusiya/

Член 4
Страните по Договора ще се консултират съвместно всеки път, когато по мнение на някоя от тях е възникнала заплаха за териториалната цялост, политическата независимост или сигурността на която и да е от тях.

Член 5
Страните по Договора се договарят, че въоръжено нападение, предприето срещу една или повече от тях, в Европа или в Северна Америка, ще се разглежда като нападение срещу всички тях, вследствие на което те се договарят, че в случай на такова въоръжено нападение всяка от тях, упражнявайки правото си на индивидуална или колективна самоотбрана, признато в член 51 от Устава на Организацията на обединените нации, ще окаже помощ на нападнатата страна или страни по Договора, като незабавно предприеме, индивидуално и съгласувано с останалите страни по Договора, такива действия, каквито смята за необходими, включително употребата на въоръжена сила, за възстановяване и поддържане на сигурността в Северноатлантическата зона.

(Северноатлантически договор, Вашингтон, 4 април 1949 г.)

България между член 4 и страха от Русия

Военните конфликти, в които е участвала България през своята най-нова история, винаги са били предшествани от поляризация в общественото мнение. Достатъчно е да си припомним разделението, което цари сред българския елит и избирателите в навечерието на двете световни войни, както и отчаяните опити на българските монарси да лавират между силните на деня в Европа. Някой би нарекъл тези исторически събития специфични само за българското житие, но ако погледнем историята на международните отношения ще видим, че не е така. 

Въпреки че войната взема много човешки жертви и води до тотално разрушение, може би една от най-фаталните последици от нея е слагането на край на солидарността между хората. Всъщност смело можем да кажем, че днес България дори няма нужда да влиза в нов военен конфликт, тъй като тук вече се води вътрешна война, а изходът от нея ще е решаващ за дългосрочното бъдеще на нашата страна. 

Но какво тогава трябва да ни притеснява в случващото се съвсем близо до нашите териториални води? 

Ами ако САЩ излязат от НАТО?

Живеем в свят, в който съюзите не са даденост. И това донякъде е добре, защото бяхме склонни да ги приемаме за вечни, а е полезно да си припомняме защо съществуват и какво точно изчезва, когато ги няма. Но ако САЩ се оттеглят от НАТО, в какво ще се превърне Европа и на каква цена? От Искрен Иванов.

Защо сега и защо Черно море?

Войната в Украйна продължава вече четири години, а през цялото това време нашата морска граница изглеждаше неестествено спокойна. Анексията на Крим през 2014 г. и последвалата ескалация на конфликта останаха някак си далечни за българина, който обикновено посрещаше новините за ставащото с отегчение от факта, че постоянно го занимават с едно и също, с недоверие, че войната може да стигне до България, или с неоправдана истерия, че страната ни ще стане жертва на амбициите на Запада Русия да бъде победена на всяка цена. 

Тези наративи бяха същинското проявление на войната у нас, тъй като в началните ѝ етапи Москва нямаше интерес да я изнася извън границите на Украйна. Реално целта на Русия в тази война е Америка, но пътят към нея минава през Украйна – една руска победа би принудила Вашингтон отново да приеме Москва като глобален актьор в международната система. САЩ обаче декларираха категоричната си подкрепа за България и Румъния, а Европа започна усилено да се въоръжава. Истинската война на Стария континент се водеше на когнитивно ниво – в интернет, в социалните мрежи, дори и в медиите.

Нещата започнаха да се променят след 28 февруари тази година, когато САЩ нанесоха първите си въздушни удари срещу Иран – преломен политически момент, който за пореден път показа, че Вашингтон разглежда ядрената програма на Техеран като екзистенциална заплаха за сигурността си. По това време Украйна вече разполагаше с най-силната армия от дронове в Европа, докато Русия се опитваше да допълни конвенционалната си стратегия с ядрено говорене. В същото време присъединяването на Финландия и Швеция към НАТО лиши Русия от стратегическото ѝ превъзходство в Калининградска област, а Полша даде да се разбере, че е готова да посрещне решително всяко руско нападение срещу границите ѝ. 

Така Черно море остана единствената уязвима точка, в която Кремъл можеше директно да провокира Алианса. Тази опасност не беше отчетена навреме нито от България, нито от останалите страни в региона, тъй като падането на иранския режим изглеждаше въпрос на време, а подобен развой би отслабил стратегическите позиции на Русия и би освободил американски ресурс за възпиране на Москва. Оказа се обаче, че Иран има технологии и стратегия, с която да воюва, и това сякаш даде кураж на Русия да продължи да предизвиква НАТО.

Основната причина за уж закъснялото желание на Русия да изнесе конфликта се появи, когато руските загуби на фронта рязко се повишиха, след като Киев започна все по-широко да прилага асиметрична стратегия, основана на масовото използване на дронове. Нещо повече, Кремъл имаше нужда конфликтът да излезе извън рамките на руско-украинската война, за да легитимира собствената си теза, че истинският сблъсък е със САЩ и НАТО. Това би могло да стане по два начина. 

Първият е директен военен конфликт между Вашингтон и Пекин за Тайван – сценарий, на който Русия, изглежда, много се надяваше, но той така и не се реализира. Подобен конфликт би отворил втори фронт на глобалното противопоставяне със САЩ и би отклонил американски ресурси и внимание от войната в Украйна. За Китай обаче това би означавало да рискува собствения си възход в името на руския стратегически интерес.

Това постави руските политици в особено положение – те или трябваше да признаят, че в продължение на четири години Русия не може да победи Украйна, или все пак да търсят как да изнесат конфликта извън украинските граници, с което да покажат на партньорите си, че войната с Киев е част от американския план за унижението на руснаците.

Как би започнала войната в Черно море?

Първото и основно условие за пламването на конфликт в Черно море парадоксално са действията на самото НАТО, или по-конкретно стъпките, които Алиансът ще предприеме, за да отговори на инцидентите с нападнатите кораби в басейна. Тук следва да отбележим, че макар в официалната позиция на българското правителство да не се назовава по име държавата, която стои зад тези атаки, случващото се недвусмислено е заплаха за националната ни сигурност. И не само защото е в териториалните ни води, а защото задълбочава разделението в обществото, което съществува от началото на войната в Украйна. Всъщност управляващите вече няколко пъти намекнаха, че всички доказателства сочат в полза на Русия, макар че самата Русия отрича.

Страдателният залог на генерал-премиера

„Онзи-който-не-бива-да-се-назовава“ продължава да потапя кораби в Черно море. Междувременно Румъния сваля дронове и укрепва отбраната си, а ние търсим доказателства и призоваваме безадресно за мораториуми. Колко струва снишаването, когато войната вече е на брега ни? От Емилия Милчева.

Ситуацията е класическа провокация към страна членка на НАТО. Такива провокации суперсилите са предприемали по време на Студената война, за да проверят какви ще бъдат действията на отсрещната страна. Или по-просто казано – хвърлена ръкавица. Затова и най-недалновидното, което Алиансът би могъл да направи, е да не демонстрира решителност. 

За щастие, в Европа вече се чуха множество гласове в подкрепа на страната ни, а България, Румъния и Турция вече обсъждат задълбочаване на тристранното си сътрудничество за сигурността и безопасността на корабоплаването в Черно море. До голяма степен това изчерпва и прагматичните стъпки, които бихме могли да предприемем на този етап, макар в публичното пространство все повече да се дискутира задействането на член 4 от Северноатлантическия договор.

Може ли обаче член 4 може да влоши нещата? 

Механизмът на съюзническите консултации, залегнал в член 4, е доста стар и може да служи като последна политическа бариера пред ескалация, която би поставила на дневен ред член 5. Тук идва и обективната реалност – Русия иска точно това. Атаките с дронове ще продължат, докато член 4 не бъде задействан, което ще даде основание на Москва да започне подготовка за потенциално нахлуване в Европа просто защото нито руският президент, нито неговите генерали ще чакат задействането на члена за колективната отбрана. 

САЩ са свръхфокусирани върху войната с Иран и възпирането на Китай и макар техните войски все още да са разположени в Европа, реалната тежест за отбраната на Стария континент пада върху самите европейци. Затова и един потенциален конфликт между Русия и Алианса в Черно море би могъл да започне именно след задействането на член 4 или ако някой от съюзниците директно отговори на провокациите (освен ако договорката между Тръмп и Путин за руския дизел не се окаже толкова обещаваща, че да разубеди руснаците във „виновността“ на Европа).

Войната, която никой не иска, но всички вече водят

За американската дилема между Израел и глобалната икономика, за иранската ядрена амбиция и за новото разделение между Европа и САЩ. Какво ни показва блокадата на Ормузкия проток? От Искрен Иванов.

Ролята на САЩ в конфликта с Русия

Основният предупредителен сигнал за евентуална война в Европа би бил зачестяването на атаките с дронове в Черно море, а той вече е налице. Големият проблем е, че ако НАТО задейства член 4, Москва може да използва това като аргумент пред Тръмп, че Европа, а не Русия тласка Алианса към война.

За Кремъл подобно внушение не противоречи на стратегическото му противопоставяне със САЩ – напротив, то би могло да отслаби трансатлантическата връзка и да остави европейските съюзници без пълната подкрепа на Вашингтон. Ролята на Америка ще е решаваща при евентуален опит на Русия да нападне европейските държави – ако това се случи по време на междинните избори, може да бъде използвано от привържениците на Тръмп като аргумент Вашингтон да не се въвлича в още една война. 

Изглежда, че американският президент е сред малкото лидери, които разполагат с реални инструменти да повлияят върху сметките на Кремъл за евентуална ескалация в Европа. Сделката между Тръмп и Путин за руския дизел би могла да даде на Москва допълнителен икономически стимул да се въздържа от подобни провокации, но руснаците едва ли ще се трогнат от това.

Да, някой би нарекъл този опит изключително циничен, защото предложението Европа отново да купува руски газ я връща в прегръдката на Москва, докато зависимостта ѝ от американските енергийни доставки остава. Но и Тръмп не би се трогнал от това, тъй като е доста обиден на някои европейски държави, че не го подкрепиха във войната с Иран.

Накъде след „Мюнхен 2026“? Отворените въпроси пред Европа и България

Мюнхенската конференция по сигурността затвърди усещането (де да беше само такова), че старият трансатлантически баланс се разпада. Вече всички сме на една вълна по този въпрос. Но докато Европа търси автономия, България рискува да остане между линиите на разделението. От Александър Малинов.

В същото време Москва не трябва да си прави илюзии, че САЩ ще гледат безучастно какво се случва в Европа. В най-лошия случай ще предприемат политика на офшорно балансиране, отваряйки по-широк фронт за възпиране на Русия на територията на НАТО. В публични изказвания на високопоставени военни от Алианса се допуска при евентуална руска атака той да нанася бързи удари по военни цели на руска територия, включително в района на Санкт Петербург, при избягване на ядрена ескалация.

Стратегическият проблем е, че Алиансът никога не е бил предвиден да напада или да воюва срещу СССР, а да защитава Европа от него. И ако след 11 септември беше ясно, че елитните части на НАТО могат да се справят с „Ал Кайда“, когато срещу тях стои ядрена сила, сценариите могат лесно да се размият. 

Най-решаващата променлива за изход от ескалацията обаче остава ядреният фактор, който на този етап е и най-успокояващият. Докато Русия говори как ще изпепели цяла Европа, едва ли Европа има от какво да се страхува – това е остаряла реторика от съветско време, която може да е в състояние да разбуни духовете в обществото, но сама по себе си не означава непосредствена ядрена заплаха за Алианса. Реалната употреба на ядрено оръжие срещу страна от НАТО би създала риск от ответен удар и ескалация с катастрофални последици и за самата Русия.

Когато обаче подобно говорене отстъпи място на зачестили провокации от страна на Москва, това би могло да е сигнал, че Русия се готви да изнесе конфликта извън границите на Украйна. Сред факторите, които ограничават подобна ескалация, остава способността на САЩ бързо да съсредоточават военни сили там, където възниква заплаха, включително чрез самолетоносачите си, разположени в Близкия изток. Един от тях е атомният самолетоносач „Джордж Х. У. Буш“, чието Седмо палубно авиокрило разполага със значителни възможности за нанасяне на удари по наземни цели. Затова за Москва би било по-изгодно да избягва пряка провокация срещу Алианса и да остави НАТО да направи следващия ход.

Ролята на България и реалната опасност от война

Може би най-сигурният сценарий, при който Русия няма да бави започването на война срещу европейците и би действала решително срещу Алианса, е, ако САЩ започнат сухопътна операция срещу Иран. Тогава американските стратегически ресурси ще са толкова ангажирани с военните действия в гигантската държава, че едва ли ще успеят да се намесят пълноценно в Европа, освен с настоящото си военно присъствие на Стария континент, което и без това е силно редуцирано.

Една голяма стратегическа грешка, която европейците допуснаха, е, че ако иранският режим беше свален по-рано, южният фланг на Русия отдавна щеше да бъде оголен и Москва щеше да възприеме малко по-различен подход. За нещастие, това така и не се случи, като нежеланието на Европа да се намеси не трябва да се търси само в една посока – както вече пояснихме в един от предишните материали.

В останалите сценарии всичко зависи от реакциите на НАТО на следващите провокации, а отговорът на България ще е особено важен за целостта на Алианса. В това отношение новите многостранни формати в Черно море са обнадеждаващи. 

НАТО, ЕС и „българската мечта“. Но кое по-напред?

Представите за „българската мечта“ често се люшкат между исторически митове и заемки от чужди модели. Но как изобщо се ражда тази идея и защо днес изглежда толкова трудно да я формулираме? Нейните корени, трансформации и рискове в съвременния геополитически контекст проследява Искрен Иванов.

Липсата на противоракетна система и противодронова защита обаче крият сериозни рискове от инцидент, което от своя страна се корени в погрешната стратегия, по която се модернизираха въоръжените сили на страната ни. Тази модернизация беше завършена някак си на парче, а крайъгълният камък на всяка подобна реформа е придобиването на способности, с които една държава да се защитава от ракети и дронове, следвано от обновяване на военния авиопарк и флота. Затова и до осигуряването на такива ресурси съюзническата подкрепа от съседите ни ще има водеща роля, а присъединяването ни към Европейската инициатива за защита от дронове е повече от закъсняло.

И накрая, нека не забравяме, че прибързаното активиране на член 4 и член 5, както и необузданите призиви НАТО да използва „цялата си мощ“ срещу Русия са проява на същата истерия, която наблюдаваме и в онзи сегмент от обществото ни, който мечтае за завръщането на добрия стар СССР. 

Реалностите обаче са други – въпреки стратегическата надпревара и санкциите САЩ и Русия продължават да имат пресечни икономически и енергийни интереси. 

Отношенията с Китай и Иран заемат далеч по-важно място в дневния ред на американската президентска администрация и това може да се промени най-рано след междинните избори. Ето защо решението да бъде въведен мораториум върху военните удари срещу цивилните и търговските кораби в Черно море и засилването на натовското присъствие в черноморския регион са може би най-адекватната политика, която страните в региона могат да следват на този етап. Така, ако един ден се стигне и до задействането на член 4 или член 5, България ще е изчерпала възможностите за деескалация, преди да потърси съюзническа защита, а за Москва ще бъде далеч по-трудно да представи този избор като поредното българско „предателство“ спрямо Русия и да задълбочи още повече разделението в българското общество.

Заглавно изображение: Военнослужещи и техника на НАТО по време на учението Steadfast Dart 2026, което тества способността на Алианса за бързо разполагане и подсилване на силите му. Снимка: НАТО

Security updates for Tuesday

Post Syndicated from jzb original https://lwn.net/Articles/1101617/

Security updates have been issued by AlmaLinux (environment-modules, kernel, pcs, perl-URI, python3.14-urllib3, and webkit2gtk3), Debian (python-django), Fedora (bind, bind-dyndb-ldap, chromium, cifs-utils, curl, haveged, python3.15, qt5-qtbase, rust-rbw, rust-routinator, rust-rustls, xorg-x11-server, and xorg-x11-server-Xwayland), Mageia (firefox, firefox-l10n, nss, flatpak-builder, imagemagick, libpng, libxi, libxpm, libxtst, openssh, postgis, and thunderbird), Oracle (emacs, environment-modules, libsoup, perl-URI, python3.14-urllib3, webkit2gtk3, and xorg-x11-server), Red Hat (go-fdo-client, go-fdo-server, golang, kernel, kernel-rt, openssh, postgresql:16, postgresql:18, and rust-sequoia-sq), SUSE (alsa, AusweisApp, chromedriver, ffmpeg-4, kubernetes, libsoup2, nvidia-open-driver-G07-signed, p11-kit, perl-Net-OAuth, perl-Net-Whois-Raw, pgvector-devel, pi-coding-agent, podman, python, python3, python3-base, python3-doc, python315, python36, thunderbird, and velociraptor), and Ubuntu (cifs-utils, curl, golang-1.22, libxtst, openssh, openssh-gssapi, and php8.5, php8.3, php8.1, php7.4, php7.2, php7.0, php5).

Introducing tsrs: a Port of TypeScript to Rust

Post Syndicated from Boshen Chen original https://blog.cloudflare.com/typescript-rust-port/

Cloudflare and VoidZero are now working with Max Schwenk of Owner.com on tsrs, a Rust port of the TypeScript compiler. We are doing this work in close collaboration with the TypeScript team, and incubating tsrs as part of the Oxc JavaScript compiler toolchain.

Our goal is to help developers spend less time waiting for their code to be checked and more time building. Making TypeScript faster and more memory-efficient also helps bring complete development environments to more places, including right in your browser.

To be clear, we are not forking TypeScript. We believe the TypeScript team should remain in full control of the language’s design and direction. They have maintained a long-term vision while guiding TypeScript’s adoption across the JavaScript community. We do not want to change that.

The TypeScript team can move quite fast on many things, but for some features they may spend years intentionally exploring options and making prototypes before picking the right implementation. A Rust port has to follow those decisions closely, or it will eventually fall apart and become incompatible. We have to preserve the TypeScript language strictly based on its original implementation – and the TypeScript team should remain solely responsible for deciding what that looks like.

Performance and memory improvements

Early benchmarks of our Rust port of TypeScript are promising: tsrs is up to 8x faster and uses ~70% less memory compared to TypeScript 7.0 when using the same number of type check workers:

As you can see, the next version of TypeScript already brings many performance improvements, making TypeScript 7.1 beta up to 2.5x faster than TypeScript 7.0. Some of these optimizations were upstreamed from tsrs, and we’re hoping to find more.

You may have seen recent benchmarks of different TypeScript ports with various performance claims, often due to using larger machine types and different options compared to TypeScript’s defaults. We worked with the TypeScript team to ensure the above benchmarks are comparing the same configuration.

By default, tsrs ships with an adaptive configuration dependent on the machine type that uses more memory but is even faster:

Try tsrs

TypeScript in Rust aims to be a faithful port of TypeScript. You can try an experimental release by installing the tsrs package from npm:

npm install tsrs
npx tsrs

Why now?

We’ve seen many attempts at porting TypeScript to other languages over the years. Because of the complexity involved, only one of the ports succeeded: the TypeScript team’s port of TypeScript from JavaScript to Go.

However, frontier AI models can now do large-scale ports almost independently in a matter of days. We have now seen slopforks, faithful ports, and completely re-architected versions of TypeScript in Rust or C++. There is clearly a demand for even faster TypeScript.

Why Rust?

You might be thinking: “TypeScript’s Go port already made TypeScript 10x faster and far more memory efficient than the previous version written in TypeScript. Why isn’t that enough?”

However, it’s not just about speed. Rust offers some unique advantages: running in WebAssembly. The Rust + Wasm story has always been strong, and one of the reasons comes down to the fundamentals of Rust’s language design. When you compile a Go program to Wasm, you have to compile Go’s garbage collector along with it. But Rust’s memory management model enables straightforward memory interactions between a WebAssembly guest and host. This is one of the key things that makes Rust a much better fit for the WebAssembly use-case: memory efficiency.

Cloudflare Workers have supported Wasm for a long time. Just a few weeks ago we announced supporting native Rust in Workers with the new Emscripten target for wasm-bindgen. When you run entire software build and deployment systems in tight loops on Workers, the benefits of a small memory footprint pay off quickly. It means you can run these workloads so efficiently that it’s now possible to run fully encapsulated development systems in places where they couldn’t have been run before.

This enables new possibilities when combined with agents: You are now able to run a development toolchain end-to-end in a fully sandboxed environment on Cloudflare. But with Wasm, you can also run those environments safely client-side in your browser, or on an embedded device, or an IoT application.

How will the tsrs port be maintained?

First, we are working with Theo Browne to merge tsc-rs and tsrs into a single package that supports all of TypeScript’s features including Language Server Protocol (LSP) and content mappers. Second, we’ve seen a lot of success with how we maintain Vinext in sync with its upstream, Next.js. We explained how we do this in a recent blog post:

Each morning, an agent reviews the changes, fetches diffs, and opens tracking issues for anything that could affect Vinext. Every night, the compatibility matrix is regenerated as we run the Next.js test suite against Vinext. When one of these tests or issues reveals a gap, agents are now in the position where they can identify the change across both codebases, build a reproduction, port any relevant tests, and propose a fix.

We will apply the same process to TypeScript, taking extreme care that we don’t introduce diverging behaviors from upstream TypeScript. When we come across performance improvements, we’ll attempt to contribute them back to the TypeScript Go codebase so everyone wins.

Finally, we recognize that there are some differences to the upstream version of TypeScript right now, like for example the order in which diagnostics are printed. We aim to reduce those differences to a minimum by the time we publish a stable release.

What’s next?

Cloudflare is already the home of many free and open source Rust tools that power the JavaScript ecosystem, such as Vite, Rolldown, Oxlint, and Oxfmt. With more than 10 million developers building on Cloudflare, we care a lot about making the underlying developer toolchain faster, more portable, and easier to run in more places. We are excited to experiment with deeper tsrs integrations into our stack, for example for type-aware lint rules in Oxlint.

Like with Vinext, our goal is to run tsrs as a well-maintained healthy open source project — without getting in the way of TypeScript itself. The Oxc team has already begun refactoring the codebase to make it faster, use less memory, and make it maintainable. We know the TypeScript team is taking this seriously – they are experimenting with memory and performance improvements for tsc. We are excited to collaborate with the TypeScript team and the JavaScript community to build the best and fastest implementations of TypeScript together.

The next Chair of the Board of Trustees, Blythe Masters

Post Syndicated from Philip Colligan, CBE original https://www.raspberrypi.org/blog/the-next-chair-of-the-board-of-trustees-blythe-masters/

I am delighted to share the news that Blythe Masters has been appointed as the next Chair of the Raspberry Pi Foundation’s Board of Trustees. Blythe brings a wealth of experience to our governance at a time when our mission to enable all young people to realise their full potential through the power of computing and AI has never felt more urgent.

Blythe Masters
Blythe Masters

Blythe is one of the most prominent figures in global financial services and fintech. A graduate and Senior Scholar of Trinity College, University of Cambridge, she spent nearly three decades at JPMorgan, rising to its Executive Committee and holding senior leadership roles including Chief Financial Officer of the Investment Bank and Head of Global Commodities. After leaving JPMorgan in 2014, Blythe served as CEO of Digital Asset and later became a Founding Partner at Motive Partners, the fintech-focused investment firm. Most recently, Blythe served as Group CEO of FNZ, the global wealth technology platform and Motive Partners portfolio company.

Blythe has extensive corporate governance experience, currently serving as the Chair of JPMorgan Securities plc and non-executive director on the board of SymphonyAI. She has previously served on numerous other boards including A.P. Moeller Maersk, Credit Suisse, Santander Consumer USA, Forge, and GCM Grosvenor.

Blythe also has significant experience in nonprofit governance, having served as the co-chair of the Global Fund for Women, vice chair of ID2020, chair of the NYC chapter of Susan G. Komen Breast Cancer Foundation, chair of the Hyperledger Foundation, and numerous other trustee roles.

Blythe takes over the Chair from Sir John Lazar who has led the Board of Trustees since 2020. Under Sir John’s leadership the Foundation has supported hundreds of thousands of educators and tens of millions of students all over the world to develop the skills, knowledge, and mindsets to shape their world through computing and AI.

Sir John Lazar
Sir John Lazar

We have achieved so much under his leadership and I have learned a huge amount from working with him. We are all profoundly grateful to Sir John for his contribution. 

Blythe will take up the role at the end of March 2027 and John will be staying on to manage the transition and handover. While it is hard to imagine a world where John isn’t our Chair, I am genuinely excited about the prospect of working with Blythe.

What is a Board of Trustees?

As a charity, the Foundation is governed by a Board of Trustees that is responsible for ensuring we use our resources effectively to advance our charitable goals. We are fortunate to have an exceptionally strong and diverse group of Trustees who bring significant experience and expertise from a wide range of backgrounds. Trustees generally serve two three-year terms. Trustees are volunteers who provide their time and expertise to the Foundation for no remuneration. 

You can see the full list of Trustees and Members on our website.

The post The next Chair of the Board of Trustees, Blythe Masters appeared first on Raspberry Pi Foundation.

Possible new Cellebrite iPhone Radio Zero-Day

Post Syndicated from Bruce Schneier original https://www.schneier.com/blog/archives/2026/10/possible-new-cellebrite-iphone-radio-zero-day.html

Justin.sh is reporting on a confidential Cellebrite document that has been leaked to him:

Cellebrite calls it Advanced Unlocks (AU from here on), not to be confused with the “advanced unlocking services” they’ve marketed for years. A press release from earlier this year confirms AU is a new product for 2026.

[…]

According to Cellebrite, AU:

  • is a “next-generation AFU vector that is more resilient to Apple’s OS changes”
  • works with Stolen Device Protection enabled, which tightens USB restrictions
  • is enabled by a dedicated appliance with a stated range (!) of about 8 meters.

AU = Advanced Unlocks, Cellebrite’s term. AFU = after first unlock.

Version 1.2.6

Post Syndicated from NTPsec Project Blog original https://blog.ntpsec.org/2026/10/20/version-1.2.6.html

The NTPsec Project is pleased to announce the tagging of version 1.2.6

Note: Python 2 and OpenSSL 1.1.0 support will be removed in the next release.

  • Shared key authentication now supports HMAC mode.
    It’s one of the options for NIST’s authenticated service.
    https://www.nist.gov/pml/time-and-frequency-division/time-services/nist-authenticated-ntp-service

  • A shared key ID equal to the maximum key number is now accepted in the configuration (NTPsec/ntpsec#896).

  • The Trimble TSIP reference clock driver no longer announces an imminent leap second weeks early whenever the receiver has a leap correction queued.

  • Fixed misaligned access to restriction list entries, which could crash ntpd on strict-alignment platforms.

  • ntpd now starts on systems whose OpenSSL providers don’t offer MD5, such as FIPS-only configurations. Keys whose algorithm OpenSSL can’t run are now skipped with a log message when the keys file is read, instead of failing on every packet (NTPsec/ntpsec#900).

Security Fixes:

  • Fixed an out-of-bounds read in NTS server extension parsing caused by an unchecked nonce length, which allowed a remote attacker holding an NTS cookie to crash ntpd (CVE-2026-102486).

  • Fixed a remotely triggerable exit in the NTS server when a request carried more NTS Cookie Placeholders than fit in the response (CVE-2026-102483).

  • Fixed an out-of-bounds write in the JJY reference clock driver when a Telephone JJY source sends more time replies than expected (CVE-2026-102484).

  • Fixed an out-of-bounds read in the Motorola Oncore reference clock driver on a PPS Control reply with an out-of-range mode byte (CVE-2026-102485).

NTS and NTS-KE Fixes:

  • The NTS-KE server no longer treats unrecognized non-critical records as critical, fixing interoperability with chrony (NTPsec/ntpsec#892).

  • The NTS-KE server now replies with an RFC 8915 Error record when a request is malformed or the server cannot derive session keys, rejects duplicate or missing Next Protocol and AEAD records, and passes the ntske-test suite.

  • The NTS server now rejects Unique Identifier extension fields shorter than the 32 octets RFC 8915 requires.

  • The NTS server now rejects NTS cookies shorter than the key ID and nonce before parsing them.

  • The NTS server now accepts requests with nonces longer than 16 octets, shorter nonces with enough padding, and encrypted extension fields, as RFC 8915 allows.

  • The NTS-KE client now rejects responses that lack an End of Message record.

  • The NTS client now bounds the AEEF nonce length against the bytes remaining in the packet.

  • Fixed misaligned reads and writes of NTS-KE records, which could crash ntpd on strict-alignment platforms.

Getting this release

You can clone the git repo
from https://gitlab.com/NTPsec/ntpsec.git
and you can download the release tarballs with sums and signatures
from https://ftp.ntpsec.org/pub/releases/

This release is signed with the GPG key id
E57235D22764129FA4F2F4D17F52608ED0E49D76

Cutting our inference bill by 68% by being obsessive about optimization

Post Syndicated from Ryan Skidmore original https://blog.cloudflare.com/obsessive-inference-optimization/

When we previously blogged about our AI code reviewer in April, an average review cost a palatable $1.19. By the end of August, that figure had shot up to about $2.46. We hadn't made any significant architectural changes: the coordinator was still handing work to the same set of specialist reviewers, and the same risk tiers decided how intensive of a review we gave.

Around mid-September we tasked our agents with working out where those tokens were going and cutting them — aggressively. With code quality at high effort, the average review now costs just $0.77, down 68% from the $2.43 it averaged over our two most expensive weeks before we started. Our main goal was to cut costs, but as part of this work we also managed to optimize the reviewer, so that the median review now takes just 1m 32s instead of the 4m 09s it took before.

About 40% of the savings came from changes and optimizations to the reviewer's code, and the rest from experimenting with which models we use and how much effort they put in.

How a review doubled in cost

The chart below shows the cost of an average review on each weekday since March. It holds the mix of review tiers fixed, so a day with more large reviews doesn't skew the data.

The cost per review steadily rose from $1.22 (March) → $1.44 (June) → $1.74 (July) and finally, to $2.32 (August). A small part of that is that more reviews landed in the most expensive tier (59% of reviews in March and then 65% in August). We believe there’s a simple answer for why: models are getting much better, and much more capable. Naturally, engineers are producing bigger, more complex changes which means more of them fall into our “full review” tier. We found that most of the cost increase actually came from model changes over those months, though.

At the start of August we moved every reviewer onto Anthropic models, which raised the cost per job from $1.38 to $2.03. We made this choice because we found that during our evals, Anthropic models performed better on this specific workload than other models.

Our internal standards reviewer, Codex, ended up on Claude Opus 4.7 due to a mix of performance and reliability. That took it from about $0.25 per review to $0.88 in August, which made it more expensive than the coordinator agent itself.

The cache hit rate also increased, going from 85.7% in April to 97% by September, while the number of tokens per review more than tripled, from 0.91 million to 2.99 million. A high hit rate on three times as many tokens still costs a lot more, even with the low cache read cost.

What else has changed since our last post?

One of the biggest changes is that the reviewer now runs on OpenCode v2, which is a ground-up rewrite from v1. Before switching all reviews over from v1 to v2, we ran every review in every canary repo on both v1 and v2 in a comparative shadow mode. The two agreed on the approval decision in 98% of the merge requests we tested, so we moved everyone over in one go in early October and removed the v1 code. Comparing two days with the same models, full-tier reviews on v2 finish about 13% faster. We’re also currently experimenting with other ways to run our internal AI reviewer, including solely on Durable Objects using pi-durable. We’re hopefully going to have more on this coming soon, so keep an eye out!

So, where were the tokens going?

Right before we started focusing on cost optimization, our AI review spend was split by: output tokens making up about 23%,  cache writes cost 43%, and cache reads cost 34%. This means that  most of the money was going on context the model had already seen or was about to see again.

That makes complete sense when you look into a single session. The code quality reviewer made 16.6 large language model (LLM) calls per review on average and over those calls it wrote 72k tokens to the cache and read back 1.08m, because each call sends the whole conversation as context. A session's cost grows with both the number of calls and the size of the context, and over the last few months we had slowly increased both.

It’s worth taking a few minutes to read about how Anthropic's prompt cache works. It works by caching parts of the prompt that have already been computed by the large language model (LLM). These are known as prefixes, because they only work on the messages at the start of the conversation, not mid way through or the end. This means that a future request can reuse an earlier prefix, up to the part of the conversation that changes from what’s been cached. In our case, the harness tools, system prompt and messages at the start of our AI reviewer sessions rarely change, so they’re a great candidate for prefix caching. A prefix is only stored where a cache breakpoint ends it. Writing to the cache costs 1.25 times the normal input price and reading costs 0.1 times, and an entry expires after five minutes unless something reads it.

That means we had two things to work on: make the first request of each session read from the cache instead of writing to it, and make each session use fewer calls.

Sharing a cached prefix between every repository

Beginning September 14, the reviewer recorded the token usage of each reviewer's first LLM call, plus a hash of the first system block exactly as it was sent to the provider.

The data showed that the first request of a session found a cached prefix only 14% to 26% of the time. Every session starts with the same tool definitions and the same agent prompt, between 11k and 21k tokens that are identical in every repository we review, so almost all of them should have been cache hits.

The problem ended up being in how OpenCode v1 constructed the system prompt: It built one block containing our agent prompt, followed by an environment section with the working directory and the date, and placed the only cache breakpoint at the end of that block. The shared part was never stored on its own, so a review in one repository could never reuse what a reviewer ran in another repository had written.

On September 16, we added a marker to the end of every agent prompt and a plugin hook that split the block in two at that marker. The first half now ended on bytes that every job shares, and got its own breakpoint. To keep it that way we had to remove anything repository-specific from in front of it, so the list of available skills is disabled and tool descriptions can't change between jobs.

The same day we also moved our internal standards (Codex) reviewer's reference index (a table of internal standards, a skill file and a list of reference files) into its prompt. Until then every session had spent its first three turns reading those files with tool calls. Its LLM calls per run decreased from 15.9 to 9.6, and its cost per run dropped from $1.12 to $0.72.

Together these took the cost per review from $2.47 down to $2.02, and the drop was noticeable as soon as we kicked off the release.

Fewer calls, fewer dollars

The next set of changes went out on September 21 and 23. None of them were particularly impressive by themselves, but together they took about $0.20 off every review.

Change

What was happening

Effect of change

Removing tools that reviewers couldn't use

Sub-reviewers could see the tool that posts the final review comment. In 57% to 76% of sessions they tried to call it, were rejected by a check on the server, and spent another call recovering.

One wasted call gone, and about 2.9k fewer tokens of tool definitions in every sub-reviewer request

Reading files in parallel

In 64% of the code quality reviewer's turns, the model made exactly one tool call, usually to read a single file.

Reviewers read the shared context and all of their patches in their first response, up to 150 KB

Skipping reviewers on re-reviews

About two-thirds of our jobs are a second or later review of the same merge request, and often three of the reviewers have nothing new to look at.

On full-tier re-reviews, AGENTS.md reviews are skipped 56% of the time, performance reviews skipped 23% and documentation reviews skipped 13%.

Stopping after the review is posted

OpenCode passed the result back to the model for one more turn, which read the entire conversation again to write a summary nobody saw.

About $0.07 saved per job

Treating a slow reviewer differently from a broken provider

A reviewer that hit its time limit was treated like a provider failure and started again with the same time limit.

Together with longer time limits and lower effort, security reviewer timeouts went from 1.8% of runs to almost none

Canceling canceled jobs

GitLab's Kubernetes executor doesn't send a signal to a job's script when the job is cancelled. In a sample of 446 cancelled jobs, 358 kept running until the review was finished.

Jobs check their own status every 15 seconds and stop if cancelled

The most involved change was sharing one prefix between three reviewers. The code quality, security, and performance reviewers now send identical first requests with the same tools, a shared rules file, then the merge request with every patch included. Each reviewer's own instructions follow after that, and we make sure that one of them writes the cache and the other two read from it.

A cache entry can't be read until the response that wrote it has started streaming, and the three reviewers start at the same time. So the second and third wait for the first one's response to begin, for up to 20 seconds, before sending their own first request. It slows them down slightly and saves about nine cents per reviewer.

Changing models and effort

The next chart shows the same line from the start of September, with each change marked.

When we split the period at every release and every configuration change, the code changes turn out to be the smaller part of the saving.

Code changes account for $0.65 of the $1.67, and model and effort changes for $1.06. Each step compares the weekday hours before a change with the hours after it, so this isn't a statistically sound controlled experiment.

The coordinator had been running three model and effort combinations since August. On the same model, full-tier jobs on medium effort finished 20% sooner, so we dropped the other two. In a later randomized split, Opus 5.5 at medium showed no measurable change in review outcomes or critical findings compared with Opus 5, so we switched. Opus 5.5 at high effort cost more than Opus 5.5 at medium while not producing a meaningful increase in findings.

Opus 5.5 is cheaper per token than Opus 5, but price is only responsible for about $0.20 of the drop. The rest comes from sending and generating fewer tokens. Since the start of September cache reads per review are down 82%, cache writes down 54%, and output down 67%.

The most recent change was a new model. On October 3, we split every Sonnet reviewer 50/50 between Sonnet 5 and Sonnet 5.5. After two and a half days, Sonnet 5.5 was 62% cheaper per run for code quality, 58% for performance and 47% for security. The two models cost the same per token, so all of that comes from using fewer tokens. On full-tier reviews, the 5.5 reviewers posted about as many critical and warning findings as the Sonnet 5 ones, so on October 5 we moved all of them to 5.5.

On Sonnet 5.5 at medium effort, the code quality reviewer makes 1.7 LLM calls per run instead of 6.2, and more than half of its runs finish in a single call, which means they don't open any other file in the repository. At high effort it makes 3.4 calls per run. We were concerned that this made reviews shallower, which we cover in the quality section below.

To see whether more effort brings findings back on the larger tiers, the code quality reviewer has been split 50/50 between medium and high effort on 5.5 since October 5. After one day, high effort costs 61% more per run and posts 58% more critical and warning findings. That's about two cents per review, and the quality section below shows those extra findings are worth having, so we're moving code quality to high effort. The cost figures in this post assume that.

Latency

We weren't aiming to make reviews faster, but fewer calls also means less waiting, which means faster reviews and happier engineers.

The slowest reviews improved the most. In the four weeks before September 14, 37.9% of reviews took longer than five minutes and now just 0.7% do. The 99th percentile today is faster than three quarters of reviews were in April. Every tier got faster along the way with the median full-tier review going from 5m 16s to 1m 54s, lite from 2m 58s to 1m 14s, and trivial from 77 seconds to 30.

By August, the median review was 14% slower than what we reported in April and the 99th percentile 48% slower, so a good part of this work just got us back to where we had been.

Review quality

A cheaper review isn't worth much if it also finds fewer problems, and the first chart here looks like that's what happened.

With code quality on Sonnet 5.5 at high effort, it posts 40% fewer critical and warning findings than it did in late August. Security and performance, which stay at medium effort, post 56% and 71% fewer. A fall in severe findings doesn't tell you on its own whether real problems are being missed or noise is being cut, so we looked at it from two directions.

First, we checked whether authors act on what the reviewer flags. For samples of critical and warning findings, we compared the commit that was reviewed with the author's next push, and counted a finding as acted on if the lines it pointed at had changed. Lines 30 to 40 away from each finding changed about 15% of the time in every period, which gives a baseline for edits that happen by coincidence.

Before the changes, authors acted on 34% of the code quality reviewer's serious findings. Now it's 59%. The reviewer flags fewer things, but those it flags are much more likely to lead to a change, so the number of findings that led to a change per 1,000 reviews is about the same. We now saw 132 against 145 before, which is within the margin of error. Across all four reviewers, serious findings that led to a change went from 229 to 321 per 1,000 reviews.

Second, we had two models from different providers judge a blinded sample of 657 findings from the three Sonnet reviewers, with the diff each one referred to and without knowing which period it came from. Disagreements went to a third model. Each finding was labelled important, minor, duplicate, wrong, or unverifiable, and its severity was marked as fair, too high, or too low.

Most of what disappeared was minor findings, plus some duplicates and findings the judges couldn't verify from the diff. Important findings per review went from 0.28 before to 0.30 now, and the intervals overlap. The bigger change was in severity. Before, the judges rated 0.46 critical or warning findings per review as more severe than they deserved. Now that's 0.14, a 70% drop and the clearest result in the research. Much of the drop in critical findings is the reviewer no longer calling minor things critical.

So the answer depends on the reviewer. For code quality at high effort, what disappeared was mostly noise and inflated severity, and it still finds about as many real problems as before. Medium effort did lose real findings. In the randomized split, code quality at medium led to roughly a quarter as many acted-on findings as at high, which is why we're moving it to high. Performance also lost real findings: the judges found about 64% fewer important performance issues per review, which in practice is about one fewer important finding every 24 full-tier reviews. Security fell by about a quarter, though that isn't statistically significant. Both are still at medium effort, and testing them at high is next.

Neither method is perfect. An author changing the flagged lines shows they did something, not that the finding was right. The judges are models too, and there are only 35 to 66 findings in each group. The "now" window is also only a day long. Even so, the two methods agree with each other, and neither suggests that code quality is finding fewer real problems.

Reliability has held up as well. Reviews that end without a verdict went from 0.79% to 0.27%, and security reviewer retries from 3.5% to 0.04%.

Where this leaves us

An average review now costs $0.77 instead of $2.43, and the median one finishes in 1m 32s instead of 4m 9s. The biggest single saving came from checking what actually reached the provider on each session’s first request, and finding a way to order those messages in a way that was as consistent as possible across commits, merge requests and repositories. The remaining cost savings came from relentlessly experimenting with different models and effort mixes, while making sure we put any preconceived bias for particular models aside.

Lower cost reviews didn’t automatically mean worse quality, but it didn’t automatically mean fine either. Code quality at high effort finds about as many real problems as before, with much less noise and far fewer inflated severities. Performance lost real findings at medium effort, and security may have, too, so testing both at high effort is next. If you run agents at any kind of volume, the two things we’d check first are whether each session’s first request actually reads from the cache, and whether your reviewers still find real problems at the effort level you’re paying for.

If you’re at Cloudflare Connect in San Francisco, I’m talking about how we built the reviewer instead of buying one in my session, It’s time to build, not buy, on Tuesday, October 20 at 12:30 PM PDT. I’ll also be in the Speaker Connection Lounge from 1:10 PM if you want to ask about any of the numbers in this post.

The collective thoughts of the interwebz